Python数据类型

字符串（str）
1. 字符串的独有功能
2. 字符串的公共功能
列表（list）
元组（tuple）
1. 元组的独有功能
2. 元组的公共功能
字典（dict)
集合（set）
其他数据类型

字符串（str）

字符串是一个不可变类型。

字符串用一对双引号或一对单引号包裹，之所以两种引号都可以使用，是为了避免当字符串里面出现单引号或双引号时引起歧义。

用三对双引号或三对单引号表示多行的字符串。

# 单行文本
'字符串'
"字符串"

# 多行文本
'''
字
符
串
'''

字符串的独有功能

字符串类型具有独有的功能，使用方法有两种,比如字符串n1 = "root"，①n1.功能名() ②"root".功能名()

转换为整型

部分整型和字符串可以相互转换，比如

1
2
3

str(19)			# 把整型数据类型19转换成字符串类型
int('19')		# 把字符串类型的19转换成整型
int('其他字符串')		# 这样的无法转换

转换大小写

英文字符串可以使用upper()可以使之转化为大写，使用lower()使之转化为小写，比如：

n1 = root
n2 = WHERE
n3 = n1.upper()	 # n3是一个新的字符串，n3 = UPPER
n4 = n2.lower()	 # n4是一个新的字符串，n4 = where

判断字符串是否可以转化为整型

使用isdecimal()可以判断一个字符串是否可以转化为整型，结果会得到一个布尔值，比如：

n1 = "123"
n2 = "张三"
b1 = n1.isdecimal()	#b1 = True
b2 = n2.isdecimal()	#b2 = False

判断字符串的开头和结尾

使用startswith()判断是否以某字符串开头，使用endwith()判断是否以某字符串结尾

1
2
3

n1 = "中华人民共和国"
b1 = n1.startswith("中华")	#b1 = True
b2 = n1.endswith("中华")	#b2 = False

去除空白

空白是指空格、回车、制表符，使用strip()去除左右两边的空白，使用lstrip()和rstrip()分别去除左边和右边的空白，上述三种方法并不能去除字符串中间的空白。

n1 = " 台湾省 "
v1 = n1.strip()		#v1 = "台湾省"
v2 = n1.lstrip()	#v2 = "台湾省 "
v3 = n1.rstrip()	#v3 = " 台湾省"

替换字符串中的部分内容

用replace()将字符串中的部分内容替换为另一部分内容

1 2	n1 = "常州大学西太湖校区" n2 = n1.replace("西太湖","武进") #n2 = "常州大学武进校区"

字符串切割

使用split()将字符串切割为几个部分,切割后得到的是一个列表，通过索引来获取各个切割后的各个部分

campu_name = "常州大学-西太湖校区"
name_list = campu_list.split("-")	#name_list = [ "常州大学" , "西太湖校区" ]
name_list[0]						#"常州大学"
name_list[1]						#"西太湖校区"

字符串拼接

将多个字符串拼接起来有三种方法：①通过"+" ②字符串格式化 ③通过join()

通过"+"

n1 = "常州大学西太湖校区"
n2 = "常州大学"+"西太湖校区"		#n2 = "常州大学西太湖校区"

# 另外还有字符串乘以数字，表示让字符串重复多少次，比如：
print('6'*3)	# 666

字符串格式化
- 使用format()（推荐）
  
  在一个字符串中使用{}代表了一个占位符，在字符串后面加上.format()可以传入其他字符串到占位符里，比如
  1
  2
  text="我是{0}，今年{1}岁".format("邓金俊",22)
  #text=我是邓金俊，今年22岁
  也可以不使用0，1的序号，那么format()里面的字符串将会按顺序传入占位符里，比如
  1
  2
  text="我是{0}，今年{1}岁".format("邓金俊",22)
  #text=我是邓金俊，今年22岁
  可以不使用0，1的序号，而是在format()里面给进行替换的字符串命名，使用变量名来指代字符串，比如
  1
  2
  text="我是{name}，今年{age}岁".format(name="邓金俊",age=22)
  #text=我是邓金俊，今年22岁
  字符串可以重用，比如
  1
  2
  3
  text = "我是{0}，今年{1}岁"
  text1 = text.format("张三", 13) #text1=我是张三，今年13岁
  text2 = text.format("李四", 14) #text2=我是李四，今年14岁
- 使用%
  
  在一个字符串中使用%代表占位符，在字符串后面使用空格加上一个%可以传入其他字符串到占位符里。%s、%d分别代表一个字符串和一个整型的占位符，与C语言中相似，比如：
  1
  2
  text="我是%s，今年%d岁" %("邓金俊",22)
  #text=我是邓金俊，今年22岁
  字符串按顺序传入，与format()的用法相似，也可以进行字符串的重用
- 使用f-string
  
  预先给字符串命名，需要传入字符串时再使用{}传入，字符串前要加上f。f-string是Python3.6版本后才出现的用法,比如:
  1
  2
  3
  4
  name="邓金俊"
  age=22
  text=f"我是{name}，今年{age}岁"
  #text=我是邓金俊，今年22岁

通过join()将列表中的字符串拼接起来

列表中必须全部都是字符串，通过任意符号将所有字符串按顺序连接，比如：

1
2
3

name_list = [ "张三" , "李四" , "王五" ]
n1 = "和".join(name_list)	# n1 = "张三和李四和王五"
n2 = "".join(name_list)		# n2 = "张三李四王五"

编码和解码

python中默认使用的是unicode方式编码的字符串类型，可以使用encode()将字符串类型转化为字节类型，使用decode()将字节类型转化为字符串类型，比如：

1
2
3

n1 = "常州大学"
v1 = n1.encode("utf-8")	# 此时v1是字节类型，v1 = b'\xe5\xb8\……\xa6',b'表示是字节类型
n2 = v1.decode("utf-8")	# 此时v2是字符串类型，v2 = "常州大学"

字符串长度的补足

当需要将字符串的长度未达到预设的长度时，可以使用center()、ljust()、rjust()对字符串长度进行补足，括号里放预设的长度和任意的填充符，center()是将字符串放到填充符的中间，ljust()和rjust()是将字符串放到填充符的左边和右边，比如：

n1 = "常州大学"
v1 = n1.center(13,"-")	# v1 = -----常州大学----
v2 = n1.ljust(13,"*")	# v2 = 常州大学*********
v3 = n1.rjust(13," ")	# v3 =          常州大学

字符串左边补0

使用zfill()在字符串的左边进行补0，直到达到预设长度，是ljust()的子集用法，常用于二进制字符串

1 2	data = "01101" v1 = data.zfill(8) # v1 = "00001101"

字符串的公共功能

获取长度

使用len()获取字符串长度，比如：

name = "百里守约"
l1 = len(name)	# l1= 4
text = "紫霞仙子yyds"
l2 = len(text) # l2 = 8

索引

字符串的每个字符都有索引，通过 字符串名称[] 获取，比如：

text = "常州大学西太湖校区"
#       0 1 23 4 56 7 8	一共9个字符
# 也可以从后往前      -2-1
text[0] # "常"
text[4] # "西"
text[-1]# "区"
text[9] # 报错

切片

通过字符串每个字符的索引，可以截取一部分字符串，通过 text[索引号:索引号] 获取(前取后不取)，比如：

text = "常州大学西太湖校区"
#       0 1 23 4 56 7 8	一共9个字符
# 也可以从后往前      -2-1
text[0:7] # "常州大学西太湖" 从第一个索引号开始，取到第二个索引号的前一位
text[4:7] # "西太湖"
text[0:-2]# "常州大学西太湖"	也可以按照从后往前的索引号
text[4:]  # "西太湖校区"	省略第二个索引号，直接截取剩余全部
text[:-1] # "常州大学西太湖校"	省略第一个索引号，从第一个字符开始截取
text[:]   # "常州大学西太湖校区"	两个索引号都省略，截取全部字符串

循环输出

将字符串中的单个字符循环输出，两种方式，一种是通过字符索引+while循环，另一种是通过for循环，比如：

data = "123456"
for item in data:
    print(item)
# 1	 2	3	4	5	6
# item并不是关键字，而是一个普通变量名，可替换

包含

使用in判断字符串中是否包含某个字符串，比如：

1
2
3

text = "常州大学西太湖校区"
if "常州大学" in text:	# True
	pass

列表（list）

列表是一个有序且可变的容器，里面的元素可以是不同的数据类型。

与字符串不同的是，列表是可变类型，绝大部分的功能都是对原列表进行操作。

列表的独有功能

追加

通过append()在列表末尾追加一个元素，括号中是要追加的元素或者变量名，比如：

1 2	list1 = [1,2,3] list2 = list1.append(55) #list2 = [1,2,3,55]

插入

通过insert()在列表中任意位置插入一个元素，括号中是索引值和要追加的元素，比如：

1
2
3

list1 = ["张三","李四",3,True]
list1.insert(2,"常州大学")	# list1:["张三","李四","常州大学",3,True]
#要插入的位置如果已经存在元素，则向后顺延

删除

删除有两种方式

remove()通过元素值在列表中删除一个元素，比如：

list1 = ["张三","李四",3,True]
list1.remove("3")	# list1:["张三","李四",True]
#如果列表中存在多个相同元素，则只会删除索引值从小到大起的第一个
#如果列表中不存在括号中的元素，则会报错

del，通过索引值在列表中删除一个元素，比如：

1 2	list1 = ["张三","李四",3,True] del list1[2] # list1:["张三","李四",True]

出列

通过pop()在列表中获取到一个元素，该元素在列表中移出，括号中是索引值，比如：

1 2	list1 = ["张三","李四",3,True] data = list1.pop(2) # data = 3 list1:["张三","李四",True]

清空列表

通过clear()清空列表中的所有元素，比如：

1 2	list1 = ["张三","李四",3,True] list1.clear() # list1:[]

排序

通过sort()将列表中的元素进行排序，比如：

list1 = ["3","1","8"]
list1.sort()			# ["1","3","8"] sort默认是从小到大排序
list.sort(reverse=True)	# ["8","3","1"] 括号中填入reverse=True，会逆序排序
# 只能对列表进行排序，且是在原列表的基础上排序
# 当列表中的元素是字符串时，会按照首个字符的Unicode编码顺序排列

列表的公共功能

获取长度

通过len()获取列表的长度，即列表中元素的个数，比如：

1 2	list1 = ["3","1","8"] len(list1) #3

索引

列表中的元素同样对应索引值，从0开始，也可以从后往前取，从-1开始。

通过索引值可以对列表中的元素进行获取，修改和删除。

列表可以嵌套，即列表中的元素可以是一个列表，子列表中的每一个元素同样具有独立的索引值

切片

与字符串中的切片功能类似，通过两个索引值，截取列表中的部分元素，比如：

list1 = ["张三","李四",3,True]
list1[1:3]	#["李四",3] 前取后不取
list1[1:-1] #["李四",3] 也可以根据负数索引值
list1[:]	#["张三","李四",3,True] 省略两个索引值，截取全部字符串
list1[1:]	#["李四",3,True] 省略第二个索引值，截取剩余的全部元素
list1[:2]	#["张三","李四",] 省略第一个索引值，从第一个元素开始截取

对拿到的切片列表可以进行修改，比如：

1
2
3

list1 = ["张三","李四",3]
list1[0:2] = [1,2]
print(list1)	# [1, 2, 3]

也可以对拿到的切片列表进行删除，比如：

1
2
3

list1 = ["张三","李四",3]
del list1[0:2]
print(list1)	# [3]

循环输出

使用for可以循环输出列表元素，具有与字符串同样的操作：

data_list = [11,22,33,44]
for item in data:
    print(item)
# 11   22	33	44

包含

使用in判断列表中是否包含某个元素。

列表推导式

python中提供了简便的语法，用一行代码生成列表、字典中的多个元素。

这是一个完整的推导式，括号内有三个部分，第一个部分是每次要生成的元素，第二个部分是生成元素的次数，第三个部分是元素需要满足的条件

1 2	data_list = [i for i in range(101) if i > 10] # 大于10的100以内的整数 # [11,12,13,……,100]

1 2	data_list = [i for i in range(101)] # 100以内的整数 # [1,2,3,……,100]

1 2	data_list = [3 for i in range(101)] # 第一部分可以是任意数据类型 # [3,3,3,……,3] 循环100次，100个3

1 2	data_list = [[1,2] for i in range(101)] # 第一部分可以是任意数据类型 # [[1,2],[1,2],[1,2],……[1,2]] 循环100次，100个[1,2]

1 2	data_list = ["位序为{}".format(i) for i in range(101)] # 第一部分也可以是表达式 # ["位序为1"，"位序为2"，"位序为3",……,"位序为100"]

1 2	data_list = [11,"cczu",{1,2,},34,True] result = [item for item in data_list if type(item)==int] # [11, 34]

元组（tuple）

元组是一个有序且不可变的容器，元素可以是不同的数据类型。

元组可以嵌套，但元组定义之后，元组的个数不能修改，元组中的元素也不能修改。比如：

1	v1 = (1,"python",True,(1,2),[1])

但是，元组中的元素中的元素可以修改，比如元组中的列表中的元素可以修改，比如：

1
2
3

v1 = (1,"python",True,(1,2),[1])
v1[-1][0]=11	# v1 = v1 = (1,"python",True,(1,2),[11]) 
# 可以理解为，元组中的元素的内存地址不能改变，但该元素自身可以发生改变

注意事项：如果括号中只有一个元素，且尾部没有逗号，则它不是元组，而是去除括号之后的值。比如：

1 2	v1 = (666,) #是元组 v2 = (666) #不是元组，v2 = 666

元组的独有功能

无

元组的公共功能

获取长度

通过len()获取元组中元素的个数。比如：

1 2	v1 = (1,"python",True,(1,2),[1]) len(v1) # 5

索引

元组中的元素同样具有索引值，但是不能删除和修改，只能读取。比如：

1 2	v1 = (1,"python",True,(1,2),[1]) v2 = v1[1] # v2 = "python"

切片

通过索引值，可以获取元组中的部分元素。比如：

1
2
3

v1 = (1,"python",True,(1,2),[1])
v2 = v1[1:3]	# v2 = ("python",True)
# 索引从0开始，前取后不取

循环

通过for()循环输出元组内的元素，比如：

1
2
3

v1 = (1,"python",True,(1,2),[1])
for item in v1:
    print(item)

包含

使用in判断元组中是否包含某个元素。

字典（dict)

字典是一个元素只能是键值对且键不重复的可变的容器。（python3.6之前字典中的元素是无序的）比如：

1 2	info = {"k1":123,"k2":456} # 里面的元素称为键值对 # 如果键重复，数据将会覆盖

键必须是可哈希类型：

1 2	int bool str tuple # 可哈希类型 list dict # 不可哈希类型，即字典和列表不可作为键名

字典的独有功能

获取所有键

字典可以通过key()来获取字典中的所有键名，比如：

v1 = {"name":"邓胖胖","age":23,"hobby":"学习"}
v2 = v1.keys()	# v2 = dict_keys(['name', 'age', 'hobby'])
# 此时的v2是一个类似于列表的对象,可以进行for循环
v3 = list(v2)	# v3 = ['name', 'age', 'hobby'],这是一个真正的列表

获取所有值

字典可以通过values()来获取字典中的所有值，比如：

v1 = {"name":"邓胖胖","age":23,"hobby":"学习"}
v2 = v1.values()	# v2 = dict_values(['邓胖胖', 23, '学习'])
# 此时的v2也是一个类似于列表的对象,可以进行for循环
v3 = list(v2)		# v3 = ['邓胖胖', 23, '学习'],这是一个真正的列表

获取所有键值对

字典可以通过items()来获取字典中的所有键值对，比如：

v1 = {"name":"邓胖胖","age":23,"hobby":"学习"}
v2 = v1.items()	# v2 = dict_items([('name', '邓胖胖'), ('age', 23), ('hobby', '学习')])
# 此时的v2也是一个类似于列表的对象,里面的每个元素都是一个元组，可以通过for循环输出每个键值对，也可以通过解包获取到单个的键和值
for key,value in v2:	
	print(key,value)		# 两个变量名是随意的   
    
v3 = list(v2)	# v3 = [('name', '邓胖胖'), ('age', 23), ('hobby', '学习')]这是一个真正的列表

通过键名获取值

字典通过get()来获取值，括号中是键名。比如：

v1 = {"name":"邓胖胖","age":23,"hobby":"学习"}
v2 = v1.get("name")			# v2 = "邓胖胖"
v3 = v1.get("email")		# v3 = None 如果键名不存在，则返回None
v4 = v1.get("hobby","xxx")   # v4 = "学习" 如果键名存在，则返回键值，如果不存在，则返回"xxx"

字典的公共功能

获取长度

通过len()获取字典中键值对的个数，比如：

1 2	v1 = {"name":"邓胖胖","age":23,"hobby":"学习"} len(v1) # 3

索引

与字符串、列表和元组中的索引不同，字典中的索引是指键名，比如：

v1 = {"name":"邓胖胖","age":23,"hobby":"学习"}
data = v1["name"]	# 一般推荐使用v1.get("name")的方式来获取键值，因为通过索引取值，若键名不存在会报错
v1["age"] = "24"	# 通过索引来修改键值对，若键名不存在，则会新增一个键值对
del v1["hobby"]		# 通过索引来删除一个键值对，若键名不存在，则会报错，可以先进行判断
# if "hobby" in v1:
#     del v1["hobby"]

循环

通过for()循环输出字典中的所有键名或键值或键值对，独有功能中已经描述。

包含

使用in判断字典中是否包含某个键。比如：

1 2	if "hobby" in v1: del v1["hobby"]

字典推导式

字典推导式的方法与列表推导式基本相同，第一部分是键值对的形式，键和值都可以自定义

1 2	data_dict = {i:pow(i,2) for i in range(11) if i>5} # 需要注意键必须是可哈希类型 # {6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

集合（set）

集合是一个无序、可变、元素必须可哈希且元素不重复的容器。

集合的定义

# 定义一个空列表、元组或字典有两种方法
l1 = []
l1 = list()	# 定义一个空列表
t1 = ()
t1 = tuple()# 定义一个空元组
d1 = {}
d1 = dict()	# 定义一个空字典
# 与列表、元组、字典不同，定义一个空集合只有一种方法
s1 = set()	# 定义一个空集合

集合的独有功能

添加元素

通过add()向集合中添加一个元素，比如：

1 2	s1 = {11,22} s1.add(33) # s1 = {11,22,33}

删除元素

通过discard()从集合中删除一个元素，比如：

1
2
3

s1 = {11,22}
s1.discard(22)	# s1 = {11}
s1.discard(44)	# 如果要删除的元素不存在，不会报错

交集

获取两个集合的交集有两种方式，一种是使用&符号，另一种是通过intersection()获取交集，比如：

v1 = {1,2,3}
v2 = {3,4,5}
# 方式1
res = v1 & v2	# res = {3}
# 方式2
res = v1.intersection(v2)	# res = {3}

并集

获取两个集合的并集有两种方式，一种是使用|符号，另一种是通过union()获取交集，比如：

v1 = {1,2,3}
v2 = {3,4,5}
# 方式1
res = v1 | v2	# res = {1,2,3,4,5}
# 方式2
res = v1.union(v2)	# res = {1,2,3,4,5}

差集

获取两个集合的差集有两种方式，一种是使用-符号，另一种是通过difference()获取交集，比如：

v1 = {1,2,3}
v2 = {3,4,5}
# 方式1
res = v1-v2		# res = {1,2},v1中有而v2中没有的
res = v2-v1		# res = {4,5},v2中有而v1中没有的
# 方式2
res = v1.difference(v2)		# res = {1,2},v1中有而v2中没有的
res = v2.difference(v1)		# res = {4,5},v2中有而v1中没有的

集合的公共功能

获取长度

通过len()获取集合中元素的个数，比如：

1 2	v1 = {1,2,3} len(v1) # 3

循环

通过for()循环输出集合中的元素，比如：

1
2
3

v1 = {1,2,3}
for item in v1:
    print(item)		# 无序输出

包含

通过in判断集合中时候包含某元素（集合中的元素必须是可哈希类型）

列表、元组、集合的相互转换

列表、元组或集合可以相互转换，比如：

1
2
3

v1 = [1,2,3]	# 列表
v2 = set(v1)	# v2 = {1,2,3} 集合
# 当元组和列表转换为集合时，会自动去重

其他数据类型

None类型

None表示空值，相当于其他语言中的null

布尔类型（bool）

bool类型有两个值：

1 2	True:真 False:假

很多类型的值都可以转化为bool值，极个别转化为False

1
2
3

0,"",[],(),{},set(),None	-> False
#其他的值转化后都为True
#所以当if或while后的条件是一个其他类型的值时，会自动转化为bool值

浮点型（float）

浮点型，就是小数，比如：

v1 = 9.23

由于计算机底层浮点型的存储原理，有时候获取的值可能不太准确。

字节类型（bytes）

字节类型是由字符串类型转化而来的，比如：

n1 = "常州大学"
v1 = n1.encode("utf-8")	
# v1 = b'\xe5\xb8\xb8\xe5\xb7\x9e\xe5\xa4\xa7\xe5\xad\xa6',v1是字节类型，底层是utf-8编码
v2 = n1.encode("gbk")
# v2 = b'\xb3\xa3\xd6\xdd\xb4\xf3\xd1\xa7',v2是字节类型，底层是gbk编码

同样的，拿到了字节类型，也可以使用decode()转化为字符串类型，比如：

1 2	v2 = b'\xb3\xa3\xd6\xdd\xb4\xf3\xd1\xa7' n1 = v2.decode("gbk") # n1 = "常州大学"

2022-12-23 该篇文章被邓胖胖打上标签: Python 归为分类: 学习笔记