Python：列表、元组、字典、集合介绍——干货多多！！！

于 2020-04-23 09:52:24 发布
阅读量240 收藏
点赞数
分类专栏： Python 文章标签： python 列表 集合论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46428072/article/details/105700195
版权

Python列表、元组、字典、集合介绍

文章目录

序列

在了解列表、元组与字典之前我们还需要了解一个概念：序列。

1、概念：序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列中都有唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引

2、序列的分类：

(1)、可变序列（序列中的元素可以改变）：例如 列表（list），字典（doct）；

(2)、不可变序列（序列中的元素不可变）：例如 字符串（str）、元组（tuple）；

列表（List）

列表简介：

列表是Python中的一个对象

列表作用:

列表可以保存多个有序的数据

列表可以储存对象的对象

列表的基本使用

通过“[]”英文的中括号来创建列表

lst = []
print(lst,type(lst))
#输出结果为：[] <class 'list'>

一个列表可以储存元素，可以在创建时直接指定元素，也可以创建后添加。

创建时直接指定：

lst = [1, 2, 'Pyhton']
print(lst, type(lst))
#输出结果为：[1, 2, 'python'] <class 'list'>

列表中元素可以时任意类型

lst = [1, None, True, 'python', '1.2']
print(lst, type(lst))
#输出结果为：[1, None, True, 'python', '1.2'] <class 'list'>

在来介绍下列表的索引：

列表索引有两种形式，一种时由左至右从0开始；一种时由右至左从-1开始，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-svAkjszP-1587606228168)(C:\Users\thadqy\AppData\Roaming\Typora\typora-user-images\image-20200422150011201.png)]

lst = [1, 2, 3, 4]
print(lst[0])
print(lst[1])
print(lst[2])
print(lst[3])
#输出结果为：1 2 3 4
print(lst[-1])
print(lst[-2])
print(lst[-3])
print(lst[-4])
#输出结果为：4 3 2 1

列表的切片操作

概念：从现有列表在获取一个子列表。切片时根据列表索引来操作的。

例：

#创建列表
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
heroA = hero[1:3]
print(heroA)
#输出结果为：['蜘蛛侠', '绿巨人']

**切片的具体作用：

  • 添加元素

    • 向零索引添加元素：

      hero = ['美队', '黑寡妇']
hero[0:0] = ['灭霸']
print(hero)
#输出结果为：['灭霸', '美队', '黑寡妇']

    • 向列表中索引为偶数的添加元素

      hero = ['灭霸', '美队', '黑寡妇']
hero[::2] = ['黑豹'] * 3
print(hero)
#输出结果为：['黑豹', '灭霸', '黑豹', '美队', '黑豹', '黑寡妇']

      上面个的hero[::2]表示从列表开头到结束以没两个添加一个元素

  • 删除列表中的元素

    lst = [1, 2, 3, 4, 5]
list[1:3] = []
print(lst)
#输出结果为：[1,4,5] 删除了列表索引1、2处的值

  • 逆序列表

    lst = [1, 2, 3, 4, 5]
print(lst[::-1])

  • 特殊的切片

    • list[::]从开始到结束

      lst = [1,2,3]
ptint(lst[::])
#输出结果为：[1,2,3]
print(list)
#输出结果为：[1,2,3]

    • list[:n]从列表索引0开始到n结束，不包括n

      hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
print(hero[:3])
#输出结果为：['钢铁侠', '蜘蛛侠', '绿巨人']

    • list[n:]从n开始到结束

      hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
print(hero[3:])
#输出结果为：['黑寡妇', '蚁人', '美国队长']

  • 切片的步长

    • list[int start, int end, int step]表时从start开始以没隔step个元素取一个元素到end为止，不包括end

      hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
print(hero[::2])
#输出结果为：['钢铁侠', '绿巨人', '蚁人']

    • list[int start, int end, -1]当列表步长为-1时就可以实现列表的逆序

      lst = [1,2,3,4]
print(lst[::-1])
#输出结果为：[4,3,2,1]

列表的函数与方法和通用操作

通用操作：

  • “+”将两个列表拼接起来：
lst1 = [1,2,3]
lst2 = [4,5,6]
lst = lst1 + lst2
print(lst)
#输出结果为：[1,2,3,4,5,6]
  • “*”将列表中指元素重复次数
list = ['黑豹'] * 3
print(list)
#输出结果为：['黑豹','黑豹','黑豹']
  • “in” 和 “not in” 判断元素是否在列表中，返回boolean类型
lst = [1,2,3]
print(1 in lst)
#输出结果为：True
print(1 not in lst)
#输出结果为：False

函数：

  • len() 获取列表中元素的个数或列表长度
lst = [1,2,3]
print(len(lst))
#输出结果为：3
  • max() 获取列表元素的ascll码最大值
lst = [1,2,3]
print(max(lst))
#输出结果为：3
  • min() 获取列表元素的ascll最小值
lst = [1,2,3]
print(min(lst))
#输出结果为：1

方法：

  • list.index(x[, i[, j]])获取元素在列表中的位置，从i开始查询到j结束
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '黑寡妇', '蚁人', '美国队长']
print(hero.index('绿巨人',2,6))
#输出结果为：2
  • list.count(x) 统计指定元素在列表在出现的次数
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']
print(hero.count('美国队长'))
#输出结果为：2
  • list.append(x) 向列表最后添加元素
hero = ['钢铁侠', '蜘蛛侠', '绿巨人']
hero.append('黑寡妇')
print(hero)
#输出结果为：['钢铁侠', '蜘蛛侠', '绿巨人'， '黑寡妇']
  • list.insert(int index, char x) 向列表只当的索引位置index插入元素x
hero = ['钢铁侠', '蜘蛛侠', '绿巨人']
hero.insert(2,'黑寡妇')
print(hero)
#输出结果为：['钢铁侠', '蜘蛛侠', '黑寡妇', '绿巨人']
  • list.extend() 用新的序列来扩展当前序列
lst1 = [1,2,3]
lst2 = [4,5,6]
lst1.extend(lst2)
print(lst1)
#输出结果为：[1,2,3,4,5,6]
  • list.clear() 清空列表中的所有元素
lst = [1,2,3]
lst.clear()
print(lst)
#输出结果为：[]
  • list.pop(int index) 根据索引删除元素并返回指定元素，无索引时默认删除最后一个
lst = [1,2,3]
result = lst.pop(2)
print(result,lst)
#输出结果为：3 [1,2]
  • list.remove(char c)移除指定的元素，如果列表中有多个c则只会删除第一个
lst = [1,2,3]
lst.remove(2)
print(lst)
#输出结果为：[1,2]
  • list.reverse() 逆序列表的所有元素
lst = [1,2,3]
lst.reverse
print(lst)
#输出结果为：[3,2,1]
  • list.sort(reverse) 对列表元素进行ascll排序，reverse=True反序，reverse=False正序
lst = ['a','v','s']
lst.sort(reverse = True)
print(lst)
#输出结果为：['v', 's', 'a']
lst.sort()
print(lst)
#输出结果为：['a', 's', 'v']

列表的修改

  • 通过索引修改
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']
hero[0] = '雷神'
print(hero)
#输出结果为：['雷神', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']
  • 通过del 删除元素
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']
del hero[2]
print(hero)
#输出结果为：hero = ['钢铁侠', '蜘蛛侠', '美国队长'， '黑寡妇', '蚁人', '美国队长']
  • 通过切片修改列表
hero = ['钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']
hero[0:2] = ['雷神', '奥丁', '月老']
print(hero)
#输出结果为：['雷神', '奥丁', '月老'， '钢铁侠', '蜘蛛侠', '绿巨人', '美国队长'， '黑寡妇', '蚁人', '美国队长']

列表的遍历

在这就用一个例题来看：

温度转换问题，输入华氏温度转换为摄氏温度，输入摄氏温度转换为华氏温度；

Input Description：12.34C

Output Description: 54.21F

temperature = input("请输入温度:")
if temperature[-1] in ['F', 'f']:
    c = (eval(temperature[0:-1]) - 32) / 1.8
    print("转换后的温度是{:.2f}C".format(c))
elif temperature[-1] in ['c', 'C']:
    f = eval(temperature[0:-1]) * 1.8 + 32
    print("转换后的温度是{:.2f}F".format(f))
else:
    print("输入的数据错误")

元组（tuple）

简介：

元组操作方式基本和列表是一致的，不过元组时不可变序列。所以在操作时像索引赋值，切片修改元素等这些，其他的通用方法都可以。

那么，我们应该在什么时候用列表，什么时候用元组呢？

一般，当我们希望数据不改变就可以用元组，其他情况都用列表。

元组的基本操作

创建元组：

  • 用()创建元组

    #创建一个空元组
my_tuple = ()
print(my_tuple, type(my_tuple))
#输出结果为：() <class 'tuple'>

  • 创建时指定元素

    my_tuple = (1,2,3,4)
print(my_tuple, type(my_tuple))
#输出结果为：(1,2,3,4) <class 'tuple'>

  • 不使用()创建元组，至少有一个“ , ”

    my_tuple = 1,
print(my_tuple, type(my_tuple))
#输出结果为：(1) <class 'tuple'>

元组的解包：

  • 概念：将元组中各元素的值赋值给其他变量。

    my_tuple = (1,2,3,4)
a, b, c, d = my_tuple
print(a)
#输出结果为：1
print(b)
#输出结果为：2
print(c)
#输出结果为：3
print(d)
#输出结果为：4

  • 解包方式

    • 只需要前两个值 a, b, *c = my_tuple

      my_tuple = (1,2,3,4)
a, b, *c = my_tuple
print(a)
#输出结果为：1
print(b)
#输出结果为：2
print(*c)
#输出结果为：3 4
print(c)
#输出结果为：[3, 4]

    • 只需要后两个值*a, b, c = my_tuple

      my_tuple = (1,2,3,4)
*a, b, c = my_tuple
print(*a)
#输出结果为：1 2
print(a)
#输出结果为;[1, 2]
print(b)
#输出结果为：3
print(c)
#输出结果为：4

    • 只去中间两个值

      • a, *b, c = my_tuple

        my_tuple = (1,2,3,4)
a, *b, c = my_tuple
print(a)
#输出结果为：1
print(*b)
#输出结果为：2 3
print(b)
#输出结果为：[2, 3]
print(c)
#输出结果为：4

      • *a, b, c, *d = my_tuple

        my_tuple = (1,2,3,4)
*a, b, c, *d = my_tuple
print(a)
#输出结果为：1
print(b)
#输出结果为：2
print(c)
#输出结果为：3
print(d)
#输出结果为：4

字典（dict）

字典的基本简介

  • 字典属于一种新的数据结构称为映射（Mapping）
  • 字典与列表很相似，都是用来储存对象的容器
  • 列表储存性能好，但查询数据性能差，字典正好与之相反
  • 字典中每一个元素都有唯一一个名字，可以通过名字找到指定的元素
  • 唯一一个的名字可以称为key，通过key可以快速查找到与值唯一对应的值称为value
  • 字典也称为键值对（key——value）结构
  • 每个字典可以有多个键值对，每一对键值对称为项
  • 创建一个有数据的字典语法：{key:value}
  • 字典的值可以是任意对象，字典的键可以是任意的不可变对象

字典的基本操作

  • 使用{}创建字典

    #创建空字典
d = {}
#创建带有数据的字典
d = {'name':'葫芦娃', 'age':12, 'gender':'男'}

  • 使用函数dict()创建字典

    d = dict('name':'葫芦娃', 'age':12, 'gender':'男')
print(d, type(d))
#输出结果为：{'name':'葫芦娃', 'age':12, 'gender':'男'} <class 'dict'>

  • 如果字典里的key重复了，那么后面的覆盖前面的

    d = {'name':'葫芦娃', 'age':12, 'gender':'男, 'name':'钢铁侠'}
print(d)
#输出结果为：{'name':'钢铁侠', 'age':12, 'gender':'男}

  • 取值，字典根据key来取值

    d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
print(d['name'])
#输出结果为：葫芦娃

字典的方法函数和通用 方法

  • 通用方法

    • in 和 not in 判断字典中是否有这一元素

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
print('name' in d)
#输出结果为：True

  • 函数

    • len() 获取字典键值对个数

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
print(len(d))
#输出结果为：3

    • min() 获取字典key的ascll码最小值

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
print(min(d))
#输出结果为：age

    • max() 获取字典key的ascll码最大值

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
print(max(d))
#输出结果为：name

    • del 删除key——value

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
del d['name']
print(d)
#输出结果为：d = {'age':12, 'gender':'男'}

  • 方法

    • dict.setdefault(key,value)字典添加键值对，如果key存在则返回value，不对字典操作。

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
d.setdefault('name':'钢铁侠')
print(d)
#输出结果为：d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
d.setdefault('address':'中国')
print(d)
#输出结果为：d = {'name':'葫芦娃', 'age':12, 'gender':'男', 'address':'中国'}

    • dict.update(dict2) 将其他字典元素添加到当前字典中，如果有重复的key则后面的覆盖前面的

      d1 = {'a':1, 'b':2}
d2 = {'c':3, 'd':4}
d1.update(d2)
print(d1)
#输出结果为：{'a':1, 'b':2, 'c':3. 'd':4}
d3 = {'b':3, 'd':4}
d1.update(d3)
print(d1)
#输出结果为：{'a':1, 'b':3, 'd':4}

    • dict.popitem() 随机删除，一般是最后一个，返回一个元组，元组中第一个是key，第二个是value

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
s = d.popitem()
pritn(s, d)
#输出结果为：('gender', '男') {'name': '葫芦娃', 'age': 12}

    • dict.pop(key[, default]) 根据key删除字典中的key——value，返回key的value,如果字典中没有要删除的key——value，则返回默认语句default

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
k = d.pop('name','没有这个值')
print(k,d)
#输出结果为：葫芦娃 {'age':12, 'gender':'男'}
k = d.pop('str', '没有这个值')
print(k, d)
#输出结果为：没有这个值 {'name':'葫芦娃', 'age':12, 'gender':'男'}

    • dict.keys() 返回字典所有key

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
keys = d.keys()
pritn(keys)
#输出结构为：dict_keys(['name', 'age', 'gender'])

    • dict.values()返回字典所有value

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
values = d.values()
print(values)
#输出结果为：dict_values(['葫芦娃', 7, '男'])

    • dict.item() 返回字典所有key——value的双值子序列

      d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
items = d.items()
print(items)
#输出结果为：dict_items([('name', '葫芦娃'), ('age', 7), ('gender', '男')])

字典的遍历

  • 根据dict.keys()函数遍历

    d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
for i in d.keys():
    print(d.get(i))
#输出结果为：
            葫芦娃
            7
            男

  • 根据dict.values()函数遍历

    d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
for i in d.values():
    print(i)
#输出结果为：
            葫芦娃
            7
            男

  • 根据dict.items()函数遍历

    d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
for k, v in d.items():
    print('{} = {}'.format(k, v))
#输出结果为：
            name = 葫芦娃
            age = 7
            gender = 男

集合（set）

集合概念

  • 集合只能储存不可变对象
  • 集合中储存的对象是无序的
  • 集合中没有重复的对象

集合的基本操作

  • 创建集合

    • 通过“ {} ”创建集合, 通过该方法不可以创建空集合

      s1 = {1,2,3,4}
print(s1,type(s1))
#输出结果为：{1,2,3,4} <calss 'set'>
s2 = {}
print(s2, type(s2))
#输出结果为：{} <class 'dict'>

    • 通过set()函数创建集合

      s1 = set()
print(s1, type(s1))
#输出结果为：set() <class 'set'>
#将列表转化为集合
s2 = set([1,2,3,4])
print(s2, type(s2))
#输出结果为：{1,2,3,4} <class 'set'>
#将字典转化为集合是只保留key
d = {'name':'葫芦娃', 'age':12, 'gender':'男'}
s3 = set(d)
print(s3, type(s3))
#输出结果为：{'gender', 'name', 'age'} <class 'set'>

  • 集合通用操作

    • in 和not in 判断是否包含元素

      s1 = {1,2,3,4}
pritn(1 in s1)
#输出结果为：True
print(0 not in s1)
#输出结果为：True

集合的函数方法

  • len(set) 获取集合中的元素个数

    s1 = {1,2,3,4}
print(len(s1))
#输出结果为：4

  • set.add()向集合中添加元素

    s = {1,2,3,4}
s.add(5)
print(s)
#输出结果为：{1, 2, 3, 4, 5}

  • set.update()将另一个集合添加到当前集合

    s1 = {1,2,3,4}
s2 = set('python')
s1.update(s2)
print(s1)
#输出结果为：{1, 2, 3, 4, 'h', 'p', 'n', 'o', 'y', 't'}

  • set.pop()随机删除集合中的元素，并返回删除值

    s1 = {1,2,3,4}
result = s1.pop()
print(result, s1)
#输出结果为：1 {2,3,4}

  • set.remove()删除集合中指定的值

    s1 = {1,2,3,4}
s1.remove(1)
print(s1)
#输出结果为：{2,3,4}

  • set.clear() 清空集合中的所有元素

    s1 = {1,2,3,4}
s1.clear()
print(s1)
#输出结果为：set()

集合的运算

  • 交集运算 “ & ”

    s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s1 & s2
print(result)
#输出结果为：{3, 4, 5}

  • 并集运算 “ | ”

    s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s1 | s2
print(result)
#输出结果为：{1, 2, 3, 4, 5, 6, 7}

  • 差集运算 “ - ”

    s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result1 = s1 - s2
result2 = s2 - s1
print(result1,result2)
#输出结果为：{1, 2} {6, 7}

  • 异或运算 “ ^ ”

    s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s1 ^ s2
print(result)
#输出结果为：{1, 2, 6, 7}

  • <= 检查一个集合是否是另一个集合的子集

    s1 = {1,2,3}
s2 = {1,2,3,4}
result = s1 <= s2
print(result)
#输出结果为：True

  • < 检查一个集合是否是；另一个集合的真子集

    #s2 必须有s1中所有的元素，并且有s1没有的元素
s1 = {1,2,3}
s2 = {1,2,3,4}
result = s1 < s2
print(result)
#输出结果为：True

  • >= 检查一个集合是否是另一个集合的超集

  • >检查一个集合是否是另一个集合的真超集

结束语

新学Python，以上是我结合自己的感悟和笔记写的，还有许多不懂之处。希望大家多多包涵，同时也希望多家多多留言指出不妥之处。在这谢谢大家的鼓励与支持。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值