python

数据结构

https://www.runoob.com/python3/

运算符

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔”与” - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 **id(x) != id(y)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

三元运算符

max = a if a>b else b

条件语句

• if … else if.. else

  if 表达式1:
      语句
      if 表达式2:
          语句
      elif 表达式3:
          语句
      else:
          语句
  elif 表达式4:
      语句
  else:
      语句

• switch…case

  match subject:
      case <pattern_1>:
          <action_1>
      case <pattern_2>:
          <action_2>
      case <pattern_3>:
          <action_3>
      case _:	# 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。
          <action_wildcard>

循环

• for

  for item in iterable:
      # 循环主体
  else:
      # 循环结束后执行的代码

• range() 函数

  a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
  for i in range(len(a)):
  	print(i, a[i])

  还可以使用 range() 函数来创建一个列表：

  list(range(5))	# [0, 1, 2, 3, 4]

常用函数

bisect.bisect_left / bisect.bisect_right

bisect.bisect和bisect.bisect_right返回大于x的第一个下标(相当于C++中的upper_bound)，bisect.bisect_left返回大于等于x的第一个下标(相当于C++中的lower_bound)

index = bisect_left(ls, x)   #第1个参数是列表，第2个参数是要查找的数，返回值为索引

Numpy

• Numpy 是 Python 中科学计算的核心库，NumPy 这个词来源于 Numerical 和 Python 两个单词。它提供了一个高性能的多维数组对象，以及大量的库函数和操作，可以帮助程序员轻松地进行数值计算，广泛应用于机器学习模型、图像处理和计算机图形学、数学任务等领域。

Numpy数组：ndarray

# NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型，它是描述相同类型的元素集合。ndarray 中的每个元素都是数据类型对象(dtype)的对象。ndarray 中的每个元素在内存中使用相同大小的块。
numpy.array(object, dtype=None, copy=True, order='K', subok=True, ndmin=0)

• object 任何暴露数组接口方法的对象

• dtype 数据类型

• copy 如果为 True，则 object 对象被复制，否则，只有当array返回副本，object 是嵌套序列，或者需要副本来满足任何其他要求（dtype，order等）时，才会生成副本。

• order 指定阵列的内存布局。 如果 object 不是数组，则新创建的数组将按行排列（C），如果指定了（F），则按列排列。 如果 object 是一个数组，则以下成立。C（按行）、F（按列）、A（原顺序）、K（元素在内存中的出现顺序）

• subok 默认情况下，返回的数组被强制为基类数组。 如果为 True，则返回子类。

• ndmin 返回数组的最小维数

例1

import numpy as np

a = [1, 2, 3]
b = np.array(a)

print(b)
print(type(b))

Result

[1 2 3]
<class 'numpy.ndarray'>
# 注意：list 打印显示是 [1, 2, 3]，而 ndarray 打印显示是 [1 2 3]，当中没有逗号。

例2：dtype 参数用法示例

import numpy as np

a = [1, 2, 3]
b = np.array(a, dtype=np.float_)
# 或者
b = np.array(a, dtype=float)

print(b)
print(b.dtype)
print(type(b[0]))

Result

[1. 2. 3.]
float64
<class 'numpy.float64'>

例3：copy 参数的用法

import numpy as np

a = np.array([1, 2, 3])
b = np.array(a, copy=True)
a[0] = 0

print(a)
print(b)

Result

[0 2 3]
[1 2 3]
# 可以看到 a 和 b 的值不同，说明 b 是 a 的副本，两个是不同的对象。

import numpy as np

a = np.array([1, 2, 3])
b = np.array(a, copy=False)
a[0] = 0

print(a)
print(b)

[0 2 3]
[0 2 3]
# a 改变同时引起了 b 的改变，说明 a 和 b 指向的是同一个对象。

例4：ndmin 参数用法示例

import numpy as np

a = [1, 2, 3]
b = np.array(a, ndmin=2)

print(b)

Result

[[1 2 3]]

例5：subok 参数用法示例

布尔类型的 subok 参数，用于控制输出数组是否应该共享 a 矩阵对象的数据存储。如果 subok 参数为 True，则输出数组将与 a 矩阵对象共享相同的存储。否则，输出数组将创建一个新的存储空间

import numpy as np

a = np.matrix('1 2 7; 3 4 8; 5 6 9')
print(type(a))
print(a)
at = np.array(a, subok=True)
af = np.array(a, subok=False)
print(type(at))
print(type(af))

Result

<class 'numpy.matrix'>
[[1 2 7]
 [3 4 8]
 [5 6 9]]
<class 'numpy.matrix'>
<class 'numpy.ndarray'>

Numpy数组属性

• ndarray.ndim 秩，即轴的数量或维度的数量
• ndarray.shape 数组的维度，对于矩阵，n 行 m 列
• ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
• ndarray.dtype ndarray 对象的元素类型
• ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
• ndarray.flags ndarray 对象的内存信息
• ndarray.real ndarray 元素的实部（复数的实部）
• ndarray.imag ndarray 元素的虚部（复数的虚部）
• ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

Numpy中的常数

• 正无穷：Inf = inf = infty = Infinity = PINF
• 负无穷：NINF
• 正零：PZERO
• 负零：NZERO
• 非数值：nan = NaN = NAN
• 自然数e：e
• π：pi
• 伽马：euler_gamma
• None 的别名：newaxis

print(np.inf)
print(np.NINF)
print(np.PZERO)
print(np.NZERO)
print(np.nan)
print(np.e)
print(np.pi)
print(np.euler_gamma)
print(np.newaxis)
# inf
# -inf
# 0.0
# -0.0
# nan
# 2.718281828459045
# 3.141592653589793
# 0.5772156649015329
# None

Numpy创建数组

numpy.empty

# 此方法用来创建一个指定维度（shape）、数据类型（dtype）的未初始化的数组。
numpy.empty(shape, dtype=float, order='C')

例

import numpy as np

x = np.empty([3, 2], dtype=int)
print(x)

[[         0 1072693248]
 [         0 1072693248]
 [         0 1072693248]]

numpy.zeros

numpy.zeros(shape, dtype=float, order='C')

例

import numpy as np

x = np.zeros(5)
print(x)

[0. 0. 0. 0. 0.]

numpy.ones

numpy.ones(shape, dtype=float, order='C')

numpy.full

# 返回给定维度和类型的新数组，填充 fill_value。
numpy.full(shape, fill_value, dtype=None, order='C')

例

import numpy as np

a = np.full((2, 3), 9)
print(a)

[[9 9 9]
 [9 9 9]]

Numpy从数值范围创建数组

numpy.arange

# 该函数等效于 Python 内置 range 函数，但返回的是 ndarray 而不是列表。
arange([start,] stop[, step,], dtype=None)

例

import numpy as np

a = np.arange(5)
b = np.arange(10, 20, 2)
print(a)
print(b)

[0 1 2 3 4]
[10 12 14 16 18]

numpy.linspace

# 创建一个一维等差数列的数组，与 arange 函数不同，arange 是固定步长，而 linspace 则是固定元素数量。
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

例

import numpy as np

a = np.linspace(0, 5, 3, endpoint=False)
b = np.linspace(0, 5, 4, endpoint=True)

print(a)
print(b)

[0.         1.66666667 3.33333333]
[0.         1.66666667 3.33333333 5.        ]

numpy.logspace

# numpy.logspace 函数用于创建一个等比数列。
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

• start 序列的起始值为：base ** start （幂运算）
• stop 序列的终止值为：base ** stop。如果 endpoint 为 True，该值包含于数列中
• num 要生成的等步长的样本数量，默认为50
• endpoint 该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。
• base 对数 log 的底数。
• dtype ndarray 的数据类型

import numpy as np

a = np.logspace(1, 4, num=4)
print(a)

# [   10.   100.  1000. 10000.]

numpy.geomspace

numpy.geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)

• start 序列的起始值
• stop 序列的终止值，如果 endpoint 为 True，该值包含于数列中
• num 要生成的样本数量，默认为 50
• endpoint 该值为 Ture 时，数列中中包含 stop 值，反之不包含，默认是 True。
• dtype ndarray 的数据类型
• axis 1.16.0 版本中的新功能 ，没看懂怎么用，官网上连个例子都没有，值为 0 和 -1 的时候结果相同，其他时候都报错。

import numpy as np

a = np.geomspace(1, 8, num=4)
print(a)

# [1. 2. 4. 8.]

Numpy从已有的数组创建数组

numpy.asarray

# numpy.asarray 类似 numpy.array，但 numpy.asarray 的参数只有三个。
numpy.asarray(a, dtype=None, order=None)

a	输入数据，可以转换为数组的任何形式。 这包括列表，元组列表，元组，元组元组，列表元组和 ndarray。
dtype	数据类型
order	在计算机内存中的存储元素的顺序，只支持 ‘C’（按行）、‘F’（按列），默认 ‘C’

import numpy as np

a = np.asarray([1, 2, 3])
print(a)

# [1 2 3]

numpy.frombuffer

# numpy.frombuffer 用于实现动态数组。numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)

buffer	实现了 __buffer__ 方法的对象，（绝对不是菜鸟教程上说的任意对象都可以）
dtype	返回数组的数据类型
count	读取的数据数量，默认为 -1，读取所有数据。
offset	读取的起始位置，默认为 0。

例1

import numpy as np
# buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。
a = np.frombuffer(b'Hello World', dtype='S1')
print(a)

# [b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']

例2

import numpy as np
import array

a = array.array('i', [1, 2, 3, 4])
print(a)

na = np.frombuffer(a, dtype=np.int_)
print(na)

a[0] = 10
print(a)
print(na)

#array.array 创建的数组对象内存是连续的（这里不能用 list，会报：AttributeError: ‘list’ object has no attribute ‘buffer’）
# numpy.frombuffer 从 array.array 的内存中创建数组，从上例中可以看出，改变 array.array 的值，numpy.frombuffer 的值也会跟着改变，由此可见。
# array.array 数组中的值改变是可以的，但是如果是添加值，那就不行了。

# array('i', [1, 2, 3, 4])
# [1 2 3 4]
# array('i', [10, 2, 3, 4])
# [10  2  3  4]

numpy.fromiter

# numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
numpy.fromiter(iterable, dtype, count=-1)

例

import numpy as np

iterable = (x * x for x in range(5))
a = np.fromiter(iterable, int)
print(a)

# [ 0  1  4  9 16]

# 看起来有点像 numpy.array，array 方法需要传入的是一个 list，而 fromiter 可以传入可迭代对象。

numpy.empty_like

numpy.empty_like(prototype, dtype=None, order='K', subok=True)

numpy.zeros_like

numpy.zeros_like(a, dtype=None, order='K', subok=True)

numpy.ones_like

numpy.ones_like(a, dtype=None, order='K', subok=True)

numpy.full_like

numpy.full_like(a, fill_value, dtype=None, order='K', subok=True)