瓜瓜头条

day13-阶段总结

2024-04-08 16:50 由 死不悔改奇男子 发表于 #后端开发

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)	# root

name = '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)	# root


name = '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)	# root

1.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", [44, 55]]
print(id(v1))  # 140405837216896
print(id(v1[2]))  # 140405837214592

v2 = copy.copy(v1)
print(id(v2))  # 140405837214784
print(id(v2[2]))  # 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, [44, 55], (11, 22), (11, [], 22), 33])
v2 = copy.deepcopy(v1)

print(id(v1))  # 140391475456384
print(id(v2))  # 140391475456640

print(id(v1[2]))  # 140352552779008
print(id(v2[2]))  # 140352552920448

print(id(v1[2][1]))  # 140642999940480
print(id(v2[2][1]))  # 140643000088832

print(id(v1[2][2]))  # 140467039914560
print(id(v2[2][2]))  # 140467039914560

print(id(v1[2][3]))  # 140675479841152
print(id(v2[2][3]))  # 140675480454784

    • 可变类型，找到所有层级的 【可变类型】或【含有可变类型的元组】 均拷贝一份

      import copy

v1 = ["武沛齐", "root", [11, [44, 55], (11, 22), (11, [], 22), 33]]
v2 = copy.deepcopy(v1)

print(id(v1))  # 140391475456384
print(id(v2))  # 140391475456640

print(id(v1[2]))  # 140352552779008
print(id(v2[2]))  # 140352552920448

print(id(v1[2][1]))  # 140642999940480
print(id(v2[2][1]))  # 140643000088832

print(id(v1[2][2]))  # 140467039914560
print(id(v2[2][2]))  # 140467039914560

print(id(v1[2][3]))  # 140675479841152
print(id(v2[2][3]))  # 140675480454784

      import copy

v1 = ["武沛齐", "root", [44, 55]]
v2 = copy.deepcopy(v1)

print(id(v1))  # 140405837216896
print(id(v2))  # 140405837214784


print(id(v1[2]))  # 140563140392256
print(id(v2[2]))  # 140563140535744

2.阶段总结

3.考试题

  1. 一个大小为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)
  1. 编写一个函数，这个函数接受一个文件夹名称作为参数，寻找文件夹中所有文件的路径并输入（包含嵌套）。
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)
  1. 以下的代码数据的结果是什么？
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)	# [10, 'a'] [123] [10, 'a']
  1. python代码获取命令行参数。
import sys
print(sys.argv)
  1. 简述深浅拷贝？
  • 浅拷贝：
    • 可变类型，只拷贝第一层
    • 不可变类型：不拷贝
  • 深拷贝：
    • 可变类型：找到所有层级的可变类型或含有可变类型的元组均拷贝一份
    • 不可变类型：不拷贝
  • 元组比较特殊
    • 元组中无可变类型，不拷贝
    • 元组中有可变类型，会将所有的可变类型或含有可变类型的元组均拷贝一份
  1. 基于推导式一行代码生成1-100以内的偶数列表。
even_list = [i for i in range(101) if i % 2 == 0]
print(even_list)
  1. 请把以下函数转化为python lambda匿名函数
def add(x,y):
   return x+y

add = lambda x, y: x + y
  1. 看代码写结果
def num():
   return [lambda x: i * x for i in range(4)]

result = [m(2) for m in num()]
print(result)	# [6, 6, 6, 6]
  1. 列表推导式和生成器表达式 [i % 2 for i in range(10)] 和 (i % 2 for i in range(10)) 输出结果分别是什么？
    列表推导式的输出结果：[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
    生成器表达式的输出结果：生成器的地址
  2. 写装饰器
# 写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)

  1. re的match和search区别？
    match会从所给文本的头开始匹配，如果不符合条件，直接返回none
    search会从所给文本中找到第一处匹配规则的文本，然后返回，没找到就返回none

  2. 什么是正则的贪婪匹配？或 正则匹配中的贪婪模式与非贪婪模式的区别？
    贪婪匹配就是会尽可能多的去匹配符合正则表达式的文本
    非贪婪匹配就是只要找到符合正则表达式的文本就返回

  3. sys.path.append("/root/mods")的作用？
    将"/root/mods"加入sys.path，那么项目就可以直接导入"/root/mods"下的模块和包。

  4. 写函数

    有一个数据结构如下所示，请编写一个函数从该结构数据中返回由指定的 字段和对应的值组成的字典。如果指定字段不存在，则跳过该字段。
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 result

    def select(fields):
    result = {}
    field_list = fields.split("|")
    for field in field_list:
        data = DATA.get(field)
        if not data:
            continue
        result[field] = data
    return result

  5. 编写函数，实现base62encode加密（62进制），例如：

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

import 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[div])	# 取得MAP中对应的值放到列表最前面
    position_value.insert(0, MAP[data])
    res = "".join(position_value)
    return res
  1. 基于列表推导式一行实现输出9*9乘法表。
print("\n".join([" ".join(["{}*{}={}".format(i, j, i * j) for i in range(1, 10) for j in range(i, 10)])]))

热门相关：极品妖孽归来   学霸，你女朋友掉了   勇闯天涯   明天和意外   鬼喊抓鬼