python内置函数总结---考试小抄版

总结自菜鸟教程：https://www.runoob.com/python/python-built-in-functions.html

abs(): 返回数字的绝对值，若参数为复数，则返回复数的绝对值（此复数与它的共轭复数的乘积的平方根）😗。

abs(1+1j) 1.4142135623730951

all()：用于判断可迭代参数 iterable 中的所有元素是否都为 TRUE，即不能有( 0、空、None、False) ，如果是返回 True，否则返回 False。

all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0 True all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素 False all([0, 1，2, 3]) # 列表list，存在一个为0的元素 False all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0 True all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素 False all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素 False # 注意 all([]) # 空列表 True all(()) # 空元组 True

any()： 用于判断可迭代参数 iterable 中的所有元素是否有 TRUE，即除了( 0、空、None、False) 之外，还有别的元素，如果有返回 True，否则返回 False。

>>> any(['a', 0, '', False]) # 列表list中存在0、空、FALSE 之外的东西 >>> any([]) # 空列表 False >>> any(()) # 空元组 False

bin()： 返回一个整数 int 或者长整数 long int 的二进制表示的字符串。

bin(10) '0b1010'

bool()： 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

>>> bool(0) False

bytearray() ：方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。不知道有啥用

>>> bytearray([1,2,3]) bytearray(b'\x01\x02\x03')

callable()： 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。

lass A: # 类 def method(self): return 0 callable(A) # 类返回 True True a = A() callable(a) # 没有实现 __call__, 返回 False False class B: def __call__(self): return 0 callable(B) True b = B() # 注意这里 callable(b) # 实现 __call__, 返回 True True

chr()： 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

print(chr(0x30), chr(0x31), chr(0x61)) # 十六进制 0 1 a print(chr(48), chr(49), chr(97)) # 十进制 0 1 a

类方法 @classmethod

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。 runoob 的classmethod评论

class A(object): # 属性默认为类属性（可以给直接被类本身调用） num = "类属性" # 实例化方法（必须实例化类之后才能被调用） def func1(self): # self : 表示实例化类后的地址id print("func1") print(self) # 类方法（不需要实例化类就可以被类本身调用） @classmethod def func2(cls): # cls : 表示没用被实例化的类本身 print("func2") print(cls) print(cls.num) cls().func1() # 表示进行了实例化 # 不传递传递默认self参数的方法（该方法也是可以直接被类调用的，但是这样做不标准） def func3(): print("func3") print(A.num) # 属性是可以直接用类本身调用的 # A.func1() 这样调用是会报错：因为func1()调用时需要默认传递实例化类后的地址id参数，如果不实例化类是无法调用的 A.func2() A.func3()

输出

func2 <class '__main__.A'> 类属性 func1 <__main__.A object at 0x7f7f7113c710> func3 类属性

cmp(x,y): 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。

cmp(80, 100) : -1

compile() :函数将一个字符串编译为字节代码。

str = "for i in range(0,3): print(i)" c = compile(str,'','exec') # 编译为字节代码对象 print(c) print(exec(c)) str = "3 * 4 + 5" a = compile(str,'','eval') print(eval(a))

输出

<code object <module> at 0x7f03c840c300, file "", line 1> 0 1 2 None 17

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

complex(1, 2) (1 + 2j)

delattr： 函数用于删除属性。delattr(x, ‘foobar’) 相等于 del x.foobar。

dict()： 函数用于创建一个字典。

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

dir()： 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] >>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

divmod() ：函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

>>>divmod(7, 2) (3, 1) >>> divmod(8, 2) (4, 0) >>> divmod(1+2j,1+0.5j) ((1+0j), 1.5j)

enumerate() ：函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

seq = ['one', 'two', 'three'] for i, element in enumerate(seq): print(i, element)

输出

0 one 1 two 2 three

eval() ：函数用来执行一个字符串表达式，并返回表达式的值。

x = 7 eval( '3 * x' ) 21 eval('pow(2,2)') 4

execfile() ：函数可以用来执行一个文件。

execfile('hello.py') hello

file()： 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。

f = file('hello.py') f.read() print('hello')

filter() ：函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(newlist)

float()： 函数用于将整数和字符串转换成浮点数。

float(1024) 1024.0

format()：基本语法是通过 {} 和 : 来代替以前的 % 。format 函数可以接受不限个参数，位置可以不按顺序。

"{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'

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

a = frozenset(range(10)) # 生成一个新的不可变集合 >>> a frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

getattr() 函数用于返回一个对象属性值。

class A(object): ... bar = 1 ... >>> a = A() >>> getattr(a, 'bar') # 获取属性 bar 值 1 >>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常 Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'A' object has no attribute 'bar2' >>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值 3 class A(object): def set(self, a, b): x = a a = b b = x print(a, b) a = A() c = getattr(a, 'set') # 等价于c = a.set print(a) print(c) c(a='1', b='2')

globals()： 函数会以字典类型返回当前位置的全部全局变量。 globals 函数返回一个全局变量的字典，包括所有导入的变量。 想起来一个关键字 global

name = "小明" def test(): global name # 把外面的拿过来 print(name) name = "along" return name if __name__ == "__main__": print(name) print(test()) print(name)

输出

小明 小明 along along

hasattr() ：函数用于判断对象是否包含对应的属性

class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x')) print(hasattr(point1, 'no')) # 没有该属性 True False

hash() ：用于获取取一个对象（字符串或者数值等）的哈希值。

hash('test') # 字符串 2314058222102390712

help()： 函数用于查看函数或模块用途的详细说明。

help('sys') # 查看 sys 模块的帮助 ……显示帮助信息……

hex()： 函数用于将10进制整数转换成16进制，以字符串形式表示。

hex(255) '0xff'

id()： 函数返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。

a = 'runoob' >>> id(a) 4531887632

input：函数接受一个标准输入数据，返回为 string 类型。

a = input("input:") a = int(a) 输入： input:123 #注意 数字接收后需要转换一下，防止报错

int() ：函数用于将一个字符串或数字转换为整型。

int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制 18

评论中

怒写一波： int(x,base) x 有两种：str / int 1、若 x 为纯数字，则不能有 base 参数，否则报错；其作用为对入参 x 取整 >>> int(3.1415926) 3 >>> int(-11.123) -11 >>> int(2.5,10) #报错 >>> int(2.5) 2 2、若 x 为 str，则 base 可略可有。 base 存在时，视 x 为 base 类型数字，并将其转换为 10 进制数字。 若 x 不符合 base 规则，则报错。如: >>>int("9",2) #报错，因为2进制无9 >>> int("9") 9 #默认10进制 >>> int("3.14",8) >>> int("1.2") #均报错，str须为整数 >>>int("1001",2) 9 # "1001"才是2进制格式，并转化为十进制数字9 >>> int("0xa",16) 10 # ≥16进制才会允许入参为a,b,c... >>> int("b",8) #报错 >>> int("123",8) 83 #视123为8进制数字，对应的10进制为83

isinstance() ：函数来判断一个对象是否是一个已知的类型，类似 type()。 对于基本类型来说 classinfo 可以是：int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple

a = 2 >>> isinstance (a,int) True >>> isinstance (a,str) False >>> isinstance (a,(str,int,list)) # 是元组中的一个就返回 True True

issubclass() ：方法用于判断参数 class 是否是类型参数 classinfo 的子类。

class A: pass class B(A): pass print(issubclass(B,A)) # 返回 True

iter() ：函数用来生成迭代器。 这个例子不好，因为list本身就可以for出来

lst = [1, 2, 3] list = iter(lst) print(type(list)) for i in iter(lst): print(i)

输出

<class 'list_iterator'> 1 2 3

len()： 方法返回对象（字符、列表、元组等）长度或项目个数。

str = "runoob" len(str) 6

list()： 用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中

strs="python" list_str = list(strs) print(list_str )

输出

['p', 'y', 't', 'h', 'o', 'n']

下面是字典

dicts = dict(zip(["a", "b", "c"],["e", "f", "g"])) dicts = list(dicts) print(dicts) ['a', 'b', 'c']

locals() ：函数会以字典类型返回当前位置的全部局部变量。 对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

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

long() ：函数将数字或字符串转换为一个长整型。

long(123) 123L

map() ：会根据提供的函数对指定序列做映射。

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

max() ：方法返回给定参数的最大值，参数可以为序列。

max(80, 100, 1000) 1000

min()： 方法返回给定参数的最小值，参数可以为序列。

min(80, 100, 1000) 80

next() ：返回迭代器的下一个项目。next() 函数要和生成迭代器的iter() 函数一起使用。

# 首先获得Iterator对象: it = iter([1, 2, 3]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break

结果

1 2 3

评论 如果传入第二个参数, 获取最后一个元素之后, 下一次next返回该默认值, 而不会抛出 StopIteration:

it = iter([1, 2, 3]) while True: x = next(it, 'a') print(x) if x == 'a': break

oct() ：函数将一个整数转换成 8 进制字符串。

oct(10) '012'

open() ：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

file_name = str(file_path.rsplit('/', 1)[1]) # 拿到的是文件名 f = open(file_path, 'rb') # 文件名打开 response = FileResponse(f) # 文件响应

还需要详细写

ord()：它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值

ord('a') 97

pow() 方法返回 xy（x 的 y 次方） 的值。

math.pow(2, 4) : 16.0

@property 廖雪峰的python

class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self, value): if not isinstance(value, int): raise ValueError('birth must be an integer!') if value < 0 or value > 2020: raise ValueError('birth must between 0 ~ 2020!') self._birth = value @property def age(self): return 2020 - self._birth along = Stuent() along.birth = 2000 print(along.birth) print(along.age)

输出

2000 20

range()： 函数可创建一个整数列表，一般用在 for 循环中。

range(3) [0, 1, 2]

raw_input() ：将所有输入作为字符串看待，返回字符串类型。 reduce() ：函数会对参数序列中元素进行累积。

reduce(lambda x, y: x+y, [1,2,3,4,5]) 15

评论：reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里

from functools import reduce

reload()： 用于重新载入之前载入的模块。 Python 3.0 把 reload 内置函数移到了 imp 标准库模块中。它仍然像以前一样重载文件，但是，必须导入它才能使用。

from imp import reload reload(module)

repr() ：函数将对象转化为供解释器读取的形式。现在看来就是加双引号

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

reverse()： 函数用于反向列表中元素。

aList = [123, 'xyz', 'zara'] aList.reverse() ['zara', 'xyz', 123]

round() ：方法返回浮点数x的四舍五入值。

round(80.23456, 2) # 小数点后两位 80.23

评论

在实际使用中发现round函数并不总是如上所说的四舍五入。如： In [14]: round(2.355, 2) Out[14]: 2.35 注：环境为 python3.5.2 因为该函数对于返回的浮点数并不是按照四舍五入的规则来计算，而会受到计算机表示精度的影响。 关于该问题搜索后解释比较清楚的文章地址如下：http://www.runoob.com/w3cnote/python-round-func-note.html

set()： 集合函数

x = set('along') y = set('google') x = set(x) # 重复的被删除 y = set(y) print(x) print(y) print(x & y) # 交集 print(x | y) # 并集 print(x - y) # 差集

输出

{'g', 'n', 'a', 'l', 'o'} {'l', 'e', 'o', 'g'} {'l', 'o', 'g'} {'a', 'l', 'o', 'e', 'g', 'n'} {'n', 'a'}

setattr()： 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。

class Student(): name = "along" along = Student() getattr(along, "name") print(along.name) setattr(along, "name", "xiefan") print(along.name) # 设置一个没有的属性 setattr(along, "age", 18) print(along.age)

输出

along xiefan 18

slice() ：函数实现切片对象，主要用在切片操作函数里的参数传递。 不好用，直接切片就行

myslice = slice(5) # 设置截取5个元素的切片 arr = list(range(10)) print(arr[myslice]) # 截取 5 个元素 print(arr[:3]) # 截取 3 个元素

输出

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4] [0, 1, 2]

sorted() 函数对所有可迭代的对象进行排序操作。list 的 sort 方法在原有的列表上进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

L = [('b', 3), ('a', 1), ('c', 2), ('d', 4)] l = sorted(L, key=lambda x: x[1], reverse=True) # 利用key, 按降序 print(l)

输出

('d', 4), ('b', 3), ('c', 2), ('a', 1)]

评论： key 和 reverse 比一个等价的 cmp 函数处理速度要快。这是因为对于每个列表元素，cmp 都会被调用多次，而 key 和 reverse 只被调用一次，所以不用cmp

@staticmethod： 返回函数的静态方法。

该方法不强制要求传递参数，如下声明一个静态方法：

class Student(object): @staticmethod def f(name: str, age: int): print('along is {}'.format(name)) print('age is {}'.format(age)) Student.f("along", 20) # 静态方法无需实例化 stu = Student() stu.f("alonglong", 21) # 也可以实例化后调用

输出

along is along age is 20 along is alonglong age is 21

str()： 函数将对象转化为字符串。

num = 123 s = str(num) print(type(s))

输出

<class 'str'>

sum()： 方法对序列进行求和计算。

sum([1, 2, 3]) 6

评论 涉及到了numpy，单独写

import numpy as np a = np.array([[1,2],[3,4]]) # 按行相加，并且保持其二维特性 print(np.sum(a, axis=1, keepdims=True)) # 按行相加，不保持其二维特性 print(np.sum(a, axis=1))

输出

array([[3], [7]]) array([3, 7])

super()：函数是用于调用父类(超类)的一个方法。

class A: def add(self, x): y = x + 1 print(y) class B(A): def add(self, x): print(x * 2) # 前后都可添加代码 super().add(x) print(x * 3) b = B() b.add(2)

输出

4 3 6

tuple()：元组函数将列表转换为元组。

tuple([1,2,3,4]) (1, 2, 3, 4)

type()： 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。

type(1) <type 'int'>

unichr() ：函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符。（python3 没有）

unichr(99) u'c'

zip() ：拉链

a = [1,2,3] b = [4,5,6] zippo = zip(a,b) print(zippo)

输出

打火机

** _ _ feature _ _ **

from __future__ import division, print_function, absolute_import 如果你的python版本是python2.X，你也可以按照python3.X那样使用这些函数

愿你我都站上巨人的肩膀