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'x00x05'
b'x05x00'
b'x05'
5

　　

2. str类
　　方法汇总：

str.lower()     # 只能做英文
str.casefold()    # 包含小语种        β-->ss的大写
str.center('总长度',"前后填充")
str.ljust('总长度',"后面填充")
str.rjust('总长度',"前面填充")
str.count("序列","起始位","结束位")  # 查看序列是否存在
str.expandtabs('总位数')     # xxx	  一共占多少位，可以做简单表格形式
      # 
 或 
 换行符  	制表符
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	  一共占多少位，可以做简单表格形式
# 
 或 
 换行符  	制表符
v = "aDG	HH	daH
aDG	HH	daH
aDG	HH	daH"
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
alf
kal
akl"
val = v.partition("
")       #只有一次
print(val)

# str.rpartition()    从右分割并且保留分割符，(结果是元组)
v = "akl
alf
kal
akl"
val = v.rpartition("
")      #只有一次
print(val)

# str.split()       分割不保留分割符，结果是列表
v = "akl
alf
kal
akl"
val = v.split("
")
print(val)

# str.rsplitl()   从右边分割 ，分割不保留分割符， 结果是列表
v = "akl
alf
kal
akl"
val = v.rsplit("
")
print(val)

# str.splitlines()   根据换行符分割 ， 结果是列表
v = "akl
alf
kal
akl"
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 = '二十
123'
val = name.isprintable()
print(val)

# str.isspace()   是否全为空格
name = '二十
123'        #空字符串也是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)