目录:

int 整数

bool布尔

str字符串

list列表

tuple元祖

dict字典

set集合

数据类型之间的转换

列表与字典的删除

有序字典

枚举

深浅拷贝

按哈希分类

不可哈希的数据类型即可变数据类型:list、dict、set

可哈希的数据类型即不可变数据类型:int、str、tuple、bool

python通过方法type(对象)获取对象的数据类型

1. int 整数
特点:不可变、无序

表示方法:a=1

可用的函数方法:


# 查看所占字节长度,几乎不用
ret = int.bit_length(333)
print(ret) --->9
# 将小数转为整数
int(12.34) ---> 12
# 常用于进制转换
二进制:1与0组成,0b开头表示
八进制:0~7组成,逢8进1,0o开头
十进制:0~9组成,逢10进1,
十六进制:0~9~a~f组成,0x开头
进制转换原理,是先将n转化为10进制,然后调用相关方法进行对应进制转换
bin(n) 将n转化为2进制
oct(n) 将n转化为8进制
hex(n) 将n转化为16进制
将2进制转化为10进制
int(n,2)
将2进制转化为8进制
oct(int(n,2))
将2进制转化为16进制
hex(int(n,2))
将8进制转化为2进制
bin(int(n,8))
将10进制转化为2进制
bin(int(n))
将16进制转化为2进制
bin(int(n,16))
# 示例
生成一个5位的验证码?
import random
verify_num = ''
for i in range(5):
int_num = random.randint(0, 9) # 取[0,9]10个数字
# int_num = chr(random.randint(48,57)) # 也可以取到0~9
lstr_num = chr(random.randint(65, 90)) # 取ascii码表对应的a~z,chr(num)将数字转化为ascii中对应的字母
ustr_num = chr(random.randint(97, 122)) # 取对应的A~Z
choice_list = [int_num, lstr_num, ustr_num] # 构建一个含有数字大小字母的列表
v = str(random.choice(choice_list)) # 随机选一个
verify_num += v
print(verify_num)

2. bool 布尔
特点:不可变,无序,不可切片

表示方法:False,True

# python中用于条件判断用
>=1的整数,或有值的变量都为真True,0,None,"",list(),tuple(),dict(),set() 都为False

3. str 字符串
特点:不可变、有序、可切片、可迭代、不可增删改,交互默认输出为字符串

表示方法:a='xxx' 或a="xxx"

可用的常用方法:

# 切片:从左到右,字符串中的索引从0开始 [起始位置:截止位置:跨度] 顾头不顾尾
"china"[1:3] 表示获取从索引1到2的字符,即结果为:hi
"china"[1:-1] 标识获取从索引1到倒数第二个字符(-1在切片中代表最后一个字符),即结果为:hin
del string 删除字符串
len(string) 统计字符串长度
str.count(s) 统计s元素出现的次数
string.capitalize() 首写字母大写
string.upper() 字符串全部转成大写
string.lower() 字符串全部转成小写
string.startswith("元素") 字符串是否以指定元素开头
string.endswith("元素")
string.find("元素",start,end) 获取指定元素的索引,如果元素不存在,返回-1
string.index("元素",start,end) 同上,但元素不存在,抛出异常
string.strip("元素,默认为空") 字符串两侧删除指定的元素,不指定元素时删除两侧的空格
string.split("分隔符元素,默认空格,多个空格看成一个") 以指定元素分隔字符串,返回一个列表
string.replace(old,new,替换几次) 将字符串中的元素替换成新的元素
string.zfill(n) 字符串长度不够指定的n长度,则默认字符串左侧补0,二进制会用到
# 将IP:192.168.0.100转化为二进制
ip = "192.168.0.100"
bin_list = []
for i in ip.split("."):
s = bin(int(i))[2:].zfill(8)
bin_list.append(s)
bin_string = ".".join(bin_list)
print(bin_string) ---> 11000000.10101000.00000000.01100100
# 字符串格式化
0. + 拼接
"my name" + "is sun" --->"my name is sun"
1. string.format()
"{} my name is:{}".format(2021,"sun")
"{1} my name is {2},last number is {1}".format(2021,"sun")
"{year} is niu, my name is {name}".format(year=2021,name="sun")
"{year} is niu, my name is {name}".format(**{"year":2021,"name":"sun"})
2. % 百分号
%s 表示字符串
%d 表示整数
%f 表示小数 %.2f 保留2位小数
"my name is %s,age is %d" % ("china","30")
"my name is %(name)s,age is %(age)d" % {"name":"sun","age":30}
3. python版本>=3.6时,通过f"{变量}is my name" 格式化速度更快
4. "拼接符".join(可迭代对象) 可迭代对象的每个元素以拼接符为桥接,拼接成一个新字符串
".".join(["192","168"]) ---> "192.168"
"$".join([11,22]) 此种情况报错,join不能将数字进行拼接,需转化为字符串后再拼接
"$".join("%s" %id for id in [11,22]) ---> "11$22"

4. list 列表
特点:可变、有序、可切片、可迭代、元素可为任意元素、可增删改查

表示方法:a=[] 或a=list()

可用的方法:

切片:
方法同字符串切片一样通过索引取值
增:
list_obj.append(元素) 向列表末尾添加元素
list_obj.insert(元素,元素) 向列表指定索引位置添加元素
list_obj.extend(可迭代对象) 向列表末尾添加多个元素
删【删除后没有返回值】:
list_obj.pop(索引) 删除列表中指定位置的元素,如果索引不存在,则抛出异常
list_obj.remove(元素) 删除列表中指定的元素,如果元素不存在,则抛出异常
del list_obj 从内存中删除列表对象
del list_obj[:3] 根据索引切片删除
list_obj.clear() 清空列表
改:
切片修改:list_obj[index] = new_data
li =[11,22,33,44,55]
li[:2]=[66,77,88,99] # li=[66,77,88,99,33,44,55] 步长为1时,不考虑个数对应,切的是一片空间
li[:3:2] = [10,20] # 步长非1时,左右元素个数需一致才行,故本表达式,将报错抛出异常
查:
list_obj[index] 通过索引查
for i in list_obj 通过迭代循环查,i为列表中的每个元素
常用方法:
del list_obj 删除列表
len(list_obj) 统计列表元素的个数
list_obj.count(元素) 统计元素出现的次数
list_obj.index(object,start,end) 查找元素的索引
list_obj.sort(reverse=False) 排序,默认为升序,当reverse值设为True时,降序排列,只有列表中元素相同时才可,不然报错
list_obj.reverse() 列表中元素顺序反转过来,同上面sort一样在列表对象上操作,直接生效,不会有返回值
list_obj.copy() 列表浅拷贝
object in list_obj 判断对象是否在列表中
枚举函数enumerate
for i in enumerate(list_obj):
print(i) --->(索引,元素)

5. tuple 元祖
特点:不可变、可切片、可迭代、有序、元素可为任意元素、不可增删改

表示方法:t=() 或t=tuple()

注:

如果元素只有一个,需在尾部加一个逗号,不然python认为其为一个变量或是做数学运算等,如t=(10000,)

元祖中的第一层数据不可变,如其第二层数据类型为可变的(list,dict,set)则可变的,如t=(1,[1,2,3],{4,5,6},{"a":1,"b":2})

t=1, python认为这也是一个元素

可用的方法:


# 查
tuple_obj[2] 通过切片查
for t in tuple_obj:pass 通过迭代循环查
del tuple_obj
len(tuple_obj) 统计对象的长度
tuple_obj.count(元素) 统计元素出现的次数
tuple_obj.index(元素) 获取元素的索引
# 解构
a,b = (3,6)
--> a=3,b=6
要求左边元素个数必须和右边一致,同样的str,list,dict都有这种特性

6. dict 字典
特点:可变(key不可变,值可变)、无序(3.6后都为有序)、可迭代、值元素可为任意数据类型、可增删改查

表示方法:d={key:value} 或d=dict()

# 增
dict_obj[key]=new_data 如果key不存在则新增,如果存在则更新对应key的值
dict_obj.setdefault("key", default="默认值")
新增的key,如果在dict_obj中已经存在,则不会改变原来的value,否则新增
setdefault是有返回值的,返回值为value,如果该key存在,返回的为原值,如果不存在返回的为默认值
d = {"test":111}
d.setdefault("test",2222)
print(d) ---> {"test":111}
# 示例:将列表li=[1,2,3,4,5,6,7,8]以3分隔成两个字典{"k1":[小于3的值],"k2":[大于等于3的值]}
d = {}
for i in li:
if i < 3:
d.setdefault("k1", []).append(i)
else:
d.setdefault("k2", []).append(i)
print(d) ---> {'k1': [1, 2], 'k2': [3, 4, 5, 6, 7, 8]}
dict.fromkeys(iterale,value)
前面的可迭代的序列中的每个元素,都与后面设定的值,组成一个key不同,value相同的字典
如果后面的value是可变数据类型,那么改变序列元素组成的字典任一个value,其他元素也都会改变
其实就是浅拷贝
# 示例
s = dict.fromkeys("key", [11, 22])
print(s) # ---> {'k': [11, 22], 'e': [11, 22], 'y': [11, 22]}
s["k"][0] = 333
print(s) # ---> {'k': [333, 22], 'e': [333, 22], 'y': [333, 22]}
s["k"] = "xxxx"
print(s) # ---> {'k': 'xxxx', 'e': [333, 22], 'y': [333, 22]}
# 删
dict_obj.pop(key) 删除指定key,返回对应删除的value,默认删最后一项,如果key不存在,报错
dict_obj.popitem() python3.6版本前随机删除,之后默认删除最后一个键值对,以元祖形式返回对饮的键值对
del dict_obj[key]
del dict_obj
dict_obj.clear()
# 改
dict_obj[key]=new_data
dict_obj.update(dict_obj) 无返回值!!!,两个字典合并,如果有key相同,则后面的覆盖前面的
# 查
dict_obj[key] key不存在时,报错
dict_obj.get(key,"默认值") key不存在时,返回默认值,默认值不设置时默认为None
dict_obj.items() 返回以元祖形式展示的键值对
dict_obj.keys() 返回以列表展示的所有的key,可迭代
dict_obj.values() 返回以列表展示的所有的values,可迭代
for k in dict_obj k为dict_obj的每个键
len(dict_obj) 统计字典的个数

7. set 集合
特点:可变、无序、不可切片、可迭代、元素需唯一不重复且可哈希即不可变的数据类型

表示方法:s={1,2,3} 或s=set()

注:集合可以用于去重,以及分析数据时的差异与相同部分


# 增
set_obj.add(元素) 无返回值
set_obj.update(iterale) 序列迭代的更新到set中
# 删
set_obj.pop() 随机删除,返回删除的值
set_obj.remove(元素) 无返回值,不存在报错
set_obj.clear()
del set_obj
# 改
因无序,只能通过先删除指定元素,然后增加新元素
set_obj.remove(元素)
set_obj.add(元素)
# 查
for s in set_obj
# 求元素个数
len(set_obj)
# 求两个集合的交集(相同的部分)
set_obj1 & set_obj2
# 求两个集合的并集(合并到一起)
set_obj1 | set_obj2
# 求两个集合的差集(将前面集合中在后面集合出现的元素去掉)
set_obj1 - set_obj2
# 求是否为子集(前面集合是后面集合的一部分)
set_obj1.issubset(set_obj2)
8. 数据类型之间的转换
字符串转成数字
# 想把str转换成int,str必须全是数字才行,不然报错
s = "1111"
s_to_int = int(s)
字符串转成列表
string.split()
list(string)
列表&元祖&集合转化成字符串
"".join(iterale)
其实除了字典因需2个键值对的关系无法通过类方法转化,字符串都可以迭代的通过list(),tuple(),set() 方法转换成对应的数据类型
相同的数据类型合并
# 字符串
可通过+ 、format()、%、f"{}{}"
# 列表
+、extend()
# 字典
update()
# 集合
update()

9. 列表和字典的元素删除
因直接删除列表或字典时,改变了列表的索引,字典的长度,导致可能达不到目的或报错

# 将要删除的元素存放临时表,遍历临时表,删除原列表
base_list = [x,xx,xxx,xxxx]
base_dict = {k1:v1,k2:v2}
del_temp= [obj1,obj2]
for d in del_temp:
# 列表删除
base_list.remove(d)
# 字典删除
base_dict.pop(d)

10. 有序字典
从python3.6开始,字典创建时就有序了,但却是按创建时key的位置来定义的,而工作中有序的字典是经常用到的,比如验证签名,往往需要将请求体json按一定顺序进行排序后再拼接编码

# 将字典按ASCII码表顺序进行倒序排序,组成一个新字典
方案一:
import json
ret = json.dumps(data, sort_keys=True)
方案二:
报文json嵌套层级2层:
def base_sort(data):
for k, v in data.items():
if isinstance(v, dict):
second_sort = sorted(v, reverse=True)
gen_dict = {j: v[j] for j in second_sort}
# 排完序回填回去
data[k] = gen_dict
else:
data = {i: data[i] for i in sorted(data, reverse=True)}
return data
报文json层级嵌套3层或更多层呢?
python自带的有序字典:OrderedDict
"""python的有序字典,是按字典插入的顺序来输出的"""
from collections import OrderedDict
d = OrderedDict()
d["a"] = "a"
d["b"] = "b"
d["c"] = "c"
for k, v in d.items():
print(k, v)

11. 枚举
枚举保证了key与value的唯一性,工作中常用于构建枚举字典,状态响应说明的构建

# 枚举函数:enumerate(iterable,start=0),以元祖的形式输出元素的索引及值
for index,value in enumerate(li):
print(index,value)

需求构建服务响应状态码枚举类?

# 方案一
class ErrorEnumV1(object):
code0 = (0, "成功")
code2 = (1, "失败")
code3 = (2, "参数异常")
# 方案二:优化【保证key与value的唯一性,不然报错】
from enum import Enum, unique
@unique
class StateEnum(Enum):
code0 = (0, "成功")
code2 = (1, "失败")
code3 = (2, "参数异常")
if __name__ == '__main__':
# 获取code和desc
code = StateEnum.code0.value[0]
desc = StateEnum.code0.value[1]
print(code, desc)

12. 深浅拷贝
浅拷贝:

1、针对的是可变数据类型:list、dict、set ,不可变数据类型int、str、tuple、bool 是没有拷贝一说的,他们都没copy() 方法

2、浅拷贝后是在内存地址中分配了一份新的地址,且浅拷贝只拷贝了第一层,第二层不会拷贝,故第二层如果改变,原数据及浅拷贝后的数据也将改变

3、= 赋值不是浅拷贝

a = [11,22,[11,22]]

b = a

注:以上称为赋值,只是将a,b都指向了同一个内存地址

a.append(33)

print(b) ---> [11,22,[11,22],33] 还是一起改变,b和a都是列表的内存地址的两个别名

c = a.copy() 用方法copy是浅拷贝,id(a) 与 id(c) 的内存地址是不同的
4、[:] 切片是浅拷贝


lis = [11,22,[11,22]]
qie = lis[:]
lis[2].append(33)
print(lis,qie) # [11, 22, [11, 22, 33]] [11, 22, [11, 22, 33]]
print(id(lis),id(qie)) # 1482689615624 1482689615752
深拷贝:
就是将原文件内部元素完全拷贝,不会将因为第二层元素改变,另一个也会改变
深拷贝方法:
import copy
list_new = copy.deepcopy()
# 这个方法在你处理请求报文过程中如果对报文内容进行了改动,
# 记得一定先深拷贝一份,不然你会为排bug头疼的
```!