当前位置：首页 > news >正文

Python基础知识归纳总结

news 来源：原创 2024/9/29 23:26:39

一、线性表

总结

二、栈

三、队列

四、哈希表

五、字符串

六、正则表达式

综合示例

一、线性表

线性表（通常用列表表示）是一种按线性顺序存储元素的数据结构。

插入元素 (append, insert)
删除元素 (remove, pop)
查找元素 (index)
更新元素 (直接索引访问)
遍历元素 (for循环)
检查元素存在 (in运算符)
获取长度 (len)

插入元素

append: 在列表末尾添加一个元素。

1
lst = [1, 2, 3]

2
lst.append(4)

3
print(lst) # 输出: [1, 2, 3, 4]
返回值：None，操作是原地修改列表。
insert: 在指定位置插入一个元素。

1
lst = [1, 2, 3]

2
lst.insert(1, 9)

3
print(lst) # 输出: [1, 9, 2, 3]
返回值：None，操作是原地修改列表。

删除元素

remove: 删除第一个匹配的元素。

1
lst = [1, 2, 3, 2]

2
lst.remove(2)

3
print(lst) # 输出: [1, 3, 2]
返回值：None，操作是原地修改列表。如果元素不存在，会引发ValueError。
pop: 删除并返回指定位置的元素，默认删除最后一个元素。

1
lst = [1, 2, 3]

2
removed_element = lst.pop()

3
print(lst) # 输出: [1, 2]

4
print(removed_element) # 输出: 3
返回值：被删除的元素。如果列表为空，调用pop会引发IndexError。

查找元素

index: 返回第一个匹配元素的索引。

1
lst = [1, 2, 3]

2
idx = lst.index(2)

3
print(idx) # 输出: 1
返回值：匹配元素的索引。如果元素不存在，会引发ValueError。

更新元素

直接索引访问：通过索引更新元素。

1
lst = [1, 2, 3]

2
lst[1] = 9

3
print(lst) # 输出: [1, 9, 3]
返回值：None，操作是原地修改列表。

遍历元素

使用for循环遍历列表中的元素。

1
lst = [1, 2, 3]

2
for elem in lst:

3
print(elem)
返回值：None，只用于遍历和访问元素。

检查元素存在

使用in运算符检查元素是否存在于列表中。

1
lst = [1, 2, 3]

2
is_in_list = 2 in lst

3
print(is_in_list) # 输出: True
返回值：布尔值，表示元素是否存在。

获取长度

使用len函数获取列表长度。

1
lst = [1, 2, 3]

2
length = len(lst)

3
print(length) # 输出: 3
返回值：整数，表示列表的长度。

总结

以下是一个包含所有操作的示例代码：

`1`	`lst = [1, 2, 3]`
`2`
`3`	`# 插入元素`
`4`	`lst.append(4) # 返回值: None`
`5`	`lst.insert(1, 9) # 返回值: None`
`6`	`print(lst) # 输出: [1, 9, 2, 3, 4]`
`7`
`8`	`# 删除元素`
`9`	`lst.remove(2) # 返回值: None`
`10`	`print(lst) # 输出: [1, 9, 3, 4]`
`11`	`removed_element = lst.pop() # 返回值: 4`
`12`	`print(lst) # 输出: [1, 9, 3]`
`13`	`print(removed_element) # 输出: 4`
`14`
`15`	`# 查找元素`
`16`	`idx = lst.index(9) # 返回值: 1`
`17`	`print(idx) # 输出: 1`
`18`
`19`	`# 更新元素`
`20`	`lst[1] = 7 # 返回值: None`
`21`	`print(lst) # 输出: [1, 7, 3]`
`22`
`23`	`# 遍历元素`
`24`	`for elem in lst:`
`25`	`print(elem)`
`26`
`27`	`# 检查元素存在`
`28`	`is_in_list = 2 in lst # 返回值: False`
`29`	`print(is_in_list) # 输出: False`
`30`
`31`	`# 获取长度`
`32`	`length = len(lst) # 返回值: 3`
`33`	`print(length) # 输出: 3`

好的，下面是栈、队列和哈希表的基础操作、其返回值及如何返回的详细介绍。

二、栈

栈（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构。

基础操作及返回值

压栈（push）
出栈（pop）
查看栈顶元素（peek）
检查栈是否为空（is_empty）

栈的操作示例（使用Python列表模拟）：

`1`	`# 初始化栈`
`2`	`stack = []`
`3`
`4`	`# 压栈`
`5`	`stack.append(1) # 返回值: None`
`6`	`stack.append(2) # 返回值: None`
`7`	`stack.append(3) # 返回值: None`
`8`	`print(stack) # 输出: [1, 2, 3]`
`9`
`10`	`# 出栈`
`11`	`top_element = stack.pop() # 返回值: 3`
`12`	`print(top_element) # 输出: 3`
`13`	`print(stack) # 输出: [1, 2]`
`14`
`15`	`# 查看栈顶元素`
`16`	`top_element = stack[-1] # 返回值: 2`
`17`	`print(top_element) # 输出: 2`
`18`
`19`	`# 检查栈是否为空`
`20`	`is_empty = len(stack) == 0 # 返回值: False`
`21`	`print(is_empty) # 输出: False`

三、队列

队列（Queue）是一种先进先出（FIFO，First In First Out）的数据结构。

基础操作及返回值

入队（enqueue）
出队（dequeue）
查看队头元素（peek）
检查队列是否为空（is_empty）

队列的操作示例（使用Python的collections.deque）：

`1`	`from collections import deque`
`2`
`3`	`# 初始化队列`
`4`	`queue = deque()`
`5`
`6`	`# 入队`
`7`	`queue.append(1) # 返回值: None`
`8`	`queue.append(2) # 返回值: None`
`9`	`queue.append(3) # 返回值: None`
`10`	`print(queue) # 输出: deque([1, 2, 3])`
`11`
`12`	`# 出队`
`13`	`front_element = queue.popleft() # 返回值: 1`
`14`	`print(front_element) # 输出: 1`
`15`	`print(queue) # 输出: deque([2, 3])`
`16`
`17`	`# 查看队头元素`
`18`	`front_element = queue[0] # 返回值: 2`
`19`	`print(front_element) # 输出: 2`
`20`
`21`	`# 检查队列是否为空`
`22`	`is_empty = len(queue) == 0 # 返回值: False`
`23`	`print(is_empty) # 输出: False`

四、哈希表

哈希表（Hash Table）是一种通过键（Key）直接访问值（Value）的数据结构。在Python中，哈希表由dict（字典）来实现。

基础操作及返回值

插入/更新元素（setitem）
删除元素（delitem）
查找元素（getitem）
检查键是否存在（contains）
遍历元素（items）

哈希表的操作示例：

`1`	`# 初始化哈希表`
`2`	`hash_table = {`
`3`	`"apple": 3,`
`4`	`"banana": 5,`
`5`	`"cherry": 7`
`6`	`}`
`7`
`8`	`# 插入/更新元素`
`9`	`hash_table["date"] = 9 # 返回值: None`
`10`	`hash_table["banana"] = 6 # 返回值: None`
`11`	`print(hash_table) # 输出: {'apple': 3, 'banana': 6, 'cherry': 7, 'date': 9}`
`12`
`13`	`# 删除元素`
`14`	`del hash_table["cherry"] # 返回值: None`
`15`	`print(hash_table) # 输出: {'apple': 3, 'banana': 6, 'date': 9}`
`16`
`17`	`# 查找元素`
`18`	`value = hash_table.get("apple") # 返回值: 3`
`19`	`print(value) # 输出: 3`
`20`
`21`	`# 检查键是否存在`
`22`	`key_exists = "banana" in hash_table # 返回值: True`
`23`	`print(key_exists) # 输出: True`
`24`
`25`	`# 遍历元素`
`26`	`for key, value in hash_table.items():`
`27`	`print(f"Key: {key}, Value: {value}")`
`28`
`29`	`# 获取所有键`
`30`	`keys = hash_table.keys() # 返回值: dict_keys(['apple', 'banana', 'date'])`
`31`	`print(keys) # 输出: dict_keys(['apple', 'banana', 'date'])`
`32`
`33`	`# 获取所有值`
`34`	`values = hash_table.values() # 返回值: dict_values([3, 6, 9])`
`35`	`print(values) # 输出: dict_values([3, 6, 9])`

五、字符串

拼接

使用 + 运算符或 join 方法。

`1`	`# 使用 + 运算符`
`2`	`str1 = "Hello"`
`3`	`str2 = "World"`
`4`	`result = str1 + " " + str2`
`5`	`print(result) # 输出: Hello World`
`6`
`7`	`# 使用 join 方法`
`8`	`words = ["Hello", "World"]`
`9`	`result = " ".join(words)`
`10`	`print(result) # 输出: Hello World`

查找

使用 find 或 index 方法。

`1`	`text = "Hello, World!"`
`2`	`position = text.find("World")`
`3`	`print(position) # 输出: 7`
`4`
`5`	`position = text.index("World")`
`6`	`print(position) # 输出: 7`

替换

使用 replace 方法。

`1`	`text = "Hello, World!"`
`2`	`new_text = text.replace("World", "there")`
`3`	`print(new_text) # 输出: Hello, there!`

分割

使用 split 方法。

`1`	`text = "apple,banana,cherry"`
`2`	`fruits = text.split(",")`
`3`	`print(fruits) # 输出: ['apple', 'banana', 'cherry']`

去除空白

使用 strip, lstrip, rstrip 方法。

`1`	`text = " Hello, World! "`
`2`	`stripped_text = text.strip()`
`3`	`print(stripped_text) # 输出: Hello, World!`

大小写转换

使用 upper, lower, capitalize, title, swapcase 方法。

`1`	`text = "hello, world!"`
`2`	`print(text.upper()) # 输出: HELLO, WORLD!`
`3`	`print(text.lower()) # 输出: hello, world!`
`4`	`print(text.capitalize()) # 输出: Hello, world!`
`5`	`print(text.title()) # 输出: Hello, World!`
`6`	`print(text.swapcase()) # 输出: HELLO, WORLD!`

检查前缀/后缀

使用 startswith, endswith 方法。

`1`	`text = "Hello, World!"`
`2`	`print(text.startswith("Hello")) # 输出: True`
`3`	`print(text.endswith("World!")) # 输出: True`

格式化

使用 format 方法或 f-string（Python 3.6+）。

`1`	`# 使用 format 方法`
`2`	`name = "Alice"`
`3`	`age = 30`
`4`	`text = "My name is {} and I am {} years old.".format(name, age)`
`5`	`print(text) # 输出: My name is Alice and I am 30 years old.`
`6`
`7`	`# 使用 f-string`
`8`	`text = f"My name is {name} and I am {age} years old."`
`9`	`print(text) # 输出: My name is Alice and I am 30 years old.`

六、正则表达式

正则表达式用于模式匹配和文本处理。Python的 re 模块提供了正则表达式支持。

常用正则表达式操作

匹配（match, search）
查找所有（findall）
替换（sub）
分割（split）
编译正则表达式（compile）

匹配

使用 match 和 search 方法。

`1`	`import re`
`2`
`3`	`pattern = r"\d+"`
`4`
`5`	`# match 从字符串开始位置匹配`
`6`	`result = re.match(pattern, "123abc")`
`7`	`if result:`
`8`	`print(result.group()) # 输出: 123`
`9`
`10`	`# search 在整个字符串中搜索`
`11`	`result = re.search(pattern, "abc123")`
`12`	`if result:`
`13`	`print(result.group()) # 输出: 123`

查找所有

使用 findall 方法。

`1`	`text = "abc123xyz456"`
`2`	`pattern = r"\d+"`
`3`	`matches = re.findall(pattern, text)`
`4`	`print(matches) # 输出: ['123', '456']`

替换

使用 sub 方法。

`1`	`text = "abc123xyz456"`
`2`	`pattern = r"\d+"`
`3`	`new_text = re.sub(pattern, "#", text)`
`4`	`print(new_text) # 输出: abc#xyz#`

分割

使用 split 方法。

`1`	`text = "one1two2three3four"`
`2`	`pattern = r"\d"`
`3`	`parts = re.split(pattern, text)`
`4`	`print(parts) # 输出: ['one', 'two', 'three', 'four']`

编译正则表达式

使用 compile 方法。

`1`	`pattern = re.compile(r"\d+")`
`2`	`text = "abc123xyz456"`
`3`	`matches = pattern.findall(text)`
`4`	`print(matches) # 输出: ['123', '456']`

综合示例

`1`	`import re`
`2`
`3`	`# 字符串操作`
`4`	`text = " Hello, World! "`
`5`	`text = text.strip().replace("World", "there").upper()`
`6`	`print(text) # 输出: HELLO, THERE!`
`7`
`8`	`# 正则表达式操作`
`9`	`pattern = re.compile(r"\d+")`
`10`	`text = "abc123xyz456"`
`11`	`matches = pattern.findall(text)`
`12`	`print(matches) # 输出: ['123', '456']`
`13`
`14`	`# 替换和分割`
`15`	`new_text = re.sub(r"\d+", "#", text)`
`16`	`print(new_text) # 输出: abc#xyz#`
`17`	`parts = re.split(r"\d", text)`
`18`	`print(parts) # 输出: ['abc', '', '', 'xyz', '', '', '']`