[ python ] 练习作业

1. 写出Python查找一个变量的顺序 提示：4中作用域的顺序

本地作用域(local) --> 当前作用域被嵌入的本地作用域(enclsing locals) --> 全局/模块作用域(Global) --> 内置作用域(build-in)

2. Python里的拷贝，打印结果并解释。

https://www.cnblogs.com/hukey/p/9812035.html

3. 打印代码的值,并解释其原因。

a = 1


def fun(a): # 局部作用域中
    a = 2   # a 重新定义为2
    return a    # 首先在局部作用域中找，找到 a = 2返回


print(fun(a))   # 返回 a=2
print(a)    # 在本地全局环境中找，找到 a = 1

4. 打印代码的值,并解释其原因。

a = []


def fun(a):
    a.append(1)
    return a 


print(fun(a))   # a = [] a.append(1) = [1,]
print(a)    # a =[] 是可变数据类型

5. L = [x*x for x in range(10)] 和 g = (x*x for x in range(10))的结果分别为：

L = [x * x for x in range(10)]

print(L)  # list表达式，有多少值都会通过列表显示出来

g = (x*x for x in range(10))

print(g)    # 返回一个生成器，不会打印任何值，需要通过 next 或者 for循环进行遍历


执行结果：

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
<generator object <genexpr> at 0x000002632AA334C0>

6. 将列表生成式中[]改成() 之后数据结构是否改变？请说明原因。

[]：列表生成式，返回一个list列表，显示所有元素
(): 返回一个生成器，需要通过 next() 或 for 来遍历结果

7. 创建一个闭包必须满足那些条件:

    （1）必须要一个嵌套函数
    （2）嵌套函数必须引用外部函数中的变量
    
    提示：装饰器就是一个闭包函数

8. 通过函数化编程实现5的阶乘 提示：在函数中使用递归 例如函数中传入5，计算出5*4*3*2*1的结果

def func(n):
    if n == 1:
        return n
    return n * func(n - 1)


print(func(5))

9. 为此函数加装饰器

def log(func):
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res

    return wrapper


@log
def foo():
    print('hello foo')


foo()

10. 写函数，将字典作为参数传进函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
PS:字典中的value只能是字符串或列表

dic = {"k1": "v1v1", "k2": [11, 22, 33, 44]}


def func(dic):
    for k, v in dic.items():
        if len(v) > 2:
            dic[k] = v[:2]
    return dic

11. 写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

l1 = [0, 1, 2, 3, 4, 5, 6, 7]

f = l1[1::2]
print(f)


def func(*args):
    li = args[0]
    return li[1::2]


print(func(l1))

12. 使用内置函数将 a="1234" 变为 [1, 2, 3, 4]

a = '1234'

l = list(map(int, a))
print(l)

13. 使用内置函数对obj = [25, 9, -23, 9, -11]按绝对值大小排序。

obj = [25, 9, -23, 9, -11]

print(sorted(obj, key=abs))

14.
1）提供2017-11-1 2017-11-30 打印出他们之间的日期

import time

start_time = time.mktime(time.strptime('2017-11-1', '%Y-%m-%d'))
end_time = time.mktime(time.strptime('2017-11-30', '%Y-%m-%d'))

while end_time >= start_time:
    print(time.strftime('%Y-%m-%d', time.localtime(start_time)))
    start_time += 86400.00

2）打印出 2017-11-1 2017-11-30的之间日期，并打印出各自对应的星期。

import time

start_time = time.mktime(time.strptime('2017-11-1', '%Y-%m-%d'))
end_time = time.mktime(time.strptime('2017-11-30', '%Y-%m-%d'))

while end_time >= start_time:
    w_dic = {0: '星期一', 1: '星期二', 2: '星期三', 3: '星期四', 4: '星期五', 5: '星期六', 6: '星期日'}
    print(time.strftime('%Y-%m-%d', time.localtime(start_time)), w_dic[time.localtime(start_time).tm_wday])
    start_time += 86400.00

15. 使用生成器编写foo函数，调用该函数foo(21)产生如下结果（斐波那契数列），1,1,2,3,5,8,13,21

def foo(n):
    a, b = 0, 1
    while b < n:
        yield b
        a, b = b, a+b


f = foo(21)

16. 读取文件a.txt,匹配文中所有ip地址,将所有ip地址加入到一个列表中,打印该列表。

import re
with open('ip.txt') as f:
    i_list = []
    for line in f:
        ip_list = re.findall(r'((([01]{0,1}d{0,1}d|2[0-4]d|25[0-5]).){3}([01]{0,1}d{0,1}d|2[0-4]d|25[0-5]))',
                             line)
        for ip in ip_list:
            i_list.append(ip[0])

print(i_list)

17. s = '123.33sdhf3424.34fdg323.324',计算字符串中所有数字的和

import re

s = '123.33sdhf3424.34fdg323.324'

r = re.findall("d*.d*", s)

n = 0
for num in r:
    n += float(num)

print(n)

18. 正则替换：

1.将字符串中所有的数字换为大写字母A, 结果为 aakkAdddAkkA
result=aakk123ddd55kk66

import re
result='aakk123ddd55kk66'
r = re.sub("d+", 'A', result)  # re.sub(匹配到的正则，'替换的内容', '需要被替换的内容')
print(r)

2.将字符串的前4位数字转换为A

import re
result='aakk123ddd55kk66'
r = re.sub("d", 'A', result, 4)  # re.sub(匹配到的正则，'替换的内容', '需要被替换的内容')
print(r)

19. 利用random模块随机生成四位验证码,包括字母和数字

import random

code = ''
for i in range(4):
    ran_int = random.randint(1, 9)
    ran_str = chr(random.randint(65, 90))
    n = random.choice([str(ran_int), ran_str])
    code = ''.join([code, n])

print(code)

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

f = filter(lambda x: x['price']> 100, portfolio)
print(list(f))

21. 怎么理解迭代器和生成器？生成器有什么特点？

可迭代的：
    必须包含 __iter__ 方法

迭代器：
    必须要有 __iter__ 和 __next__ 方法

迭代器一定是可迭代的，可迭代的不一定是迭代器

生成器：

生成器是一种特殊的迭代器，生成器自动实现了“迭代器协议”（即__iter__和__next__方法），不需要在手动实现这两方法
生成器在迭代的过程中可以改变当前迭代值，而修改普通迭代器的当前迭代值往往会发生异常
具有yield关键字的函数都是生成器

22. 函数的形参有哪几种方式，各自在什么情况下使用以及存放顺序？

位置参数：func(a)     # 任何类型
默认参数：func(a=1)    # 不传参数时，使用默认值
可变参数：func(*args)    # 传入list、tuple 类型
关键字参数：func(**kwargs)    # 传入字典类型

func(a, b=1, *args, **kwargs)

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

24. 实现9*9乘法口诀表

for i in range(1, 10):
    for j in range(1, i+1):
        print('{}x{}={}	'.format(j, i, i*j), end='')
    print()