排序
直接排序sort（）
numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None])
axis：排序沿数组的（轴）方向，0表示按纵轴，1表示按横轴，None表示展开来排序，默认为-1，表示沿最后的轴排序。
kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。
order：排序的字段名，可指定字段排序，默认为None。(样例见下）
import numpy as np
dt = np.dtype([('name', 'S10'), ('age', np.int)])
a = np.array([("Mike", 21), ("Nancy", 25), ("Bob", 17), ("Jane", 27)], dtype=dt)
b = np.sort(a, order='name')
print(b)
# [(b'Bob', 17) (b'Jane', 27) (b'Mike', 21) (b'Nancy', 25)]
得到排序后元素的索引位置argsort(）
排序后想用元素的索引位置替代排序后的实际结果。
numpy.argsort(a[, axis=-1, kind=‘quicksort’, order=None])
import numpy as np
np.random.seed(20200612)
x = np.random.randint(0, 10, 10)
print(x)
# [6 1 8 5 5 4 1 2 9 1]
y = np.argsort(x)
print(y)
# [1 6 9 7 5 3 4 0 2 8]
print(x[y])
# [1 1 1 2 4 5 5 6 8 9]
多列指标按照主次顺序排序lexsort()
numpy.lexsort(keys[, axis=-1]) # 使用键序列执行间接稳定排序。
给定多个可以在电子表格中解释为列的排序键，lexsort返回一个整数索引数组，该数组描述了按多个列排序的顺序。序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。keys参数必须是可以转换为相同形状的数组的对象序列。如果为keys参数提供了2D数组，则将其行解释为排序键，并根据最后一行，倒数第二行等进行排序。
import numpy as np
x = np.array([1, 5, 1, 4, 3, 4, 4])
y = np.array([9, 4, 0, 4, 0, 2, 1])
a = np.lexsort([x])
b = np.lexsort([y])
print(a) # [0 2 4 3 5 6 1]
print(x[a]) # [1 1 3 4 4 4 5]
print(b) # [2 4 6 5 1 3 0]
print(y[b]) # [0 0 1 2 4 4 9]
z = np.lexsort([y, x])
print(z)
# [2 0 4 6 5 3 1]
print(x[z])
# [1 1 3 4 4 4 5]
以某索引元素为基准排序partition（）
numpy.partition(a, kth, axis=-1, kind=‘introselect’, order=None)
The ordering of the elements in the two partitions is undefined.
以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面。两部分元素的顺序未定义。
得到以某元素为基准排序后的索引位置argpartition(）
numpy.argpartition(a, kth, axis=-1, kind=‘introselect’, order=None)
搜索
np.argmax()/np.argmin()
numpy.argmax(a[, axis=None, out=None]) # 返回最大值的索引位置
numpy.argmin(a[, axis=None, out=None]) # 返回最小值的索引位置
np.nonzero()
numppy.nonzero(a) # 返回非0元素的索引值
- 只有a中非零元素才会有索引值，那些零值元素没有索引值。
- 返回一个长度为a.ndim的元组（tuple），元组的每个元素都是一个整数数组（array）。
- 每一个array均是从一个维度上来描述其索引值。比如，如果a是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。
- 该 np.transpose(np.nonzero(x)) 函数能够描述出每一个非零元素在不同维度的索引值。
- 通过a[nonzero(a)]得到所有a中的非零值。
# 二维数组
import numpy as np
x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
print(x)
# [[3 0 0]
# [0 4 0]
# [5 6 0]]
print(x.shape) # (3, 3)
print(x.ndim) # 2
y = np.nonzero(x)
print(y)
# (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
print(np.array(y))
# [[0 1 2 2]
# [0 1 0 1]]
print(np.array(y).shape) # (2, 4)
print(np.array(y).ndim) # 2
y = x[np.nonzero(x)]
print(y) # [3 4 5 6]
y = np.transpose(np.nonzero(x))
print(y)
# [[0 0]
# [1 1]
# [2 0]
# [2 1]]
nonzero()可将布尔数组转换成整数数组进行操作。
import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(x)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
y = x > 3
print(y)
# [[False False False]
# [ True True True]
# [ True True True]]
y = np.nonzero(x > 3)
print(y)
# (array([1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))
y = x[np.nonzero(x > 3)]
print(y)
# [4 5 6 7 8 9]
y = x[x > 3]
print(y)
# [4 5 6 7 8 9]
np.where()
numpy.where(condition, [x=None, y=None])
1)满足条件condition，输出x，不满足输出y。
2)只有condition，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。
numpy.searchsorted(a, v[, side=‘left’, sorter=None]) Find indices where elements should be inserted to maintain order.
a：一维输入数组。当sorter参数为None的时候，a必须为升序数组；否则，sorter不能为空，存放a中元素的index，用于反映a数组的升序排列方式。
v：插入a数组的值，可以为单个元素，list或者ndarray。
side：查询方向，当为left时，将返回第一个符合条件的元素下标；当为right时，将返回最后一个符合条件的元素下标。
sorter：一维数组存放a数组元素的 index，index 对应元素为升序。
import numpy as np
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
y = np.searchsorted(x, 15)
print(y) # 5
import numpy as np
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
np.random.shuffle(x) #随机打乱数组顺序
print(x) # [33 9 11 26 18 5 1 0]
x_sort = np.argsort(x)
print(x_sort) # [7 6 5 1 2 4 3 0]
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], sorter=x_sort)
print(y) # [0 0 4 5 7 8]
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right', sorter=x_sort)
print(y) # [0 1 5 5 8 8]
计数
numpy.count_nonzero(a, axis=None) # 返回数组中的非0元素个数。
集合操作
构造集合(去重）numpy.unique()
numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)
return_index=True # 表示返回新列表元素在旧列表中的位置。
return_inverse=True # 表示返回旧列表元素在新列表中的位置。
return_counts=True # 表示返回新列表元素在旧列表中出现的次数。
import numpy as np
x = np.array(['a', 'b', 'b', 'c', 'a'])
u, index = np.unique(x, return_index=True)
print(u) # ['a' 'b' 'c']
print(index) # [0 1 3]
print(x[index]) # ['a' 'b' 'c']
x = np.array([1, 2, 6, 4, 2, 3, 2])
u, index = np.unique(x, return_inverse=True)
print(u) # [1 2 3 4 6]
print(index) # [0 1 4 3 1 2 1]
print(u[index]) # [1 2 6 4 2 3 2]
u, count = np.unique(x, return_counts=True)
print(u) # [1 2 3 4 6]
print(count) # [1 3 1 1 1]
补：python_set()函数
set(iterable)用于创建一个空集合，或者将一个可迭代对象转化为一个无序集合。
iterable–待转化为无序集合的可迭代对象，包括列表、字符串和字典等。可省略，当该参数省略时，将创建一个不包含任何元素的空集合
- 参数省略时：创建一个空集合赋给一个变量，输出变量的类型和值
a = set()
print(type(a)) # <class 'set'>
print(a) # set()
# 此时变量a是集合类型，没有任何元素。
- 将字符串转化为集合
a = "Hello World !"
b = set(a)
print(b) # {'l', 'e', 'H', '!', 'o', 'd', 'r', ' ', 'W'}
- 将列表转化为集合
a = []
b = [21,7, 21, 22, 530, 'wdf']
print(set(a)) # set()
print(set(b)) # {7, 530, 21, 22, 'wdf'}
- 将元组转化为集合：
a = ()
b = (7, 7, 23, 22, 530, 'wdf')
print(set(a)) # set()
print(set(b)) # {'wdf', 7, 530, 22, 23}
- 将字典转化为集合：
a = {}
b = {'China': 'Beijing', 'Japan': 'Tokyo', 'Mongolia': 'Ulan Bator'}
print(set(a)) # set()
print(set(b)) # {'China', 'Japan', 'Mongolia'}
注意：将字典转化为集合时，只是收录了字典中的key。
- 多个重复元素的可迭代对象
a = 'uuuvvvaaa'
b = [1, 1, 1]
c = ('sdf', 'sdf', 'sdf')
d = {1: 12, 2: 23, 1: 345}
print(set(a)) # {'a', 'v', 'u'}
print(set(b)) # {1}
print(set(c)) # {'sdf'}
print(set(d)) # {1, 2}
注意事项：
- 当使用set的有参函数时，参数必须是可迭代对象。当参数不是可迭代对象时，Python会抛出异常。例如：
a = 1.23
print(set(a))
- 转化为集合后，序列是随机的，可能跟转化前的序列不同。
- 由于集合不包含重复元素，使用set()函数后会将之前的可迭代序列中的重复元素删除。
- 将字典转化为集合，仅仅只是将键（key）收录到集合中。如果想将字典中的值转化为集合，可以用字典函数values()
————————————————
python_set()函数部分参考链接：https://blog.csdn.net/TCatTime/article/details/82312600
布尔运算 numpy.in1d()
numpy.in1d(ar1, ar2, assume_unique=False, invert=False)
前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。
import numpy as np
test = np.array([0, 1, 2, 5, 0])
states = [0, 2]
mask = np.in1d(test, states)
print(mask) # [ True False True False True]
print(test[mask]) # [0 2 0]
mask = np.in1d(test, states, invert=True)
print(mask) # [False True False True False]
print(test[mask]) # [1 5]
求两个集合的交集 np.intersect1d(ar1, ar2)
numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)#求两个数组的唯一化+求交集+排序函数
import numpy as np
from functools import reduce
x = np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
print(x) # [1 3]
x = np.array([1, 1, 2, 3, 4])
y = np.array([2, 1, 4, 6])
xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
print(x_ind) # [0 2 4]
print(y_ind) # [1 0 2]
print(xy) # [1 2 4]
print(x[x_ind]) # [1 2 4]
print(y[y_ind]) # [1 2 4]
x = reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
print(x) # [3]
补：python_reduce()函数
from functools import reduce
reduce(function, iterable[, initializer])
function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
求两个集合的并集numpy.union1d(ar1, ar2)
numpy.union1d(ar1, ar2) # 计算两个集合的并集，唯一化并排序。
求两个集合的差集numpy.setdiff1d(ar1, ar2)
numpy.setdiff1d(ar1, ar2, assume_unique=False) # 集合的差，即元素存在于第一个数组,不存在于第二个数组中。
import numpy as np
a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setdiff1d(a, b)
print(x) # [1 2]
求两个集合的异或numpy.setxor1d(ar1, ar2)
numpy.setxor1d(ar1, ar2, assume_unique=False) Find the set exclusive-or of two arrays. # 两个集合的交集的补集——两个数组中各自独自拥有的元素的集合。
import numpy as np
a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setxor1d(a, b)
print(x) # [1 2 5 6]
扫一扫
2999
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
