day13-阶段总结

热情之风

1.知识补充

1.1 nolocal关键字

在之前的课程中，我们学过global关键字。

1. name = 'root'
4. def outer():
5.     name = "武沛齐"
7.     def inner():
8.         global name
9.         name = 123
11.     inner()
12.     print(name)        # 武沛齐
15. outer()
16. print(name)        # 123

复制代码

其实，还有一个nolocal关键字，用的比较少，此处作为了解即可。

1. name = 'root'
4. def outer():
5.     name = "武沛齐"
7.     def inner():
8.         nonlocal name
9.         name = 123
11.     inner()
12.     print(name)        # 123
15. outer()
16. print(name)        # root

复制代码

1. name = 'root'
4. def outer():
5.     name = 'alex'
7.     def func():
8.         name = "武沛齐"
10.         def inner():
11.             nonlocal name
12.             name = 123
14.         inner()
15.         print(name)        # 123
17.     func()
18.     print(name)        # alex
21. outer()
22. print(name)        # root

复制代码

1. name = 'root'
4. def outer():
5.     name = 'alex'
7.     def func():
8.         nonlocal name
9.         name = "武沛齐"
11.         def inner():
12.             nonlocal name
13.             name = 123
15.         inner()
16.         print(name)        # 123
18.     func()
19.     print(name)        # 123
22. outer()
23. print(name)        # root

复制代码

1.2 yield from

在生成器部分我们了解了yield关键字，其在python3.3之后有引入了一个yield from。

1. def foo():
2.     yield 2
3.     yield 2
4.     yield 2
7. def func():
8.     yield 1
9.     yield 1
10.     yield 1
11.     yield from foo()
12.     yield 1
13.     yield 1
16. for item in func():
17.     print(item)

复制代码

1.3 深浅拷贝

• 浅拷贝
  
  
  
  • 不可变类型，不拷贝。
    1. import copy
    3. v1 = "武沛齐"
    4. print(id(v1)) # 140652260947312
    6. v2 = copy.copy(v1)
    7. print(id(v2)) # 140652260947312

    复制代码
    按理说拷贝v1之后，v2的内存地址应该不同，但由于python内部优化机制，内存地址是相同的，因为对不可变类型而言，如果以后修改值，会重新创建一份数据，不会影响原数据，所以，不拷贝也无妨。
    
  • 可变类型，只拷贝第一层。
    1. import copy
    3. v1 = ["武沛齐", "root", [44, 55]]
    4. print(id(v1))  # 140405837216896
    5. print(id(v1[2]))  # 140405837214592
    7. v2 = copy.copy(v1)
    8. print(id(v2))  # 140405837214784
    9. print(id(v2[2]))  # 140405837214592

    复制代码
  
  

• 深拷贝
  
  
  
  • 不可变类型，不拷贝
    1. import copy
    3. v1 = "武沛齐"
    4. print(id(v1))  # 140188538697072
    6. v2 = copy.deepcopy(v1)
    7. print(id(v2))  # 140188538697072

    复制代码
    特殊的元组：
    
    
    
    • 元组元素中无可变类型，不拷贝
      1. import copy
      3. v1 = ("武沛齐", "root")
      4. print(id(v1))  # 140243298961984
      6. v2 = copy.deepcopy(v1)
      7. print(id(v2))  # 140243298961984

      复制代码
    • 元组元素中有可变类型，找到所有【可变类型】或【含有可变类型的元组】   均拷贝一份
      1. import copy
      3. v1 = ("武沛齐", "root", [11, [44, 55], (11, 22), (11, [], 22), 33])
      4. v2 = copy.deepcopy(v1)
      6. print(id(v1))  # 140391475456384
      7. print(id(v2))  # 140391475456640
      9. print(id(v1[2]))  # 140352552779008
      10. print(id(v2[2]))  # 140352552920448
      12. print(id(v1[2][1]))  # 140642999940480
      13. print(id(v2[2][1]))  # 140643000088832
      15. print(id(v1[2][2]))  # 140467039914560
      16. print(id(v2[2][2]))  # 140467039914560
      18. print(id(v1[2][3]))  # 140675479841152
      19. print(id(v2[2][3]))  # 140675480454784

      复制代码
    
    
  • 可变类型，找到所有层级的 【可变类型】或【含有可变类型的元组】   均拷贝一份
    1. import copy
    3. v1 = ["武沛齐", "root", [11, [44, 55], (11, 22), (11, [], 22), 33]]
    4. v2 = copy.deepcopy(v1)
    6. print(id(v1))  # 140391475456384
    7. print(id(v2))  # 140391475456640
    9. print(id(v1[2]))  # 140352552779008
    10. print(id(v2[2]))  # 140352552920448
    12. print(id(v1[2][1]))  # 140642999940480
    13. print(id(v2[2][1]))  # 140643000088832
    15. print(id(v1[2][2]))  # 140467039914560
    16. print(id(v2[2][2]))  # 140467039914560
    18. print(id(v1[2][3]))  # 140675479841152
    19. print(id(v2[2][3]))  # 140675480454784

    复制代码
    1. import copy
    3. v1 = ["武沛齐", "root", [44, 55]]
    4. v2 = copy.deepcopy(v1)
    6. print(id(v1))  # 140405837216896
    7. print(id(v2))  # 140405837214784
    10. print(id(v1[2]))  # 140563140392256
    11. print(id(v2[2]))  # 140563140535744

    复制代码
  
  

2.阶段总结

3.考试题

• 一个大小为100G的文件 etl_log.txt，要读取文件中的内容，写出具体过程代码。
  

1. # 如果文件有多行
2. with open("etl_log.txt", mode="r", encoding="utf-8") as f:
3.     for line in f:
4.         print(line)

复制代码

1. # 文件只有一行
2. import os
4. file_size = os.path.getsize("etl_log.txt")
5. chunk_size = 0
6. with open("etl_log.txt", mode='r', encoding="utf-8") as f:
7.     while chunk_size < file_size:
8.         data = f.read(1)
9.         chunk_size += len(data)

复制代码

• 编写一个函数，这个函数接受一个文件夹名称作为参数，寻找文件夹中所有文件的路径并输入（包含嵌套）。
  

1. import os
4. def get_all_file(folder_name):
5.     data_list = os.walk(folder_name)
6.     for folder_path, folder_list, file_list in data_list:
7.         for file_name in file_list:
8.             file_path = os.path.join(folder_path, file_name)
9.             print(file_path)

复制代码

• 以下的代码数据的结果是什么？
  

1. def extend_list(val,data=[]):
2.         data.append(val)
3.         return data
5. list1 = extend_list(10)
6. list2 = extend_list(123,[])
7. list3 = extend_list("a")
9. print(list1,list2,list3)        # [10, 'a'] [123] [10, 'a']

复制代码

• python代码获取命令行参数。
  

1. import sys
2. print(sys.argv)

复制代码

• 简述深浅拷贝？
  

• 浅拷贝：
  
  
  
  • 可变类型，只拷贝第一层
    
  • 不可变类型：不拷贝
    
  
  
• 深拷贝：
  
  
  
  • 可变类型：找到所有层级的可变类型或含有可变类型的元组均拷贝一份
    
  • 不可变类型：不拷贝
    
  
  
• 元组比较特殊
  
  
  
  • 元组中无可变类型，不拷贝
    
  • 元组中有可变类型，会将所有的可变类型或含有可变类型的元组均拷贝一份
    
  
  

• 基于推导式一行代码生成1-100以内的偶数列表。
  

1. even_list = [i for i in range(101) if i % 2 == 0]
2. print(even_list)

复制代码

• 请把以下函数转化为python lambda匿名函数
  

1. def add(x,y):
2.    return x+y

复制代码

1. add = lambda x, y: x + y

复制代码

• 看代码写结果
  

1. def num():
2.    return [lambda x: i * x for i in range(4)]
4. result = [m(2) for m in num()]
5. print(result)        # [6, 6, 6, 6]

复制代码

• 列表推导式和生成器表达式 [i % 2 for i in range(10)] 和 (i % 2 for i in range(10)) 输出结果分别是什么？
  列表推导式的输出结果：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
  生成器表达式的输出结果：生成器的地址
  
• 写装饰器
  

1. # 写timer装饰器实现：计算fun函数执行时间，并将结果给 result，最终打印（不必使用datetime,使用time.time即可）。
3. @timer
4. def func():
5.     pass
7. result = func()
8. print(result)

复制代码

1. import time
2. import functools
5. def timer(origin):
6.     @functools.wrap(origin)
7.     def inner(*args, **kwargs):
8.         start = time.time()
9.         res = origin(*args, **kwargs)
10.         end = time.time()
11.         message = "耗时：{}".format(end - start)
12.         print(message)
13.         return res
15.     return inner
18. @timer
19. def func():
20.     pass
22. result = func()
23. print(result)

复制代码

• re的match和search区别？
  match会从所给文本的头开始匹配，如果不符合条件，直接返回none
  search会从所给文本中找到第一处匹配规则的文本，然后返回，没找到就返回none
  
• 什么是正则的贪婪匹配？或 正则匹配中的贪婪模式与非贪婪模式的区别？
  贪婪匹配就是会尽可能多的去匹配符合正则表达式的文本
  非贪婪匹配就是只要找到符合正则表达式的文本就返回
  
• sys.path.append("/root/mods")的作用？
  将"/root/mods"加入sys.path，那么项目就可以直接导入"/root/mods"下的模块和包。
  
• 写函数
  1. 有一个数据结构如下所示，请编写一个函数从该结构数据中返回由指定的 字段和对应的值组成的字典。如果指定字段不存在，则跳过该字段。
  2. DATA = {
  3.     "time": "2016-08-05T13:13:05",
  4.     "some_id": "ID1234",
  5.     "grp1": {"fld1": 1, "fld2": 2, },
  6.     "xxx2": {"fld3": 0, "fld4": 0.4, },
  7.     "fld6": 11,
  8.     "fld7": 7,
  9.     "fld46": 8
  10. }
  12. fields:由"|"连接的以fld开头的字符串, 如fld2|fld7|fld29  
  14. def select(fields):
  15.     print(DATA)
  16.     return result

  复制代码
  1. def select(fields):
  2.     result = {}
  3.     field_list = fields.split("|")
  4.     for field in field_list:
  5.         data = DATA.get(field)
  6.         if not data:
  7.             continue
  8.         result[field] = data
  9.     return result

  复制代码
• 编写函数，实现base62encode加密（62进制），例如：
  

1. 内部维护的数据有：0123456789AB..Zab..z(10个数字+26个大写字母+26个小写字母)。
2. 当执行函数：
3.     base62encode(1)，获取的返回值为1
4.     base62encode(61)，获取的返回值为z
5.     base62encode(62)，获取的返回值为10

复制代码

1. import string
2. import itertools
4. MAP = list(itertools.chain(string.digits, string.ascii_uppercase, string.ascii_lowercase))        # 生成内部维护的数据
6. def base62encode(data):
7.     total_count = len(MAP)
8.     position_value = []
9.     while data >= total_count:
10.         data, div = divmod(data, total_count)  # 得到余数和商
11.         position_value.insert(0, MAP[div])        # 取得MAP中对应的值放到列表最前面
12.     position_value.insert(0, MAP[data])
13.     res = "".join(position_value)
14.     return res

复制代码

• 基于列表推导式一行实现输出9*9乘法表。
  

1. print("\n".join([" ".join(["{}*{}={}".format(i, j, i * j) for i in range(1, 10) for j in range(i, 10)])]))

复制代码

来源:https://www.cnblogs.com/sbhglqy/p/18121003
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！