一. 命名关键字参数:
在定义函数时,*与**之间的参数就是关键字参数
特点: 在调用函数时,命名关键字参数必须按照key=value的形式传值
def func(x,*,y=1,z):
print（x）
print（y）
print（z）
func（1，z=2）
def func(a,b=2,*args,c,**kwargs):
print(a)
print(b)
print(args)
print(c)
print(kwargs)
二。函数对象
函数时第一类对象：指的是函数的内存地址可以像一个变量值一样去使用
def foo（）： #foo=函数的内地址
print（‘from foo’）
1。变量值可以被引用
x=1 #foo=函数的内地址
y=x
f=foo
print（f）
f（）
2.变量值可以当做参数传给另外一个函数
def bar（x）：
print（x）
x（）
x=11111 #foo=函数的内存地址
bar（x）
bar（foo）
3.变量值可以当做函数的返回值
def func（x）：
return x
f= func（foo）
print（f）
4.变量值可以当做容器类型的元素
1=[foo,]
print(1)
1[0]()
#在后面加上括号就可以调用函数了.
dic={'1':foo}
print(dic)
dic['1']()
三.函数的嵌套:
函数的嵌套调用: 在一个函数内部又调用其他函数
def max2(x,y):
if x > y:
return x
eles:
return y
def max4(a,b,c,d):
res1=max2(a,b)
res2=max2(res1,c)
res3=max2(res2,d)
return res3
print(max4(1,2,3,4))
函数的嵌套定义: 在函数内有定义了其他函数
def func():
def foo():
print('from foo')
#print(foo)
foo()
x=1
print(x)
func()
求圆的周长跟面积的方式:
from math import pi
def circle(radius,action):
def cal_perimeter():
return 2 * pi * radius
def cal_area():
return pi * (radius ** 2)
if action == 1:
res=cal_perimeter()
elif action == 2:
res=cal_area()
return res
res=circle(10,1)
print(res)
四.名称空间与作用域:
1，名称空间相关
名称空间namespaces：指的是存放名字与值内存地址绑定关系的地方，（内存空间）
x=1
2.名称空间分为三大类：
内置名称空间：存放的是python解释器自带的名字
产生：python解释器的启动则产生
销毁：python解释器关闭则销毁。
全局名称空间：在顶级定义的名字。（前面没有缩进）
x1
if True：
y=2
while True：
while True：
while True：
z=3
（因为if 跟 while后面的变量可以写在一行）
产生：执行python程序时产生
销毁：python程序执行完毕后则销毁
局部名称空间：在函数内定义的名字
def foo（）：
m=100
foo（）
产生：在函数调用的时候临时产生
销毁：在函数调用完毕后则销毁
三种名称空间的产生的先后顺序：内置-》全局-》局部
查找名字的顺序：从当前位置往外一层一层的找
如果当前在局部名称空间： 局部-》全局-》内置
如果当前在全局名称空间： 全局-》内置
示例：
len=111
def foo():
# len=222
print(len)
len=111
foo()
x=0
def f1():
# x=1
def f2():
# x=2
def f3():
# x=3
print(x)
f3()
f2()
f1()
def foo1():
def foo2():
def foo3():
print(x)
2. 作用域：指的是作用的范围
全局作用域：包含内置与全局名称空间的名字
特点：全局存活，全局有效。
局部作用域：包含局部名称空间的名字
特点：临时存活，局部有效
终极无敌之天打五雷轰之上帝视角之霸王硬上弓之重点之重点！！！！！！！！
作用域关系是在函数定义阶段就已经固定死了，与调用位置无关！！！！！！！
示例：
def f1():
print(xxx)
xxx=111
def f2():
xxx=222
f1()
f2()
xxx=111
def f1():
print(xxx)
# xxx=222
yyy=222
print(yyy)
f
五。闭包函数。
闭：封闭，指的是该函数是定义一个函数内部的函数
包：该内部函数包含对外层函数名字的引用（alex在集装箱里吃蛋糕，就是闭包函数）
def outter（）：
x=1
def inner（）：
print（‘from inner’，x）
return inner
f = outter（）
（也就是说f = inner）
def foo（）：
print（f）
x=11111111111
f（）
foo（）
为函数体传值的两种方式：
def foo（）：
print（‘hello %s’%name）
方式一：直接以参数的形式传入
def foo（name）：
print（‘hello%s’%name）
foo（‘egon’）
（这种方式确实可以。但是太麻烦，用的多了就不好修改了。）
方式二：闭包函数
def outter(name):
#name='egon'
def foo():
print('hello %s' %name)
return foo
f=outter('egon')
print(f)
f()
f()
f()
f1=outter('alex')
f1()
f1()
f1()
（这种方式可以随意的修改多次使用的函数的值。）
爬虫的闭包用法
pip3 install requests
import requests
问题
def get():
response=requests.get(url)
if response.status_code == 200:
print(response.text)
解决方案一:
def get(url):
response=requests.get(url)
if response.status_code == 200:
print(response.text)
get('https://www.baidu.com')
get('https://www.baidu.com')
get('https://www.baidu.com')
解决方案二:
def outter(url):
# url='https://www.baidu.com'
def get():
response=requests.get(url)
if response.status_code == 200:
print(response.text)
return get
baidu=outter('https://www.baidu.com')
cnblogs=outter('https://www.cnblogs.com')