备忘录
- 2022.11.20日
pytorch 不安装cuda,cudnn 方法:
建立虚拟环境:
conda create -n xx python=3.8
conda remove -n xxx --all
pip3 install torch==1.8.2 torchvision==0.9.2 torchaudio==0.8.2 --extra-index-url https://download.pytorch.org/whl/lts/1.8/cu111
pip install torch==1.7.1+cu101 torchvision==0.8.2+cu101 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html
日语系统的更改
2022.11.22 日
class initial(object):
def __init__(self, f1 = 222):
self.f1 = f1
def pri(self):
print("hello, F1 :", self.f1)
class new(initial):
def __init__(self):
print("this print is for new function. ")
self.f1 = 33
print('before the super function : ', self.f1)
#
super(new, self).__init__()
print('after the super function : ', self.f1)
if __name__ == '__main__':
new()
# before the super function : 33
# after the super function : 222
算法模板
并查集
class UnionFind:
def __init__(self, n):
self.parent = list(range(n)) # 初始化,每个元素的父节点都是它本身
self.rank = [0] * n # 初始化,每个元素的秩都为0
def find(self, x):
if x != self.parent[x]: # 如果x不是根节点,就一直往上找
self.parent[x] = self.find(self.parent[x]) # 路径压缩
return self.parent[x]
def union(self, x, y):
root_x, root_y = self.find(x), self.find(y)
if root_x != root_y: # 如果两个元素不在同一个集合中,就进行合并
if self.rank[root_x] > self.rank[root_y]: # 以秩小的为子节点,秩大的为父节点
self.parent[root_y] = root_x
elif self.rank[root_x] < self.rank[root_y]:
self.parent[root_x] = root_y
else: # 如果秩相等,则随便选一个作为父节点,并把秩加1
self.parent[root_y] = root_x
self.rank[root_x] += 1
拓扑排序模板
from collections import deque
def topo_sort(graph):
# 统计每个节点的入度
in_degrees = {node: 0 for node in graph}
for node in graph:
for neighbor in graph[node]:
in_degrees[neighbor] += 1
# 将入度为 0 的节点加入队列
queue = deque([node for node in graph if in_degrees[node] == 0])
# 依次取出队列中的节点,并将其邻居的入度减 1
result = []
while queue:
node = queue.popleft()
result.append(node)
for neighbor in graph[node]:
in_degrees[neighbor] -= 1
if in_degrees[neighbor] == 0:
queue.append(neighbor)
# 如果图中有环,则无法完成拓扑排序
if len(result) != len(graph):
return None
else:
return result
两个字符串的公共最长子序列
dp = [["" for _ in range(n + 1)] for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if str1[i-1] == str2[j-1]:
dp[i][j] = dp[i-1][j-1] + str1[i-1]
else:
if len(dp[i-1][j]) > len(dp[i][j-1]):
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = dp[i][j-1]
LCS = dp[m][n]
桶排序
def bucket_sort(arr):
# 找到最大值和最小值
max_val, min_val = max(arr), min(arr)
# 桶的数量和范围
bucket_range = (max_val - min_val) / len(arr)
bucket_size = len(arr) + 1
# 创建桶
buckets = [[] for _ in range(bucket_size)]
# 将元素放入桶中
for num in arr:
index = int((num - min_val) / bucket_range)
buckets[index].append(num)
# 对每个桶进行排序
for bucket in buckets:
bucket.sort()
# 将桶中的元素按顺序合并起来
sorted_arr = []
for bucket in buckets:
sorted_arr.extend(bucket)
return sorted_arr
01 背包模板
def test_2_wei_bag_problem1(bag_size, weight, value) -> int:
rows, cols = len(weight), bag_size + 1
dp = [[0 for _ in range(cols)] for _ in range(rows)]
# 初始化dp数组.
for i in range(rows):
dp[i][0] = 0
first_item_weight, first_item_value = weight[0], value[0]
for j in range(1, cols):
if first_item_weight <= j:
dp[0][j] = first_item_value
# 更新dp数组: 先遍历物品, 再遍历背包.
for i in range(1, len(weight)):
cur_weight, cur_val = weight[i], value[i]
for j in range(1, cols):
if cur_weight > j: # 说明背包装不下当前物品.
dp[i][j] = dp[i - 1][j] # 所以不装当前物品.
else:
# 定义dp数组: dp[i][j] 前i个物品里,放进容量为j的背包,价值总和最大是多少。
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight]+ cur_val)
print(dp)
if __name__ == "__main__":
bag_size = 4
weight = [1, 3, 4]
value = [15, 20, 30]
test_2_wei_bag_problem1(bag_size, weight, value)
区间DP 问题
方法1:
for (int i = n; i >= 1; --i) {
for (int j = i + 1; j <= n; ++j) {
for (int k = i; k < j; ++k) {
dp[i,j] = max/min(dp[i,j], dp[i,k] + dp[k+1, j] + cost)
}
}
}
方法2 :
for (int len = 2; len <= n; ++len) {
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
for (int k = i; k < j; ++k) {
dp[i,j] = max/min(dp[i,j], dp[i,k] + dp[k+1, j] + cost)
}
}
}
单调栈模板
def monotonic_stack(arr):
stack = []
result = []
for i in range(len(arr)):
while stack and stack[-1] < arr[i]:
stack.pop()
stack.append(arr[i])
result.append(stack[0]) # 根据具体题目需求修改结果
return result
其中,arr
是需要处理的序列,stack
是维护单调栈的栈,result
是结果数组。
在单调栈中,通常需要维护一个单调递增或单调递减的栈。当新元素进入栈时,如果该元素比栈顶元素大(或小),则一直弹出栈顶元素,直到栈为空或新元素比栈顶元素小(或大),此时将新元素压入栈中。
单调栈通常用于处理一些求解 “下一个更大元素
”、“下一个更小元素
” 等问题。具体实现时,可以根据问题的具体要求,修改代码中的 result.append()
语句。
论文工具
jupyter notebook 显示多个kernel
conda activate my-conda-env # this is the environment for your project and code
conda install ipykernel
conda deactivate
conda activate base # could be also some other environment
conda install nb_conda_kernels
jupyter notebook
只要在每个环境中安装ipykernel
,然后再基础环境中安装 nb_conda_kernels
即可。
自动补全
安装 nbextensions
安装:pip install jupyter_contrib_nbextensions -i https://pypi.mirrors.ustc.edu.cn/simple
激活:jupyter contrib nbextension install --user
安装 nbextensions_configurator
安装:pip install jupyter_nbextensions_configurator
激活:jupyter nbextensions_configurator enable --user
风格
pip install jupyterthemes
jt -t onedork
jt -t grade3 -fs 13 # 最适合
其他的命令:https://www.cnblogs.com/ikventure/p/15192158.html
jupter lab 安装:
pip install jupyterlab
代码补全:
pip install jupyter-lsp
pip install python-lsp-server[all]
启动jupyter lab,在插件中搜索lsp,点击@krassowski/jupyterlab-lsp下的install安装
setting 按钮 开启自动提示(Hinterland mode)
代码格式化:
$ pip install jupyterlab_code_formatter black isort