第1章 函数有用信息
1.1 login.__doc__
1.2 login.__name__
第2章 装饰器的进阶
2.1 带参数的装饰器
2.2 多个装饰器装饰一个函数
2.3 开放封闭原则
第3章 可迭代对象
3.1 判断对象方法dir（）
3.2 通俗测试方法：
3.3 方法1：‘__iter__‘ in dir(list)
3.4 方法2：isinstance
第4章 迭代器
4.1 定义
4.2 迭代器转换
4.2.1 判断方法1
4.2.2 判断方法2：
4.3 转换成迭代器的优势
4.4 模拟for循环
第5章 生成器
5.1 生成器对象
5.2 以函数的方式来构建生成器
第6章 生成器表达式
6.1 生成表达式特性
6.2 遍历模式
6.2.1 列表推导式简单用法
6.2.2 列表推导式应用
6.3 筛选模式
6.4 生成器取值：
6.5 列表表达式转换生成器表达式
6.5.1 区别：
6.6 练习题
6.7 作业题
第7章 内置函数
7.1 作用域相关
7.1.1 locals***
7.1.2 globals***
7.2 其它相关
7.2.1 eval***
7.2.2 exec***
7.2.3 compile
7.2.4 print
7.2.5 hash
7.2.6 callable**
7.3 数据类型相关
7.3.1 int
7.3.2 complex
7.4 数学运算
7.4.1 divmod
7.4.2 sum****
7.4.3 min****
7.5 数据结构相关
7.5.1 reversed
7.5.2 encode
7.5.3 repr
7.5.4 sorted****
7.5.5 enumerate****
7.5.6 any**
7.5.7 zip****
7.5.8 map****
7.5.9 filter
第8章 匿名函数
8.1 练习
第9章 拾遗
9.1 except StopIteration
第1章 函数有用信息
1.1 login.__doc__
解释：得到有用信息
1.2 login.__name__
解释：得到函数名
原函数：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def login(username,password):
‘‘‘
次函数是完成登录功能的函数，需要两个参数用户名和密码，返回True登录成功
:return: True
‘‘‘
print(666)
return True
# login(‘w‘,123)
print(login.__doc__) #得到有用信息
print(login.__name__)#得到函数名
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
次函数是完成登录功能的函数，需要两个参数用户名和密码，返回True登录成功
:return: True
例：要求加上装饰器返回值也正常：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from functools import wraps
def logger(f):
@wraps(f)
def inner(*args,**kwargs):
ret = f(*args,**kwargs)
return ret
return inner
@logger
def login(username,password):
‘‘‘
次函数是完成登录功能的函数，需要两个参数用户名和密码，返回True登录成功
:return: True
‘‘‘
print(666)
return True
输出
print(login.__doc__) #得到有用信息
print(login.__name__)#得到函数名
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
次函数是完成登录功能的函数，需要两个参数用户名和密码，返回True登录成功
:return: True
login
第2章 装饰器的进阶
2.1 带参数的装饰器
解决批量加糖的方法：
1.将@与函数分开@ timerout(flag),将flag传进去，返回了timer
2.将@与timer结合
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
def timmerout(flag1):
def timer(f):
def inner(*args,**kwargs):
if flag1:
start_time = time.time()
ret = f(*args,**kwargs)
end_time = time.time()
print(‘此函数的执行效率%s‘ % (end_time - start_time))
return ret
else:
ret = f(*args,**kwargs)
return ret
return inner
return timer
flag = True
@timmerout(flag)#1.将@与函数分开@ timmerout(flag) 返回了 timer 2.将@timer结合
def func1():
time.sleep(0.3)
print(‘非常复杂....‘)
return 666
@timmerout(flag)
def func2():
time.sleep(0.2)
print(‘非常复杂....‘)
return 777
@timmerout(flag)
def func3():
time.sleep(0.1)
print(‘非常复杂.....‘)
return 999
func1()
func3()
func2()
输出：
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
非常复杂....
此函数的执行效率0.3000171184539795
非常复杂.....
此函数的执行效率0.1000056266784668
非常复杂....
此函数的执行效率0.2000114917755127
2.2 多个装饰器装饰一个函数
def wrapper1(func):
def inner1():
print(‘wrapper1,before func‘)
func()
print(‘wrapper1,after func‘)
return inner1()
def wrapper2(func):
def inner2():
print(‘wrapper2,before func‘)
func()
print(‘wrapper2,after func‘)
return inner2()
@wrapper2 # f = warpper2(f) 里面的f 是inner1 外面的f 是inner2。
@wrapper1 # f = warpper(f) 里面的f函数名 外面的f是inner1.
def f():
print(‘in f‘)
f() #inner(2)
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
wrapper2,before func
wrapper1,before func
in f
wrapper1,after func
wrapper2,after func
逻辑梳理：函数就近原则先读，语法糖wrapper1è再读wrapper2，并存入缓存，没有输出，此时当f参数传入时，wrapper1中的 f = inner1,没有输出è继续执行wrapper2 print（wrapper2,before func）；è执行f() = inner1()è输出wrapper1,before func è继续输出èf() = in f è继续输出：wrapper1,after funcè执行inner2输出èwrapper2,after func
2.3 开放封闭原则
l 对扩展开放
对于装饰器本身的扩展内容是可添加和更改的
l 对修改是封闭的
对所装饰的对象是不能进行修改的
第3章 可迭代对象
3.1 判断对象方法dir（）
定义：该对象中含有__iter__方法就是可迭代对象，遵循可迭代协议。
3.2 通俗测试方法：
凡是用for循环能够遍历的都是可迭代的
str、list、tuple、dict、set、range、文件句柄
3.3 方法1：‘__iter__‘ in dir(list)
print(‘__iter__‘ in dir(str))
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
True
3.4 方法2：isinstance
解释：isinstance 比type的范围更大
from collections import Iterable
print(isinstance(‘abc‘,Iterable))
输出
D:/python/untitled2/python_5/练习.py
True
isinstance也可以判断类型
from collections import Iterable
print(isinstance(‘abc‘,str))
输出
D:/python/untitled2/python_5/练习.py
True
第4章 迭代器
4.1 定义
解释：内部含有__iner__且含有__next__方法的对象就是迭代器，遵循迭代器协议。
迭代器可以取值，迭代对象也是转换成迭代器才取值的
4.2 迭代器转换
s1 = ‘abc‘
obj_s = s1.__iter__() #可迭代对象传换成迭代器
obj_s1 =iter(s1) #可迭代对象传换成迭代器
print(obj_s,obj_s1)
内置方法：
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
<str_iterator object at 0x00000000022282E8> <str_iterator object at 0x00000000022282B0>
4.2.1 判断方法1
s1 = ‘abc‘
print(‘__iter__‘ in dir(s1))
print(‘——next‘ in dir(s1))
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
True
False
4.2.2 判断方法2：
from collections import Iterator
l1 = [1,2,3]
print(isinstance(l1,Iterator))
l1_obj = l1.__iter__()
print(isinstance(l1_obj,Iterator))
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
False
True
4.3 转换成迭代器的优势
l 节省内存，只占一条的数据
l 惰性机制
l 单向执行，不可逆
4.4 模拟for循环
for循环其实就是迭代器原理，我们之前在讲循环对象的时候，曾提到一个StopIteration的异常，该异常是在循环对象穷尽所有元素时的报错。
s1 = ‘fkdsafhdskfhsdklfjdslfksd‘
s1_obj = s1.__iter__()
while True:
try:
print(s1_obj.__next__())
except StopIteration:
break
输出：
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
f
k
d
s
a
f
……..
第5章 生成器
定义：生成器的本质就是迭代器，他是自定义的迭代器（用python代码手写一个迭代器叫做生成器）
凡是在函数中见到yield 就是生成器
例：
def func1():
print(111)
yield 666
ret = func1()
print(ret)
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
<generator object func1 at 0x0000000001E8E4C0>
5.1 生成器对象
解释:上述案例中
ret = func1() 为生成对象
print(ret)#凡事函数中见到yield 就是生成器
例：
def func1():
yield 999
print(222)
print(333)
yield ‘wang‘
print(888)
g_obj = func1()
#__next__()和yield 必须一一对应
print(g_obj.__next__())
print(g_obj.__next__())
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
999
222
333
wang
5.2 以函数的方式来构建生成器
def cloth():
for i in range(1,5001):
print(‘衣服%s‘ %i)
cloth()
一次性生成
def cloth1():
for i in range(1,5001):
yield ‘衣服%s‘ %i
g_obj = cloth1() # 生成器对象
分批次生成，并且号码相连
for i in range(50):
print(g_obj.__next__())
for i in range(150):
print(g_obj.__next__())
第6章 生成器表达式
6.1 生成表达式特性
u 生成表达式又称：列表推导式
u 列表推导式：简单，一行能搞定
u 特别复杂的数据列表推导式无法实现，只能用其他方式实现
u 列表推导式不能排错
6.2 遍历模式
[变量 （加工后的变量） for 变量 in iterable ] 遍历模式
例：遍历模式
l1 = []
for i in range(1,23):
l1.append(‘python%s期‘ % i)
print(l1)
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
[‘python1期‘, ‘python2期‘, ‘python3期‘, ‘python4期‘, ‘python5期‘, ‘python6期‘, ‘python7期‘, ‘python8期‘, ‘python9期‘, ‘python10期‘, ‘python11期‘, ‘python12期‘, ‘python13期‘, ‘python14期‘, ‘python15期‘, ‘python16期‘, ‘python17期‘, ‘python18期‘, ‘python19期‘, ‘python20期‘, ‘python21期‘, ‘python22期‘]
6.2.1 列表推导式简单用法
l = [i for i in range(1,11)]
print(l)
输出
D:/python/untitled2/python_5/练习.py
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
6.2.2 列表推导式应用
l2 = [‘python%s期‘ %i for i in range(1,23)]
print(l2)
输出
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
[‘python1期‘, ‘python2期‘, ‘python3期‘, ‘python4期‘, ‘python5期‘, ‘python6期‘, ‘python7期‘, ‘python8期‘, ‘python9期‘, ‘python10期‘, ‘python11期‘, ‘python12期‘, ‘
6.3 筛选模式
[变量 （加工后的变量） for 变量 in iterable if 条件]删选模式
l1 = []
for i in range(1,31):
if i % 3 == 0:
l1.append(i)
print(l1)
l2 = [i for i in range(1,31) if i % 3 == 0]
print(l2)
列表声称式 生成器表达式
6.4 生成器取值：
u send 和next 都是对生成器取值。
u send 会给上一个yield 发送一个值。
u send 不能用在第一次取值。
u 最后一个yield 不能得到值
例1：yield
def func1():
count = yield 666
print(count)
yield ‘alex‘
yield ‘abc‘
g_obj = func1() # 生成器对象
print(g_obj.__next__())
print(g_obj.__next__())
解释：
# send 和next 都是对生成器取值。
# send 会给上一个yield 发送一个值。
# send 不能用在第一次取值。
# 最后一个yield 不能得到值
例2：send
def func1():
count = yield 666
print(count)
yield ‘afr‘
yield ‘abc‘
g_obj = func1() # 生成器对象
# print(g_obj.__next__())
# print(g_obj.__next__())
print(g_obj.__next__())
print(g_obj.send(‘taibai‘))
# print(g_obj.send(‘taibai‘))
print(g_obj.__next__())
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
666
taibai
afr
abc
6.5 列表表达式转换生成器表达式
6.5.1 区别：
u 列推直观能看出，但是占内存
u 生成器表达式不易看出，但是节省内存
例：
l2_obj = (i for i in range(1,31) if i % 3 == 0 )
print(l2_obj)
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
<generator object <genexpr> at 0x00000000021CC0A0>
6.6 练习题
1） 构建列表： 十以内的所有的元素的平方。
l1 = [i**2 for i in range(1,10)]
print(l1)
2） 30以内所有能被3整除的数的平方
l1 = [i**2 for i in range(1,31) if i % 3 == 0]
print(l1)
3）[3,6,9] 组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]
l1 =[[i-2,i-1,i] for i in [3,6,9]]
print(l1)
4）
names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
[‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
找出名字中含有两个e的名字
l1 =[i for l in names for i in l if i.count(‘e‘) == 2 ]
print(l1)
6）
# l = [‘您好‘, ‘3.64‘,
# ‘请问您是刘晓宇同学的家长吗‘, ‘6.25‘,
# ‘是的有什么事情吗‘, ‘6.15‘,
# ‘您好我是学大教育的刘老师‘, ‘5.06‘,
# ‘这次给给您打电话主要是想了解一下孩子上学期的协议情况‘, ‘5.86‘,
# ‘针对于上学期的学习状况‘, ‘5.37‘,
# ‘我们学校邀请您和孩子周末过来听一下针对性的辅导课好吧好吧‘, ‘5.36‘,
# ‘可以我想问一下都有什么课程呢‘, ‘5.65‘,
# ‘呃主要是有英语和语文‘, ‘4.35‘,
# ‘你看‘, ‘3.77‘,
# ‘到时候咱们再联系好吧‘, ‘6.10‘,
# ‘好的‘, ‘6.45‘,
# ‘恩再见‘, ‘4.84‘]
# 上面这个列表帮我转成下面这种格式
# [{"onebest":"您好", "speed":"6.060606"},
# {"onebest":"我这是中国电信的客户代表请问您是幺五幺幺零幺五六六六幺号码的长期使用者吗", "speed":"5.479452"},
# {"onebest":"是的", "speed":"5.405406"},
# {"onebest":"为啥谢谢您长期以来的支持", "speed":"5.529954"},
# {"onebest":"交银退掉", "speed":"4.938272"},
# {"onebest":"考虑了解生活小贴士服务美元四月","speed":"4.672897"},
# {"onebest":"你们可以收到天气情况活动", "speed":"5.529954"},
# {"onebest":"我建议", "speed":"4.347826"},
# {"onebest":"生活中了就是周转现在开通后","speed":"4.024768"},
# {"onebest":"发到您的", "speed":"8.510638"},
# {"onebest":"都会","speed":"4.255319"},
# {"onebest":"现在","speed":"6.451613"},
# {"onebest":"可以享有就是看吗", "speed":"5.161290"},
# {"onebest":"可以","speed":"6.451613"},
# {"onebest":"改天先生那是的", "speed":"4.046243"},
# {"onebest":"另外再见", "speed":"5.479452"}
# ]
方法：
print([{‘onebest‘:l[i],‘speed‘:l[i+1]} for i in range(len(l)) if i % 2 == 0])
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
[{‘onebest‘: ‘您好‘, ‘speed‘: ‘3.64‘}, {‘onebest‘: ‘请问您是刘晓宇同学的家长吗‘, ‘speed‘: ‘6.25‘}, {‘onebest‘: ‘是的有什么事情吗‘, ‘speed‘: ‘6.15‘}, {‘onebest‘: ‘您好我是学大教育的刘老师‘, ‘speed‘: ‘5.06‘}, {‘onebest‘: ‘这次给给您打电话主要是想了解一下孩子上学期的协议情况‘, ‘speed‘: ‘5.86‘}, {‘onebest‘: ‘针对于上学期的学习状况‘, ‘speed‘: ‘5.37‘}, {‘onebest‘: ‘我们学校邀请您和孩子周末过来听一下针对性的辅导课好吧好吧‘, ‘speed‘: ‘5.36‘}, {‘onebest‘: ‘可以我想问一下都有什么课程呢‘, ‘speed‘: ‘5.65‘}, {‘onebest‘: ‘呃主要是有英语和语文‘, ‘speed‘: ‘4.35‘}, {‘onebest‘: ‘你看‘, ‘speed‘: ‘3.77‘}, {‘onebest‘: ‘到时候咱们再联系好吧‘, ‘speed‘: ‘6.10‘}, {‘onebest‘: ‘好的‘, ‘speed‘: ‘6.45‘}, {‘onebest‘: ‘恩再见‘, ‘speed‘: ‘4.84‘}]
6.7 作业题
x = {
‘name‘:‘alex‘,
‘Values‘:[{‘timestamp‘:1517991992.94,
‘values‘:100,},
{‘timestamp‘: 1517992000.94,
‘values‘: 200,},
{‘timestamp‘: 1517992014.94,
‘values‘: 300,},
{‘timestamp‘: 1517992744.94,
‘values‘: 350},
{‘timestamp‘: 1517992800.94,
‘values‘: 280}
],}
# 将上面的数据通过列表推导式转换成下面的类型：
# [[1517991992.94, 100], [1517992000.94, 200], [1517992014.94, 300], [1517992744.94, 350], [1517992800.94, 280]]
解答：
l2 = [[i[‘timestamp‘],i[‘values‘]] for i in x[‘Values‘] ]
第7章 内置函数
|
7.1 作用域相关
7.1.1 locals***
函数会以字典的类型返回当前位置的全部局部变量
7.1.2 globals***
函数以字典的类型返回全部全局变量
例：
a = 1
b = 2
print(locals())
print(globals())
# 这两个一样，因为是在全局执行的。
##########################
def func(argv):
c = 2
print(locals())
print(globals())
func(3)
#这两个不一样，locals() {‘argv‘: 3, ‘c‘: 2}
#globals() {‘__doc__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__cached__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x0000024409148978>, ‘__spec__‘: None, ‘__file__‘: ‘D:/lnh.python/.../内置函数.py‘, ‘func‘: <function func at 0x0000024408CF90D0>, ‘__name__‘: ‘__main__‘, ‘__package__‘: None}
7.2 其它相关
7.2.1 eval***
解释：执行字符串类型的代码，并返回最终结果
eval(‘2 + 2‘) # 4
n=81
eval("n + 4") # 85
eval(‘print(666)‘) # 666
7.2.2 exec***
解释:执行字符串类型的代码
例：
s = ‘‘‘
for i in [1,2,3]:
print(i)
‘‘‘
exec(s)
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
1
2
3
7.2.3 compile
解释：将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值
参数说明：
u 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
u 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
u 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为‘single‘。
‘‘‘
>>> #流程语句使用exec
>>> code1 = ‘for i in range(0,10): print (i)‘
>>> compile1 = compile(code1,‘‘,‘exec‘)
>>> exec (compile1)
>>> #简单求值表达式用eval
>>> code2 = ‘1 + 2 + 3 + 4‘
>>> compile2 = compile(code2,‘‘,‘eval‘)
>>> eval(compile2)
>>> #交互语句用single
>>> code3 = ‘name = input("please input your name:")‘
>>> compile3 = compile(code3,‘‘,‘single‘)
>>> name #执行前name变量不存在
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
name
NameError: name ‘name‘ is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:‘pythoner‘
>>> name #执行后name变量有值
"‘pythoner‘"
注释：有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile
7.2.4 print
input:函数接受一个标准输入数据，返回为 string 类型。print:打印输出。
print(111,222,333,sep=‘*‘) # 111*222*333
print(111,end=‘‘)
print(222) #两行的结果 111222
f = open(‘log‘,‘w‘,encoding=‘utf-8‘)
print(‘写入文件‘,file=f,flush=True)
7.2.5 hash
获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值
print(hash(12322))
print(hash(‘123‘))
print(hash(‘arg‘))
print(hash(‘alex‘))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))
输出
12322
-2996001552409009098
-4637515981888139739
2311495795356652852
1
0
2528502973977326415
‘‘‘
将不可变元素定义一个值，除了int和bool
7.2.6 callable**
解释：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功
>>>callable(0)
False
>>> callable("runoob")
False
>>> def add(a, b):
... return a + b
...
>>> callable(add) # 函数返回 True
True
>>> class A: # 类
... def method(self):
... return 0
...
>>> callable(A) # 类返回 True
True
>>> a = A()
>>> callable(a) # 没有实现 __call__, 返回 False
False
>>> class B:
... def __call__(self):
... return 0
...
>>> callable(B)
True
>>> b = B()
>>> callable(b) # 实现 __call__, 返回 True
7.3 数据类型相关
u bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
u int：函数用于将一个字符串或数字转换为整型。
u float：函数用于将整数和字符串转换成浮点数
u complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
7.3.1 int
print(int()) # 0
print(int(‘12‘)) # 12
print(int(3.6)) # 3
print(int(‘0100‘,base=2)) # 将2进制的 0100 转化成十进制。结果为 4
7.3.2 complex
>>>complex(1, 2)
(1 + 2j)
>>> complex(1) # 数字
(1 + 0j)
>>> complex("1") # 当做字符串处理
(1 + 0j)
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
7.4 数学运算
u abs：函数返回数字的绝对值。
u divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
u round：保留浮点数的小数位数，默认保留整数。
u pow：求x**y次幂。（三个参数为x**y的结果对z取余）
u sum：对可迭代对象进行求和计算（可设置初始值）。
u min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
u max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
7.4.1 divmod
print(abs(-5)) # 5
print(divmod(7,2)) # (3, 1)
print(round(7/3,2)) # 2.33
print(round(7/3)) # 2
print(round(3.32567,3)) # 3.326
print(pow(2,3)) # 两个参数为2**3次幂
print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。
7.4.2 sum****
print(sum([1,2,3]))
print(sum((1,2,3),100))
print(max([1,2,3])) # 返回此序列最大值
ret = max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值
print(ret)
dic = {‘a‘:3,‘b‘:2,‘c‘:1}
print(max(dic,key=lambda x:dic[x]))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最大的值对应的键
7.4.3 min****
print(min([1,2,3])) # 返回此序列最小值
ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
print(ret)
dic = {‘a‘:3,‘b‘:2,‘c‘:1}
print(min(dic,key=lambda x:dic[x]))
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
7.5 数据结构相关
列表和元祖（2）
u list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
u tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元
相关内置函数（2）
u reversed：将一个序列翻转，并返回此翻转序列的迭代器。
u slice：构造一个切片对象，用于列表的切片。
字符串相关（9）
u str：将数据转化成字符串。
u format:与具体数据相关，用于计算各种小数，精算等。
u bytes：用于不同编码之间的转化
u bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
u ord:输入字符找该字符编码的位置
u chr:输入位置数字找出其对应的字符
u ascii:是ascii码中的返回该值，不是就返回/u...
u repr:返回一个对象的string形式（原形毕露）
数据集合
u dict：创建一个字典。
u set：创建一个集合。
u frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数
u len:返回一个对象中元素的个数。
u sorted：对所有可迭代的对象进行排序操作。
7.5.1 reversed
建列表生成一个翻转后的迭代器
ite = reversed([‘a‘,2,3,‘c‘,4,2])
for i in ite:
print(i)
li = [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘]
sli_obj = slice(3)
print(li[sli_obj])
sli_obj = slice(0,7,2)
print(li[sli_obj]
7.5.2 encode
s = ‘完‘
b1 = s.encode(‘utf-8‘)
print(b1)
输出
b‘\xe5\xae\x8c‘
7.5.3 repr
解释：返回一个对象的string形式（原形毕露）
# %r 原封不动的写出来
# name = ‘taibai‘
# print(‘我叫%r‘%name)
# repr 原形毕露
print(repr(‘{"name":"alex"}‘))
print(‘{"name":"alex"}‘)
7.5.4 sorted****
解释：对所有可迭代的对象进行排序操作
L = [(‘a‘, 1), (‘c‘, 3), (‘d‘, 4),(‘b‘, 2), ]
sorted(L, key=lambda x:x[1]) # 利用key
[(‘a‘, 1), (‘b‘, 2), (‘c‘, 3), (‘d‘, 4)]
students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
sorted(students, key=lambda s: s[2]) # 按年龄排序
[(‘dave‘, ‘B‘, 10), (‘jane‘, ‘B‘, 12), (‘john‘, ‘A‘, 15)]
sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘, ‘B‘, 10)]
7.5.5 enumerate****
解释：返回一个枚举对象
l1 = [‘wang‘,‘li‘,‘zhao‘]
for index,count in enumerate(l1):
print(index,count)
输出
0 wang
1 li
2 zhao
7.5.6 any**
# all 可迭代对象中，全都是True才是True
# any 可迭代对象中，有一个True 就是True
# print(all([1,2,True,0]))
# print(any([1,‘‘,0]))
7.5.7 zip****
解释：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
l1 = [1,2,3,]
l2 = [‘a‘,‘b‘,‘c‘,5]
l3 = (‘*‘,‘**‘,(1,2,3))
for i in zip(l1,l2,l3):
print(i)
输出
l1 = [1,2,3,]
l2 = [‘a‘,‘b‘,‘c‘,5]
l3 = (‘*‘,‘**‘,(1,2,3))
for i in zip(l1,l2,l3):
print(i)
7.5.8 map****
解释：会根据提供的函数对指定序列做映射
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
7.5.9 filter
#filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True
#类似于[i for i in range(10) if i > 3]
# def func(x):return x%2 == 0
# ret = filter(func,[1,2,3,4,5,6,7])
# print(ret)
# for i in ret:
# print(i)
第8章 匿名函数
定义：将一些简单的函数用一行来体现
u 参数可以多个，用逗号隔开
u 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行的结束后的内容就是返回值
u 返回值和正常的函数一样可以是任意数据类型
格式：
calc (函数名) = lambda（定义匿名函数关键字和def类似） n（参数） n**n（返回值）
print(calc(10))
例：
def func2(x,y):
return x + y
func1 = lambda x,y: x + y
print(func1(3,4))
例2：
res = map(lambda x: x**2,[1,5,7,4,8])
for i in res:
print(i)
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
1
25
49
16
64
8.1 练习
l1 = [ {‘sales_volumn‘: 0},
{‘sales_volumn‘: 108},
{‘sales_volumn‘: 337},
{‘sales_volumn‘: 475},
{‘sales_volumn‘: 396},
{‘sales_volumn‘: 172},
{‘sales_volumn‘: 9},
{‘sales_volumn‘: 58},
{‘sales_volumn‘: 272},
{‘sales_volumn‘: 456},
{‘sales_volumn‘: 440},
{‘sales_volumn‘: 239}]
按照数字升序排序
print(sorted(l1,key = lambda x:x[‘sales_volumn‘]))
输出
C:\python3\python.exe D:/python/untitled2/python_5/lession.py
[{‘sales_volumn‘: 0}, {‘sales_volumn‘: 9}, {‘sales_volumn‘: 58}, {‘sales_volumn‘: 108}, {‘sales_volumn‘: 172}, {‘sales_volumn‘: 239}, {‘sales_volumn‘: 272}, {‘sales_volumn‘: 337}, {‘sales_volumn‘: 396}, {‘sales_volumn‘: 440}, {‘sales_volumn‘: 456}, {‘sales_volumn‘: 475}]
第9章 拾遗
9.1 except StopIteration
for循环其实就是迭代器原理，我们之前在讲循环对象的时候，曾提到一个StopIteration的异常，该异常是在循环对象穷尽所有元素时的报错。
s1 = ‘fkdsafhdskfhsdklfjdslfksd‘
s1_obj = s1.__iter__()
while True:
try:
print(s1_obj.__next__())
except StopIteration:
break
输出：
C:\python3\python.exe D:/python/untitled2/python_5/练习.py
f
k
d
s
a
f
原文地址：https://www.cnblogs.com/wang-xd/p/9146765.html