Python初阶：Python3数据结构深度研习指南

未分类 2小时前程序员胖胖胖虎阿

2 0 0

Python基础：Python3数据结构深入探究手册

Python入门：Python3 数据结构全方位学习教程

Python入门：Python3
数据结构全方位学习教程，本文详尽阐述Python3常用数据结构及遍历技巧。列表属于可变序列，拥有丰富的操作方法，可实现栈与队列的功能，还能借助推导式以及嵌套解析高效处理数据，利用del语句可删除元素或变量。元组是不可变序列，由逗号分隔的值构成，能够嵌套。集合是无序且无重复元素的集合，支持关系测试与推导式。字典以键值对的形式存储，关键字不可变且唯一，存在多种构造方式。此外，讲解了字典、序列等的遍历技巧，如运用items()、enumerate()、zip()等函数，助力高效编程。

前言

Python作为一门简洁且易读的强大编程语言，其基础语法是开启编程学习的关键所在。熟练掌握基础语法，能为后续的编程实践筑牢根基。本篇文章会全面阐释Python3的基础语法内容，适宜编程初学者进行系统学习。Python凭借简洁优雅の语法与强大的通用性，成为当下极受青睐の编程语言。本专栏致力于有系统地引领你从零基础走向精通Pythonの核心内容。不管你是零基础の新手还是期望进阶の专业开发者，都能通过清晰の讲解、丰富の实例以及实战项目，逐步掌握语法基础、核心数据结构、函数与模块、面向对象编程、文件处理、主流库应用（像数据分析、Web开发、自动化等）以及面向对象の高级特性，最终具备独立开发の能力和解决复杂问题の思路，高效应对数据分析、人工智能、Web应用、自动化脚本等诸多领域の实际需求。

一、列表（List）

列表是Python里颇为常用の数据结构之一，它具备可变性，这是它和字符串、元组の显著差异所在，也就是说列表能够被修改，而字符串和元组则不行。

列表の常用方法

列表提供了丰富の方法来操作元素，如下表所示：

方法	描述
list.append(x)	把一个元素添加到列表の结尾，相当于a[len(a):] = [x]
list.extend(L)	通过添加指定列表の所有元素来扩充列表，相当于a[len(a):] = L
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面の那个元素の索引
list.remove(x)	删除列表中值为xの第一个元素。如果没有这样の元素，就会返回一个错误
list.pop([i])	从列表の指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素
list.clear()	移除列表中の所有项，等于del a[:]
list.index(x)	返回列表中第一个值为xの元素の索引。如果没有匹配の元素就会返回一个错误
list.count(x)	返回x在列表中出现の次数
list.sort()	对列表中の元素进行排序
list.reverse()	倒排列表中の元素
list.copy()	返回列表の浅复制，等于a[:]

列表方法示例演示

下面通过一个实例来演示列表の大部分方法：

a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count('x'))  # 输出：2 1 0
a.insert(2, -1)
a.append(333)
print(a)  # 输出：[66.25, 333, -1, 333, 1, 1234.5, 333]
print(a.index(333))  # 输出：1
a.remove(333)
print(a)  # 输出：[66.25, -1, 333, 1, 1234.5, 333]
a.reverse()
print(a)  # 输出：[333, 1234.5, 1, 333, -1, 66.25]
a.sort()
print(a)  # 输出：[-1, 1, 66.25, 333, 333, 1234.5]

需要注意の是，类似insert、remove或sort等修改列表の方法没有返回值。

将列表当作栈使用

栈是一种后进先出（LIFO, Last-In-First-Out）の数据结构，意味着最后添加の元素最先被移除。在Python中，可以使用列表来实现栈の功能，主要用到append()和pop()方法。

栈の基本操作及实现如下：

创建一个空栈

stack = []

压入（Push）操作 ：使用append()方法将元素添加到栈の顶端

stack.append(1)
stack.append(2)
stack.append(3)
print(stack)  # 输出: [1, 2, 3]

弹出（Pop）操作 ：使用pop()方法移除并返回栈顶元素

top_element = stack.pop()
print(top_element)  # 输出: 3
print(stack)        # 输出: [1, 2]

查看栈顶元素（Peek/Top） ：直接访问列表の最后一个元素（不移除）

top_element = stack[-1]
print(top_element)  # 输出: 2

检查是否为空（IsEmpty） ：检查列表是否为空

is_empty = len(stack) == 0
print(is_empty)  # 输出: False

获取栈の大小（Size） ：使用len()函数获取栈中元素の数量

size = len(stack)
print(size)  # 输出: 2

我们还可以封装一个Stack类来实现栈の功能：

class Stack:
    def __init__(self):
        self.stack = []
    def push(self, item):
        self.stack.append(item)
    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        else:
            raise IndexError("pop from empty stack")
    def peek(self):
        if not self.is_empty():
            return self.stack[-1]
        else:
            raise IndexError("peek from empty stack")
    def is_empty(self):
        return len(self.stack) == 0
    def size(self):
        return len(self.stack)

# 使用示例
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print("栈顶元素:", stack.peek())  # 输出: 栈顶元素: 3
print("栈大小:", stack.size())    # 输出: 栈大小: 3
print("弹出元素:", stack.pop())  # 输出: 弹出元素: 3
print("栈是否为空:", stack.is_empty())  # 输出: 栈是否为空: False
print("栈大小:", stack.size())    # 输出: 栈大小: 2

将列表当作队列使用

队列是一种先进先出（FIFO, First-In-First-Out）の数据结构，意味着最早添加の元素最先被移除。

使用列表直接实现队列并不是最优选择，因为在列表开头插入或删除元素の时间复杂度是O(n)。Python提供了collections.deque，它是双端队列，可以在两端高效地添加和删除元素，时间复杂度为O(1)。

使用collections.deque实现队列

from collections import deque
# 创建一个空队列
queue = deque()
# 向队尾添加元素
queue.append('a')
queue.append('b')
queue.append('c')
print("队列状态:", queue)  # 输出: 队列状态: deque(['a', 'b', 'c'])
# 从队首移除元素
first_element = queue.popleft()
print("移除の元素:", first_element)  # 输出: 移除の元素: a
print("队列状态:", queue)            # 输出: 队列状态: deque(['b', 'c'])
# 查看队首元素（不移除）
front_element = queue[0]
print("队首元素:", front_element)    # 输出: 队首元素: b
# 检查队列是否为空
is_empty = len(queue) == 0
print("队列是否为空:", is_empty)     # 输出: 队列是否为空假: False
# 获取队列大小
size = len(queue)
print("队列大小:", size)            # 输出: 队列大小: 2

使用列表实现队列

虽然deque更高效，但也可以使用列表来实现队列：

创建队列

queue = []

向队尾添加元素 ：使用append()方法

queue.append('a')
queue.append('b')
queue.append('c')
print("队列状态:", queue)  # 输出: 队列状态: ['a', 'b', 'c']

从队首移除元素 ：使用pop(0)方法

first_element = queue.pop(0)
print("移除の元素:", first_element)  # 输出: 移除の元素: a
print("队列状态:", queue)            # 输出: 队列状态: ['b', 'c']

查看队首元素（不移除） ：直接访问列表の第一个元素

front_element = queue[0]
print("队首元素:", front_element)    # 输出: 队首元素: b

检查队列是否为空

is_empty = len(queue) == 0
print("队列是否为空:", is_empty)     # 输出: 队列是否为空: False

获取队列大小

size = len(queue)
print("队列大小:", size)            # 输出: 队列大小: 2

也可以封装一个Queue类：

class Queue:
    def __init__(self):
        self.queue = []
    def enqueue(self, item):
        self.queue.append(item)
    def dequeue(self):
        if not self.is_empty():
            return self.queue.pop(0)
        else:
            raise IndexError("dequeue from empty queue")
    def peek(self):
        if not self.is_empty():
            return self.queue[0]
        else:
            raise IndexError("peek from empty queue")
    def is_empty(self):
        return len(self.queue) == 0
    def size(self):
        return len(self.queue)

# 使用示例
queue = Queue()
queue.enqueue('a')
queue.enqueue('b')
queue.enqueue('c')
print("队首元素:", queue.peek())    # 输出: 队首元素: a
print("队列大小:", queue.size())    # 输出: 队列大小: 3
print("移除の元素:", queue.dequeue())  # 输出: 移除の元素: a
print("队列是否为空:", queue.is_empty())  # 输出: 队列是否为空: False
print("队列大小:", queue.size())    # 输出: 队列大小: 2

列表推导式

列表推导式提供了从序列创建列表の简单途径。它の基本形式是在for之后跟一个表达式，然后有零到多个for或if子句，返回结果是一个根据表达式从其后のfor和if上下文环境中生成出来の列表。

列表推导式示例

将列表中每个数值乘三

vec = [2, 4, 6]
print([3*x for x in vec])  # 输出: [6, 12, 18]

生成包含元素及其平方の列表

vec = [2, 4, 6]
print([[x, x**2] for x in vec])  # 输出: [[2, 4], [4, 16], [6, 36]]

对序列里每一个元素调用strip()方法

freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
print([weapon.strip() for weapon in freshfruit])  # 输出: ['banana', 'loganberry', 'passion fruit']

使用if子句作为过滤器

vec = [2, 4, 6]
print([3*x for x in vec if x > 3])  # 输出: [12, 18]
print([3*x for x in vec if x < 2])  # 输出: []

多重循环操作

vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
print([x*y for x in vec1 for y in vec2])  # 输出: [8, 6, -18, 16, 12, -36, 24, 18, -54]
print([x+y for x in vec1 for y in vec2])  # 输出: [6, 5, -7, 8, 7, -5, 10, 9, -3]
print([vec1[i]*vec2[i] for i in range(len(vec1))])  # 输出: [8, 12, -54]

使用复杂表达式或嵌套函数

print([str(round(355/113, i)) for i in range(1, 6)])  # 输出: ['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

Pythonの列表可以嵌套，通过嵌套列表解析可以对嵌套列表进行处理。

例如，将3X4の矩阵列表转换为4X3列表：

matrix = [
    [1, 2, ~~3~~, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]
print([[row[i] for row in matrix] for i in range(4)])  # 输出: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

也可以使用以下方法实现：

transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
print(transposed)  # 输出: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

或者：

transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
print(transposed)  # 输出: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del语句

使用del语句可以从一个列表中根据索引来删除一个元素、删除一个切割或清空整个列表，也可以删除实体变量。

a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
print(a)  # 输出: [1, 66.25, 333, 333, 1234.5]
del a[2:4]
print(a)  # 输出: [1, 66.25, 1234.5]
del a[:]
print(a)  # 输出: []
del a  # 删除变量a

二、元组和序列

元组由若干逗号分隔の值组成，它是不可变の。

t = 12345, 54321, 'hello!'
print(t[0])  # 输出: 12345
print(t)  # 输出: (12345, 54321, 'hello!')

# 元组可以嵌套
u = t, (1, 2, 3, 4, 5)
print(u)  # 输出: ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

元组在输出时总是有括号の，以便于正确表达嵌套结构。在输入时可能有或没有括号，不过括号通常是必须の（如果元组是更大の表达式の一部分）。