文章目录

  • 四、组合数据类型
  • 内置函数range（）
  • 列表
  • 添加元素
  • 删除元素
  • 置逆和排序
  • 浅拷贝与深拷贝
  • 列表生成式
  • 元组
  • 字典
  • 添加元素
  • 删除元素
  • 获取键值
  • 字典生成式


四、组合数据类型

内置函数range（）

  • 用于生成一个整数序列，返回值是一个迭代器对象
  • 创建range对象的方式：range（【start，】stop【，step】）（【…】可省略）
  • start：起始索引（默认从0开始）
  • stop：结束索引（不含stop）
  • step：步长，默认为1；步长为负数，表示从右向左切片
  • range类型的优点：
    不管range对象表示的整数的序列有多长，所有range对象占用的内存空间都是相同的；因为仅仅需要存储start，stop，step，只有当用到range对象时，才会去计算序列中的相关元素；
  • in与not in判断整数序列中是否存在（不存在）指定的整数；

列表

可变序列，顺序存储，表中元素可以重复

  • 创建列表：
  • list_demo1 = []
  • list_demo2 = list（）
  • slice切片：语法格式：[start：end：step]
  • start：切片开始的索引（默认从0开始）
  • end：切片结束的索引（不包含end）（默认序列长度）
  • step：步长，默认为1；步长为负数，表示从右向左切片；

-6

-5

-4

-3

-2

-1

p

y

t

h

o

n

0

1

2

3

4

5

list_demo = [1, 2, 3, 4, 5, 6]
print(list_demo[5::-1])
#[6, 5, 4, 3, 2, 1]
print(list_demo[-1::-1])
#[6, 5, 4, 3, 2, 1]
  • 查找：index（x【，start【，end】】）
  • 找出x第一次出现的位置；
  • start：从开始索引
  • end：结束索引
list_demo = [1, 2, 3, 4, 5, 6, 2]
print(list_demo.index(2))	# 1
添加元素
  • append（）
    在列表的尾部追加一个元素，该方法可以接受单个值，也接受元组或列表，但此时，元组或列表作为一个整体追加，形成了嵌套；
list_demo = [1, 2, 3, 4]
list_demo.append([5, 6])
print(list_demo)
#[1, 2, 3, 4, [5, 6]]
  • insert（指定位置，要插入的元素）
    在列表指定的位置插入：
list_demo = [1, 2, 3, 4]
list_demo.insert(1, 9)
print(list_demo)
#[1, 9, 2, 3, 4]
  • extend（）
    将一个列表的元素追加到另一个列表的尾部；
list_demo = [1, 2, 3, 4]
list_demo.extend([5, 6])
print(list_demo)
#[1, 2, 3, 4, 5, 6]
  • 切片添加
list_demo1 = [1, 2, 3, 4]
list_demo2 = [5, 6]
list_demo1[1:] = list_demo2
print(list_demo1)
#[1, 5, 6]
删除元素
  • del（）
    根据索引删除列表中的一个元素或一段区间中的元素；删除列表
list_demo = [1, 2, 3, 4, 5, 6]
del list_demo[1:2]
print(list_demo)	# [1, 3, 4, 5, 6]
del list_demo	# NameError: name 'list_demo' is not defined
  • remove（）
    根据元素本身删除列表中的某个元素
list_demo = [1, 2, 3, 4, 5, 6]
list_demo.remove(2)
print(list_demo)	# [1, 3, 4, 5, 6]
  • clear（）
    清空列表
list_demo = [1, 2, 3, 4, 5, 6]
list_demo.clear()
print(list_demo)	# []
  • pop（x）
    弹出并返回索引x的元素；默认弹出列表最后一个值
list_demo = [1, 2, 3, 4, 5, 6]
list_demo.pop()
print(list_demo)	# [1, 2, 3, 4, 5]
置逆和排序
  • 置逆：reverse（）和 reversed（）
    （reversed（）需要列表化）
# 将列表中的元素置逆
list_demo = [1, 2, 3, 4, 5, 6]
list_demo.reverse()
print(list_demo)
# [6, 5, 4, 3, 2, 1]

list_demo1 = [1, 2, 3, 4, 5, 6]
list_demo2 = list(reversed(list_demo1))
print(list_demo2)
# [6, 5, 4, 3, 2, 1]
  • 排序：sort（）和 sorted（）
    可以通过reverse = True 使元素逆序
    sort（）是直接在原列表上排序，sorted（）是新生成一个列表进行排序，对原列表无影响
# 将列表中的元素排序
list_demo = [1, 3, 2, 4, 6, 0]
list_demo.sort(reverse=True)
print(list_demo)
# [6, 5, 4, 3, 2, 1]

list_demo1 = [1, 3, 2, 4, 6, 0]
list_demo2 = sorted(list_demo1)
print(list_demo1)	
# [1, 3, 2, 4, 6, 0]
print(list_demo2)
# [0, 1, 2, 3, 4, 6]
浅拷贝与深拷贝
  • copy（）：浅拷贝，原列表中的可变序列会根据拷贝列表中的序列元素变化而变化
  • deepcopy（）：深拷贝，避免了浅拷贝对原列表和拷贝列表中可变序列变化的影响
# 浅拷贝
import copy
list_demo1 = [1, 1, 1, [1, 1, 1]]
list_demo2 = copy.copy(list_demo1)
list_demo2[0] = 9
list_demo2[3][0] = 9
print(list_demo1)
# [1, 1, 1, [9, 1, 1]]
print(list_demo2)
# [9, 1, 1, [9, 1, 1]]

# 深拷贝
import copy
list_demo1 = [1, 1, 1, [1, 1, 1]]
list_demo2 = copy.deepcopy(list_demo1)
list_demo2[0] = 9
list_demo2[3][0] = 9
print(list_demo1)
# [1, 1, 1, [1, 1, 1]]
print(list_demo2)
# [9, 1, 1, [9, 1, 1]]
列表生成式

list_demo = [表达式 for i in range（范围）【if 条件】]

list_demo = [i * i for i in range(10) if i % 2 == 0]
print(list_demo)
# [0, 4, 16, 36, 64]

元组

不可变序列，顺序存储，元组中元素可以重复

  • 创建元组
  • tuple_demo1 = （）
  • tuple_demo2 = tuple（）
  • tuple_demo3 = 1,

若创建时只有一个元素，则必须在元素后加逗号，否则被视为变量；

字典

可变序列，哈希存储，字典中的键不可重复且必须是不可变序列，值可以重复

  • 创建字典
  • dict_demo1 = {}
  • dict_demo2 = dict（）
  • 以关键字参数的形式创建字典
dict_demo3 = dict(name='努力学习的小白P', age=30)
print(dict_demo3)
# {'name': '努力学习的小白P', 'age': 20}
  • 访问元素：字典名[键名]
    如果键名不存在，则返回KeyError: ‘键名’、
添加元素
  • 字典名[键名] = 值
    如果键已存在，则修改值，否则添加新键；
删除元素
  • del （）字典名[键名]
  • popitem（）
    返回并删除字典最后一个键值对；
dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
print(dict_demo.popitem())
# ('occupation', '学生')
  • pop（键名）
    弹出并返回与键名对应的元素；
  • clear（）
    清空字典；
获取键值
  • get（）
    返回指定键对应的值，并允许该键不存在时返回特定的值,默认返回None；
dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
print(dict_demo.get('努力学习的小白P', '一起来学习吧！'))
# 一起来学习吧！
  • items（）
    可以返回字典的键和值，返回值为键值类型；
dict_demo = {'name': '努力学习的小白P', 'age': 20, 'occupation': '学生'}
x = dict_demo.items()
print(x, '\n', type(x))
# dict_items([('name', '努力学习的小白P'), ('age', 20), ('occupation', '学生')]) 
# <class 'dict_items'>
  • keys（）
    返回字典的键；
  • values（）
    返回字典的值；
  • fromkeys（keys，value）
    创建新字典，给定keys作字典的键，value为字典所有键的值；
dict_demo = {}
x = dict_demo.fromkeys(['小白P', '小白L', '小白J'], '快去学习！')
print(x)
# {'小白P': '快去学习！', '小白L': '快去学习！', '小白J': '快去学习！'}
字典生成式

zip()函数

  • 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表；
  • 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同；
  • 利用 * 号操作符，可以将元组解压为列表；
a = [1, 2, 3]
b = [3, 2, 1]
c = [1, 2, 3, 4, 5]
zipped = zip(a, b)
print(zipped)
# <zip object at 0x00000168D2C77780>
print(list(zipped))
# [(1, 3), (2, 2), (3, 1)]
print(list(zip(a, c)))
# [(1, 1), (2, 2), (3, 3)]

e, d = zip(*zip(a, b))
print(list(e))
# [1, 2, 3]
print(list(d))
# [3, 2, 1]