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

╰半夏微凉° 2023-07-11 11:11 26阅读 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、列表的创建

创建一个空列表

  1. >>> a=[]

创建一个带有值的列表

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

list()函数创建

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

2、列表的性质 —— 增 删 改 查

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

示例：

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

示例：

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

3、遍历列表

  1. >>> li
  2. ['end', 7, 6, 5, 4, 'index=3', 2, 1, 'head']
  3. >>> for i in li:
  4. ...     print(i)
  6. end
  7. 7
  8. 6
  9. 5
  10. 4
  11. index=3
  12. 2
  13. 1
  14. 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的平方的列表：

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

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

  1. >>> [i for i in range(101) if i % 2 == 1]
  2. [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前面的表达式，并将结果加入到列表的最后。

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

  1. li = [ ]
  2. for i in range(101):
  3.     if i % 2 == 1:
  4.         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() 函数创建出的示例 不属于列表

  1. >>> isinstance(q,list)
  2. False
  3. >>> type(q)
  4. <class 'collections.deque'>

5、列表小结

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

二、元组

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

1、创建元组

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

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

    t = (1,)
    t
    (1,)

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

2、合并元组

  1. >>> t = ('a',)
  2. >>> t
  3. ('a',)
  4. >>> b = (2,'b')
  5. >>> b
  6. (2, 'b')
  8. >>> c = t + b        # 合并元组（用这种方法来添加元素也不失为一种方法）
  9. >>> c
  10. ('a', 2, 'b')

3、查找元素

  1. >>> c
  2. ('a', 2, 'b')
  3. >>> c[0]
  4. 'a'
  5. >>> c[2]
  6. 'b'
  8. # 切片方法和列表类似
  9. >>> c[0:]
  10. ('a', 2, 'b')
  11. >>> c[:2]
  12. ('a', 2)
  13. >>> c[:3]
  14. ('a', 2, 'b')
  15. >>> c[1:3]
  16. (2, 'b')

4、遍历元组

  1. >>> c
  2. ('a', 2, 'b')
  3. >>> for i in c:
  4. ...     print(i)
  5. ...
  6. a
  7. 2
  8. b

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

  1. >>> c
  2. ('a', 2, 'b')
  3. >>> for i in [x for x in range(10) if x % 2 == 0 ]:
  4. ...     t  = (i,)
  5. ...     c = c + t
  6. ...
  7. >>> c
  8. ('a', 2, 'b', 0, 2, 4, 6, 8)
  • 类似的删改都可以通过for循环，利用元组的合并特性来实现

三、字典

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

1、创建字典

  1. >>> dic = { }            # 空字典
  2. >>> dic
  3. { }
  4. >>> type(dic)
  5. <class 'dict'>        # 数据类型 为 dict
  7. >>> dic = { 'lxn':90,'zhangsan':80,'lisi':70}
  8. >>> dic
  9. { 'lxn': 90, 'zhangsan': 80, 'lisi': 70}
  11. # 使用dict()创建字典
  12. >>> dict([[1,'1'],[2,'2']])
  13. { 1: '1', 2: '2'}
  15. >>> dict([(1,'1'),(2,'2')])
  16. { 1: '1', 2: '2'}
  18. >>> dict(name='lxn',score=90)
  19. { 'name': 'lxn', 'score': 90}
  21. >>> dict()            # 不传参是空字典
  22. { }

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

  1. >>> for i in dic:
  2. ...     print(i)
  3. ...
  4. lxn
  5. zhangsan
  6. lisi

遍历key 和 value

  1. >>> for key,value in dic.items():
  2. ...       print('key--->%s value--->%s' % (key,value))
  3. ...
  4. key--->lxn  value--->90
  5. key--->zhangsan  value--->80
  6. key--->lisi  value--->79

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

  1. >>> 'lxn' in dic
  2. True
  3. >>> 'lixiaonan' in dic
  4. False

也可以使用遍历：

  1. >>> for i in dic:
  2. ...     if 'lxn' == i:
  3. ...             print('True')
  4. ...             break
  5. ...
  6. 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、过滤重复元素

  1. >>> li = [8,2,'md5',4,5,1,0,8,'hash']
  2. >>> set(li)
  3. { 0, 1, 2, 4, 5, 8, 'md5', 'hash'}
  • 可以看到自然数在前面，而且是按自然数顺序排列，字符串在后面

2、交集，并集，差集

  1. >>> a=set([3,2,5,4])
  2. >>> b=set([3,1,2])
  4. # 交集
  5. >>> set(a & b)
  6. { 2, 3}
  8. # 并集
  9. >>> set(a | b)
  10. { 1, 2, 3, 4, 5}
  12. # 差集
  13. >>> set(a - b)
  14. { 4, 5}

写在最后

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

发表评论

表情：
评论列表 （有 0 条评论，26人围观）

还没有评论，来说两句吧...

相关阅读