python函数(二)

格式化输出/函数名的运用/可迭代对象和迭代器

格式化输出(新特性)

1、格式化输出可以是变量

name = 'alex'
age = 18
msg = f'我的名字叫{name},今年{age}'
print(msg)

# 显示结果：我的名字叫alex,今年18

2、格式化输出可以是表达式

name = 'alex'
msg = f'我的名字叫{name.upper()}'
print(msg)

# 显示结果：我的名字叫ALEX

info = {'name':'alex','age':18}
msg = f'我的名字叫{info["name"]},今年{info["age"]}'
print(msg)

# 显示结果：我的名字叫alex,今年18

函数名的运用

1、函数名可以像变量一样赋值

def func1():
    print('in func1')
func2 = func1
func3 = func2
func3()

# 显示结果：'in func1'

2、函数名可以可跌打对象的元素

def func1():
    print('in func1')
li = [1,2,3,func1]
li[3]()

# 显示结果：'in func1'

3、函数名可以当做函数的参数进行传递

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

# 显示结果： 'in func2'  'in func1'

4、函数名可以当做函数的返回值

def func1():
    return 'in func1'
def func2(x):
    return x
ret = func2(func1)
print(ret())

# 显示结果： 'in func1'

可迭代对象和迭代器

1、可迭代对象：

概念：

字面意思：可迭代对象就是一个可以重复取值的实实在在的东西

专业角度：该对象有’__iter__’方法的就叫可迭代对象。

辨别方式：’__iter__’  in  dir(对象)   ,为真就是可跌打对象。dir(对象)可以查看该对象下面有什么方法,常有的可迭代对象有：str  list   tuple  dic  set  range

优缺点：

       优点：可以直观的查看里面的数据

       缺点：1、占用内存  2、可迭代对象不能迭代取值(除去索引，key以为)

2、迭代器：

概念：

字面意思：迭代器就是可以迭代取值的工具

专业角度：在python中，内部含有'__Iter__'方法并且含有'__next__'方法的对象就是迭代器。

辨别方式：’__iter__’  in  dir(对象) and ’__next__’  in dir(对象)    ,为真就是迭代器。常有的迭代器有：文件句柄

优缺点：

       优点：

                1、节省内存：迭代器在内存中相当于只占一个数据的空间，因为每次取值都上一条数据会在内存释放，加载当前的此条数据。

                  2、惰性机制：next一次，取一个值，绝对不多取

       缺点：1、不能直观看到数据   2、取值时不走回头路，只能一直向下取值。

li = [11, 22, 33, 44, 55, 66, 77, 88, 99]
for i in li:
    print(i)
for i in li:
    print(i)


print("==============================================")

obj = iter(li)
count = 0
for i in obj:
    if count == 2:
        break
    else:
        print(i)
    count += 1

for i in obj:
    if count == 7:
        break
    else:
        print(i)
    count += 1

显示结果：

# 结果：

11
 22
 33
 44
 55
 66
 77
 88
 99
 11
22
 33
 44
 55
66
 77
 88
 99
==============================================
 11
 22
 44
 55
 66
 77
 88

3、可迭代对象转换成迭代器

# 可迭代对象与迭代器的转换并取值

li = [1,3,7,'ald']
obj = iter(li)        #  iter(可迭代对象)  把可迭代对象转成迭代器   也可以：li.__iter__()
print(obj)            # <list_iterator object at 0x000002B1ACFD1588>
print(next(obj))      # 1
print(next(obj))      # 3
print(next(obj))      # 7
print(next(obj))      # 'ald'
print(next(obj))      # 报错：StopIteration

# 小结：  可迭代对象可以通过iter(可迭代对象)来转成迭代器，取值时通过next方法，一次只能取一个值，超过了取值范围就报错：StopIteration

4、 while模拟for的内部循环机制

li = [33, 77, 'ale', 'adkf']
# 把可迭代对象转换成迭代器
obj = iter(li)
while 1:
    try:
        print(next(obj))
    except StopIteration:       # except捕捉异常
        break

# 显示结果： 33    77   'ale'   'adkf'

5、可迭代对象与迭代器对比

可迭代对象：

     是一个私有的方法比较多，操作灵活（比如列表，字典的增删改查，字符串的常用操作方法等）,比较直观，但是占用内存，而且不能直接通过循环迭代取值的这么一个数据集。

    应用：当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。

迭代器：

    是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。

    应用：当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。（可参考为什么python把文件句柄设置成迭代器）。

-----------------   end ----------------------