首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Python 升级之路( Lv3 ) 序列

Python 升级之路( Lv3 ) 序列

作者头像
时间静止不是简史
发布2022-12-02 16:26:23
2.8K0
发布2022-12-02 16:26:23
举报
文章被收录于专栏:Java探索之路Java探索之路

Python系列文章目录

第一章 Python 入门

第二章 Python基本概念

第三章 序列

序列

前言

本章主要主要讲述什么是序列, 以及序列的几种类型: 列表, 元组, 字典, 集合等 熟悉相关概念以及操作方式(创建, 修改, 删除, 查询). 注意他们之间的使用区别并在不同情况下选取合适的序列

一、序列是什么

序列是一种数据存储方式,用来存储一系列的数据。 在内存中,序列就是一块用来存放多个值的连续的内存空间

比如一个整数序列10,20,30,40,示意表示:

序列分类

序列可分为以下五类:

  • 列表
  • 元组
  • 字典
  • 集合
  • 字符串序列

特别注意

序列类似Java中的集合的概念, 但是, 序列中的集合和Java中的集合却不一样 (约等于Java中的list 集合).


二、列表

介绍

列表:用于存储任意数目、任意类型的数据集合。 列表是内置可变序列,是包含多个元素的有序连续的内存空间。 特点: 有序, 可变, 中括号**[]**

列表的标准语法格式:a = [10,20,30,40] . 其中,10,20,30,40这些称为:列表a的元素。

注意:

  • 字符串和列表都是序列类型,一个字符串是一个字符序列,一个列表是任何元素的序列。
  • 前面学习的很多字符串的方法,在列表中也有类似的用法,几乎一模一样。

操作

列表的创建

  • 使用list()可以将任何可迭代的数据转化成列表
  • range()创建整数列表
  • 推导式生成列表
# 列表:用于存储任意数目、任意类型的数据集合
# list()创建
import random

a = [10086, 10010, 10000, "中国移动", "中国联通", "中国电信"]
b = []  # 创建一个空列表对象
print(a)
print(b)

# list()创建
# 使用list()可以将任何可迭代的数据转化成列表
a = list()
b = list(range(9))
c = list("中国移动,10086")
print(a)
print(b)  # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(c)  # ['中', '国', '移', '动', ',', '1', '0', '0', '8', '6']

# range()创建整数列表
# range()可以帮助我们非常方便的创建整数列表,这在开发中极其有用. 语法格式为:range([start,] end [,step])
# start参数:可选,表示起始数字。默认是0
# end参数:必选,表示结尾数字
# step参数:可选,表示步长,默认为1
a = list(range(3, 15, 2))  # 结果:[3, 5, 7, 9,11, 13]
b = list(range(15, 9, -1))  # 结果:[15, 14, 13,12, 11, 10]
c = list(range(3, -4, -1))  # 结果:[3, 2, 1, 0,-1, -2, -3]
print(a, b, c)

# 推导式生成列表
# 使用列表推导式可以非常方便的创建列表,在开发中经常使用
a = [x * 2 for x in range(5)]
# #通过if过滤元素[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
b = [x * 2 for x in range(100) if x % 9 == 0]
print(a, b)

列表的新增

  • append()方法( 速度最快, 推荐使用 )
  • +运算符操作 ( 生成新对象 )
  • extend()方法 ( 尾插, 不生成新对象 )
  • insert()插入元素 ( 插入到指定位置, 慎用 )
  • 使用乘法扩展列表,生成一个新列表,新列表元素是原列表元素的多次重复
# 列表元素的增加
# 1. append()方法 原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用
a = [20, 40]  # 此列表创建可以重写为列表文字
a.append(80)
print(a)  # 结果:[20, 40, 80]
# 2. +运算符操作 并不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中
a = [20, 40]
print("测试第一次时对象的引用: ", id(a))
a = a + [50]
print("测试第二次时对象的引用: ", id(a))  # 两次地址不一样,创建了新的对象
# 3. extend()方法 将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象
a = [20, 40]
print(id(a))
b = [50, 60]
a.extend(b)  # 原对象修改
print(id(a), a)
a = a + b  # 产生新对象
print(id(a), a)
# 4. insert()插入元素
# 使用 insert() 方法可以将指定的元素插入到列表对象的任意制定位置.
# 这样会让插入位置后面所有的元素进行移动,会影响处理速度. 涉及大量元素时,尽量避免使用。
a = [10, 20, 30]
a.insert(2, 100)  # 在2号下标位置(起点为0)放入100
print(a)  # 结果:[10, 20, 100, 30]
# 5. 乘法扩展 使用乘法扩展列表,生成一个新列表,新列表元素是原列表元素的多次重复
a = ["托尼斯塔克", "爱你三千遍"]
d = a * 30  # 3000是在太多了...
print(a)
print(d)

列表的删除:

  • del() 删除列表指定位置的元素
  • pop()删除并返回指定位置元素
  • 删除首次出现的指定元素,若不存在该元素抛出异常
# 列表元素的删除
# 1. del删除, 删除列表指定位置的元素
a = [100, 200, 888, 300, 400]
del a[2]
print(a)  # 结果:[100,200,300,400]
# 2. pop()方法
# pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素
a = [10, 20, 30, 40, 50]
b1 = a.pop()  # 结果:b1=50
print(a, b1)  # 结果:[10, 20, 30, 40] 50
b2 = a.pop(1)
print(a, b2)  # 结果:[10, 30, 40],20
# 3.remove()方法
# 删除首次出现的指定元素,若不存在该元素抛出异常
a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
a.remove(20)  # [10, 30, 40, 50, 20, 30, 20,30]
print(a)
# a.remove(90)  # ValueError: list.remove(x): x not in list

复制列表所有的元素到新列表对象:

# 复制列表所有的元素到新列表对象
# 只是将list2也指向了列表对象,也就是说list2和list2持有地址值是相同的. 列表对象本身的元素并没有复制。
list1 = [30, 40, 50]
list2 = list1
print(list2)

访问 & 计数

访问:

  • 通过索引直接访问元素
  • index()获得指定元素在列表中首次出现的索引
# 列表元素访问和计数
# 1. 通过索引直接访问元素
# 我们可以通过索引直接访问元素。索引的区间在 [0, 列表长度-1] 这个范围。超过这个范围则会抛出异常。
a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
print(a[2])  # 结果:30
# print(a[10])  # 报错:IndexError: list index out of range
# 2. index()获得指定元素在列表中首次出现的索引
# index() 可以获取指定元素首次出现的索引位置。语法是: index(value,[start, [end]]) 。其中, start 和 end 指定了搜索的范围。
print(a.index(20))  # 1
print(a.index(20, 3))  # 5
print(a.index(30, 5, 7))  # 6
print(a[a.index(20)])
print(a[a.index(20, 3)])
print(a[a.index(30, 5, 7)])

计数:

  • count()获得指定元素在列表中出现的次数
  • len()返回列表长度,即列表中包含元素的个数
# 3. count()获得指定元素在列表中出现的次数
print("20在列表中出现的次数:", a.count(20))
# 4. len()返回列表长度,即列表中包含元素的个数。
a = [10, 20, 30]
print(len(a))

列表的遍历:

# 列表的遍历
print("测试列表的遍历")
a = [10, 20, 30, 40]
for o in a:
    print(o)

常见用法

列表常见方法如下图所示, 下面我们对部分用法进行操作

切片操作:

# 切片操作
# 类似字符串的切片操作,对于列表的切片操作和字符串类似. 
# 标准格式为:[起始偏移量start:终止偏移量end[:步长step]]
# 切片操作时,起始偏移量和终止偏移量不在 [0,字符串长度-1] 这个范围,也不会报错。
# 起始偏移量 小于0 则会当做 0 ,终止偏移量 大于 “长度-1” 会被当成 ”长度-1”
print([10, 20, 30, 40][1:30])

成员资格判断:

# 成员资格判断
# 判断列表中是否存在指定的元素,我们可以使用 count() 方法,返回0则表示不存在,返回大于0则表示存在
# 但是,一般我们会使用更加简洁的 in 关键字来判断,直接返回 True 或 False
a = [10, 20, 30, 40, 50, 20, 30, 20, 30]
print(20 in a)
print(20 not in a)
print(60 not in a)

列表排序:

  • sort(): 修改原列表,不建新列表的排序
  • sort(): 建新列表的排序
  • reversed(): 返回迭代器
# 列表排序
# 1.修改原列表,不建新列表的排序
# sort() 默认升序, 参数 reverse 代表降序
a = [2, 3, 1, 5, 4]
print(id(a))
print(a.sort())
print(a)
a.sort(reverse=True)
print(a)
random.shuffle(a)  # 打乱顺序
print(a)
# 2. 建新列表的排序
# 我们也可以通过内置函数sorted()进行排序,这个方法返回新列表,不对原列表做修改。
a = [20, 10, 30, 40]
print(id(a))
b = sorted(a)
c = sorted(a, reverse=True)
print(b, c)
# 3. reversed()返回迭代器
# 内置函数reversed()也支持进行逆序排列,与列表对象reverse()方法不同的是,
# 内置函数reversed()不对原列表做任何修改,只是返回一个逆序排列的迭代器对象
a = [20, 10, 30, 40]
b = reversed(a)
print(type(c))
print(list(c))

关于reversed()

我们打印输出c发现提示是:list_reverseiterator。也就是一个迭代对象。 同时,我们使用list(c)进行输出,发现只能使用一次。 第一次输出了元素,第二次为空。那是因为迭代对象在第一次时已经遍历结束了,第二次不能再使用。

max, min 和 sum

max, min用于返回列表中最大和最小值 sum 用于统计列表中各元素的和

# 列表相关的其他内置函数汇总
# 1. max和min
a = [3, 10, 20, 15, 9]
print(max(a))
print(min(a))
# 2. sum
print(sum(a))

多维列表

二维列表

  • 一维列表可以帮助我们存储一维、线性的数据。
  • 二维列表可以帮助我们存储二维、表格的数据。例如下表的数据:

队名

第几季

胜者

才子队

1

比尔

九头蛇队

2

皮尔斯

巨亨队

3

卡罗尔

二维表的访问方式:

a = [
    ["才子队", 1, "比尔"],
    ["九头蛇队", 2, "皮尔斯"],
    ["巨亨队", 3, "卡罗尔"],
]
# 输出单个元素
# print(a[0][0], a[1][1], a[1][2])

# 嵌套循环打印二维列表所有的数据
for m in range(3):
    for n in range(3):
        print(a[m][n], end="\t")
    print()

三、其他序列类型

元组

介绍

列表属于可变序列,可以任意修改列表中的元素。 元组属于不可变序列,不能修改元组中的元素。 元组特点: 有序, 不可变, 小括号 ( )

操作

元组没有增加元素、修改元素、删除元素相关的方法。 只需学元组的创建和删除,元素的访问和计数即可。

元组支持如下操作:

  • 索引访问
  • 切片操作
  • 连接操作
  • 成员关系操作
  • 比较运算操作
  • 计数:元组长度len()、最大值max()、最小值min()、求和sum()等

元组的创建

tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组 list()可以接收元组、字符串、其他序列类型、迭代器等生成列表

# 元组tuple
# 列表属于可变序列,可以任意修改列表中的元素
# 元组属于不可变序列,不能修改元组中的元素. 因此,元组没有增加元素、修改元素、删除元素相关的方法
a = (1)
print(type(a))
# 一般创建方式
# 如果元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1)解释为整数1,(1,)解释为元组。
a = (1,)
b = 2,
print(type(a), type(b))
# 通过tuple()创建元组
a = tuple()
b = tuple("abc")
c = tuple(range(3))
d = tuple([2, 3, 4])
print(a, b, c, d)

元组的访问和计数

# 元组的元素访问和计数
# 1 元组的元素不能修改
a = [20, 10, 30, 9, 8]
# 元组的元素访问、index()、count()、切片等操作,和列表一样
print(a[1])
print(a[1:3])
print(a[:4])
print(a[2:])
print("元组的计数:", len(a))
print("指定元素出现的个数:", a.count(8))

# 列表关于排序的方法list.sorted()是修改原列表对象,元组没有该方法
# 如果要对元组排序,只能使用内置函数sorted(tupleObj),并生成新的列表对象
a = (20, 10, 30, 9, 8)
b = sorted(a)
print(b)  # [8, 9, 10, 20, 30]

zip

zip(列表1,列表2,…)将多个列表对应位置的元素组合成为元组,并返回这个zip对象

# zip(列表1,列表2,...)将多个列表对应位置的元素组合成为元组,并返回这个zip对象
# 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
d = zip(a, b, c)
print(d)  # <zip object at 0x000001F1E4FBE280>
e = list(d)
print(e)

生成器推导式创建元组

# 生成器推导式创建元组
# 1.从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号
# 2.列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象
# 3.我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的 __next__() 方法进行遍历,或者直接作为迭代器对象来使用。
#   不管什么方式使用,元素访问结束后,如果需要重新访问其中的元素,必须重新创建该生成器对象
# 列表推导式: [0, 2, 4, 6, 8]
a = [x * 2 for x in range(5)]
print(a)
# 列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象
s = (x * 2 for x in range(5))
print(s)
# 我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的 __next__() 方法进行遍历,或者直接作为迭代器对象来使用
b = tuple(s)
print(b)  # (0, 2, 4, 6, 8)
c = tuple(s)
# 不管什么方式使用,元素访问结束后,如果需要重新访问其中的元素,必须重新创建该生成器对象
print(c)  # ()

s2 = (x for x in range(3))
print(s2.__next__())  # 0
print(s2.__next__())  # 1
print(s2.__next__())  # 2
# print(s2.__next__())  # 报错:StopIteration

字典

介绍

字典是“键值对”的无序可变序列,字典中的每个元素都是一个“键值对”,包含:“键对象”和“值对象”。 可以通过“键对象”实现快速获取、删除、更新对应的“值对象” 字典特点: 无序, 可变, 大括号 {} + 键值对 k,v 字典是 Python 项目中最常用的序列类型之一, 对应Java 中常用的 Json 数据类型

操作

字典的创建

  • 通过 {} + kv 来创建
  • 通过dict()来创建字典对象(两种方式)
  • 过zip()创建字典对象
  • 通过fromkeys创建值为空的字典
# 字典(类比Json)
# “键”是任意的不可变数据,比如:整数、浮点数、字符串、元组. 但是:列表、字典、集合这些可变对象,不能作为“键”. 并且“键”不可重复。
# “值”可以是任意的数据,并且可重复
# 1. 通过{} 创建字典
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
print(a)
# 2. 通过dict()来创建字典对象(两种方式)
b = dict(name='TimePause', age=18, sex='man')
a = dict([("name", "TimePause"), ("age", 18)])
print(b)
print(a)
c = {}  # 空的字典对象
d = dict()  # 空的字典对象
print(c)
print(d)
# 3. 通过zip()创建字典对象
k = ["name", "age", "sex"]
v = ["TimePause", 18, "man"]
d = dict(zip(k, v))
print(d)  # {'name': 'TimePause', 'age': 18, 'sex': 'man'}
# 4. 通过fromkeys创建值为空的字典
f = dict.fromkeys(["name", "age", "sex"])
print(f)  # {'name': None, 'age': None, 'sex': None}

元素的访问:

# 字典元素的访问
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
# 1. 通过 [键] 获得“值”。若键不存在,则抛出异常。
b = a["name"]
print(b)
# c = a["birthday"]  # KeyError: 'birthday'
# print(c)
# 2. 通过get()方法获得“值”. 推荐使用.
# 优点是:指定键不存在,返回None;也可以设定指定键不存在时默认返回的对象. 推荐使用get()获取“值对象”
b = a.get("name")
c = a.get("birthday")
d = a.get("birthday", "值不存在")
print(b)
print(c)
print(d)
# 3. 列出所有的键值对
b = a.items()
print(b)  # dict_items([('name', 'TimePause'), ('age', 18), ('sex', 'man')])
# 4. 列出所有的键,列出所有的值
k = a.keys()
v = a.values()
print(k, v)  # dict_keys(['name', 'age', 'sex']) dict_values(['TimePause', 18, 'man'])
# 5. len() 键值对的个数
b = len(a)
print(b)
# 6. 检测一个“键”是否在字典中
print("name" in a)  # True

字典元素添加、修改、删除

# 字典元素添加、修改、删除
# 1. 给字典新增“键值对”。如果“键”已经存在,则覆盖旧的键值对;如果“键”不存在,则新增“键值对
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
a['name'] = "时间静止"
a['phone'] = 18322222222
print(a)
# 2. 使用 update() 将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复,则直接覆盖
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
b = {'name': '时间静止', 'age': 18, 'phone': 18322222222}
a.update(b)  # 旧字典.update(新字典)
print(a)
# 3. 字典中元素的删除,可以使用 del() 方法;或者 clear() 删除所有键值对; pop() 删除指定键值对,并返回对应的“值对象
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
del (a["name"])
print(a)  # {'age': 18, 'sex': 'man'}
a.pop("age")
print(a)  # {'sex': 'man'}
# 4. popitem() :以后入先出的方式删除和返回该键值对
# 删除并返回一个(键,值)对作为 2 元组。对以 LIFO(后进先出)顺序返回。如果 dict 为空,则引发 KeyError。
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
a.popitem()
print("第一次调用popitem", a)
a.popitem()
print("第二次调用popitem", a)
a.popitem()
print("第三次调用popitem", a)
# a.popitem()     # KeyError: 'popitem(): dictionary is empty'
# print("第四次调用popitem", a)

序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值

# 序列解包
# 序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值
x, y, z = (20, 30, 10)  # 变量
(a, b, c) = (9, 8, 10)  # 元组
[m, n, p] = [10, 20, 30]    # 列表
# 序列解包用于字典时,默认是对“键”进行操作;
a = {'name': 'TimePause', 'age': 18, 'sex': 'man'}
name, age, sex = a
print(name)
# 如果需要对键值对操作,则需要使用items()
name, age, sex = a.items()
print(name)
# 如果需要对“键”进行操作,则需要使用keys()
name, age, sex = a.keys()
print(name)
# 如果需要对“值”进行操作,则需要使用values()
name, age, sex = a.values()
print(name)

表格数据使用字典和列表存储访问

# 表格数据使用字典和列表存储访问
# 定义字典对象
a1 = {"name": "才子队", "season": 1, "winner": "比尔"}
a2 = {"name": "九头蛇队", "season": 2, "winner": "皮尔斯"}
a3 = {"name": "巨亨队", "season": 3, "winner": "卡罗尔"}
# 定义列表对象tl
tl = [a1, a2, a3]
print(tl)
print(tl[1].get("name"))
# 输出所有获胜人员名称
for x in range(3):
    print(tl[x].get("winner"))
# 打印表的所有数据
for i in range(len(tl)):
    print(tl[i].get("name"), tl[i].get("season"), tl[i].get("winner"))

字典核心底层原理(重要)

一 : 将一个键值对放进字典的底层过程

  1. 字典对象的核心是散列表. 散列表是一个稀疏数组(总是有空白元素的数组) 数组的每个单元叫做 bucket. 每个 bucket 有两部分:一个是键对象的引用,一个是值对象的引用 由于所有 bucket 结构和大小一致,我们可以通过偏移量来读取指定bucket

下面操作将一个键值对放入字典

假设字典a对象创建完后,数组长度为8

a = {}
a["name"]="比尔"

我们要把”name”=”比尔”这个键值对放到字典对象a中,

首先第一步需要计算键”name”的散列值。Python中可以通过hash()来计算。

下面我们通过 Python Console 来查看 name 的hash值

bin(hash("name"))
'-0b1010111101001110110101100100101'

由于数组长度为8,我们可以拿计算出的散列值的最右边3位数字作为偏移量,即“101”,十进制是数字5

我们查看偏移量6对应的bucket是否为空

如果为空,则将键值对放进去。如果不为空,则依次取右边3位作为偏移量,即“100”,十进制是数字4

再查看偏移量为7的bucket是否为空。直到找到为空的bucket将键值对放进去. 流程图如下:

字典扩容

python会根据散列表的拥挤程度扩容。“扩容”指的是:创造更大的数组,将原有内容拷贝到新数组中。

接近2/3时,数组就会扩容

二. 根据键查找“键值对”的底层过程

通过 Python console() 查看字典元素值如下

>>> a.get("name")
		'比尔'

当调用a.get(“name”),就是根据键“name”查找到“键值对”,从而找到值对象“比尔”

我们仍然要首先计算“name”对象的散列值:

>>> bin(hash("name"))
'-0b1010111101001110110101100100101'

和存储的底层流程算法一致,也是依次取散列值的不同位置的数字。

假设数组长度为8,我们可以拿计算出的散列值的最右边3位数字作为偏移量,即 101 ,十进制是数字5。

我们查看偏移量5,对应的 bucket 是否为空。如果为空,则返回 None 。

如果不为空,则将这个 bucket 的键对象计算对应散列值,和我们的散列值进行比较

如果相等。则将对应“值对象”返回。

如果不相等,则再依次取其他几位数字,重新计算偏移量依次取完后,仍然没有找到。则返回None

流程图如下:

用法总结:

  • 字典在内存中开销巨大 (空间换时间)
  • 键查询速度很快 (通过位运算+Hash运算)
  • 往字典里面添加新键值对可能导致扩容,导致散列表中键的次序变化。 因此,不要在遍历字典的同时进行字典的修改
  • 键必须可散列 数字、字符串、元组,都是可散列的 如果是自定义对象, 需要支持下面三点: (1) 支持 hash() 函数 (2) 支持通过 __eq__() 方法检测相等性 (3) 若 a==b 为真,则 hash(a)==hash(b) 也为真

集合

介绍

集合: 集合是无序可变,元素不能重复 实际上,集合底层是字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的 集合特点: 无需, 可变, 大括号 {} , 底层基于字典, 键不能重复

操作

创建和删除

# 集合创建和删除(类似set)
# 1 使用{}创建集合对象,并使用add()方法添加元素
a = {3, 5, 7}
a.add(9)
print(a)  # {9, 3, 5, 7}
# 2 使用set(),将列表、元组等可迭代对象转成集合. 如果原来数据存在重复数据,则只保留一个
a = ['a', 'b', 'c', 'b']
b = set(a)  # {'b', 'a', 'c'}
print(b)
# remove()删除指定元素;clear()清空整个集合
a = {10, 20, 30, 40, 50}
a.remove(20)  # {10, 50, 40,30}
print(a)

集合相关操作

# 集合相关操作
# 像数学中概念一样,Python对集合也提供了并集、交集、差集等运算
a = {1, 2, 3}
b = {3, 4, 5}
print("求并集: ", a | b)
print("求并集: ", a.union(b))
print("求交集: ", a & b)
print("求交集: ", a.intersection(b))
print("求差集: ", a - b)
print("求差集: ", a.difference(b))

四、思考

根据上面的学习, 思考如下问题

  1. a = 100,200,300 的内存存储示意图
  2. 使用 range 生成序列: 30,40,50,60,70,80
  3. 推导式生成列表: a = x*2 for x in range(100) if x%9==0 ,手写出结果

name

season

winner

才子队

1

比尔

九头蛇队

2

皮尔斯

巨亨队

3

卡罗尔

  1. 元组和列表有哪些共同点?有哪些不同点?
  2. 创建一个字典对象,包含如下信息:支出金额:300.15,支出日期:2022.04.27,支出人:拿破仑

name

season

winner

才子队

1

比尔

九头蛇队

2

皮尔斯

巨亨队

3

卡罗尔

  1. 用文字和自己画的示意图描述:字典存储一个键值对的底层过程。
  2. 集合和字典有什么关系

答案

# 1. a = [100,200,300] 的内存存储示意图, 如图1
a = [100, 200, 300]
print(id(a[0]))
print(id(a[1]))
print(id(a[2]))

# 2. 使用 range 生成序列: 30,40,50,60,70,80
a = [i * 10 for i in range(3, 9)]
print(a)

# 3. 推导式生成列表: a = [x*2 for x in range(100) if x%9==0] ,
a = [x * 2 for x in range(100) if x % 9 == 0]
print(a)  # 输出 0-198中对9整除的数, 包括0

# 4. 使用二维列表存储表格信息,并画出简单的内存存储示意图, 如图2
a = [
    ["才子队", 1, "比尔"],
    ["九头蛇队", 2, "皮尔斯"],
    ["巨亨队", 3, "卡罗尔"],
]

#  5. 元组和列表有哪些共同点?有哪些不同点?
# 1.相同点
# ( 1 )索引相同,从左到右都为0~~n-1。
# ( 2 )拼接相同,都可以用“+”拼接。
# ( 3 )计数相同,都使用len()函数统计元素个数、使用count()函数统计指定元素的出现次数。
# ( 4 )都属于有序序列。
# ( 5 )都可以使用del删除。
# ( 6 )都可以使用“*”来使本身重复。
# ( 7 )都可以强制转换。
# ( 8 )切片方法都一致。
# ( 9 )都可以使用for循环来进行元素遍历、索引遍历以及枚举遍历。
# ( 10 )使用index()方法获取指定元素的索引。
# ( 11 )使用运算符in测试是否包含某个元素
# 2. 不同点
# 类型不同: 元组类型为:tuple; 列表类型为:list
# 修改方式不同: 元组是不可变序列,不能修改; 列表可以根据索引来修改元素值
# 查找方式不同: 元组只能用Index()函数来查看; 列表只能用Index()函数来查看
# 查询速度不同: 元组的访问和处理速度比列表快

# 6. 创建一个字典对象,包含如下信息:支出金额:300.15,支出日期:2022.04.27,支出人:拿破仑
# 方式一
order = {"支出金额": 300.15, "支出日期": "2022.04.27", "支出人": "拿破仑"}
print(order)
# 方式二
order2 = dict([("支出金额", 300.15), ("支出日期", "2022.04.27"), ("支出人", "拿破仑")])
print(order2)
# 7.使用字典存储行数据,最后将整个表使用列表存储起来
a1 = {"name": "才子队", "season": 1, "winner": "比尔"}
a2 = {"name": "九头蛇队", "season": 2, "winner": "皮尔斯"}
a3 = {"name": "巨亨队", "season": 3, "winner": "卡罗尔"}

# 8. 用文字和自己画的示意图描述:字典存储一个键值对的底层过程。 见字典核心底层原理

# 9. 集合和字典有什么关系
# 字典:
#   由key和value组成,字典是有序的(python3.7中)
#   字典是可变的
#   字典支持索引操作
#   字典对应的哈希表中存储了哈希值、key和value
#   字典的key不能重复
#
# 集合:
#   集合没有key和value的配对,是无序的,且元素值唯一
#   集合是可变的
#   集合不支持索引/切片操作
#   集合对应的哈希表中仅存储了哈希值
#   集合的值不能重复
# 注意: 
# 在 Python3.7+以后字典都被确定为有序,而集合是无序的元素集。
# 集合和字典基本相同,区别是集合没有键和值的配对,是一系列无序的、唯一的元素组合。

图1

图2

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2022-06-08,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • Python系列文章目录
    • 序列
    • 前言
    • 一、序列是什么
    • 二、列表
      • 介绍
        • 操作
          • 访问 & 计数
          • 常见用法
        • 多维列表
        • 三、其他序列类型
          • 元组
            • 介绍
            • 操作
          • 字典
            • 介绍
            • 操作
            • 字典核心底层原理(重要)
          • 集合
            • 介绍
            • 操作
        • 四、思考
        相关产品与服务
        对象存储
        对象存储(Cloud Object Storage,COS)是由腾讯云推出的无目录层次结构、无数据格式限制,可容纳海量数据且支持 HTTP/HTTPS 协议访问的分布式存储服务。腾讯云 COS 的存储桶空间无容量上限,无需分区管理,适用于 CDN 数据分发、数据万象处理或大数据计算与分析的数据湖等多种场景。
        领券
        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档