python组合数据类型

---

一、序列

序列，指的是一块可以存放多个值的连续内存空间，空间中的值按一定顺序排列，每个值对应一个位置编号，这个位置编号称为值的索引或序列，可以通过索引或序号访问它们；python中的序号体系分为正向递增和反向递增序号。

1.1、字符串

字符串（string）是字符的序列，是python中最常见的序列类型，python中的字符串是用单引号（’ '）、双引号（" “）或三引号（”“” “”"）括起来的一个或多个字符。

a = '123'
b = "abc"
c = """a1a"""
print("a=",a,"=",type(a))
print("b=",b,"=",type(b))
print("c=",c,"=",type(c))

D:\pythonLED\python.exe E:/pythonProject/1.py
a= 123 = <class 'str'>
b= abc = <class 'str'>
c= a1a = <class 'str'>

1.1.1、访问字符串

对字符串中的单个字符或连续多个字符进行访问时，可以采用单个访问或区间访问。

单个访问

单个访问的功能是访问字符串a中序号n对应的字符，其中，a是存储字符串的变量名称，n是希望访问的字符串的序号。

语法：a[n]

a = "Hello World!"
print("a=",a[0])
print("a=",a[-1])
print("a=",a[5])

D:\pythonLED\python.exe E:/pythonProject/1.py
a= H
a= !
a=  

区间访问

区间访问的功能是访问字符串a中多个字符，其中，a是存储字符串的变量名称，n是第一个字符的序号，m是访问的多个字符串结束的位置，访问到的字符串不包含该位置上的字符，k为步长，限定访问方向和访问频率，当k为正数时，正向访问，当k为负数时，反向访问，访问频率表示从第一个访问位置开始每几个字符中取1个字符。

语法：a[n: m :k]

a = "Hello World!"
print("a=",a[0:8:2])
print("a=",a[7:2:-2])
print("a=",a[2:5])
print("a=",a[:7:2])
print("a=",a[::2])

D:\pythonLED\python.exe E:/pythonProject/1.py
a= HloW
a= o l
a= llo
a= HloW
a= HloWrd

1.1.2、转义字符

作为程序设计语言，python和c类似，也有转义字符；\与后面一个字符组成一个转义字符，产生新的含义，如：当需要输出引号或反斜杠时，就可以使用转义字符。

转义字符	功能
\n	表示换行
\\	表示反斜杠
\’	表示单引号
\"	表示双引号
\t	表示水平制表符（TAB）

print('\'python\'')

D:\pythonLED\python.exe E:/pythonProject/1.py
'python'

print('\\python\\')

D:\pythonLED\python.exe E:/pythonProject/1.py
\python\

print('pyt\nhon')

D:\pythonLED\python.exe E:/pythonProject/1.py
pyt
hon

print("\"python\"")

D:\pythonLED\python.exe E:/pythonProject/1.py
"python"

print('pyt\thon')

D:\pythonLED\python.exe E:/pythonProject/1.py
pyt	hon

1.1.3、字符串运算符

运算符	功能
x + y	返回字符串x的长度
n * x或x * n	复制n此子串x
x in s	如果x是s的子串，返回True，否则返回False
x not in s	如果x不是s的子串，返回True，否则返回False
str[ i ]	索引，返回第i个字符
str[ N:M ]	切片，返回第N个字符到第M个字符（子串），不包含第M个字符

1.1.4、字符串处理函数

函数	功能
len(x)	返回字符串x的长度
str(x)	把任意类型数据x转换为字符串
chr(x)	返回Unicode代码x对应的单字符
ord(x)	返回单字符x对应的Unicode代码
hex(x)	返回整数x对应的十六进制数的小写形式字符串
oct(x)	返回整数x对应的八进制数的小写形式字符串

1.1.5、字符串处理方法

方法	功能
str.lower()	字符串中字母小写
str.upper()	字符串中字母大写
str.islower()	字符串中所有字母都是小写，返回True
str.isnumeric()	字符串中所有字符都是数字，返回True
str.isspace()	字符串中所有字符都是空格，返回True
str.split(sep=None)	按指定字符分割字符串为数组，默认分隔符为空格
str.replace(old,new,[count])	字符串替换
str.strip([char])	去掉两边空格或去掉指定字符
str.count(sub[,start[,end]])	返回str[start:end]中sub子串出现的次数

1.2、列表

列表（list）是最常用的python序列类型，对于字符串起连接作用的“+”、起复制左右的“*”和用于成员判断的“in” “not in”对于元组有同样的功能，列表的数据项不需要具有相同的类型，列表中的元素按先后顺序排列，元素之间可以没有任何关系，列表类似其他语言的数组，但功能比数组强大。

1.2.1、创建列表

创建列表可以用以下三种方式
空列表

list1 = []
print(list1,"=",type(list1))

D:\pythonLED\python.exe E:/pythonProject/1.py
[] = <class 'list'>

列表赋值

list1 = ['list','123','abc']
print(list1,"=",type(list1))

D:\pythonLED\python.exe E:/pythonProject/1.py
['list', '123', 'abc'] = <class 'list'>

其他数据类型转换为列表

list1 = list('list')
print(list1,"=",type(list1))

D:\pythonLED\python.exe E:/pythonProject/1.py
['l', 'i', 's', 't'] = <class 'list'>

1.2.2、访问列表

访问列表与访问字符串类似，可以对列表中的单个元素进行访问，也可以访问连续的多个元素。

单个访问

list1 = ['list','123','abc']
print('list=',list1[0])
print('list=',list1[-1])

D:\pythonLED\python.exe E:/pythonProject/1.py
list= list
list= abc

区间访问

list1 = ['list','123','abc','456','def','789']
print('list=',list1[0:3])
print('list=',list1[1:2:4])

D:\pythonLED\python.exe E:/pythonProject/1.py
list= ['list', '123', 'abc']
list= ['123']

注：包头不包尾

整体访问

list1 = ['list','123','abc','456','def','789']
print('list=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list= ['list', '123', 'abc', '456', 'def', '789']

遍历访问

list1 = ['list','123','abc','456','def','789']
for i in list1:
    print(i,end=(','))

D:\pythonLED\python.exe E:/pythonProject/1.py
list,123,abc,456,def,789,

list1 = ['list','123','abc','456','def','789']
for i in range(len(list1)):
    print(i,end=(','))
    
D:\pythonLED\python.exe E:/pythonProject/1.py
0,1,2,3,4,5,

注：方法二中返回的其实是步长序号。

1.2.3、操作列表

对列表的操作进行修改、增加、插入、查找、删除、清空列表。

修改：用新值替换序号（索引）对应元素的内容。

list1 = ['list','123','abc','456','def','789']
list1[0] = 'str'
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['str', '123', 'abc', '456', 'def', '789']

增加：在列表末尾增加元素。

list1 = ['list','123','abc','456','def','789']
list1.append('str')
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['list', '123', 'abc', '456', 'def', '789', 'str']

插入：在指定位置插入指定元素。

list1 = ['list','123','abc','456','def','789']
list1.insert(2,'str')
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['list', '123', 'str', 'abc', '456', 'def', '789']

查找：在列表中查询指定元素，也称为成员判断。

list1 = ['list','123','abc','456','def','789']
print('abc' in list1)
print('abc' not in list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
True
False

删除：删除列表元素。

list1 = ['list','123','abc','456','def','789']
list1.pop(3)
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['list', '123', 'abc', 'def', '789']

list1 = ['list','123','abc','456','def','789']
list1.remove('123')
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['list', 'abc', '456', 'def', '789']

list1 = ['list','123','abc','456','def','789']
del list1[3]
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= ['list', '123', 'abc', 'def', '789']

清空列表：将列表中所有元素删除。

list1 = ['list','123','abc','456','def','789']
list1.clear()
print('list1=',list1)

D:\pythonLED\python.exe E:/pythonProject/1.py
list1= []

1.2.4、列表常用函数及方法

函数及方法	功能
len(list)	返回列表元素个数
max(list)	返回列表元素中的最大值
min(list)	返回列表元素中的最小值
list.count(obj)	统计某个元素在列表中出现额次数
list1.extend(list2)	扩展列表，在一个列表的末尾追加一个新的列表，参数为一个列表
list.index(obj)	从列表中找出某一个值的第一个匹配项的位置
list.reversr()	返回排列列表中的元素，该方法没有返回值
list.sort()	对列表进行排序，该方法没有返回值
list.copy()	复制列表

随机产生100个[70,100]中的数据，每10个一行输出，找出最大值及其第一此出现的位置，并统计其出现的次数。

import random
list=[]
for i in range(0,100):  # 循环100次
    x = random.randint(70,100)  # 生成一个70到100之间的随机整数
    list.append(x)  # 将随机整数添加到列表中
    print(list[i],end="")  # 打印当前随机数，不换行
    if (i + 1) % 10 == 0:  # 每10个数字换一行
        print()
maxnum = max(list)  # 找到列表中的最大值
print(maxnum)  # 打印最大值
print(list.index(maxnum))  # 打印最大值在列表中的索引
print(list.count(maxnum))  # 打印最大值在列表中出现的次数

D:\pythonLED\python.exe E:/pythonProject/1.py
82857682788772857873
94778496777879869284
75787876938288728399
95899499789396998884
93887985869470777984
93759976927472968784
91709473768580947298
83877093978599717171
90978085958672798577
92768999819787888673
99
29
6

Process finished with exit code 0

随机产生26个不重复的小写英文字母，按从大到小排列。

import random
s = []  # 创建一个空列表用于存储随机生成的字母
for i in range(1,100):  # 循环100次
    x = random.randint(97,122)  # 生成一个97到122之间的随机整数，对应ASCII码中的小写字母
    if chr(x) not in s:  # 如果生成的字母不在列表中
        s.append(chr(x))  # 将生成的字母添加到列表中
    if len(s) == 26:  # 如果列表中已经有26个不同的字母
        break  # 跳出循环
s.sort(reverse=True)  # 对列表中的字母进行降序排序
print(s)  # 打印排序后的列表


D:\pythonLED\python.exe E:/pythonProject/1.py
['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

1.3、元组

python的元组（tuple）和列表类似，也是序列类型，通过序号访问各个元素，对于字符串起连接作用的“+”、起复制作用的“*”和用于成员判断的“in”、“not in”对于元组有同样的功能。

元组和列表的区别有两类，一类是元组使用小括号( )，列表使用中括号[ ]；二类是元组的元素不能被修改，而列表的元素可以被修改，因此元组没有增加、插入、删除单个元素等方法。

1.3.1、创建元组

用逗号将一组数据彼此隔开并赋值给元组名，即可生成元组。

a = (1,2,3)
b = 4,5,6
c= (7)
d = 8,
print('a=',type(a),'\n','b=',type(b),'\n','c=',type(c),'\n','d=',type(d))

D:\pythonLED\python.exe E:/pythonProject/1.py
a= <class 'tuple'> 
 b= <class 'tuple'> 
 c= <class 'int'> 
 d= <class 'tuple'>

1.3.2、访问元组

虽然元组的元素不能被改变，但是元组也是序列类型，列表对元素的访问方式对元组通用适用，虽然元组用小括号表示边界，但是用序号访问元组的元素时依然用中括号表示。

单个访问

a = 1,2,3,4,5,6)
print(type(a),a[5])

D:\pythonLED\python.exe E:/pythonProject/1.py
<class 'tuple'> 6

区间访问

a = (1,2,3,4,5,6,7,8,9)
print(a[0:6:2])

D:\pythonLED\python.exe E:/pythonProject/1.py
(1, 3, 5)

整体访问

a = (1,2,3,4,5,6,7,8,9)
print(a)

D:\pythonLED\python.exe E:/pythonProject/1.py
(1, 2, 3, 4, 5, 6, 7, 8, 9)

遍历访问

a = (1,2,3,4,5,6,7,8,9)
for i in a:
    print('i=',i,type(i),end=(','))

D:\pythonLED\python.exe E:/pythonProject/1.py
i= 1 <class 'int'>,i= 2 <class 'int'>,i= 3 <class 'int'>,i= 4 <class 'int'>,i= 5 <class 'int'>,i= 6 <class 'int'>,i= 7 <class 'int'>,i= 8 <class 'int'>,i= 9 <class 'int'>,

1.3.3、删除元组

元组和列表不一样，元组中的元素不允许被单独修改、删除或清空，因此只能使用del语句来删除整个元组。

使用del之后，元组不再存在，如果继续访问则会出现NameError: name ‘a’ is not defined异常。

a = ('1',2,3,4,5,6,7,8,'9')
print("删除之前的元组：",a)
del a
print("删除之后的元组：",a)

D:\pythonLED\python.exe E:/pythonProject/1.py
删除之前的元组： ('1', 2, 3, 4, 5, 6, 7, 8, '9')
Traceback (most recent call last):
  File "E:\pythonProject\1.py", line 225, in <module>
    print("删除之后的元组：",a)
                     ^
NameError: name 'a' is not defined

1.3.4、元组的常用函数

函数	功能
len(tuple)	返回元组元素个数
max(tuple)	返回列表元素中的最大值
min(tuple)	返回列表元素中的最小值
tuple(list)	将列表转换为元组

二、集合

集合（set）是组合数据类型的一种，集合类型数据与数学中的集合概念相同，为包含0个或多个元素的无序组合；集合与序列最大的区别就在于集合中的元素是无序的，彼此之间没有位置关系，并且集合中不存在相同的元素；因此集合没有序号和位置的概念，不能切片。

a = {"set",(18,"男"),56,1.45}
print("a=",a,type(a))

D:\pythonLED\python.exe E:/pythonProject/1.py
a= {56, 1.45, (18, '男'), 'set'} <class 'set'>

a = set('Hello world')
print("a=",a,type(a))

D:\pythonLED\python.exe E:/pythonProject/1.py
a= {'l', 'e', 'H', 'w', ' ', 'd', 'r', 'o'} <class 'set'>

集合的常用函数及方法

函数及方法	功能
S.add(x)	如果元素x不再集合s中，则将x添加到S
S.clear()	移除集合S中的所有元素
S.copy()	返回集合S的一个副本
S.pop()	随机返回集合S中的一个元素，如果S为空，则产生“KeyError”异常
S.discard()	如果元素x在集合S中，移除该元素；如果元素x不再集合S中，不报错
S.remove(x)	如果元素x在集合S中，移除该元素；如果元素x不在集合S中，则产生“KeyError”异常
S.isdisjoint(T)	如果集合S和集合T没有相同元素，则返回True
Len(S)	返回集合S的元素个数

三、字典

在Python中，字典用放在花括号{}中的一系列键—值对表示。每个键—值对通过冒号:连接，不同键值对之间用逗号,分隔。字典中的键是唯一的，而值不需要唯一。字典的值可以取任何数据类型，但键必须是不可变的，如字符串、数字或元组。

在实际应用中，字典常用于存储配置信息、进行快速查找和映射等场景。例如，可以将用户信息作为值，以用户名作为键来创建一个用户字典；或者用字典来存储程序配置项，通过配置名快速获取配置值。

• 字典的创建：可以使用大括号{}直接创建，例如：d = {‘key1’: ‘value1’, ‘key2’: ‘value2’}。也可以使用set()函数从其他数据类型转换为集合，例如：s = set([1, 2, 3])。
• 字典的访问：把相应的键放入熟悉的方括弧，例如：tinydict[‘Name’]返回对应的值。如果用字典里没有的键访问数据，会输出错误。
• 字典的修改：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。
• 字典元素的删除：能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令。
• 字典键的特性：字典值可以没有限制地取任何python对象，但键不行。两个重要的点需要记住：1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。
• 字典内置函数&方法：Python字典包含了以下内置函数：cmp(dict1, dict2)比较两个字典元素。

3.1、创建字典

字典的创建有两种方式，可以直接创建空字典，也可以将键值对赋值给字典变量。

使用大括号创建字典

d = { }
print('d=',type(d),d)

D:\pythonLED\python.exe E:/pythonProject/1.py
d= <class 'dict'> {}

将键值对赋值给字典变量

d = {'name':'小明','age':18,'sex':'男'}
print('d=',type(d),d)

D:\pythonLED\python.exe E:/pythonProject/1.py
d= <class 'dict'> {'name': '小明', 'age': 18, 'sex': '男'}

3.2、访问字典

字典中，通过指定放在中括号中的键访问对应的值，字典的键就相当于列表的序号；其他组合数据类型都是通过数字索引来获得值，字典是通过字符索引来获得值。

d = {'name':'小明','age':18,'sex':'男'}
print('d=',type(d),d['name'])

D:\pythonLED\python.exe E:/pythonProject/1.py
d= <class 'dict'> 小明

遍历字典

d = {'name': '小明', 'age': 18, 'sex': '男'}
for key, value in d.items():
    print(key, value)

D:\pythonLED\python.exe E:/pythonProject/1.py
name 小明
age 18
sex 男

3.3、修改字典元素

字典元素是可以修改的，通过键找到具体元素之后，给出一个新的元素即可。

d = {'name': '小明', 'age': 18, 'sex': '男'}
d['age'] = 20
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
{'name': '小明', 'age': 20, 'sex': '男'}

3.4、添加字典元素

动态地向字典添加元素的时候，只要添加的键在字典中不存在，就会新增这个元素。

d = {'name': '小明', 'age': 18, 'sex': '男'}
d[' ip address'] = '192.168.1.1'
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
{'name': '小明', 'age': 18, 'sex': '男', ' ip address': '192.168.1.1'}

3.5、删除字典元素

del语句

d = {'name': '小明', 'age': 18, 'sex': '男'}
del d['age']
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
{'name': '小明', 'sex': '男'}

d = {'name': '小明', 'age': 18, 'sex': '男'}
del d
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
Traceback (most recent call last):
  File "E:\pythonProject\1.py", line 260, in <module>
    print(d)
          ^
NameError: name 'd' is not defined. Did you mean: 'id'?

pop语句

d = {'name': '小明', 'age': 18, 'sex': '男'}
d.pop('age')
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
{'name': '小明', 'sex': '男'}

clear语句

d = {'name': '小明', 'age': 18, 'sex': '男'}
d.clear()
print(d)

D:\pythonLED\python.exe E:/pythonProject/1.py
{}

3.6、字典的常用函数及方法

函数及方法	功能
len(dict)	返回字典元素个数
type(variable)	返回输入变量的数据类型，如果变量是字典就返回<class’dict’>
dict.fromkeys(seq[,value])	创建一个新字典，以序列seq中的元素作为字典的键，value为字典所有键对应的初始值
key in dict	如果键在字典dict里，则返回True，否则返回False
dict.keys()	以列表返回一个字典的所有键
dict.values()	以列表返回一个字典中的所有值
dict.items()	以列表返回一个字典中的所有键值对
dict.get(key,default=None)	返回指定键的值，如果值不在字典中，则返回default

# 创建一个字典
my_dict = {"name": "小明", "age": 18, "sex": "男"}

# 使用update()函数更新字典中的键值对
my_dict.update({"city": "北京", "job": "学生"})
print("更新后的字典：", my_dict)

# 使用get()函数获取字典中的值
name = my_dict.get("name")
print("获取到的名字：", name)

# 使用pop()函数删除字典中的键值对
age = my_dict.pop("age")
print("删除的年龄：", age)
print("删除后的字典：", my_dict)

D:\pythonLED\python.exe E:/pythonProject/1.py
更新后的字典： {'name': '小明', 'age': 18, 'sex': '男', 'city': '北京', 'job': '学生'}
获取到的名字： 小明
删除的年龄： 18
删除后的字典： {'name': '小明', 'sex': '男', 'city': '北京', 'job': '学生'}