基本使用

基本使用.png

函数定义和调用阶段的坑

  1. ### 判断以下函数是否会报错
  3. # 1. 
  4. def foo():
  5.     bar()
  6.     print("from foo")
  8. def bar():
  9.     print("from bar")
  11. foo()
  13. """
  14. 答案：不会报错,因为在foo()被调用之前,bar和foo都已经定义了，有了对应的内存空间
  15. """
  17. # 2. 
  18. def foo():
  19.     bar()
  20.     print("from foo")
  22. foo()
  24. def bar():
  25.     print("from bar")
  26. """
  27. 答案：会报错,在foo()时，bar并没有被定义，所以找不到对应的内存地址
  28. """

函数的参数

函数的参数.png

默认参数

  1. ### 写出以下函数的输出结果
  2. m=2
  3. def func(x,y=m):   # y==>2的内存地址
  4.     print(x,y)
  5. m=33
  6. func(1)
  8. """
  9. 答案：1 2 
  10. - 原因：默认参数的值是在函数定义阶段被赋值的
  11. - 过程：在定义时y=m,其实是y指向了2的内存地址,所以后面定义的m,与定义时无关了。
  12. """
  14. m = [1111]
  15. def func(x, y=m):
  16.     print(x, y)
  17. m.append(33)
  18. func(1)
  20. """
  21. 答案：1 [1111,33]
  22. - y=[]的内存地址,append并不会改变地址,只是原地添加
  23. - 修好不要使用可变类型，因为这样可能受其他语句影响
  24. """

args和*kwargs

*和被用到形参中**

  1. # *args :位置形参
  2. # **kwargs：关键字形参
  3. def func(x, y, *args):
  4.     print(x, y, args)
  5. func(1, 2, 3, 4, 5, 6)
  6. """
  7. 输出：1 2 (3, 4, 5, 6)
  8. - *:用来接收溢出的位置实参,溢出的位置实参会被*保存成元组赋值给紧随其后的变量名args
  9. """
  11. def func(x, y, *args, **kwargs):
  12.     print(x, y, args, kwargs)
  13. func(1, 2, 3, 4, k=5, z=6, m=7)
  15. """
  16. 输出: 1 2 (3, 4) {'k': 5, 'z': 6, 'm': 7}
  17. """

*和被用到实参中**

  1. # 实参中带*，可以先*将值打散成位置实参
  2. 应用：将l中的内容空格隔开输出，最后一个不要空格
  3. l = [1, 2, 3, 4, 5, 6]
  4. print(*l)
  5. >>> 1 2 3 4 5 6
  8. ## **示例
  9. def func(k1, k2, k3):
  10.     print(k1, k2, k3)
  11. dic = {"k1": 3, "k2": 2, "k3": 3}
  12. func(*dic)     # func('k1','k2','k3')
  13. func(**dic)    # func(k1=1,k2=2,k3=3)  # 这里是关键字参数，形参和实参的名字要相同
  14. print(*dic)    # k1 k2 k3
  15. print(**dic)  # 报错==>因为print中并没有对应可以接收关键字的key，所以会报错
  1. def test(k1, k2, k3):
  2.     print("===>test", k1, k2, k3)
  3. dic = {"k1": 3, "k2": 2, "k3": 3}
  4. test(*dic)  # func('k1','k2','k3')
  5. test(**dic)  # func(k1=1,k2=2,k3=3)
  7. def func(x1, x2, x3): # 这里的参数需要是data3,data2,data1
  8.     print(x1, x2, x3)
  9. dic = {"data3": 1, "data2": 2, "data1": 3}
  10. func(*dic)
  11. func(**dic)
  14. ***********运行结果***********
  15. ===>test k1 k2 k3
  16. ===>test 3 2 3
  17. data3 data2 data1
  18. Traceback (most recent call last):
  19.   File "D:/mycode/test_top/direction1/leetcode_49.py", line 11, in <module>
  20.     func(**dic)
  21. TypeError: func() got an unexpected keyword argument 'data3'
  23. Process finished with exit code 1

形参和实参中都带或*

  1. ### 形参和实参中都带*
  2. def func(x, y, *args):
  3.     print(x, y, args)
  6. func(1, 2, [3, 4, 5, 6])
  7. func(1, 2, *[3, 4, 5, 6])
  9. >>>1 2 ([3, 4, 5, 6],)  # 注意，若元组中只有一个元素，需要加逗号
  10. >>>1 2 (3, 4, 5, 6)
  12. ### 形参和实参中都带**
  13. def func(x,y,**kwargs):
  14.     print(x,y,kwargs)
  16. func(**{'y':222,'x':111,'a':333,'b':444})
  17. >>>111 222 {'a': 333, 'b': 444}
  1. # 定义
  2. def index(x, y):
  3.     print(x, y)
  6. def wrapper(*args, **kwargs): # 形参： args=(1,)  kwargs={'y':2,'z':3}
  7.     index(*args, **kwargs) # 实参：index(*(1,),**{'y':2,'z':3})
  8.                              解析为：index(1,z=3,y=2)
  9. # 调用
  10. wrapper(1, z=3, y=2)   
  11. """
  12. - 调用wrapper函数需要遵循index的参数规则(目前多了z=3,会报错)
  13. - 参数不能多，不能少
  14. """

命名关键字参数(了解)

  1. # 命名关键字参数：在定义函数时，*后定义的参数,如下所示：
  2. def fun(x,y,*,a,b):
  3.     print(x,y)
  4.     print(a,b)
  5. """
  6. 命名关键字参数必须按照key=value的形式为其传值
  7. """
  8. >>> func(1,2,b=222,a=111)

名称空间和作用域

名称空间和作用域.png

gloabl和nonlobal

  1. # 示例一:局部和全局使用相同的名字
  2. x = 111
  3. def foo():
  4.     x = 222
  5.     print("===>foo:", x)  # 222
  7. foo()
  8. print("===>main:", x)   # 111
  11. # 示例2 :通过局部去修改全局变量的值，需要使用global(注：不可变类型)
  12. x = 111
  13. def foo():
  14.     global x  # 声明该x为全局的x，不需要新的内存空间了
  15.     x = 222
  16.     print("===>foo:", x)  # 222
  18. foo()
  19. print("===>main:", x)  # 222
  22. # 示例3 :通过局部去修改全局变量的值(可变类型可以直接改)
  23. x = [111]
  24. def foo():
  25.     x.append(222)  # 原地修改的,所以没有global问题不大
  26.     print("===>foo:", x)  # [111,222]
  27. foo()
  28. print("===>main:", x)  # [111,222]
  1. # 示例1:函数外层仍为函数
  2. x = 1
  3. def func1():
  4.     x = 2
  5.     def func2():
  6.         x = 3
  7.         print("====>func2:", x)  # 3
  8.     func2()
  9.     print("====>func1:", x)   # 2
  11. func1()
  12. print("====> main:", x)  # 1
  14. # 示例2:
  15. x = 1
  16. def func1():
  17.     x = 2
  18.     def func2():
  19.         nonlocal x   # 声明该x为当前函数外部函数里的x(不会上升到全局变量,若外部函数没有则报错)
  20.         x = 3
  21.         print("====>func2:", x)  # 3
  22.     func2()
  23.     print("====>func1:", x)   # 3
  25. func1()
  26. print("====> main:", x)  # 1
  29. # 示例3:
  30. x = 1
  31. def func1():
  32.     ####### 
  33.     def func2():
  34.         nonlocal x   # 声明该x为当前函数外部函数里的x(不会上升到全局变量,若外部函数没有则报错)
  35.         x = 3
  36.         print("====>func2:", x)  
  37.     func2()
  38.     print("====>func1:", x)   
  40. func1()
  41. print("====> main:", x)
  43. >>> SyntaxError: no binding for nonlocal 'x' found
  44. """
  45. nonlocal：会从当前函数的局部往外层套着的函数里查找,一直到外层函数不再套函数为止。
  46. - 可变类型依然不需要声明
  47. """

装饰器

装饰器.png

函数对象

  1. def func():
  2.     print("===>func")
  4. """   
  5. 函数对象：即把函数当成变量名使用
  6.   - 不加括号去调用,而是直接传函数名
  7.   - func ==> 本质是内存地址
  8. """
  11. # 1. 函数对象：可以被赋值
  12. f = func
  13. print(f, func)  # 两个相同的内存地址
  16. # 2. 函数对象：可以作为函数的参数
  17. def foo(x):
  18.     print("===>foo", x)
  19.     x()  # func仍然可以被调用
  22. foo(func)
  24. # 3. 函数对象：可以作为另外一个函数的返回值
  25. def new(x):
  26.     return x
  29. res = new(func)
  30. print(res)
  31. res()
  32. print(res())  # None(该函数没有返回值)
  35. # 4. 函数对象：可以作为容器中的元素
  36. ls = [func, 2]
  37. ls[0]()
  39. dic = {"k1": func}
  40. dic["k1"]()

函数对象的应用案例

  1. def login():
  2.     print("登录成功")
  5. def tranfer():
  6.     print("转账记录")
  9. def check_banlance():
  10.     print("查询余额")
  13. def withdraw():
  14.     print("提现")
  17. while True:
  18.     print("q==>退出\n0==>登录\n1==>转账\n2==>余额\n3==>提现")
  19.     choice = input("请输入对应编号已完成对应功能>>>").strip()
  20.     if choice == "q":
  21.         break
  22.     if not choice.isdigit():
  23.         print("请输入正确的编号")
  24.         continue
  26.     elif choice == "0":
  27.         login()
  28.     elif choice == "1":
  29.         tranfer()
  30.     elif choice == "2":
  31.         check_banlance()
  32.     elif choice == "3":
  33.         withdraw()
  34.     else:
  35.         print("该编号不存在")
  37. """
  38. - if...elif...else过长,过于冗余
  39. - 另外如果新加功能的话,需要从新写if...else...
  40. """
  1. def login():
  2.     print("登录成功")
  5. def tranfer():
  6.     print("转账记录")
  9. def check_banlance():
  10.     print("查询余额")
  13. def withdraw():
  14.     print("提现")
  17. dic = {
  18.     ### 注:这里使用元组可能更好,因为列表是可变类型,元组是不可变类型
  19.     'q': ['退出', None],
  20.     '0': ['登录', login],
  21.     '1': ['转账', tranfer],
  22.     '2': ['余额', check_banlance],
  23.     '3': ['提现', withdraw]
  24. }
  26. while True:
  27.     for key in dic:
  28.         print('%s:%s' % (key, dic[key][0]))
  29.     choice = input("请输入对应编号已完成对应功能>>>").strip()
  30.     if choice == "q":
  31.         break
  32.     if not choice.isdigit():
  33.         print("请输入正确的编号")
  34.         continue
  35.     else:
  36.         if dic.get(choice):
  37.             dic.get(choice)[1]()
  38.         else:
  39.             print("该编号不存在")

all 和 any 的用法

在写torch.fx时，源码中的用法

  1. patterns = set([operator.add, torch.add, "add"])
  3. # Go through all the nodes in the Graph
  4. for n in traced.graph.nodes:
  5.     # If the target matches one of the patterns
  6.     if any(n.target == pattern for pattern in patterns):
  7.         # Set the insert point, add the new node, and replace all uses
  8.         # of `n` with the new node
  9.         with traced.graph.inserting_after(n):
  10.             new_node = traced.graph.call_function(torch.bitwise_and, n.args, n.kwargs)
  11.             n.replace_all_uses_with(new_node)
  12.         # Remove the old node from the graph
  13.         traced.graph.erase_node(n)
  15. # Don't forget to recompile!
  16. traced.recompile()
  18. """
  19. any(iterator): iterator种有一个满足即为True
  20. all(iterator): iterator种有全部满足才为True
  21. """

闭包函数

  1. """
  2. 闭包函数=名称空间与作用域+函数嵌套+函数对象
  3. """
  5. # 1. 名称空间与作用域+函数嵌套(目前还没有使用函数对象)
  6. def f1():
  7.     x = 33
  9.     def f2():
  10.         print("f2中的x:", x)
  12.     f2()
  15. x = 111
  16. f1()  # "f2中的x:", 33
  19. # 2.加上函数对象
  20. def f1():
  21.     x = 33
  23.     def f2():
  24.         print("f2中的x:", x)
  26.     return f2
  29. x = 111
  30. f1()()  # "f2中的x:", 33 ==>这里是两个括号相当于 f2()
  33. '''
  34. 函数传参有两种方式：可能会遇到一种传参不满足需求的情况
  35. '''
  36. # 1. 方式1:形参
  37. def func(x):
  38.     print(x)
  41. func(1)
  42. # 2.方式二：闭包函数
  43. def f1(x):
  44.     # x=3
  45.     def func():
  46.         print(x)
  47.     return func
  49. f2=f1(3)
  50. f2()

装饰器详解

装饰器属于名称空间与作用域+函数对象+函数嵌套+闭包函数的综合应用

装饰器的引导过程

  1. """
  2. 现有一个函数,本身的功能是两数之和
  3. 需求：现在要求输出函数的运行时间
  4. """
  5. import time
  7. def add(x, y):
  8.     time.sleep(2)
  9.     print(x + y)
  11. """
  12. 方法一: 在add函数内部直接修改
  13. - 但是在程序庞大的情况下,直接修改可能导致错误,因此尝试不修改原函数但添加该功能
  14. """
  16. def add(x, y):
  17.     start = time.time()
  18.     time.sleep(2)
  19.     print(x + y)
  20.     stop = time.time()
  21.     print(stop - start)
  23. add(1, 2)
  25. """
  26. 方法二: 在调用该函数前后修改
  27. - 问题:若该函数调用多次,那则需要在每一个函数调用前后都加上该代码
  28. - 容易造成代码冗余
  29. """
  30. start = time.time()
  31. add(2, 3)
  32. stop = time.time()
  33. print(stop - start)
  35. start = time.time()
  36. add(4, 5)
  37. stop = time.time()
  38. print(stop - start)
  40. """
  41. 优化方法二：将代码冗余部分写成函数
  42. - 1. 将冗余部分写入函数体,每次去调用新写的函数
  43. - 2. 但是参数会被写死,进一步改进参数(*args,**kwargs) 
  44. - 3. 参数修改完成了,但是被装饰的函数add写死了(闭包改进)
  45. """
  46. # 第二步更新后
  47. def wrapper(*args,**kwargs):
  48.     start = time.time()
  49.     add(*args, **kwargs)
  50.     stop = time.time()
  51.     print(stop - start)
  52. wrapper(2,3)
  54. # 第三步更新后
  55. def outter(func):
  56.     # func=add
  57.     def wrapper(*args, **kwargs):
  58.         start = time.time()
  59.         func(*args, **kwargs)
  60.         stop = time.time()
  61.         print(stop - start)
  63.     return wrapper  # 返回的是wrapper的内存地址
  65. # 若是被调用后又赋值给了add,那么原来的add在使用上完全没改变,但功能多了
  66. add = outter(add)  
  67. # 用户使用新的add(该add是被wrapper装饰过的add,内存地址由原来的add变成了现在的wrapper)
  68. add(3, 4) 
  71. # 新定义一个函数名为mul,让该函数也输出运行时间
  72. def mul(x, y):
  73.     time.sleep(2)
  74.     print(x * y)
  75. # 那么调用方式会变成
  76. mul = outter(mul)
  77. mul(3, 4)
  79. """
  80. 方法二的进一步优化：
  81. - 在以上的写法中我们都没有考虑返回值的问题
  82. - 但其实,修改过程需要函数本身不变、函数调用方式不变、返回值也不变
  83. - 因此可以进一步改写装饰器,该方法也为装饰器的常用写法
  84. """
  86. def outter(func):
  87.     def wrapper(*args, **kwargs):
  88.         start = time.time()
  89.         res = func(*args, **kwargs)
  90.         stop = time.time()
  91.         print(stop - start)
  92.         return res  # 为被装饰的函数func的返回值
  93.     return wrapper  # 返回的是wrapper的内存地址
  95. mul = outter(mul)
  96. res = mul(3, 4)
  97. print(res)

装饰器语法糖

  1. import time
  3. def outter(func):
  4.     def wrapper(*args, **kwargs):
  5.         start = time.time()
  6.         res = func(*args, **kwargs)
  7.         stop = time.time()
  8.         print(stop - start)
  9.         return res  # 为被装饰的函数func的返回值
  11.     return wrapper  # 返回的是wrapper的内存地址
  14. @outter  #该语法等于 add=outter(add)
  15. def add(x, y):
  16.     time.sleep(2)
  17.     return x + y
  19. @outter
  20. def mul(x, y):
  21.     time.sleep(2)
  22.     return x * y
  24. # add = outter(add)
  25. res = add(3, 4)
  26. print(res)
  28. # mul = outter(mul)
  29. res = mul(3, 4)
  30. print(res)
  33. """
  34. 原本代码中：
  35.     add = outter(add)
  36.     mul = outter(mul)
  37. 可以使用 @装饰器名称 写在被装饰函数的前面
  38. """

装饰器补充

  1. def add(x, y):
  2.     """两数相加"""
  3.     time.sleep(2)
  4.     return x + y
  6. print(add.__name__)  # 该函数原函数的名称
  7. print(help(add))     # 帮助文档，看的是文档的注释信息===> 原函数.__doc__
  9. 返回结果：
  10. >>>add
  11. >>>两数相加
  1. @outter
  2. def add(x, y):
  3.     """两数相加"""
  4.     time.sleep(2)
  5.     return x + y
  7. print(add.__name__)
  8. print(help(add))
  10. 返回结果：
  11. >>>wrapper
  12. >>>None
  14. """
  15. 出现原因：
  16. - 在add函数被装饰过后，即使原函数不变、调用方式不变、返回值不变，但是还有函数的内置属性
  17. - 如果想进一步使装饰过后的函数，内置属性也相同需要在写装饰器时加上内置属性
  18. """
  20. def timmer(func):
  21.     def wrapper(*args, **kwargs):
  22.         pass
  24.     wrapper.__name__ = func.__name__
  25.     wrapper.__doc__ = func.__doc__
  26.     return wrapper
  27. # 但是这种写法没有办法写全所有的内置属性，还很麻烦，因此python提供了库
  29. """最终写法："""
  30. from functools import wraps
  31. def timmer(func):
  32.     @wraps(func)
  33.     def wrapper(*args, **kwargs):
  34.         res = func(*args, **kwargs)
  35.         return res
  36.     return wrapper

装饰器模板

  1. from functools import wraps
  2. def outter(func):
  3.     @wraps(func)   # 使得func函数的内置属性不变
  4.     def wrapper(*args, **kwargs):
  5.         """添加新功能"""
  6.         res = func(*args, **kwargs)
  7.         """添加新功能"""
  8.         return res  # 为被装饰的函数func的返回值
  9.     return wrapper  # 返回的是wrapper的内存地址
  11. """
  12. 注意：闭包函数最后返回的是wrapper函数对象,并没有加括号调用
  13. - 方便记忆，可以理解为：被装饰的函数func原本是在 全局变量 里的，经过闭包写在了 局部变量里，
  14.                       因此最后需要把被装饰的函数返回到 全局变量 里
  15. """
  1. #套三层
  1. 加载顺序自下而上
  2. 运行顺序自上而下
  4. def func1(add):
  5.     print("func1")
  6.     def wrapper1(*args, **kwargs):
  7.         print("wrapper1")
  8.         res = add()
  9.         return res
  11.     return wrapper1
  14. def func2(add):
  15.     print("func2")
  17.     def wrapper2(*args, **kwargs):
  18.         print("wrapper2")
  19.         return add()
  21.     return wrapper2
  24. @func1
  25. @func2
  26. def func():
  27.     print("hello world")
  29. func()
  32. """
  33. func2
  34. func1
  35. wrapper1
  36. wrapper2
  37. hello world
  38. """

迭代器

迭代器.png

  1. # 循环取值:这种取值办法不依赖索引
  2. ls = [1, 2, 3]
  3. ls_iter = ls.__iter__()
  4. """ls下有__iter__,是可迭代对象"""
  5. print(ls_iter)
  6. """
  7. ls_iter:调用了可迭代对象下的__iter__转为迭代器对象
  8. 迭代器对象.__next__：可以得到迭代器的下一个值
  9. """
  10. # 方法一:
  11. value = ls_iter.__next__()
  12. print(value)  # 1
  13. value = ls_iter.__next__()
  14. print(value)  # 2
  15. value = ls_iter.__next__()
  16. print(value)  # 3
  17. # value = ls_iter.__next__()
  18. # print(value)  # StopIteration
  21. # 方法二:使用while迭代
  22. while True:
  23.     try:
  24.         value = ls_iter.__next__()
  25.         print(value)
  26.     except StopIteration:
  27.         break  # 抛出异常后退出循环即可
  29. """
  30. 可迭代对象：字符串、列表、元组、字典、集合、文件对象
  31. 迭代器对象：文件对象
  32. """
  33. # 方法3: for循环
  36. # 文件使用迭代器
  37. with open('a.txt', mode='rt', encoding='utf-8') as f:
  38.     # f.__iter__()
  39.     # f.__next__()
  40.     for line in f:  # f.__iter__()
  41.         print(line)

生成器

引入

生成器：本质是一个自定义的迭代器。也包含了__iter__ 和__next__

  1. # 引入
  2. def func():
  3.     print("aaa")
  4.     return 'a'
  6. res=func()
  7. print(res)
  8. """
  9. 如果使用的是return，我们调用这个函数时，便会出现调用结果
  10. 但是如果使用的是yield，调用该函数的时候，其实并没有运行
  11. """
  12. # 生成器例子
  14. def func():
  15.     print("第一次")
  16.     yield 1
  17.     print("第二次")
  18.     yield 2
  19.     print("第三次")
  20.     yield 3
  21.     print("第四次")
  24. g = func()
  25. print(g)  # 迭代器对象
  27. g = g.__iter__()  # iter(迭代器对象)之后还是本身
  28. print(g)
  31. """
  32. 生成器: 
  33. - 函数调用之后赋值给一个值,这个值是生成器对象。
  34. - 内置有__iter__和__next__方法
  35. - 使用next(迭代器对象)就会被赋值
  36. - 但是会在遇见yield时停下来，将yield后的值，当作本次调用的返回值
  37. - yield后没有值的话，默认为None
  38. """
  39. # 方法一：
  40. while True:
  41.     try:
  42.         value=g.__next__()
  43.         print(value)
  44.     except StopIteration:
  45.         break
  46. # 方法二：
  47. for value in g:
  48.     print(value)

yield

  1. yield与return一样用在函数中(上述例子就是)
  2. yield用在表达式中（并发编程的时候使用的比较多） ```python def student(name): print(“你的名字是：%s” % name) while True:
    1.  x = yield None
    2.  print('你的名字是 %s, 今年 %s 岁了' % (name, x))

gen = student(‘python’) print(gen) #

gen.send(‘19’) # can’t send non-None value to a just-started generator

gen.send(None) # 你的名字是：python

gen.send(“18”) # 你的名字是 python, 今年 18 岁了 gen.send(‘20’) # 你的名字是 python, 今年 20 岁了 gen.close() # 关闭生成器

gen.send(‘12’) # 关闭之后在传值会导致错误

“”” yield在表达式中：

  • yield在表达式中会接收send()传入的值
  • 并且一开始传入的值只能是None
  • 该生成器可以使用close()关闭，但是关闭之后不可以再传值了
  • gen.send() 就相当于 g = next(gen) “”” ```

    解析式

    生成式.png

    列表、字典、集合、生成器

    ```python

    1. 列表生成式

    l = [‘wxx_py’, ‘yxx_py’, ‘exx_py’, ‘a_java’, ‘b_java’] new_ls = [name for name in l if name.endswith(‘py’)] print(new_ls) “””
  1. 将l中的元素转为大写
  2. 去掉后缀py “”” new_ls = [name.upper() for name in l] new_ls = [name[:-2] for name in l if name.upper().endswith(‘PY’)]

    for name in l:

    if name.upper().endswith(‘PY’):

    name = name.upper()[:-2]

    new_ls.append(name)

    print(new_ls)

2.字典生成式(key:value必须有)

items = [(‘name’, ‘egon’), (‘age’, 18), (‘gender’, ‘male’)] dic = {name[0]: name[1] for name in items} dic_new = {k: v for k, v in items} print(dic) print(dic_new)

3.集合生成式

key = [‘name’, ‘age’, ‘gender’] set1 = {value for value in key if value != ‘gender’} print(set1)

4. 生成器表达式

g = (i for i in range(10) if i > 7) print(g, type(g)) # g是一个生成器,此时g中没有东西，需要使用next print(next(g)) # 8 print(next(g)) # 9

  1. <a name="TFuo7"></a>
  2. ### 生成器解析式案例
  3. ```python
  4. 文件字符数总和(注：\n也属于一个字符)
  5. with open('../file_n.txt', mode="rt", encoding='utf-8') as f:
  6.     # 方法一：
  7.     res = 0
  8.     for line in f:
  9.         res += len(line)
  10.     print(res)
  11.     # 方法二:
  12.     res = [len(line) for line in f]
  13.     print(res)
  14.     # 方法三:效率最高
  15.     res = sum(len(line) for line in f)
  16.     print(res)
  17. """
  18. 方法3的效率最高是因为生成器的内部是没有内容的，不然如果是列表还需要占空间占内存
  19. """