周末学习笔记——day01（函数，函数对象，嵌套调用，名称空间，作用域，闭包，装饰器）

一，复习

字符编码

　　　　文件头：py2—ASCII，py3—UTF-8

　　　　三种字符串：u' '   b ' '  r ' '

　　　　u' ' .endcode(' utf-8 ')

　　　　b' '.deconde(' utf-8 ')

　　　　str(b' ' , encode=' utf-8 ' )

　　　　bytes( u' ' , encode=' utf-8 ')

文件操作：

　　　　三步骤：
　　　　　　　　1，打开文件
　　　　　　　　2，操作文件（读写）
　　　　　　　　3，关闭
　　　　简写：
　　　　　　　　with open => 可以自动关闭文件流
　　　　操作模式：
　　　　　　　　主 ：r  w  a   x
　　　　　　　　从：t  b   +
　　　　seek：游标（偏移量，游标操作位置）与b模式结合
函数基础：

　　　　函数的定义：def  函数名（）：函数体
　　　　函数调用：函数名（）
　　　　函数的返回值：省略  空return   return一个值  return多个值  =》本质返回一个装有多个值得元组

二，今日内容：

　　　　1，函数的参数：实参与形参
　　　　2，函数对象：函数名
　　　　3，名称空间与作用域：LEGB
　　　　4，闭包：函数的嵌套定义
　　　　5，装饰器：闭包的一种应用场景
　　　　6，迭代器对象：迭代器，生成器，for迭代
　　　　7，匿名函数
　　　　8，内置函数
　　　　9，三元表达式，列表，字典生成式
　　　　10，模块

三，如何定义函数：

　　　　1，功能的单一化
　　　　2，函数内部需要外部的资源：通过函数的参数来实现
　　　　3，函数执行后的结果需要告诉外界：通过返回值告诉给外界

四，函数的参数：

形参与实参：
　　　　形参：在函数定义时（）里出现的参数
　　　　　　——形参本身没有实际值（意义），在函数调用时，传入什么实参，形参就装有什么值
　　　　实参：在函数调用时（）里出现的参数
　　　　　　——实参有实际值（意义）
　　　　重点：函数调用传参：将实参的值赋值给形参 |  形参要获取外界的值只能通过实参进行获取

　　　　def  fn（a，b）：　　  #a , b  ：形参
　　　　　　pass
　　　　a = 10
　　　　fn（a , 20）   　　　　#a , 20  实参

　两种实参：
　　　　1，位置实参：

　　　　　　a，传参两种方式：实参名|实参具体值

　　　　　　b，必须按位置对形参进行传值

　　　　2，关键字实参：

　　　　　　a，传参两种方式：形参名=实参名 | 形参名=实参值

　　　　　　b，可以指名道姓对形参进行传值，所以可以不用按位置进行传参

　　　　'''

　　　　　　def func(a,b,c):

　　　　　　　　 print(a,b,c)

　　　　　　#func(10，b=20,200)  #报错：SyntaxError: positional argument follows keyword argument

　　　　'''

　　　　#重点：两种实参在一起进行传参时：必须位置在前，关键字在后

　两大形参分类：

　　　　形参种类：

　　　　　　1，位置形参：

　　　　　　　　——普通位置形参

　　　　　　　　——默认值形参

　　　　　　　　——可变长位置形参

　　　　　　2，关键字形参：

　　　　　　　　——有默认值关键字形参

　　　　　　　　——无默认值关键字形参

　　　　　　　　——可变长关键字

　　　　'''

　　　　　　def fn(a,b,*,x,y):　　#位置形参：a,b  关键字形参：x，y

　　　　　　　　pass

　　　　'''

　　　　重点：

　　　　　　1，*为分水岭

　　　　　　2，位置实参只能给位置形参进行传值

　　　　　　3，关键字实参可以给位置形参与关键字形参进行传值

　　　　

　两个带默认值的形参：

　　　　'''

　　　　　　def fn2(a=10,*,x=20):

　　　　　　　　print(a，x)

　　　　　　fn2(100，x=200)

　　　　'''

　　　　总结：

　　　　　　1，有默认值的参数可以不用传值

　　　　　　2，*前有默认值的叫默认值参数，属于位置形参，可以被位置及关键字实参进行传值

　　　　　　3，*后有默认值的叫有默认值的关键字形参，属于关键字形参，只能被关键字实参进行传值

　　　　　　4，如果省略*,有默认值的形参都是默认值参数

　不带默认值与带默认值形参结合使用:　　

def fn3(a, b=10, *, x, y=20, z):
print(a, b, x, y, z)
fn3(100, x=200, z=300)
# 总结：
# 1.没有默认值的必须传参，有默认值的可以传也可以不传
# 2.位置有值的必须出现在无值之后，关键字顺序不做要求

　

　可变长位置形参与可变长关键字形参:

def fn4(a, b=10, *args, x, **kwargs):
    print(a, b, x)
    print(args)
    print(kwargs)
fn4(10, 20, 30, x=100, y=200, z=300)

　　总结：
   1.可变长是用来接收未接收完的值(接收0到n个)：
　　　　 -- *args用来接收所有没有接收完的位置(只能接收位置实参)
　　　　 -- **kwargs用来接收所有没有接收完的关键字(只能接收关键字实参)
　　2.*args必须出现在所以位置参数之后，**kwargs必须出现在所以参数之后

# 常见应用场景
　　假设第一个位置永远是参数name

　　def func4(*args, **kwargs):
  　　  name = args[0]  # 将name抽出来
​
　　def func44(name, *args, **kwargs):
   　　 # name 可以直接接收，省了抽出来的过程
  　　  pass

　　总结：

1.位置实参只能给位置形参传值
2.关键字实参可以给位置及关键字形参传值
3.有默认值的可以不用传参
4.可变长位置形参只能接受位置实参，接受位置形参没有接收完的位置实参，存放到元组中
5.可变长关键字形参只能接受关键字实参，接受关键字形参没有接收完的关键字实参，存放到字典中
6.*args必须出现在所有位置形参之后，**kwargs必须在所有形参之后

　可变长整体传参：打散传值

　　　　　　'''

def fn(*args, **kwargs):
print(args, kwargs)

fn([1, 2, 3], {'a':1 , 'b': 2}) # =>接收到的 ([1, 2, 3], {'a':1 , 'b': 2}) {}
fn(*[1, 2, 3], **{'a':1 , 'b': 2}) # =>接收到的 (1, 2, 3) {'a':1 , 'b': 2}

# 注：字符串也可以作为单列集合进行打散传递
fn(*'abc') # => ('a', 'b', 'c') {}

　　　　　　'''

五，函数对象：

#函数名就是存放了函数的内存地址，存放了内存地址的变量都是对象，即 函数名 就是 函数对象

#函数对象的应用场景
　　1 可以直接被引用
　　2 可以当作函数参数传递
　　3 可以作为函数的返回值
　　4 可以作为容器类型的元素

'''
　　#功能体：
　　　def add(n1,n2):
　　　　　　return n1 + n2

　　　def low(n1,n2):
　　　　　　return n1 - n2

　　　def jump(n1,n2):
　　　　　　return n1 * n2

　　#完成功能：
　　　def computed(n1,n2,fn):　　#fn = add|low|jump
　　　　　　res = fn(n1,n2)　　　 #调用具体的功能
　　　　　　return res

　　#功能对应关系：
　　　method_map = {　　　　　　　#指令与函数对象的对应关系
　　　　　　'1':add,
　　　　　　'2':low,
　　　　　　'3':jump
　　　　}
　　
　　#获取功能：
　　　def get_method(cmd)：
　　　　　　if cmd in method_map:
　　　　　　　　return method_map[cmd]　　#返回 add|low|jump
　　　　　　return add　　　　　　　　　　　#当指令错误，add作为默认功能
　　　while True:
　　　　cmd = input('cmd')
　　　　res = get_method(cmd)(10,20)　　#根据指令获取功能并调用得到结果
　　　　print(res)
'''

六：函数的嵌套调用

# 函数的嵌套调用：在一个函数内部调用另一个函数
# 求两个数最大值
'''
　　def max_tow(n1,n2):
　　　　if n1 > n2:
　　　　　　return n1
　　　　return n2

　　#求三个数的最大值
　　def max_three(n1,n2,n3):
　　　　max = max_tow(n1,n2)
　　　　return max_tow(max,n3)

　　#求四个数的最大值
　　def max_four(n1,n2,n3,n4)
　　　　max = max_three(n1,n2,n3)
　　　　return max_tow(max,n4)
　　print(max_four(20，90，30，10))
'''

七：名称空间：

# 名称空间：存放名字与内存空间地址对应关系的容器
# 作用：解决由于名字有限，导致名字重复发送冲突的问题 - 内置全局局部可以同时使用一个名字存放不同地址

# 三种名称空间
# Built-in：内置名称空间；系统级，一个；随解释器执行而产生，解释器停止而销毁
# Global：全局名称空间；文件级，多个；随所属文件加载而产生，文件运行完毕而销毁
# Local：局部名称空间；函数级，多个；随所属函数执行而产生，函数执行完毕而销毁

# 加载顺序：Built-in > Global > Loca
# -- 采用堆栈存储数据的方式(压栈)，导致内置最后被访问

八，函数的嵌套定义：

# 函数的嵌套定义：在函数内部定义函数
# 诞生的理由：一个函数想使用另一个函数内部的变量，可以定义在其内部

'''
　　def func():
　　　　a = 10
　　　　def fn():
　　　　　　print(a)
　　　　return fn

　　new_fn = func()
　　new_fn()
'''

#两个与函数有关的关键字：global nonlocal

'''
　　#global :统一局部与全局的变量名
　　num = 10
　　def outer():
　　　　#global num
　　　　#num = 100
　　　　def inner():
　　　　　　global num
　　　　　　num = 1000

　　#nonlcal:统一局部与嵌套局部的变量名
　　def outer():
　　　　num = 100
　　　　def inner():
　　　　　　nonlcal num
　　　　　　num = 1000
'''

九，作用域：

# 作用域：名字起作用的范围
# 作用：解决同名字可以共存问题 - 不同作用域相同名字的值都能在其作用域范围下进行使用
'''
四种作用域: LEGB
Built-in：内置作用域 - 所有文件所有地方都可以被访问
Global：全局作用域 - 在当前文件的所有位置
Enclosing：嵌套作用域 - 自身内部与内部的子函数
Local：局部作用域 - 只有自身内部
'''
# 加载顺序：Built-in > Global > Enclosing > Local
# 访问(查找)顺序：报错 < Built-in < Global < Enclosing < Local
# 作用范围：Built-in > Global > Enclosing > Local

　十，闭包

# 闭包：定义在函数内部的函数，这个内部的函数就是闭包

#应用场景：

　　1，可以去使用其他函数的内部变量，且还可以保证调用位置不变（闭包的函数对象作为那个函数的返回值）
　　'''
　　　　def outer():
　　　　　　count = 3000
　　　　　　def fn():
　　　　　　　　print(count)   #能使用outer内部的变量count
　　　　　　return fn

　　　　#还是在外界调用
　　　　outer()()   #outer()()=>fn()=>调用fn
　　'''

　　2，延迟执行（外层函数可以为内部函数传递参数）
　　'''
　　　　import requests
　　　　def outer(url):
　　　　　　def show_html():
　　　　　　　　response = requests.get(url)
　　　　　　　　print(response.text)
　　　　　　return show_html

　　　　#制作 爬百度与新浪的 函数对象
　　　　show_baidu = outer('https://www.baidu.com')
　　　　show_sina = outer('https://www.sina.com.cn')

　　　　#延迟的需求来了，需要爬百度，就用百度函数对象，需要爬新浪，就用新浪函数对象
　　　　show_baidu()
　　　　show_sina()
　　　　show_baidu()

　　'''

十一，装饰器

# 装饰器：装饰器就是闭包的一个应用场景
#       -- 外层函数与内层函数形成的闭包结构的一种综合使用

# 重点：开放封闭原则
# 开放：拓展功能的点是开放的 - 可以为之前的函数添加新功能
# 封闭：1.不能改变原函数的源代码  2.还有通过原函数的函数对象来调用函数

'''
　　def huaping():
　　　　print('插花功能')

　　temp = huaping

　　def my_huaping():
　　　　temp()
　　　　print('观赏功能')

　　huaping = my_huaping

　　huaping()
'''　　
#------------------------------------------------------
'''
　　def huaping():
　　　　print('插花功能')

　　def outer(temp):　　　　　　　#temp = huaping
　　　　def my_huaping():
　　　　　　temp()
　　　　　　print('观赏功能')
　　　　return my_huaping
　　huaping = outer(huaping)   #huaping = my_huaping

　　huaping()
'''
#------------------------------------------------------
'''
　　def outer(temp):　　　　#temp  = huaping
　　　　def my_huaping():
　　　　　　temp()
　　　　　　print('观赏功能')
　　　　return my_huaping
　　
　　@outer 　　#huaping = outer(huaping)
　　def huaping():
　　　　 print('插花功能')

　　huaping()
'''
#-----------------------------------------------------
#被装饰的函数可能有参有返回：装饰器模板，可以满足所有参数，且能装饰原函数返回值
'''
def outer(func):　　#temp = huaping
　　　def inner(*args , **kwargs):
　　　　　　pass
　　　　　　res = func(*args,**kwargs)
　　　　　　pass
　　　　　　return res
　　　return inner

@outer 
def any_method():
　　　pass
'''

十二：装饰器案例

#为登录功能添加账号检验功能：必须是3个及以上英文字母组成
'''
　　def check_user(func):
　　　　def inner(user,pwd):
　　　　　　if not(user.isalpha() and len(user) >= 3)：
　　　　　　　　return '账号不合法'
　　　　　　res = func(user，pwd)
　　　　　　return res
　　　　return inner
'''

#为登录功能添加密码检验功能：必须是3个及以上英文字母或数字组成
'''
　　def check_pwd(func):
　　　　def inner(*args,**kwargs):
　　　　　　pwd = args[1]
　　　　　　if not(pwd.isalnum() and len(pwd) >= 3):
　　　　　　　　return '密码不合法'
　　　　　　res = func(*args,**kwargs)
　　　　　　return res
　　　　return inner
'''

#为登录结果的修饰装饰器：True => 登陆成功 ，False => 登录失败
'''
　　def change_res(func):
　　　　def inner(*args,**kwargs):
　　　　　　res = func(*args,**kwargs)
　　　　　　if res = True:
　　　　　　　　return '登陆成功'
　　　　　　return '登陆失败'
　　　　return inner
'''

#装饰器被执行的过程是从上至下
'''
　　@check_user 　　　　　　　#login = check_user(func=login)=inner
　　@check_pwd
　　@chang_res
　　def login(user,pwd):　　#被装饰的函数对象
　　　　if user == 'Owen' and pwd == '123':
　　　　　　return True
　　　　return False
　　user = input('user: ')
　　pwd = input('pwd: ')
　　res = login(user,pwd)
　　
　　print(res)
'''