整体文章目录
一、 当前章节目录
二、元组结构
- 列表通常用来存储相同类型的数据;而元组在实际开发中,通常用来存储不同类型的数据。
- 元组(Tuple)与列表相似,不同之处在于元组的元素不能修改;
- 元组表示多个元素组成的序列;用于存储一串信息,不同数据之间用逗号隔开;
- 元组的索引从0开始;
2.1 元组的创建
tuple = ("apple",) # 定义元组,注意后面的逗号不可少
print(tuple[0]) # 打印第一个元素
print(type(tuple)) # 打印定义的tuple的类型
运行结果:
a:apple
<class ‘tuple’>
2.2 元组的访问
tuple = ("apple", "banana", "grape", "orange") # 定义元组
print(tuple[-1]) # 分片,倒数第一个元素
print(tuple[-2]) # 分片,倒数第二个元素
tuple2 = tuple[1:3] # 分片,第二个元素到第三个元素(不包括第四个)
tuple3 = tuple[0:-2] # 分片,从第一个元素到倒数第二个元素(不包括倒数第二个)
tuple4 = tuple[2:-2] # 分片,从第三个元素到倒数第二个元素(不包括倒数第二个)
print(tuple2)
print(tuple3)
print(tuple4)
运行结果:
orange
grape
(‘banana’, ‘grape’)
(‘apple’, ‘banana’)
()
fruit1 = ("apple", "banana")
fruit2 = ("grape", "orange")
tuple = (fruit1, fruit2)
print(tuple)
print("tuple[0][1] = ", tuple[0][1])
print("tuple[1][1] = ", tuple[1][1])
print("tuple[1][2] = ", tuple[1][2])
运行结果:
((‘apple’, ‘banana’), (‘grape’, ‘orange’))
tuple[0][1] = banana
tuple[1][1] = orange
IndexError: tuple index out of range
# 打包
tuple = ("apple", "banana", "grape", "orange")
# 解包
a, b, c, d = tuple
print(a, b, c, d)
运行结果:
apple banana grape orange
2.3 元组的遍历
tuple = (("apple", "banana"), ("grape", "orange"), ("watermelon", ), ("grapefruit", ))
for i in range(len(tuple)):
print("tuple[%d] : " % i, end=' ')
for j in range(len(tuple[i])):
print(tuple[i][j], end=' ')
print()
运行结果:
tuple[0] : apple banana
tuple[1] : grape orange
tuple[2] : watermelon
tuple[3] : grapefruit
tuple = (("apple", "banana"), ("grape", "orange"), ("watermelon", ), ("grapefruit", ))
for i in tuple: # 遍历元组tuple
for j in i: # 同样对子元组进行遍历
print(j) # 依次打印出元素
运行结果:
apple
banana
grape
orange
watermelon
grapefruit
三、列表结构
- 列表是Python中非常重要的数据类型,通常作为函数的返回类型。
- 列表和元组相似,也是由一组元素组成,列表可以实现添加、删除和查找操作,元素的值可以被修改。
3.1 列表的创建
list = ["apple", "banana", "grape", "orange"] # 定义列表
print(list) # 输出列表中所有元素
print(list[2]) # 切片,输出第3个元素
list.append("watermelon") # 在列表末尾添加元素
list.insert(1, "grapefruit") # 向列表中插入元素
print(list)
list.remove("grape") # 从列表中移除grape
print(list)
list.remove("a") # 从列表中移除a,因为当前列表中并没有a,所以将抛出错误
print(list.pop()) # 打印从列表中弹出的元素,即最后一个元素
print(list)
运行结果:
[‘apple’, ‘banana’, ‘grape’, ‘orange’]
grape
[‘apple’, ‘grapefruit’, ‘banana’, ‘grape’, ‘orange’, ‘watermelon’]
[‘apple’, ‘grapefruit’, ‘banana’, ‘orange’, ‘watermelon’]
ValueError: list.remove(x): x not in list
watermelon
[‘apple’, ‘grapefruit’, ‘banana’, ‘orange’]
3.2 列表的使用
list = ["apple", "banana", "grape", "orange"] # 定义list列表
print(list[-2]) # 分片,输出倒数第二个元素
print(list[1:3]) # 分片,输出第2个和第3个元素
print(list[-3:-1]) # 分片
list = [["apple", "banana"], ["grape", "orange"], ["watermelon"], ["grapefruit"]]
for i in range(len(list)):
print("list[%d] : " % i, end=' ')
for j in range(len(list[i])):
print(list[i][j], end=' ')
print()
运行结果:
grape
[‘banana’, ‘grape’]
[‘banana’, ‘grape’]
list[0] : apple banana
list[1] : grape orange
list[2] : watermelon
list[3] : grapefruit
list1 = ["apple", "banana"] # 定义list1列表
list2 = ["grape", "orange"] # 定义list2列表
list1.extend(list2) # list1连接list2
print(list1)
list3 = ["watermelon"]
list1 = list1 +list3 # 将list1与list3连接后赋给list1
print(list1)
list1 += ["grapefruit"] # 使用+=给list1连接上["grapefruit"]
print(list1)
list1 = ["apple", "banana"] * 2
print(list1)
运行结果:
[‘apple’, ‘banana’, ‘grape’, ‘orange’]
[‘apple’, ‘banana’, ‘grape’, ‘orange’, ‘watermelon’]
[‘apple’, ‘banana’, ‘grape’, ‘orange’, ‘watermelon’, ‘grapefruit’]
[‘apple’, ‘banana’, ‘apple’, ‘banana’]
3.3 列表的查找、排序、反转
list = ["apple", "banana", "grape", "orange"] # 定义list列表
print(list.index("grape")) # 打印grape的索引
print(list.index("orange")) # 打印orange的索引
print("orange" in list) # 判断orange是否在列表中
运行结果:
2
3
True
list = ["banana", "apple", "orange", "grape"] # 定义list列表
list.sort() # 排序
print("Sorted list : ", list)
list.reverse() # 反转
print("Reversed list : ", list)
运行结果:
Sorted list : [‘apple’, ‘banana’, ‘grape’, ‘orange’]
Reversed list : [‘orange’, ‘grape’, ‘banana’, ‘apple’]
3.4 列表实现堆栈和队列
# 堆栈的实现
list = ["apple", "grape", "grape"] # 定义list列表
list.append("orange") # 队尾加入orange
print(list)
print("弹出的元素:", list.pop(0)) # 弹出第一个元素
print(list)
运行结果:
[‘apple’, ‘grape’, ‘grape’, ‘orange’]
弹出的元素: apple
[‘grape’, ‘grape’, ‘orange’]
四、字典结构
- 字典是Python中重要的数据类型,字典是由“键-值”对组成,“键-值”对组成的集合,字典中的“值”通过“键”来引用。
4.1 字典的创建
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
print(dict)
print(dict["a"]) # 打印键a对应的值
运行结果:
{‘a’: ‘apple’, ‘b’: ‘banana’, ‘g’: ‘grape’, ‘o’: ‘orange’}
apple
dict = {1 : "apple", 2 : "banana", 3 : "grape", 4 : "orange"}
print(dict)
print(dict[2])
运行结果:
{1: ‘apple’, 2: ‘banana’, 3: ‘grape’, 4: ‘orange’}
banana
print("%s, %(a)s, %(b)s" % {"a":"apple", "b" : "banana"})
运行结果:
{‘a’: ‘apple’, ‘b’: ‘banana’}, apple, banana
4.2 字典的访问
# 字典的添加、删除、修改操作
dict = {"a": "apple", "b": "banana", "g": "grape", "o": "orange"} # 定义dict字典
dict["w"] = "watermelon" # 向字典中增加键为w,值为watermelon的键值对
del(dict["a"]) # 删除字典中键为a的元素
dict["g"] = "grapefruit" # 修改字典中键为g的值
print(dict.pop("b")) # 弹出字典中键为b的元素
print(dict)
dict.clear() # 清除字典中所有元素
print(dict)
运行结果:
banana
{‘g’: ‘grapefruit’, ‘o’: ‘orange’, ‘w’: ‘watermelon’}
{}
# 字典的遍历
dict = {"a": "apple", "b": "banana", "g": "grape", "o": "orange"} # 定义dict字典
for k in dict:
print("dict[%s] = " % k, dict[k])
运行结果:
dict[a] = apple
dict[b] = banana
dict[g] = grape
dict[o] = orange
# 调用items()实现字典的遍历
dict = {"a": "apple", "b": "banana", "g": "grape", "o": "orange"} # 定义dict字典
for(k, v) in dict.items():
print("dict[%s] = " % k, v)
运行结果:
dict[a] = apple
dict[b] = banana
dict[g] = grape
dict[o] = orange
# 使用列表、字典作为字典的值
dict = {"a": ("apple", ), "bo": {"b": "banana", "o": "orange"}, "g": ["grape", "grapefruit"]}
print(dict["a"])
print(dict["a"][0])
print(dict["bo"])
print(dict["bo"]["o"])
print(dict["g"])
print(dict["g"][1])
运行结果:
(‘apple’,)
apple
{‘b’: ‘banana’, ‘o’: ‘orange’}
orange
[‘grape’, ‘grapefruit’]
grapefruit
4.3 字典的方法
dict = {"a": "apple", "b": "banana", "c": "grape", "d": "orange"} # 定义dict字典
# 输出key的列表
print(dict.keys())
# 输出value的列表
print(dict.values())
运行结果:
dict_keys([‘a’, ‘b’, ‘c’, ‘d’])
dict_values([‘apple’, ‘banana’, ‘grape’, ‘orange’])
# get()的等价语句
D = {"key1": "value1", "key2": "value2"} # 定义dict字典
if "key1" in D: # if判断键"key1"是否在字典中
print(D["key1"])
else:
print("None")
运行结果:
value1
# 字典中元素的获取方法
dict = {"a": "apple", "b": "banana", "c": "grape", "d": "orange"} # 定义dict字典
print(dict)
print(dict.get("c", "apple")) # 使用get获取键为c的值,若不存在返回默认值apple
print(dict.get("e", "apple"))
运行结果:
{‘a’: ‘apple’, ‘b’: ‘banana’, ‘c’: ‘grape’, ‘d’: ‘orange’}
grape
apple
# uppate()的等价语句
D = {"key1": "value1", "key2": "value2"}
E = {"key3": "value3", "key4": "value4"}
for k in E:
D[k] = E[k]
print(D)
运行结果:
{‘key1’: ‘value1’, ‘key2’: ‘value2’, ‘key3’: ‘value3’, ‘key4’: ‘value4’}
# 字典E中含有字典D中的key
D = {"key1": "value1", "key2": "value2"}
E = {"key2": "value3", "key4": "value4"}
for k in E:
D[k] = E[k]
print(D)
运行结果:
{‘key1’: ‘value1’, ‘key2’: ‘value3’, ‘key4’: ‘value4’}
# 字典的更新
dict = {"a": "apple", "b": "banana"}
print(dict)
dict2 = {"c": "grape", "d": "orange"}
dict.update(dict2) # 使用update方法更新dict
print(dict)
运行结果:
{‘a’: ‘apple’, ‘b’: ‘banana’}
{‘a’: ‘apple’, ‘b’: ‘banana’, ‘c’: ‘grape’, ‘d’: ‘orange’}
# 设置默认值
dict = {} # 定义空字典dict
dict.setdefault("a")
print(dict)
dict["a"] = "apple"
dict.setdefault("a", "None")
print(dict)
运行结果:
{‘a’: None}
{‘a’: ‘apple’}
4.4 字典的排序、复制
# 调用sorted()排序
dict = {"a": "apple", "b":"grape", "c": "orange", "d": "banana"} # 定义dict字典
print(dict)
# 按照key排序
print(sorted(dict.items(), key=lambda d: d[0]))
# 按照value排序
print(sorted(dict.items(), key=lambda d: d[1]))
运行结果:
{‘a’: ‘apple’, ‘b’: ‘grape’, ‘c’: ‘orange’, ‘d’: ‘banana’}
[(‘a’, ‘apple’), (‘b’, ‘grape’), (‘c’, ‘orange’), (‘d’, ‘banana’)]
[(‘a’, ‘apple’), (‘d’, ‘banana’), (‘b’, ‘grape’), (‘c’, ‘orange’)]
# 字典的浅拷贝
dict = {"a": "apple", "b": "grape"} # 定义dict字典
dict2 = {"c": "orange", "d": "banana"} # 定义dict2字典
dict2 = dict.copy() # 拷贝dict并赋值给dict2
print(dict2)
运行结果:
{‘a’: ‘apple’, ‘b’: ‘grape’}
# 字典的深拷贝
import copy # 导入copy模块
dict = {"a": "apple", "b": {"g": "grape", "o": "orange"}} # 定义字典dict
dict2 = copy.deepcopy(dict) # 深拷贝
dict3 = copy.copy(dict) # 浅拷贝
dict2["b"]["g"] = "orange"
print(dict)
dict3["b"]["g"] = "orange"
print(dict)
运行结果:
{‘a’: ‘apple’, ‘b’: {‘g’: ‘grape’, ‘o’: ‘orange’}}
{‘a’: ‘apple’, ‘b’: {‘g’: ‘orange’, ‘o’: ‘orange’}}
4.5 全局字典——sys.modules模块
import sys # 导入sys模块
print(sys.modules.keys())
print(sys.modules.values())
print(sys.modules["os"])
import sys
d = sys.modules.copy()
import copy, string
for i in zip(set(sys.modules) - set(d)):
print(i)
运行结果:
(’_sre’,)
(’_weakrefset’,)
(’_string’,)
(‘copy’,)
(‘sre_parse’,)
(‘enum’,)
(‘string’,)
(‘sre_compile’,)
(‘copyreg’,)
(‘re’,)
(‘weakref’,)
(‘sre_constants’,)
五、序列
- 序列是具有索引和切片能力的集合。
- 元组、列表和字符串具有通过索引访问某个具体的值,或通过切片返回一段切片的能力,因此元组、列表和字符串都属于序列。
# 索引操作
tuple = ("apple", "banana", "grape", "orange") # 定义tuple元组
list = ["apple", "banana", "grape", "orange"] # 定义list列表
str = "apple" # 定义str字符串
print(tuple[0])
print(tuple[-1])
print(list[0])
print(list[-1])
print(str[0])
print(str[-1])
运行结果:
apple
orange
apple
orange
a
e
# 分片操作
tuple = ("apple", "banana", "grape", "orange")
list = ["apple", "banana", "grape", "orange"]
str = "apple"
print(tuple[:3])
print(tuple[3:])
print(tuple[1:-1])
print(tuple[:])
print(list[:3])
print(list[3:])
print(list[1:-1])
print(list[:])
print(str[:3])
print(str[3:])
print(str[1:-1])
print(str[:])
运行结果:
(‘apple’, ‘banana’, ‘grape’)
(‘orange’,)
(‘banana’, ‘grape’)
(‘apple’, ‘banana’, ‘grape’, ‘orange’)
[‘apple’, ‘banana’, ‘grape’]
[‘orange’]
[‘banana’, ‘grape’]
[‘apple’, ‘banana’, ‘grape’, ‘orange’]
app
le
ppl
apple
六、习题
习题:
- 给定列表L,如[2,5,3,8,10,1],对其进行升序排序并输出。
- 给定字符串s,如’123456’,将其逆序并输出。(提示:使用切片)
- 给定字典d,如{‘a’:1,’b’:2,’c’:3},分别输出它的key与value。向其中插入字典{‘d’:4},并输出新的字典。
- 求出100以内的所有素数,素数之间使用逗号隔开。
答案:
list = [2, 5, 3, 8, 10, 1]
list.sort()
print(list)
运行结果:
[1, 2, 3, 5, 8, 10]
str = '123456'
str = str[::-1]
print(str)
运行结果:
654321
d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys())
print(d.values())
d['d'] = 4
print(d)
运行结果:
dict_keys([‘a’, ‘b’, ‘c’])
dict_values([1, 2, 3])
{‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: 4}
list = []
for i in range(2, 101):
for j in range(2, i+1):
if i == j:
list.append(i)
break
if i % j == 0:
break
print(list)
运行结果:
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]