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 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头疼的
```！