1.关键字 global nonlocal

为什么不能直接在局部对全局的变量进行修改?

因为UnboundLocalError: local variable 'count' referenced before assignment,

解释器认为：如果你在局部作用域对一个变量进行修改了，你在局部作用域已经定义好这个变量了。

global

1.可以在局部作用域声明一个全局变量。

这是剪切
def func():global namename = 1print(globals())name += 1print(globals())

2.可以修改全局变量。

count = 0
def func():global countcount += 1
print(count)
func()
print(count)

nonlocal

1.不能操作全局变量。

2.可以对父级作用域的变量进行修改，并且在当前作用域创建（复制）一份此变量。

这是复制
def func():count = 0def inner():nonlocal countcount += 1print(count)print(locals())inner()print(locals())
func()
UnboundLocalError: local variable 'count' referenced before assignment
解释器认为：如果你在局部作用域对一个变量进行修改了，
你在局部作用域已经定义好这个变量了。

2.默认参数的坑

def func(a,b=False):print(a)print(b)
func(1,True)
当你的默认参数如果是可变的数据类型，你要小心了。def func(a,l=[]):l.append(a)return l
print(func(1))  # [1,]
print(func(2))  # [2,]
print(func(3))  # [3,]

3.函数名的应用

<函数名是一个特殊的变量。

a = 1
b = 2
c = a + b
print(c)
def func():print(666)
print(func)  # func = <function func at 0x00000000003F1EA0>
1,函数名指向的是函数的内存地址,加上()就执行这个函数。
func()

<函数名是一个变量。

age1 = 12
age2 = age1
age3 = age2
print(age3)
def func():print(666)
f1 = func
f2 = f1
f2()
f1()

<函数名可以作为容器类类型的元素。

a = 1
b = 2
c = 3
l = [a,b,c]
print(l)def func1():print('in func1')
def func2():print('in func2')
def func3():print('in func3')
l = [func1, func2, func3]print(l)
for i in l:i()

<函数名可以作为函数的实参。

a = 1
def func(argv):print(argv)
func(a)def func1():
print('in func1')
def func2(argv):argv()print('in func2')
func2(func1)

<函数名可以作为函数的返回值

b = 666def func1():print('in func1')def func2(argv):print('in func2')return argv
ret = func2(b)
print(ret)def func1():print('in func1')def func2(argv):# argv = func1 : function 43543print('in func2')return argv
ret = func2(func1)  # func1 : function 43543
ret()def wrapper():def inner():print(666)return innerret = wrapper()ret()
wrapper()()

4.Python的新特性:f-string

(f的格式化输出)

1,不区分大小写
num = input('>>>')
s = F'python{num}'
print(s)可以加入表达式s1 = 'alex'
s2 = f'我的名字{s1.upper()}'
print(s2)l1 = ['太白', 18, 176]
s1 = f'我的名字{l1[0]}，我的年龄{l1[1]}，我的身高{l1[2]}'
print(s1)可以结合函数
def func(a,b):return a + bs1 = f'最终的结果{func(1,3)}'
print(s1)不能放一些特殊的字符 ! , : { } ;
print(f"替换结果{{{73}}}")
print(f'{12,}')

5.可迭代对象

字面意思分析：可以重复的迭代的实实在在的东西。

list,dict(keys(),values(),items()),tuple,str,set,range, 文件句柄（待定）

专业角度: 内部含有'__iter__'方法的对象，就是可迭代对象。

内置函数：dir()
print(dir(str))

判断一个对象是否是可迭代对象：
print('iter' in dir(str))

优点：

1. 直观。
2. 操作方法较多。

缺点：

1. 占内存。
2. 不能迭代取值（索引，字典的key）。

6.迭代器

字面意思：可以重复迭代的工具。

专业角度： 内部含有'__iter__'并且含有"__next__"方法的对象，就是迭代器

可迭代对象转化成迭代器：

l1 = [1, 2, 3, 4, 5]
# 内置函数iter()
obj = iter(l1)

# 迭代器可以迭代取值。利用next()进行取值
l1 = [1, 2, 3, 4, 5]
# 内置函数iter()
obj = iter(l1)
# print(obj)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

迭代器优点：

1. 非常节省内存。
2. 惰性机制。

迭代器缺点：

1. 不直观。
2. 操作不灵活。
3. 效率相对低。

特性：

l1 = [22, 33, 44, 55, 66, 77]
obj = iter(l1)for i in range(3):print(next(obj))for i in range(2):print(next(obj))

1. 利用while循环，模拟for循环内部循环可迭代对象的机制。

   1. 先要将可迭代对象转化成迭代器。

   2. 利用next对迭代器进行取值。

   3. 利用异常处理try一下防止报错。

2. 可迭代对象与迭代器的对比

   可迭代对象：可迭代对象是一个操作比较灵活，直观，效率相对高，但是比较占用内存的数据集。

   迭代器：迭代器是一个非常节省内存，满足惰性机制，但是效率相对低，操作不灵活的数据集。