所有函数

Python 标准操作符和函数

1、内置函数

enumerate() ****

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

input() *****

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

next() ****

迭代器的下一个项目。

slice() ****

实现切片对象，主要用在切片操作函数里的参数传递。

any() ****

用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True。

id() ****

用于获取对象的内存地址。

abs() ****

函数返回数字的绝对值。

dict() ****

用于创建一个字典。

min() ****

返回给定参数的最小值，参数可以为序列。

staticmethod() ****

返回函数的静态方法。

all() ****

用于判断给定的可迭代参数 iterable 中的所有元素是否不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False

dir() ****

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

object() *****

eval() ****

用来执行一个字符串表达式，并返回表达式的值。

eval(def_name) 里面可以直接跟函数名。返回的是函数对象（内存地址）

用eval(def_name)() 执行。

int() *****

用于将一个字符串或数字转换为整型。

open() *****

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

str() *****

将对象转化为适于人阅读的形式。

bool() *****

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

bool 是 int 的子类。

iter() ****

用来生成迭代器。

pow() ****

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

print() *****

打印输出

super() ****

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

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

bytes() ****

返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

float() ****

将整数和字符串转换成浮点数。

tuple() *****

函数将列表转换为元组。

callable() ****

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

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

format() *****

字符串格式化的功能。

len() *****

返回对象（字符、列表、元组等）长度或项目个数。

exec() ****

执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

frozenset() ****

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

list() *****

用于将元组转换为列表。

max() ****

返回给定参数的最大值，参数可以为序列。

round() ****

返回浮点数x的四舍五入值。

delattr() ****

函数用于删除属性。

range() *****

返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。

filter() ****

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

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

zip() ****

函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

globals() ****

函数会以字典类型返回当前位置的全部全局变量。

set() ****

创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

locals() ****

会以字典类型返回当前位置的全部局部变量。

map() ****

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

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

reversed() ****

返回一个反转的迭代器。

 

vars() *****

返回对象object的属性和属性值的字典对象。

sum() ****

对系列进行求和计算。

sorted() ****

对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

setattr() ***

对应函数 getatt()，用于设置属性值，该属性必须存在。

isinstance() ***

来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

classmethod() ***

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

getattr() ***

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

compile() ***

函数将一个字符串编译为字节代码。

repr() ***

将对象转化为供解释器读取的形式。

__import__() ***

用于动态加载类和函数 。

如果一个模块经常变化就可以使用 __import__() 来动态载入。

complex() ***

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

hasattr() ***

用于判断对象是否包含对应的属性。

hash() ***

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

property() ***

作用是在新式类中返回属性值。

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

help() **

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

hex() **

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

ascii() **

类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 

oct() **

将一个整数转换成8进制字符串。

bin() **

一个整数 int 或者长整数 long int 的二进制表示。

ord() **

是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

bytearray() **

法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

issubclass() **

用于判断参数 class 是否是类型参数 classinfo 的子类。

chr() **

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

memoryview() **

返回给定参数的内存查看对象(Momory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

 

 

2、字符串

在Python3中，所有的字符串都是Unicode字符串

三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

\(在行尾时)    续行符

\\    反斜杠符号

\'    单引号

\"    双引号

\n    换行

\v    纵向制表符

\t    横向制表符

\r    回车

format()字符串格式化

按顺序msg='name:{},age:{},sex:{}'

print(msg.format('haiyan',18,女))

按索引msg='name:{0},age:{1},sex:{0}'

print(msg.format('aaaaaa','bbbbbb'))

赋值的方式msg='name:{x},age:{y,sex:{z}'

print(msg.format(x='haiyan',y='18',z='女'))

% 字符串格式化 %s %d %f

print('abdc %s sdfsdf' % 'aaa')

%s 后面可以是数字类型。但%d 后面必须是数字类型的。

使用字典：

d={"name":"lisi","age":"18"}

s='my name is %(name)s, age is %(age)s'

print(s % d)

%d     格式化整数

%f     格式化浮点数字，可指定小数点后的精度

center(width, fillchar) ****

返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

count(str, beg= 0,end=len(string)) ****

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

bytes.decode(encoding="utf-8", errors="strict") ****

Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

encode(encoding='UTF-8',errors='strict') ****

以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

endswith(suffix, beg=0, end=len(string)) ****

检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

expandtabs(tabsize=8) ****

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

find(str, beg=0 end=len(string)) ****

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

index(str, beg=0, end=len(string)) ****

跟find()方法一样，只不过如果str不在字符串中会报一个异常.

upper() ****

转换字符串中的小写字母为大写

isalnum() ****

如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

isdigit()****

如果字符串只包含数字则返回 True 否则返回 False..

islower() ****

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

isnumeric() ****

如果字符串中只包含数字字符，则返回 True，否则返回 False

isspace() ****

如果字符串中只包含空白，则返回 True，否则返回 False.

istitle() ***

如果字符串是标题化的(见 title())则返回 True，否则返回 False

isupper() ****

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

startswith(str, beg=0,end=len(string)) ****

检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

split(str="", num=string.count(str)) ****

num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串

strip([chars]) ****

在字符串上执行 lstrip()和 rstrip()

join(seq) ****

以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

len(string) ****

返回字符串长度

ljust(width[, fillchar]) ***

返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

lower() ****

转换字符串中所有大写字符为小写.

lstrip() ****

截掉字符串左边的空格或指定字符。

replace(old, new [, max]) ****

把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

maketrans() ****

创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

max(str) ***

返回字符串 str 中最大的字母。

min(str) ***

返回字符串 str 中最小的字母。

capitalize() ***

将字符串的第一个字符转换为大写

isalpha() ***

如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

rfind(str, beg=0,end=len(string)) ***

类似于 find()函数，不过是从右边开始查找.

rindex( str, beg=0, end=len(string)) ***

类似于 index()，不过是从右边开始.

rjust(width,[, fillchar]) ***

返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

rstrip() ***

删除字符串字符串末尾的空格.

swapcase() ***

将字符串中大写转换为小写，小写转换为大写

title() ***

返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

translate(table, deletechars="") ***

根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

zfill (width) **

返回长度为 width 的字符串，原字符串右对齐，前面填充0

isdecimal()**

检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

splitlines([keepends]) **

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

3、数字

算术运算符

+    加 - 两个对象相加

-    减 - 得到负数或是一个数减去另一个数    

*    乘 - 两个数相乘或是返回一个被重复若干次的字符串

/    除 - x 除以 y    

%    取模 - 返回除法的余数

**    幂 - 返回x的y次幂

//    取整除 - 返回商的整数部分

比较运算符

==    等于 - 比较对象是否相等

!=    不等于 - 比较两个对象是否不相等

>    大于 - 返回x是否大于y

<    小于 - 返回x是否小于y。返回1表示真，返回0表示假。

>=    大于等于 - 返回x是否大于等于y。

<=    小于等于 - 返回x是否小于等于y。

赋值运算符

=    简单的赋值运算符

+=    加法赋值运算符

-=    减法赋值运算符

*=    乘法赋值运算符

/=    除法赋值运算符

%=    取模赋值运算符

**=    幂赋值运算符

//=    取整除赋值运算符

逻辑运算符

在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。

x or y , x为真，值就是x，x为假，值是y。其中一个为真，就返回为真的值，如果两个都为真，就返回第一个。

x and y, x为真，值是y,x为假，值是x。在第一个值为真的时候，就看第二个值，第二值为真，就为真，第二个值为假，就为假。第一个值为假，直接返回第一个值，即，为假。

x and y    布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

x or y    布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

not x    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

成员运算符

in    如果在指定的序列中找到值返回 True，否则返回 False。    x 在 y 序列中 , 如果 x 在 y 序列中返回 True。

not in    如果在指定的序列中没有找到值返回 True，否则返回 False。

身份运算符

is 是判断两个标识符是不是引用自一个对象    x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not 是判断两个标识符是不是引用自不同对象，x is not y，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间

del

删除一些数字对象的引用

整型(Int)

通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。

浮点型(float)

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex))

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

int(x)

将x转换为一个整数。

float(x)

将x转换到一个浮点数。

complex(x)

将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y)

将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //

abs(x)    

返回数字的绝对值，如abs(-10) 返回 10

ceil(x)    

返回数字的上入整数，如math.ceil(4.1) 返回 5

cmp(x, y)

如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。

exp(x)    

返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x)

返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x)    

返回数字的下舍整数，如math.floor(4.9)返回 4

log(x)    

如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x)

返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1, x2,...)

返回给定参数的最大值，参数可以为序列。

min(x1, x2,...)

返回给定参数的最小值，参数可以为序列。

modf(x)

返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x, y)

x**y 运算后的值。

round(x [,n])

返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

sqrt(x)

返回数字x的平方根。

choice(seq)

从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。

randrange ([start,] stop [,step])

从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1

random()

随机生成下一个实数，它在[0,1)范围内。

seed([x])

 

改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。

shuffle(lst)

将序列的所有元素随机排序

uniform(x, y)

随机生成下一个实数，它在[x,y]范围内。

4、列表

len(list)

列表元素个数

max(list)

返回列表元素最大值

min(list)

返回列表元素最小值

list(seq)

将元组转换为列表

list.append(obj)

在列表末尾添加新的对象

list.count(obj)

统计某个元素在列表中出现的次数

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

list.insert(index, obj)

将对象插入列表

list.pop(obj=list[-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj)

移除列表中某个值的第一个匹配项

list.reverse()

反向列表中元素

list.sort([func])

对原列表进行排序

list.clear()

清空列表

list.copy()

复制列表

del

语句来删除列表的的元素

5、元组

元组的元素不能修改

len((1, 2, 3))    计算元素个数

(1, 2, 3) + (4, 5, 6)    (1, 2, 3, 4, 5, 6)    连接

('Hi!',) * 4    ('Hi!', 'Hi!', 'Hi!', 'Hi!')    复制

3 in (1, 2, 3)    元素是否存在

for x in (1, 2, 3): print (x,) 循环遍历

del

语句来删除列表的的元素

len(tuple)

计算元组元素个数。    

max(tuple)

返回元组中元素最大值。    

min(tuple)

返回元组中元素最小值。    

tuple(seq)

将列表转换为元组。

6、字典

可变容器模型，且可存储任意类型对象。

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

键必须是可哈希的

len(dict)

计算字典元素个数，即键的总数。    

str(dict)

输出字典，以可打印的字符串表示。    

type(variable)

返回输入的变量类型，如果变量是字典就返回字典类型。    

radiansdict.clear()

删除字典内所有元素

radiansdict.copy()

返回一个字典的浅复制

radiansdict.fromkeys(seq,[val])

创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

如：dic1=dict().fromkeys([1,2,3,4,5],'test')

radiansdict.get(key, default=None)

返回指定键的值，如果值不在字典中返回default值

key in dict

如果键在字典dict里返回true，否则返回false

radiansdict.items()

以列表返回可遍历的(键, 值) 元组数组

radiansdict.keys()

以列表返回一个字典所有的键

radiansdict.setdefault(key, default=None)

和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)

把字典dict2的键/值对更新到dict里

radiansdict.values()

以列表返回字典中的所有值

pop(key,[default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。是有返回值的。

popitem()

随机返回并删除字典中的一对键和值(一般删除末尾对)。

del

能删单一的元素也能清空字典。

7、集合

集合是一个无序的，不重复的数据组合，基本功能是进行成员关系测试和删除重复元素。关系测试，测试两组数据之前的交集、差集、并集等关系，创建一个空集合必须用 set()。

set([obj])

可变集合：ojb必须是支持迭代的，由obj中的元素创建集合，否则创建一个空集合frozenset([obj])

不可变集：执行方式好set()方法相同，但它返回的是不可变集合

s|t        s.union(t)    

求并集

s&t        s.intersection(t)

求交集

s-t        s.difference(t)

求差集

s^t        s.symmetric_difference(t)

对称差集 a和b中不同时存在的元素

s <= t        s.issubset(t)

测试是否 s 中的每一个元素都在 t 中

s >= t        s.issuperset(t)

测试是否 t 中的每一个元素都在 s 中

len(s)

集合s中元素个数

obj in s

成员测试

obj not in s

非成员测试

s == t

等价测试

s != t

不等价测试

s.copy()

赋值操作：返回s的（浅复制）副本

s.update(t)

将t中的成员添加s

s.add(obj)

将obj添加到s

s.remove(obj)

删除操作

s.discard(obj)

丢弃操作：remove()的友好版本，如果s中存在ojb，从s中删除它

s.pop()

移除并返回s中的任意一个值

s.clear()

移除s中的所有元素