day13-阶段总结
1.知识补充1.1 nolocal关键字
在之前的课程中，我们学过global关键字。
name = 'root'
def outer():
name = "武沛齐"
def inner():
global name
name = 123
inner()
print(name) # 武沛齐
outer()
print(name) # 123其实，还有一个nolocal关键字，用的比较少，此处作为了解即可。
name = 'root'
def outer():
name = "武沛齐"
def inner():
nonlocal name
name = 123
inner()
print(name) # 123
outer()
print(name) # rootname = 'root'
def outer():
name = 'alex'
def func():
name = "武沛齐"
def inner():
nonlocal name
name = 123
inner()
print(name) # 123
func()
print(name) # alex
outer()
print(name) # rootname = 'root'
def outer():
name = 'alex'
def func():
nonlocal name
name = "武沛齐"
def inner():
nonlocal name
name = 123
inner()
print(name) # 123
func()
print(name) # 123
outer()
print(name) # root1.2 yield from
在生成器部分我们了解了yield关键字，其在python3.3之后有引入了一个yield from。
def foo():
yield 2
yield 2
yield 2
def func():
yield 1
yield 1
yield 1
yield from foo()
yield 1
yield 1
for item in func():
print(item)1.3 深浅拷贝
[*]浅拷贝
[*]不可变类型，不拷贝。
import copy
v1 = "武沛齐"
print(id(v1)) # 140652260947312
v2 = copy.copy(v1)
print(id(v2)) # 140652260947312按理说拷贝v1之后，v2的内存地址应该不同，但由于python内部优化机制，内存地址是相同的，因为对不可变类型而言，如果以后修改值，会重新创建一份数据，不会影响原数据，所以，不拷贝也无妨。
[*]可变类型，只拷贝第一层。
import copy
v1 = ["武沛齐", "root", ]
print(id(v1))# 140405837216896
print(id(v1))# 140405837214592
v2 = copy.copy(v1)
print(id(v2))# 140405837214784
print(id(v2))# 140405837214592
[*]深拷贝
[*]不可变类型，不拷贝
import copy
v1 = "武沛齐"
print(id(v1))# 140188538697072
v2 = copy.deepcopy(v1)
print(id(v2))# 140188538697072特殊的元组：
[*]元组元素中无可变类型，不拷贝
import copy
v1 = ("武沛齐", "root")
print(id(v1))# 140243298961984
v2 = copy.deepcopy(v1)
print(id(v2))# 140243298961984
[*]元组元素中有可变类型，找到所有【可变类型】或【含有可变类型的元组】 均拷贝一份
import copy
v1 = ("武沛齐", "root", , (11, 22), (11, [], 22), 33])
v2 = copy.deepcopy(v1)
print(id(v1))# 140391475456384
print(id(v2))# 140391475456640
print(id(v1))# 140352552779008
print(id(v2))# 140352552920448
print(id(v1))# 140642999940480
print(id(v2))# 140643000088832
print(id(v1))# 140467039914560
print(id(v2))# 140467039914560
print(id(v1))# 140675479841152
print(id(v2))# 140675480454784
[*]可变类型，找到所有层级的 【可变类型】或【含有可变类型的元组】 均拷贝一份
import copy
v1 = ["武沛齐", "root", , (11, 22), (11, [], 22), 33]]
v2 = copy.deepcopy(v1)
print(id(v1))# 140391475456384
print(id(v2))# 140391475456640
print(id(v1))# 140352552779008
print(id(v2))# 140352552920448
print(id(v1))# 140642999940480
print(id(v2))# 140643000088832
print(id(v1))# 140467039914560
print(id(v2))# 140467039914560
print(id(v1))# 140675479841152
print(id(v2))# 140675480454784import copy
v1 = ["武沛齐", "root", ]
v2 = copy.deepcopy(v1)
print(id(v1))# 140405837216896
print(id(v2))# 140405837214784
print(id(v1))# 140563140392256
print(id(v2))# 140563140535744
2.阶段总结
3.考试题
[*]一个大小为100G的文件 etl_log.txt，要读取文件中的内容，写出具体过程代码。
# 如果文件有多行
with open("etl_log.txt", mode="r", encoding="utf-8") as f:
for line in f:
print(line)# 文件只有一行
import os
file_size = os.path.getsize("etl_log.txt")
chunk_size = 0
with open("etl_log.txt", mode='r', encoding="utf-8") as f:
while chunk_size < file_size:
data = f.read(1)
chunk_size += len(data)
[*]编写一个函数，这个函数接受一个文件夹名称作为参数，寻找文件夹中所有文件的路径并输入（包含嵌套）。
import os
def get_all_file(folder_name):
data_list = os.walk(folder_name)
for folder_path, folder_list, file_list in data_list:
for file_name in file_list:
file_path = os.path.join(folder_path, file_name)
print(file_path)
[*]以下的代码数据的结果是什么？
def extend_list(val,data=[]):
data.append(val)
return data
list1 = extend_list(10)
list2 = extend_list(123,[])
list3 = extend_list("a")
print(list1,list2,list3) #
[*]python代码获取命令行参数。
import sys
print(sys.argv)
[*]简述深浅拷贝？
[*]浅拷贝：
[*]可变类型，只拷贝第一层
[*]不可变类型：不拷贝
[*]深拷贝：
[*]可变类型：找到所有层级的可变类型或含有可变类型的元组均拷贝一份
[*]不可变类型：不拷贝
[*]元组比较特殊
[*]元组中无可变类型，不拷贝
[*]元组中有可变类型，会将所有的可变类型或含有可变类型的元组均拷贝一份
[*]基于推导式一行代码生成1-100以内的偶数列表。
even_list =
print(even_list)
[*]请把以下函数转化为python lambda匿名函数
def add(x,y):
return x+yadd = lambda x, y: x + y
[*]看代码写结果
def num():
return
result =
print(result) #
[*]列表推导式和生成器表达式 和 (i % 2 for i in range(10)) 输出结果分别是什么？
列表推导式的输出结果：
生成器表达式的输出结果：生成器的地址
[*]写装饰器
# 写timer装饰器实现：计算fun函数执行时间，并将结果给 result，最终打印（不必使用datetime,使用time.time即可）。
@timer
def func():
pass
result = func()
print(result)import time
import functools
def timer(origin):
@functools.wrap(origin)
def inner(*args, **kwargs):
start = time.time()
res = origin(*args, **kwargs)
end = time.time()
message = "耗时：{}".format(end - start)
print(message)
return res
return inner
@timer
def func():
pass
result = func()
print(result)
[*]re的match和search区别？
match会从所给文本的头开始匹配，如果不符合条件，直接返回none
search会从所给文本中找到第一处匹配规则的文本，然后返回，没找到就返回none
[*]什么是正则的贪婪匹配？或 正则匹配中的贪婪模式与非贪婪模式的区别？
贪婪匹配就是会尽可能多的去匹配符合正则表达式的文本
非贪婪匹配就是只要找到符合正则表达式的文本就返回
[*]sys.path.append("/root/mods")的作用？
将"/root/mods"加入sys.path，那么项目就可以直接导入"/root/mods"下的模块和包。
[*]写函数
有一个数据结构如下所示，请编写一个函数从该结构数据中返回由指定的 字段和对应的值组成的字典。如果指定字段不存在，则跳过该字段。
DATA = {
"time": "2016-08-05T13:13:05",
"some_id": "ID1234",
"grp1": {"fld1": 1, "fld2": 2, },
"xxx2": {"fld3": 0, "fld4": 0.4, },
"fld6": 11,
"fld7": 7,
"fld46": 8
}
fields:由"|"连接的以fld开头的字符串, 如fld2|fld7|fld29
def select(fields):
print(DATA)
return resultdef select(fields):
result = {}
field_list = fields.split("|")
for field in field_list:
data = DATA.get(field)
if not data:
continue
result = data
return result
[*]编写函数，实现base62encode加密（62进制），例如：
内部维护的数据有：0123456789AB..Zab..z(10个数字+26个大写字母+26个小写字母)。
当执行函数：
base62encode(1)，获取的返回值为1
base62encode(61)，获取的返回值为z
base62encode(62)，获取的返回值为10import string
import itertools
MAP = list(itertools.chain(string.digits, string.ascii_uppercase, string.ascii_lowercase)) # 生成内部维护的数据
def base62encode(data):
total_count = len(MAP)
position_value = []
while data >= total_count:
data, div = divmod(data, total_count)# 得到余数和商
position_value.insert(0, MAP) # 取得MAP中对应的值放到列表最前面
position_value.insert(0, MAP)
res = "".join(position_value)
return res
[*]基于列表推导式一行实现输出9*9乘法表。
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】 我们会及时删除侵权内容，谢谢合作！
页:
[1]