第三次测试

 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)]