Python_学习之基础数据类型

目录：

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 randomverify_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 += vprint(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在切片中代表最后一个字符)，即结果为：hindel string   删除字符串len(string)  统计字符串长度str.count(s)  统计s元素出现的次数string.capitalize() 首写字母大写string.upper() 字符串全部转成大写string.lower() 字符串全部转成小写string.startswith("元素") 字符串是否以指定元素开头string.endswith("元素")string.find("元素"，start,end) 获取指定元素的索引，如果元素不存在，返回-1string.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_datali =[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      判断对象是否在列表中枚举函数enumeratefor 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_objlen(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] = 333print(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_objdict_obj.clear()# 改dict_obj[key]=new_datadict_obj.update(dict_obj)  无返回值！！！，两个字典合并，如果有key相同，则后面的覆盖前面的# 查dict_obj[key]  key不存在时，报错dict_obj.get(key,"默认值")  key不存在时，返回默认值,默认值不设置时默认为Nonedict_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 jsonret = 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 OrderedDictd = 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@uniqueclass 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 copylist_new = copy.deepcopy()# 这个方法在你处理请求报文过程中如果对报文内容进行了改动，# 记得一定先深拷贝一份，不然你会为排bug头疼的```！

更多相关文章

随机推荐