作业

1.迭代器

• 为什么要用迭代器

  • 对于字符串，列表，元组，我们可以使用迭代的方式迭代出其所有的元素，但是由于字典，集合，文件是没有索引的，若还想取出其内部的元素，则必须找出一个不依赖于索引的迭代方式，这就是迭代器

• 什么是可迭代对象

  • 可迭代的对象

    可迭代对象指的是具有内置__iter__方法的对象，即obj.__iter__，如下
    可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下
    'hello'.__iter__
    (1,2,3).__iter__
    [1,2,3].__iter__
    {'a':1}.__iter__
    {'a','b'}.__iter__
    open('a.txt').__iter__
    

• 迭代器对象

  可迭代对象执行Obj.__iter__得到的结果就是迭代器对象
  迭代器对象指的是既有obj.__iter__，又有obj.__next__方法的对象
  迭代器对象一定是可迭代对象，可迭代对象不一定是迭代器对象
  
  a={"a":2,"b":2}
  a_obj=a.__iter__()
  
  print (a_obj is a_obj.__iter__())
  while True:
      try:
          print (a_obj.__next__())
      except Exception:
          break
  

• 迭代器的优缺点

  优点：
  提供一种统一的，不依赖与索引的迭代方式
  惰性计算，节省内存
  缺点：
  无法获取长度，只能next完毕才能确定有几个值
  一次性的，只能往后走，不能往前退
  
  

2.生成器

• 什么是生成器

  只要函数内包括yield关键字，那么函数名（）得到的结果就是生成器，并且不会执行函数内代码
  

3.生产式

1.三元表达式
x=10
y=20
print (x if x>y else y)

2.列表生成式
lis=[i for i in range(10) if i>3]

3.字典生成式
keys=["name","age"]
values=["yqliu",20]
res=zip(keys,values)
dict1={k:v for k,v in res}

4.

4.异常处理

try:
    1/0
except Exception as e:
    print (e)

5.内置函数

1.enumerate
lis=["yqliu","nick","tank"]
for ind,name in enumerate(lis):
    print (ind,name)
    
2.eval把字符串的引号去掉,留下来的是什么就是什么
dict1='{"a":1}'
dict2=eval(dict1)
print (dict2,type(dict2))

3.time=__import__("time")
time.sleep(3)

6.面向过程编程

面向过程编程类似于流水线，一步一步往下走
优点：逻辑非常清晰
缺点：上一步错了，下一步跟着错

7.匿名函数

1.max
lis=[{'name': 'egon', 'sex': 'male', 'age': '18', 'salary': '3000'}, {'name': 'alex', 'sex': 'male', 'age': '38', 'salary': '30000'}, {'name': 'wupeiqi', 'sex': 'female', 'age': '28', 'salary': '20000'}, {'name': 'yuanhao', 'sex': 'female', 'age': '28', 'salary': '10000'}]

res=max(lis,key=lambda x:x["salary"])
res1=max(lis,key=lambda y:y['age'])
res2=filter(lambda item:int(item['age'])>29,lis)
res3=map(lambda item:item['name'].title(),lis)
print (list(res3))
res4=filter(lambda item:'a' not in item['name'],lis)
print (list(res4))

作业1

"""
egon male 18 3000
alex male 38 30000
wupeiqi female 28 20000
yuanhao female 28 10000
要求:
从文件中取出每一条记录放入列表中，列表的每个元素都是`{'name':'egon','sex':'male','age':18,'salary':3000}`的形式

1. 根据1得到的列表，取出薪资最高的人的信息
2. 根据1得到的列表，取出最年轻的人的信息
3. 根据1得到的列表，将每个人的信息中的名字映射成首字母大写的形式
4. 根据1得到的列表，过滤掉名字以a开头的人的信息
5. 使用递归打印斐波那契数列(前两个数的和得到第三个数，如：0 1 1 2 3 4 7...)
6. 一个嵌套很多层的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用递归取出所有的值

"""

with open('info.txt','r',encoding='utf-8') as fr:
    user_info_list=fr.read().split("\n")


keys=["name","sex","age","salary"]
lis=[]
for i in range(len(user_info_list)):
    res=zip(keys,user_info_list[i].split())
    lis.append({k:v for k,v in res})

print (lis)

res=max(lis,key=lambda x:x["salary"] ) #取出薪资最高的人的信息
print (res)
res1=min(lis,key=lambda x:x['age']) #取出最年轻的人的信息
print (res1)
res3=map(lambda item:item['name'].title(),lis) #将每个人的信息中的名字映射成首字母大写的形式
print (list(res3))
res4=filter(lambda item:'a' not in item['name'],lis)#过滤掉名字以a开头的人的信息
print (list(res4))

作业2

一个嵌套很多层的列表，如l=［1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]］，用递归取出所有的值

l=[1,2,[3,[4,5,6,[7,8,[9,10,[11,12,13,[14,15]]]]]]]

def func(lis):
    for i in lis:
        if type(i) is not list:
            print (i)
        else:
            func(i)

func(l)

作业3

使用递归打印斐波那契数列(前两个数的和得到第三个数，如：0 1 1 2 3 4 7...)

def func(n):
    if n == 1 or n == 2:
        return 1
    else:
        return func(n-1) + func(n-2)

print (func(20))
count=1
while count<20:
    print (func(count),end=' ')
    count+=1