整体文章目录

一、当前章节目录

二、元组结构

列表通常用来存储相同类型的数据；而元组在实际开发中，通常用来存储不同类型的数据。
元组(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:             # 遍历元组tuplefor 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)breakif 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]

《零基础学Python》Python数据结构【四】相关推荐

python零基础看什么视频和书籍-资料│最适合大学生零基础学的Python视频+电子书...
原标题:资料│最适合大学生零基础学的Python视频+电子书月最热资源下载 (▲点击阅读) 已经不少童鞋跟播妞咨询了python的资源今天播妞将整理好的部分python资源发布是最适合零基础大学 ...
零基础学python电子书-资料│最适合大学生零基础学的Python视频+电子书
原标题:资料│最适合大学生零基础学的Python视频+电子书月最热资源下载 (▲点击阅读) 已经不少童鞋跟播妞咨询了python的资源今天播妞将整理好的部分python资源发布是最适合零基础大学 ...
python零基础学习书-Python零基础到进阶必读的书藉：Python学习手册pdf免费下载
提取码:0oor Google和YouTube由于Python的高可适应性.易于维护以及适合于快速开发而采用它.如果你想要编写高质量.高效的并且易于与其他语言和工具集成的代码,<Python学习 ...
c语言scanf函数隐藏的缓冲区,零基础学C语言笔记四 Scanf函数清除缓冲区
Scanf函数清除缓冲区之前涉及到scanf会先到缓冲区看看是否存在数据,若存在数据,就直接拿缓冲区的数据过来使用,这就涉及到了一个问题,那如果缓冲区的数据不是我想要的呢? 方法一:我们用scanf ...
零基础学 Python爬虫（5）：前置准备（四）数据库基础
人生苦短,我用 Python 本篇文章,我们接着介绍基础内容,数据库. 爬虫将数据爬取完成后,总要有地方存放吧,这个数据存在哪里呢? 当然是数据库中,那个说放在 Excel 里的,你给我站住! 当然 ...
零基础学 Python 爬虫（13）：urllib 基础使用（三）
人生苦短,我用 Python 引言前面两篇基础,我们介绍请求发送的过程. 不知道各位同学有没有想过这样一个问题,如果在爬虫运行的过程中,网络突然波动了下,比如突然网速很慢很慢,造成当前的请求超时,程 ...
零基础如何学好python爬虫？之python爬取B站小视频
B 站真是个神奇的网站.找不到资料了,去 B 站逛一逛,保准有你满意的东西. 前几天写了个爬虫,用 path.re.BeautifulSoup 爬取的 B 站 python 视频,如果要爬取多页的话 ...
零基础如何学好python爬虫？python爬取B站小视频
B 站真是个神奇的网站.找不到资料了,去 B 站逛一逛,保准有你满意的东西. 前几天写了个爬虫,用 path.re.BeautifulSoup 爬取的 B 站 python 视频,如果要爬取多页的话 ...
零基础学 Python3（22）：2019 豆瓣电影排行
人生苦短,我用 Python 引言从本篇的标题各位同学应该已经猜到了,本篇又到了实战环节~~~ 2019 已经快过完了,按照本文推送的时间预估,到 2020 应该还有十来天的时间,又到了各个公司出各 ...
浙江理工大学我的编程之路零基础学C/C++ 200题标程/题解
浙江理工大学我的编程之路零基础学C/C++ 200题标程/题解 OJ地址:http://47.96.116.66/index.php 标程/题解GitHub:https://github.com ...

《零基础学Python》Python数据结构【四】

整体文章目录

一、当前章节目录

二、元组结构

2.1 元组的创建

2.2 元组的访问

2.3 元组的遍历

三、列表结构

3.1 列表的创建

3.2 列表的使用

3.3 列表的查找、排序、反转

3.4 列表实现堆栈和队列

四、字典结构

4.1 字典的创建

4.2 字典的访问

4.3 字典的方法

4.4 字典的排序、复制

4.5 全局字典——sys.modules模块

五、序列

六、习题

《零基础学Python》Python数据结构【四】相关推荐

最新文章

热门文章

《零基础学Python》Python数据结构【四】

整体文章目录

一、 当前章节目录

二、元组结构

2.1 元组的创建

2.2 元组的访问

2.3 元组的遍历

三、列表结构

3.1 列表的创建

3.2 列表的使用

3.3 列表的查找、排序、反转

3.4 列表实现堆栈和队列

四、字典结构

4.1 字典的创建

4.2 字典的访问

4.3 字典的方法

4.4 字典的排序、复制

4.5 全局字典——sys.modules模块

五、序列

六、习题

《零基础学Python》Python数据结构【四】相关推荐

最新文章

热门文章

一、当前章节目录