首页 / PYTHON / Python_学习之基础数据类型
Python_学习之基础数据类型
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Python_学习之基础数据类型，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11528字，纯文字阅读大概需要17分钟。
内容图文
目录：
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头疼的
```！内容总结
以上是互联网集市为您收集整理的Python_学习之基础数据类型全部内容，希望文章能够帮你解决Python_学习之基础数据类型所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。