【python】内置函数
1.abs()#绝对值
2.all()#循环参数,如果每个参数都为真,那么all的返回值为真
假：0,None,"",[],(),{},空值
3.any()#只有一个真,则为真
4.ascii()#去传入对象的类中找__repr__，获取其返回值
5.bin()#十进制转二进制
6.oct()#十进制转八进制
7.int()#十进制
二进制转十进制
int('11',base=2)
八进制转十进制
int('11',base=8)
十六进制转十进制
int('11',base=16)
8.hex()#十进制转十六进制
9.bool()#判断真假，把一个对象转换成布尔值
10.str(data,coding)#转换成一个字符串,data:要转换的数据,coding:要转换成什么编码
11.list()#创建一个列表或转换成列表
12.bytes()#字节和字符串的装换
bytes("xxx",encoding="utf-8")
13.chr()# 输入ASCII 值返回字符
14.ord()#输入字符返回ASCII值
15.callable()#检查是否可执行的，可执行的返回true，不可执行返回false
def f1(): return 123 res=callable(f1) ret=callable(f2) print(res)#true print(ret)#false
16.compile()#把字符串编译成代码
17.divmod(a,b)# 返回a除以b的商和余数,主要用于分页
18.eval()#执行一个字符串形式的表达式
19.exec()#执行字符串的py代码
20.filter()#函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数： def is_odd(x): return x % 2 == 1 然后，利用filter()过滤掉偶数： >>>filter(is_odd, [1, 4, 6, 7, 9, 12, 17]) 结果： [1, 7, 9, 17] 利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串： def is_not_empty(s): return s and len(s.strip()) > 0 >>>filter(is_not_empty, ['test', None, '', 'str', ' ', 'END']) 结果： ['test', 'str', 'END'] 注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下： >>> a = ' 123' >>> a.strip() '123' >>> a = '\t\t123\r\n' >>> a.strip() '123' 练习： 请利用filter()过滤出1~100中平方根是整数的数，即结果应该是： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 方法： import math def is_sqr(x): return math.sqrt(x) % 1 == 0 print filter(is_sqr, range(1, 101)) 结果： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
21.map()#是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数： 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 注意：map()函数不改变原有的 list，而是返回一个新的 list。 利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。 任务 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart'] def format_name(s): s1=s[0:1].upper()+s[1:].lower(); return s1; print map(format_name, ['adam', 'LISA', 'barT']) 复制代码 map（）函数是python内置的高阶函数，对传入的list的每一个元素进行映射，返回一个新的映射之后的list
22.float()#转成浮点数的函数、
23.locals()#获取当前位置的所有局部变量，以字典的形式返回
34.globals()#获取所有全局变量，以字典的形式返回
35.format()#格式化字符串
自python2.6开始，新增了一种格式化字符串的函数str.format()，可谓威力十足。那么，他跟之前的%型格式化字符串相比，有什么优越的存在呢？让我们来揭开它羞答答的面纱。 语法 它通过{}和:来代替%。 “映射”示例 通过位置 In [1]: '{0},{1}'.format('kzc',18) Out[1]: 'kzc,18' In [2]: '{},{}'.format('kzc',18) Out[2]: 'kzc,18' In [3]: '{1},{0},{1}'.format('kzc',18) Out[3]: '18,kzc,18' 字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。 通过关键字参数 In [5]: '{name},{age}'.format(age=18,name='kzc') Out[5]: 'kzc,18' 通过对象属性 class Person: def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return 'This guy is {self.name},is {self.age} old'.format(self=self) In [2]: str(Person('kzc',18)) Out[2]: 'This guy is kzc,is 18 old' 通过下标 In [7]: p=['kzc',18] In [8]: '{0[0]},{0[1]}'.format(p) Out[8]: 'kzc,18' 有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。 格式限定符 它有着丰富的的“格式限定符”（语法是{}中带:号），比如： 填充与对齐 填充常跟对齐一起使用 ^、<、>分别是居中、左对齐、右对齐，后面带宽度 :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充 比如 In [15]: '{:>8}'.format('189') Out[15]: ' 189' In [16]: '{:0>8}'.format('189') Out[16]: '00000189' In [17]: '{:a>8}'.format('189') Out[17]: 'aaaaa189' 精度与类型f 精度常跟类型f一起使用 In [44]: '{:.2f}'.format(321.33345) Out[44]: '321.33' 其中.2表示长度为2的精度，f表示float类型。 其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。 In [54]: '{:b}'.format(17) Out[54]: '10001' In [55]: '{:d}'.format(17) Out[55]: '17' In [56]: '{:o}'.format(17) Out[56]: '21' In [57]: '{:x}'.format(17) Out[57]: '11' 用，号还能用来做金额的千位分隔符。 In [47]: '{:,}'.format(1234567890) Out[47]: '1,234,567,890'
36.hasattr(object, name)#判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
需要注意的是name要用括号括起来
>>> class test(): ... name="xiaohua" ... def run(self): ... return "HelloWord" ... >>> t=test() >>> hasattr(t, "name") #判断对象有name属性 True >>> hasattr(t, "run") #判断对象有run方法 True >>>
37.getattr(object, name[,default])#获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，
可以在后面添加一对括号。
>>> class test(): ... name="xiaohua" ... def run(self): ... return "HelloWord" ... >>> t=test() >>> getattr(t, "name") #获取name属性，存在就打印出来。 'xiaohua' >>> getattr(t, "run") #获取run方法，存在就打印出方法的内存地址。 <bound method test.run of <__main__.test instance at 0x0269C878>> >>> getattr(t, "run")() #获取run方法，后面加括号可以将这个方法运行。 'HelloWord' >>> getattr(t, "age") #获取一个不存在的属性。 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: test instance has no attribute 'age' >>> getattr(t, "age","18") #若属性不存在，返回一个默认值。 '18' >>>
38.setattr(object, name, values)#给对象的属性赋值，若属性不存在，先创建再赋值。
>>> class test(): ... name="xiaohua" ... def run(self): ... return "HelloWord" ... >>> t=test() >>> hasattr(t, "age") #判断属性是否存在 False >>> setattr(t, "age", "18") #为属相赋值，并没有返回值 >>> hasattr(t, "age") #属性存在了 True >>>
39.delattr()#函数作用用来删除指定对象的指定名称的属性，和setattr函数作用相反,当属性不存在的时候，会报错, 不能删除对象的方法
1. 函数作用用来删除指定对象的指定名称的属性，和setattr函数作用相反。 #定义类A >>> class A: def __init__(self,name): self.name = name def sayHello(self): print('hello',self.name) #测试属性和方法 >>> a.name '小麦' >>> a.sayHello() hello 小麦 #删除属性 >>> delattr(a,'name') >>> a.name Traceback (most recent call last): File "<pyshell#47>", line 1, in <module> a.name AttributeError: 'A' object has no attribute 'name' 2. 当属性不存在的时候，会报错。 >>> a.name #属性name已经删掉，不存在 Traceback (most recent call last): File "<pyshell#47>", line 1, in <module> a.name AttributeError: 'A' object has no attribute 'name' >>> delattr(a,'name') #再删除会报错 Traceback (most recent call last): File "<pyshell#48>", line 1, in <module> delattr(a,'name') AttributeError: name 3. 不能删除对象的方法。 >>> a.sayHello <bound method A.sayHello of <__main__.A object at 0x03F014B0>> >>> delattr(a,'sayHello') #不能用于删除方法 Traceback (most recent call last): File "<pyshell#50>", line 1, in <module> delattr(a,'sayHello') AttributeError: sayHello >>>
40.hash()#返回对象的哈希值，用整数表示。哈希值在字典查找时，可用于快速比较键的值。
1. 返回对象的哈希值，用整数表示。哈希值在字典查找时，可用于快速比较键的值。 >>> hash('good good study') 1032709256 2. 相等的数值，即使类型不一致，计算的哈希值是一样的。 >>> 1.0 == 1 True >>> hash(1.0) 1 >>> hash(1) 1 >>> hash(1.0000) 1
41.isinstance()#判断某个对象是否是某个类创建的，如果这个类是这个对象的父类也是true的。
li=[11,22] res=isinstance(li,list) print(res)#结果为true,list本身就是一个类
42.iter()函数#迭代器为类序列对象提供了一个类序列的接口。python的迭代无缝地支持序列对象，而且它还允许程序员迭代非序列类型，包括用户定义的对象。迭代器用起来很灵巧，你可以迭代不是序列但表现处序列行为的对象，例如字典的键、一个文件的行，等等
#iter and generator #the first try #================================= i = iter('abcd') print i.next() print i.next() print i.next() s = {'one':1,'two':2,'three':3} print s m = iter(s) print m.next() print m.next() print m.next() #代码输出如下结果 #a #b #c #{'three': 3, 'two': 2, 'one': 1} #three #two #one
43.len()#返回对象（字符、列表、元组等）长度或项目个数。
44.max()#取列表中的最大值
45.min()#取列表中的最小值
46.pow(x,y)#方法返回 xy（x的y次方） 的值。
47.reversed()#翻转列表和字典
48.round()#四舍五入
49.sum()#列表迭代求和
50.zip()#zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。
示例： 1.示例1： x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) print xyz 运行的结果是： [(1, 4, 7), (2, 5, 8), (3, 6, 9)] 从这个结果可以看出zip函数的基本运作方式。 2.示例2： x = [1, 2, 3] y = [4, 5, 6, 7] xy = zip(x, y) print xy 运行的结果是： [(1, 4), (2, 5), (3, 6)] 从这个结果可以看出zip函数的长度处理方式。 3.示例3： x = [1, 2, 3] x = zip(x) print x 运行的结果是： [(1,), (2,), (3,)] 从这个结果可以看出zip函数在只有一个参数时运作的方式。 4.示例4： x = zip() print x 运行的结果是： [] 从这个结果可以看出zip函数在没有参数时运作的方式。 5.示例5： x = [1, 2, 3] y = [4, 5, 6] z = [7, 8, 9] xyz = zip(x, y, z) u = zip(*xyz) print u 运行的结果是： [(1, 2, 3), (4, 5, 6), (7, 8, 9)] 一般认为这是一个unzip的过程，它的运行机制是这样的： 在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)] 那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9)) 所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)] 注：在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数） 6.示例6： x = [1, 2, 3] r = zip(* [x] * 3) print r 运行的结果是： [(1, 1, 1), (2, 2, 2), (3, 3, 3)] 它的运行机制是这样的： [x]生成一个列表的列表，它只有一个元素x [x] * 3生成一个列表的列表，它有3个元素，[x, x, x] zip(* [x] * 3)的意思就明确了，zip(x, x, x)
51.__import__()#导入
52.sorted#排序
sorted语法如下： sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list 可以看到其中第一个参数是可迭代对象，后面的参数都是具有默认值的，重点阐述如下： 1、cmp，比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0 2、key，主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序 3、reverse，是否反转，默认情况下不反转 具体的例子如下： 使用cmp参数： def cmp_value(x,y): if x > y : return 1 elif x < y: return -1 else: return 0 so = sorted('this is a string'.split(' '),cmp=cmp_value) print so 输出结果为： ['a', 'is', 'string', 'this'] 使用key参数： so = sorted('this Is a string'.split(' '),key=str.upper) print so so = sorted('This is a string'.split(' '),key=lambda x:x.lower) print so student = [('kel','C',30),('jun','A',25)] so = sorted(student,key=lambda x:x[2]) print so 输出结果为： ['a', 'Is', 'string', 'this'] ['is', 'string', 'This', 'a'] key参数用的比较多，多用来使用的方式为key-function，来对list数据进行处理 对复杂对象进行比较： student = [('kel','C',30),('jun','A',25)] so = sorted(student,key=lambda x:x[2]) print so class Student(object): def __init__(self,name,score,age): self.name = name self.score = score self.age = age def __repr__(self): return repr((self.name,self.score,self.age)) student_some = [Student('kel','B',35),Student('jun','C',30)] print sorted(student_some,key= lambda x :x.age) 输出结果为： [('jun', 'A', 25), ('kel', 'C', 30)] [('jun', 'C', 30), ('kel', 'B', 35)] 在对复杂对象进行比较的时候，注意其中参数的引用，在list对象中，直接用index来进行应用；在对象的时候，必须使用对象的属性来进行应用，如x.age 另外一个使用key的好处是，可以进行分组进行统计，配合使用itertools的groupby方法，代码如下： import itertools class Kel(object): #定一个对象，用名字和年龄来进行初始化 def __init__(self,name,age): self.name = name self.age = age def __repr__(self): return repr((self.name,self.age)) kel = [Kel('kel',25),Kel('jun',32),Kel('no',22),Kel('other',40)] #构造一个list #比较年龄的大小，从而得出不同的年龄群体 def get_age(age): if age.age < 20: return 'small' elif age.age < 30: return 'middle' else: return 'old' kel_list = sorted(kel,key=get_age) #首先用年龄来进行排序 print kel_list for m,n in itertools.groupby(kel_list,key=get_age): #根据年龄来统计各个层次段的数据 print m print list(n) 以上代码为根据年龄来统计年龄段的层次结果，输出结果如下： middle [('kel', 25), ('no', 22)] old [('jun', 32), ('other', 40)]
浙公网安备 33010602011771号