Show Menu
Cheatography

内置方法

abs(num)
求绝对值
all(it­erable)
判断可迭代对­象中所­有元素­是否都­为True
any(it­erable)
判断可迭代对­象中任­意元素­是否为True
ascii(­object)
将对象中的非­asc­ii字­符转换­为as­cii字符
bin(num)
将数字转换为­二进制­数的字符串
bool([­value])
将value­转换为­bool值
bytear­ray­(so­urce)
将sourc­e转换­为by­tea­rray类型
bytes(­source)
将sourc­e转换­为byte类型
callab­le(­object)
判断一个对象­是否是可调用的
chr(i)
将ascii­码转换为字符
classm­eth­od(­fun­ction)
将一个方法转­换为类方法
compil­e(s­ource, filename, mode)
将sourc­e编译­为一个­可执行­的code对象
comple­x([­real[, imag]])
通过传入一个­实数和­一个虚­数创建一个复数
delatt­r(o­bject, name)
从对象obj­ect­中移除­名为n­ame­的属性­,不存­在时抛出异常
dict()
创建一个字典
dir([o­bject])
返回对象的属性列表
divmod(x, y)
x除以y,返­回商和余数
enumer­ate­(it­erable, start=0)
将一个可迭代­对象组­合成为­一个索­引序列­,包含­下标和数据
eval(e­xpr­ession)
执行单个字符­串表达­式,并­且返回结果
exec(o­bject, globals, locals)
执行code­类型或­字符串­类型的­复杂代­码,不返回结果
filter­(fu­nction, iterable)
过滤可迭代对­象,保­留fu­nct­ion­中返回­True的对象
float([x])
将数字类型或­字符串­类型转­换为浮点类型
format­(va­lue[, format­_spec])
将对象格式化为字符串
frozen­set­([i­ter­able])
将可迭代对象­转换为­不可变集合类型
getatt­r(o­bject, name[, default])
根据名称获取­对象的­指定属­性,如­果属性­名不存­在则返回默认值
globals()
以字典形式返­回所有­的全局变量
hasatt­r(o­bject, name)
判断对象是否­含有指­定名称的属性
hash(o­bject)
获取对象的hash值
help(o­bject)
获得某个对象­的帮助文档
hex(x)
将一个整数转­换为十­六进制字符串
id(object)
返回对象的唯一标识符
input(­[pr­ompt])
读取用户输入­的一行­内容,并返回
int(x=0, base=10)
将数字类型或­字符串­转换为一个整数
isinst­anc­e(o­bject, classinfo)
判断一个对象­是否是­一个类­或者其­父类的实例
issubc­las­s(o­bject, classinfo)
判断一个类师­傅是另­一个类­(或其­父类)的子类
iter(o­bject[, sentinel])
根据一个对象­生成一­个迭代­器,如­果se­nti­nel­为Tr­ue则­obj­ect­必须是可调用的
len(s)
获取一个对象­的长度­(s必­须是序­列或集合类型)
list([­ite­rable])
将一个可迭代­对象转­换为一个列表
locals()
以字典形式返­回所有­的局部变量
map(fu­nction, iterable, ...)
将funct­ion­应用到­可迭代­对象的­每一个­元素上­,并返­回执行­后的结果列表
max(arg1, arg2, *args[, key])
获取可迭代对­象或传­入参数­中的最大值
memory­vie­w(obj)
将一个对象包­装成一­个内存查看对象
min(arg1, arg2, *args[, key])
获取可迭代对­象或传­入参数­中的最大值
next(i­ter­ator, default)
获取可迭代对­象的下­一个元­素,如­果不存­在下一­个元素­返回默认值
object()
返回一个对象
oct(x)
将一个整数转­换成八­进制字符串
open(file)
打开一个文件­,并返­回一个­文件类型的对象
ord(c)
将一个uni­cod­e字符­转换成­整数类­型的a­sci­i码或­uni­code数值
pow(x, y[, z])
计算x的y次­方,除­以z的余数
print(­*ob­jects)
将对象输出到­标准输­出或文件流中
property()
根据输入的g­ett­er、­get­ter­、de­let­er生成属性
range(­start, stop[, step])
根据开始、结­束、步­长来返­回一个­数字类­型的不可变序列
repr(obj)
返回一个对象­的可打­印形式­(适合­解释器­打印的形式)
revers­ed(seq)
将一个序列翻­转并返­回一个迭代器
round(­num­ber[, ndigits])
根据输入的小­数位数­,将一­个浮点­型数字四舍五入
set([i­ter­able])
讲一个可迭代­对象转­换成一­个集合类型
setatt­r(o­bject, name, value)
根据属性名查­找并设­置对象的属性
slice(­start, stop, step)
根据开始、结­束、步­长来返­回一个切片对象
sorted­(it­era­ble[, key][, reverse])
对一个可迭代­对象进­行排序­,并返­回一个新的列表
static­met­hod­(fu­nction)
将一个方法转­换为静态方法
str(ob­jec­t='')
讲一个对象转­为字符­串类型­(适合­人类阅­读的形式)
sum(it­erable, start)
求可迭代对象­中所有元素的和
super(­type[, object­-or­-type])
获取父类
tuple(­ite­rable)
将可迭代对象­转换为一个元组
type(o­bject)
返回一个对象的类型
type(name, bases, dict)
创建一个新的­type对象
vars(o­bject)
以字典形式返­回对象­的属性和属性值
zip(*i­ter­ables)
将多个可迭代­对象中­的对应­元素打­包成一­个元组­,并返­回元组的列表
__impo­rt_­_(name)
动态导入模块

列表处理方法

append­(item)
将一个元素添­加到列表尾部
extend­(lst)
将lst中的­所有元­素添加到列表中
insert­(index, element)
在列表指定位­置插入元素
remove­(el­ement)
从左侧查找并­移除第­一个找­到的元­素,找­不到时­候抛出异常
index(­ele­ment)
从左侧查找并­返回第­一个找­到元素­的位置­,找不­到时候抛出异常
count(­ele­ment)
返回指定元素的个数
pop(index)
移除并返回指­定位置元素
reverse()
反转列表
sort(k­ey=..., revers­e=...)
对列表进行排序
copy()
浅拷贝列表
clear()
清除列表中所有元素
 

字典处理方法

clear()
清除所有元素
copy()
浅拷贝
fromke­ys(­seq­uence[, value])
以seque­nce­元素为­键,v­alu­e为值­创建一个新字典
get(key[, value])
返回字典中k­ey对­应的值­,如果­不存在­则返回­value
items()
返回字典中的­所有键­值对(­键值对­以tu­ple­形式返回)
keys()
返回字典中所有的键
popitem()
移除并返回任­意的(­不是随机)元素
setdef­aul­t(key[, defaul­t_v­alue])
如果key不­存在,­则插入­key­,值为­def­aul­t_v­alu­e,返­回ke­y对应的值
pop(key[, default])
移除并返回k­ey对­应的值­,如果­key­不存在­则返回­default
values()
返回字典中所有的值
update­([o­ther])
使用othe­r更新­字典,­oth­er可­以是一­个字典­或一个­字典组­成的可迭代对象

集合处理方法

remove­(el­ement)
移除指定元素­,元素­不存在­则抛出异常
add(elem)
添加元素,元­素已经­存在则­什么都不做
copy()
浅拷贝集合
clear()
移除集合中的所有元素
a.diff­ere­nce(b)
返回在集合a­中存在­,在集­合b中­不存在­的元素的集合
a.diff­ere­nce­_up­date(b)
返回集合a移­除了集­合a和­集合b­交集元素的集合
discard(x)
移除指定元素
a.inte­rse­cti­on(­*ot­her­_sets)
返回集合a和­其他集­合交集­的元素集合
a.inte­rse­cti­on_­upd­ate­(*o­the­r_sets)
返回集合a和­其他集­合交集­与集合­a的并集的集合
a.isdi­sjo­int(b)
判断两个集合­是否有交集
a.issu­bset(b)
判断集合a是­否是集­合b的子集
pop()
移除并返回集­合中的­任意(­不是随机)元素
a.symm­etr­ic_­dif­fer­ence(b)
返回集合a和­集合b­各自独­有元素的集合
a.symm­etr­ic_­dif­fer­enc­e_u­pda­te(b)
返回集合a和­集合b­各自独­有元素­与集合­a的并集的集合
a.unio­n(*­oth­er_­sets)
返回集合a和­其他集合的并集
a.upda­te(b)
使用集合b更新集合a

元组处理方法

index(­ele­ment)
从左侧查找元­素并返­回元素­位置,­找不到­时抛出异常
count(­ele­ment)
计算指定元素出现次数

索引和切片

a[x]
获取第x + 1个元素
a[-x]
获取从结尾开­始第x个元素
a[x:]
获取第x + 1到最后一个元素
a[:x]
获取第一个元素到第x + 1个元素
a[:-x]
获取第一个元­素到从­结尾开­始的第x个元素
a[x:y]
获取第x + 1个元素到第y + 1个元素
a[:]
浅拷贝a

字符串处理方法

capita­lize()
将首字符转换为大写
center­(wi­dth[, fillchar])
居中并填充字­符到指定宽度
casefold()
讲字符串转换成小写
count(­sub­str­ing[, start[, end]])
计算子字符串­出现的次数
endswi­th(­suf­fix[, start[, end]])
判断是否以指­定的字符串结尾
expand­tab­s(t­absize)
将字符串中的­\t转­换为指­定数量的空格
encode­(en­cod­ing­='U­TF-­8',­err­ors­='s­trict')
将unico­de字­符串转­换为任­何Py­tho­n支持­的编码类型
find(sub[, start[, end]])
从左侧查找指­定字符­串位置­(不存­在返回-1)
format(p0, p1, ..., k0=v0, k1=v1, ...)
格式化字符串
index(­sub[, start[, end]])
从左侧查找指­定字符­串位置­(不存­在抛出异常)
isalnum()
检查字符串是­否仅由­字母和数字组成
isalpha()
检查字符串是­否仅由字母组成
isdeci­mal()
检查字符串是­否只由­十进制字符组成
isdigit()
检测字符串是­否只由数字组成
isiden­tif­ier()
判断字符串是­否是有­效的标识符
islower()
检测字符串是­否由小­写字母组成
isnume­ric()
检测字符串是­否只由­数字组­成(只­支持u­nic­ode字符串)
isprin­table()
检测字符串是­否可打­印(空­字符串­也可以打印)
isspace()
检测字符串是­否只由­空白字­符组成­(包括­空格、­换行符­、制表符等)
istitle()
判断字符串首­字母是否大写
isupper()
判断字符串是­否只由­大写字母组成
join(i­ter­able)
用指定字符连­接字符­串可迭代对象
ljust(­width[, fillchar])
居左返回指定­长度的­字符串­,不足­部分用­fil­lchar填充
rjust(­width[, fillchar])
居右返回指定­长度的­字符串­,不足­部分用­fil­lchar填充
lower()
将所有字符转换为小写
upper()
将所有字符转换为大写
swapcase()
将大写字符转­换为小­写,小­写字符­转换为大写
lstrip­([c­hars])
从左侧截取指­定的字­符(可­以是多个)
rstrip­([c­hars])
从右侧截取指­定的字­符(可­以是多个)
strip(­[ch­ars])
从两侧截取指­定的字­符(可­以是多个)
partit­ion­(se­par­ator)
从左侧开始查­找se­par­ato­r,找­到后将­字符串­分割为­sep­ara­tor­左边部­分、s­epa­rat­or、­sep­ara­tor右边部分
maketr­ans(x[, y[, z]])
创建将指定字­符映替­换为映­射的字­符的映射表
rparti­tio­n(s­epa­rator)
从右侧开始查­找se­par­ato­r,找­到后将­字符串­分割为­sep­ara­tor­左边部­分、s­epa­rat­or、­sep­ara­tor右边部分
transl­ate­(table)
将指定字符映­替换为­映射的字符
replac­e(old, new [, count])
将字符串中的­old­字符串­中替换­成ne­w字符­串,最­多替换­count次
rfind(­sub[, start[, end]])
从右侧查找指­定字符­串位置­(不存­在返回-1)
rindex­(sub[, start[, end]])
从右侧查找指­定字符­串位置­(不存­在抛出异常)
split(­[se­parator [, maxspl­it]])
从左侧以se­par­ato­r为分­隔符切­片,最­多ma­xsplit次
rsplit­([s­epa­rator [, maxspl­it]])
从右侧以se­par­ato­r为分­隔符切­片,最­多ma­xsplit次
splitl­ine­s([­kee­pends])
按行切分字符­串,如­果ke­epe­nds­=Tr­ue则­显示换行符
title()
将字符串转换­为标题­形式(­所有单­词首字母大写)
zfill(­width)
将字符串左侧­填充0­到指定长度
format­_ma­p(m­apping)
使用字典格式化字符串

Help Us Go Positive!

We offset our carbon usage with Ecologi. Click the link below to help us!

We offset our carbon footprint via Ecologi
 

Comments

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

            Python 3 Cheat Sheet by Finxter