python常见数据类型总结

python常见数据类型

类型	描述
数字(int)	整数
数字(float)	浮点
数字(complex)	复数
数字(bool)	布尔
字符串(String)	**[序列]**描述文本的数据
列表(List)	**[序列]**有序的可变序列
元组(Tuple)	**[序列]**有序的不可变序列
集合(Set)	无序的不重合集合
字典(Dictionary)	无序的key-value集合

• 序列支持切片操作，在下文有关于序列**(字符串、列表、元组)**的相关解释

数值类型定义

int1 = 123
str1 = "你好"
float1 = 11.3
bool1=True

列表list：[]

• 列表，定义是[]，在列表内可存不同数据类型
• 列表是一个无序的可变的序列
• 列表的内部可以继续嵌套一个列表

list1  = list()   #空列表
list2 = ['你好',666,True]    #列表存放不同数据类型
list3 = [list1,list2,"end"]   #嵌套列表

#对应结果：
list1：[]
list2：['你好', 666, True]
list3：[[], ['你好', 666, True], 'end']

列表访问 （在元组、字符串中也可使用这种访问方式）

• 0、1、2、3、4… ：从第一个索引顺序访问
• -1、-2、-3、-4…：从最后一个索引逆序访问

# list3：[[], ['你好', 666, True], 'end']
print(list3[1][1])
print(list3[1][-2])
#访问结果：
list3[1][1]:666
list3[1][-2]:666

列表操作-增

• 列表.append(元素)：将元素尾插到列表中
• 列表.insert(索引，元素)：将元素插入到索引对应的位置
• 列表.extend(数据容器)：将数据容器尾插入列表

list5 = [2,4,6,"你好",'A','B','C']
list6 = ['X','Y','Z']
list5.append('D') #尾插元素
print(list5)
list5.extend(list6) #尾插数据容器(列表)
print(list5)
list5.insert(0,1) #索引插
print(list5)

#输出结果：
list5.append('D')：
[2, 4, 6, '你好', 'A', 'B', 'C', 'D']
list5.extend(list6)：
[2, 4, 6, '你好', 'A', 'B', 'C', 'D', 'X', 'Y', 'Z']
list5.insert(0,1)：
[1, 2, 4, 6,'你好', 'A', 'B', 'C', 'D', 'X', 'Y', 'Z']

列表操作-删

• del 列表[索引]：删除列表索引位置的元素，不返回被删元素
• 列表.pop(索引)：删除列表索引位置的元素，返回被删元素，可用变量接收
• 列表.remove(元素)：查找列表中的索引到的第一个元素(只删一个)

#list5：
#[1, 2, 4, 6, '你好', 'A', 'B', 'C', 'D', 'X', 'Y', 'Z']
list5.pop(-1) #索引删，返回删除元素('z')
print(list5)
del list5[-1] #索引删，不返回值('Y')
print(list5)
list5.remove("X") #元素删('X')
print(list5)

#对应输出结果：
[1, 2, 4, 6, '你好', 'A', 'B', 'C', 'D', 'X', 'Y']
[1, 2, 4, 6, '你好', 'A', 'B', 'C', 'D', 'X']
[1, 2, 4, 6, '你好', 'A', 'B', 'C', 'D']

列表操作-改

• 改元素值其实很简单，把一个新值赋值给列表对应索引元素即可

#list5：[1, 2, 4, 6, '你好', 'A', 'B', 'C', 'D']
list5[0]=2
print(list5)

#对应输出结果：
[2, 2, 4, 6, '你好', 'A', 'B', 'C', 'D']

列表操作-查

• 列表.index(元素)：返回元素在列表中的索引
• 列表.count(元素1)：统计元素1在列表中的个数，返回
• len(列表)：返回列表的元素总个数

#list5：[2, 2, 4, 6, '你好', 'A', 'B', 'C', 'D']
s1 = list5.index("你好")
print(s1)
s2 = list5.count(2)  #查找元素2在列表的个数
print(s2)  
s3 = len(list5)   #返回列表元素个数
print(s3) 

#输出结果：
s1：4
s2：2
s3：9

列表操作-排序

• 列表.sort()：对列表永久排序(改变原列表)
• 列表.sorted()：对列表临时排序(不改变原列表)
• 列表.reverse()；反转列表

list10 = [1,5,2,3,2,4]
list11 = ['a','d','e','b','c']
list10.sort()
print(list10)
list11.sort()
print(list11)

# 输出结果：
[1, 2, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e']

列表操作-清空

• 列表.clear()：调用clear()方法，将；列表所有元素清空

#list5：[2, 2, 4, 6, '你好', 'A', 'B', 'C', 'D']
list5.clear()
print(list5)

#输出结果：
[]

元组tuple：()

• 元组一旦定义，就无法修改，可以理解为一个只读列表
• 虽然元组不可修改，但是里面嵌套一个list，则列表的元素可修改
• 若元组只有一个元素，一定要加个","来区分
• 由于元组不可变，所以比列表少了增、删、改功能，基本只剩下查

tuple1 = ("112",)   #不加","输出的结果是str
print(type(tuple1))
tuple2 = ("你好元组",123,True)
print(tuple2.index(True))  #index()查找元素下标
print(len(tuple2))  #len() ：元组长度
print(tuple2.count(123))  #count(元素)：统计

# 输出结果：
<class 'tuple'>
2
3
1

字符串str：“”

字符串定义

• ‘’、“”、“”“”""其中三引里面的内容如果不进行赋值，则默认为注释
• 当字符串内部本身存在字符串，则选用不同的引号嵌套，外层的引号pyth会识别为字符串标记，而内层的引号就可以被保留，同时也可使用"转义
• 与Java不同，python字符串之间拼接用+，但是字符串无法与数字用+直接拼接

str1 = "'单引号被保留'"
str2 = '"双引号被保留"'
str3 = "\"双引号“和‘单引号’都被保留"
print(str1,str2,str3)
#输出为：'单引号被保留' "双引号被保留" "双引号“和‘单引号’都被保留"

字符串输出

• %s : 内容转化为字符串 传入所占位置
• %d : 内容转化为整数 传入所占位置
• %f : 内容转化为浮点 传入所占位置
• 输出语句前加f(format格式设置)，输出变量用{}标注

name = "林爱学习"
address = "广东省广州市"
phone = 12345678
print("姓名:%s,地址:%s,电话:%s" %(name ,address,phone))
print(f"姓名:{name},地址:{address},电话:{phone}")

#输出：
姓名:林爱学习,地址:广东省广州市,电话:12345678
姓名:林爱学习,地址:广东省广州市,电话:12345678

补充知识：% m.n f 的格式中，前面m控制总数字位数，后面.n控制小数位数，此格式可实现数字精度控制

num1 = 11
print("num1精度控制结果：%6.3f"%(num1))
#输出：
num1精度控制结果：11.000

• python中的字符串是不可变数据类型，所以可以理解为只读
• 字符串操作并不会修改原字符串，返回了一个新字符串
• 从数据容器角度理解字符串，python字符串可以像列表一样实现下标索引
• 字符串[索引]：获取索引对应的字符
• 字符串.index(元素) ：获取元素在字符串中的索引
• 与元组类似，字符串也有len、count()方法
• 字符串.replace(子字符串，新字符串) : 将字符串中的子字符串替换为新字符串
• 字符串.split(分割字符串) ；根据分割字符串对字符串进行分割，返回一个列表
• 字符串.strip()、.lstrip()、.rstrip() ：表示去除字符串两端、左端、
• 字符串.strip(子字符串) : 移除字符串中子字符串内容

str1 = "nice to meet you"
print(str1[3])   #获取索引对应的字符
print(str1.index("e"))   #获取"e"在字符串中的索引
print(str1.count('e'))   #获取"e"在字符串中出现的次数
print(len(str1))         #计算字符串长度
str2 = str1.replace("nice","glad")
print(str2)              #得到一个"nice"被"glad"替换的新字符串
list1 = str2.split(" ")
print(list1)             #以空格分割后得到一个列表
str3 = str1.strip("nice ")
print(str3)              #移除"nice "

# 输出结果：
e
3
3
16
glad to meet you
['glad', 'to', 'meet', 'you']
to meet you

序列 (列表、元组、字符串)：切片操作

• 内容连续、有序、可使用下标索引的数据容器在python中称为序列
• 序列支持切片操作，语法：序列[起始索引：结束索引：步长]
• 起始可省略，从头开始；结束可省略，到尾结束；步长可省略，默认为1
• 当步长为负数，表示反向取序列的元素

list2=[0,1,2,3,4,5]
print(list2[::2])
str4="012345"
print(str4[5:1:-1])
tuple1=[0,1,2,3,4,5]
print(tuple1[0:5])

# 输出结果：
[0, 2, 4]
5432
[0, 1, 2, 3, 4]

集合 set：{}

• 与有序数据类型不同，集合是存储无序、不重复数据的容器
• 由于集合无序，所以集合元素的顺序无法保证，也无法通过索引访问
• 集合支持修改，集合内容重复时，会自动去重
• 集合是可变数据容器，可进行添加、删除、清空、随机取出一个元素操作
• 遍历集合时，应当使用for循环去遍历
• 集合.add(元素) ：若元素不重复，添加进集合
• 集合.remove(元素) ：删除集合中的元素
• 集合.pop() ：随机取出集合中的一个元素，原集合会少掉这个元素！！！
• 集合1.deference(集合2) ：取集合1有，集合2没有的元素，返回一个新集合
• 集合1.difference_update(集合2) ：在调用集合中消除两个集合的相同元素
• 集合1.union(集合2) ：表示两个集合的合并，自动去除重复元素

set1 = {"猪多","羊多","粮多","钱多","钱多"}
print(set1)   #"钱多"只会留下一个
set1.add("喜事多")
print(set1)   #"喜事多"被添加进去
set1.remove("喜事多")
print(set1)   #"喜事多"被删除掉
random_word = set1.pop()  #随机取出元素，取出后原集合元素不存在
print(f"取出元素为；{random_word}，取出后集合为{set1}")
set2 = {1,2,3,4}
set3 = {3,4,5,6}
set4 = set2.difference(set3)
print(set4)   #取set2有、set3没有的元素形成一个新集合(不改变原集合)
set2.difference_update(set3)
print(set2)   #在set2中删除与set3相同的元素(set发生改变)
set5 = set2.union(set3)
print(set5)   #合并set2和set3,会自动去重

# 由于集合是无序的，所以部分输出元素位置会不一样，但所含元素都是相同
# 输出结果：
{'羊多', '粮多', '猪多', '钱多'}
{'猪多', '粮多', '钱多', '羊多', '喜事多'}
{'猪多', '粮多', '钱多', '羊多'}
取出元素为；猪多，取出后集合为{'粮多', '钱多', '羊多'}
{1, 2}
{1, 2}
{1, 2, 3, 4, 5, 6}

字典dict : {}

• 字典与集合类似，不可重复，元素类型为[key : value]键值对
• 空字典定义方式有：dict()、或者{} (这也表明集合不能用此方式定义)
• 字典跟集合一样，不能通过索引获取元素，只能通过key来获取value
• key的类型不能为字典，value的类型无限刷，也可以是另外一个字典(字典嵌套)
• 字典[key] = value : 如果key不存在，则新增键值对；若key存在，则更新value的值
• 字典.pop(key) : 将key的键值对从字典取出(删除)，返回key对应的value
• 字典.keys() : 获取该字典的全部key，可用于遍历字典

#空字典
dict1 = {}

#key不存在，相当于添加操作
dict1["张三"] = 202001
dict1["李四"] = 202002
dict1["王五"] = 202003
print(dict1)

#key存在，相当于修改操作(更新)
dict1["王五"] = 202000
print(dict1)

#取出操作(删除)
dict1.pop("王五")
print(dict1)

#字典嵌套
dict1["张三"] = {"语文":100,"数学":90,"英语":80}
dict1["李四"] = {"语文":70,"数学":60,"英语":50}
print(dict1)
print(f"张三的语文成绩为：{dict1['张三']['语文']},数学：{dict1['张三']['数学']},英语：{dict1['张三']['英语']}")

# 获取字典的key，for循环遍历
list1 = dict1.keys()
for key in list1:
    print(f"{key}的语文成绩为：{dict1[key]['语文']}")
    print(f"{key}的数学成绩为：{dict1[key]['数学']}")
    print(f"{key}的英语成绩为：{dict1[key]['英语']}")

# 输出结果：
{'张三': 202001, '李四': 202002, '王五': 202003}
{'张三': 202001, '李四': 202002, '王五': 202000}
{'张三': 202001, '李四': 202002}
{'张三': {'语文': 100, '数学': 90, '英语': 80}, '李四': {'语文': 70, '数学': 60, '英语': 50}}
张三的语文成绩为：100,数学：90,英语：80
张三的语文成绩为：100
张三的数学成绩为：90
张三的英语成绩为：80
李四的语文成绩为：70
李四的数学成绩为：60
李四的英语成绩为：50

以上的字典嵌套相当于

姓名	语文	数学	英语
张三	100	90	80
李四	70	60	50

总结

1.通用操作

• 都支持for循环，集合、字典无法下标索引，不支持while循环

• len(数据容器) ：统计元素个数、max(数据容器)：最大值、min(数据容器)：最小值

• 类型转化：list()、tuple()、str()、set()，字典转字符串外的其他转化会丢失value

• sorted(数据容器，reverse =True) : 对数据容器进行排序，参数reverse =True表示反转，可不选

  操作	作用
  for循环	遍历数据容器里的元素
  len(数据容器)	统计数据容器的元素个数
  max(数据容器)	查找最大元素
  min(数据容器)	查找最小元素
  list(数据容器)	转换为列表
  tuple(数据容器)	转化为元组
  str(数据容器)	转化为字符串
  set(数据容器)	转化为集合
  sorted(数据容器，reverse=True)	排序，默认升序，reverse=True是可选项(反转)

2.使用差别

比较类别	列表	元组	字符串	集合	字典
元素类型	任意	任意	字符	任意	key：非字典 value：任意
下标索引	√	√	√	×	×
可修改性	√	×	×	√	√
有序性	√	√	√	×	×
重复性	√	√	√	×	×
应用场景	可修改、可重复	不可修改、可重复	字符串	不可重复数据	key查找value

python注意点：

• python大小写敏感，标识符以汉字、字母、数字、下划线组成，数字不能作为开头，虽然支持汉字，但还是不建议使用汉字作为变量名
• True、False、None是首字母大写的
• 与Java不同，python的变量可以不写类型
• python语句结束不需要写";"