5.1 认识组合数据类型

• Python中常用的序列类型有字符串、列表和元组。

• Python中的序列支持双向索引：正向递增索引和反向递减索引正向递增索引从左向右依次递增，第一个元素的索引为0，第二个元素的索引为1，以此类推；反向递减索引从右向左依次递减，从右数第一个元素的索引为-1，第二个元素的索引为-2，以此类推。

• Python集合具备确定性、互异性和无序性三个特性。Python要求放入集合中的元素必须是不可变类型，Python中的整型、浮点型、字符串类型和元组属于不可变类型，列表、字典及集合本身都属于可变的数据类型。

        确定性：给定一个集合，那么任何一个元素是否在集合中就确定了。

        互异性：集合中的元素互不相同。

        无序性：集合中的元素没有顺序，顺序不同但元素相同的集合可视 同一集合。

• 映射类型以键值对的形式存储元素，键值对中的键与值之间存在映射关系。字典（dict）是Python唯一的内置映射类型，字典的键必须遵守以下两个原则：

1. 每个键只能对应一个值，不允许同一个键在字典中重复出现。
2. 字典中的键是不可变类型。

5.2列表

存放多个值，可以根据索引存取值。

在[ ]内用逗号分隔开多个任意类型的值。

5.2.1创建列表

既可以直接使用中括号“[]”创建，也可以使用内置的list()函数快速创建。

格式：

list_one = []     # 使用[]创建空列表   

li_two = list()   # 使用list()创建空列表

迭代

迭代（interaction）就是一次次重复的过程，不断地将上一次的输出结果作为下一次的输入或初始值。

'''迭代'''
'''遍历有下标的list的两种用法'''
#第一种方法
L=['steven','kate','jack']
for i in range(len(L)):     #遍历下标
    print('Hello',L[i])     #打印下标对应的list值

#第二种方法
L=['steven','kate','jack']
for i in L:             #遍历元素
    print('Hello',i)    #打印元素


'''遍历无下标的dict'''
#默认情况下，dict迭代的是key
d={'a':1,'b':2,'c':3}
for key in d:    #不需要使用下标
    print(key)

#如果要迭代value，可以用for value in d.values()
d={'a':1,'b':2,'c':3}
for value in d.values():    #迭代dict的value
    print(value)

#如果要同时迭代key和value，可以用for key,value in d.items()
d={'a':1,'b':2,'c':3}
for key,value in d.items():
    print(key,value)

可迭代对象

在Python中，支持通过for…in…语句迭代获取数据的对象就是可迭代对象。

可迭代的类型有字符串、列表、集合、字典、文件。

使用isinstance()函数可以判断目标是否为可迭代对象，返回True表示为可迭代对象。

'''可迭代对象'''
#示例1
from collections.abc import Iterable    #collections模块的Iterable对象
print(isinstance('abcde', Iterable))    #判断字符产是否可迭代
#示例2
from collections.abc import Iterable    #collections模块的Iterable对象
ls = [3,4,5]
print(isinstance(ls, Iterable))     #判断列表是否可迭代

5.2.2访问列表元素

列表中的元素可以通过索引或切片这两种方式进行访问，也可以在循环中依次访问。

#示例
L=['python',1,1.2,[5,'高数']]

1、按索引取值

print(L)
print(L[0])
print(L[-1])    #反向取值
print(L[3])     #正向取值

2、按切片取值

print(L[0:3])
print(L[0:3:1])
print(L[0:3:2])
print(L[0:3:3])

3、按循环取值

for i in L:
    print(i)

5.2.3添加列表元素

向列表中添加元素是非常常见的一种列表操作，Python提供了append()、extend()和insert()这几个方法。

#示例
L=['python',1,1.2,[5,'高数']]

​​​​​​​1、append()在往列表末尾加一个元素

L.append('英语')
print(L)

2、extend()在列表末尾添加另一个序列的所有元素

在括号里放列表[]也是末尾追加

L.extend(['物理','化学'])
print(L)

3、insert()往指定索引位置前插入一个元素

L.insert(0,'应用')
print(L)

5.2.4元素排序

列表的排序是将元素按照某种规定进行排列。列表中常用的排序方法有sort()、reverse()、sorted()。

#示例
list=[8,5,3,7,2]

1、sort()有序的元素会覆盖原来的列表元素，不产生新列表

list.sort()
print(list)

2、reverse()逆置列表，即把原列表中的元素从右至左依次排列存放

list.reverse()
print(list)

3、sorted() 产生排序后的新列表，排序操作不会对原列表产生影响

list_new=sorted(list)
print(list_new)
print(list)

5.2.5删除列表

删除列表元素的常用方式有del语句、remove()方法、pop()方法和clear()方法。

#示例
R=[6,'毛概',[9,'思政'],'shell']

1、del语句, 删除列表中指定位置的元素

del R[0]
print(R)

2、remove()方法，移除列表中匹配到的第一个元素

R.remove(6)
R.remove('shell')
print(R)

3、pop()方法，移除列表中的某个元素，若未指定具体元素，则移除  

列表中的最后一个元素

R.pop(2)
print(R)

4、clear()方法,清空列表

R.clear()
print(R)

5.2.6列表推导式

列表推导式是符合Python语法规则的复合表达式，它用于以简洁的方式根据已有的列表构建满足特定需求的列表。

列表推导式的基本格式如下：

  [exp for x in list]  

#前面是运算，后面跟一个迭代

#示例1
list1=[ x * x for x in range(1,10)]
print(list1)
#示例2
list2=[x for x in range(100)]
print(list2)
#示例3
list3=[m+n for m in 'ABC' for n in 'XYZ']
print(list3)

5.3元组

记录多个值，当多个值没有改的需求，用元组更合适。

在()内用逗号分隔开多个任意类型的值。

5.3.1创建元组

除了使用()构建元组外，还可以使用内置函数tuple()构建元组。

格式：

 t1 = ()       # 使用()构建元组    

 t2 = tuple()         # 使用tuple构建元组

5.3.2访问元组元素

1、按索引取值

2、按切片取值

3、遍历元组

'''示例'''
T= ('p','y','t', 'h', 'o','n')

#按索引取值
print(T)
print(T[0])
print(T[1])
print(T[-1])    #反向取值
print(T[3])     #正向取值

#切片取值
print(T[0:4])
print(T[0:4:1])
print(T[0:4:2])
print(T[0:3:3])

#遍历元组
for i in T:
    print(i)

当使用圆括号“()”创建元组时，如果元组中只包含一个元素，那么需要在该元素的后面添加逗号，从而保证Python解释器能够识别其为元组类型。

t1 = ('python')

t2 = ('python',)

print(type(t1))

print(type(t2))

5.4集合

在{}内用逗号分开的多个值。

元素不能重复。

集合里面的元素是无序的。

5.4.1创建集合

Python的集合（set）本身是可变类型，但Python要求放入集合中的元素必须是不可变类型。大括号“{}”或内置函数set()均可构建集合。

格式：

s1 = {1}  # 使用{}构建集合

s2 = set([1,2])  # 使用set构建元组

注：使用{}不能创建空集合（不包含元素的{}创建的是字典变量），空集合只能利用set()函数创建。

set_demo1 = {}
set_demo2 = set()
print(type(set_demo1))
print(type(set_demo2))

 集合是可变的，集合中的元素可以动态增加或删除。Python提供了一些内置方法来操作集合，常见内置方法如下：

集合也可以利用推导式创建，集合推导式的格式与列表推导式相似，区别在于集合推导式外侧为大括号“{}”，具体如下：

 {exp for x in set if cond} 

5.5字典

在{}内用逗号分隔开多个key:value元素，其中value可以是任意的数据类型，而key通常应该是字符串类型。

5.5.1创建字典

除了使用“{}”创建字典还可以使用内置函数dict创建字典。

格式：

d1 = {'A': 123, 12: 'python'}        # 使用{}构建集合

d2 = dict({'A': '123', 'B': '135'})   # 使用dict构建元组

注：字典元素无序，键值必须唯一

5.5.2字典的访问

#示例
info = {'name': 'Jack','age':23,'height':185}

5.5.3元素的添加和修改

元素的添加

字典添加不用重新赋值

列表添加和修改必须是操作存在的索引

info['addr']='长沙'
print(info)

或

info.update(sco=98)
print(info)

元素的修改

info['name']='Mary'
print(info)

或

info.update({'name':'Mary'})
print(info)

5.5.4字典元素的删除

Python支持通过pop()、popitem()和clear()方法删除字典中的元素。

1、pop()：根据指定键值删除字典中的指定元素

2、popitem()：随机删除字典中的元素

3、clear()：清空字典中的元素

'''字典的删除'''
info = {'name': 'Jack','age':23,'height':185,'addr':'长沙'}
print(info)
#pop()
info.pop('addr')
print(info)
#popitem()
info.popitem()
print(info)
#clear()
info.clear()
print(info)

5.5.5字典推导式

字典推导式外侧为大括号“{}”，且内部需包含键和值两部分，具体格式如下：

 {new_key:new_value for key,value in dict.items()} 

• 利用字典推导式可快速交换字典中的键和值，示例如下：

'''字典推导式'''
old_dict = {'name': 'Jack','age':23,'height':185}
new_dict = {value:key for key,value in old_dict.items()}
print(new_dict)