4月2日 python学习总结-CSDN博客

昨天内容回顾：

1、迭代器

　　可迭代对象：只要内置有__iter__方法的都是可迭代的对象

　　　　　　　　既有__iter__,又有__next__方法

　　调用__iter__方法==》得到内置的迭代器对象

　　　　调用__next__方法==》得到下一个值

for 循环机制

      for item in 可迭代对象：
            pass

　　　　先调用对象的__iter__方法得到迭代器，再调用__next__方法，取出下一个值

优点：

提供了一种不依赖索引的取值方式
同一时间在内存中只存在一个值，节省内存空间

缺点：

取值麻烦
一次性。只能往后取不能往前取，取完抛出StopIteration

2、生成器

　　　　函数内有yield 关键字，再调用函数不立刻执行，会得到一个返回值，该返回值就是生成器，生成器本身就是迭代器

　　　yield 功能

1. 可返回多次值

提供了一种自定义迭代器的方法

#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')

g=func()
print(g) #<generator object func at 0x0000000002184360>

3、面向过程编程　

　　面向过程的核心是过程二字，过程指的是解决问题的步骤，既先干什么再干什么　　

　　基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

当日学习总结：

1、三元表达式

 res= x if  x>y else y      # x>y 成立 则返回x,否则返回y

2、函数递归

函数的递归调用，在函数调用过程中，又直接或间接的调用了函数本身
python递归有层数限制，默认限制为1000，可自定义，用 sys.setrecursionlimit()方法
递归分为回溯和递推两部分，回溯一定要在满足某种条件的情况下结束回溯，否则无限递归导致死机

　　递归总结：

一定要有明确的结束条件
每进入下一层地柜问题规模都应该减少
python没有尾递归优化

3、匿名函数

匿名函数就是没有名字的函数
用 lambda定义
自带return 不用自己写
匿名函数不会单独使用，通常与内置函数一起使用
```
#输出x的n次方
f=lambda x,n :x**n
print(f(2,3)) #8
```

　强调：

匿名函数的目的就是没有名字，给匿名函数赋值给一个名字是无意义的
匿名函数的参数规则、作用域关系都与有名函数一样
匿名函数的函数体通常是一个表达式，该表达式必须有返回值

4、匿名函数应用：

max(), min(), sorted(), map(), reduce(), filter()

salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

#求工资最高的那个人是谁
max(salaries,key=lambda x:salaries[x])
#求工资最低的那个人是谁
min(salaries,key=lambda x:salaries[x])
#按薪资高低排序
sorted(salaries,key=lambda x:salaries[x])

#reduce 并  在python2中内置，python3中要导入
 from functools import reduce
 num=['my','name','is','alex']
 res=reduce(lambda x,y: x+' '+y,num,'a ')
 print(res)

#filter过滤 只留下结果为True的元素
x=[0,3,5,8,10,4]
res=filter(lambda x: x<8 ,x)
print(list(res))

5、其他常用方法：

print(divmod(20,3))   #20除3.返回商和余数   输出为（6，2）

print(all(x))       #迭代器中元素全部为Ture 则返回Ture 
print(any(x))     #迭代器中存在元素为Ture 则返回Ture 

print(bin(30))    #十进制转二进制
print(oct(30))    #十进制转八进制
print(hex(30))    #十进制转十六进制

print(chr(90))     #数字转为ASCII码对应字符
print(ord('A')  )   #字符ASCII码对应数字

res=eval('[1,2,3,4,4]')    #eval 用于取出字符串中的表达式
print(res)

c=1
print(globals())    #查看全局作用域中的名字与值的绑定关
hash([3])

print(help(all))     #查看帮助文档

　6、作业

'''
4月2日作业：
'''
'''
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}的形式
'''

f=open('E:\\test.txt','r',encoding='utf-8')
date=f.read()
useinfo=date.split('\t\n')
title=['name','sex','age','salary']
useinfos=[]
for suse in useinfo:
    suse.strip('\n\n\t')
    use=suse.split()
    if not use:
        continue
    info={}.fromkeys(['name','sex','age','salary'],None)
    for i in range(4):
        info[title[i]]=use[i]
    useinfos.append(info)
print('1、文件中取出的信息列表：')
print('\t',useinfos)

'''
2 根据1得到的列表,取出薪资最高的人的信息

'''

max_sal=max(useinfos,key=lambda x:x['salary'])
print('2、薪资最高的人信息：')
print('\t',max_sal)

'''
3 根据1得到的列表,取出最年轻的人的信息

'''
min_sal=min(useinfos,key=lambda x:x['age'])
print('3、年龄最小的人的信息：')
print('\t',min_sal)

'''
4 根据1得到的列表,将每个人的信息中的名字映射成首字母大写的形式

'''

for iter in useinfos:
    iter.update({'name':iter['name'].capitalize()})
print('4、名字影射成首字母大写：')
print('\t',list(useinfos))

name_type=map(lambda x : x['name'].capitalize() ,useinfos)
print('4、名字影射成首字母大写：')
print('\t',list(name_type))

'''
5 根据1得到的列表,过滤掉名字以a开头的人的信息
	
'''
filter_name=filter(lambda x : x['name'][0]!='a' ,useinfos)
print('5、过滤掉首字母为a的人的信息后结果：')
print('\t',list(filter_name))

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

def my_sun(a,b,stop):
    if a > stop:
        return
    print(a, end= ' ')
    my_sun(b, a + b,stop)
print('6、使用递归打印斐波那契数列: ')
my_sun(0, 1, 10)
print()
'''
7、 一个嵌套很多层的列表，如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 tell(l):
     for item in l:
         if type(item) is not list:
                 print(item,end=' ')
         else:
                 tell(item)
print('7、用递归取出一个嵌套很多层的列表的值： ')
tell(l)

"E:\Python 3.6.4\python.exe" F:/python/object/days2/lyj_0402.py
1、文件中取出的信息列表：
	 [{'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'}]
2、薪资最高的人信息：
	 {'name': 'alex', 'sex': 'male', 'age': '38', 'salary': '30000'}
3、年龄最小的人的信息：
	 {'name': 'egon', 'sex': 'male', 'age': '18', 'salary': '3000'}
4、名字影射成首字母大写：
	 [{'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'}]
4、名字影射成首字母大写：
	 ['Egon', 'Alex', 'Wupeiqi', 'Yuanhao']
5、过滤掉首字母为a的人的信息后结果：
	 [{'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'}]
6、使用递归打印斐波那契数列: 
0 1 1 2 3 5 8 
7、用递归取出一个嵌套很多层的列表的值： 
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
Process finished with exit code 0

转载于:https://www.cnblogs.com/95lyj/p/8696419.html