01-recode
1.函数的调用
过程：
回到函数声明的位置
用实参给形参赋值
执行函数体
过去返回值
回到函数调用的位置
压栈：当调用函数的时候，系统会自动在栈区间开辟空间保存函数调用过程中产生的数据（形参，函数中声明的变量）
2.返回值
看有没遇到return，遇到了函数的返回值就是return后面的值，没有返回值就是None
函数调用表达式的结果就是函数的返回值
3.函数的参数
位置参数和关键字参数：位置参数要在关键字参数的前面
参数的默认值：参数名 = 值
不定长参数：*参数名 ； **参数名
参数类型说明：参数名：类型名
def fun1（a：int） ->int： #函数返回值进行说明
4.匿名函数
函数名 = lambda 参数列表 ：返回值
02-变量的作用域
1.变量的作用域
变量在程序中能够使用的范围
2.全局变量
a.声明在函数或者类的外部的变量都是全局变量
b.全局变量是从声明开始到整个py文件结束，任何位置都可以使用（作用域：声明开始到文件结束）
3.局部变量
a.声明在函数或者类的里面的变量都是局部变量
b.局部变量是从声明开始到函数结束，任何位置都可以使用（作用域：从声明开始到函数结束）
4.global关键字只能在函数中使用，作用是在函数中声明一个全局变量
5.nonlocal关键字只能在函数中使用
但需要在局部的局部中修改局部变量的值，就是使用nonlocal
语法：nonlocal 变量名
变量名 = 值
def func1():
a2 = 'abc'# 声明一个局部变量
def func11():
nonlocal a2
a2 ='python'
print(a2)
a3 =111 #a3 的作用域在func11中
func11()
print('打印：',a2)
func1()
a1 = 100
def test1():
global a1 #声明一个全局变量a1
a1=200
print(a1)
global b1 #在函数里声明一个全局变量
b1 =300
test1()
print(a1)
print(b1)
# 局部变量
def fun2(num1,num2):
print(num1,num2)
aa= 11
print(aa)
functions = []
for x in range(5):
def func1(a):
return a*x
functions.append(func1)
t1 =functions[0]
t2 = functions[2]
print(t1(2),t2(2))
03-函数作为变量
python 中，声明函数其实就是声明一个类型是function的变量。函数名就是变量名
函数作为变量除了用来调用函数获取返回值以外，普通变量能做的它都能做
# 声明类型是int的变量
a = 10
# 声明类型是dict类型的变量
b = {'a':1,'b':2}
# 声明类型是function类型的变量c
c = lambda x:x*x
print(type(c))
# 声明类型是function类型的变量d
def d(x):
return x*x
print(type(d))
# 1.让一个变量给另一个变量赋值
list1 =[1,2,3]
list2 =list1
print(list2[0])# 使用列表list1给list2赋值
#声明一个函数变量func11
def func11():
print('我是函数')
ff = func11
ff() #使用函数变量func11给ff赋值，将ff当成函数使用
# 2.将变量作为列表的元素或者字典的值
list1 = [1,2,3]
list2 =[list1,100]#将列表变量list1作为列表list2的元素
print(list2[0][0])
def func2(): #声明一个函数变量func2
print("我是函数2")
list2 = [func2,100] # 将函数变量func2作为列表list2的元素
print(list2[0]())
3.作为函数的参数
将函数1作为实参传递给函数2，这儿的函数2就是一个高阶函数（实参高阶函数）
def test(x):
print('text：',x)
if not isinstance(x,int):
x()
a = 10 #声明一个int类型的变量a
test(a)# 将变量a作为test的实参
def func3():
print('我是函数3')
test(func3)
3.1 sort()
def sort(key = None,reverse=False)
key - 确定排序的时候以什么值为标准来排序（默认情况下以列表元素大小为标准来排序）；
需要传一个函数，函数需要一个参数和一个返回值，这的参数的值是列表的元素
reverse - 是否降序排序，需要传个布尔值
# list2.sort()
def yt_sort(list1,key=None):
if key == None:
for index in range(len(list1)):
for index2 in range(index+1,len(list1)):
current = list1[index]
behind = list1[index2]
if behind < current:
list1[index],list1[index2] = list1[index2],list1[index]
else:
for index in range(len(list1)):
for index2 in range(index+1,len(list1)):
current = key(list1[index])
behind = key(list1[index2])
if behind < current:
list1[index],list1[index2] = list1[index2],list1[index]
# my_list = [1,34,20,89,8]
# yt_sort(my_list)
# print(my_list)
my_list2 = [{'name':'zc','age':18},{'name':'ls','age':30},{'name':'ww','age':10}]
# yt_sort(my_list2)#TypeError: '<' not supported between instances of 'dict' and 'dict'
def get_age(x):
return x['age']
yt_sort(my_list2,get_age)
print(my_list2)
# 练习：要求将列表中元祖的第二个元素，获取最大值
my_list3 = [('z',10),('b',30),('c',30)]
print(max(my_list3,key= lambda item:item[1]))
4.变量作为函数的返回值
返回值势函数的函数，也叫高阶函数（返回高阶函数）
def test2(n):
sum1 = 1
for x in range(1,n+1):
sum1 *= x
return sum1
re =test2(5) + 10
print(re)
def get_operation(char):
根据不同的符号返回不同的功能（函数功能的描述）
:param char: 运算符号
:return: 不同运算符对应得功能的函数
if char == '+':
# 求和功能
def sum(*args,**kwargs):
sum1 =0
for item1 in args:
sum1 += item1
for key in kwargs:
sum1 += kwargs[key]
return sum1
return sum
elif char == '*':
def mul(*args,**kwargs):
sum1 =1
for item1 in args:
sum1 *=item1
for key in kwargs:
sum1 *= kwargs[key]
return sum1
return mul
elif char == '-':
def jian(*args,**kwargs):
sum1 = 0
for index in range(len(args)):
if index == 0:
num = args[index]
else:
sum1 = sum1 +args[index]
sum2 = num - sum1
return sum2
for key in kwargs:
sum1 = sum1 - kwargs[key]
return sum1
return jian
else:
print('不支持')
return None
re = get_operation('+')#re是一个函数（相当于sum函数）
print(re(1,2,3,4,5)) #调用sum函数获取返回值
04 -迭代器
1.什么事迭代器（iter）
迭代器是python中容器类的数据类型，可以同时存储多个数据。
取迭代器中的数据只能一个一个取，而且取出来的数据，在迭代器中就不存在了
2.迭代器中的数据来源
a.将其他序列转换成迭代器
b.使用生成式、生成器产生数据
3.将数据转换成迭代器
所有序列都可以转换成迭代器
# 将字符串转换成迭代器
iter1 = iter('abcd')
print(iter1)
iter2 = iter([1,2,3,4])
print(iter2)
iter3 = iter({'a':2,'b':1})
print(iter3)
4.获取迭代器中的元素
next(迭代器)/迭代器.next() - 取出迭代器中第一个元素（已经取出来的元素再也回不到迭代器中了）
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1))#StopIteration（当迭代器为空时，使用next获取元素会出现StopIteration异常）
5.通过for循环取出迭代器中的每个元素
for x in iter2:
print('==',x)
05-生成器
1.什么是生成器
生成器就是迭代器，迭代器不一定是生成器
生成器就是带有yield关键字的函数的结果
调用带有yield关键字的函数，拿到的结果就是一个生成器。生成器中的元素就是yield关键字后面的值
2.生成器怎么产生数据
只要函数只要有yield关键字，调用函数不会再执行函数体获取返回值，而是创建一个生成器
当获取生成器的元素的时候，才会执行函数的函数体，执行到yield语句为止，并且将yield后面的值作为结果返回，
并且保存当前执行的位置。获取下一个元素的时候，就从上次结束的卫视接着往下去执行函数，指导函数结束或者遇到yield为止，
如果遇到yield就将yield后面的值作为结果返回，并且保存当前执行位置，如果函数结束了，就出现stopiteration
生成器对应的函数，执行完成遇到yield的次数，决定了生成器能产生的数据的个数
def func1():
print('abc')
yield 123
print('!!!!')
yield
re = func1()
print('===',next(re))#next（re） - 执行re对应的函数体，将yield关键字后边的值作为结果
print('===',next(re))
def numbers():
for x in range(101):
yield x
x = numbers()
# print(next(x))
# print(next(x))
# 写一个生成器可以无限产生学号
def creat_id():
num = 0
while True:
yield 'stu'+str(num)
num += 1
gener_id = creat_id()
# print(next(gener_id))
for x in range(10):
print(next(gener_id))
# 写一个生成器，可以不断产生斐波那契数列：1，1，2，3，5，8，13，21....
def sequence(n):
pre_1 =0
pre_2 = 1
for _ in range(n):
yield pre_2
pre_1,pre_2=pre_2,pre_1+pre_2
gen = sequence(10)
print(next(gen))
print(next(gen))
for x in range(8):
print('==',next(gen))
