组合数据类型1 列表列表的表达序列类型：内部元素有位置关系，能通过位置序号访问其中元素
列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型
ls = [python, 1989, true, {version: 3.7}]ls
['python', 1989, true, {'version': 3.7}]
另一种产生方式：list(可迭代对象)
可迭代对象包括：字符串、元组、集合、range()等
字符串转列表
list(欢迎订阅本专栏)
['欢', '迎', '订', '阅', '本', '专', '栏']
元组转列表
list((我, 们, 很, 像))
['我', '们', '很', '像']
集合转列表
list({李雷, 韩梅梅, jim, green})
['green', 'jim', '李雷', '韩梅梅']
特殊的range()
for i in [0, 1, 2, 3, 4, 5]:    print(i)
012345

for i in range(6):    print(i)
012345

range(起始数字,中止数字,数字间隔)
如果起始数字缺省，默认为0
必须包含中止数字，但是注意中止的数字取不到
数字间隔缺省，默认为1
for i in range(1, 11, 2):    print(i)
13579
range()转列表
list(range(1, 11, 2))
[1, 3, 5, 7, 9]
列表的性质列表的长度——len(列表)
ls = [1, 2, 3, 4, 5]len(ls)
5
列表的索引——与同为序列类型的字符串完全相同
变量名[位置编号]
正向索引从0开始
反向索引从-1开始
cars = [byd, bmw, audi, toyota]


print(cars[0])print(cars[-4])
bydbyd
列表的切片
变量名[开始位置：结束位置：切片间隔]
cars = [byd, bmw, audi, toyota]


正向切片
print(cars[:3])     # 前三个元素，开始位置缺省，默认为0；切片间隔缺省，默认为1
['byd', 'bmw', 'audi']
print(cars[1:4:2])  # 第二个到第四个元素 前后索引差为2
['bmw', 'toyota']
print(cars[:])      # 获取整个列表，结束位置缺省，默认取值到最后
['byd', 'bmw', 'audi', 'toyota']
print(cars[-4:-2])  # 获取前两个元素
['byd', 'bmw']
反向切片
cars = [byd, bmw, audi, toyota]


print(cars[:-4:-1])      # 开始位置缺省，默认为-1print(cars[::-1])        # 获得反向列表
['toyota', 'audi', 'bmw']['toyota', 'audi', 'bmw', 'byd']
列表的操作符用**list1+lis2**的形式实现列表的拼接
a = [1, 2]b = [3, 4]a+b            # 该用法用的不多
[1, 2, 3, 4]
用n*list或list*n实现列表的成倍复制
初始化列表的一种方式
[0]*10
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
列表的操作方法1、增加元素
在末尾增加元素——列表.append(待增元素)
languages = [python, c++, r]
languages.append(java)languages
['python', 'c++', 'r', 'java']


在任意位置插入元素——列表.insert(位置编号，待增元素)
在位置编号相应元素前插入待增元素
languages.insert(1, c)languages
['python', 'c', 'c++', 'r', 'java']
在末尾整体并入另一列表——列表1.extend(列表2)
append 将列表2整体作为一个元素添加到列表1中
languages.append([ruby, php])languages
['python', 'c', 'c++', 'r', 'java', ['ruby', 'php']]
extend 将待列表2内的元素逐个添加到列表1中，当然也可以采用加法实现。
languages = ['python', 'c', 'c++', 'r', 'java']languages.extend([ruby, php])languages
['python', 'c', 'c++', 'r', 'java', 'ruby', 'php']
2、删除元素
删除列表i位置的元素 列表.pop(位置)
languages = ['python', 'c', 'c++', 'r', 'java']languages.pop(1)languages
['python', 'c++', 'r', 'java']


不写位置信息，默认删除最后一个元素
languages.pop()languages
['python', 'c++', 'r']
删除列表中的第一次出现的待删元素列表.remove(待删元素)
languages = ['python', 'c', 'r', 'c', 'java']languages.remove(c)    languages
['python', 'r', 'c', 'java']
languages = ['python', 'c', 'r', 'c', 'java']while c in languages:    languages.remove(c)    languages
['python', 'r', 'java']
3、查找元素
列表中第一次出现待查元素的位置列表.index(待查元素)
languages = ['python', 'c', 'r','java']idx = languages.index(r) idx
2
4、修改元素
通过先索引后赋值的方式，对元素进行修改列表名[位置]=新值
languages = ['python', 'c', 'r','java']languages[1] = c++languages
['python', 'c++', 'r', 'java']


5、列表的复制
错误的方式：这种方式仅是相当于给列表起了一个别名
languages = ['python', 'c', 'r','java']languages_2 = languagesprint(languages_2)
['python', 'c', 'r', 'java']
languages.pop()print(languages)print(languages_2)
['python', 'c', 'r']['python', 'c', 'r']
正确的方式——浅拷贝
当内容中也有列表这种可变的情况时，这时浅拷贝可能出问题，应该采用深拷贝。
方法1：列表.copy()
languages = ['python', 'c', 'r','java']languages_2 = languages.copy()languages.pop()print(languages)print(languages_2)
['python', 'c', 'r']['python', 'c', 'r', 'java']

方法2：列表 [:]
相当于对整个列表的切片
languages = ['python', 'c', 'r','java']languages_3 = languages[:]languages.pop()print(languages)print(languages_3)
['python', 'c', 'r']['python', 'c', 'r', 'java']

6、列表的排序
使用列表.sort()对列表进行永久排序
直接在列表上进行操作，无返回值
默认是递增的排序
ls = [2, 5, 2, 8, 19, 3, 7]ls.sort()ls
[2, 2, 3, 5, 7, 8, 19]
递减排列
ls.sort(reverse = true)ls
[19, 8, 7, 5, 3, 2, 2]

使用sorted(列表)对列表进行临时排序
原列表保持不变，返回排序后的列表
ls = [2, 5, 2, 8, 19, 3, 7]ls_2 = sorted(ls)print(ls)print(ls_2)
[2, 5, 2, 8, 19, 3, 7][19, 8, 7, 5, 3, 2, 2]
sorted(ls, reverse = true)
[19, 8, 7, 5, 3, 2, 2]

7、列表的翻转
使用列表.reverse()对列表进行永久翻转
直接在列表上进行操作，无返回值
ls = [1, 2, 3, 4, 5]print(ls[::-1])ls
[5, 4, 3, 2, 1][1, 2, 3, 4, 5]
ls.reverse()ls
[5, 4, 3, 2, 1]
8、使用for循环对列表进行遍历
ls = [1, 2, 3, 4, 5]for i in ls:    print(i)
12345
2 元组 元组的表达元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型
通俗的讲，可以将元组视作“不可变的列表”
names = (peter, pual, mary)
元组的操作不支持元素增加、元素删除、元素修改操作
其他操作与列表的操作完全一致
元组的常见用处打包与解包
例1 返回值是打包成元组的形式
def f1(x):              # 返回x的平方和立方    return x**2, x**3   # 实现打包返回print(f1(3))print(type(f1(3)))      # 元组类型
(9, 27)<class 'tuple'>
a, b = f1(3)            # 实现解包赋值 print(a)print(b)
927
例2
采用zip函数进行打包
numbers = [201901, 201902, 201903]name = [小明, 小红, 小强]list(zip(numbers,name))
[(201901, '小明'), (201902, '小红'), (201903, '小强')]
for number,name in zip(numbers,name):   # 每次取到一个元组，立刻进行解包赋值    print(number, name)
201901 小明201902 小红201903 小强
3 字典字典的表达映射类型： 通过“键”-“值”的映射实现数据存储和查找
常规的字典是无序的，仅可以通过键来对数据进行访问
students = {201901: '小明', 201902: '小红', 201903: '小强'}students
字典键的要求
1、字典的键不能重复
如果重复，前面的键就被覆盖了
students = {201901: '小明', 201901: '小红', 201903: '小强'}students
{201901: '小红', 201903: '小强'}
2、字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了
不可变类型：数字、字符串、元组。 一旦确定，它自己就是它自己，变了就不是它了。
可变类型：列表、字典、集合。 一旦确定，还可以随意增删改。因此这三个类型不能作为字典的键。
d1 = {1: 3}d2 = {s: 3}d3 = {(1,2,3): 3}
上面没有报错，说明是合法的。
d = {[1, 2]: 3}
---------------------------------------------------------------------------typeerror                                 traceback (most recent call last)<ipython-input-68-bf7f06622b3f> in <module>----> 1 d = {[1, 2]: 3}typeerror: unhashable type: 'list'
d = {{1:2}: 3}
---------------------------------------------------------------------------typeerror                                 traceback (most recent call last)<ipython-input-69-188e5512b5fe> in <module>----> 1 d = {{1:2}: 3}typeerror: unhashable type: 'dict'
d = {{1, 2}: 3}
---------------------------------------------------------------------------typeerror                                 traceback (most recent call last)<ipython-input-70-c2dfafc1018a> in <module>----> 1 d = {{1, 2}: 3}typeerror: unhashable type: 'set'
字典的性质字典的长度——键值对的个数
students = {201901: '小明', 201902: '小红', 201903: '小强'}len(students)
3

字典的索引
通过字典[键]的形式来获取对应的值
students = {201901: '小明', 201902: '小红', 201903: '小强'}students[201902]
'小红'
字典的操作方法1、增加键值对
变量名[新键] = 新值
students = {201901: '小明', 201902: '小红', 201903: '小强'}students[201904] = 小雪students
{201901: '小明', 201902: '小红', 201903: '小强', 201904: '小雪'}
2、删除键值对
通过del 变量名[待删除键]
students = {201901: '小明', 201902: '小红', 201903: '小强'}del students[201903]students
{201901: '小明', 201902: '小红'}
通过变量名.pop(待删除键)
students = {201901: '小明', 201902: '小红', 201903: '小强'}value = students.pop(201903)   # 删除键值对，同时获得删除键值对的值print(value)print(students)
小强{201901: '小明', 201902: '小红'}
变量名.popitem()随机删除一个键值对，并以元组返回删除键值对
students = {201901: '小明', 201902: '小红', 201903: '小强'}key, value = students.popitem()print(key, value)print(students)
201903 小强{201901: '小明', 201902: '小红'}
3、修改值
通过先索引后赋值的方式对相应的值进行修改
students = {201901: '小明', 201902: '小红', 201903: '小强'}students[201902] = 小雪students
{201901: '小明', 201902: '小雪', 201903: '小强'}
4、d.get( )方法
d.get(key,default)从字典d中获取键key对应的值，如果没有这个键，则返回default
小例子：统计牛奶奶找刘奶奶买牛奶中字符的出现频率
s = 牛奶奶找刘奶奶买牛奶d = {}print(d)for i in s:    d[i] = d.get(i, 0)+1 # 如果该字符第一次出现，则返回default 0 ，然后+1统计。如果之前就有i这个键，则返回该 key i 所对应的值。    print(d)# print(d)
{}{'牛': 1}{'牛': 1, '奶': 1}{'牛': 1, '奶': 2}{'牛': 1, '奶': 2, '找': 1}{'牛': 1, '奶': 2, '找': 1, '刘': 1}{'牛': 1, '奶': 3, '找': 1, '刘': 1}{'牛': 1, '奶': 4, '找': 1, '刘': 1}{'牛': 1, '奶': 4, '找': 1, '刘': 1, '买': 1}{'牛': 2, '奶': 4, '找': 1, '刘': 1, '买': 1}{'牛': 2, '奶': 5, '找': 1, '刘': 1, '买': 1}
5、d.keys( )d.values( )方法
把所有的key，value 单独拿出来。
students = {201901: '小明', 201902: '小红', 201903: '小强'}print(list(students.keys()))print(list(students.values()))
[201901, 201902, 201903]['小明', '小红', '小强']
6、d.items( )方法及字典的遍历
print(list(students.items()))for k, v in students.items():#进行解包    print(k, v)
[(201901, '小明'), (201902, '小红'), (201903, '小强')]201901 小明201902 小红201903 小强
4 集合集合的表达一系列互不相等元素的无序集合（互斥）
元素必须是不可变类型：数字，字符串或元组，可视作字典的键
可以看做是没有值，或者值为none的字典
students = {小明, 小红, 小强, 小明}   #可用于去重students
{'小强', '小明', '小红'}
集合的运算小例子 通过集合进行交集并集的运算
chinese_a = {刘德华, 张学友, 张曼玉, 钟楚红, 古天乐, 林青霞}chinese_a
{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '钟楚红'}
math_a = {林青霞, 郭富城, 王祖贤, 刘德华, 张曼玉, 黎明}math_a
{'刘德华', '张曼玉', '林青霞', '王祖贤', '郭富城', '黎明'}
语文和数学两门均为a的学员
s & t 返回一个新集合，包括同时在集合s和t中的元素
chinese_a & math_a
{'刘德华', '张曼玉', '林青霞'}
语文或数学至少一门为a的学员
s | t 返回一个新集合，包括集合s和t中的所有元素
chinese_a | math_a
{'刘德华', '古天乐', '张学友', '张曼玉', '林青霞', '王祖贤', '郭富城', '钟楚红', '黎明'}
语文数学只有一门为a的学员
s ^ t 返回一个新集合，包括集合s和t中的非共同元素
chinese_a ^ math_a
{'古天乐', '张学友', '王祖贤', '郭富城', '钟楚红', '黎明'}
语文为a，数学不为a的学员
s - t 返回一个新集合，包括在集合s但不在集合t中的元素
chinese_a - math_a
{'古天乐', '张学友', '钟楚红'}
数学为a，语文不为a的学员
math_a - chinese_a
{'王祖贤', '郭富城', '黎明'}
集合的操作方法增加元素——s.add(x)
stars = {刘德华, 张学友, 张曼玉}stars.add(王祖贤)stars
{'刘德华', '张学友', '张曼玉', '王祖贤'}
移除元素——s.remove(x)
stars.remove(王祖贤)stars
{'刘德华', '张学友', '张曼玉'}
集合的长度——len(s)
len(stars)
3

集合的遍历——借助for循环
for star in stars:    print(star)
张学友张曼玉刘德华
以上就是python的组合数据类型怎么用的详细内容。