元组和列表

元组和列表是序列类型的扩展类型，所以我们先了解一下序列类型的基本用法。

一、序列类型

1、序列

• 序列是具有先后关系的一组元素
• 序列是一堆元素向量，元素类型可以不同
• 序列间由序号引导，通过下标访问序列的特定元素

2、序列类型的6个通用操作符

3、序列类型的6个通用函数

函数	描述
len(s)	返回序列s的长度
min(s)	返回序列s中的最小元素
max(s)	返回序列s中的最大元素
s.index(x)或s.index(x,i,j)	返回序列s中从i到j位置中第一次出现元素x的位置
s.count(x)	返回序列中元素x出现的次数

4、可变与不可变数据类型

判断可变与不可变类型，只需在改变值的同时，使用id()函数查看变量id值是否变化就可以知道这种数据类型是可变还是不可变

• 不可变数据类型：数值型、字符串、布尔值、元组
• 可变数据类型：列表，字典，集合

二、元组

1、元组

• 元组是序列类型中比较特殊的类型
• 创建后就不能修改
• 元组在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历等情况下十分有用
• 在python中元组是用逗号来定义的，圆括号可要可不要

>>>s = '1','python','2'
>>>s
('1', 'pyhton', '2')

2、元组的用法

• 元组的索引

>>>s = '1','python','2'
>>>s[1]
'python'
>>>s = '1','2','python',('pink','red','blue')
>>>s[3][1]
'red'

3、元组的应用场景

数据保护：如果不希望数据被程序所改变，转换成元组类型

>>>ls = ['pig','cat']
>>>lt = tuple(ls)
>>>lt
('pig','cat')

三、列表

1、列表

• 列表是一种序列类型，创建后可以随意修改
• 使用方括号[]或list()创建，元素间用逗号分隔
• 列表中各元素类型可以不同，无长度限制
• 方括号[]真正创建一个列表，赋值仅传递引用

2、列表类型操作函数和方法

函数或方法	描述
ls[i] = x	替换列表ls第i个元素为x
ls[i:j:k] = lt	用列表lt替换ls切片后所对应元素子列表
del ls[i]	删除列表ls中的第i个元素
del ls[i:j:k]	删除列表中第i到第j以k为步长的元素
ls += lt	更新列表ls，将列表lt元素增加到列表ls中
ls *= n	更新列表ls，其元素重复n次

>>>ls = ['black','pink','red','1234']
>>>ls[3] = '666'
['black','pink','red','666']
>>>ls[1:2] = [1,2,3,4]
['black',1,2,3,4,'red','666']
>>>del ls[0]
[1,2,3,4,'red','666']
>>>del ls[1:3]
[1,4,'red','666']
>>>ls *= 2
[1,4,'red','666',1,4,'red','666']

函数或方法	描述
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除列表ls中所以元素
ls.copy()	生成一个新列表,赋值ls中的所有元素
ls.insert(i,x)	在列表ls中第i位置插入元素x
ls.pop(i)	将列表ls中第i位置元素取出并删除元素
ls.remove(x)	将列表ls中出现的第一个元素x删除
ls.reverse()	将列表ls中的元素反转
ls.sort()	对列表元素进行排序

注意：除ls.copy()以外，列表方法均不会改变列表的id，也不会新建列表，ls.copy()除外

>>>ls = ['apple','pear','banana']
>>>ls.append('grasp')
['apple','pear','banana','grasp']
>>>ls.pop(2)
'banana'
>>>ls.insert(2,'bear')
['apple','pear','bear','grasp']
>>>ls.reverse()
['grasp','bear','pear','apple']

3、列表推导式

[ 新元素表达式 for 临时变量 in 可迭代对象 if 条件表达式]

>>>multiples = [i for i in range(30) if i % 3 == 0] 
>>>print(multiples)
[0,3,6,9,12,15,18,21,24,27,30]

四、集合

1、集合

• 集合类型与数学中的集合概念一致
• 集合元素之间无序，每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型
• 集合用大括号{}表示，元素间用逗号分隔
• 建立集合类型用{}或set()
• 建立空集合类型，必须使用set()

>>>s = {1,3,5,3,1}
>>>s
{1,3,5}
>>>s = set('python')
{'p','y','t','h','o',n'}

2、集合操作符

• 6个操作符

操作符	描述
s | t	返回一个新集合,包括在集合s和t中的所有元素
s - t	返回一个新集合,包括在集合s但不在t中的元素
s & t	返回一个新集合,包括同时在集合s和t中的元素
s ^ t	返回一个新集合,包括集合s和t中的非相同元素
s <= t或s < t	返回True/False,判断s和t的子集关系
s >= t或s > t	返回True/False,判断s和t的包含关系

• 4个增强操作符

操作符	描述
s |= t	更新集合s,包括在集合s和t中的所有元素
s -= t	更新集合s,包括集合s但不在集合t中的元素
s &= t	更新集合s,包括同时在集合s和t中的元素
s ^= t	更新集合s,包括在集合s和t中的非相同元素

3、集合的比较运算

运算符	描述
s1 == s2	s1和s2元素相同
s1 != s2	s1和s2元素不相同
s1 < s2	s1是s2的纯子集
s1 <= s2	s1是s2的子集
s1 > s2	s1是s2的纯超集
s1 >= s2	s1是s2的超集

>>>s1 = {1,2,3}
>>>s2 = {2,3,4}
>>>s3 = {1,2}
>>>s4 = {1,2,3,4,5}
>>>s1 == s2
True
>>>s2 < s4
True
>>>s1 < s3
False

4、集合处理方法

方法	描述
s.copy()	返回集合s的一个拷贝
len(s)	返回集合元素的个数
x in s	判断s中元素x，x在集合s中，返回True，否则返回False
x not in s	判断s中元素x，x不在集合s中，返回False，否则返回True
set(x)	将其他类型的变量x转变为集合类型
s.add(x)	如果元素x不在集合s中,将x加入s
s.clear()	清除集合中所有元素
s.pop()	随机返回集合中的一个元素,如果s为空，产生KeyError异常
s.discard(x)	如果x在集合s中,移除改元素,如果x不在,不报错
s.remove(x)	如果x在集合s中,移除改元素，如果x不在,产生KeyError异常
s.iddisjoint(t)	如果集合s和t没有相同元素,则返回True

>>>s = {'e','r',1,2}
>>>1 in s
True
>>>len(s)
4

5、集合类型应用场景

• 数据去重：集合类型所有元素无重复

>>>s = ['e','r','e','r',1,2]
>>>t = set(s)
>{'e','r'1,2}

五、字典

1、映射

在字典之前先理解映射

• 映射是一种键(索引)和值(数据)的对应

  城市：武汉
  地址：中关村
  这里‘城市’和‘地址’就是键，‘武汉’和‘中关村’就只值

2、字典

• 字典类型是“映射”的体现
• 键值对：键是数据索引的扩展
• 字典是键值对的集合,键值对之间无序
• 在字典中键不能重复,根据键能查询到值
• 字典的值只能使用不可变类型,但字典的值可以使用可变或不可变类型
• 创建一个空字典可以能用大括号直接创建，也可以使用dict()创建
• 采用大括号{}和dict()创建，键值对用冒号：表示
  {<键1>:<值1>，<键2>:<值2>…<键n>:<值n>}

>>>s = {'中国':‘北京’,'美国':'华盛顿','法国':'巴黎'}
>>>{'中国':‘北京’,'法国':'巴黎','美国':'华盛顿'}

注意：字典打印出来的顺序与创建之初的顺序不同,这不是错误,字典是集合类型的延续,各个元素并没有顺序之分

3、字典的用法

• 在字典变量中,通过键获得值(最主要的用法)
  <值> = <字典变量>[<键>]
  <字典变量>[<键>] = <值>
  ([ ]用来向字典变量中索引或增加元素)

4、字典类型操作函数及方法

>>>s = {'A':'a','B':'b','C':'c'}
>>>s.keys()
dict_keys(['A','B','C'])
>>>s.item()
dict_item([('A':'a'),('B':'b'),('C':'c')])
>>>s.get('A','D')
'A'
>>>s.get('F','h')
'h'