跳转至

第二阶段考试题

  1. 一个大小为100G的文件 etl_log.txt，要读取文件中的内容，写出具体过程代码。
#文件只有一行的情况 多行也适用
import shutil
with open('video.csv',mode='rt',encoding='utf-8') as f_r,\
        open('video.csv.swap',mode='w',encoding='utf-8')as f_w:
    while True:
        line = f_r.read(1)
        if not line:
            break
        f_w.write(line)
        f_w.flush()

shutil.move("video.csv.swap",'video.csv')
  1. 编写一个函数，这个函数接受一个文件夹名称作为参数，寻找文件夹中所有文件的路径并输入（包含嵌套）。
import os
# 编写一个函数，这个函数接受一个文件夹名称作为参数，寻找文件夹中所有文件的路径并输出（包含嵌套）。
def lstree_folder(path):
    data = os.walk(path)
    for path, folder, file_list in data:
        for file in file_list:
            file_path = path + file
            print(file_path)


lstree_folder('/Users/kanghua/Downloads')
  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)
  1. python代码获取命令行参数。
import sys

print(sys.argv)
  1. 简述深浅拷贝？
深浅拷贝是针对可变类型来说的。
浅拷贝对可变类型拷贝是内存地址
深拷贝是把值拷贝过来，与原来的对象没有关系了
  1. 基于推导式一行代码生成1-100以内的偶数列表。
# 基于推导式一行代码生成1-100以内的偶数列表。
data = [i for i in range(1,101,2)]
print(data)
  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)
-------------------------------------------------
def num():
    return [lambda x: i * x for i in range(4)]

result = [m(2) for m in num()]

# [func,func,func,func] i=3
#[6,6,6,6]
print(result)
  1. 列表推导式和生成器表达式 [i % 2 for i in range(10)] 和 (i % 2 for i in range(10)) 输出结果分别是什么？
data = [i % 2 for i in range(10)]
# [0,1,0,1,0,1,0,1,0,1]
print(data)
data2=(i % 2 for i in range(10)) #generator
print(data2)

  1. 写装饰器

    # 写timer装饰器实现：计算fun函数执行时间，并将结果给 result，最终打印（不必使用datetime,使用time.time即可）。

@timer
def func():
    pass

result = func()
print(result) 
---------------------------------------------------
import time
def timer(func):
    def inner():
        start_time = time.time()
        func()
        stop_time = time.time()
        return stop_time - start_time
    return inner

@timer
def func():
    time.sleep(1)

result = func()
print(result)

  2. re的match和search区别？

    match 是从字符串开头匹配， 取第一个匹配成功的值， 否则返回none
search是从整个字符串进行匹配，取第一个匹配到的值 ， 匹配不到就返回none

  3. 什么是正则的贪婪匹配？或 正则匹配中的贪婪模式与非贪婪模式的区别？

    贪婪模式是以尽量多的匹配字符
非贪婪是以尽量少的匹配字符，（只要符和条件就结束），特点是 ？

  4. sys.path.append("/root/mods")的作用？

    将/root/mods 加入到sys.path,  在项目中直接导入这个目录里的模块和包

  5. 写函数

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

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: str):
    result = {}
    fields_list = fields.strip().split('|')
    for fields in fields_list:
        if DATA.get(fields):
            result[fields] = DATA.get(fields)
    return result

result = select('time|cca|fld6|grp1|aas|bbd')
print(result)

    import string
import itertools

# 生成 0-9 A-z 列表
print(string.digits)
print(string.ascii_uppercase)
print(string.ascii_lowercase)
#方法一
# data = []
# for i in string.digits:
#     data.append(i)
# for i in string.ascii_uppercase:
#     data.append(i)
# for i in string.ascii_lowercase:
#     data.append(i)
# print(data)
#方法二
# data = [item for item in itertools.chain(string.digits,string.ascii_uppercase,string.ascii_lowercase)]
# print(data)
#方法三
data = list(itertools.chain(string.digits, string.ascii_uppercase, string.ascii_lowercase))

def base62encode(num: int):
    count_num = len(data)
    postion_value = []
    while num >= count_num:
        num,remain = divmod(num,count_num)
        postion_value.insert(0,data[remain])
    postion_value.insert(0,data[num])
    result = ''.join(postion_value)
    return result

print(base62encode(2222312))
print(base62encode(3011))
print(base62encode(5011111))

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

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

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

# 基于列表推导式一行实现输出9*9乘法表。
data = '\n'.join([" ".join(['{}*{}={}'.format(i,j,i*j) for i in range(1,j+1)]) for j in range(1,10)])
print(data)