- 数学运算（7）
- 类型转换（21）
- 序列操作（8）
- 对象操作（6）
- 反射操作（7）
- 装饰器（3）
- 变量作用域（3）
- 字符串类型代码（4）
- 输入输出（2）
- 迭代器、生成器相关（2）
- 其他（4）
一、数学运算
abs：返回数字的绝对值
abs(-1) # 1
round：保留浮点数的小数位数，默认保留整数。四舍五入。
round(1.553,1) #1.6
divmod：计算除数和被除数的结果，并返回一个包含商和余数的元组。
divmod(5,2) # (2,1)
pow：求x**y次幂（当有第三参数时，x**y的结果对z取余 ）
pow(2,5) #32 pow(2,3,5) # 这里为3个参数，2的3次方，结果为8。用8和5做除法，取余为3，最终输出3
sum：对可迭代对象进行求和计算（可设置初始值）
# sum最多只有2个参数 sum([1,2,3,4,5]) #15 sum([1,2,3,4,5],100) #115 sum(1,2,3,4,5) #报错
min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
I. 将iterable的每一个元素当作函数的参数传给函数，字典中，元素是键
II. 按照函数的返回值进行比较大小
III. 返回的是遍历的元素x，即传入函数的参数
min([1,-2,3,-4,5]) #-4 min([1,-2,3,-4,5],key=abs) # 按照绝对值的大小，返回此序列最小值 1 min(1,2,-5,6,-3,key=lambda x:abs(x)) # 可以设置很多参数比较大小
ls=[('spring',100),('summer',18),('winter',500)] def func(x): return x[1] print(min(ls,key=func)) #('summer',18)
dic = {'a': 3, 'b': 2, 'c': 1}
def func1(x):
return dic[x]
print(min(dic,key=func1)) # c
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键 dic = {'a':3,'b':2,'c':1} print(min(dic,key=lambda x:dic[x])) # c,只有键没有值 min(dic.items(),key=lambda x:x[1]) # ('c', 1) [min(dic.items(),key=lambda x:x[1])] # [('c', 1)]
必须外面加上【】，转成元组组成的字典之后才可以使用dict转成字典
dict([min(dic.items(),key=lambda x:x[1])]) #{'c': 1}
max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。与min用法相同
二.类型转换
进制转化
bin：将十进制转化成二进制
bin(100) #0b1100100
oct：将十进制转化成八进制
oct(100) #0o144
hex：将十进制转化成十六进制
hex(100) #0x64
字符串和ASCll编码转换
ord：输入字符，找该字符在unicode编码的位置
ord('A') = 65 ord('Z') = 90 ord('a') = 97 ord('z') = 122 ord('你') = 20320
chr：输入位置数字，找出相对应的字符，与ord相反
chr(65) = 'A' chr(90) = 'Z' chr(97) = 'a' chr(122) = 'z' chr(20320) = '你'
ascii：是ascii码表中的内容返回原值，不是返回u + 他在Unicode中的位置
ascii('q') #'q'
ascii('你') #'u4f60' 转化成十进制就是 20320
数据类型转化相关
int：将字符串或数字转化成整型，用于将其他进制数转化成十进制。取整数，不会四舍五入
int(1.543) #1 int('123') #123 int('0101',base=2) # 5
float：将字符串或整数转化成浮点型
float(1) #1.0 float('1') #1.0
bool：用于将给定参数转化为布尔类型
bool(123) #True
complex：用于创建一个值为 real+image*j的复数，当第一个参数为字符串时，不要设置第二个参数。
complex(1,2) #(1+2j) complex('1') #(1+0j)
str：将数据转化成字符串
str(2.3) # 转换为字符串2.3
bytes：用于不同编码之间的转化。将unicode 转为非unicode。只能编码，不能解码
编码转换，将unicode转换为utf-8 方法一： s1 = '小太阳' s2 = s1.encode('utf-8') print(s2) # b'xe5xb0x8fxe5xa4xaaxe9x98xb3' 方法二： s1 = '小太阳' print(bytes(s1,encoding='utf-8')) # b'xe5xb0x8fxe5xa4xaaxe9x98xb3'
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
l1 = list((1,2,3)) # [1, 2, 3] l2 = list({1,2,3}) # [1, 2, 3] l3 = list({'name':'xiaoming','age':13}) # ['name', 'age']
tuple：将一个可迭代对象转化成元组（如果是字典，默认将key作为元组的元素）
tup1 = tuple([1,2,3]) # (1, 2, 3) tup2 = tuple({'name':'xiaoming','age':13}) # ('name', 'age')
dict：创建一个字典 *****
dict(a = 1,b = 2) # {'b': 2, 'a': 1} # 传入映射函数创建字典。 dict(zip(['a','b'],[1,2])) # {'b': 2, 'a': 1} # 传入可迭代对象创建字典。 dict((('a',1),('b',2))) # {'b': 2, 'a': 1} dict([('a',1),('b',2)]) # {'b': 2, 'a': 1}
set：创建一个集合
a = set(range(10)) # 传入可迭代对象，创建集合{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
其他
bytearry：返回一个新字节数组。数组中元素可变，并且每个元素的值范围: 0 <= x < 256。（很少用）
ret = bytearray('hello',encoding='utf-8') print(ret) #bytearray(b'hello') print(id(ret)) #1979800230744 print(ret[0]) #104 h在ascii码中的位置 ret[0] = 97 #将第一位改为a print(ret) #bytearray(b'aello') print(id(ret)) #1979800230744 id是相同的
bytearray('中文','utf-8') # bytearray(b'xe4xb8xadxe6x96x87')
memoryview：返回对象obj的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。（没啥用）
ret = memoryview(bytes('你好',encoding='utf-8')) print(ret) #<memory at 0x000001DA89DDB408> print(len(ret)) # 6 print(bytes(ret[0:3]).decode('utf-8')) #你 print(bytes(ret[3:]).decode('utf-8')) #好
ret = memoryview(b'abcefg') print(ret[1]) # 98 print(ret[-1]) # 103
frozenset：返回一个冻集合(新的不可变集合)，冻结后的集合不能再添加或删除任何元素
a = frozenset(range(10)) print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
enumerate:枚举，返回一个枚举对象。 (0, seq[0]), (1, seq[1]), (2, seq[2])
li = ['spring', 'summer', 'autumn', 'winter'] print(enumerate(li)) # <enumerate object at 0x02E3D558> print('__iter__' in dir(enumerate(li))) # True print('__next__' in dir(enumerate(li))) # True
enumerate是一个迭代器, 返回结果为：列表元素的索引以及对应的值
li = ['spring', 'summer', 'autumn', 'winter'] for i in enumerate(li): print(i)
执行输出：
(0, 'spring')
(1, 'summer')
(2, 'autumn')
(3, 'winter')
li = ['spring', 'summer', 'autumn', 'winter'] for k,v in enumerate(li): print(k,v)
执行输出：
0 spring
1 summer
2 autumn
3 winter
enumerate的第2个参数，表示从多少开始。默认从0开始
li = ['spring', 'summer', 'autumn', 'winter'] print(list(enumerate(li))) # [(0, 'spring'), (1, 'summer'), (2, 'autumn'), (3, 'winter')] print(list(enumerate(li, start=1))) # 指定起始值,[(1, 'spring'), (2, 'summer'), (3, 'autumn'), (4, 'winter')]
li = ['spring', 'summer', 'autumn', 'winter'] for k,v in enumerate(li,10): print(k,v)
执行输出：
10 spring
11 summer
12 autumn
13 winter
li = ['spring', 'summer', 'autumn', 'winter'] enumerate(li,1) # <enumerate object at 0x7f805f9c5b90> list(enumerate(li,1)) # [(1, 'spring'), (2, 'summer'), (3, 'autumn'), (4, 'winter')]
range：根据传入的参数创建一个新的range对象，一般用在for循环中
a = range(10) b = range(1,10) c = range(1,10,3) print(a,list(a)) # range(0, 10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print(b,list(b)) # range(1, 10) [1, 2, 3, 4, 5, 6, 7, 8, 9] print(c,list(c)) # range(1, 10, 3) [1, 4, 7]
三、序列操作
slice：构建一个切片对象，用于列表的切片
l1 = [i for i in range(10)] l2 = l1[:5:2] print(l2) #[0, 2, 4],按照普通切片方法
reversed：将一个序列反转，并返回此反转序列的迭代器，字典不能反转。
l1 = [1,2,3,4] print(reversed(l1)) # <list_reverseiterator object at 0x0000026B679FA4E0> for i in reversed(l1): print(i) # 4 3 2 1
s = 'asdf' for i in reversed(s): print(i) # f d s a
dic = {'name':'xiaoming','age':13}
for i in reversed(dic):
print(i) #字典不能反转 TypeError: 'dict' object is not reversible
sorted：对可迭代对象进行排序，只能列表使用. 可加key，key为函数名，通过函数的规则进行排序。默认从小到大，加入reverse = True时按照从大到小。与 li.sort()相比，原列表不发生改变
sorted(iterable,key=None,reverse=False)
key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse :是否是倒叙,True 倒叙 False 正序
默认升序 li = [1,2,7,8,5,4,3] print(sorted(li)) # [1, 2, 3, 4, 5, 7, 8] 按照绝对值排序 li = [1,-2,-7,8,5,-4,3] print(sorted(li,reverse=True,key=abs)) # [8, -7, 5, -4, 3, -2, 1] 原列表改变 l1 = [1,3,3,2,9] l1.sort() print(l1) #[1, 2, 3, 3, 9] 原列表不发生改变 l2 = [2,3,4,6,4,1] print(sorted(l2)) #[1, 2, 3, 4, 4, 6] print(l2) #[2, 3, 4, 6, 4, 1] l3 = [(1,100),(2,18),(4,250),(3,500)] def func1(x): return x[1] print(sorted(l3,key=func1)) #[(2, 18), (1, 100), (4, 250), (3, 500)] 字典使用sorted排序, 字典排序返回的就是排序后的key dic = {1:'a',3:'c',2:'b'} print(sorted(dic)) # [1,2,3] 和函数组合使用 定义一个列表,然后根据一元素的长度排序 lst = ['天龙八部','西游记','红楼梦','三国演义'] def func(s): return len(s) print(sorted(lst,key=func)) # ['西游记', '红楼梦', '天龙八部', '三国演义'] 和lambda组合使用 lst = ['天龙八部','西游记','红楼梦','三国演义'] print(sorted(lst,key=lambda s:len(s))) # ['西游记', '红楼梦', '天龙八部', '三国演义'] lst = [{'id':1,'name':'alex','age':18}, {'id':2,'name':'wusir','age':17}, {'id':3,'name':'taibai','age':16},] # 按照年龄对学生信息进行排序,这个和min() max()函数不一样，出来的还是字典 print(sorted(lst,key=lambda e:e['age'])) 结果:[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
all：可迭代对象中，全是True才是True
print(all([1,2,3,0])) #False print(all([1,2,3,4])) #True
any：可迭代对象中，有一个是True就是True
print(any([1,[],{},0,()])) #True
zip：将可迭代对象作为参数，将对象中的元素打包成一个元组，返回由这些元组组成的迭代器。
如果可迭代对象中元素的数量不一致，则返回元组个与最短的对象相同。zip结果取决于最短的一个,返回的数据是元组。
拉链方法：将多个iter纵向组成一个个的元组
l = [1,3,5] tu = ('china','america','japan','korean') dic = {'name':1,'age':2,'hobby':3} for i in zip(l,tu,dic): print(i) 输出结果： (1, 'china', 'name') (3, 'america', 'age') (5, 'japan', 'hobby') lst1 = [1,2,3] lst2 = ['a','b','c','d'] lst3 = (11,12,13,14,15) for i in zip(lst1,lst2,lst3): print(i) 输出结果: (1, 'a', 11) (2, 'b', 12) (3, 'c', 13)
filter：通过函数过滤可迭代对象，函数中return的是一个条件，返回一个迭代器。相当于生成器表达式的筛选模式。类似于[i for i in range(10) if i > 3]
filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据
iterable:可迭代对象
l = [i for i in range(10)] def func1(x): return x>5 for i in filter(func1,l): print(i)
lst = [{'id': 1, 'name': 'Joe', 'age': 18},
{'id': 1, 'name': 'Paul', 'age': 17},
{'id': 1, 'name': 'May', 'age': 16}, ]
ls = filter(lambda lst: lst['age'] > 16, lst)
print(list(ls)) # [{'id': 1, 'name': 'Joe', 'age': 18}, {'id': 1, 'name': 'Paul', 'age': 17}]
取列表中的偶数 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) 执行输出： <filter object at 0x0000021325A4B6D8> 2 4 6
使用列表生成式完成 li = [i for i in [1,2,3,4,5,6,7] if i % 2 == 0] print(li)
map：根据提供的函数对指定的序列做映射，返回一个迭代器，相当于生成器表达式中的循环模式
map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别执行function
计算列表各个元素的平方 def square(x): return x ** 2 ret = map(square,[1,2,3,4,5]) for i in ret: print(i) 执行输出： 1 4 9 16 25
改写成lambda lst = [1,2,3,4,5] print(list(map(lambda s:s*s,lst)))
map也是迭代器 l = [i for i in range(3)] def func(x): return x**2 for i in map(func,l): print(i)
计算两个列表中相同位置的数据的和 lst1 = [1, 2, 3, 4, 5] lst2 = [2, 4, 6, 8, 10] print(list(map(lambda x, y: x+y, lst1, lst2))) # [3, 6, 9, 12, 15]
四、对象操作
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值
print(hash('123')) #6154395912723147770 print(hash(123)) #123，数字不变
id：获取对象的内存地址
print(id(123)) #1785819168
dir：查看对象或者当前作用域内的属性列表。函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir(list)) # ['__add__', '__class__', '__contains__'...] print(dir()) # ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] print(dir('hello')) # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__ne........... print('__iter__' in dir(iter)) # False
help：返回对象的帮助信息，主要用于查看函数或模块用途的详细说明。
help(abs)
help(str)
len：返回一个对象中元素的个数
print(len('abcd')) # 4 字符串 print(len(bytes('abcd','utf-8'))) # 4 字节数组 print(len((1,2,3,4))) # 4 元组 print(len([1,2,3,4])) # 4 列表 print(len(range(1,5))) # 4 range对象 print(len({'a':1,'b':2,'c':3,'d':4})) # 4 字典 print(len({'a','b','c','d'})) # 4 集合 print(len(frozenset('abcd'))) #4 不可变集合
type：返回对象的类型，或者根据传入的参数创建一个新的类型
type(1) # <class 'int'>
五、反射操作
hasattr(obj, attr): 用于检查obj是否有一个名为attr的值的属性，返回一个布尔值。
getattr(obj, attr): 返回obj中名为attr值的属性的值
setattr(obj, attr, val): 给obj的attr属性赋值为val。例如attr为'bar'，则相当于obj.bar = val
delattr(obj, name)该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar
class Test: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def say_hi(self): print('hi,%s'%self.name) obj=Test('Joe',12) #检测是否含有某属性 print(hasattr(obj,'name')) # True print(hasattr(obj,'say_hi')) # True #获取属性 n=getattr(obj,'name') func=getattr(obj,'say_hi') print(n,func) # Joe <bound method Test.say_hi of <__main__.Test object at 0x0000000009F69128>> #设置属性 setattr(obj,'self.hobby','paiting') setattr(obj,'show_hobby',lambda self:self.name+' like paiting') print(obj.__dict__) # {'name': 'Joe', 'age': 12, 'self.hobby': 'paiting', 'show_hobby': <function <lambda> at 0x00000000029947B8>} print(obj.show_hobby(obj)) # Joe like paiting #删除属性 delattr(obj,'age') delattr(obj,'show_hobby') print(obj.__dict__) # {'name': 'Joe', 'self.hobby': 'paiting'}
isinstance(a,b)：判断a是否是b类（或者b类的基类）实例化的对象
issubclass(a,b)： 判断a类是否是b类（或者b的基类）的派生类
class A: pass class B(A): pass class C(B): pass obj = B() print(isinstance(obj,B)) # True print(isinstance(obj,A)) # True print(issubclass(B,A)) # True print(issubclass(C,A)) # True
callable：检测对象是否可被调用。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。callable其实就是判断一个对象是否是函数，是就返回True，其他类型直接返回False
name = 'summer' print(callable(name)) #False，不可调用
def func1():
pass
print(callable(func1)) #True,可以调用
class A: # 定义类B def __call__(self): print('instances are callable now.') print(callable(A)) # 类A是可调用对象,True a = A() # 实例 print(a) # <__main__.A object at 0x02A6C490> a() # 调用实例a成功,instances are callable now.
六、装饰器
property：标示属性的装饰器。property是一个装饰器函数，可以将一个方法伪装成属性，调用的时候可以不用加()
例如：BMI指数
class Person(object): def __init__(self,name,weight,height): self.name = name self.__weight = weight self.__height = height @property def bmi(self): return self.__weight / self.__height **2
classmethod：标示方法为类方法的装饰器。必须通过类的调用，而且此方法的意义：就是对类里面的变量或者方法进行修改添加
class Goods: __discount = 0.8 # 折扣 def __init__(self,name,origin_price): self.name = name self.__price = origin_price # 原价 @property def price(self): # 价格 return self.__price * Goods.__discount @classmethod def change_discount(self,new_discount): # 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了 Goods.__discount = new_discount Goods.change_discount(1) # 不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量 apple = Goods('apple',5) banana = Goods('banana',8) print(apple.price) # 5 print(banana.price) # 8
staticmethod：标示方法为静态方法的装饰器。不依赖类以及对象。
class Student: def __init__(self,name):pass @staticmethod def login(a): # login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可 user = input('user :') if user == 'alex': print('success') else: print('faild') Student.login(1)
七、变量作用域相关
globals：返回一个字典，包含全部的全局变量
locals：返回一个字典，包含当前作用域的全部变量
vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
class Test: f = '类的静态变量' def __init__(self,name,age): self.name=name self.age=age def variation(self): hobby = 'paiting' print(globals()) print(locals()) obj = Test('Joe', 12) obj.variation() print(obj.__dict__) # {'name': 'Joe', 'age': 12} print(vars(obj)) # {'name': 'Joe', 'age': 12}
globals()的输出：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DEC208>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'F:/Python/test.py', '__cached__': None, 'Test': <class '__main__.Test'>, 'obj': <__main__.Test object at 0x0000000001F50A20>}
locals()的输出：
{'hobby': 'paiting', 'self': <__main__.Test object at 0x0000000001F50A20>}
八、字符串类型代码的执行
eval：执行字符串类型的代码，并返回最终结果。相当于拨开字符串2边的引号，执行里面的代码
print(eval('3+4')) # 7 ret = eval('{"name":"summer"}') print(ret) # {'name': 'summer'}
exec：执行字符串类型的代码，不返回结果
print(exec('3+4')) # None
ret1 = ''' li = [1,2,3] for i in li: print(i) ''' print(exec(ret1)) 执行输出： 1 2 3 None
val和exec 功能是类似的, 区别：
eval有返回值,exec没有没有值
exec适用于有流程控制的,比如for循环。eval只能做一些简单的。
compile：将字符串类型的代码编译，代码对象能够通过exec语句执行或eval()求值。（了解即可）
code1 = 'for i in range(0,3): print (i)' compile1 = compile(code1,'','exec') exec (compile1) 执行输出： 0 1 2
repr:返回一个对象的string形式（原形毕露）。
#%r 原封不动的写出来 name = 'Joe' print('我叫%r' % name) # 我叫'Joe' print(repr('{"name":"Joe"}')) # '{"name":"Joe"}' print('{"name":"Joe"}') # {"name":"Joe"}
九、输入输出相关
input：函数接收一个标准输入数据，返回str类型
print(self,*args,sep=' ',end=' ',file=None, flush=False)
sep：打印多个内容的分隔符，默认是空格
end：默认是换行符
file：默认是None，默认输出到屏幕，设置文件句柄可输出到文件
flush: 立即把内容输出到流文件，不作缓存
sep默认是用空格拼接 print(11, 22, 33) # 11 22 33 sep 指定分隔符 | print(11, 22, 33, sep = '|') # 11|22|33 end结尾符 print(1,end=' ') print(222) # 1 222 print(333,end='') print(666,) #333666 print(333,end='**') print(666,) # 333**666
file写入文件
with open('log.txt',encoding='utf-8',mode='w') as f1: print('5555',file=f1) # 执行程序，查看log.txt文件内容为: 555 f = open('t1',encoding='utf-8',mode='w') print(111,'222',file=f) # 执行程序，查看t1文件内容为: 111 222 f = open('tmp_file','w') print(123,456,sep=',',file = f,flush=True)
打印进度条
import time for i in range(0,101,2): time.sleep(0.1) char_num = i//2 #打印多少个'*' per_str = ' %s%% : %s ' % (i, '*' * char_num) if i == 100 else ' %s%% : %s'%(i,'*'*char_num) print(per_str,end='', flush=True)
十、迭代器、生成器相关
iter：函数用来生成迭代器（将一个可迭代对象，生成迭代器）
from collections import Iterable from collections import Iterator l = [1,2,3] print(isinstance(l,Iterable)) # 判断是否可迭代 True print(isinstance(l,Iterator)) # 判断是否为迭代器 False
from collections import Iterable from collections import Iterator l = [1,2,3] l1 = iter(l) #生成迭代器 print(isinstance(l1,Iterable)) # True print(isinstance(l1,Iterator)) # True print(l1) # <list_iterator object at 0x031D3690> print(next(l1)) # 1 print(next(l1)) # 2 print(next(l1)) # 3 print(next(l1)) # 报错 StopIteration
next：内部实际使用了__next__方法，返回迭代器的下一个项目。
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) while True: try: # 获得下一个值: x = next(it) #next内部封装了__next__方法,都是求下一个值 print(x) except StopIteration: # 遇到StopIteration就退出循环 break 执行输出： 1 2 3 4 5
十一、其他
文件操作相关
open() ：打开一个文件，返回一个文件操作符(文件句柄), 可以用encoding指定编码。操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
format：1、提供参数，指定对其方式，<是左对齐，>是右对齐，^是居中
2、将整数转化成二进制’b‘、’n‘、unicode ’c‘、八进制’o‘、十六进制’x’、’X‘等
3、将浮点数用科学计数法或小数点计数法表示
print(format('test', '<20')) print(format('test', '>20')) print(format('test', '^20')) 执行输出： test test test
super：根据传入的参数创建一个新的子类和父类关系的代理对象
class A(object): def __init__(self): print('A.__init__') class B(A): def __init__(self): print('B.__init__') super().__init__() #super调用父类方法 b = B() 结果输出： B.__init__ A.__init__
__import__：动态导入模块
index = __import__('index') index.sayHello()
特例：reduce()
在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：
from functools import reduce
语法
reduce(function, iterable[, initializer])
- function -- 函数，有两个参数
- iterable -- 可迭代对象
- initializer -- 可选，初始参数
reduce() 函数会对参数序列中元素进行累积。
reduce()函数有2个参数：第一个参数是有两个变量的函数（f（x，y）),第二个是迭代对象 i (元组，列表或字符串）。reduce(f,i)将前两个迭代元素（i[0], i[1]）传至函数f，计算f返回的值，然后将该值作为f的第一个参数，迭代器的第三个元素（i[2]）作为第二个参数，以此类推。
实例
（1）数字加和
from functools import reduce def add(x,y): return x + y print (reduce(add, range(1, 101))) # 5050
（2）统计某字符串重复次数:
from functools import reduce sentences = ['The Deep Learning textbook is a resource intended to help students and practitioners enter the field of machine learning in general and deep learning in particular. '] word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0) print(word_count) # 2
（3）字符串反序
import functools str1="hello" print(functools.reduce(lambda x,y:y+x,str1)) # 输出 olleh
（4）找多个集合中共有元素
from functools import reduce a = set((1, 2, 3, 4, 5)) b = set((2, 4, 6, 7, 1)) c = set((1, 4, 5, 9)) triple_set = [a, b, c] common = reduce(set.intersection, triple_set) print(common) ''' {1, 4} '''
参考链接：
https://www.cnblogs.com/sesshoumaru/p/6140987.html
https://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html