个人主页：Yang-ai-cao
系列专栏：Python学习
博学而日参省乎己，知明而行无过矣
目录
一、列表（List） 列表是Python中最常用的数据结构之一。它是一个有序的、可变的集合，可以包含任意类型的元素。
二、元组（Tuple）元组是一个有序的、不可变的集合。一旦创建，元组中的元素不能被修改。
三、集合（Set）集合是一个无序的、不可重复的元素集合。集合主要用于去重和集合运算。
四、字典（Dictionary）字典是一个无序的键值对集合。键必须是唯一的，通常是字符串，但也可以是其他不可变类型。
五、列表推导式（List Comprehension）列表推导式是一种简洁的创建列表的方式，通常用于生成新的列表。
六、字典推导式（Dictionary Comprehension）字典推导式是一种简洁的创建字典的方式。
以上我们学习了Python中常见数据结构，接下来我们基于以上基础，进行栈、队列等的学习。
七、栈（Stack）栈是一种后进先出（LIFO, Last In First Out）的数据结构。最常见的操作是压栈（push）和弹栈（pop）。
1、使用列表实现栈 在Python中，我们可以使用列表来实现栈，因为列表支持在末尾添加和删除元素。
八、 队列（Queue）队列是一种先进先出（FIFO, First In First Out）的数据结构。最常见的操作是入队（enqueue）和出队（dequeue）。
1、使用"collections.deque"实现队列虽然列表也可以用来实现队列，但"collections.deque"（双端队列）更为高效，因为它在两端的插入和删除操作都是O(1)时间复杂度。
3、双端队列（Deque）双端队列是一种可以在两端进行插入和删除操作的队列。"collections.deque"提供了这种数据结构。
4、优先队列（Priority Queue）优先队列是一种每个元素都有优先级的数据结构。出队时总是优先级最高的元素先出队。可以使用"heapq"模块实现优先队列。
九、正则表达式简介正则表达式是一种强大的字符串匹配工具，用于搜索、匹配和操作文本。它们由一系列字符和特殊符号组成，可以用于复杂的文本处理任务。
1、 Python中的正则表达式模块："re"Python提供了"re"模块来处理正则表达式。我们可以使用这个模块来执行各种正则表达式操作。
"re.match()""re.match()"从字符串的起始位置进行匹配，如果匹配成功，返回一个匹配对象，否则返回"None"。
"re.search()""re.search()"在整个字符串中搜索第一个匹配，如果匹配成功，返回一个匹配对象，否则返回"None"。
"re.findall()""re.findall()"返回字符串中所有非重叠的匹配。
"re.finditer()""re.finditer()"返回一个迭代器，包含字符串中所有非重叠的匹配对象。
"re.sub()""re.sub()"用于替换匹配的字符串。
"re.split()""re.split()"根据匹配的模式拆分字符串。
3、示例一：验证电子邮件地址以下是使用正则表达式验证电子邮件地址的示例：
4、示例二：提取URL中的域名以下是使用正则表达式提取URL中域名的示例：
在现代编程中，数据结构和正则表达式是两个核心概念，它们在处理复杂数据和高效文本处理方面发挥着至关重要的作用。无论你是初学者还是有经验的开发者，掌握这些概念都将极大地提升你的编程技能和解决问题的能力。
数据结构
~ 数据结构是组织和存储数据的方式，它们决定了数据的存取和操作效率。
~ 不同的数据结构适用于不同的应用场景，选择合适的数据结构可以显著提高程序的性能和可维护性。
一、列表（List）
列表是Python中最常用的数据结构之一。它是一个有序的、可变的集合，可以包含任意类型的元素。
1、创建列表
# 创建一个空列表
empty_list = []
# 创建一个包含元素的列表
fruits = ['apple', 'banana', 'cherry']
2、访问列表元素
# 通过索引访问元素
first_fruit = fruits[0] # 'apple'
#从0开始
3、修改列表
# 修改元素
fruits[1] = 'blueberry' # ['apple', 'blueberry', 'cherry']
# 添加元素
fruits.append('date') # ['apple', 'blueberry', 'cherry', 'date']
# 删除元素
fruits.remove('blueberry') # ['apple', 'cherry', 'date']
二、元组（Tuple）
元组是一个有序的、不可变的集合。一旦创建，元组中的元素不能被修改。
1、创建元组
# 创建一个空元组
empty_tuple = ()
# 创建一个包含元素的元组
coordinates = (10, 20)
2、访问元组元素
# 通过索引访问元素
x = coordinates[0] # 10
三、集合（Set）
集合是一个无序的、不可重复的元素集合。集合主要用于去重和集合运算。
1、创建集合
# 创建一个空集合
empty_set = set()
# 创建一个包含元素的集合
unique_numbers = {1, 2, 3, 3, 4} # {1, 2, 3, 4}
2、集合操作
# 添加元素
unique_numbers.add(5) # {1, 2, 3, 4, 5}
# 删除元素
unique_numbers.remove(3) # {1, 2, 4, 5}
# 集合运算
another_set = {4, 5, 6}
intersection = unique_numbers & another_set # {4, 5}
四、字典（Dictionary）
字典是一个无序的键值对集合。键必须是唯一的，通常是字符串，但也可以是其他不可变类型。
1、创建字典
# 创建一个空字典
empty_dict = {}
# 创建一个包含键值对的字典
person = {'name': 'Alice', 'age': 25}
2、访问和修改字典
# 访问值
name = person['name'] # 'Alice'
# 修改值
person['age'] = 26
# 添加键值对
person['city'] = 'New York'
# 删除键值对
del person['age']
五、列表推导式（List Comprehension）
列表推导式是一种简洁的创建列表的方式，通常用于生成新的列表。
示例
# 创建一个包含0到9的列表
numbers = [x for x in range(10)] # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 创建一个包含0到9的平方的列表
squares = [x**2 for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 带条件的列表推导式
even_numbers = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
六、字典推导式（Dictionary Comprehension）
字典推导式是一种简洁的创建字典的方式。
示例
# 创建一个字典，其中键是0到9，值是键的平方
squares_dict = {x: x**2 for x in range(10)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
# 带条件的字典推导式
even_squares_dict = {x: x**2 for x in range(10) if x % 2 == 0} # {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}
以上我们学习了Python中常见数据结构，接下来我们基于以上基础，进行栈、队列等的学习。
七、栈（Stack）
栈是一种后进先出（LIFO, Last In First Out）的数据结构。最常见的操作是压栈（push）和弹栈（pop）。
1、使用列表实现栈
在Python中，我们可以使用列表来实现栈，因为列表支持在末尾添加和删除元素。
# 创建一个空栈
stack = []
# 压栈（添加元素）
stack.append(1)
stack.append(2)
stack.append(3)
# 弹栈（移除并返回最后一个元素）
top_element = stack.pop() # 3
2、 栈的基本操作
# 检查栈是否为空
is_empty = len(stack) == 0
# 查看栈顶元素（不移除）
top_element = stack[-1] if not is_empty else None
八、 队列（Queue）
队列是一种先进先出（FIFO, First In First Out）的数据结构。最常见的操作是入队（enqueue）和出队（dequeue）。
1、使用"collections.deque"实现队列
虽然列表也可以用来实现队列，但"collections.deque"（双端队列）更为高效，因为它在两端的插入和删除操作都是O(1)时间复杂度。
from collections import deque
# 创建一个空队列
queue = deque()
# 入队（添加元素）
queue.append(1)
queue.append(2)
queue.append(3)
# 出队（移除并返回第一个元素）
first_element = queue.popleft() # 1
2、队列的基本操作
# 检查队列是否为空
is_empty = len(queue) == 0
# 查看队首元素（不移除）
front_element = queue[0] if not is_empty else None
3、双端队列（Deque）
双端队列是一种可以在两端进行插入和删除操作的队列。"collections.deque"提供了这种数据结构。
基本操作
from collections import deque
# 创建一个双端队列
deque_obj = deque()
# 在右端添加元素
deque_obj.append(1)
deque_obj.append(2)
# 在左端添加元素
deque_obj.appendleft(0)
# 在右端删除元素
right_element = deque_obj.pop() # 2
# 在左端删除元素
left_element = deque_obj.popleft() # 0
4、优先队列（Priority Queue）
优先队列是一种每个元素都有优先级的数据结构。出队时总是优先级最高的元素先出队。可以使用"heapq"模块实现优先队列。
import heapq
# 创建一个空优先队列
priority_queue = []
# 入队（添加元素）
heapq.heappush(priority_queue, (1, 'task1')) # (优先级, 元素)
heapq.heappush(priority_queue, (3, 'task3'))
heapq.heappush(priority_queue, (2, 'task2'))
# 出队（移除并返回优先级最高的元素）
highest_priority_task = heapq.heappop(priority_queue) # (1, 'task1')
通过以上的示例，我们可以看到如何在Python中实现和使用栈、队列、双端队列和优先队列。每种数据结构都有其独特的特点和适用场景：
- 栈：用于需要后进先出（LIFO）的场景，比如函数调用栈、撤销操作等。
- 队列：用于需要先进先出（FIFO）的场景，比如任务调度、消息队列等。
- 双端队列：提供在两端进行插入和删除操作的灵活性。
- 优先队列：用于需要按优先级处理元素的场景，比如任务调度、路径搜索等。
正则表达式
正则表达式是一种强大的文本处理工具，用于搜索、匹配和操作字符串。它们由一系列字符和特殊符号组成，可以用于解决复杂的文本处理任务。正则表达式在数据验证、格式化、解析等方面具有广泛的应用。
九、正则表达式简介
正则表达式是一种强大的字符串匹配工具，用于搜索、匹配和操作文本。它们由一系列字符和特殊符号组成，可以用于复杂的文本处理任务。
1、 Python中的正则表达式模块："re"
Python提供了"re"模块来处理正则表达式。我们可以使用这个模块来执行各种正则表达式操作。
# 导入`re`模块
import re
#匹配模式
- `.`：匹配任意单个字符（除换行符）
- `^`：匹配字符串的开头
- `$`：匹配字符串的结尾
- `*`：匹配前面的字符零次或多次
- `+`：匹配前面的字符一次或多次
- `?`：匹配前面的字符零次或一次
- `{n}`：匹配前面的字符恰好n次
- `{n,}`：匹配前面的字符至少n次
- `{n,m}`：匹配前面的字符至少n次，至多m次
- `[]`：匹配括号内的任意一个字符
- `|`：匹配左右任意一个表达式
- `()`：分组匹配2、常用函数
"re.match()"
"re.match()"从字符串的起始位置进行匹配，如果匹配成功，返回一个匹配对象，否则返回"None"。
pattern = r'^Hello'
text = 'Hello, world!'
match = re.match(pattern, text)
if match:
print("Match found:", match.group())
else:
print("No match found")
"re.search()"
"re.search()"在整个字符串中搜索第一个匹配，如果匹配成功，返回一个匹配对象，否则返回"None"。
pattern = r'world'
text = 'Hello, world!'
search = re.search(pattern, text)
if search:
print("Match found:", search.group())
else:
print("No match found")
"re.findall()"
"re.findall()"返回字符串中所有非重叠的匹配。
pattern = r'\d+'
text = 'There are 123 apples and 456 oranges.'
matches = re.findall(pattern, text)
print("All matches:", matches) # ['123', '456']
"re.finditer()"
"re.finditer()"返回一个迭代器，包含字符串中所有非重叠的匹配对象。
pattern = r'\d+'
text = 'There are 123 apples and 456 oranges.'
matches = re.finditer(pattern, text)
for match in matches:
print("Match found:", match.group())
"re.sub()"
"re.sub()"用于替换匹配的字符串。
pattern = r'apples'
replacement = 'bananas'
text = 'I like apples.'
result = re.sub(pattern, replacement, text)
print("Replaced text:", result) # 'I like bananas.'
"re.split()"
"re.split()"根据匹配的模式拆分字符串。
pattern = r'\s+'
text = 'Split this text by spaces.'
result = re.split(pattern, text)
print("Split result:", result) # ['Split', 'this', 'text', 'by', 'spaces.']
接下来鄙人会举些实际运用的例子，帮助你来理解。
3、示例一：验证电子邮件地址
以下是使用正则表达式验证电子邮件地址的示例：
import re
def validate_email(email):
pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
return re.match(pattern, email) is not None
email = 'example@example.com'
if validate_email(email):
print("Valid email address")
else:
print("Invalid email address")
4、示例二：提取URL中的域名
以下是使用正则表达式提取URL中域名的示例：
import re
def extract_domain(url):
pattern = r'https?://(www\.)?([^/]+)'
match = re.search(pattern, url)
if match:
return match.group(2)
return None
url = 'https://www.example.com/path/to/page'
domain = extract_domain(url)
print("Domain:", domain) # 'example.com'
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
