python学习知识点

  python知识点

1、python中的注释符号：#

# 注释内容

2、行连接

行尾加反斜杠（\）显示连接两行，若括号未结束则可隐式连接两行。

3、幂运算符“**”

4、字符串可用单引号‘’或双引号包含””，多行字符串用三重引号。

‘valid string’

“string with double quotes”

”””This is

a long,

long string”””

5、列表：放在方括号 [ ]里的有序对象列表

L1 = [5, 6]

list(range(n))创建一个n个元素的列表，元素从零开始

len()给出一个列表的长度，len([‘a’, 1, 2, 34])  #返回4

append()用于将元素添加到列表中，L.append(‘d’)

索引从零开始，负索引值为倒数，如L2 = [‘a’, 1, [3, 4]]，L2[0]为‘a’，L2[2][0]为3，L2[-1]为[3, 4], L2[-2]为1

6、列表运算符

“+”连接两个列表，“*”将列表重复自身几次

如L1 = [1, 2]，L2 = [3, 4]，L = L1 + L2  #[1, 2, 3, 4]

3 * L  #[1, 2, 1, 2, 1, 2]

7、布尔表达式

比较可以连接：2<3<4  #True (and被隐式连接)

or 或 and 来组合不同的布尔值，not 为否定逻辑值

8、循环语句

for 索引变量 in 列表

9、使用if语句作用于一个非布尔类型的数据，可使其转换为布尔值

如：if a … 等价于if bool(a):…

10、字符串可以用简单地索引或切片索引

如：name = ‘Johan Carlsson’

name[-1]  # 返回‘r’,name[-8:]  # 返回‘Carlsson’

11、join()将列表连接为字符串

sep = ‘ ;’;

sep.join([‘Johan’,’Carlsson’,’19890327’])

# 返回 ’Johan;Carlsson;19890327’

12、find()方法返回字符串所匹配的第一个索引值，即给定子串的起始位置

birthday = ‘20101210’

birthday.find(‘10’)  # 返回2

13、format()实现字符串格式化

调用format()对字符串中占位符{ }中的内容格式化，说明符：定义格式

如：course_code = “NUMA21”

print(“This course’s name is { }”.format(course_code))

返回# This course’s name is NUMA21

再如：quantity = 33.45

print(“{:1.1f}”.format(quantity))  # 33.45

print(“{name} {value : .1f}”.format(name = “quantity”, value = quantity))  # 输出“quantity 33.5”

若字符串原本需要打印字符串中的{ }，则在此方法中需要用双括号

14、字符串前加‘r’可防止字符转义

如s = r ’\tt’  # s返回‘\tt’

15、列表

• 列表切片：L[i : j] , 截取列表L从L[i]开始到L[j – 1]之间所有元素

L[i : ] 截取除前i个元素外的所有元素

L[ : i] 截取前i个元素

例：L = [‘c’, ‘1’, ‘o’, ‘u’, ‘d’, ‘s’]

则L[1 : 5]  # 返回 [‘1’, ‘o’, ‘u’, ‘d’, ‘s’]

L[1 : ]  # 返回[‘1’, ‘o’, ‘u’, ‘d’, ‘s’]

L[ : 5]  # 返回[‘c’, ‘1’, ‘o’, ‘u’, ‘d]

L[-2 : ]  # 返回[‘d’, ‘s’]

L[ : -2]  # 返回[‘c’, ‘1’, ‘o’, ‘u’]

② 步长：切片时一个索引到另一个索引之间的长度

例：L = list(range(100))

则L[ : 10 : 2]  # 返回[0, 2, 4, 6, 8]

L[20 : 10 : -3]  # 返回[20, 17, 14, 11]

③ 列表修改：删除可直接赋值空切片[ ], 插入时指定切片赋值切片

例：L = [‘a’, 1, 2, 3, 4]

L[2 : 3] = [ ]  # 删除1  [‘a’, 1, 3, 4]

L[3 : ] = [ ]  # 删除4 [‘a’, 1, 3]

L[1 : 1] = [1000, 2000]  # 插入 [‘a’, 1000, 2000, 1, 3]

④ in和not in判断一个元素是否属于列表

例：L = [‘a’, 1, ‘b’, 2]

‘a’ in L  # True

⑤ 列表方法

list.append(x)  将元素x添加到列表末尾

list.expand(L)  用列表L的元素来扩充列表

list.insert(i, x)  在索引i处插入元素x

list.remove(x)  移除列表中第一个值为x的元素

list.count(x)  列表中x出现的次数

list.sort()  对列表中元素排序

list.reverse()  按顺序反转列表中元素

list.pop()  按顺序移除列表中最后一个元素

⑥ 原位操作：以上方法为列表对自身操作，并直接改变自身值赋予自身

⑦ 列表合并zip：将列表元素配对合并成元组列表，长度取短

例：ind = [0, 1, 2, 3, 4]

color = [“red”, “greed”, “blue”, “alpha”]

list(zip(color, ind))  #输出[(‘red’, 0), (‘green’, 1), (‘blue’, 2), (‘alpha’, 3)]

⑧ 列表推导：包含条件的列表，语法：[<expr> for <variable> in <list> if <condition>]

例：L = [2, 3, 10, 1, 5]

则L2 = [ x * 2 for x in L]  #[4, 6, 20, 2, 10]

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

flat = [M[i][j] for i in range(2) for j in range(3)]  # 返回[1, 2, 3, 4 ,5 ,6]

16、元组tuple：逗号分隔的对象序列。元素不可改变。一般放在圆括号（）中。

例：my_tuple = 1, 2, 3  # 逗号表示对象是一个元组

my_tuple = (1, 2, 3)

a, b = b, a  # 交换两变量

17、字典：无序的键值对集合，放在大括号{ }中

例：truck_wheel = {‘name’:’wheel’, ‘mass’: 5.7}

访问方式：truck_wheel[‘name’]  # 返回’wheel’

遍历方式：for key in truck_wheel:

for value in truck_wheel.value():

18、集合：无序，不重复，放在大括号{ }中

例：A = {1, 2, 3, 4}

B = {5}

C = A.union(B)  # 并，返回set（[1, 2, 3, 4, 5）

D = A.intersection(C)  # 交，返回set([1, 2, 3, 4])

E = C.difference(A)  # 差，返回set([5])

5 in C  # 返回True

19、类型检查

•  type()可以查看变量类型，例：label = ‘local error’ 

则type(label)  # 返回str

②  isinstance(x, list)检测一个变量是否为某种特定的类型(x是否为list)

20、数组

• 创建向量或矩阵 v = array([1. , 2. , 3.])  # 单个方括号

   M = array([[1. , 2], [0. , 1]])  # 双方括号

• dot函数线性运算求积

例： dot(M, v)  # 另一种表述：M @ v

• 数组切片，与列表切片类似（维度多）

例：矩阵切片M[i, …]是由M的i行所填充的向量，M[: , j]是由M的j列所填充的向量，M[2:4, 1:4]是行和列的切片

• 数组构造函数：zeros((n, m))  # 由0填充的矩阵

ones(n, m)  # 由1填充的矩阵

diag(v, k)  # 以向量v构成的对角矩阵

random.rand(n, m)  # （0,1）之间的随机数填充矩阵

arange(n)  # 前n个整数，例arange(3) -> [0, 1, 2]

linspace(a, b, n)  # 由平均分布在a和b之间的n个点组成向量

• 数组维数ndim

例：T = zeros((2, 2, 3))

则ndim(T)  # 3

⑥ 数组重塑reshape(m, n)，可仅指定一个参数，将另外参数设置-1

例：v = array([1, 2, 3, 4, 5, 6, 7, 8])

M = v.reshape(2, -1)

此时shape(M)  # 返回(2, 4)

⑦ 转置用M.T

⑧ 叠加，通用方法concatenate((v1, v2, …), axis = 0),axis = 0为垂直叠加（另：vstack（[v1, v2]），axis = 1为水平叠加（另：hstack）

column_stack([v1, v2])为逐列叠加

21、高级数组

• 数组视图：是与较大数组共享数据的较小数组，与引用类似。改变数组视图也会改变整个大数组。

例：M = array([[1. , 2.], [3. , 4.]])

v = M[0, :]  # M的第一行取为v ->([ [1. , 2.]])，v即为数组视图

v[-1] = 0  # 改变v –>([[1. , 0]])

则会同时改变M ->([[1. , 0], [3. , 4.]])

用数组的base属性可以判断视图是否是原数组的引用。

例：v.base is M  # True

• 布尔数组：元素为bool的数组，可由比较运算创建

例：M = array([[2, 3], [1, 4]])

则 M > 2  # 返回数组([[False, True], [False, True]])

布尔数组中不能使用and、or或not操作符，应用&、|和~代替。

• allclose()判断浮点数组是否相等
• where命令可根据布尔数组中不同的值而返回不同值

例：x = linspace(-4, 4, 5)  # [-4. , -2. , 0. , 2. , 4.]

print(where(x > 0, 1, -1))  # [-1, -1, -1, 1, 1]

22、向量化技术显著提高运算性能

例：对于一个元素计算函数my_func(x)，每次调用计算获得一个值

若想将函数应用于一个向量v，不必for循环遍历v获得x，再代入。

可直接用构建my_vecfunc = vectorize(my_func)

此时直接对向量v计算： v = my_vecfunc(v)

23、lambda关键字实现匿名函数

格式：lambda parameter_list : expression

例：parabola = lambda x : x ** 2 + 5

则parabola(3)  # 14

24、在迭代中，用yield可构建生成器（生成列表？）

例：def odd_numbers(n):

                for k in range(n):

                       if k % 2 == 1:

                              yield k

使用：for k in odd_numbers(10):  # …do something

注：生成的迭代是一次性使用的

25、迭代器工具

• enumerate()生成一个（索引，元素）的迭代器

例：A = [‘a’, ‘b’, ‘c’]

for iteration, x in enumerate(A):

          print(iteration, x)  # (0, ‘a’) (1, ‘b’) (2, ‘c’)

• reversed()迭代生成反向的列表

例：A = [0, 1, 2]

for elt in reversed(A):

print(elt)  # result: 2 1 0

26、引发异常用raise Exception(“Something went wrong”)

异常捕捉用try:

                except ValueError:

                       print(“a ValueError occurred”)

                finally:

                       …

27、上下文管理器——with语句，封装了一个try … finally的结构，简化异常处理

例：with open(‘data.txt’, ‘r’) as f:

其包含两个方法：__enter__（用于初始化），__exit__(用于清理指令)

若__enter__方法中有return语句，则用as结构访问返回对象，若无return语句，as可忽略

28、模块：包含类和函数的文件。导入用from … import … as…

变量__name__定义为当前模块的名称。

一些有用的模块：

scipy：在科学计算中使用的函数

numpy：支持数组并包含相关方法

matplotlib：导入子模块pyplot，用于绘图并实现可视化

functools：函数的偏函数应用

itertools：提供特殊迭代工具，如切片生成器

re：用于复杂字符串处理的正则表达式

sys：系统特定函数

os：操作系统交互，例如展示目录结构和文件处理

datatime：呈现日期和时间增量

time：返回时钟时间

timeit：评估执行时间

sympy：计算机运算程序包（符号计算）

pickle：Pickling，输入和输出格式的特殊文件

shelves：Shelves，输入输出格式的特殊文件

contextlib：用于上下文管理器的工具

29、文件处理

① 文件格式：

with open(name, ‘w’) as myfile:  # 自动处理异常和关闭文件

• 文件模式：’r’  # read only  ‘r+’  # read/write

                ‘rb’  #read in byte mode  ‘a’ # append(write to end)

                ‘w’  #write the file  ‘wb’# write in byte mode

‘w’模式将自动创建新文件，注意换行符\n

• savetxt(filename, data)将数组写入txt, loadtxt从txt中读取数组
• Picking：读写复杂类型文件

例：# 写数据

import pickle

with open(‘file.dat’,’wb’) as myfile:

          a = random.rand(20, 20)

          b = ‘hello world’

          pickle.dump(a, myfile)  # 第一个存入

          pickle.dump(b, myfile)  # 第二个存入

# 读数据

import pickle

with open(‘file.dat’,’rb’) as myfile:

          numbers = pickle.load(myfile)  # 第一个读出

          text = pickle.load(myfile)  # 第二个读出

注意返回两个对象的顺序。

30、 split()函数分割默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

31、 argmax(f(x))是使得 f(x)取得最大值所对应的变量点x(或x的集合)

​​​​​​​