Python——判断未知源的编码类型

有时候遇到一个文件，而我们并不知道它是什么编码方式编码的,本文给出了一些判断未知文件编码方式的方法

使用chardet包

在程序中判断

安装Chardet包
1
pip install chardet

使用Chardet包做判断

import urllib
rawdata = urllib.urlopen('http://yahoo.co.jp/').read()
import chardet
print chardet.detect(rawdata)
# Output:
{'confidence': 0.99, 'language': '', 'encoding': 'utf-8'}

更多高级使用方法可参考chardet文档

直接使用命令判断

安装chardetect工具
1
pip install chardet

使用chardetect命令

# 检测test.txt文件的编码方式
chardetect test.txt
# Output：
test-chardetect.txt: ascii with confidence 1.0

Python——反编译(Disassemble)与字节码(Bytecode)

为了知道Python代码底层都做了哪些操作，我们常常需要反编译Python代码以获得Python的字节码
我们可以获得: classes, methods, functions, or code 的字节码

获取字节码的方法

# 比较`[]`和`list()`两者的不同
from dis import dis

# test case 1
dis("[]")
# Output:
  1           0 BUILD_LIST               0
              2 RETURN_VALUE

# test case 2
dis("list()")
# Output:
  1           0 LOAD_NAME                0 (list)
              2 CALL_FUNCTION            0
              4 RETURN_VALUE

**由上述输出可知，`list()` 比 `[]` 会多执行一行字节码`LODA_NAME`**

Python——命名规范

Python命名规范(Name Convention)
Reference: https://blog.csdn.net/real_myth/article/details/68927665

命名：

module_name, package_name, ClassName, method_name, ExceptionName, function_name, GLOBAL_VAR_NAME, instance_var_name, function_parameter_name, local_var_name.

应该避免的名称

单字符名称, 除了计数器和迭代器.

包/模块名中的连字符(-)
双下划线开头并结尾的名称(Python保留, 例如__init__)

命名约定

所谓”内部(Internal)”表示仅模块内可用, 或者, 在类内是保护或私有的.

用单下划线(_)开头表示模块变量或函数是protected的(使用import * from时不会包含).
用双下划线(__)开头的实例变量或方法表示类内私有.
将相关的类和顶级函数放在同一个模块里. 不像Java, 没必要限制一个类一个模块.
对类名使用大写字母开头的单词(如CapWords, 即Pascal风格), 但是模块名应该用小写加下划线的方式(如lower_with_under.py). 尽管已经有很多现存的模块使用类似于CapWords.py这样的命名, 但现在已经不鼓励这样做, 因为如果模块名碰巧和类名一致, 这会让人困扰.

引号

自然语言使用双引号（想表达人为意思的，比如log，错误，提示等）

机器标识使用单引号（比如dict的key等）
正则表达式使用原生的双引号 r”…”
docstring使用三双引号

Python之父Guido推荐的规范

Type	Public	Internal
Modules	lower_with_under	_lower_with_under
Packages	lower_with_under
Classes	CapWords	_CapWords
Exceptions	CapWords
Functions	lower_with_under()	_lower_with_under()
Global/Class Constants	CAPS_WITH_UNDER	_CAPS_WITH_UNDER
gobal/Class Variables	lower_with_under	_lower_with_under
Instance Variables	lower_with_under	_lower_with_under (protected) or __lower_with_under (private)
Method Names	lower_with_under()	_lower_with_under() (protected) or __lower_with_under() (private)
Function/Method Parameters	lower_with_under
Local Variables	lower_with_under

Python——np.nan, None的判断和比较

Python值的判断与比较： np.nan, None

None

type(None)
# Output: <type 'NoneType'>

None is None
# Output: True

None == None
# Output: True

np.nan

type(np.nan)
# Output: <type 'float'>

np.nan == np.nan
# Output: False 

np.nan is np.nan
# Output: True 

np.nan != np.nan
# Output: True 

np.nan > np.nan
# Output: False

np.nan < np.nan
# Output: False

np.nan 与 None

None == np.nan
# Output: False 

None != np.nan
# Output: True

None is np.nan
# Output: False

与数字的比较

np.nan > 10
# Output: False 

np.nan < 10
# Output: False 

np.nan == 10
# Output: False

总结

【Python2和Python3表现相同】
np.nan 只有在np.nan != np.nan或者np.nan is np.nan时为True ，其他情况下和数字比较(包括和自身)都为False
【Python2和Python3表现相异】
Python3与Python2在直接使用np.nan时表现正常,但是当涉及到DataFrame的NaN时表现不同

特殊情况

DataFrame中的NaN与数字比较时会出现有时候为True有时候为False的情况

这种情况出现在Python3中，当NaN 与数字比较时
- 此时对于列属性类型为数值型，那么返回False
- 否则返回True
Python2中NaN和数字的就是np.nan和数字比较的结果，都为False
Python2与Python3比较
代码示例：

# Python3：
import pandas as pd
df = pd.DataFrame([['a',2,3], ['a',3,4], ['a',8,9]], index=['a', 'b', 'c'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f'])
print(df)
# Output: 
	     0    1    2
	a    a  2.0  3.0
	b    a  3.0  4.0
	c    a  8.0  9.0
	d  NaN  NaN  NaN
	e  NaN  NaN  NaN
	f  NaN  NaN  NaN

print(df > 5)
# Output: 
	      0      1      2
	a  True  False  False
	b  True  False  False
	c  True   True   True
	d  True  False  False
	e  True  False  False
	f  True  False  False

print(df.values)
# Output:
	[['a' 2.0 3.0]
	 ['a' 3.0 4.0]
	 ['a' 8.0 9.0]
	 [nan nan nan]
	 [nan nan nan]
	 [nan nan nan]]

# Python2：
import pandas as pd
df = pd.DataFrame([['a',2,3], ['a',3,4], ['a',8,9]], index=['a', 'b', 'c'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f'])
print(df)
# Output: 
	     0    1    2
	a    a  2.0  3.0
	b    a  3.0  4.0
	c    a  8.0  9.0
	d  NaN  NaN  NaN
	e  NaN  NaN  NaN
	f  NaN  NaN  NaN

print(df > 5)
# Output: 
	       0      1      2
	a   True  False  False
	b   True  False  False
	c   True   True   True
	d  False  False  False
	e  False  False  False
	f  False  False  False

print(df.values)
# Output: 
	[['a' 2.0 3.0]
	 ['a' 3.0 4.0]
	 ['a' 8.0 9.0]
	 [nan nan nan]
	 [nan nan nan]
	 [nan nan nan]]

Python——位运算与逻辑运算和C++有什么不同

参考链接: https://blog.csdn.net/weixin_39129504/article/details/85958295

位运算(与C++相同)

按位与 `&`

按位或 `|`

按位异或 `^`

按位取反 `~`

移位运算 `>>`,`<<`,`<<=`和`>>=`

逻辑运算(与C++不同)

逻辑与

Python: and
C++: &&

逻辑或

Python: or
C++: ||

逻辑非

Python: not
C++: !

Python——使用pip管理包

使用 pip 管理 Python 包的常见用法如下：

管理包（安装、升级、卸载和查看等）

安装最新版本：
1
pip install package_name
安装指定版本：
1
pip install package_name==1.2.3
从本地文件安装：
1
pip install /path/to/package.whl

从 GitHub 安装：

1	pip install git+https://github.com/user/repo.git

升级到最新版本：
1
pip install --upgrade package_name
卸载包：
1
pip uninstall package_name
查看某个包的详细信息：
1
pip show package_name
列出所有已安装的包：
1
pip list

搜索包

搜索包：
1
pip search package_name
- 这个命令已经弃用，现在需要访问官网才行 https://pypi.org/
搜索包版本：
1
pip index versions package_name

检查包更新

检查哪些包需要更新：
1
pip list --outdated

配置镜像源

临时使用镜像源：

1	pip install package_name -i https://pypi.tuna.tsinghua.edu.cn/simple

永久配置镜像源：

1	pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

其他常用命令

查看帮助：
1
pip --help
查看版本：
1
pip --version

用`pip`批量导出或安装环境配置

可以使用 pip freeze 命令导出当前 Python 环境的配置
下面的pip freeze 命令将在当前目录下创建一个名为 requirements.txt 的文件，并写入当前环境中已安装的所有包及其版本信息 ：
1
pip freeze > requirements.txt
下面的命令可以在任何地方根据 requirements.txt 中列出的包及其版本信息重新安装所有必需的包，从而重建相同的环境（其中-r参数用于指定依赖性的文件名）：
1
pip install -r requirements.txt

从源码安装包

以通过源码安装transformers为例子
clone仓库 ：git clone https://github.com/huggingface/transformers.git
进入目录 ：cd transformers
安装依赖（准备项） ：确保你的Python环境中已经安装了setuptools等必要的依赖。如果没有安装，可以先使用pip install setuptools进行安装
安装（推荐方式） ：pip install .
- 注意：这种方式会将transformers安装到你的Python环境中，但如果后续你对源码进行了修改，需要重新执行安装命令才能使修改生效
- 其他安装方式（可编辑安装） ：pip install -e .命令，该命令会将克隆的仓库链接到你的Python库路径，这样Python不仅会在正常的库路径中搜索库，也会在你克隆到的文件夹中进行查找，方便修改后生效
安装完成后，对于还未发行的版本，版本名称可能是带有后缀.dev等的（依赖可能识别不了）

附录：安装带 `-e` 的含义

是否使用 -e 在安装方式和后续开发行为上有本质区别
具体来说 pip install . 和 pip install -e . 都是用来安装当前目录下的 Python 包的命令，但安装本质不同

`pip install .` （标准安装）

将当前目录（. 代表当前目录）下的 Python 包进行复制安装（静态）
安装过程 ：
- 1）pip 会查找当前目录中的 setup.py 或 pyproject.toml 文件
- 2）根据配置，将包的源代码复制到 Python 环境的 site-packages 目录下
- 3）同时安装包的依赖项
安装后，你在项目源码中做的任何修改，不会自动反映到已安装的包中，即不可编辑
- 如果你修改了源代码，必须重新运行 pip install . 来更新已安装的包，才能让改动生效
当你准备发布一个稳定版本时，通常使用这种方式

`pip install -e .` （可编辑安装 / 开发安装）

-e 是 --editable 的缩写，进行的是可编辑安装或开发安装（动态链接）
安装过程 ：
- 1）pip 同样查找 setup.py 或 pyproject.toml
- 2）它不会复制源代码，而是在 site-packages 目录下创建一个指向你当前项目目录的符号链接（symlink） 或特殊的 .pth 文件
- 3）这样，Python 解释器在导入这个包时，会直接从你的项目源码目录加载模块
你在项目源码中做的任何修改，立即生效 ，不需要重新安装，即是可编辑的
- 非常适合在开发过程中使用，可以快速测试代码变更
包的依赖项仍然会被安装到环境中
包的“安装位置”就是开发目录，删除开发目录会导致包“消失”

附录：安装包的用法

常规用法

使用普通命令足以
1
pip install package==1.1.0
若已经安装有包（不管是升级还是降级均可），想要强制重新安装，使用：
1
pip install package==1.1.0 --force-reinstall

已经有包的情况下，也可以使用：

1 2	pip3 uninstall package pip3 install package==1.1.0

Python——函数返回值是copy还是引用

Python中有些函数是直接操作当前对象的，有些函数是操作副本的

操作当前对象的

list.sort()，返回空
random.shuffle(my_list)，返回空
func(inplace=True), 这里Pandas库中的其他方法几乎均适用

返回copy的

除了numpy的reshape()外目前默认都为
sorted(), 内置函数，返回新对象，不论接受什么参数返回的都是列表
np.ndarray.reshape() 返回新对象，但是新对象除了shape属性外，数据属性是和原始对象共享的
- np.ndarray存储着数据和一个shape属性
- 我们可通过修改shape属性而不是创建新对象来修改当前对象的shape object.shape = 3,4
- 使用reshape时可以理解为创建了一个新对象，但是共享了数据，两个ndarray对象有相同的数据引用
- numpy包没有array类，只有ndarray类，array是一个函数，用于构造ndarray,也可以用ndarray函数构建，但是不推荐，测试ndarray函数发现用法很奇怪

Python——标准输入input函数

本文简单讲解input和raw_input函数的用法,两者都是内置函数,无需用户自己导入模块

input函数

用法
1
input[[prompt]]

实例

1
2
3

while True:
	a = input("input: ")
	print type(a), a

交互结果

input: 123
<type 'int'> 123
input: "abc"
<type 'str'> abc
input: 1.0
<type 'float'> 1.0
input: abc
SyntaxError: unexpected EOF while parsing

总结:
- 当输入为整数时,识别为int和long类型
- 当输入为小数时,识别为float等类型
- 当输入为string(两边需要添加")时,识别为str类型
- 当输入为未知,像是string但是没被"引用起来时,抛出语法错误异常

raw_input函数

用法与inputx完全相同
把所有的输入都当做字符串,注意,如果输入的字符串带有",那么"会被保留在字符串内部

用法实例

1
2
3

while True:
	a = raw_input("input: ")
	print type(a), a

交互结果

input: 123
<type 'str'> 123
input: "abc"
<type 'str'> "abc"
input: 1.0
<type 'str'> 1.0
input: abc
<type 'str'> abc

Python——编程笔记-各种易忘点总结

Python编程笔记，各种易忘点总结
持续更新

快速排序和归并排序参数不可使用 list 子列表

注意使用子列表时是一个新对象，操作子列表与原始 list 无关
在快速排序和归并排序中不可将子列表传入, 以期待可以从函数中修改原始列表的值

list 初始化

list 初始化的多种方式

1 2	l = [0] * 10 l = [0 for _ in range(10)]

list.count 函数的应用

list.count 可以统计某个元素出现的次数

l = [1,  3,  2,  3,  3,  3]
print l.count(3)
# output:
4

str 是一个不可变对象

Python 中的 str 是不可变对象

s = "12345"
# OK
print s[1]
print s[2:4]
# Error
s[1] = 10

Random 的应用

输出一个 [start, end] 之间(包括 start 和 end)的随机数
1
2
import random
print random.randint(start, end)

sorted 函数不修改原始数组

sorted 函数不修改原始数组

a.sort() 会修改原始数组

l = [1, 3, 4, 2]
l1 = sorted(l)
print l,  l1
l.sort()
print l
# output
[1, 3, 4, 2] [1, 2, 3, 4]
[1, 2, 3, 4]

sorted 参数 cmp 和 key 比较

key是个单参数函数, 返回值为一个可用于比较的值即可
cmp是个双参数函数, 返回值为-1, 1, 0, 分别表示小于, 大于, 等于
- 特别注意不是返回 True 和 False
二者均可作为排序的比较函数

Python 数值类型自动转换

强制类型转换: int(a)
隐式转换
- boolean 型转 int 型: True =1 False =0
- 自动类型提升: int 型转 float 型
- 注意: 两个 int 型的除法不会保留小数 ，这点与 C++ 一致

关于 bool

if 判断语句中，实际上时调用 bool(object)
bool(object) 调用的时 object.__bool__()
如果一个对象没有实现 __bool__ 方法，那么会尝试调用 __len__ 方法
- 返回为 0 时表示 False
- 否则返回 True

对象 ID

Python 中对象的 ID 类似于其他语言中对象的地址
调用方法为
1
2
id(object)
# Output: 4332312578

运算符号的内部实现

+ 和 +=
- + : __add__()
- += : __iadd__()
  - 当没有 __iadd__() 时 Python 解释器会调用 __add__()
* 和 *=
- * : __mul__()
- *= : __imul__()
  - 当没有 __imul__() 时 Python 解释器会调用和 __mul__()
不可变变量，比如 tuple也可以调用 *= 和 +=，表现也是一样的，只是对象id会改变，等价于调用了 __add__() 然后又赋值给当前变量
1
2
3
4
tu1 = (1, 2, 3)
tu2 = (2, 3, 4)
tu1 += tu2 # <==> tu1 = tu1 + tu2, id of tu1 will change
# Output: (1, 2, 3, 2, 3, 4)

尽量避免使用最小整数

需要初始化一个最小值, 然后方便求得某个序列的最大值, 此时可以初始化为某个可能的值, 从而避免寻找最小整数的尴尬, 可能会找错, 初始化错的话很容易造成后面结果都错

参数”`key`“

一些需要比较功能的函数都会有此参数
key参数是一个函数，这个函数接受一个唯一的对象，然后返回用于比较的值，外层函数比较时会使用key函数返回值进行比较
- 比如可用与字符窜长度 key = len 排序，忽略大小写排序 key = str.lower 比较等功能
可用于 list.sort(), sorted(), min(), max() 等函数
另外一些其他标准库也会接受这个参数，用法相似

Foreach 局部变量

Python for 循环语句中的“局部”变量与Java中的不同

1
2
3

# Python
for i in range(0,  10):
	pass

1 2	// Java for(int i=1; i < 10; i++)

上面的代码执行完之后i的值为多少？
- Java 中 i 是局部变量，所以在代码执行完成后变量 i 是不能访问的
- Python 中 i 是全局变量，所以i的值为最后一次迭代的值 9
- Java 中要实现与 Python 相同的效果，可以使用全局变量(将 i 的定义放到 for 循环外面即可)

函数内部定义函数时注意

注意内部函数是否访问到 Inner 外的变量
如果某个函数 Otter 只被访问一次且另一个函数 Inner 只被 Otter 访问，那么 Inner 一般定义在 Otter 内部比较合适

正则表达式匹配完整字符串

必须使用 ^ 和 $，否则部分匹配也会返回结果

import re
def totally_match(pattern,  string):
	if re.match(pattern,  string) is not None:
		return True
totally_match(r"^cat$",  "cat")

Python 可以函数定义后再定义全局变量

Python 支持先定义函数，再定义全局变量
1
2
3
4
def visit():
print(global_variable)
global_variable = "testing"
visit()
- 因为 Python 是解释器

Python 无穷大的数

常用的是无穷大的实数:

正无穷: float('inf')
负无穷: float('-inf')

运算:

Python 里面的无穷大与 C++ 不同, C++ 里面是定义一个最大的整数实现, Python 里面可以视为一个无穷大的对象
和数学分析里面一样, 我们可以和无穷大做计算, 加上无穷大还是无穷大
1
2
3
4
5
6
7
8
9
10
11
12
13
x = float('inf')
print x
print x - 1
print x + 1
print x + x
print x - x

# output
inf
inf
inf
inf
nan
- 无穷大减去无穷大为一个未知结果 nan
- 判断一个数是否为 nan, nan == nan 返回 False

复制一个普通列表时不要用 copy 模块

copy.deepcopy 支持对可变对象的深度复制, 直到解析到不可变对象为止
1
2
3
import copy
list1 = [1, 3, 4, [5, 6]]
list2 = copy.deepcopy(list1)
- 如果list对象元素都是不可变对象, 那么可以有简便实现
  1
  2
  list1 = [1, 3, 4, 5, 6]
  list2 = list1[:]

测试

import copy
list1 = [1,  3,  4,  [5,  6]]
l1 = list1[:]
l2 = copy.deepcopy(list1)
l3 = copy.copy(list1)
l4 = list1
list1.append(10)
list1[3].append(7)
print "l[:]",  l1
print "deepcopy",  l2
print "copy",  l3
print "l",  l4

# output
l[:] [1,  3,  4,  [5,  6,  7]]
deepcopy [1,  3,  4,  [5,  6]]
copy [1,  3,  4,  [5,  6,  7]]
l [1,  3,  4,  [5,  6,  7],  10]

一次其他同学排查很久的 Bug：
- 在多线程并发时，将同一个 List[Dict] 对象直接分别放到不同任务中做不同的处理（并发处理），任务 B 会朝对象中添加字符串，然后有趣的事情发生了
  - 任务 B 总是对的，任务 A 偶尔出现错误，且不可复现
  - 离线两个任务分别测试，都是对的（即关闭任务 B 后，任务 A 总是对的）
- 这位同学排查了很久，束手无策，最后其他同学 Review 代码找到是编程习惯不好（没有对可变对象做深拷贝）造成的，因为两边用的是用同一个对象，而这位同学不知道

`not " "` 返回的是 `False`

在编程时容易错误的以为空白就是没有, 所以容易认为 not " " 是 True
- " " 不是什么都没有, 而是有个 space 字符

实际上只有空字符串, 空列表和 None 等是空的, not None, not [], not ''等均为True

print not " "
print not ""
print not []
print not None
print not 0
print not -1

# output:
False
True
True
True
True
False

Python中32位最小和最大整形数

# max
max_int = 0x7FFFFFFF
# min
min_int = -0x80000000

使用abs(n)求n的绝对值

1
2
3

print abs(-11)
# output
11

使用整除符号//

print 3.5 // 2
print 3.5 / 2
print 3 // 2
print 3 / 2

//是整除符号，只保留整数部分，但是结果的类型可能为整数，也可能为浮点数，具体取决于除法两边是否含有浮点数

list中的子列表

l = [1, 2, 3, 4, 5]
print l[2:-1]
print l[-1]
# output
[3,  4]
5

list l 中使用 -1 可以理解为 len(l)-1, 不管是字列表还是元素的索引操作

sorted的返回值总是list

即使传入的是一个 string, 返回值也是 list, 需要牢记
1
2
3
print sorted("1523")
# output:
['1', '2', '3', '5']

Python 的 for 循环语句结束时 i 的值与 Java 不同

Python

for i in range(0,  5):
	print i
print "final:",  i
# output
0 1 2 3 4
final: 4

Java/C++

int i;
for(i = 0; i < 5; i++){
	System.out.print(i);
}
System.out.print("final:")
System.out.print(i)
# output
0 1 2 3 4
final: 4

如果想得到 Java/C++ 的效果, 可以使用 while 语句

i = 0
while i < 5:
	print i
	i+= 1
print "final:",  i
# output
0 1 2 3 4
final: 4

join 函数调用的条件

特别注意: join 函数的参数只能是字符串, 不能是数字
1
2
3
4
5
l = [1, 2, 3, 4]
print ''.join(l)

# output
TypeError: sequence item 0: expected string, int found
- 使用非string元素的列表时抛出TypeError的错误

dict.get()

原始定义
1
dict.get(key[, default=None])
- default参数可以指定默认值, 当key值不存在时可以返回默认值, 如果不指定, 则默认key值不存在时返回None
与dict[key]对比
- 使用dict[key]时要确保key在dict中, 否则会报异常

一行太长的代码需要分多行

必须在每个子行行尾部使用\
子行内部不用对齐, 因为解析时Python解释器会将所有子行合并成一行

示例：

1 2	if 9 < 10 and 11 < 12 and 13 < 14: print "works"

等价于

if 9 < 10 and \
	11 < 12 and \
	13 < 14:
	print "works"

等价于

if 9 < 10 and \
		11 < 12 and \
13 < 14:
	print "works"

全局变量只要在函数调用前声明就行了

我们定义函数时, 函数里面的变量可以没有定义
调用函数的时候, 默认这个函数中没定义过的变量都是全局变量, 函数会主动寻找相关的全局变量, 找不在再报错
核心: 定义函数时函数中没定义的变量被使用了(如 x=10 这样的赋值算是变量的定义, 不是使用), 那么默认函数认为他是全局变量, 当函数被调用的时候, 才会寻找全局变量是否在当前 Python 运行环境中
所以, 可以先定义函数, 再初始化(定义全局变量), 最后调用函数
- 只要初始化全局变量在调用函数之前即可
- 但是需要注意函数中不能给全局变量赋值, 被赋值的变量将被函数认为是局部变量
  1
  2
  3
  4
  5
  6
  7
  8
  def sum_x(y):
  return x+y
  
  x = 100
  print sum_x(10)
  
  # output
  110

使用列表切片修改列表

测试代码

a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3, 4, 5, 6]
c = [0, 0, 0, 0, 0, 0]

a[:2] = c[:2]
print(a)
d = b[:2]
d[:] = c[:2]
print(d)
print(b)
b[:2] = [0]
print(b)

# Output:
[0,  0,  3,  4,  5,  6]
[0,  0]
[1,  2,  3,  4,  5,  6]
[0,  3,  4,  5,  6]

列表切片在左边时, 可以修改数组内部数据, 甚至是长度都可以修改(最后两行代码)
列表切片在右边时, 表现为复制一份列表返回给变量d, 所以修改d的值将不影响原始的列表b

使用`del`删除列表或字典中的元素

删除列表或字典中的元素

l = [1,  2,  3]
d = {"m": 10,  "x": 11}
print(l)
print(d)
del l[0]
print(l)
del l[0]
print(l)
del d["m"]
print(d)

# Output:
[1,  2,  3]
{'m': 10,  'x': 11}
[2,  3]
[3]
{'x': 11}

注意不能删除元组中的元素

t = (1, 2, 3)
del t[1]

# Output:
Traceback (most recent call last):
File "/home/jiahong/JupyterWorkspace/test2.py",  line 13,  in <module>
	del t[1]
TypeError: 'tuple' object doesn't support item deletion

dict.keys()返回的是列表吗?

代码示例

1
2
3

d = {"m": 10,  "x": 11}
print(d.keys())
print(type(d.keys()))

Python 2.7中输出
1
2
['x', 'm']
<type 'list'>

Python 3.6中输出

1 2	dict_keys(['m', 'x']) <class 'dict_keys'>

总结
- Python2.7中输出是列表, 丢失了set信息, 占用空间小, 但是会造成使用x in d.keys()时变成线性搜索时间 O(n)
- Python3.6中输出是dict_keys类型的对象, 保留了set信息, 占用空间也大了, 便于使用x in d.keys()时变成常数搜索时间 O(1)

列表切片的详细说明 `[::-1]`

切片完整用法
1
li[start:end:step]
- start: 开始索引, 包含li[start], 默认为0
- end: 结束索引, 不包含li[end], 默认为len(li)
- step: 跳着取元素, step为间隔, 默认为1
  - step可以设置为负, 此时若start > end则能得到, 从[start, end]结束的序列, 包含li[start], 不包含li[end], 由于此时start > end, 所以得到的是逆序列
  - 注意: 若step参数省略的话第二个:也能省略

代码示例

A = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(A)
print(A[::-1])
print(A[::-2])
print(A[::1])
print(A[::2])
print(A[1:5:])
print(A[1:5:])
print(A[5:1:-1])

# Output:
[0,  1,  2,  3,  4,  5,  6,  7,  8,  9]
[9,  8,  7,  6,  5,  4,  3,  2,  1,  0]
[9,  7,  5,  3,  1]
[0,  1,  2,  3,  4,  5,  6,  7,  8,  9]
[0,  2,  4,  6,  8]
[1,  2,  3,  4]
[1,  2,  3,  4]
[5,  4,  3,  2]

`vars`函数的使用

定义

def vars(p_object=None): # real signature unknown; restored from __doc__
	"""
	vars([object]) -> dictionary
	
	Without arguments,  equivalent to locals().
	With an argument,  equivalent to object.__dict__.
	"""
	return {}

vars(object)返回对象的字典

代码示例

class A:
	def __init__(self):
		self.a = 10
		self.b = "abc"

	def getA(self):
		self.c = "100"


a = A()
print(A.__dict__)
print(vars(A))

# Output:
{'__module__': '__main__',  '__init__': <function A.__init__ at 0x7f87b2be01e0>,  'getA': <function A.getA at 0x7f87994c2e18>,  '__dict__': <attribute '__dict__' of 'A' objects>,  '__weakref__': <attribute '__weakref__' of 'A' objects>,  '__doc__': None}
{'__module__': '__main__',  '__init__': <function A.__init__ at 0x7f87b2be01e0>,  'getA': <function A.getA at 0x7f87994c2e18>,  '__dict__': <attribute '__dict__' of 'A' objects>,  '__weakref__': <attribute '__weakref__' of 'A' objects>,  '__doc__': None}

注意: object.__dict__一般在序列化的时候访问, 平时不会访问

整数除法(负整数)

C++ 和 Java中整数除法是向0取整
Python中整数除法是向下取整(向负无穷取整)
正整数除法他们的商和余数都相同
负整数除法商和余数都不同，需要注意, 不要用错

如何获取一个正数的小数部分?

方法1
1
2
a = 10.234
decimal = a - int(a)
方法2
1
2
a = 10.234
decimal = a % 1

for循环中使用lambda的坑

问题代码
1
2
3
4
5
6
funs = []
for i in range(3):
funs.append(lambda: i)
print funs[0](), funs[1](), funs[2]()

## output: 2 2 2
- 问题原因：由于lambda引用对象不会被lambda定义时复制，lambda定义后x还可以在外面被修改，最终结果是所有函数都持有相同的i作为引用对象

解决方案：

funs = []
for i in range(3):
	funs.append(lambda x=i: x)
print funs[0](),  funs[1](),  funs[2]()

## output: 0 1 2

核心思想：在定义lambda时将i的值复制给默认参数，这一步实现了值的复制

对象当做函数调用

在类定义中加入__call__函数定义，则可以将对象当做函数来调用

代码示例：

class SimpleCallable:
	def __init__(self,  multiplier):
		self.multiplier = multiplier

	def __call__(self,  value):
		# 当实例被当作函数调用时执行的逻辑
		return value * self.multiplier

# 创建 SimpleCallable 的一个实例
callable_instance = SimpleCallable(multiplier=2)

# 将实例作为函数调用
result = callable_instance(5)  # 这里相当于调用了 __call__ 方法
print(result)  # 输出应该是 10

import 包可使用括号

在 Python 中，导入包时可以使用括号，也可以不使用括号
这两种导入方式在功能上没有任何区别 ，它们的作用完全相同
- from x import x, y 是紧凑的单行写法，用逗号分隔导入的对象
- from x import (x, y) 是将导入的对象放在括号中，这种写法在导入对象较多、需要换行时更常用

括号导入的示例如下：

from module import (
	object1, 
	object2, 
	object3, 
	object4
)

使用括号的形式可以让代码结构更清晰，避免因换行导致的语法问题（Python 中通常用反斜杠处理换行，但用括号更优雅）

assert 语句的使用

使用示例：
1
assert a == b, c
- 含义：若 a == b 返回 True，则 c 不执行；否则返回 c（c 一般包含错误信息）

PYTHONUNBUFFERED 环境变量的使用

默认情况下，Python 会将输出内容，如 print() 语句的输出，暂存在内存缓冲区中，直到缓冲区填满或程序结束才一次性写入终端或日志文件
而设置 PYTHONUNBUFFERED=1 后，所有输出会立即写入，不再等待缓冲区
- 这在需要实时查看输出的场景，如调试、监控、日志流等情况下非常有用，可以避免日志延迟，确保信息即时可见
注：设置 PYTHONUNBUFFERED=1 相当于在运行 Python 程序时使用 -u 命令行选项，二者效果是等效的
更准确的描述：PYTHONUNBUFFERED=1 的作用是禁用 Python 标准输出（stdout）和标准错误（stderr）的缓冲机制，使得输出内容能够实时显示，而非等待缓冲区填满后才一次性写入

Python 不支持函数重载（overload）

Python 本身不支持传统意义上的函数重载（即同名函数根据参数个数 / 类型自动匹配调用）
- 因为 Python 是动态类型语言，函数定义时不指定参数类型，且同名函数会直接覆盖前一个定义
- Python 不允许同名函数并存（后定义的会覆盖前一个）
如果要 “模拟重载”，则其本质是：在同一个函数中，通过判断参数个数（args/*kwargs）或参数类型，分支执行不同逻辑
Python 中可使用 @overload 装饰器的类型提示重载，但是并不是真的生效，仍然需要自己手动判断调用类型

列表等可变对象赋值时需要注意准确性

初始化

初始化时，如果是乘法是对列表的列表进行的，则会出现赋制引用的情况

# 正确初始化 m 行 n 列的数组（元素之间隔离）
l = [[0] * n for range(m)] 
# 错误初始化 m 行 n 列的数组（同一列的不同行元素共享引用）
l = [[0]* n] * m

# 正确初始化 1 行 n 列数组（元素之间隔离）
l = [[0] for range(m)]
# 错误初始化 1 行 n 列数组（不同行元素共享引用）
l = [0] * m

多个值同时赋值

错误交换元素的实现：

1	numbers[i], numbers[numbers[i]] = numbers[numbers[i]], numbers[i]

两个核心规则：

右侧表达式先全部计算 ：赋值符号 = 右侧的所有值会先被计算并暂存，不会受左侧赋值的影响
左侧按顺序赋值 ：右侧暂存的值会按顺序赋值给左侧的变量/元素
- 注意：是按照顺序的，所以第一个值 numbers[i] 赋值后会修改第二个值 numbers[numbers[i]] 的引用

详细拆解

假设：

numbers = [2, 0, 1]
i = 0
# 执行目标代码
numbers[i], numbers[numbers[i]] = numbers[numbers[i]], numbers[i]

步骤 1：计算右侧所有表达式（暂存值）
- 先计算 numbers[numbers[i]] 和 numbers[i] 的值，此时 i=0，numbers 还是初始状态 [2,0,1]
- numbers[i] = numbers[0] = 2
- numbers[numbers[i]] = numbers[2] = 1
- 右侧最终暂存的元组是 (1, 2)
步骤 2：按顺序给左侧赋值
- 将右侧暂存的 (1, 2) 按顺序赋值给左侧的两个目标
- 第一个赋值：numbers[i] = 1 给 numbers[0] = 1，此时 numbers 变为 [1, 0, 1]
- 第二个赋值：numbers[numbers[i]] = 2
  - 注意！问题出在这里的 numbers[i] 已经是第一步赋值后的结果（值为 1），因此实际是 numbers[1] = 2，最终 numbers 变为 [1, 2, 1]

Python——编程规范

Python 编程中经验型的一些规范
持续更新

使用li[:]代替copy.copy(li)

li[:]等价于copy.copy(li)
li[:]不等价于copy.deepcopy(li)
li[:]可以简化代码

从后开始访问列表

list作为stack用时访问栈顶元素list[-1]

list1 = [1, 5, 2, 3]
print list1[-1]
print list1[-2]
print list1[1:-1]

# # output:
# 3
# 2
# [5, 2]

函数内函数

Python可以在函数内部定义函数,但是要注意不能与外部变量混淆

def sum_all(alist):

    def sum_two(a, b):
        return a+b

    result = 0
    for i in alist:
        result = sum_two(result, i)
    return result


print sum_all([1, 2, 3, 4, 5])
# # output:
# 15

不要随意调用特殊方法

(比如：__len__)

特殊方法不应该被开发者调用，而应该被开发者定义新类时实现
一般使用len(object)即可
原因：内置的方法(比如：len())可能会直接返回对象中的ob_size属性，而不用调用__len__()(这个函数往往会用迭代或者其他比较复杂的方法实现)

多使用列表推导

(list comprehension, 简写listcomps)和生成器表达式(generator expression, 简写genexps)

listcomps
1
[str(i) for i in range(1,10)]
genexps
1
(str(i) for i in range(1,10))

考虑使用reduce而不是循环语句

reduce

1
2
3

def add(x, y):
	return x + y
reduce(add, [1,2,3,4,5])

1 2	from operator import mul reduce(mul, range(1, 10))

多使用pprint

(Pretty Print)而不是print

import pprint
l1 = (1, {2: 3}, "first", ("second", 5, 6, [7, 8, 9]), [1, 3, 5], "this is a pprint")
pprint.pprint(l1)

# Output:
(1,
 {2: 3},
 'first',
 ('second', 5, 6, [7, 8, 9]),
 [1, 3, 5],
 'this is a pprint')

多使用三目运算符

Python不像Java和C++一样,有x?y:z这样的三目运算符号,但是可以有自己的特殊使用方法,等价于三目运算符且更容易理解
1
2
3
# same as x?y:z
result = y if x is True else z
return y if x is True else z
- 注意: 在使用return语句中的三目运算时必须有else语句,否则编译不通过,因为返回值可能会缺失

匿名变量的使用

初始化一个列表时

1	list1 = [_ for _ in list2 if _.val > 10]

Python异常处理

异常处理的正确姿势, 注意如果不是必要的话不要使用Exception, 可以考虑列出来需要捕获的所有异常, 然后在函数内部判断异常类型
1
2
3
4
5
try:
read some thing
except IOError, ValueError, e:
exception_type = type(e)
print("%s" % e)

当然, 我们一般为了方便也会直接使用下面的方法

try:
	read some thing
except Exception, e:
	exception_type = type(e)
	print("%s" % e)

位运算

在Python中, 位运算与C++中有所不同
参见Python——位运算与逻辑运算和C++有什么不同

函数

内部函数访问全局变量时使用global关键字声明(与外部函数一样)
内部函数访问外部函数的变量使用nonlocal(仅限Python 3)关键字声明
如果没有声明
- 变量变为只读的
  - 可以写出a.append()这样的语句
  - 但不可以写出a = b这样的语句
函数内部变量与函数外同名时:
- 若写出赋值操作,则认为当前变量为局部变量
- 否则认为是函数外的全局变量
- 若先访问变量(一般访问,不是对变量赋值,此时视为全局变量),然后对变量赋值(此时视为局部变量),则产生矛盾,Python解释器报错

三元表达式的使用

如果在三元表达式使用在加法中,需要加上括号,不然整体意思会变成错误的
比如两个结点的加法操作,带有进位carry,我们可以简单的写一行:
- 下面是错误示例:
  1
  val = l1.val if l1 else 0 + l2.val if l2 else 0 + carry
- 上面的表达式可以理解为如果l1不为空,返回l1.val,否则返回0 + l2.val if l2 else 0 + carry
- 当l1为空时又可以理解为如果l2不为空,返回0+l2.val否则返回0+carry

正确的写法

1	val = (l1.val if l1 else 0) + (l2.val if l2 else 0) + carry

迭代dict的键时用dict.iterkeys()

迭代键值时使用iterkeys()而不是keys()
iterkeys()返回一个迭代器而不是所有键值列表

keys()返回所有键值列表

# 迭代效率高
for _ in dict.iterkeys()
# 迭代效率低
for _ in dict.keys()

迭代值时也同理

# 迭代效率高
for _ in dict.itervalues()
# 迭代效率低
for _ in dict.values()

zip实现二维列表的行列变换

只适用于Python3，因为涉及到*操作

a = [[1,2,3],
	 [4,5,6]]

print([e for e in zip(*a)]) # 等价于 print([a for a in zip(a[0],a[1])])
print(*a) # 等价于 print(a[0],a[1])
# b = *a # 这行会报错: SyntaxError: can't use starred expression here

# Output
# [(1,4), (2,5), (3,6)]
# [1, 2, 3] [4, 5, 6]

Python3中才能使用*作为列表解包符
Python3中zip函数返回的是一个生成器而不是列表，所以需要迭代成列表
注意：在代码中，*a 的作用是将列表 a 中的子列表解包（unpack）为独立的参数。具体来说：
- 当a 是一个列表时，*a可以作为参数传递，不能直接赋值给其他变量
- 使用 print(a) 时，它会直接打印整个嵌套列表，输出为：[[1, 2, 3], [4, 5, 6]]
- 使用 zip(*a) 时，*a 会将 a 解包为两个独立的列表 [1, 2, 3] 和 [4, 5, 6]，等价于 zip(a[0], a[1])
- 使用 print(*a) 时，*a 会将 a 解包为两个独立的列表 [1, 2, 3] 和 [4, 5, 6]，然后 print 函数会分别打印这两个列表，输出为：[1, 2, 3] [4, 5, 6]

Python中逻辑运算符的巧用

不建议使用

print 0 or 1
print 10 or 1
print None or 1
print 0 and 1
print 1 and 10
print None and 10

# # output:
# 1
# 10
# 1
# 0
# 10
# None

理解

print a or b 
<==>
print a if a else b

print a and b
<==>
print b if a else a

记忆:
- 把a, b当做逻辑表达式,如果访问到b则返回b,否则返回a

reversed函数的使用

接受参数为可迭代对象,返回一个反向访问迭代对象的迭代器
1
2
3
4
5
for i in reversed(range(n)):

<==>

for i in range(n-1, -1, -1):
reversed的使用似乎更优雅,也更容易理解
容易遗忘的点,需要注意: reversed的参数必须是可迭代的对象,而不是两个数字

将简单的句子优雅的写到一行

返回值

if i < 0: return Flase
<==>
if i < 0:
	return False

其他简单的执行语句直接合并
1
i = 10; j = 10
判断语句之后使用
1
if bool: i = 10;
判断语句后使用多条
1
if bool: i = 10; j = 20
while语句后使用
1
while(bool): print 10; print 20
当句子较长时不建议使用
一般为了美观,平时的项目也不建议使用
刷题时为了让代码看起来简便,是可以使用的,但是这样会使得代码不易调试
总之:慎用

用同一个值初始化两个变量

1	x = y = value

在初始化链表头部时最常用
1
head, curr = ListNode(None)

使用`collections.Counter`

import collections

counter = collections.Counter([1, 2, 1, 3, 4, "a", "a", "c"])

print counter
print counter["a"]
print counter[1]
print counter[-1]
print counter.get("a")
print counter.get(-1, 0)

# # Output:
# Counter({'a': 2, 1: 2, 2: 1, 3: 1, 4: 1, 'c': 1})
# 2
# 2
# 0
# 2
# 0

括号用作分组表达式

在 Python 中，括号用于分组表达式，不会改变表达式的值（除非用于元组、函数调用等特殊情况）
- 所以，(1) 只是 1，不会变成元组或其他类型
a = (1) 和 a = 1 等价
a = (1,)，则是元组类型，和 a = 1 不等价

for 和 while 语句内部作用域

Python 和 C++ 不一样
- C++ 中，通常变量在函数、类、或代码块（如循环、条件语句）内部定义时，只能在该作用域内访问
- Python 中，在函数、类中定义的是局部变量，但是循环、条件语句内部定义的不是
C++ 中，for 和 while 语句中定义的变量仅在语句内可访问（虽然 for 和 while 语句本身并不产生新的作用域，但是 for 和 while 语句需要接 {}，这个会产生一个作用域块）
1
2
3
4
5
6
// C++ 中
for (int i = 0; i < 3; ++i) {
int x = i;
// 可以使用 i 和 x
}
// 这里不能访问 i 和 x

Python 中，for 和 while 语句不会产生新的定义域，在 for 和 while 语句内部定义的变量，可以直接在外面访问

for i in range(3):
	x = i
print(x) # 输出 2，最后一次循环的值
print(i) # 输出 2，i 也不会被视作局部变量

i = 1
while True:
	y = i
	i += 1
	if y >= 20:
		break
print(y) # 输出 20

注：当 for 循环迭代没有生效时，外面无法访问

for x in range(11, 11):
	print(x)
	
print("finally, x is", x) # NameError: name 'x' is not defined

for x in range(0):
	print(x)
	
print("finally, x is", x) # NameError: name 'x' is not defined

这是一个常见的 bug，所以建议在循环语句前加一个默认赋值操作，确保变量可访问

list 切片索引可以超过 list 长度而不会报错

示例

a = [1,2,3,4,5,6]

print(a[:100]) # [1, 2, 3, 4, 5, 6]
print(a[99:100]) # []

递归函数中定义函数会影响递归函数的运行效率吗？

在 Python 中，在递归函数内部定义函数（嵌套函数）可能会对运行效率产生一定影响，主要体现在以下几个方面：
函数定义开销：
- 递归函数每次调用时，内部嵌套的函数都会被重新定义一次（生成新的函数对象），例如：
  1
  2
  3
  4
  5
  6
  7
  def recursive(n):
  # 每次递归调用时，都会重新定义 inner()
  def inner(x):
  return x * 2
  if n == 0:
  return 0
  return inner(n) + recursive(n-1)
- 每次递归调用 recursive(n) 时，inner 函数都会被重新创建，这会产生额外的内存分配和函数对象初始化开销
- 如果将 inner 定义在递归函数外部，只会初始化一次，避免了重复定义的成本
作用域查找的开销：
- 嵌套函数需要访问外部递归函数的变量时，会涉及闭包作用域的查找 ，比全局作用域或局部作用域的查找更耗时
- 例如，若 inner 引用了 recursive 中的局部变量，Python 解释器需要在闭包环境中逐级查找，增加了每次调用的开销
对解释器优化的限制
- Python 解释器（如 CPython）对函数的优化（如局部变量缓存）在嵌套函数中可能效果较差
- 递归本身已经依赖解释器对函数调用栈的处理，嵌套函数可能进一步增加解释器的执行负担
建议：
- 将嵌套函数移到递归函数外部定义，避免重复初始化
- 若需要共享变量，可通过参数传递替代闭包引用，减少作用域查找开销

默认参数是在函数定义时立即绑定的

核心原则：Python 中函数的默认参数值，是在函数定义时（而非调用时）计算并绑定的
这里影响我们对函数的调用行为，需要特别关注

测试一：

# 只要 function 定义就会立即调用 a(), 且后续无论如何调用 function(), a()仅会被调用一次
def a():
	print("a")

def function(x = a()):
	print(f'function+{x}')
	pass

function()
function()
function()

# a
# function+None
# function+None
# function+None

测试二：

# 文件一内定义：
import os
def function(x = os.path.abspath(__file__)):
	print(f'function+{x}')
	pass

# 文件一内调用：
function() # 输出是文件一: function+/path_to_file1.py

# 文件二内调用：
function() # 输出还是文件一: function+/path_to_file1.py

如何打印对象名称？

在 Python 中，对象本身没有“名字”属性（变量名只是引用对象的“标签”）
- 一个对象可能被多个变量引用，也可能没有显式变量名（如匿名对象 func() 的返回值）
- 因此，我们无法直接获取“对象自己的名字”
可以通过 查找引用该对象的变量名 来间接实现打印对象名称，核心原理为：
- 通过 globals()（全局变量字典）、locals()（局部变量字典）或 inspect 模块遍历变量，反向查找“值等于目标对象”的变量名（即“找到引用该对象的标签”）

方案示例：查找全局变量中的对象名（最常用）

如果对象是全局变量（模块级定义），可遍历 globals() 字典，匹配值等于目标对象的变量名：

def get_object_name(obj) -> list[str]:
	"""
	查找全局变量中引用该对象的所有名字（一个对象可能被多个变量引用）
	:param obj: 目标对象
	:return: 变量名列表（无匹配则返回空列表）
	"""
	return [name for name, value in globals().items() if value is obj]

# 测试示例
import torch

# 全局变量（对象）
a = [1, 2, 3]
b = a  # 同一对象的另一个引用
tensor1 = torch.randn(2, 3)

# 打印对象的“名字”（变量名）
print(get_object_name(a))        # 输出：['a', 'b']（a和b都引用同一个列表对象）
print(get_object_name(tensor1))  # 输出：['tensor1']
print(get_object_name([4,5,6]))  # 输出：[]（匿名对象，无全局变量引用）

方案示例：查找局部变量中的对象名（如函数内）

如果对象是函数内的局部变量，需结合 locals()（当前作用域局部变量）或 inspect 模块获取调用者的局部变量：

import inspect

def get_object_name(obj, include_global=True) -> list[str]:
	"""
	同时查找局部变量和全局变量中引用该对象的名字
	:param obj: 目标对象
	:param include_global: 是否包含全局变量
	:return: 变量名列表
	"""
	names = []
	# 1. 查找当前调用者的局部变量（函数内的变量）
	caller_locals = inspect.currentframe().f_back.f_locals
	names.extend([name for name, value in caller_locals.items() if value is obj])
	
	# 2. 可选：包含全局变量
	if include_global:
		names.extend([name for name, value in globals().items() if value is obj])
	
	return list(set(names))  # 去重（避免局部和全局变量名重复）

# 测试：函数内的局部对象
def test_local():
	local_dict = {"key": "value"}
	local_tensor = torch.tensor([1,2])
	# 查找局部变量中的对象名
	print(get_object_name(local_dict))    # 输出：['local_dict']
	print(get_object_name(local_tensor))  # 输出：['local_tensor']

test_local()

Joe Zhou

Stay Hungry. Stay Foolish.

GitHub E-Mail

使用chardet包

在程序中判断

直接使用命令判断

获取字节码的方法

命名：

应该避免的名称

命名约定

引号

Python之父Guido推荐的规范

None

np.nan

np.nan 与 None

与数字的比较

总结

特殊情况

Python2与Python3比较

位运算(与C++相同)

按位与 &

按位或 |

按位异或 ^

按位取反 ~

移位运算 >>,<<,<<=和>>=

逻辑运算(与C++不同)

逻辑与

逻辑或

逻辑非

管理包（安装、升级、卸载和查看等）

搜索包

检查包更新

配置镜像源

其他常用命令

用pip批量导出或安装环境配置

从源码安装包

附录：安装带 -e 的含义

pip install . （标准安装）

pip install -e . （可编辑安装 / 开发安装）

附录：安装包的用法

常规用法

推荐用法

操作当前对象的

返回copy的

input函数

raw_input函数

快速排序和归并排序参数不可使用 list 子列表

list 初始化

list.count 函数的应用

str 是一个不可变对象

Random 的应用

sorted 函数不修改原始数组

sorted 参数 cmp 和 key 比较

Python 数值类型自动转换

关于 bool

对象 ID

运算符号的内部实现

尽量避免使用最小整数

参数”key“

Foreach 局部变量

函数内部定义函数时注意

正则表达式匹配完整字符串

Python 可以函数定义后再定义全局变量

Python 无穷大的数

常用的是无穷大的实数:

运算:

复制一个普通列表时不要用 copy 模块

not " " 返回的是 False

Python中32位最小和最大整形数

使用abs(n)求n的绝对值

使用整除符号//

list中的子列表

sorted的返回值总是list

Python 的 for 循环语句结束时 i 的值与 Java 不同

join 函数调用的条件

dict.get()

一行太长的代码需要分多行

全局变量只要在函数调用前声明就行了

使用列表切片修改列表

使用del删除列表或字典中的元素

dict.keys()返回的是列表吗?

列表切片的详细说明 [::-1]

vars函数的使用

按位与 `&`

按位或 `|`

按位异或 `^`

按位取反 `~`

移位运算 `>>`,`<<`,`<<=`和`>>=`

用`pip`批量导出或安装环境配置

附录：安装带 `-e` 的含义

`pip install .` （标准安装）

`pip install -e .` （可编辑安装 / 开发安装）

参数”`key`“

`not " "` 返回的是 `False`

使用`del`删除列表或字典中的元素

列表切片的详细说明 `[::-1]`

`vars`函数的使用

Python 不支持函数重载（overload）

使用`collections.Counter`

默认参数是在函数定义时立即绑定的