全面的 python 数据结构备忘单
目录
- 列表
- 元组
- 套装
- 词典
- 弦乐
- 数组
- 堆栈
- 排队
- 链接列表
- 树
- 堆
- 图表
- 高级数据结构
列表
列表是有序的、可变的序列。
创建
empty_list = []
list_with_items = [1, 2, 3]
list_from_iterable = list("abc")
list_comprehension = [x for x in range(10) if x % 2 == 0]
常用操作
# accessing elements first_item = my_list[0] last_item = my_list[-1] # slicing subset = my_list[1:4] # elements 1 to 3 reversed_list = my_list[::-1] # adding elements my_list.append(4) # add to end my_list.insert(0, 0) # insert at specific index my_list.extend([5, 6, 7]) # add multiple elements # removing elements removed_item = my_list.pop() # remove and return last item my_list.remove(3) # remove first occurrence of 3 del my_list[0] # remove item at index 0 # other operations length = len(my_list) index = my_list.index(4) # find index of first occurrence of 4 count = my_list.count(2) # count occurrences of 2 my_list.sort() # sort in place sorted_list = sorted(my_list) # return new sorted list my_list.reverse() # reverse in place
先进技术
# list as stack stack = [1, 2, 3] stack.append(4) # push top_item = stack.pop() # pop # list as queue (not efficient, use collections.deque instead) queue = [1, 2, 3] queue.append(4) # enqueue first_item = queue.pop(0) # dequeue # nested lists matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] flattened = [item for sublist in matrix for item in sublist] # list multiplication repeated_list = [0] * 5 # [0, 0, 0, 0, 0] # list unpacking a, *b, c = [1, 2, 3, 4, 5] # a=1, b=[2, 3, 4], c=5
元组
元组是有序的、不可变的序列。
创建
empty_tuple = ()
single_item_tuple = (1,) # note the comma
tuple_with_items = (1, 2, 3)
tuple_from_iterable = tuple("abc")
常用操作
# accessing elements (similar to lists) first_item = my_tuple[0] last_item = my_tuple[-1] # slicing (similar to lists) subset = my_tuple[1:4] # other operations length = len(my_tuple) index = my_tuple.index(2) count = my_tuple.count(3) # tuple unpacking a, b, c = (1, 2, 3)
先进技术
# named tuples
from collections import namedtuple
point = namedtuple('point', ['x', 'y'])
p = point(11, y=22)
print(p.x, p.y)
# tuple as dictionary keys (immutable, so allowed)
dict_with_tuple_keys = {(1, 2): 'value'}
套
集合是独特元素的无序集合。
创建
empty_set = set()
set_with_items = {1, 2, 3}
set_from_iterable = set([1, 2, 2, 3, 3]) # {1, 2, 3}
set_comprehension = {x for x in range(10) if x % 2 == 0}
常用操作
# adding elements my_set.add(4) my_set.update([5, 6, 7]) # removing elements my_set.remove(3) # raises keyerror if not found my_set.discard(3) # no error if not found popped_item = my_set.pop() # remove and return an arbitrary element # other operations length = len(my_set) is_member = 2 in my_set # set operations union = set1 | set2 intersection = set1 & set2 difference = set1 - set2 symmetric_difference = set1 ^ set2
先进技术
# frozen sets (immutable)
frozen = frozenset([1, 2, 3])
# set comparisons
is_subset = set1 <= set2
is_superset = set1 >= set2
is_disjoint = set1.isdisjoint(set2)
# set of sets (requires frozenset)
set_of_sets = {frozenset([1, 2]), frozenset([3, 4])}
词典
字典是键值对的可变映射。
立即学习“Python免费学习笔记（深入）”；
创建
empty_dict = {}
dict_with_items = {'a': 1, 'b': 2, 'c': 3}
dict_from_tuples = dict([('a', 1), ('b', 2), ('c', 3)])
dict_comprehension = {x: x**2 for x in range(5)}
常用操作
# accessing elements
value = my_dict['key']
value = my_dict.get('key', default_value)
# adding/updating elements
my_dict['new_key'] = value
my_dict.update({'key1': value1, 'key2': value2})
# removing elements
del my_dict['key']
popped_value = my_dict.pop('key', default_value)
last_item = my_dict.popitem() # remove and return an arbitrary key-value pair
# other operations
keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()
length = len(my_dict)
is_key_present = 'key' in my_dict
先进技术
# dictionary unpacking
merged_dict = {**dict1, **dict2}
# default dictionaries
from collections import defaultdict
dd = defaultdict(list)
dd['key'].append(1) # no keyerror
# ordered dictionaries (python 3.7+ dictionaries are ordered by default)
from collections import ordereddict
od = ordereddict([('a', 1), ('b', 2), ('c', 3)])
# counter
from collections import counter
c = counter(['a', 'b', 'c', 'a', 'b', 'b'])
print(c.most_common(2)) # [('b', 3), ('a', 2)]
弦乐
字符串是不可变的 unicode 字符序列。
创建
single_quotes = 'hello'
double_quotes = "world"
triple_quotes = '''multiline
string'''
raw_string = r'c:\users\name'
f_string = f"the answer is {40 + 2}"
常用操作
# accessing characters
first_char = my_string[0]
last_char = my_string[-1]
# slicing (similar to lists)
substring = my_string[1:4]
# string methods
upper_case = my_string.upper()
lower_case = my_string.lower()
stripped = my_string.strip()
split_list = my_string.split(',')
joined = ', '.join(['a', 'b', 'c'])
# other operations
length = len(my_string)
is_substring = 'sub' in my_string
char_count = my_string.count('a')
先进技术
# string formatting
formatted = "{} {}".format("hello", "world")
formatted = "%s %s" % ("hello", "world")
# regular expressions
import re
pattern = r'\d+'
matches = re.findall(pattern, my_string)
# unicode handling
unicode_string = u'\u0061\u0062\u0063'
数组
数组是紧凑的数值序列（来自数组模块）。
Ztoy网络商铺多用户版
下载
在原版的基础上做了一下修正：增加1st在线支付功能与论坛用户数据结合，vip也可与论坛相关，增加互动性vip会员的全面修正评论没有提交正文的问题特价商品的调用连接问题删掉了2个木马文件去掉了一个后门补了SQL注入补了一个过滤漏洞浮动价不能删除的问题不能够搜索问题收藏时放入购物车时出错点放入购物车弹出2个窗口修正定单不能删除问题VIP出错问题主题添加问题商家注册页导航连接问题添加了导航FLASH源文
创建和使用
from array import array
int_array = array('i', [1, 2, 3, 4, 5])
float_array = array('f', (1.0, 1.5, 2.0, 2.5))
# operations (similar to lists)
int_array.append(6)
int_array.extend([7, 8, 9])
popped_value = int_array.pop()
堆栈
堆栈可以使用lists或collections.deque来实现。
实施和使用
# using list stack = [] stack.append(1) # push stack.append(2) top_item = stack.pop() # pop # using deque (more efficient) from collections import deque stack = deque() stack.append(1) # push stack.append(2) top_item = stack.pop() # pop
队列
队列可以使用collections.deque或queue.queue来实现。
实施和使用
# using deque from collections import deque queue = deque() queue.append(1) # enqueue queue.append(2) first_item = queue.popleft() # dequeue # using queue (thread-safe) from queue import queue q = queue() q.put(1) # enqueue q.put(2) first_item = q.get() # dequeue
链表
python没有内置链表，但可以实现。
实施简单
class node:
def __init__(self, data):
self.data = data
self.next = none
class linkedlist:
def __init__(self):
self.head = none
def append(self, data):
if not self.head:
self.head = node(data)
return
current = self.head
while current.next:
current = current.next
current.next = node(data)
树木
树可以使用自定义类来实现。
简单的二叉树实现
class treenode:
def __init__(self, value):
self.value = value
self.left = none
self.right = none
class binarytree:
def __init__(self, root):
self.root = treenode(root)
def insert(self, value):
self._insert_recursive(self.root, value)
def _insert_recursive(self, node, value):
if value < node.value:
if node.left is none:
node.left = treenode(value)
else:
self._insert_recursive(node.left, value)
else:
if node.right is none:
node.right = treenode(value)
else:
self._insert_recursive(node.right, value)
堆
堆可以使用 heapq 模块来实现。
用法
import heapq # create a heap heap = [] heapq.heappush(heap, 3) heapq.heappush(heap, 1) heapq.heappush(heap, 4) # pop smallest item smallest = heapq.heappop(heap) # create a heap from a list my_list = [3, 1, 4, 1, 5, 9] heapq.heapify(my_list)
图表
图可以使用字典来实现。
实施简单
class graph:
def __init__(self):
self.graph = {}
def add_edge(self, u, v):
if u not in self.graph:
self.graph[u] = []
self.graph[u].append(v)
def bfs(self, start):
visited = set()
queue = [start]
visited.add(start)
while queue:
vertex = queue.pop(0)
print(vertex, end=' ')
for neighbor in self.graph.get(vertex, []):
if neighbor not in visited:
visited.add(neighbor)
queue.append(neighbor)
高级数据结构
特里树
class trienode:
def __init__(self):
self.children = {}
self.is_end = false
class trie:
def __init__(self):
self.root = trienode()
def insert(self, word):
node = self.root
for char in word:
if char not in node.children:
node.children[char] = trienode()
node = node.children[char]
node.is_end = true
def search(self, word):
node = self.root
for char in word:
if char not in node.children:
return false
node = node.children[char]
return node.is_end
不相交集（并查集）
class DisjointSet:
def __init__(self, vertices):
self.parent = {v: v for v in vertices}
self.rank = {v: 0 for v in vertices}
def find(self, item):
if self.parent[item] != item:
self.parent[item] = self.find(self.parent[item])
return self.parent[item]
def union(self, x, y):
xroot = self.find(x)
yroot = self.find(y)
if self.rank[xroot] < self.rank[yroot]:
self.parent[xroot] = yroot
elif self.rank[xroot] > self.rank[yroot]:
self.parent[yroot] = xroot
else:
self.parent[yroot] = xroot
self.rank[xroot] += 1
这份全面的备忘单涵盖了广泛的 python 数据结构，从基本的内置类型到更高级的自定义实现。每个部分都包含创建方法、常用操作以及适用的高级技巧。
0
