Python小知识点

1.常用 pip 命令使用方法

pip命令示例	说明
pip install SomePackage	安装SomePackage
pip list	列出当前已安装好的所有模块
pip install --upgrade SomePackage	升级SomePackage模块
pip uninstall SomePackage	卸载SomePackage模块
pip install somePackage, whl	使用whl文件直接安装SomePackage

2.在 python 中，不需要事先声明变量名及其类型，但 python 仍是强类型语言。

3.字符串和元组属于不可变序列，这意味着不能通过下标的方式来修改其中的元素值。

4.python采用的是基于值的内存管理方式。

5.python具有自动内存管理功能，会跟踪所有的值，并自动删除不再有变量指向的值。
（因此，一般不需要太多考虑内存管理的问题，尽管如此，显式使用 del 命令删除不需要的值或显式关闭不再需要访问的资源，仍是一个好习惯。）

6.矩阵相乘运算符@

>>> import numpy
>>> x = numpy.ones(3)
>>> m = numpy.eye(3) * 3
>>> m[0, 2] = 5
>>> m[2, 0] = 3
>>> x
array([1., 1., 1.])
>>> m
array([[3., 0., 5.],
       [0., 3., 0.],
       [3., 0., 3.]])
>>> x @ m
array([6., 3., 8.])

7.常用内置函数
abs(x)
all(iterable)
any(iterable)
bin(x)
callbale(object)
dir(x)
filter(function or None, sequence) 其中function or None返回能够被判断为True的元素
zip(seq1[, seq2[…])
编写程序时优先使用内置函数，成熟稳定速度快~

8.ord()和chr()
python2.x：ASCII
python3.x：Unicode

9.要会用 dir() 和 help() 获取帮助

10.在大的程序中可能会需要导入很多模块，应按照这样的顺序来依次导入模块。
（1）导入python标准库模块，如os、sys、re
（2）导入第三方扩展库，如PIL、numpy、scipy
（3）导入自己定义和开发的本地模块

11.为增强可读性，一般在运算符两侧、函数参数之间、逗号两侧使用空格进行分割，而不同功能的代码块之间、不同的函数定义以及不同的类定义之间则建议增加一个空行以增加可读性。

12.python文件名
py
pyw
pyc
pyo
pyd

13.python脚本的 __ name __ 属性
每个python脚本在运行时都有一个 __ name __ 属性。
如果脚本作为模块被导入，则其 __ name __ 属性的值被自动设置为模块名；
如果脚本独立运行，则其 __ name __ 属性值被自动设置为“__ main __”。

作用：利用 __ name __ 属性即可控制 python 程序的运行方式。
例如，编写一个包含大量函数的模块，而不希望该模块可以直接运行，则可以在程序中添加：

if __name__ == '__main__':
	print('Please use me as a module.')

这样程序直接执行时将会得到提示“Please use me as a module.”，而使用import语句将其作为模块导入后可以使用其中的类、方法、常量或其他成员。

14.列表是python的内置可变序列，是包含若干元素的有序连续内存空间。

当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩，从而保证元素之间没有缝隙。

python列表内存的自动管理可以大幅度减少程序员的负担，但列表的这个特点会涉及列表中大量元素的移动，效率较低，并且对于某些操作可能会导致以外的错误结果。

因此，除非确实有必要，否则应尽量从列表尾部进行元素的增加与删除操作。

15.列表元素的增加
使用+运算在严格意义上并不是真正为列表添加元素，而是创建一个新列表，并将原列表中的元素和新元素一次复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。
补充：其增强运算符“+=”就是原地修改列表。

使用列表对象的 append() 方法，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快，推荐使用。√

上述两种方法，运算量越大，速度差异越大~

16.python采用基于值的自动内存管理方式。
当为对象修改值时，并不是真的直接修改变量的值，而是使变量指向新的值。

>>> a = [1, 2, 3]
>>> id(a)
2234651514624
>>> a = [1, 2]
>>> id(a)
2234645481536

对于列表、集合、字典等可变序列类型。
以列表为例，列表中包含的是元素值的引用，而不是直接包含元素值。如果直接修改序列变量的值，则于普通变量的情况相同；如果是通过下标来修改序列中元素的值或通过可变序列对象自身提供的方法来增加和删除元素时，序列对象在内存中的起始地址是不变的，仅仅是被改变的元素地址发生变化。

>>> a = [1, 2, 3]
>>> id(a)
2234645479808
>>> id(a[0])
140725534639776
>>> a[0] = 0
>>> id(a)
2234645479808
>>> id(a[0])
140725534639744

使用列表对象的extend()方法可以将另一个可迭代的对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址，属于原地操作。

"""继续上面例子"""
>>> a.extend([4, 5, 6])
>>> id(a)
2234645479808

尽量避免insert()、remove()、pop()方法或del命令在列表中间修改元素，这涉及到大量元素的移动。
优先考虑使用append()、pop()方法

使用乘法扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。
注意！当使用*运算符将包含列表的列表进行重复并创建新列表时，并不创建元素的复制，而是创建已有对象的引用。因此，当修改其中一个值时，相应的引用也会被修改。

>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0]
>>> x
[[None, None], [None, None], [None, None]]
>>> x = [[1, 2, 3]] * 3
>>> x[0][0] = 10
>>> x
[[10, 2, 3], [10, 2, 3], [10, 2, 3]]

若要避免这种引用情况⬇️

>>> x = [[1,2,3] for i in range(3)]
>>> x
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
>>> x[0][0] = 0
>>> x
[[0, 2, 3], [1, 2, 3], [1, 2, 3]]

17.python对列表内存的自动收缩移动元素保证列表所有元素之间没有空隙

>>> x = list(range(20))
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> for i in range(len(x)):
	del x[0]

>>> x
[]

👆说明列表内存在不断向前收缩

利用该方法使用从后向前的顺序来删除列表中的重复元素。
从前向后可能会造成 IndexError

>>> ls = [i for i in range(10)]
>>> for s in ls:
	ls.remove(s)
	print(ls)
	
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 8, 9]
[1, 3, 5, 7, 9]
-------------------------------
>>> ls = [i for i in range(10)]
>>> for s in ls[::-1]:
	ls.remove(s)
	print(ls)
	
[0, 1, 2, 3, 4, 5, 6, 7, 8]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 2]
[0, 1]
[0]
[]

18.切片适用于列表、元组、字符串、range对象等类型。
与使用下标访问列表元素不同，切片操作不会因为下标越界而抛出异常，而是简单的在列表尾部截断或者返回一个空列表，具有更强的健壮性。

>>> for i in range(6,4):
	print(i)

	
>>> ls
[1, 2, 3, 4, 5, 6]
>>> ls[4:2]
[]

切片返回的是列表元素的浅复制。

19.enumerate(列表)：枚举列表、元组或其他可迭代的对象的元素，返回枚举对象，枚举对象中每个元素是包含下标和元素值的元组。对字符串、字典同

>>> B
[2, 2, 3]
>>> for item in enumerate(B):
	print(item)

(0, 2)
(1, 2)
(2, 3)
--------------------------------------
>>> ls = '12345'
>>> for item in enumerate(ls):
	print(item)

(0, '1')
(1, '2')
(2, '3')
(3, '4')
(4, '5')
--------------------------------------
>>> d = dict(zip(list('abc'),range(1,4)))
>>> d
{
   'a': 1, 'b': 2, 'c': 3}
>>> for item in enumerate(d):
	print(item)

(0, 'a')
(1, 'b')
(2, 'c')
>>> for item in enumerate(d.values()):
	print(item)

(0, 1)
(1, 2)
(2, 3)

20.列表推导

>>> a = [