Python之数据类型的常用方法
常用方法汇总
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)
