1. 写出Python查找一个变量的顺序 提示：4中作用域的顺序
#站在全局角度上找变量 : 先找全局 再找内置 #站在局部的角度上:先找局部 再全局 再内置
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 = [1, 2, 3, 4, ['a', 'b'],5] a[4].append('c') #修改对象a中的['a', 'b']数组对象 a = [1, 2, 3, 4, ['a', 'b','c'],5] print(id(a),id(b),id(c)) print('a = ', a) #a = [1, 2, 3, 4, ['a', 'b','c'],5] print('b = ', b) #a = [1, 2, 3, 4, ['a', 'b','c'],5]#b是把a赋值 print('c = ', c) #[1, 2, 3, 4, ['a', 'b','c']] #c是浅拷贝第一层列表地址独立，第二层和a用的是一个 print('d = ', d) #[1, 2, 3, 4, ['a', 'b']] #d是深拷贝，每一层都是独立的
3. 打印代码的值,并解释其原因。
a = 1 def fun(a): a = 2 return a print(fun(a)) # 等于2 因为在函数内部重新赋值了 print(a) # 等于1 因为只能使用全局变量，局部变量不能被全局变量引用
4. 打印代码的值,并解释其原因。
a = [] def fun(a): # 在python中传递参数 或者返回值 的时候 都是 使用 地址引用 a.append(1) # a=[1] 空列表中添加一个[1] return a print(fun(a)) #返回的是[1] print(a) #[1] 局部变量a传入的是一个可变数据类型[]空列表，局部变量只会指向那个列表的地址，列表内的数据变化时，全局也会=跟着变化
5. L = [x*x for x in range(10)] 和 g = (x*x for x in range(10))的结果分别为：
L=[0,1,4,...81]#列表推导式 g是一个生成器#生成器表达式
6. 将列表生成式中[]改成() 之后数据结构是否改变？请说明原因。
#数据类型发生变化，一个是列表推导式。另一个是生成器表达式
7. 创建一个闭包必须满足那些条件:
#内部函数被外部函数变量的引用
8. 通过函数化编程实现5的阶乘 提示：在函数中使用递归 例如函数中传入5，计算出5*4*3*2*1的结果
def f(n):#定义函数 if n == 1:return 1#如果n==1返回1 return n*f(n-1)#返回n*f(n-1 print(f(5))
9. 为此函数加装饰器
def foo():
print('hello foo')
（1）为此函数加一个装饰器，执行对应函数内容后，将当前时间写入一个文件做一个日志记录。
（2）改成参数装饰器，即可以根据调用时传的参数决定是否记录时间，比如@logger(True)
import time#引入time模块 def logger(Flag):#定义一个函数 def wrapper(func):# def inner(*args,**kwargs):#定义一个inner函数 ret = func(*args,**kwargs)#返回一个函数接收inner的参数 if Flag:#在函数运行之后if 为真 with open('log.log','a',encoding='utf-8') as f:#打开log.log文件以追加的形式 f.write('执行了%s函数,执行时间%s '%(func.__name__,time.strftime('%Y-%m-%d %H:%M:%S')))#写入日志 return ret#返回 ret return inner#返回 inner return wrapper#返回一个 wrapper @logger(False) #调用函数装饰器 # wrapper = logger(False) @wrapper def foo():print('hello foo') foo()
10. 写函数，将字典作为参数传进函数，检查传入字典的每一个value的长度,如果大于2，
那么仅保留前两个长度的内容，并将新内容返回给调用者。PS:字典中的value只能是字符串或列表
dic = {"k1": "v1v1", "k2": [11,22,33,44],'k3':'1'}
def func(dic):
for key in dic:
dic[key] = dic[key][:2]
return dic
print(func(dic))
11. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
def my_fun(lst):
return lst[1::2]
my_fun([1,2,3,'edj'])
12. 使用内置函数将 a="1234" 变为 [1, 2, 3, 4]
a="1234"
print(list(map(lambda n:int(n),a)))
13. 使用内置函数对obj = [25, 9, -23, 9, -11]按绝对值大小排序。
obj = [25, 9, -23, 9, -11]
print(sorted(obj,key=abs))
import time
14. 1）提供2017-11-1 2017-11-30 打印出他们之间的日期
例如：2017-11-01
2017-11-02
2017-11-03
struct_time = time.strptime('2017-11-1','%Y-%m-%d')
timestamp = time.mktime(struct_time)
struct_time = time.strptime('2017-11-30','%Y-%m-%d')
timestamp2 = time.mktime(struct_time)
while timestamp <= timestamp2:
struct_time = time.localtime(timestamp)
print(time.strftime('%Y-%m-%d', struct_time))
timestamp = timestamp + 60*60*24 # 加了一天
2）打印出 2017-11-1 2017-11-30的之间日期，并打印出各自对应的星期。
例如：2017-12-01 星期五
2017-12-02 星期六
2017-12-03 星期日
struct_time = time.strptime('2017-11-1','%Y-%m-%d')
timestamp = time.mktime(struct_time)
struct_time = time.strptime('2017-11-30','%Y-%m-%d')
timestamp2 = time.mktime(struct_time)
dic = {0:'星期一',1:'星期二',2:'星期三',3:'星期四',4:'星期五',5:'星期六',6:'星期日'}
while timestamp <= timestamp2:
struct_time = time.localtime(timestamp)
print('%s %s'%(time.strftime('%Y-%m-%d',struct_time),dic[struct_time.tm_wday]))
timestamp = timestamp + 60*60*24 # 加了一天
def fib(n):
a = 0
b = 1
yield 1
while b<n:
yield a+b
c = a
a = b
b = c+b
g = fib(21)
for n in g:print(n)
16. 读取文件a.txt,匹配文中所有ip地址,将所有ip地址加入到一个列表中,打印该列表。
import re
l = []
with open('a.txt') as f:
for line in f:
ret = re.findall(r'[d]+.[d]+.[d]+.[d]+',line)
l.extend(ret)
print(l)
17. s = '123.33sdhf3424.34fdg323.324',计算字符串中所有数字的和(使用正则)
本题结果应为：123.33+3424.34+323.32
import re
s = '123.33sdhf3424.34fdg323.324'
ret = re.findall('d+.d{0,2}',s)
print(sum([float(i) for i in ret]))
18. 正则替换：
1.将字符串中所有的数字换为大写字母A, 结果为 aakkAdddAkkA
result='aakk123ddd55kk66'
import re
ret = re.sub('d+','A',result)
print(ret)
2.将字符串的前4位数字转换为A
result='aakk123ddd55kk66'
import re
ret = re.sub('d','A',result,4)
print(ret)
19. 利用random模块随机生成四位验证码,包括字母和数字
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}
]
print(list(filter(lambda dic:dic['price']>100 ,portfolio)))
21. 怎么理解迭代器和生成器？生成器有什么特点？
生成器就是迭代器
迭代器的特点:遵循可迭代协议 惰性运算 可以节省内存
生成器: python用户可以写的迭代器
生成器函数 和 生成器表达式 是python程序员实现迭代器效果的主要途径
22. 函数的形参有哪几种方式，各自在什么情况下使用以及定义顺序？
位置参数 关键字(默认)参数 动态参数(*args,**kwargs)
位置参数 *args 默认参数 **kwargs
23. 输出以下函数的执行结果 : 默认参数的陷阱问题
def foo(a1,args = []):
print("args before = %s" % (args)) #[] [99999,10]
args.insert(0, 10)
args.insert(0, 99999)
print("args = %s " % (args)) #[99999,10] [99999,10,99999,10]
def main():
foo('a')
foo('b')
if __name__ == "__main__":
main()
24. 使用代码实现 9 * 9 乘法表 如：
1 x 1 = 1
1 x 2 = 2 2 x 2 = 4
1 x 3 = 3 2 x 3 = 6 3 x 3 = 9
1 x 4 = 4 2 x 4 = 8 3 x 4 = 12 4 x 4 = 16
1 x 5 = 5 2 x 5 = 10 3 x 5 = 15 4 x 5 = 20 5 x 5 = 25
1 x 6 = 6 2 x 6 = 12 3 x 6 = 18 4 x 6 = 24 5 x 6 = 30 6 x 6 = 36
1 x 7 = 7 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49
1 x 8 = 8 2 x 8 = 16 3 x 8 = 24 4 x 8 = 32 5 x 8 = 40 6 x 8 = 48 7 x 8 = 56 8 x 8 = 64
1 x 9 = 9 2 x 9 = 18 3 x 9 = 27 4 x 9 = 36 5 x 9 = 45 6 x 9 = 54 7 x 9 = 63 8 x 9 = 72 9 x 9 = 81
for i in range(1,10):
for j in range(1,i+1):
if i == j:
print('%s x %s = %2s'%(j,i,i*j))
else:
print('%s x %s = %2s' % (j, i, i * j),end=' ')
[print('%s x %s = %2s'%(j,i,i*j)) if i == j else print('%s x %s = %2s'%(j,i,i*j),end=' ')
for i in range(1,10) for j in range(1,i+1)]