Python系列（4）-list，tuple，dict，set

╰半夏微凉° 2023-07-11 11:11 2阅读 0赞

### 文章目录 ###

*  前言
 *  一、列表（list）
 *   *   *   *  1、列表的创建
             *  2、列表的性质 ---- 增 删 改 查
             *   *  2.1 、增
                 *  2.2 、删
                 *  2.3 、改
                 *  2.4 、查
             *  3、遍历列表
             *  4、列表进阶
             *   *   *  4.1、切片
                     *  4.2、列表生成式
                     *  4.3、双向‘列表’ deque
             *  5、列表小结
 *  二、元组
 *   *   *   *  1、创建元组
             *  2、合并元组
             *  3、查找元素
             *  4、遍历元组
             *  5、强行给元组添加元素（末尾）
 *  三、字典
 *   *   *   *  1、创建字典
             *  2、字典的 增删改查
             *   *   *  2.1 增
                     *  2.2 删
                     *  2.3 改
                     *  2.4 查
             *  3、遍历字典
             *  4、判断 一个 key 是否在字典中
             *  5、字典的更新（可同时添加，修改）
             *  6、获取 keys ,values, keys + values
             *  7、清空字典
 *  四、set
 *   *   *   *  1、过滤重复元素
             *  2、交集，并集，差集
 *  写在最后

# 前言 #

本人自学了廖雪峰老师编写的Python教程，将在学习过程中的一些心得、方法 成体系的写成 本Python系列，所举的部分例子可能会和廖雪峰老师举的例子一致，本Python系列仅供大家学习参考，也相当于本人的学习笔记。

# 一、列表（list） #

列表是一个 **有序** 的集合，可以**随时添加、删除**里面的元素

#### 1、列表的创建 ####

创建一个空列表

>>> a=[]

创建一个带有值的列表

>>> li = [1,2,'hello']
    >>> li
    [1, 2, 'hello']

list()函数创建

>>> li = list(range(10))
    >>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#### 2、列表的性质 ---- 增 删 改 查 ####

##### 2.1 、增 #####

*  append() 方法可在列表的末尾加入元素
 *  insert() 方法可以在列表的任意地方插入元素，第一个参数是要插入的索引位置，第二个参数是要插入的元素

示例：

>>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]			# 原列表
    >>> li.append('end')
    >>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'end']
    >>> li.insert(0,'hand')				# 索引0位置对应的是列表第一个元素
    >>> li
    ['hand', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'end']
    >>> li.insert(3,'index=3')			# 相对应，索引3就是第四个元素
    >>> li
    ['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, 'end']
    >>> li.insert(-1,'倒数第二个元素')	# -1 对应倒数第二个元素
    >>> li
    ['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素', 'end']

##### 2.2 、删 #####

*  pop()方法

>>> li
    ['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素', 'end']
    >>> li.pop()		# 不加参数 默认删掉最后一个
    'end'
    >>> li
    ['hand', 0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
    >>> li.pop(0)		# 传入的参数是索引，0为列表第一个元素
    'hand'
    >>> li
    [0, 1, 'index=3', 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
    >>> li.pop(2)
    'index=3'
    >>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, '倒数第二个元素']
    >>> li.pop(-1)		# 可以看到传入-1和不传入参数是一样的，说明pop()的默认参数是-1
    '倒数第二个元素'
    >>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> li.pop(-2)		# -2 对应的是倒数第二个元素
    8					#需要注意的是insert()的-1对应的是倒数第二个元素
    >>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 9]

##### 2.3 、改 #####

*  改只有一种方法

>>> li
    [0, 1, 2, 3, 4, 5, 6, 7, 9]
    >>> li[0] = 'head'		# 将索引为0 的元素改成 'head'
    >>> li
    ['head', 1, 2, 3, 4, 5, 6, 7, 9]
    >>> li[-1] = 'end'
    >>> li
    ['head', 1, 2, 3, 4, 5, 6, 7, 'end']
    >>> li[3] = 'index=3'
    >>> li
    ['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']

##### 2.4 、查 #####

*  根据索引查

>>> li
    ['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']
    >>> li[3]		# 根据索引查
    'index=3'
    >>> li[-1]
    'end'

*  列表的常用性质功能  
    len() 函数  
    count() 方法  
    index() 方法  
    reverse() 方法  
    clear() 方法

示例：

>>> len(li)			# 查列表内元素的个数
    9
    >>> li.count('end')		# 查询列表内 某个元素 出现的个数
    1
    >>> li.index('end')		# 查询某个元素 在列表中的索引位置
    8
    >>> li.reverse()		# 反转列表
    >>> li
    ['end', 7, 6, 5, 4, 'index=3', 2, 1, 'head']
    >>> li.clear()			# 清空列表
    >>> li
    []

#### 3、遍历列表 ####

>>> li
    ['end', 7, 6, 5, 4, 'index=3', 2, 1, 'head']
    >>> for i in li:
    ...     print(i)
    
    end
    7
    6
    5
    4
    index=3
    2
    1
    head

#### 4、列表进阶 ####

在此讲解列表的高级用法

###### 4.1、切片 ######

*  在python中，代码越少越好，而切片可以一次性取出很多元素，效率大大提高

>>> li
    ['head', 1, 2, 'index=3', 4, 5, 6, 7, 'end']
    >>> li[0:3]				# 取索引0到2 对应的元素
    ['head', 1, 2]
    >>> li[:3]				# 如果是从 索引0开始，这个0可以省略
    ['head', 1, 2]
    >>> li[3:5]				# 取 索引3，4索引的元素
    ['index=3', 4]
    # 从以上 你可以发现，正向切片的最后一个数是取不到的
    >>> li[-3:]				# 取 倒数3个数
    [6, 7, 'end']
    >>> li[-3:-1]			# 取 索引为 倒数第3和倒数第2 的元素
    [6, 7]

###### 4.2、列表生成式 ######

例一：来一个1-9的平方的列表：

>>> list(i * i for i in range(1,10))
    [1, 4, 9, 16, 25, 36, 49, 64, 81]

例二：来一个0-100中奇数的列表：

>>> [i for i in range(101) if i % 2 == 1]
    [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]

*  可以看到，使用列表生成式 可以一行代码就生成出元素很多的列表，效率高了不少
 *  可以用 list() 函数来生成列表
 *  也可以直接用 \[ \] 来生成列表
 *  语法是 \[ 表达式 for i in 迭代器 if 判断语句 \],if判断语句不是必须的  
    就按照例二，来解释一下这个列表生成式，从0到100一次给i赋值，每一次赋值都去if语句判断一下，如果满足if条件，就执行for前面的表达式，并将结果加入到列表的最后。

例二的列表生成式可以等效为以下代码：

li = [ ]
    for i in range(101):
    	if i % 2 == 1:
    		li.append(i)

*  列表生成式的使用 远不止这么简单，以上示例均是为了 让读者学习如何使用 列表生成式

###### 4.3、双向‘列表’ deque ######

*  使用list存储数据时，**按索引访问很快**，但是**插入和删除元素就很慢**了。  
    因为**list是线性存储**，**数据量大**的时候，**插入和删除的效率很低**。
 *  **deque**是为了**高效实现插入和删除操作的双向列表**，适用于队列和栈

from collections import deque
    q = deque(['a','b','c'])                    # 创建一个列表实例
    q.append('x')               # 末尾插入
    q.appendleft('y')           # 左边（首部）插入
    print(q)
    q.pop()                     # 删除末尾元素
    print(q)
    q.popleft()                 # 删除首部元素
    print(q)
    q.remove('b')               # 删除'b'元素
    print(q)
    q.insert(1,'b')             # 在索引位置为1处，插入元素'b'
    print(q)
    q[0] = 'z'					# 把索引为0的元素改成 'z'

*  可见能够实现列表的增删改查

但是严格意义上来说，deque() 函数创建出的示例 不属于列表

>>> isinstance(q,list)
    False
    >>> type(q)
    <class 'collections.deque'>

#### 5、列表小结 ####

*  列表可用来存储数据，按索引搜索速度快，但是插入和删除元素的速度就慢了，这都是因为 list 是线性存储，数据量一旦大了，插入和删除就更耗费时间，这段情况可用 deque 来解决！
 *  列表的普通用法增删改查得会。
 *  高级用法 切片 和 列表生成式 都能够省掉大量的代码，编程时应当优先考虑使用
 *  列表是一个迭代器

# 二、元组 #

*  元组和列表类似，在形式上也仅仅只是把列表的\[ \]改成了 ()
 *  元组最大的特性就是**不可变性**，什么是不可变性呢？就是元组包含的**元素**很固定，**不能**像列表那样对元素**增删改**，相当不灵活，但有的时候又需要这种不灵活！

#### 1、创建元组 ####

>>> t = ()
    >>> t
    ()
    
    >>> t = (1,'a')
    >>> t
    (1, 'a')
    
    # tuple() 传入一个迭代器为参数
    >>> t = tuple([1,2,'a'])
    >>> t
    (1, 2, 'a')
    >>> type(t)
    <class 'tuple'>				# 数据类型是元组
    
    >>> tuple(range(10))
    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

*  这里需要注意一个点，就是在创建元组的时候，如果只有一个元素，需要用英文逗号隔开，否则Python就不知道()是代表运算符中的优先级呢还是元组呢！  
    示例

>>> t = (1,)
    >>> t
    (1,)
    
    >>> t = (1)			
    >>> t				# 不是元组了哟
    1

#### 2、合并元组 ####

>>> t = ('a',)
    >>> t
    ('a',)
    >>> b = (2,'b')
    >>> b
    (2, 'b')
    
    >>> c = t + b		# 合并元组（用这种方法来添加元素也不失为一种方法）
    >>> c
    ('a', 2, 'b')

#### 3、查找元素 ####

>>> c
    ('a', 2, 'b')
    >>> c[0]
    'a'
    >>> c[2]
    'b'
    
    # 切片方法和列表类似
    >>> c[0:]
    ('a', 2, 'b')
    >>> c[:2]
    ('a', 2)
    >>> c[:3]
    ('a', 2, 'b')
    >>> c[1:3]
    (2, 'b')

#### 4、遍历元组 ####

>>> c
    ('a', 2, 'b')
    >>> for i in c:
    ...     print(i)
    ...
    a
    2
    b

#### 5、强行给元组添加元素（末尾） ####

>>> c
    ('a', 2, 'b')
    >>> for i in [x for x in range(10) if x % 2 == 0 ]:
    ...     t  = (i,)
    ...     c = c + t
    ...
    >>> c
    ('a', 2, 'b', 0, 2, 4, 6, 8)

*  类似的删改都可以通过for循环，利用元组的合并特性来实现

# 三、字典 #

*  字典：顾名思义，就是像字典一样去查询，字典有一个索引表，我们查字典就是利用索引表，来算出要查看的内容的位置，然后去对应的页码查看即可。Python中的字典也是如此，**根据Key算出Value存放的位置**
 *  所以在**字典**眼中，**无论**你这个**表有多大**，**查询的时间都不会变**~
 *  和**列表**来对比一下，列表是**从前往后，依此查询，直到查到为止**，所以列**表**如果太**大**，查询的速度就有可能会很**慢**~

#### 1、创建字典 ####

>>> dic = { }			# 空字典
    >>> dic
    { }
    >>> type(dic)
    <class 'dict'>		# 数据类型 为 dict
    
    >>> dic = { 'lxn':90,'zhangsan':80,'lisi':70}
    >>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70}
    
    # 使用dict()创建字典
    >>> dict([[1,'1'],[2,'2']])
    { 1: '1', 2: '2'}
    
    >>> dict([(1,'1'),(2,'2')])
    { 1: '1', 2: '2'}
    
    >>> dict(name='lxn',score=90)
    { 'name': 'lxn', 'score': 90}
    
    >>> dict()			# 不传参是空字典
    { }

#### 2、字典的 增删改查 ####

###### 2.1 增 ######

*  **key 应当是字典里没有的**
 *  dic\[key\] = value 即可

>>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70}
    >>> dic['laowang'] = 86
    >>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70, 'laowang': 86}

###### 2.2 删 ######

*  del dic\[key\] 或 pop() 方法

>>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70, 'laowang': 86}
    >>> del dic['laowang']
    >>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70}
    
    >>> dic.pop('lisi')
    79
    >>> dic
    { 'lxn': 90, 'zhangsan': 80}

###### 2.3 改 ######

*  **key 应当是字典里是 有 的**，和添加的区别就在于 Key 是否已经存在于字典中
 *  dic\[key\] = value 即可

>>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 70}
    >>> dic['lisi'] = 79
    >>> dic
    { 'lxn': 90, 'zhangsan': 80, 'lisi': 79}

###### 2.4 查 ######

*  dic\[key\] 即可，但是key不存在会报错

>>> dic['lxn']
    90

*  可以使用get()方法，如果key不存在返回None（空值），不会报错！

>>> dic.get('lxn')
    90
    >>> print(dic.get('haha'))
    None

#### 3、遍历字典 ####

遍历key

>>> for i in dic:
    ...     print(i)
    ...
    lxn
    zhangsan
    lisi

遍历key 和 value

>>> for key,value in dic.items():
    ...       print('key--->%s value--->%s' % (key,value))
    ...
    key--->lxn  value--->90
    key--->zhangsan  value--->80
    key--->lisi  value--->79

#### 4、判断 一个 key 是否在字典中 ####

>>> 'lxn' in dic
    True
    >>> 'lixiaonan' in dic
    False

也可以使用遍历：

>>> for i in dic:
    ...     if 'lxn' == i:
    ...             print('True')
    ...             break
    ...
    True

#### 5、字典的更新（可同时添加，修改） ####

*  用 update() 方法，传入参数是一个dict

>>> dic
    { 'lxn': 90, 'zhangsan': 80}
    >>> dic.update({ 'lxn':100,'lisi':90})
    >>> dic
    { 'lxn': 100, 'zhangsan': 80, 'lisi': 90}

#### 6、获取 keys ,values, keys + values ####

*  keys() 方法
 *  values() 方法
 *  items() 方法

# key
    >>> dic.keys()
    dict_keys(['lxn', 'zhangsan', 'lisi'])
    
    # values
    >>> dic.values()
    dict_values([100, 80, 90])
    
    # items
    >>> dic.items()
    dict_items([('lxn', 100), ('zhangsan', 80), ('lisi', 90)])

#### 7、清空字典 ####

*  clear()方法

>>> dic
    { 'lxn': 100, 'zhangsan': 80, 'lisi': 90}
    
    >>> dic.clear()
    >>> dic
    { }

# 四、set #

*  set() 函数创建一个**无序不重复元素集**
 *  可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

#### 1、过滤重复元素 ####

>>> li = [8,2,'md5',4,5,1,0,8,'hash']
    >>> set(li)
    { 0, 1, 2, 4, 5, 8, 'md5', 'hash'}

*  可以看到**自然数在前面，而且是按自然数顺序排列**，字符串在后面

#### 2、交集，并集，差集 ####

>>> a=set([3,2,5,4])
    >>> b=set([3,1,2])
    
    # 交集
    >>> set(a & b)
    { 2, 3}
    
    # 并集
    >>> set(a | b)
    { 1, 2, 3, 4, 5}
    
    # 差集
    >>> set(a - b)
    { 4, 5}

# 写在最后 #

list , tuple ,dict , set 是Python中最为基础的数据类型，有着相当重要的地位，使用场景很多~