1.变量的作用域
变量在程序中能够使用的范围
2.全局变量
a.声明在函数或者类的外部的变量都是全局变量
b.全局变量是从声明开始到整个py文件结束，任何位置都可以使用(作用域：从声明开始到文件结束)
3.局部变量
a.声明在函数或者类的里面的变量都是局部变量
b.局部变量是从声明开始到函数结束，任何位置都可以使用(作用域：从声明开始到函数结束)
num1,num2,aa 在函数内，都是局部变量
def func2(num1, num2):
print(num1, num2)
aa = 11
print(aa)
for xx in range(5):
print(xx)
print(xx)
global关键字只能在函数中使用,作用是在函数中声明一个全局变量
a=100
def test():
global
a=200
print(a)#200 修改全局变量a的值
global
b=200 #在函数中声明全局变量b
=============4.nonlocal的使用==============
"""
nonlocal关键字只能在函数中使用
当需要在局部的局部中修改局部变量的值，就使用nonlocal
语法：
nonlocal 变量名
变量名 = 值
def func1():
a=10 #在第一个函数中声明变量a=10
def func2():
nonlocal a #在第二个函数中修改a的值 a=20
a=20
print（a）#值是20
python中，声明函数其实就是声明一个类型是function的变量。函数名就是变量名
函数名作为变量除了可以用来调用函数获取返回值以外，普通变量能做的它都能做
声明类型是int类型的变量a
a = 10
print(type(a))
# 声明类型是dict类型的变量b
b = {'a': 12, 'b': 200}
print(type(b))
print(b['a'])
# 声明类型是function类型的变量c
c = lambda x: x*x
print(type(c))
c(10)
声明类型是function类型的变量d
def d(x):
def e():
print('abc')
e()
return x*x
print(type(d))
d(10) 100
使用函数变量func11给ff赋值
ff = func11
将ff当成函数来用
ff()
2.将变量作为列表的元素或者字典的值
声明列表变量list1
list1 = [100, 200, 300]
将列表变量list1作为列表list2的元素
list2 = [list1, 100]
print(list2[0][0])
声明一个函数变量func2
def func2():
print('我是函数2')
# 将函数变量func2作为列表list2的元素
list2 = [func2, 100]
print(list2[0]()) 启用函数func2
3.作为函数的参数
将函数1作为实参，传递给函数2；这儿的函数2就是一个高阶函数(实参高阶函数)
def test(x):
print('test:', x)
if not isinstance(x, int):
x()
# 声明一个int类型的变量a
a = 10
将变量a作为test的实参
test(a)
声明一个fucntion类型的变量func3
def func3():
print('我是函数3')
test(func3) 将函数func3作为实参传入函数def test（x）：中
sort函数
def sort(key=None, reverse=False)
key - 确定排序的时候以什么值为标准来排序(默认情况下，以列表的元素的大小为标准来排序);
需要传一个函数，函数需要一个参数和一个返回值。这儿的参数是列表的元素
reverse - 是否降序排序, 需要传一个bool值
def yt_sort(list1, key=None):
# list1 = my_list2; key = get_age
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)
# my_list.sort()
print(my_list)
my_list2 = [
{'name': '张三', 'age': 18},
{'name': '李四', 'age': 30},
{'name': '王五', 'age': 10}
]
def get_age(x):
return x['age']
yt_sort(my_list2, get_age)
print(my_list2)
my_list2 = [
{'name': '张三', 'age': 18, 'score': 90},
{'name': '李四', 'age': 30, 'score': 80},
{'name': '王五', 'age': 10, 'score': 89}
]
取最大年龄对应的字典
max_age = max(my_list2, key=lambda x: x['age'])
print(max_age)
取最大成绩对应的字典
max_score = max(my_list2, key=lambda x: x['score'])
print(max_score)
要求将按列表中元祖的第二个元素，获取最大值。
my_list3 = [('z', 10), ('b', 30), ('c', 20)]
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):
# char = '+'
"""
根据不同的符号返回不同的功能(函数功能的描述)
:param char: 运算符符号
:return: 不同运算符对应的功能的函数
"""
def get_operation(char):
def sum(*args, **kwargs):
# args = (10,20,30)
"""求多个数的和"""
sum1 = 0
for item1 in args:
sum1 += item1
for key in kwargs:
sum1 += kwargs[key]
print('yt')
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 diff(*args):
"""求多个数的差"""
# (10, 20, 30)
sum1 = args[0]
for index in range(1, len(args)):
sum1 -= args[index]
return sum1
return diff
else:
print('暂时不支持这个运算符')
return None
re = get_operation('+')
re(10,20,30)#60
re = get_operation('*')(1, 2, 3)
print(re)
print(get_operation('-')(100, 20, 30))
1.什么是迭代器(iter)
迭代器是python中的容器类的数据类型，可以同时存储多个数据。
取迭代器中的数据只能一个一个的取，而且取出来的数据，在迭代器就不存在了
2.迭代器中数据的来源
a.将其他序列转换成迭代器
b.使用生成式、生成器去产生数据
"""
1.将数据转换成迭代器
"""
所有的序列都可以转换成迭代器
"""
将字符串转换成迭代器
iter1 = iter('abcd')
print(iter1)
iter2 = iter([1, 10, 100, 1000])
print(iter2)
iter3 = iter({'name': '小明', 'age': 20})
print(iter3)
2.获取迭代器中的元素
"""
a.
next(迭代器) / 迭代器.next() - 取出迭代器中第一个元素(已经取出来的元素再也回不到迭代器中了)
"""
print(next(iter1)) a
print(next(iter1)) b
print(next(iter1)) c
print(next(iter1)) d
print(next(iter1)) # 当迭代器是空的时候，使用next获取元素，会出现StopIteration异常
print(iter2.next())
print(next(iter2))
"""
b.通过for循环取出迭代器中每个元素
"""
for x in iter2:
print('==:', x)
1.什么是生成器
生成器就是迭代器；迭代器不一定是生成器
调用带有yield关键字的函数，拿到的结果就是一个生成器。生成器中元素就是yield关键字后边的值
2.生成器怎么产生数据
只要函数中有yield关键字，调用函数不会再执行函数体获取返回值，而是创建一个生成器。
当获取生成器的元素的时候,才会执行函数的函数体,执行到yield语句为止，并且将yield后面的值作为结果返回；
并且保存当前执行的位置。
获取下一个元素的时候，就从上次结束的位置接着往下去执行函数，直到函数结束或者遇到yield为止;
如果遇到yield就将yield后面的值作为结果返回，并且保存当前执行的位置。如果函数结束了，就出现StopIteration异常
生成器对应的函数，执行完成遇到yield的次数，决定了生成器能产生的数据的个数
def func1():
print('abc')
yield 123
print('!!!!!!')
yield 100
re = func1()
print(re)
# next(re) - 执行re对应的函数的函数体,将yield关键字后边的值作为结果
print('===:', next(re))
# print('===:', next(re))
# print('===:', next(re))
def numbers():
for x in range(101):
yield x
print('next', x)
gener = numbers()
print(next(gener))
print(next(gener))
print(next(gener))
写一个生成器可以无限产生学号
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))
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))
print(next(gen))
print(next(gen))
for x in gen:
print('for:', x)
