迭代器的使用，新格式化输出

今日内容大纲
1. global nonlocal
2. 函数名的运用
3. 新特性：格式化输出
4. 迭代器
  - 可迭代对象
  - 判断对象的方法
  - 判断一个对象是否是可迭代对象
  - 小结
  - 迭代器
  - 迭代器的定义
  - 迭代器的取值
  - 可迭代对象如何转化成迭代器
  - while循环模拟for循环
  - 小结
  - 可迭代对象与迭代器的对不

今日具体内日

默认参数陷阱

#默认参数的陷阱
def func(name sex='男'):
    print(name)
    print(sex)
func('alex')

#陷阱只针对默认参数是可变的数据类型：
def func(name,alist=[]):
    alist.append(name)
    return alist

ret1 = func('alex')
print(ret,id(ret1)) #['alex']
ret2=func('太白金星')
print(ret2,id(ret2)) #['太白金星']

#如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个参数，都是同一个。

def func(a,list=[]):
    list.append(a)
    return list
print(func(10,)) #[10,]
print(func(20,[]))#[20,]
print(func(100,))#[10,100]

def func(a,list=[]):
    list.append(a)
    return list
ret1 = func(10,)
ret2 = func(20,[])
ret3 = func(100,)
print(ret1) #[10,100]
print(ret2) #[20,]
print(ret3) #[10,100]

局部作用域的坑：

#局部作用域的坑

count = 1
def func():
    count += 1
    print(count)
func()

#在函数中，如果你定义了一个变量，但是在定义这个变量之前对其引用，那么解释器就会认为：语法问题。
#你应该在使用之前先定义。
count = 1
def func():
    print(count)
    coutn=3
func()

global nonlocal

global
1,在局部作用域声明一个全全局变量。
def func():
    global name #这一步就是在局部变量中，声明一个全局变量
    name = '太白金星'
func()
print(name)

def func():
    global name
    name = '太白金星'
#print(name)这样会报错，一定要在调用函数声明过之后才能使用这个变量
func()
print(name)

2.修改一个全局变量
count = 1
def func():
    global count#在声明过全局变量之后，就可以在局部中修改这个全局变量
    count += 1
print(count)
func()
print(count)

#nonlocal
1.不能够操作全部变量。
count = 1
def func():
    nonlocal count
    count +=1
func()
2.局部作用域：内层函数对外层函数的局部变量进行修改。

def wrapper():
    count = 1
    def inner():
        nonlocal count
        count +=1
     print(count)
    inner()
    print(count)
wrapper()

函数名的运用

def func():
    print(666)
    
func()
1.函数名称指向的是函数的内存地址。
函数名+()就可以执行函数。

2.函数名就是变量
def func():
    print(666)
    
f = func
f1 = f
f2 = f1
f2()

def func():
    print('in func')
    
def func1():
    print('in func1')
func1 = func
func1()
#a = 1
#b = 2
#a = b
#print(a)

3.函数名可以作为容器类数据类型的元素

def func1():
    print('in func1')
def func2():
    print('in func2')
def func3():
    print('in func3')
l1 = [func1,func2,func3]
for i in l1:
    i()
    
4.函数名可以作为函数的参数

def func(a):
    print(a)
    print('in func')
b = 3
func(b)

def func():
    print('in func')
    
def func1(x):
    x()
    print('in func1')
    
func1(func)

5.函数名可以作为函数的返回值
def func():
    print('in func')
    
def func1(x):
    print('in func1')
    return x
ret = func1(func)
ret()

新特性:格式化输出

#新特性：格式化输出
name = '太白'
age = 18
msg = f'我叫{name},今年{age}'
print(msg)

可以加表达式
dic = {'name':'alex','age':73}
msg = f'我叫{dic["name"],今年{dic["age"]}'
print(msg)

count = 7
print(f'最终结果：{count*2}')
name = 'barry'
msg = f'我的名字是{name.upper()}'
print(msg)

#结合函数写：
def _sum(a,b):
    return a + b
msg = f'最终的结果是：{_sum(10,20)}'
print(msg)

优点：
1.结构更加简化。
2.可以结合表达式。
3.效率提升更多。

迭代器：
1. 可迭代对象：
  - 字面意思：对象，python中一切皆对象。一个实实在在存在的值，对象。
    
    可迭代：更新迭代。重复的，循环的一个过程，更新迭代每次都有新的内容可以进行循环更新的一个实实在在的值。
  - 专业角度：可迭代对象：内部含有'__iter__'方法的对象，可迭代对象。
  - 目前学过的可迭代对象 str list tuple dict set range
  - 获取对象的所有方法并且以字符串的形式表现：dir()
  - 判断一个对象是否是可迭代对象
```
s1 = 'fjsad'
l1 = [1,2,3]
print('__iter__' in dir(s1))
print('__iter__' in dir(l1))
```
2. 小结
  1. 字面意思：可以进行循环更新的一个实实在在的值
  2. 专业角度：内部含有'__iter__'方法的对象，可迭代对象。
  3. 判断一个对象是不是可迭代对象：'__iter__' in dir(对象)
  4. str list tuple dict set range
  5. 优点：
    1. 储存的数据直接能够显示，比较直观。
    2. 拥有方法比较多，操作方便、
  6. 缺点：
    1. 占用内存
    2. 不能直接for循环，不能直接索引（索引，key）。
3. 迭代器
4. 迭代器的定义
  1. 字面意思：更新迭代，器：工具：可更新迭代的工具。
  2. 专业角度：内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
  3. 可以判断是不是迭代器：：'__iter__' and '__next__' 在不在dir(对象)
5. 判断一个对象是否是迭代器
```
with open('文件1',encoding='utf-8',mode='w')as f1:
    print(('__iter__'in dir(f1)) and ('__next__' in dir(f1)))
```
6. 迭代器的取值
```
s1 = 'fjdakj'
obj = iter(s1) #s1.__ites__()
print(obj)

print(next(obj))#写一行取一个值
print(next(obj))

l1 = [11,22,33,44,55,66]
obj = iter(l1)
print(next(obj))
print(next(obj))
```
7. 可迭代对象转化成迭代器
```
iter([1,2,3])#转化成迭代器
```
8. while循环模拟for循环机制
```
l1 = [11,22,33,44,55,66,77,88,99]
#将可迭代对象转化成迭代器。
obj = iter(l1)
while 1:
    try:
        print(next(obj))
     except StopIteration:
        break
```
9. 小结
  1. 字面意思：更新迭代，器：工具：可更新迭代的工具。
  2. 专业角度：内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
  3. 优点：
    1. 节省内存。
    2. 惰性机制，next一次，取一个值。
  4. 缺点：
    1. 速度慢
    2. 不走回头路。
  5. 可迭代对象与迭代器的对比
    1. 可迭代对象是一个操作方法比较多，比较直观，存储收据相对少(几百万个对象，8G内存是可以承受的)的一个数据集
    2. 当你侧重于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。
    3. 迭代器是一个非常节省的内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。
    4. 当你的数据量过大，大到足以撑爆你的内存或者你以节省内存位首要因素时，将数据集设置为迭代器是一个不错的选择。

迭代器的使用，新格式化输出

今日内容大纲

今日具体内日