05 python内置函数大全

• 数学运算（7）
• 类型转换（21）
• 序列操作（8）
• 对象操作（6）
• 反射操作（7）
• 装饰器（3）
• 变量作用域（3）
• 字符串类型代码（4）
• 输入输出（2）
• 迭代器、生成器相关（2）
• 其他（4）

一、数学运算

abs：返回数字的绝对值

abs(-1)   　　　　　　　　　　　　　　　　　　#

round：保留浮点数的小数位数，默认保留整数。四舍五入。

round(1.553,1)   　　　　　　　　　　　　　　#1.6

divmod：计算除数和被除数的结果，并返回一个包含商和余数的元组。

divmod(5,2) 　　　　　　　　　　　　　　　　# (2,1)

pow：求x**y次幂（当有第三参数时，x**y的结果对z取余 ）

pow(2,5)   　　　　　　　　　　　　#
pow(2,3,5) 　　　　　　　　　　　　# 这里为3个参数，2的3次方，结果为8。用8和5做除法，取余为3，最终输出3

sum：对可迭代对象进行求和计算（可设置初始值）

# sum最多只有2个参数
sum([1,2,3,4,5])            #
sum([1,2,3,4,5],100)         #
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]))

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) 　　　　　　#
int('') 　　　　　　#
int('',base=2)   #

float：将字符串或整数转化成浮点型

float(1)   　　　　　　#1.0
float('') 　　　　　　#1.0

bool：用于将给定参数转化为布尔类型

bool(123)  　　　　　　#True

complex：用于创建一个值为 real+image*j的复数，当第一个参数为字符串时，不要设置第二个参数。

complex(1,2)   　　#(1+2j)
complex('')   　　#(1+0j)

str：将数据转化成字符串

str(2.3)                         　　# 转换为字符串2.3

bytes：用于不同编码之间的转化。将unicode 转为非unicode。只能编码，不能解码

编码转换，将unicode转换为utf-
方法一：
s1 = '小太阳'
s2 = s1.encode('utf-8')
print(s2)                           # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

方法二：
s1 = '小太阳'
print(bytes(s1,encoding='utf-8')) # b'\xe5\xb0\x8f\xe5\xa4\xaa\xe9\x98\xb3'

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}

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))   #
print(ret[])   #  h在ascii码中的位置

ret[] =    #将第一位改为a
print(ret)   #bytearray(b'aello')
print(id(ret))   #  id是相同的

bytearray('中文','utf-8') # bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

memoryview：返回对象obj的内存查看对象。所谓内存查看对象，就是对象符合缓冲区协议的对象，为了给别的代码使用缓冲区里的数据，而不必拷贝，就可以直接使用。（没啥用）

ret = memoryview(bytes('你好',encoding='utf-8'))
print(ret)   #<memory at 0x000001DA89DDB408>
print(len(ret)) #
print(bytes(ret[:]).decode('utf-8'))   #你
print(bytes(ret[:]).decode('utf-8'))   #好
 

ret = memoryview(b'abcefg')
print(ret[])                   #
print(ret[-])                  # 

frozenset：返回一个冻集合(新的不可变集合)，冻结后的集合不能再添加或删除任何元素

a = frozenset(range())
print(a)                                # frozenset({, , , , , , , , , })

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,):
    print(k,v)

执行输出：
10 spring
11 summer
12 autumn
13 winter

range：根据传入的参数创建一个新的range对象，一般用在for循环中

a = range()
b = range(,)
c = range(,,)

print(a,list(a))        # range(0, 10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(b,list(b))        # range(, ) [, , , , , , , , ]
print(c,list(c))        # range(, , ) [, , ]

三、序列操作

slice：构建一个切片对象，用于列表的切片

l1 = [i for i in range()]
l2 = l1[::]
print(l2)    　　　　　　　　　　#[, , ],按照普通切片方法

reversed：将一个序列反转，并返回此反转序列的迭代器，字典不能反转。

l1 = [,,,]
print(reversed(l1))   　　　　# <list_reverseiterator object at 0x0000026B679FA4E0>

for i in reversed(l1):
    print(i)    #    

s = 'asdf'
for i in reversed(s):
    print(i)   # f d s a

dic = {'name':'xiaoming','age':}
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 = [,,,,,,]
print(sorted(li))         # [, , , , , , ]

按照绝对值排序
li = [,-,-,,,-,]
print(sorted(li,reverse=True,key=abs))        # [, -, , -, , -, ]

原列表改变
l1 = [,,,,]
l1.sort()
print(l1)          #[, , , , ]  

原列表不发生改变
l2 = [,,,,,]
print(sorted(l2))                  #[, , , , , ]
print(l2)                      #[, , , , , ]  

l3 = [(,),(,),(,),(,)]
def func1(x):
    return x[]
print(sorted(l3,key=func1))          #[(, ), (, ), (, ), (, )]

字典使用sorted排序, 字典排序返回的就是排序后的key
dic = {:'a',:'c',:'b'}
print(sorted(dic))                 # [,,]

和函数组合使用
定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
def func(s):
    return len(s)

print(sorted(lst,key=func))                        #  ['西游记', '红楼梦', '天龙八部', '三国演义']

和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))                #  ['西游记', '红楼梦', '天龙八部', '三国演义']

lst = [{'id':,'name':'alex','age':},
    {'id':,'name':'wusir','age':},
    {'id':,'name':'taibai','age':},]

# 按照年龄对学生信息进行排序
print(sorted(lst,key=lambda e:e['age']))

结果:[{'id': , 'name': 'taibai', 'age': }, {'id': , 'name': 'wusir', 'age': }, {'id': , 'name': 'alex', 'age': }]

all：可迭代对象中，全是True才是True

print(all([,,,]))   #False
print(all([,,,]))   #True

any：可迭代对象中，有一个是True就是True

print(any([,[],{},,()]))   #True

zip：将可迭代对象作为参数，将对象中的元素打包成一个元组，返回由这些元组组成的迭代器。

如果可迭代对象中元素的数量不一致，则返回元组个与最短的对象相同。zip结果取决于最短的一个,返回的数据是元组。

    拉链方法：将多个iter纵向组成一个个的元组

l = [,,]
tu = ('china','america','japan','korean')
dic = {'name':,'age':,'hobby':}
for i in zip(l,tu,dic):
    print(i)      

输出结果：
(, 'china', 'name')
(, 'america', 'age')
(, 'japan', 'hobby')

lst1 = [,,]
lst2 = ['a','b','c','d']
lst3 = (,,,,)
for i in zip(lst1,lst2,lst3):
    print(i)
​
输出结果:
(, 'a', )
(, 'b', )
(, 'c', )

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()]
def func1(x):
    return x>

for i in filter(func1,l):
    print(i)

lst = [{'id': , 'name': 'Joe', 'age': },
       {'id': , 'name': 'Paul', 'age': },
       {'id': , 'name': 'May', 'age': }, ]

ls = filter(lambda lst: lst['age'] > , lst)
print(list(ls))　　　　# [{'id': , 'name': 'Joe', 'age': }, {'id': , 'name': 'Paul', 'age': }]

取列表中的偶数
def func(x):
    return x %  ==
ret = filter(func,[,,,,,,])
print(ret)
for i in ret:
    print(i) 

执行输出：
<filter object at 0x0000021325A4B6D8>

使用列表生成式完成
li = [i for i in [,,,,,,] if i %  == ]
print(li) 

map：根据提供的函数对指定的序列做映射，返回一个迭代器，相当于生成器表达式中的循环模式

　　map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别执行function

计算列表各个元素的平方
def square(x):
    return x ** 

ret = map(square,[,,,,])
for i in ret:
    print(i) 

执行输出：

改写成lambda
lst = [,,,,]
print(list(map(lambda s:s*s,lst)))

map也是迭代器
l = [i for i in range()]
def func(x):
    return x**

for i in map(func,l):
    print(i) 

计算两个列表中相同位置的数据的和
lst1 = [, , , , ]
lst2 = [, , , , ]
print(list(map(lambda x, y: x+y, lst1, lst2)))        # [, , , , ]

四、对象操作

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值

print(hash(''))          #
print(hash())         #，数字不变

id：获取对象的内存地址

print(id())            #

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'))                     #  字符串
print(len(bytes('abcd','utf-8')))             #  字节数组
print(len((,,,)))                     #  元组
print(len([,,,]))                     #  列表
print(len(range(,)))                 #  range对象
print(len({'a':,'b':,'c':,'d':}))             #  字典
print(len({'a','b','c','d'}))                 #  集合
print(len(frozenset('abcd')))             # 不可变集合

type：返回对象的类型，或者根据传入的参数创建一个新的类型

type() # <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',)

#检测是否含有某属性
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': , '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 **

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)                              #
print(banana.price)                             #

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

七、变量作用域相关

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', )
obj.variation()
print(obj.__dict__)         # {'name': 'Joe', 'age': }
print(vars(obj))            # {'name': 'Joe', 'age': }

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'))             #
ret = eval('{"name":"summer"}')
print(ret)                 #  {'name': 'summer'}

exec：执行字符串类型的代码，不返回结果

print(exec('3+4'))         # None

ret1 = '''
li = [,,]
for i in li:
    print(i)
'''
print(exec(ret1)) 

执行输出：

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) 

执行输出：

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='\n',file=None, flush=False)

　　sep：打印多个内容的分隔符，默认是空格

　　end：默认是换行符

　　file：默认是None，默认输出到屏幕，设置文件句柄可输出到文件

　　flush: 立即把内容输出到流文件，不作缓存

sep默认是用空格拼接
print(, , )             #   

sep 指定分隔符 |
print(, , , sep = '|')         # ||

end结尾符
print(,end=' ')
print()               #  

print(,end='')
print(,)                #

print(,end='**')
print(,)　            # **

file写入文件

with open('log.txt',encoding='utf-8',mode='w') as f1:
    print('',file=f1)             # 执行程序，查看log.txt文件内容为: 

f = open('t1',encoding='utf-8',mode='w')
print(,'',file=f)                # 执行程序，查看t1文件内容为:  

f = open('tmp_file','w')
print(,,sep=',',file = f,flush=True)

打印进度条

import time
for i in range(,,):
     time.sleep(0.1)
     char_num = i//2                      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i ==  else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)

十、迭代器、生成器相关

iter：函数用来生成迭代器（将一个可迭代对象，生成迭代器）

from collections import Iterable
from collections import Iterator
l = [,,]
print(isinstance(l,Iterable))  # 判断是否可迭代 True
print(isinstance(l,Iterator))  # 判断是否为迭代器 False

from collections import Iterable
from collections import Iterator
l = [,,]

l1 = iter(l)             #生成迭代器
print(isinstance(l1,Iterable))      # True
print(isinstance(l1,Iterator))      # True
print(l1)                           # <list_iterator object at 0x031D3690>
print(next(l1))                     #
print(next(l1))                     #
print(next(l1))                     #
print(next(l1))                     # 报错 StopIteration

next：内部实际使用了__next__方法，返回迭代器的下一个项目。

# 首先获得Iterator对象:
it = iter([, , , , ])
while True:
    try:
        # 获得下一个值:
        x = next(it) #next内部封装了__next__方法,都是求下一个值
        print(x)

    except StopIteration:
        # 遇到StopIteration就退出循环
        break 

执行输出：

十一、其他

文件操作相关

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

（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

https://www.cnblogs.com/pyyu/p/6702896.html