一. 回答题
1. 写出Python查找一个变量的顺序 提示：4中作用域的顺序
本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）
2. Python里的拷贝，打印结果并解释。
import copy
a = [1, 2, 3, 4, [‘a‘, ‘b‘]] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append(‘c‘) #修改对象a中的[‘a‘, ‘b‘]数组对象
print(‘a = ‘, a)
print(‘b = ‘, b)
print(‘c = ‘, c)
print(‘d = ‘, d)
a = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
b = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
c = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]]
d = [1, 2, 3, 4, [‘a‘, ‘b‘]]
3. 打印代码的值,并解释其原因。
a = 1
def fun(a):
a = 2
return a
print(fun(a))
print(a)
# 2 1
4. 打印代码的值,并解释其原因。
a = []
def fun(a):
a.append(1)
return a
print(fun(a))
print(a)
# [1] [1]
5. L = [x*x for x in range(10)] 和 g = (x*x for x in range(10))的结果分别为：
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] <generator object <genexpr> at 0x0000028F8B774200>
6. 将列表生成式中[]改成() 之后数据结构是否改变？请说明原因。
是，从列表变为生成器
通过列表生成式，可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含百万元素的列表，不仅是占用很大的内存空间，如：我们只需要访问前面的几个元素，后面大部分元素所占的空间都是浪费的。因此，没有必要创建完整的列表（节省大量内存空间）。在Python中，我们可以采用生成器：边循环，边计算的机制—>generator
7. 创建一个闭包必须满足那些条件:
1.必须有一个内嵌函数
2.内嵌函数必须引用外部函数中的变量
8. 通过函数化编程实现5的阶乘 提示：在函数中使用递归 例如函数中传入5，计算出5*4*3*2*1的结果
def func(n):
if n == 1:
return 1
else:
return n * func(n - 1)
obj = func(3)
print(obj)
9. 为此函数加装饰器
def foo():
print(‘hello foo‘)
（1）为此函数加一个装饰器，执行对应函数内容后，将当前时间写入一个文件做一个日志记录。
（2）改成参数装饰器，即可以根据调用时传的参数决定是否记录时间，比如@logger(True)
import time
def init(func):
def wrapper(*args,**kwargs):
a= str(time.time()) + "执行%s\n" % func
with open("record.txt","a+") as f:
f.write(a)
func(*args,**kwargs)
return wrapper
@init
def foo():
print(‘hello foo‘)
return()
foo()
import time
def auth(flag):
def init(func):
def wrapper(*args,**kwargs):
if flag == True:
a= str(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) + "执行%s\n" % func
with open("record.txt","a+") as f:
f.write(a)
func(*args,**kwargs)
return wrapper
return init
@auth(True)
def foo():
print(‘hello foo‘)
foo()
10. 写函数，将字典作为参数传进函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。PS:字典中的value只能是字符串或列表
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
def my_dict(dic):
for key in dic:
if len(dic[key]) > 2:
dic[key] = dic[key][0:2]
else:
continue
return dic
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
res = my_dict(dic)
print(res)
11. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
def my_fun(func):
my_count = 0
func1 = []
for i in func:
my_count = my_count + 1
if my_count % 2 == 0:
func1.append(i)
print(func1)
my_fun([1,2,3,‘edj‘])
12. 使用内置函数将 a="1234" 变为 [1, 2, 3, 4]
list(map(int, ‘1234‘))
13. 使用内置函数对obj = [25, 9, -23, 9, -11]按绝对值大小排序。
sorted(obj,key=abs)
14. 1）提供2017-11-1 2017-11-30 打印出他们之间的日期
例如：2017-11-01
2017-11-02
2017-11-03
import time
start_time = time.mktime(time.strptime("2017-11-01","%Y-%m-%d"))
end_time = time.mktime(time.strptime("2017-12-01","%Y-%m-%d"))
while start_time <= end_time:
print(time.strftime("%Y-%m-%d",time.localtime(start_time)))
start_time += 86400.0
2）打印出 2017-11-1 2017-11-30的之间日期，并打印出各自对应的星期。
例如：2017-12-01 星期五
2017-12-02 星期六
2017-12-03 星期日
import time
start_time = time.mktime(time.strptime("2017-12-01","%Y-%m-%d"))
end_time = time.mktime(time.strptime("2018-1-17","%Y-%m-%d"))
w_dic = {"0":"星期日","1":"星期一","2":"星期二","3":"星期三","4":"星期四","5":"星期五","6":"星期六"}
while start_time <= end_time:
date_num_mode = time.strftime("%Y-%m-%d %w",time.localtime(start_time))
date_ymd,date_w = date_num_mode.split(" ")
print(date_ymd,w_dic[date_w])
start_time += 86400.0
15. 使用生成器编写foo函数，调用该函数foo(21)产生如下结果（斐波那契数列），1,1,2,3,5,8,13,21
def fib(max):
a = 0
b = 1
while b<=max:
yield b
b,a = a+b,b
for i in fib(21):
print(i,end=‘ ‘)
16. 读取文件a.txt,匹配文中所有ip地址,将所有ip地址加入到一个列表中,打印该列表。
import re
li = []
with open("a","r") as f:
for line in f:
result = re.findall(r‘\d+\.\d+\.\d+\.\d+‘, line)
if result:
li += result
print(li)
17. s = ‘123.33sdhf3424.34fdg323.324‘,计算字符串中所有数字的和
本题结果应为：123.33+3424.34+323.32
import re
s = ‘123.33sdhf3424.34fdg323.324sss12‘
obj = re.findall(r‘\d+\.\d+|\d+‘,s)
start = 0
for i in obj:
start += float(i)
print(start)
18. 正则替换：
1.将字符串中所有的数字换为大写字母A, 结果为 aakkAdddAkkA
result=aakk123ddd55kk66
print(re.sub("\d+","A",result))
2.将字符串的前4位数字转换为A
print(re.sub("\d","A",result,4))
19. 利用random模块随机生成四位验证码,包括字母和数字
import random
checkcode = ‘‘
for i in range(4):
current = random.randrange(0,4)
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print(checkcode)
20. 如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格,用filter过滤出，单价大于100的股票有哪些
portfolio = [
{‘name‘: ‘IBM‘, ‘shares‘: 100, ‘price‘: 91.1},
{‘name‘: ‘AAPL‘, ‘shares‘: 50, ‘price‘: 543.22},
{‘name‘: ‘FB‘, ‘shares‘: 200, ‘price‘: 21.09},
{‘name‘: ‘HPQ‘, ‘shares‘: 35, ‘price‘: 31.75},
{‘name‘: ‘YHOO‘, ‘shares‘: 45, ‘price‘: 16.35},
{‘name‘: ‘ACME‘, ‘shares‘: 75, ‘price‘: 115.65}
]
name = list(filter(lambda x:x["price"] > 100,portfolio))
print(name)
21. 怎么理解迭代器和生成器？生成器有什么特点？
22. 函数的形参有哪几种方式，各自在什么情况下使用以及存放顺序？
23. 如下输出以下函数的执行结果
def foo(a1, args = []):
print("args before = %s" % (args))
args.insert(0, 10)
args.insert(0, 99999)
print("args = %s " % (args))
def main():
foo(‘a‘)
foo(‘b‘)
if __name__ == "__main__":
main()
args before = []
args = [99999, 10]
args before = [99999, 10]
args = [99999, 10, 99999, 10]
24. 解释一下是否会报错，原因是什么？要是不报错打印什么值？报错的可以怎么改就不报错
1).
def test():
print(luffy)
luffy = "the king of sea."
2).
def test():
print(luffy)
luffy = ‘e‘
luffy = "the king of sea."
3).
def test():
luffy = ‘e‘
print(luffy)
luffy = "the king of sea."
4).
def func(a,**kwargs):
print(kwargs)
print(a)
for k,v in kwargs.items():
print(k,v)
func({"name":"alex"})
结果：{‘name‘: ‘alex‘}
{}
name alex
25. 实现9*9乘法口诀表
for i in range(1,10):
for j in range(1,10):
print(j, "x", i, "=", i * j,"\t",end="")
if i==j:
print("")
break
