内置函数在__builtins__模块中，随python解释器自动导入;等同于内建模块builtins
1.abs()函数
'''abs()函数返回参数的绝对值。绝对值：absolute正如字面上的意思，可以返回一个绝对值'''importmathprint('abs(45)的值:',abs(45))print('abs(-45)的值:',abs(-45))print('abs(45+23)的值:',abs(45+23))print('abs(math.pi)的值:',abs(math.pi))print(3+4j) #复数的绝对值即他的模,即sqrt（3^2+（-4）^2）=5print(help(abs))'''运行结果：abs(45)的值:45abs(-45)的值:45abs(45+23)的值:68abs(math.pi)的值:3.141592653589793Helponbuilt-infunctionabsinmodulebuiltins:abs(x,/)Returntheabsolutevalueoftheargument.None在python2里还可以输出print"abs(119L):",abs(119L)不过python3中abs函数只能输入int型不然会报错'''
2.all()函数详解
'''all()函数用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是返回True，否则返回False。元素除了是0、空、FALSE外都算TRUE。语法以下是all()方法的语法:all(iterable)参数iterable--元组或列表。返回值如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；注意：空元组、空列表返回值为True，这里要特别注意。'''print(all(['a','b','c','']))#列表存在一个为空的元素，返回Falseprint(all(['a','b','c','d']))#列表都有元素，返回Trueprint(all([0,1,2,3,4,5,6]))#列表里存在为0的元素返回Falseprint(all(('a','b','c','')))#元组存在一个为空的元素，返回Fasleprint(all(('a','b','c','d')))#元组都有元素，返回Trueprint(all((0,1,2,3,4,5)))#元组存在一个为0的元素，返回Fasleprint(all([]))#空列表返回Trueprint(all(()))#空元组返回True
3.any()函数
'''any()函数用于判断给定的可迭代参数iterable是否全部为False，则返回False，如果有一个为True，则返回True。元素除了是0、空、FALSE外都算TRUE。语法以下是any()方法的语法:any(iterable)参数iterable--元组或列表。返回值如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。'''print(any(['a','b','c','']))#列表存在一个为空的元素，返回Trueprint(any(['a','b','c','d']))#列表都不为空，返回Trueprint(any([0,'',False]))#列表里的元素全为0,'',False返回Falseprint(any(('a','b','c','')))#元组存在一个为空的元素，返回Trueprint(any(('a','b','c','d')))#元组都有元素，返回Trueprint(any((0,'',False)))#元组里的元素全为0,'',False返回Falseprint(any([]))#空列表返回Falseprint(any(()))#空元组返回False
4.ascii()函数
'''ascii()函数类似repr()函数,返回一个表示对象的字符串,但是对于字符串中的非ASCII字符则返回通过repr()函数使用\x,\u或\U编码的字符。生成字符串类似Python2版本中repr()函数的返回值。语法以下是ascii()方法的语法:ascii(object)参数object--对象。返回值返回字符串'''print(ascii('uiatfu'))
5.bin()函数
'''函数原型bin(x)参数解释x整数型，参数不可为空。返回值
6.bool()函数
'''描述bool()函数用于将给定参数转换为布尔类型，如果没有参数，返回False。bool是int的子类。语法以下是bool()方法的语法:classbool([x])参数x--要进行转换的参数。返回值返回Ture或False。'''print(bool(0))#返回Falseprint(bool(1))#返回Trueprint(bool(True))#返回Trueprint(bool(False))#返回Falseprint(bool(''))#返回False#0,False,'',None常量、空字符串等均代表Fasle;''有空格则代表True了
7.bytes()函数
'''描述bytes函数返回一个新的bytes对象，该对象是一个0<=x<256区间内的整数不可变序列。它是bytearray的不可变版本。语法以下是bytes的语法:classbytes([source[,encoding[,errors]]])参数如果source为整数，则返回一个长度为source的初始化数组；如果source为字符串，则按照指定的encoding将字符串转换为字节序列；如果source为可迭代类型，则元素必须为[0,255]中的整数；如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray。如果没有输入任何参数，默认就是初始化数组为0个元素。返回值返回一个新的bytes对象。将一个字符串转换成字节类型'''print(bytes('python',encoding='utf-8'))#输出b'python'print(bytes('张三',encoding='utf-8'))#输出b'\xe5\xbc\xa0\xe4\xb8\x89'print(bytes([1,2,3,4]))#输出b'\x01\x02\x03\x04'print(bytes('hello','ascii'))#输出b'hello'print(type(bytes([1,2,3])))#输出
8.challable()函数
'''challable()判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例'''print(callable(max))#输出Trueprint(callable([1,2,3]))#输出Fasleprint(callable(None))#输出Fasleprint(callable('str'))#输出Fasledeffn(x):returnx*xprint(callable(fn))#输出True证明自定义的函数也可以
9.chr()函数（注：与ord()函数相对）
'''Unicode编码转化为字符方法描述chr()用一个整数作参数，返回一个对应的字符。语法以下是chr()方法的语法:chr(i)参数i--可以是10进制也可以是16进制的形式的数字，数字范围为0到1,114,111(16进制为0x10FFFF)。返回值返回值是当前整数对应的ASCII字符。'''#print(chr(-1))#报错ValueError:chr()argnotinrange(0x110000)超出范围不能小于0print(chr(0x30))#输出0print(chr(97))#输出aprint(chr(8364))#输出€print(chr(26446))#输出李
10.classmethod()函数
'''描述classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。语法classmethod语法：classmethod参数无。返回值返回函数的类方法。'''classStud:num=1deffn1(self):print('方法一')@classmethoddeffn2(cls):print('方法二')#输出方法二print(cls.num)#调用类的实例化对象cls().fn1()#调用类的方法Stud.fn2()#输出方法二不需要实例化print('===='*10)object=Stud()object.fn1()#输出方法一需要实例化
11.complex()函数
'''描述complex()函数用于创建一个值为real+imag*j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。语法complex语法：classcomplex([real[,imag]])参数说明：real--int,long,float或字符串；imag--int,long,float；返回值返回一个复数。'''print(complex(1,2))#输出(1+2j)print(complex(1))#输出(1+0j)print(complex('2'))#输出(2+0j)#注意：这个地方在"+"号两边不能有空格，也就是不能写成"1+2j"，应该是"1+2j"，否则会报错print(complex('2+3j'))#输出(2+3j)print(complex(1.2,3.4))#输出(1.2+3.4j)
12.complie()函数
'''complie()将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译1compile(source,filename,mode,flags=0,dont_inherit=False,optimize=-1)2将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。3参数source：字符串或者AST（abstractsyntaxtrees）对象。4参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。5参数model：指定编译代码的种类。可以指定'exec','eval','single'。6参数flag和dont_inherit：这两个参数为可选参数。'''s="print('helloworld')"r=compile(s,'hello','exec')print(r)#输出结果：#
13.delattr()函数
'''描述：delattr函数用于删除属性delattr(x,'foobar)相当于delx.foobar语法：setattr(object,name)参数：object--对象name--必须是对象的属性返回值：无'''classPeople():sex='男'def__init__(self,name):self.name=namedefpeopleinfo(self):print('欢迎%s访问'%self.name)delattr(People,'sex')#等同于delPeople.sexprint(People.__dict__)#输出{'__module__':'__main__','__init__':
14.dict()函数
'''描述dict()函数用于创建一个字典。语法dict语法：classdict(**kwarg)classdict(mapping,**kwarg)classdict(iterable,**kwarg)参数说明：**kwargs--关键字mapping--元素的容器。iterable--可迭代对象。返回值返回一个字典。'''print(dict())#创建空字典dict1=dict(a='a',b='b',t='t')#传入关键字构建字典print(dict1)#输出{'a':'a','b':'b','t':'t'}dict2=dict(zip(['one','two','three'],[1,2,3]))#映射函数方式来构造字典print(dict2)#输出{'one':1,'two':2,'three':3}dict3=dict([('one',1),('two',2),('three',3)])#可迭代对象方式来构造字典print(dict3)#输出{'one':1,'two':2,'three':3}
15.dir()函数
16.divmod()函数
'''pythondivmod()函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a//b,a%b)。在python2.3版本之前不允许处理复数。函数语法divmod(a,b)参数说明：a:数字b:数字'''print(divmod(20,4))#返回(5,0)print(divmod(7,2))#返回(3,1)print(divmod(8,2))#返回(4,0)#print(divmod(1+2j,1+0.5j))#报错TypeError:can'ttakefloorormodofcomplexnumber.
17.enumerate()函数
'''enumerate是翻译过来是枚举的意思，看下它的方法原型：enumerate(sequence,start=0)，返回一个枚举对象。sequence必须是序列或迭代器iterator，或者支持迭代的对象。enumerate()返回对象的每个元素都是一个元组，每个元组包括两个值，一个是计数，一个是sequence的值，计数是从start开始的，start默认为0。---------------------'''a=["q","w","e","r"]c=enumerate(a)foriinc:print(i)'''输出如下:(0,'q')(1,'w')(2,'e')(3,'r')'''a=["w","a","s","d"]#这里加了个参数2，代表的是start的值c=enumerate(a,2)foriinc:print(i)'''输出如下：(2,'w')(3,'a')(4,'s')(5,'d')'''a=["q","w","e","r"]#创建一个空字典b=dict()#这里i表示的是索引，item表示的是它的值fori,iteminenumerate(a):b[i]=itemprint(b)#输出{0:'q',1:'w',2:'e',3:'r'}fori,jinenumerate('abc'):print(i,j)#输出结果#0a#1b#2c
18.eval()函数
'''eval()函数用来执行一个字符串表达式，并返回表达式的值。语法以下是eval()方法的语法:eval(expression[,globals[,locals]])参数expression--表达式。globals--变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。locals--变量作用域，局部命名空间，如果被提供，可以是任何映射对象。返回值返回表达式计算结果。'''x=7print(eval('3*x'))#返回21print(eval('pow(2,2)'))#返回4print(eval('3+5'))#返回8#eval函数还可以实现list、dict、tuple与str之间的转化#1.字符串转换成列表a="[[1,2],[3,4],[5,6],[7,8],[9,0]]"print(type(a))#返回
19.exec()函数
20.filter()函数
'''filter()函数是一个对于可迭代对象的过滤器，过滤掉不符合条件的元素，返回的是一个迭代器，如果要转换为列表，可以使用list()来转换。该函数接收两个参数，第一个为函数的引用或者None，第二个为可迭代对象，可迭代对象中的每个元素作为参数传递给函数进行判，然后返回True或False，最后将返回True的元素放到迭代器中下面看下fiter()的用法：'''my_list=[1,2,'',3,4,'6','']new_list=list(filter(None,my_list))print(new_list)#None函数过滤掉''而不是过滤掉空字符串；或0defis_oushu(x):returnx%2==0new_list=list(filter(is_oushu,list(range(1,11))))print(new_list)#过滤掉不是偶数的数a=[1,2,3,4,5,6,2,2,2,]print(list(filter(lambdax:x!=2,a)))#筛选出列表里所有的不是2的元素
21.float()函数
'''描述float()函数用于将整数和字符串转换成浮点数。语法float()方法语法：classfloat([x])参数x--整数或字符串返回值返回浮点数。'''print(float(1))#输出1.0print(float(112.0))#输出112.0print(float('123'))#输出123.0print(float(True))#输出1.0print(float(False))#输出0.0#print(float('a'))#报错ValueError:couldnotconvertstringtofloat:'a'
22.format()函数
23.frozenset()函数
'''描述frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。语法frozenset()函数语法：classfrozenset([iterable])参数iterable--可迭代的对象，比如列表、字典、元组等等。返回值返回新的frozenset对象，如果不提供任何参数，默认会生成空集合。'''a=frozenset(range(10))print(a)#输出frozenset({0,1,2,3,4,5,6,7,8,9})b=frozenset('ltftyut1234')print(b)#输出frozenset({'2','4','t','f','1','3','l','y','u'})#1frozenset([iterable])#2set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，#3一般来说使用fronzet的地方都可以使用set。#4参数iterable：可迭代对象。
24.getattr()函数
'''描述：getattr()函数用于返回一个对象属性值语法：getattr(object,name,default)参数：object--对象name--字符串，对象属性default--默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError。返回值：返回对象属性值'''classPeople():sex='男'def__init__(self,name):self.name=namedefpeopleinfo(self):print('欢迎%s访问'%self.name)obj=getattr(People,'sex')print(obj)#返回值男#obj=getattr(People,'sexage')#print(obj)'''报错。。。Traceback(mostrecentcalllast):File"G:/pythonAI/Python_funs/getattr函数详解.py",line24,in
25.globals()函数
26.hasattr()函数
'''hasattr()函数用于判断是否包含对应的属性语法：hasattr(object,name)参数：object--对象name--字符串，属性名返回值：如果对象有该属性返回True，否则返回False'''classPeople():sex='男'def__init__(self,name):self.name=namedefpeopleinfo(self):print('欢迎%s访问'%self.name)obj=People('zhangsan')print(hasattr(People,'sex'))#输出Trueprint('sex'inPeople.__dict__)#输出Trueprint(hasattr(obj,'peopleinfo'))#输出Trueprint(People.__dict__)#输出{'__module__':'__main__','sex':'男','__init__':
27.hash()函数
28.hex()函数
'''描述hex()函数将一个整数转换成十六进制字符串。语法hex语法：hex(x)参数说明：x--整数。返回值返回十六进制字符串。'''print(hex(12))#输出12的八进制0xcprint(hex(-120))#输出-12的二进制-0x78print(type(hex(12)))#输出oct(12)的类型
29.id()函数
30.input()函数
'''Python3.x中input()函数接受一个标准输入数据，返回为string类型。注意：在Python3.x中raw_input()和input()进行了整合，去除了raw_input()，仅保留了input()函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。函数语法input([prompt])参数说明：prompt:提示信息'''a=input('请输入一个数:')#输入10print(a)#输出10print(type(a))#输出
31.int()函数
32.isinstance()函数
'''isinstance()函数来判断一个对象是否是一个已知的类型，类似type()。isinstance()与type()区别：type()不会认为子类是一种父类类型，不考虑继承关系。isinstance()会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用isinstance()。语法以下是isinstance()方法的语法:isinstance(object,classinfo)参数object--实例对象。classinfo--可以是直接或间接类名、基本类型或者有它们组成的元组。返回值如果对象的类型与参数二的类型（classinfo）相同则返回True，否则返回False。。'''a=2print(isinstance(a,int))#返回Trueprint(isinstance(a,str))#返回Fasleprint(isinstance(a,(str,int,list)))#返回True是元组中的一个类型就行classA:passclassB(A):passprint(isinstance(A(),A))#returnsTrueprint(type(A())==A)#returnsTrueprint(isinstance(B(),A))#returnsTrueprint(type(B())==A)#returnsFalse
33.issubclass()函数
34.iter()函数
35.lambda()函数
'''匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。lambda函数可以接收任意多个参数(包括可选参数)并且返回单个表达式的值。要点：1，lambda函数不能包含命令，2，包含的表达式不能超过一个。说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。'''defsum(x,y):returnx+yprint(sum(4,6))f=lambdax,y:x+yprint(f(4,6))#这俩个例子的效果是一样的，都是返回x+ya=lambdax:x*xprint(a(4))#传入一个参数的lambda函数返回x*xb=lambdax,y,z:x+y*zprint(b(1,2,3))#返回x+y*z即1+2*3=7#2.方法结合使用fromfunctoolsimportreducefoo=[2,18,9,22,17,24,8,12,27]print(list(filter(lambdax:x%3==0,foo)))#筛选x%3==0的元素print(list(map(lambdax:x*2+10,foo)))#遍历foo每个元素乘2+10再输出print(reduce(lambdax,y:x+y,foo))#返回每个元素相加的和
36.len()函数
'''描述Pythonlen()方法返回对象（字符、列表、元组等）长度或项目个数。语法len()方法语法：len(s)参数s--对象。返回值返回对象长度。'''str1='ltf1234'print(len(str1))#输出7list1=[1,2,3,4,5,6,7,8]print(len(list1))#输出8foriinrange(len(list1)):print(i)#依次输出1-8dict={'num':777,'name':"anne"}print(len(dict))#输出2
37.list()函数
'''list()列表构造函数1list([iterable])2list类的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。3该函数创建一个列表，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建列表的一个拷贝并返回，就像语句iterables[:]。描述：list()方法用于将可迭代对象转换为列表。语法：list()方法语法：lidt()list(tup)list(dict)list(str)list(iterable)......参数：iterable--要转换的可迭代对象。返回值：返回列表。'''list()#返回空列
aTuple=(123,'xyz','zara','abc');aList=list(aTuple)print"列表元素:",aList
list({"a":1,"b":2})
list("abcd")
list(range(10))
38.locals()函数
'''locals()函数会以字典类型返回当前位置的全部局部变量。对于函数,方法,lambda函式,类,以及实现了__call__方法的类实例,它都返回True。语法locals()函数语法：locals()参数无返回值返回字典类型的局部变量1不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。2在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。3不能在类区域内返回自由变量。'''deftest_py(arg):z=1print(locals())test_py(6)#输出{'z':1,'arg':6}deffoo(arg,a):x=100y='hellopython!'foriinrange(10):j=1k=iprint(locals())foo(1,2)#输出{'k':9,'j':1,'i':9,'y':'hellopython!','x':100,'a':2,'arg':1}
39.map()函数
40.max()函数
'''描述max()方法返回给定参数的最大值，参数可以为序列。语法以下是max()方法的语法:max(x,y,z,....)参数x--数值表达式。y--数值表达式。z--数值表达式。返回值返回给定参数的最大值。'''print("max(80,100,1000):",max(80,100,1000))print("max(-20,100,400):",max(-20,100,400))print("max(-80,-20,-10):",max(-80,-20,-10))print("max(0,100,-400):",max(0,100,-400))'''输出结果：max(80,100,1000):1000max(-20,100,400):400max(-80,-20,-10):-10max(0,100,-400):100'''#1.传入的多个参数的最大值print(max(1,2,3,4))#输出4#2.传入可迭代对象时，取其元素最大值s='12345'print(max(s))#输出5#3.传入命名参数key，其为一个函数，用来指定取最大值的方法s=[{'name':'sumcet','age':18},{'name':'bbu','age':11}]a=max(s,key=lambdax:x['age'])print(a)#输出{'name':'sumcet','age':18}
41.min()函数
'''描述min()方法返回给定参数的最小值，参数可以为序列。语法以下是min()方法的语法:min(x,y,z,....)参数x--数值表达式。y--数值表达式。z--数值表达式。返回值返回给定参数的最小值。'''print("min(80,100,1000):",min(80,100,1000))print("min(-20,100,400):",min(-20,100,400))print("min(-80,-20,-10):",min(-80,-20,-10))print("min(0,100,-400):",min(0,100,-400))'''输出结果min(80,100,1000):80min(-20,100,400):-20min(-80,-20,-10):-80min(0,100,-400):-400'''#1.传入的多个参数的最小值print(min(1,2,3,4))#输出1#2.传入可迭代对象时，取其元素最小值s='12345'print(min(s))#输出1#3.传入命名参数key，其为一个函数，用来指定取最小值的方法s=[{'name':'sumcet','age':18},{'name':'bbu','age':11}]a=min(s,key=lambdax:x['age'])print(a)#输出{'name':'bbu','age':11}
42.next()函数
'''描述next()返回迭代器的下一个项目。语法next语法：next(iterator[,default])参数说明：iterator--迭代器或生成器对象default--可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发StopIteration异常。返回值返回对象帮助信息。'''#首先获得Iterator对象:it=iter([1,2,3,4,5])#循环:whileTrue:try:#获得下一个值:x=next(it)print(x)exceptStopIteration:#遇到StopIteration就退出循环breaka=iter('abcde')print(next(a))#输出aprint(next(a))#输出bprint(next(a))#输出cprint(next(a))#输出dprint(next(a))#输出e#print(next(a))#报错StopIteration#函数可以接收一个可选的default参数，传入default参数后，#如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，#则返回default指定的默认值而不抛出StopIteration异常。print(next(a,'e'))#这次不报错了返回e即default参数
43.oct()函数
'''描述oct()函数将一个整数转换成八进制字符串。语法oct语法：oct(x)参数说明：x--整数。返回值返回八进制字符串。'''print(oct(12))#输出12的八进制0o14print(oct(-120))#输出-12的二进制-0o170print(type(oct(12)))#输出oct(12)的类型
44.open()函数
45.ord()函数
'''描述ord()函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的Python定义范围，则会引发一个TypeError的异常。语法以下是ord()方法的语法:ord(c)参数c--字符。返回值返回值是对应的十进制整数。'''print(ord('a'))#输出97print(ord('b'))#输出98print(ord('c'))#输出99print(ord(']'))#输出93print(ord('8'))#输出56
46.pow()函数
'''描述pow()方法返回xy（x的y次方）的值。语法以下是math模块pow()方法的语法:importmathmath.pow(x,y)内置的pow()方法pow(x,y[,z])函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y)%z注意：pow()通过内置的方法直接调用，内置方法会把参数作为整型，而math模块则会把参数转换为float。参数x--数值表达式。y--数值表达式。z--数值表达式。返回值返回xy（x的y次方）的值。'''importmath#导入math模块print("math.pow(100,2):",math.pow(100,2))#使用内置，查看输出结果区别print("pow(100,2):",pow(100,2))print("math.pow(100,-2):",math.pow(100,-2))print("math.pow(2,4):",math.pow(2,4))print("math.pow(3,0):",math.pow(3,0))'''输出结果...math.pow(100,2):10000.0pow(100,2):10000math.pow(100,-2):0.0001math.pow(2,4):16.0math.pow(3,0):1.0'''
47.property()函数
'''描述property()函数的作用是在新式类中返回属性值。语法以下是property()方法的语法:classproperty([fget[,fset[,fdel[,doc]]]])参数fget--获取属性值的函数fset--设置属性值的函数fdel--删除属性值函数doc--属性描述信息返回值返回新式类属性'''classC(object):def__init__(self):self._x=Nonedefgetx(self):returnself._xdefsetx(self,value):self._x=valuedefdelx(self):delself._xx=property(getx,setx,delx,"I'mthe'x'property.")classParrot(object):def__init__(self):self._voltage=100000#装饰器写法@propertydefvoltage(self):"""Getthecurrentvoltage."""returnself._voltageclassD(object):def__init__(self):self._x=None@propertydefx(self):"""I'mthe'x'property."""returnself._x@x.setterdefx(self,value):self._x=value@x.deleterdefx(self):delself._x
48.range()函数
'''range()函数可创建一个整数列表，一般用在for循环中。函数语法range([start,]stop[,step=1])参数说明：start:计数从start开始。默认是从0开始。例如range（5）等价于range（0，5）;stop:计数到stop结束，但不包括stop。例如：range（0，5）是[0,1,2,3,4]没有5step：步长，默认为1。例如：range（0，5）等价于range(0,5,1)返回range对象'''foriinrange(10):print(i)#输出从0-9foriinrange(0,11,2):print(i)#输出0,2,4,6,8,10foriinrange(0,-10,-3):print(i)#输出0,-3,-6,-9list=[]foriinrange(5,-5,-1):list.append(i)print(list)#输出[5,4,3,2,1,0,-1,-2,-3,-4]foriin'ahfgohiauf':print(i)#依次输出字符
49.reduece()函数
'''在python3中如果使用reduce需要先导入fromfunctoolsimportreducereduce函数，reduce函数会对参数序列中元素进行累积。reduce函数的定义：reduce(function,sequence[,initial])->valuefunction参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。'''fromfunctoolsimportreducelst=[1,2,3,4,5,6]deff(x,y):returnx+yprint(reduce(f,lst))'''过程1+2+3+4+5+6=21'''print(reduce(lambdax,y:x*y,lst))#运行过程为1*2*3*4*5*6=720#来个稍微复杂的print(reduce(lambdax,y:x*y+1,lst))'''运算步骤：1*2+1=33*3+1=1010*4+1=4141*5+1=206206*6+1=1237'''#再说说有初始化值的情况,这个时候就不是取列表的前两项,而是取初始值为第一个,#序列的第一个元素为第二个元素,开始进行lambda函数的应用计算.print(reduce(lambdax,y:x+y,lst,5))'''计算步骤：5+1=66+2=88+3=1111+4=1515+5=2020+6=26'''
50.repr()函数
'''描述repr()函数将对象转化为供解释器读取的形式。语法以下是repr()方法的语法:repr(object)参数object--对象。返回值返回一个对象的string格式。'''s='qwerasdf'print(s)#输出qwerasdfprint(repr(s))#输出'qwerasdf'dict={'a':1,'b':2}print(dict)#输出{'a':1,'b':2}print(repr(dict))#输出{'a':1,'b':2}没改变么print(repr([0,1,2,3,4]))#输出[0,1,2,3,4]print(repr('hello'))#输出'hello'print(str(1.0/7.0))#输出0.14285714285714285print(repr(1.0/7.0))#输出0.14285714285714285
51.reversed()函数
'''描述reversed函数返回一个反转的迭代器。语法以下是reversed的语法:reversed(seq)参数seq--要转换的序列，可以是tuple,string,list或range。返回值返回一个反转的迭代器。1reversed(seq)2返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__())3该函数是2.4中新增的'''str='wasdqwer'print(list(reversed(str)))#输出['r','e','w','q','d','s','a','w']tuple=('r','e','w','q','d','s','a','w')print(list(reversed(tuple)))#输出['w','a','s','d','q','w','e','r']seqRange=range(5,9)print(list(reversed(seqRange)))#输出[8,7,6,5]seqList=[1,2,4,3,5]print(list(reversed(seqList)))#输出[5,3,4,2,1]a=[1,2,3,4,5,6]b=reversed(a)print(b)#输出
52.round()函数
'''描述round()方法返回浮点数x的四舍五入值。语法以下是round()方法的语法:round(x[,n])参数x--数字表达式。n--表示从小数点位数，其中x需要四舍五入，默认值为0。返回值返回浮点数x的四舍五入值。'''print("round(70.23456):",round(70.23456))print("round(56.659,1):",round(56.659,1))print("round(80.264,2):",round(80.264,2))print("round(100.000056,3):",round(100.000056,3))print("round(-100.000056,3):",round(-100.000056,3))'''输出结果...round(70.23456):70round(56.659,1):56.7round(80.264,2):80.26round(100.000056,3):100.0round(-100.000056,3):-100.0'''
53.setattr()函数
'''描述：setattr函数，用于设置属性值，该属性必须存在语法：setattr(object,name,value)参数：object--对象name--字符串，对象属性value--属性值返回值：无'''classPeople():sex='男'def__init__(self,name):self.name=namedefpeopleinfo(self):print('欢迎%s访问'%self.name)obj=People('zhangsan')setattr(People,'x',123)print(People.x)#等同于Peopel.x=123setattr(obj,'age',18)print(obj.__dict__)#输出{'name':'zhangsan','age':18}print(People.__dict__)#输出#{'__module__':'__main__','sex':'男','__init__':
54.set()函数
55.slice()函数
'''描述slice()函数实现切片对象，主要用在切片操作函数里的参数传递。语法slice语法：classslice(stop)classslice(start,stop[,step])参数说明：start--起始位置stop--结束位置step--间距返回值返回一个切片对象。实例'''myslice=slice(5)#设置一个截取五个元素的切片print(myslice)#输出slice(None,5,None)arr=list(range(10))print(arr)#输出[0,1,2,3,4,5,6,7,8,9]print(arr[myslice])#输出[0,1,2,3,4]print(arr[3:6])#输出[3,4,5]
56.sorted()函数
57.staticmethod()函数
58.str()函数
'''描述str()函数将对象转化为适于人阅读的形式。语法以下是str()方法的语法:classstr(object='')参数object--对象。返回值返回一个对象的string格式。'''print(str(1))#输出字符串1print(type(str(1)))#输出
59.sum()函数
'''描述sum()方法对系列进行求和计算。语法以下是sum()方法的语法:sum(iterable[,start])参数iterable--可迭代对象，如：列表、元组、集合。start--指定相加的参数，如果没有设置这个值，默认为0。返回值返回计算结果'''print(sum([0,1,2]))#列表总和3print(sum((2,3,4),1))#元组计算总和后再加1print(sum([2,3,4,5,6],8))#列表计算总和后再加2a=list(range(1,11))b=list(range(1,10))c=sum([itemforiteminaifiteminb])print(c)#输出45
60.vars()函数
'''描述vars()函数返回对象object的属性和属性值的字典对象。如果不传入object参数，vars()和locals()的作用完全相同。语法vars()函数语法：vars([object])参数object--对象返回值返回对象object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值类似locals()。'''print(vars())#输出{'__name__':'__main__','__doc__':'\n描述\nvars()函数返回对象object的属性和属性值的字典对象。\n语法\nvars()函数语法：\nvars([object])\n参数\nobclassA:a=1__dict__='ltf'print(vars(A))#输出{'__module__':'__main__','a':1,'__dict__':
61.zip()函数
#zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,然后返回一个可迭代的zip对象.#这个可迭代对象可以使用循环的方式列出其元素#若多个可迭代对象的长度不一致,则所返回的可迭代元素长度与长度最短的可迭代对象相同.#1.用列表生成zip对象x=[1,2,3]y=[4,5,6]z=[7,8,9]h=['a','b','c','d']zip1=zip(x,y,z)print(zip1)foriinzip1:print(i)#打印结果如下：(1,4,7)(2,5,8)(3,6,9)zip2=zip(x,y,h)foriinzip2:print(i)#打印结果如下：(1,4,'a')(2,5,'b')(3,6,'c')zip3=zip(h)foriinzip3:print(i)print('==*=='*10)#2.二维矩阵变换l1=[[1,2,3],[4,5,6],[7,8,9]]print(l1)print([[j[i]forjinl1]foriinrange(len(l1[0]))])zip5=zip(*l1)foriinzip5:print(i)
62.print()函数
63.bytearray()函数
'''描述bytearray()方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围:0<=x<256。语法bytearray()方法语法：classbytearray([source[,encoding[,errors]]])参数如果source为整数，则返回一个长度为source的初始化数组；如果source为字符串，则按照指定的encoding将字符串转换为字节序列；如果source为可迭代类型，则元素必须为[0,255]中的整数；如果source为与buffer接口一致的对象，则此对象也可以被用于初始化bytearray。如果没有输入任何参数，默认就是初始化数组为0个元素。返回值返回新字节数组。创建bytearray对象的方法规则:bytearray()-bytearray(整数n)bytearray(整型可迭代对象)bytearray(b'字符串')bytearray(字符串,encoding='utf-8')'''>>>bytearray()bytearray(b'')>>>bytearray([1,2,3])bytearray(b'\x01\x02\x03')>>>bytearray('runoob','utf-8')bytearray(b'runoob')>>>
64.__import__()函数
'''描述__import__()函数用于动态加载类和函数。如果一个模块经常变化就可以使用__import__()来动态载入。用法：__import__(name[,globals[,locals[,fromlist[,level]]]])说明：1.函数功能用于动态的导入模块，主要用于反射或者延迟加载模块。2.__import__(module)相当于importmodule'''#!/usr/bin/envpython#encoding:utf-8importsys__import__('a')#导入a.py模块
65.type()函数
'''描述type()函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。isinstance()与type()区别：type()不会认为子类是一种父类类型，不考虑继承关系。isinstance()会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用isinstance()。语法以下是type()方法的语法:type(object)type(name,bases,dict)参数name--类的名称。bases--基类的元组。dict--字典，类内定义的命名空间变量。返回值一个参数返回对象类型,三个参数，返回新的类型对象。'''#一个参数实例>>>type(1)>>>type('runoob')>>>type([2])>>>type({0:'zero'})>>>x=1>>>type(x)==int#判断类型是否相等True#三个参数>>>classX(object):...a=1...>>>X=type('X',(object,),dict(a=1))#产生一个新的类型X>>>X#子类和父类属于不同的类型classAnimal():passclassHuman(Animal):passanimal=Animal()human=Human()print(type(animal)==type(human))print(type(animal))print(type(human))#输出结果：False
66.dict()函数
'''描述dict()函数用于创建一个字典。语法dict语法：classdict(**kwarg)classdict(mapping,**kwarg)classdict(iterable,**kwarg)参数说明：**kwargs--关键字mapping--元素的容器。iterable--可迭代对象。返回值返回一个字典。'''#!/usr/bin/python3dict0=dict()#传一个空字典print('dict0:',dict0)dict1=dict({'three':3,'four':4})#传一个字典print('dict1:',dict1)dict2=dict(five=5,six=6)#传关键字print('dict2:',dict2)dict3=dict([('seven',7),('eight',8)])#传一个包含一个或多个元祖的列表print('dict3:',dict3)dict5=dict(zip(['eleven','twelve'],[11,12]))#传一个zip()函数print('dict5:',dict5)#以上实例输出结果为：dict0:{}dict1:{'four':4,'three':3}dict2:{'five':5,'six':6}dict3:{'seven':7,'eight':8}dict5:{'twelve':12,'eleven':11}
68.tuple()函数
'''描述tuple函数将可迭代系列（如列表）转换为元组。语法以下是tuple的语法:tuple(iterable)参数iterable--要转换为元组的可迭代序列。返回值返回元组。'''a_list=['crazyit',20,-1.2]#将列表转换成元组a_tuple=tuple(a_list)print(a_tuple)#使用range()函数创建区间（range）对象a_range=range(1,5)print(a_range)#range(1,5)#将区间转换成元组b_tuple=tuple(a_range)print(b_tuple)#[1,2,3,4]#创建区间时还指定步长c_tuple=tuple(range(4,20,3))print(c_tuple)#[4,7,10,13,16,19]
69.super()函数
'''描述super()函数是用于调用父类(超类)的一个方法。super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO就是类的方法解析顺序表,其实也就是继承父类方法时的顺序表。语法以下是super()方法的语法:super(type[,object-or-type])参数type--类。object-or-type--类，一般是self'''classA:defadd(self,x):y=x+1print(y)classB(A):defadd(self,x):super().add(x)b=B()b.add(2)#3
70.breakpoint()函数
'''描述：Python3.7添加了breakpoint()，此函数将您放入调用站点的调试器中。具体来说，它调用sys.breakpointhook()，直接传递args和kws。默认情况下，sys.breakpointhook()调用pdb.set_trace()，不需要参数。在这种情况下，它纯粹是一个方便的函数，因此您不必显式地导入pdb或键入足够多的代码来进入调试器。但是，sys.breakpointhook()可以设置为其他函数，breakpoint()将自动调用该函数，允许您进入所选的调试器。语法：breakpoint(*args,**kws)参数介绍：*args,**kws---不定长参数'''importjsonfrommultiprocessingimportProcess,PipefromqueueimportQueueimportsysdefgetMyName(name):returnf"getMyName函数返回我的名字是：{name}"if__name__=='__main__':dt={"name":"tom","age":10,"sex":"m"}qs=getMyName('tomcat')print('--------调试开始')sys.breakpointhook()#出现(pdb)时输入dt;再(Pdb)输入qsifNone:print('True...')else:print('False...')
71.set()函数
'''描述set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。语法set语法：set([iterable])参数说明：iterable--可迭代对象对象；返回值返回新的集合对象。'''>>>x=set('runoob')>>>y=set('google')>>>x,y(set(['b','r','u','o','n']),set(['e','o','g','l']))#重复的被删除>>>x&y#交集set(['o'])>>>x|y#并集set(['b','e','g','l','o','n','r','u'])>>>x-y#差集set(['r','b','u','n'])
72.reduce()函数(python3.x后，非内置函数)
fromfunctoolsimportreduce格式：reduce(func,seq[,init])
reduce函数即为化简，它是这样一个过程：每次迭代，将上一次的迭代结果
（第一次时为init的元素，如没有init则为seq的第一个元素）与下一个元素一同执行一个二元的func函数。在reduce函数中，init是可选的，如果使用，则作为第一次迭代的第一个元素使用。