常用方法汇总

1. int类

方法汇总：

变量名.to_bytes('数字'，"little"\"big") # (把数字转换成bytes)

# 数字表示转换后几个字节表示 little在前面，big在后面(大小端)

int.from_bytes("要转换的东西","little"\"big") # 字节转换成数字

bit_length() # 判断当前十进制数字占二进制的位数

# 新加功能：big 和little 在这里是一个大小端，big 在后，little在前

# to_bytes() 从数字转换字节

a =5

new_bytes = a.to_bytes(2,"big")

print(new_bytes)

a =5

new_bytes = a.to_bytes(2,"little")

print(new_bytes)

# from_bytes() 从字节转换成数字

a =5

new_bytes = a.to_bytes(1,"little")

new_a = int.from_bytes(new_bytes,"big")

print(new_bytes)

print(new_a)

# 结果：

b'\x00\x05'

b'\x05\x00'

b'\x05'

5

2. str类

方法汇总：

str.lower() # 只能做英文

str.casefold() # 包含小语种 β-->ss的大写

str.center('总长度',"前后填充")

str.ljust('总长度',"后面填充")

str.rjust('总长度',"前面填充")

str.count("序列","起始位","结束位") # 查看序列是否存在

str.expandtabs('总位数') # xxx\t 一共占多少位，可以做简单表格形式

# \n 或 \r\n 换行符 \t制表符

str.find("字符") # 找到字符所在第一个位置的索引，没有时，返回-1

str.index("字符") # 找到字符所在第一个位置的索引，没有时，报错

str.format() # 字符串格式化(重点)

name = "我叫{name}，年龄{age}-{name}"

1 val= name.format("aaa","dddd")

2 val= name.format(*["aaa","dddd"])

3 val= name.format(name="aaa",dddd)

4 dic = {"name":"aaa","age":"dddd"}

val= name.format(**dic)

# 1 和 4 常用

str.format_map() # 字符串格式化

dic = {"name":"aaa","age":"dddd"}

val= name.format_map(dic) # (只能写字典)

str.isalnum() # 判断中文或字母或数字存在---True

str.isalpha() # 判断中文和字母

str.isdecimal() # 数字

str.isdigit() # 数字

str.isnumeric() # 数字

str.isidentifier() # 判断是否为关键字或python内置使用，叫做标识符(python已经赋予意义)

str.islower() # 是否全为小写

str.isprintable() # 是否可以全部打印

str.isspace() # 是否全为空格

str.title() # 变成标题

str.istitle() # 是否为标题(首字母变大写)

str.partition() # 分割并且保留分割符(结果是元组)

str.splitlines() # 根据换行符分割

str.swapcase() # 大写变小写 小写变大写

str.maketrans("原内容"，"新内容") # 依次替换

# str.capitalize() 首字母变大写

v = "adgdakl13235"

new_v = v.capitalize()

print(new_v)

# str.casefold() 变小写有英语，还包含小语种

v = "aDGHHdak"

new_v = v.casefold()

print(new_v)

# str.islower() 是否全为小写

v = "aDGHHdak"

new_v = v.islower()

print(new_v)

# str.isupper() 是否全为大写

v = "aDGHHdak"

new_v = v.isupper()

print(new_v)

# str.lower() 变小写

v = "aDGHHdak"

new_v = v.lower()

print(new_v)

# str.uppper() 变小写

v = "aDGHHdak"

new_v = v.upper()

print(new_v)

# str..swapcase() 大写变小写 小写变大写

v = "aDGHHdak"

new_v = v.swapcase()

print(new_v)

# str.center(总长度,"前后填充")

v = "aDGHHdak"

new_v = v.center(25,"%")

print(new_v)

# str.ljust(总长度,"后面填充")

v = "aDGHHdak"

new_v = v.ljust(25,"%")

print(new_v)

# str.rjust(总长度,"前面填充")

v = "aDGHHdak"

new_v = v.rjust(25,"%")

print(new_v)

# str.zfill() 给定一个总长度，只能从前面填充，只能填充0

name = 'alex'

v = name.zfill(20)

print(v)

# str.count("序列","起始位","结束位") 查看序列是否存在

v = "aDGHHdaHkFHFGJH"

print(v.count("H",3,7))

# str.encode() 字符串(Unicode编码)转换成其他编码形式

v = "海角"

new_v = v.encode("utf-8")

print(new_v)

# str.expandtabs(总位数) xxx\t 一共占多少位，可以做简单表格形式

# \n 或 \r\n 换行符 \t制表符

v = "aDG\tHH\tdaH\naDG\tHH\tdaH\naDG\tHH\tdaH"

new_v = v.expandtabs(10)

print(new_v)

# str.find("字符") 找到字符所在第一个位置的索引，没有时，返回-1

v = "aDGHHdaHkFHFGJH"

new_v = v.find("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.find("b")

print(new_v)

# str.rfind("字符") 右边开始找到字符所在第一个位置的索引，没有时，返回-1

v = "aDGHHdaHkFHFGJH"

new_v = v.rfind("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.rfind("b")

print(new_v)

# str.index("字符") 找到第一个字符所在位置的索引，没有时，报错

v = "aDGHHdaHkFHFGJH"

new_v = v.index("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.index("b")

print(new_v)

# str.index("字符") 找到第一个字符所在位置的索引，没有时，报错

v = "aDGHHdaHkFHFGJH"

new_v = v.rindex("H")

print(new_v)

v = "aDGHHdaHkFHFGJH"

new_v = v.rindex("b")

print(new_v)

# (重点)变量名.format() 字符串格式化

v = "我叫{name}，年龄{age}-{name}"

val = v.format("aaa","dddd")

print(val)

val= v.format(*["aaa","dddd"])

print(val)

val= v.format(name="aaa",age = "11")

print(val)

dic = {"name":"aaa","age":"dddd"}

val= v.format(**dic)

print(val)

# 标注：1 和 4 常用

# str.format_map() 字符串格式化

v = "我叫{name}，年龄{age}-{name}"

dic = {"name":"aaa","age":"dddd"}

val= v.format_map(dic) #(只能写字典)

print(val)

# str.isalnum() 判断中文或字母或数字存在---True

v = "aagkf243变量"

print(v.isalnum())

.isalpha() # 判断中文和字母

v = "aagkf243变量"

print(v.isalpha())

# str.isdecimal() 判断数字是否存在

name = '123'

print(name.isdecimal()) # 123

# str.isdigit() 数字

name = '②123'

print(name.isdigit()) # 123 ②

# str.isnumeric() 数字

name = '二十②123'

print(name.isnumeric()) # 123 ② 二十

# 连接符.join(可迭代对象)

li = ["978","6745","435","24","12"]

new_li = "*".join(li)

print(new_li)

# str.strip() 去空格

name = ' aff '

val = name.strip()

print(name)

print(val)

# str.lstrip() 去左边空格

name = ' aff '

val = name.lstrip()

print(name)

print(val)

# str.rstrip() 去右边空格

name = ' aff '

val = name.rstrip()

print(name)

print(val)

# str.replace() 替换

msg = "asdefasdfja"

val = msg.replace("a","##",2)

print(val)

# str.maketrans("原内容"，"新内容") 依次替换

# str.translate() 转换，把maketrans替换的内容转换出来

table = str.maketrans("aeiou",'12345')

msg = "asdefasdfjasdifw[kmnakjudfasdf"

val = msg.translate(table)

print(val)

# str.partition() 分割并且保留分割符，(结果是元组)

v = "akl\nalf\nkal\nakl"

val = v.partition("\n") #只有一次

print(val)

# str.rpartition() 从右分割并且保留分割符，(结果是元组)

v = "akl\nalf\nkal\nakl"

val = v.rpartition("\n") #只有一次

print(val)

# str.split() 分割不保留分割符，结果是列表

v = "akl\nalf\nkal\nakl"

val = v.split("\n")

print(val)

# str.rsplitl() 从右边分割 ，分割不保留分割符， 结果是列表

v = "akl\nalf\nkal\nakl"

val = v.rsplit("\n")

print(val)

# str.splitlines() 根据换行符分割 ， 结果是列表

v = "akl\nalf\nkal\nakl"

val = v.splitlines()

print(val)

# str.startswith() 检测是否以xxx开头

v = "aklalfkalakl"

val = v.startswith("a")

print(val)

# str.endswith() 检测是否以xxx结尾

v = "aklalfkalakl"

val = v.endswith("kl")

print(val)

# str.isidentifier() 判断是否为关键字或python内置使用，叫做标识符(python已经赋予意义)目前有歧义

# str.isprintable() 是否可以全部打印

name = '二十\n123'

val = name.isprintable()

print(val)

# str.isspace() 是否全为空格

name = '二十\n123' #空字符串也是False

val = name.isspace()

print(val)

# str.title() 变成标题，首字母大写

name = 'afklsdssdf'

val = name.title()

print(val)

3. list类

list.count("元素") # 判断元素是否存在于列表中，并且返回个数

list.clear() # 列表.clear()

list.extand("可迭代对象") # 传递 批量append,批量传递，如果是字符串，会把每个字符拆开来放进去，所以里面要放可迭代对象

v= list.pop('索引') # 删除并且获取到赋值给变量

# v 就是被删掉的东西

list.remove('值') # 重复时只能删第一个

list.sort(reverse=True) # 排序 默认False从小到大 True从大到小

list.index("值", '起始位置', '终止位置') # 找到字符所在第一个位置的索引，没有时，报错

# 深浅拷贝的规则和基本形式：列表里才会这样

li = ["11","22","33"]

val = li.append("44")

print(val) # val没有意义，为none

li1 = ["11","22","33"]

li2 = li1 # 指向同一个内存

print(li1,li2)

val = li.append("44") #li2也会发生变化

print(li1,li2)

li1 = ["11","22","33"]

li2 = ["11","22","33"] #指向两块内存

# copy 复制

# 浅拷贝 列表.copy() 只拷贝最外层，改变后一样

li1 = ["11", "22", "33"]

li2 = li.copy()

# 深拷贝 import copy 所有层都拷贝，最后一层补不拷贝，改变后不一样

import copy

li1 = ["11","22","33"]

li2 = copy.deepcopy()

# ****单个列表时，在只有数字，字符串的时候，深浅拷贝一样****

# *****嵌套时才有区别*****

# 列表'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

append() # 尾部添加，

li = [11,22,11,33,44]

li.append(666)

print(li)

# 浅拷贝的一种形式，列表里才会这样

li = ["11","22","33"]

val = li.append("44")

print(val) #val没有意义，为none

li1 = ["11","22","33"]

li2 = li1 #指向同一个内存

print(li1,li2)

val = li.append("44") #li2也会发生变化

print(li1,li2)

li1 = ["11","22","33"]

li2 = ["11","22","33"]#指向两块内存

#copy 浅拷贝 只拷贝最外层，指向同一块内存

# ****单个列表时，在只有数字，字符串的时候，深浅拷贝一样****

li1 = ["11","22","33"]

li2 = li1.copy() #这里相当于重新创建了一个列表 但是列表内元素所指向的是同一块内存

print(li2)

li1.append(666)

print(li1)

print(li2)

# 结果:

['11', '22', '33']

['11', '22', '33', 666]

['11', '22', '33']

# 深拷贝 所有层都拷贝，最后一层补不拷贝，改变后不一样。单个列表时，在只有数字，字符串的时候，深浅拷贝一样

import copy

li1 = ["11","22","33"]

li2 = copy.deepcopy(li1)

print(li2)

li1.append(666)

print(li1)

print(li2)

# 结果：

['11', '22', '33']

['11', '22', '33', 666]

['11', '22', '33']

# *****嵌套时才有区别*****

# 浅拷贝

li1 = ["11","22","33",[11,22,33]]

li2 = li1.copy() #这里相当于重新创建了一个列表 但是列表内元素所指向的是同一块内存

print(li2)

li1[3].append(666) #因为指向同一块内存，所以li2也会改变

print(li1)

print(li2)

# 结果：

['11', '22', '33', [11, 22, 33]]

['11', '22', '33', [11, 22, 33, 666]]

['11', '22', '33', [11, 22, 33, 666]]

# 深拷贝

import copy

li1 = ["11","22","33",[11, 22, 33]]

li2 = copy.deepcopy(li1)# 这里是把li1里所有的东西都重新创建了一份 ，li1 li2指向不同的内存，

print(li2)

li1.append(666) #因为指向不同的内存，所以li1改变 li2不会改变

print(li1)

print(li2)

# 结果：

['11', '22', '33', [11, 22, 33]]

['11', '22', '33', [11, 22, 33], 666]

['11', '22', '33', [11, 22, 33]]

# .clear 全部清空 列表.clear()

li = [11, 22, 11, 33, 44]

li.clear()

print(li)

# 判断元素是否存在于列表中，并且返回个数

.count("元素")

li = [11,22,11,33,44]

v = li.count(11)

print(v)

# .extand("可迭代对象") 传递 批量append

# 如果是字符串，会把每个字符拆开来放进去，所以里面要放可迭代对象

li = [11,22,33,44]

li.extend("aaa")

print(li)

li = [11,22,33,44]

li2 = ["aaa","bbb"]

li.extend(li2)

print(li)

# pop 删除 v= li.pop(索引) 删除并且获取到赋值给变量 v 就是被删掉的东西

li = [11,22,33,44]

li.pop(1) #默认删除最后一个，也可以指定

print(li)

# .remove(值) 重复时只能删第一个

li = [11,22,33,44,33]

li.remove(33)

print(li)

.sort(reverse=True) # 排序 默认False从小到大 True从大到小

li = [11,22,33,44,33]

li.sort()

print(li)

li = [11,22,33,44,33]

li.sort(reverse=True)

print(li)

# .index("值",起始位置，终止位置) 找到字符所在第一个位置的索引，没有时，报错

li = [11,22,33,44,33]

v = li.index(33)

print(v)

li = [11,22,33,44,33]

v = li.index(666)

print(v)

# .insert() 在指定位置插入

li = [11,22,33,44,33]

li.insert(2,"8888")

print(li)

# .reverse() 反转

li = [11,22,33,44,]

li.reverse()

print(li)

4. tuple类

方法汇总：

index("值", '起始位置', '终止位置') # 找到字符所在第一个位置的索引，没有时，报错

count() # 判断元素是否存在于列表中，并且返回个数

count() # 判断元素是否存在列表中，并返回个数

tu = (11,22,11,33,44)

v = tu.count(22)

print(v)

tuple.index("值",'起始位置', '终止位置') # 找到字符所在第一个位置的索引，没有时，报错

tu = (11,22,33,44,33)

v = tu.index(33)

print(v)

5. dict类　　方法汇总：

# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'

dict.clear() # 清空

dict.copy() # 和列表一样

dict.pop("key","默认值") # 删掉key值对应的值，并取出来，，，key不存在时报错，加了默认值，就不会报错，打印默认值

dict.popitem() # 随机删掉键值对 操作完位为元组类型

dict.setdefalut("key","value") # 设置：只添加不修改，有key时，不改变

dict.update({"key":"value"}) # 更新 不存在加进去，存在时更新

dict.fromkeys() # 生成一个字典

val = dict.fromkeys(["k1","k2","k3"],value)

# value 是一个可变数据类型时，对val做操作后，所有的key对应的value都变化

# value 是一个不可变类型时，更改其中一个时不会全部改变，只改变其中一个

# 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'

# clear 清空

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.clear()

print(d)

# copy 浅拷贝 只拷贝最外层，指向同一块内存

# ****单个字典时，在只有数字，字符串的时候，深浅拷贝一样****

d1 = {"k1":"v1","k2":"v2","k3":"v3"}

d2 = d1.copy() # 这里是重新创建了一个字典，但是字典内的元素指向同一个内存

print(d2)

d1["k1"] = 666

print(d1)

print(d2)

# 深拷贝,所有层都拷贝，最后一层补不拷贝，改变后不一样

# ****单个字典时，在只有数字，字符串的时候，深浅拷贝一样****

import copy

d1 = {"k1":"v1","k2":"v2","k3":"v3"}

d2 = copy.deepcopy(d1) # 这里是重新创建了一个字典，

print(d2)

d1["k1"] = 666

print(d1)

print(d2)

# *****嵌套时才有区别*****

# 浅拷贝

d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}

d2 = d1.copy() # 这里是重新创建了一个字典，但是字典内的元素指向同一个内存

print(d2)

d1["k1"].append(666) #因为指向同一个内存，所以d1改变d2也会改变

print(d1)

print(d2)

# 深拷贝

import copy

d1 = {"k1":[11,22,33],"k2":"v2","k3":"v3"}

d2 = copy.deepcopy(d1) # 这里是重新创建了一个字典，d1 d2 指向不同的内存

print(d2)

d1["k1"] = 666 # 因为指向不同的内存，所以d2不会改变

print(d1)

print(d2)

# 重点 类.fromkeys() dict.fromkeys() 生成一个字典

# value 是一个可变数据类型时，对val做操作后，所有的key对应的value都变化

# value 是一个不可变类型时，更改其中一个时不会全部改变，只改变其中一个

val = dict.fromkeys(["k1","k2","k3"],6666)

print(val)

val["k1"] = "aaa"

print(val)

val = dict.fromkeys(["k1","k2","k3"],[11,22,33])

print(val)

val["k1"].append("qqqq")

print(val)

# get() 取到key，没有时返回None

d = {"k1":"v1","k2":"v2","k3":"v3"}

print(d.get("k2"))

# keys() 取到所有key 常和for循环一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.keys():

print(v)

# values() 取到所有value 常和for循环一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.values():

print(v)

# items() 取到所有键值对 常和for循环一起用

d = {"k1":"v1","k2":"v2","k3":"v3"}

for v in d.items():

print(v)

# pop("key","默认值") 删掉key值对应的值，并取出来，，，key不存在时报错，加了默认值，就不会报错，打印默认值

d = {"k1":"v1","k2":"v2","k3":"v3"}

v = d.pop("k2")

print(v)

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

v = d.pop("k12",888)

print(v)

print(d)

# popitem() 随机删掉键值对 操作完为元组类型

d = {"k1":"v1","k2":"v2","k3":"v3"}

v1,v2 = d.popitem()

print(v1,v2)

print(d)

# setdefalut("key","value") 设置：只添加不修改，有key时，不改变

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.setdefault("k5","v5")

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.setdefault("k2","v5")

print(d)

# update({"key":"value"}) 更新 不存在加进去，存在时更新

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.update({"k2":"v5"})

print(d)

d = {"k1":"v1","k2":"v2","k3":"v3"}

d.update({"k5":"v5"})

print(d)

6. set类

方法汇总：

add() # 添加，如果存在不添加

copy() # 拷贝

update() # 更新，没有返回值

# 差集(后面的元素一般是可迭代对象)

v.difference(n) # v中存在n中不存在的数据，并取出

v.difference_update(n) # 找到v中存在n中不存在的数据，并更新v中的值，

# 对称差集

v.symmetric_difference(n) # 去掉v,n中相同的元素，并取出

v.symmetric_difference——update(n) # 去掉v,n中相同的元素，并更新v中的值

# 交集

intersection()

intersection_update()

# 并集

union()

isdisjoint() # 有交集False，没有True

v.issubset(n) # 判断v是否是n的子集

v.issuperset() # 判断v是否是n的父集

# 删除集合元素

pop() # 随机删除

remove() # 没有时报错

discard() # 没有时不报错

# add() 添加，如果存在不添加

s = {"a1","a2"}

s.add("a3")

print(s)

# copy 浅拷贝 只拷贝最外层，指向同一块内存

# ****单个集合时，在只有数字，字符串的时候，深浅拷贝一样****

s = {"a1","a2"}

s1 = s.copy() # 重新创建了一个集合，

print(s1)

s.add("a3") # 所以s改变，s1不改变

print(s)

print(s1)

# 深拷贝 所有层都拷贝，最后一层补不拷贝，改变后不一样

# ****单个集合时，在只有数字，字符串的时候，深浅拷贝一样****

import copy

s = {"a1","a2"}

s1 = copy.deepcopy(s) # 重新创建了一个集合，

print(s1)

s.add("a3") # 所以s改变，s1不改变

print(s)

print(s1)

# *****嵌套时才有区别*****

# 浅拷贝 只拷贝最外层，指向同一块内存， 重新创建了一个集合，但是集合中的元素指向一个内存,,所以会都改变

# 深拷贝 除最后一层全部拷贝，拷贝后指向两个内存，所以不会一起改变

# clear()清空

s = {"a1","a2"}

s.clear()

print(s)

# 删除集合元素

# pop() 随机删除

v = {"11", "22", "33", "44", "55"}

v.pop()

print(v)

# remove() 在集合中删除指定值 没有时报错

v = {"11", "22", "33", "44", "55"}

v.remove("22")

print(v)

v = {"11", "22", "33", "44", "55"}

v.remove("77")

print(v)

# discard() 在集合中删除指定值 没有时不报错

v = {"11", "22", "33", "44", "55"}

v.discard("22")

print(v)

v = {"11", "22", "33", "44", "55"}

v.discard("77")

print(v)

# update() 更新 不用接收

v = {"11", "22", "33", "44", "55"}

n = {"aaa","sss"}

v.update(n)

print(v)

# 差集(后面的元素一般是可迭代对象)

# v.difference(n) v中存在n中不存在的数据，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.difference(n)

print(a)

# v.difference_update(n) 找到v中存在n中不存在的数据，并更新v中的值，

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.difference_update(n)

print(v)

# 对称差集

# v.symmetric_difference(n) 去掉v,n中相同的元素，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.symmetric_difference(n)

print(a)

# v.symmetric_difference_update(n) 去掉v,n中相同的元素，并更新v中的值

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.symmetric_difference_update(n)

print(v)

# 交集

# intersection() 找到v,n中相同的元素，并取出

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.intersection(n)

print(a)

# intersection_update() 找到v,n中相同的元素，并更新v中的值

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

v.intersection_update(n)

print(v)

# isdisjoint() 判断是否无交集 有交集False，没有True

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.isdisjoint(n)

print(a)

# union() 并集

v = {"11","22","33","44","55"}

n = {"44","55","66","77","88"}

a = v.union(n)

print(a)

# v.issubset(n) 判断v是否是n的子集

v = {"44","55"}

n = {"44","55","66","77","88"}

a = v.issubset(n)

print(a)

# v.issuperset(n) 判断v是否是n的父集

v = {"44","55","66","77","88"}

n = {"44","55"}

a = v.issuperset(n)

print(a)

# 去重 相当于变成集合类型的数

li = ["44","55","66","77","88","44","44"]

v = set(li)

print(v)