师傅用时一个月！总结了68个内置函数的教程！零基础就该这么学！

一、内置函数

加群：960410445   即可获取数十套pdf！

语法：class complex([real[,imag]])参数：real -- int,long,float或字符串imag -- int,float>>>complex(1,2)(1 + 2j)>>> complex(1) # 数字(1 + 0j)>>> complex("1") # 当做字符串处理(1 + 0j)# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错>>> complex("1+2j")(1 + 2j)

class bytearray([source[,enCoding[,errors]]])# 如果 source 为整数，则返回一个长度为 source 的初始化数组；# 如果 source 为字符串，则按照指定的 enCoding 将字符串转换为字节序列；# 如果 source 为可迭代类型，则元素必须为[0,255] 中的整数；# 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。# 如果没有输入任何参数，默认就是初始化数组为0个元素。>>>bytearray()bytearray(b'')>>> bytearray([1,2,3])bytearray(b'\x01\x02\x03')>>> bytearray('中文','utf-8')bytearray(b'\xe4\xb8\xad\xe6\x96\x87')

（7） bytes()

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

（11） bin()

>>>bin(10)'0b1010'>>> bin(20)'0b10100'

（12） oct()

（13） hex()

（14） tuple()

>>> tuple() #不传入参数，创建空元组()>>> tuple('121') #传入可迭代对象，使用其元素创建新的元组('1','2','1')

（15） List()

>>>List() # 不传入参数，创建空列表[] >>> List('abcd') # 传入可迭代对象，使用其元素创建新的列表['a','b','c','d']

（16） dict()

# 创建空字典>>>dict() {}# 传入关键字>>> dict(a='a',b='b',t='t') {'a': 'a','b': 'b','t': 't'}# 映射函数方式来构造字典>>> dict(zip(['one','two','three'],[1,3])) {'three': 3,'two': 2,'one': 1} # 可迭代对象方式来构造字典>>> dict([('one',1),('two',2),('three',3)]) {'three': 3,'one': 1}

（17） set()

>>> a = set(range(10)) # 传入可迭代对象，创建集合>>> a{0,1,3,4,5,6,7,8,9}>>> x = set('runoob')>>> y = set('Google')>>> x,y(set(['b','r','u','o','n']),set(['e','g','l'])) # 重复的被删除>>> x & y # 交集set(['o'])>>> x | y # 并集set(['b','e','l','n','u'])>>> x - y # 差集set(['r','n'])

（18） froZenset()

>>>a = froZenset(range(10)) # 生成一个新的不可变集合>>> afroZenset([0,9])>>> b = froZenset('runoob') >>> bfroZenset(['b','n']) # 创建不可变集合

（19） enumerate()

>>>seasons = ['Spring','Summer','Fall','Winter']>>>List(enumerate(seasons))[(0,'Spring'),(1,'Summer'),(2,'Fall'),(3,'Winter')]# 指定起始值，小标从1开始>>>List(enumerate(seasons,start=1)) [(1,(4,'Winter')]普通for循环：>>>i = 0>>>seq = ['one','three']>>>for element in seq:... print(i,seq[i])... i += 1for循环使用enumerate>>>seq = ['one','three']>>>for i,element in enumerate(seq):... print(i,seq[i])同样输出：0 one1 two2 three

（20） range()

（21） iter()

>>> a = iter('abcd') #字符串序列>>> a>>> next(a)'a'>>> next(a)'b'>>> next(a)'c'>>> next(a)'d'>>> next(a)Traceback (most recent call last): file "",line 1,in  next(a)stopiteration

（22） slice()

语法：class slice(stop)class slice(start,stop[,step])# 设置截取5个元素的切片>>>myslice = slice(5) >>> mysliceslice(None,None)>>> arr = range(10)>>> arr[0,9]# 截取 5 个元素>>> arr[myslice] [0,4]

（23） super()

语法：super(type[,object-or-type])# type -- 类。# object-or-type -- 类，一般是 selfclass A: passclass B(A): def add(self,x): super().add(x)

（24） object()

3、序列 *** 作（8个）

（1） all()

>>> all(['a','','d']) # 列表List，存在一个为空的元素False>>> all([0,1，2,3]) # 列表List，存在一个为0的元素False>>> all([]) # 空列表True>>> all(()) # 空元组True

（2） any()

（3） filter()

（4） map()

>>>def square(x) : # 计算平方数... return x ** 2>>> map(square,5]) # 计算列表各个元素的平方[1,9,16,25]>>> map(lambda x: x ** 2,5]) # 使用 lambda 匿名函数[1,25]提供了两个列表，对相同位置的列表数据进行相加
map(lambda x,y: x + y,9],[2,10])
[3,11,15,19]

（5） next()

>>> a = iter('abcd')>>> next(a)'a'>>> next(a)'b'>>> next(a)'c'>>> next(a)'d'>>> next(a)Traceback (most recent call last): file "",in  next(a)stopiteration>>> next(a,'e')'e'>>> next(a,'e')'e'

（6） reversed()`` + 反转序列生成新的可迭代对象，语法： reversed(seq)`

seqList = [1,5]print(List(reversed(seqList)))输出：[5,1]

（7） sorted()

语法：sorted(iterable,key=None,reverse=False) # key主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序，reverse=True降序，reverse=False升序（默认）。>>>sorted({1: 'D',2: 'B',3: 'B',4: 'E',5: 'A'})[1,5]# 利用key进行倒序排序>>>example_List = [5,4]>>> result_List = sorted(example_List,key=lambda x: x*-1)>>> print(result_List)[7,0]

（8） zip()

>>> a = [1,3]>>> b = [4,6]>>> c = [4,8]>>> zipped = zip(a,b) # 返回一个对象>>> zipped>>> List(zipped) # List() 转换为列表[(1,4),5),6)]>>> List(zip(a,c)) # 元素个数与最短的列表一致[(1,6)]
a1,a2 = zip(zip(a,b)) # 与 zip 相反，zip() 可理解为解压，返回二维矩阵式
List(a1)
[1,3]
List(a2)
[4,6]

4、对象 *** 作(9个)

（1） help()

（2） dir()

>>> import math>>> math>>> dir(math)['__doc__','__loader__','__name__','__package__','__spec__','acos','acosh','asin','asinh','atan','atan2','atanh','ceil','copysign','cos','cosh','degrees','erf','erfc','exp','expm1','fabs','factorial','floor','fmod','frexp','fsum','gamma','gcd','hypot','inf','isclose','isfinite','isinf','isnan','ldexp','lgamma','log','log10','log1p','log2','modf','nan','pi','pow','radians','sin','sinh','sqrt','tan','tanh','trunc']

（3） ID()

（4） hash()

>>>hash('test') # 字符串2314058222102390712>>> hash(1) # 数字1>>> hash(str([1,3])) # 集合1335416675971793195>>> hash(str(sorted({'1':1}))) # 字典7666464346782421378

（5） type()

参数：name -- 类的名称。bases -- 基类的元组。dict -- 字典，类内定义的命名空间变量。# 使用type函数创建类型D，含有属性InfoD>>> D = type('D',(A,B),dict(InfoD='some thing defined in D'))>>> d = D()>>> d.InfoD 'some thing defined in D'

（6） len()

（7） ascii()

>>>a = ascii('paul你好')>>>print(a)'paul\u4f60\u597d'

（8） format()

>>>"{} {}".format("hello","world") # 不设置指定位置，按默认顺序'hello world'>>> "{1} {0} {1}".format("hello","world") # 设置指定位置'world hello world'print("网站名：{name},地址 {url}".format(name="菜鸟教程",url="www.runoob.com"))# 通过字典设置参数site = {"name": "菜鸟教程","url": "www.runoob.com"}print("网站名：{name},地址 {url}".format(**site))# 通过列表索引设置参数my_List = ['菜鸟教程','www.runoob.com']print("网站名：{0[0]},地址 {0[1]}".format(my_List)) # "0" 是**必须**的输出：网站名：菜鸟教程,地址 www.runoob.comclass AssignValue(object): def __init__(self,value): self.value = valuemy_value = AssignValue(6)print('value 为: {0.value}'.format(my_value)) # "0" 是**可选**的

（9） vars()

>>>print(vars()){'__builtins__': ,'__name__': '__main__','__doc__': None,'__package__': None}>>> class Runoob:... a = 1>>> print(vars(Runoob)){'a': 1,'__module__': '__main__','__doc__': None}>>> runoob = Runoob()>>> print(vars(runoob)){}

5、反射 *** 作(8个)

（1） import()

（2） isinstance()

type() 不会认为子类是一种父类类型，==不考虑继承关系==isinstance() 会认为子类是一种父类类型，==考虑继承关系====如果要判断两个类型是否相同推荐使用isinstance()==>>> isinstance (a,(str,int,List)) # 是元组中的一个返回 TrueTrueclass A: pass
class B(A):
pass
isinstance(A(),A) # returns True
type(A()) == A # returns True
isinstance(B(),A) # returns True
type(B()) == A # returns False

（3） issubclass()

>>> issubclass(bool,int)True>>> issubclass(bool,str)False>>> issubclass(bool,int))True

（4） hasattr()

>>> class Student: def __init__(self,name): self.name = name>>> s = Student('aim')>>> hasattr(s,'name') #a含有name属性True>>> hasattr(s,'age') #a不含有age属性False

（5） getattr()

>>>class A(object):... bar = 1... >>> a = A()>>> getattr(a,'bar') # 获取属性 bar 值1>>> getattr(a,'bar2') # 属性bar2不存在，触发异常Traceback (most recent call last): file "",in AttributeError: 'A' object has no attribute 'bar2'>>> getattr(a,'bar2',3) # 属性bar2不存在，但设置了默认值3

（6） setattr()

语法：setattr(object,name,value) #（对象，字符串/对象属性，属性值）>>>class A(object):... bar = 1... >>> a = A()# 获取属性 bar 值>>> getattr(a,'bar') 1# 设置属性 bar 值>>> setattr(a,'bar',5) >>> a.bar5

（7） delattr()

（8） callable()

>>> class B: #定义类B def __call__(self): print('instances are callable Now.')>>> callable(B) #类B是可调用对象True>>> b = B() #调用类B>>> callable(b) #实例b是可调用对象True>>> b() #调用实例b成功

6、变量 *** 作(2个)

（1） globals()

>>>a='runoob'>>>print(globals())# globals 函数返回一个全局变量的字典，包括所有导入的变量。{'__builtins__': ,'a': 'runoob','__package__': None}

（2） locals()

>>>def runoob(arg): # 两个局部变量：arg、z... z = 1... print (locals())... >>> runoob(4){'z': 1,'arg': 4} # 返回一个名字/值对的字典

7、交互 *** 作(2个)

（1） print()

（2） input()

8、文件 *** 作(1个)

（1） open()

open(file,mode='r',buffering=-1,enCoding=None,errors=None,newline=None,closefd=True,opener=None)file: 必需，文件路径（相对或者绝对路径）mode: 可选，文件打开模式buffering: 设置缓冲enCoding: 一般使用utf8errors: 报错级别newline: 区分换行符closefd: 传入的file参数类型opener:

模式 描述 t 文本模式 (默认)。 x 写模式，新建一个文件，如果该文件已存在则会报错。 b 二进制模式。 + 打开一个文件进行更新(可读可写)。 U 通用换行模式（不推荐）。 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 r+ 打开一个文件用于读写。文件指针将会放在文件的开头。 rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 9、编译执行(4个)

（1） compile()

语法：compile(source,filename,mode[,flags[,dont_inherit]])参数：source -- 字符串或者AST（Abstract Syntax Trees）对象。。filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。mode -- 指定编译代码的种类。可以指定为 exec,eval,single。flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。flags和dont_inherit是用来控制编译源码时的标志>>>str = "for i in range(0,3): print(i)" >>> c = compile(str,'exec') # 编译为字节代码对象 >>> c at 0x10141e0b0,file "",line 1>>>> exec(c)012>>> str = "3 * 4 + 5">>> a = compile(str,'eval')>>> eval(a)17

（2） eval()

>>>x = 7>>> eval( '3 * x' )21>>> eval('pow(2,2)')4>>> eval('2 + 2')4>>> n=81>>> eval("n + 4")85

x = 10expr = """z = 30sum = x + y + zprint(sum)"""def func(): y = 20 # 局部变量y exec(expr)  exec(expr,{'x': 1,'y': 2}) exec(expr,'y': 2},{'y': 3,'z': 4}) # 在expr语句中，有三个变量x,y,z,其中z值已给定，我们可以在exec()函数外指定x,y的值，也可以在exec()函数中以字典的形式指定x,y的值。在最后的语句中，我们给出了x,z的值，并且y值重复，exec()函数接收后面一个y值，且z值传递不起作用，因此输出结果为34
func()
输出：
60
33
34
eval()函数和exec()函数的区别：
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。

>>>s = 'RUNOOB'>>> repr(s)"'RUNOOB'">>> dict = {'runoob': 'runoob.com','Google': 'Google.com'};>>> repr(dict)"{'Google': 'Google.com','runoob': 'runoob.com'}"

参数：fget -- 获取属性值的函数fset -- 设置属性值的函数fdel -- 删除属性值函数doc -- 属性描述信息# 将 property 函数用作装饰器可以很方便的创建只读属性class Parrot(object): def __init__(self): self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的代码将 voltage() 方法转化成同名只读属性的getter方法。property的getter,setter 和deleter方法同样可以用作装饰器：
class C(object):
def init(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self,value):
self._x = value
@x.deleter
def x(self):
del self._x
class C:
def init(self):
self._name = ''
@property
def name(self):
"""i'm the 'name' property."""
return self._name
@name.setter
def name(self,value):
if value is None:
raise RuntimeError('name can not be None')
else:
self._name = value
c = C()
c.name # 访问属性
''
c.name = None # 设置属性时进行验证
Traceback (most recent call last):
file "<pyshell#84>",in 
c.name = None
file "<pyshell#81>",line 11,in name
raise RuntimeError('name can not be None')
RuntimeError: name can not be None
c.name = 'Kim' # 设置属性
c.name # 访问属性
'Kim'
del c.name # 删除属性，不提供deleter则不能删除
Traceback (most recent call last):
file "<pyshell#87>",in 
del c.name
AttributeError: can't delete attribute
c.name
'Kim'

class A(object): bar = 1 def func1(self):  print ('foo')  @classmethod def func2(cls): print ('func2') print (cls.bar) cls().func1() # 调用 foo 方法
A.func2() # 不需要实例化

class C(object): @staticmethod def f(arg1,arg2,...): pass# 以上实例声明了静态方法f，类可以不用实例化就可以调用该方法C.f()，当然也可以实例化后调用C().f()。class C(object): @staticmethod def f(): print('runoob');
C.f() # 静态方法无需实例化
cobj = C()
cobj.f() # 也可以实例化后调用
使用装饰器定义静态方法
class Student(object):
def init(self,name):
self.name = name
@staticmethod
def sayHello(lang):
print(lang)
if lang == 'en':
print('Welcome!')
else:
print('你好！')
Student.sayHello('en') #类调用,'en'传给了lang参数
en
Welcome!
b = Student('Kim')
b.sayHello('zh') #类实例对象调用,'zh'传给了lang参数
zh
你好