03周总结

名称空间和作用域

1.什么是名称空间
实际上就是储存变量名的地方。
2.代码演示。name = 'moon'
当我们给name赋予一个数据值，其实就是我们把name这个名字放入了一个区域内，记录了name 和数据的地址。
3.三大名称空间
  1.内置名称空间  - 储存所有内置函数和方法名的地方，如：print len input等
  2.全局名称空间  - 当前py文件中的变量名  如 name = 10 
  3.局部名称空间  - 函数或类子代码里面的变量名 def outer():
    																				name = 'moon'
4.名称空间存活周期和作用域
  1.内置名称空间  - python解释器打开则创建关闭则自动销毁。作用域所有的python文件
  2.全局名称空间  - 当前py文件运行则全局名称空间生效，关闭文件则销毁，作用域当前py文件部可以跨文件使用
  3.局部名称空间  - 当前函数体代码被执行，只在当前函数题代码内有效
 
5.名称空间调用顺序
  在全局空间内  优先 全局名称空间 ---> 内置名称空间 
  在局部空间内  优先 局部名称空间 ---> 全局名称空间 ---> 内置名称空间

global与nonlocal

global(变量名)
使用global后可以在局部空间内更改全局空间变量名
nonlocal(变量名)
使用nonlocal可以更改函数体代码外层局部空间变量

函数名的多种用法

def 函数名():
  pass
1.函数名可以当作实参传给函数   函数名(函数名)
2.函数名可以作为返回值被输出。
def 函数名():
  name = 1
  return 函数名
3.函数名可以放入容器类型中，例如字典 可以作为键的值
func_dict = {
    '1': 函数名,
    '2': 函数名,
    '3': 函数名,
    '4': 函数名,
}
func_dict.get('1')() 就可以运行了

闭包函数

1.闭包函数是什么？
定义在函数体内部的函数
内部函数用到了外包函数的变量名
2.代码展示
def outer():  # 外层函数
    x = 100
    def inner():  # 内层函数
        print(x)  # 内层函数用到了外层函数的变量
        
 3.闭包函数传参优势
  def name1(a,b):
    print(a,b)    # 调用函数中我们需要每次都给这个函数体传参才可以
    
 def outer(a,b):
   def name1():
      print(a,b)
   return name1   
变量名 = outer(a,b)  # 第一次使用需要传参
变量名()   # 参数不变的时候就不需要再次传参了 ，如需要改变则再次改变赋值即可
变量名 = outer(c,d)

无参装饰器

1，什么是装饰器？
当我们需要对一个函数增加额外功能，并且不能改变原来的函数题代码 以及 原来的调用方式。

2.根据闭包函数理论进化为装饰器
def func():
  print('执行函数')

def outer(func):
    def inner(*args,**kwargs):
        # 函数代码执行前增加的功能
        res = func(*args,kwargs)  # func = 需要被装饰的函数名
        # 函数代码执行后增加的功能
        return res
    return inner()
func = outer(func)
func()
  
3. 装饰器语法糖
@outer    # 相当于 func = outer(func)
def func():
  print('执行函数')
func()

4.多重语法糖 - 一个函数作用域多个装饰器
@outer3
@outer2
@outer1   
def func():
  print('执行函数')
func()
多重语法糖执行顺序，语法糖从下到上执行 先执行 @outer1，得到返回值再执行@outer2，@outer3 ，最后得到的返回值 再次进行生效
  

有参装饰器

1.什么是有参装饰器？
就是当我们的装饰器里面的函数体代码 需要接收到新的外界的传参
代码展示：
def outer_plus(a,b):
    def outer(func):
        def inner(*args,**kwargs):
            print(a,b)
            res = func(*args,**kwargs)
            return res
        return inner
    return outer
这样我们就可以在最外层传参了

@outer_plus(1,2)
def func():
  pass
#这样我们就可以直接在语法糖后传入装饰器内部需要的参数

装饰器模版

1，无参装饰器
def outer(func):
  def inner(*args,**kwargs)
  	res = func(*args,**kwargs)
    return res
  return inner

@outer
def func():
  pass
func()
  

2.有参装饰器
def outer_pule(a,b):
  def outer(func):
    def inner(*args,**kwargs)
    	res = func(*args,**kwargs)
      return res
    return inner
  return outer

@outer_pule(a,b)
def func():
  pass
func()

递归函数

1.什么是递归函数
递归函数就是函数体代码中又调用了其他函数，并且拥有一个明确的结束条件，这就是递归函数。
代码展示： def index(a):
  					if a == 1:
       				return 1
      			return index(a-1)
      		res = index(5)
          print(res)  # 16
          

二分法

1.什么是二分法
就是通过不断的一分而二 判断查询数据所在位置 ，然后再次一分为二的过程。
!!!必须满足列表为有序时才可以使用，从大到小或者从小到大

代码展示：
l1 = [1.2.3.4.5.6.22.33,44,123,234,355,6664,34534,234234,23423423]
find_num = 123 #要查询的数据可以随时改变
while 1:
  mid_num = len(l1) //2      #查询列表中间数索引位置
  if l1[mid_num] > find_num:   
    l1 = l1[:mid_num]    #如果中间数比查询数大 则保留左边
  elif l1[mid_num] < find_num:
    l1 = l1 [mid_num+1:] #如果中间数比查询数小 则保留右边
  elif li[mid_num] == fund_num:
    	break
  
  #现在举例列表是升序，当然列表是降序也可以

表达式和生成式

在python中，分支结构和for循环结构十分的常用，它们也有一些简化的版本。适用于简单的分支结构和for循环结构

正常分支结构：
name = input('请输入用户名')
if name =='moon':
  print('NB')
else:
  print('SB')
三元表达式:
res = 'NB' if name =='moon' else 'SB' 
一元：数据值  if   二元：判断条件  三元： else 数据值

列表表达式：
l1 = []
for num in [1, 2, 3, 4, 5]:
    l1.append(num + 1)
print(l1)  # [2, 3, 4, 5, 6]
简化版：
l1 = [num + 1 for num in [1, 2, 3, 4, 5]]
[表达式 for 变量名 in 可被遍历的对象]

匿名函数

匿名函数关键词：
lambda 
代码格式：
lambda 行参:返回值
匿名函数的应用场景很小，因为代码不能被函数名找到，所以即用即丢。
它常常搭配一些需要传入函数实参的内置函数使用。

内置函数汇总

map() 映射
res = map(lambda x:x+1, l1)

max()/min() 最大最小值
l1 = [11, 22, 33, 44]
res = max(l1)
res = min(l1)

reduce()
res = reduce(lambda a, b: a * b, l1)  # 计算 ((((1+2)+3)+4)+5)

zip() 拉链
#缝合多个列表的数据，将对应位置的元素组成一个小元组放到列表中。
l1 = [1, 2, 3, 4, 5]
l2 = ['a', 'b', 'c', 'd']
l3 = [11, 22, 33, 44, 55, 66]
res = zip(l1, l2, l3)
print(res)  # <zip object at 0x00000222BA9E7280>  迭代器对象
print(list(res))  # [(1, 'a', 11), (2, 'b', 22), (3, 'c', 33), (4, 'd', 44)]

filter -过滤
1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = filter(lambda x: x > 40, l1)  #匿名函数x返回值x>40 遍历l1
print(list(res))  # [44, 55, 66, 77, 88]

sorted 升序
l1 = [13, 12, 533, 64, 766, 322, 131, 22]
res = sorted(l1)
print(res)  # [12, 13, 22, 64, 131, 322, 533, 766]

asb - 代表数学中的绝对值

all() - 全是  用来元素类型是否都统一

any() - 全或  类似于：0 or 1 or 2 or 3 or 4

bytes - 用于类型转换
s1 = '最近缺觉'
print(bytes(s1, encoding='utf8'))
print(s1.encode('utf8'))

callable  - 查询是否是函数或者类
name = 'leethon'
callable(name) # False
def  index():
    pass
callable(index)  # True
# 无论是函数还是变量，都是名字形式的，就可以用此函数来判断。


chr\ord —— ASCII码值的数字字母对应转换
65-90 是A-Z，97-122 是a-z。

divmod - 整除和取余
divmod(100, 3)  # (33, 1)   代码格式 100 整数3  得到除数和余数

enumerate  - 枚举
通过遍历迭代器对象，得到一个序号与值的二元组迭代器。 
list(enumerate([1, 2, 3, 4]))  # [(0, 1), (1, 2), (2, 3), (3, 4)] 默认从0开始
# start参数，改变序号的开头
# 例子：ASCII表大写字母打印
l1 = [chr(i) for i in range(65, 91)]
print(list(enumerate(l1, start=65)))
[(65, 'A'), (66, 'B'), (67, 'C'), ……, (90, 'Z')]


hash - 哈希加密
print(hash('moon'))  # -2441274338754145093
print(hash('123'))  # -6488149301417385444

isinstance - 判断数据类型 
isinstance(123,int) # True
isinstance([123],int)   # False
#得到的结果是布尔值，待判断数据 加 类型

pow - 幂指数
用于计算数字次方 
print(pow(3,3))  #3*3*3 = 27


round - 通常用于 四舍五入取整
print(round(99.499))  #99
print(round(99.5))  #100

sum - 求和 
l1 = [1,2.3,2,23,1,23,1,23]
print(sum(l1)) # 76.3

可迭代对象

可迭代对象有：
str list dict tuple set 文件对象
可迭代对象特点：
都有对象内置__iter__方法
l1 = [1,2.3,2,23,1,23,1,23]
l2 = 'sdad'
l3 = {'a':'n'}
l1.__iter__()
l2.__iter__()
l3.__iter__()

可迭代的含义
迭代，依赖上一次的结果，来更新下一次。

l1 = [1,2.3,2,23,1,23,1,23]
res = l1.__iter__()
print(res.__next__())
print(res.__next__())
l2 = {'name':'moon','123':'321','222':'333'}
res = l2.__iter__()
print(res.__next__())
print(res.__next__())

# 先使用.__iter__() 把数据变为迭代器对象
#然后在使用.__next__() 进行迭代

for 循环的本

for 变量名 in 可迭代对象\迭代器对象:
	循环体代码
  - 对in后面的对象执行`__iter__`方法得到迭代器对象
  - while循环调用`__next__`取值，赋值给变量名

异常捕捉

• 语法错误

  语法错误是明眼人一眼能够看出来的，语法这是程序员的基础技能，不容有错

• 逻辑错误

  一眼可能看不出来，需要经验积累能感知到可能有的逻辑错误。

  比方说，上文变量经过分支可能被赋值为一个字符串类型的数据，但是在后面执行了一个列表的内置方法报错了。

  • 异常位置

  • 异常类型

  • 异常详情

解释器会只能的提示你 异常位置 在 哪 line 行 ，然后告诉你错误类型，还有该错误的解释

自我检测一卷 代码实战部分：

# 可循环根据⽤用户输⼊入的姓名不不同输出不不同的身份信息
# # 添加程序结束功能(如⽤用户输⼊入字⺟母q直接结束识别程序) jason: 扫地僧
# tony: 洗碗⼯工
# kevin: 服务员
# jack: 配菜员
# 其他：未识别
name_dict = {'tony':'洗碗工','kevin':'服务员','jack':'配菜员'}
while True:
    name = input('请输入查询的姓名：')
    # 输入姓名后判断是否在用户字典中
    if name in name_dict:
        print(f'{name}的身份为{name_dict[name]}')
    elif name == 'q':
        print('退出程序')
        break
    else:
        print('未识别')
        
        
  # 利利⽤用for循环及range⽅方法⾃自动⽣生成链家⼆二⼿手房多⻚页数据⽹网址(⼗十条以 上即可)
# 初始⽹网址:https://sh.lianjia.com/ershoufang/

f = 'https://sh.lianjia.com/ershoufang/pg'
#
for i in range(1,12):
    print(f'{f}{i}')
    
  
 # ⽤用户名与密码来源于字符串串source_data = 'jason|123'
# 想办法从中拆分出⽤用户名和密码⽤用于后续账户信息⽐比对 普通要求:
# 1.验证失败情况下可⼀一直循环验证 成功则直接退出 拔⾼高练习:
# 1.只允许三次失败机会
# 2.登录成功后进⼊入内层循环，⽤用户输⼊入任何指令利利⽤用格式化
# 打印正在执⾏行行该⽤用户指令即可，直到⽤用户输⼊入字⺟母q退出内层循环
source_data = 'jason|123'
count = 0
while True:
    if count == 3:
        print('登录失败3次了')
        break
    name = input('请输入用户名').strip()
    password = input('请输入密码').strip()
    r_name,r_pas = source_data.split('|')
    if name == r_name and password ==r_pas:
        print('登录成功')
        while True:
            cmd = input('请输入您的指令')
            print(f'您已成功执行{cmd}指令')
            if cmd == 'q':
                print('退出程序')
                break
    else:
        print('账户或密码错误')
        count += 1 
    

原文地址：http://www.cnblogs.com/moongodnnn/p/16796589.html