# method 1
import IPython
IPython.embed()
# method 2
import pdb
pdb.set_trace()
wget --user-agent=Lynx https://arxiv.org/pdf/2103.09460.pdf
for key in dict.keys()
for value in dict.values()
for key, value in dict.items()
from queue import Queue
q = Queue()
q.put(node) # in
q.get() # out
import collections
q = collections.deque()
q.append() # in
q.popleft() # out
Python2中/除法时，两个int相除为整除法，返回向下取整的整数值；参数中若有float变量则进行正常的float除法，返回真float值。Python3中/除法全返回float真值。
# Python2 Python3
print(3/2) # 1 1.5
print(-3/2) # -2 -1.5
print(3/2.0) # 1.5 1.5
print(-3.0/2) # -1.5 -1.5
Python2和Python3中//除法都寓意整除，均为：两个int相除时返回向下取整的整数值，参数中若有float变量则返回向下取整的整数的float形。
# Python2 Python3
print(3//2) # 1 1
print(-3//2) # -2 -2
print(3//2.0) # 1.0 1.0
print(-3.0//2) # -2.0 -2.0
[]或list创建，支持增删查改、索引等操作。| 序号 | 函数 | 方法 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加单个对象 |
| 2 | list.extend(seq) | 在列表末尾添加另一个序列内部的所有内容 |
| 3 | list.insert(index, obj) | 将对象插入列表特定位置 |
| 4 | list.pop([index=-1]) | 移除列表中的一个元素(默认最后一个)，并返回该元素的值 |
| 5 | list.remove(obj) | 移除列表中某值的第一个匹配项 |
| 6 | list.index(value) | 列表中第一个匹配某值的索引位置 |
| 7 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 8 | list.sort(key=None, reverse=False) | 列表排序 |
| 9 | list.reverse() | 反向列表中元素 |
| 10 | list.copy() | 复制列表 |
| 11 | list.clear() | 清空列表 |
()或tuple创建，支持增删查、索引等操作。功能均近似于列表，甚至常用操作函数也与列表相同，区别仅在于不可改变元组内部的值。{}或dict创建键值对，支持增删查改等操作。需注意键只可出现一次，若出现多次仅记住最后一次输入；键不可变，故键值需采用数字、字符串和元组，不可使用列表作为键。| 序号 | 函数 | 方法 |
|---|---|---|
| 1 | dict.clear() | 清空字典 |
| 2 | dict.items() | 返回可遍历的(键，值)元组数组 |
| 3 | dict.keys() | 返回可遍历的键数组(而非列表) |
| 4 | dict.values() | 返回可遍历的值数组(而非列表) |
| 5 | dict.update(dict2) | 将dict2的键值对添加到现有dict中 |
| 6 | dict.get(key, default=None) | 返回键对应的值，若不存在则返回default |
| 7 | dict.setdefault(key, default=None) | 返回键对应的值，若不存在则添加为default |
| 8 | dict.fromleys(keys[, value]) | 以keys作为键创建字典，所有键均赋值为value |
| 9 | dict.pop(key[, default]) | 删除键key对应的键值对并将值返回，若不存在则需给定default值并返回default值 |
| 10 | dict.popitem() | 删除并返回最后一对键值对 |
| 11 | del dict[key] | 删除键key对应的键值对 |
{}或set创建，支持增删操作。集合为不重复元素无序集，内部元素需为不可变数据类型(例如数字、字符串、元组等，不支持列表)。| 序号 | 函数 | 方法 |
|---|---|---|
| 1 | set1 - set2 / set1.difference(set2) | 返回set1包含而set2不包含的元素 |
| 2 | set1.difference_update(set2,...) | 将set1变为set1包含而set2不包含的元素 |
| 3 | set1 | set2 / set1.union(set2,...) | 返回并集 |
| 4 | set1 & set2 / set1.intersection(set2,...) | 返回交集 |
| 5 | set1.intersection_update(set2,...) | 将set1变为交集 |
| 6 | set1 ^ set2 / set1.symmetric_difference(set2) | 只单独存在set1或set2内的元素 |
| 7 | set1.symmetric_difference_update(set2) | 将set1变为只单独存在set1或set2内的元素 |
| 8 | set.add(x) | 添加元素 |
| 9 | set.update(x) | 添加若干个序列内部所有的内容(可为列表、元组、字典等，字典时添加键) |
| 10 | set.remove(x) | 移除元素，若不存在则报错 |
| 11 | set.discard(x) | 移除元素，若不存在不报错 |
| 12 | set.clear() | 清空集合 |
| 13 | set1.isdisjoint(set2) | 返回两个集合是否含有相同元素 |
| 14 | set1.issubset(set2) | 返回set1为set2的子集 |
| 15 | set1.issuperset(set2) | 返回set2为set1的子集 |
以上部分内容参考runoob.com。
Python2中默认的编码方式是ASCII；Python3中默认的编码方式是Unicode字符集+UTF-8编码规则。Python2中还有Unicode字符串和非Unicode字符串混用的情况，例如用unicode()将对象转换成Unicode字符串，用str()将对象转换成非Unicode字符串；而Python3只有Unicode字符串，只剩下str()函数实现所有的功能。
Python2中字节字符串是str，文本字符串是Unicode；Python3中字节字符串是bytes，文本字符串是str。
字符串都是以Unicode字符进行存储的。
Python2在导入时，先在当前目录搜索，再在Python搜索路径中搜索(sys.path)；Python3会直接在Python的搜索路径中搜索，所以有些情况下需使用from . import xx进行重名包的导入。
迭代(iterable)是访问集合元素的一种方式，迭代器(iterator)是一个可以记住遍历位置的对象。迭代器对象从集合的第一个元素开始访问，每次访问一个元素，在所有的元素均被访问后结束。迭代器只能往前不会后退。
迭代器都是可迭代的，但不是所有可迭代的对象都是迭代器。
可用isinstance(something, Iterable)语句来判断具体对象是否为可迭代的，能作用于for循环的对象都是可迭代的，我们常见的列表list、元组tuple、集合set、字典dict、字符串都是可迭代的，一些自定义类也是可迭代的。
可用isinstance(something, Iterator)语句来判断具体对象是否为迭代器，能作用于next()函数的对象都是迭代器，上述提到的列表list、元组tuple、集合set、字典dict、字符串均不是迭代器，可在自定义类中实现__iter__()与__next__()方法来创建迭代器。
我们常用iter()方法从可迭代对象构建迭代器，使用next()或常规for语句使迭代器遍历下一个元素。迭代器是一个惰性的数据流，我们并不知道迭代器的长度，只在调用next函数时才去计算并返回下一个数据，直到没有数据时抛出StopIteration错误。
a = {1, 2, 3, 4}
iteration = iter(a)
for i in range(len(a)):
print(next(iteration))
for i in iteration:
print(i)
注：我们常对迭代器使用tqdm(iterator)方法来显示进度。
使用了yield的Python函数被称为生成器(generator)，生成器一定是一个迭代器。在生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，同时返回yield的值, 并在下一次执行next()方法时从当前位置继续运行。
a = [1,2,3]
b = (4,5,6)
c = [7,8,9]
d = list(zip(a, b, c))
print(d) # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
raise BaseException或raise BaseException("GUGU")形式抛出自定义异常。try:
import mymodule
except:
# except ImportError:
# except ImportError as e:
# except (ImportError, RuntimeError) as e:
print("An Error.")
Python中可通过sorted()函数对任何可迭代对象进行排序，函数返回一个新的排序后数据；具体对于列表这种数据结构，可使用list.sort()方法对原列表进行in-place排序，此方法返回None以防止混淆。
可通过形参key来制定在列表元素上进行调用的函数，可通过reverse参数制定是否进行降序排序。
具体使用可参照下例，对同学的成绩进行降序排列，优先看得分，随后看等级：
student_tuples = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10), ('kate', 'A', 12)]
print(sorted(student_tuples, key=lambda student: (student[2], -ord(student[1])), reverse=True))
A电脑在准备传输文件的路径下使用python -m http.server创建web sever，B电脑用浏览器打开A电脑的ip地址加上:8000，例如127.0.0.1:8000，即可点击并下载相应文件。
，用于解决多重继承问题。
在类的继承中，如果重定义某个方法，该方法会覆盖父类的同名方法，但有时我们希望能同时实现父类的功能，super()函数就是用于调用父类功能的一个方法，常用于解决多重继承问题(eg多重继承时，希望祖父的__init__方法只被执行一次)。
class A(object):
def add(self, x):
print(x + 1)
class B(A):
def add(self, x):
super(B, self).add(x) # Python 2
super().add() # Python 3
更深入地，在多重继承时，Python遵循类的方法解析顺序(Method Resolution Order，MRO)列表进行解析，详细内容可参照博客。
在Pytorch定义模型时常常继承torch.nn.Module，如下：
class MyModel(nn.Module):
def __init__(self, in_features):
super(MyModel, self).__init__()
self.in_features = in_features
numpy中随机数功能都在np.random模块下，torch中随机数功能都在torch模块下。
numpy.random.rand(d0, d1, …, dn)返回[0, 1)中均匀分布的样本值，函数接收独立的参数；
numpy.random.random((d0, d1, …, dn))返回[0, 1)中均匀分布的样本值，函数接收参数元组；
torch.rand(*size, out=None)返回[0, 1)中均匀分布的样本值，函数接收独立的参数；
numpy.random.randn(d0, d1, …, dn)是从标准正态分布中返回一个或多个样本值；
torch.randn(*size, out=None)是从标准正态分布中返回一个或多个样本值；
np.random.randint(low, high, size)从[low, high)中返回特定格式的整数值；
torch.randint(low, high, size)从[low, high)中返回特定格式的整数值。
rand_np = np.random.rand(2, 3)
random_np = np.random.random((2, 3))
rand_torch = torch.rand(2, 3)
randn_np = np.random.randn(2, 3)
randn_torch = torch.randn(2, 3)
randint_np = np.random.randint(low=0, high=3, size=(2, 3))
randint_torch = torch.randint(low=0, high=3, size=(2, 3))
以此作例：
import numpy as np
a = np.ones((3,4))* 2
print(a.sum(axis=0)) # [6. 6. 6. 6.]
print(a.sum(axis=1)) # [8. 8. 8.]
print(np.count_nonzero(a, axis=0)) # [3 3 3 3]
print(np.count_nonzero(a, axis=1)) # [4 4 4]
print(np.count_nonzero(a.sum(axis=0))) # 4
当a.sum(axis=0)时，程序执行的是sum(a[:][j])；
当a.sum(axis=1)时，程序执行的是sum(a[i][:])。
try:
with open(fn, 'rb') as f:
return pickle.load(f, encoding='utf-8')
except Exception as ex:
print(ex)
return None