假设old_arr和new_arr长度相同，可以这样做：old_arr = [[8,8,8,8,0,0,0,0,6,6,5,5], [8,8,7,0,0,0,0,0,6,6,5,5]]

new_arr = [[9,9,6,7,3,6,5,0,6,4,3,4], [9,0,6,7,4,6,5,0,6,4,3,4]]

new_arr = [[x if old[i] else 0 for i, x in enumerate(new)] for old, new in zip(old_arr, new_arr)]

print(new_arr)

哪些输出：

^{pr2}$

更新：

下面是一个处理相邻单元的暴力解决方案：old_arr = [[8,8,8,8,0,0,0,0,6,6,5,5],

[8,8,8,8,0,0,0,0,6,6,5,5],

[8,8,8,8,0,0,0,0,6,6,5,5],

[8,8,8,8,0,0,0,0,6,6,5,5]]

new_arr = [[9,9,6,7,3,6,5,0,6,4,3,4],

[9,9,6,7,3,6,5,0,6,4,3,4],

[9,9,6,7,3,6,5,0,6,4,3,4],

[9,9,6,7,3,6,5,0,6,4,3,4]]

def first_last(row, next_row, old, new):

for i in range(len(new[row])):

count = 0

if old[row][i] == 0:

if old[row][i-1] == 0:

count += 1

if old[row][i+1] == 0:

count += 1

if old[next_row][i] == 0:

count += 1

if old[next_row][i-1] == 0:

count += 1

if old[next_row][i+1] == 0:

count += 1

if count > 4:

new[row][i] = 0

def middle(old, new):

for i, l in enumerate(new[1:-1]):

for j in range(len(l)):

count = 0

if old[i][j] == 0:

if old[i][j-1] == 0:

count += 1

if old[i][j+1] == 0:

count += 1

if old[i-1][j] == 0:

count += 1

if old[i-1][j-1] == 0:

count += 1

if old[i-1][j+1] == 0:

count += 1

if old[i+1][j] == 0:

count += 1

if old[i+1][j-1] == 0:

count += 1

if old[i+1][j+1] == 0:

count += 1

if count > 4:

l[j] = 0

# first row

first_last(0, 1, old_arr, new_arr)

# middle rows

middle(old_arr, new_arr)

# last row

first_last(-1, -2, old_arr, new_arr)

print(new_arr)

哪些输出：[[9, 9, 6, 7, 3, 0, 0, 0, 6, 4, 3, 4],

[9, 9, 6, 7, 0, 0, 0, 0, 6, 4, 3, 4],

[9, 9, 6, 7, 0, 0, 0, 0, 6, 4, 3, 4],

[9, 9, 6, 7, 3, 0, 0, 0, 6, 4, 3, 4]]

注意：这可以做得更好，但您可以根据自己的喜好对其进行优化。在

可以将这些行转换为1D数组，使用元素作为二维索引，并使用^{}。然后，使用^{}给我们每个唯一行的开始位置，并且还有一个可选参数return_counts来给我们计数。因此，实现将如下所示-def unique_rows_counts(a):

# Calculate linear indices using rows from a

lidx = np.ravel_multi_index(a.T,a.max(0)+1 )

# Get the unique indices and their counts

_, unq_idx, counts = np.unique(lidx, return_index = True, return_counts=True)

# return the unique groups from a and their respective counts

return a[unq_idx], counts

样本运行-

^{pr2}$

标杆管理

假设您可以将numpy数组或集合作为输出，那么可以对迄今为止提供的解决方案进行基准测试，如下-

功能定义：import numpy as np

from collections import Counter

def unique_rows_counts(a):

lidx = np.ravel_multi_index(a.T,a.max(0)+1 )

_, unq_idx, counts = np.unique(lidx, return_index = True, return_counts=True)

return a[unq_idx], counts

def map_Counter(a):

return Counter(map(tuple, a))

def forloop_Counter(a):

c = Counter()

for x in a:

c[tuple(x)] += 1

return c

时间安排：In [53]: a = np.random.randint(0,4,(10000,5))

In [54]: %timeit map_Counter(a)

10 loops, best of 3: 31.7 ms per loop

In [55]: %timeit forloop_Counter(a)

10 loops, best of 3: 45.4 ms per loop

In [56]: %timeit unique_rows_counts(a)

1000 loops, best of 3: 1.72 ms per loop

Numpy中定义的最终对象是称为ndarray的N维数组类型。它描述相同类型的元素集合。可以使用基于零的索引访问集合中的项目。

ndarray创建方式

array()函数

接收一个普通的python序列，并将其转换为ndarray。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

序号

参数

描述

1

object

任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。

2

dtype

数组的所需数据类型，可选。

3

copy

可选，默认为true，对象是否被复制。

4

order

C(按行)、F(按列)或A(任意，默认)。

5

subok

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

6

ndimin

指定返回数组的最小维数。import numpy as np

# 例子01

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

print(a)

print(type(a))

# 多于一个维度

a2 = np.array([[1,2],[3,4]])

print(a2)

# 最小维度

a3 = np.array([1,2,3,4,5],ndmin = 2)

print(a3)

empty()函数

创建指定形状和dtype的未初始化数组

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

序号

参数

描述

1

Shape

空数组的形状，整数或整数元组

2

Dtype

所需的输出数组类型，可选

3

Order

'C’为按行的 C 风格数组，'F’为按列的 Fortran 风格数组import numpy as np

#例: 数组元素为随机值

arr = np.empty((3,3),dtype = 'i1')

print(arr)

zeros()函数

创建指定长度或者形状的全零数组。

# 例

arr = np.zeros((3,3))

print(arr)

# 自定义类型

arr = np.zeros((3,3), dtype = [('x', 'i4'), ('y', 'i4')])

print(arr)

ones()函数

创建指定长度或者形状的全1数组。

arr = np.ones((2,3,4))

print(arr)

# 自定义类型

arr = np.ones((3,3), dtype = [('x', 'i4'), ('y', 'i4')])

print(arr)

asarray()函数

类似 numpy.array 可以将Python序列转换为ndarray。

# 来自列表

arr = [1,2,3,4]

arr2 = np.asarray(arr)

print(arr2)

print(type(arr))

print(type(arr2))

# 来自元组

arr = (1,2,3,4)

arr2 = np.asarray(arr)

print(arr2)

print(type(arr))

print(type(arr2))

# 来自元组列表

arr = [(1,2,3,4),(5,6,7,8)]

arr2 = np.asarray(arr)

print(arr2)

print(type(arr))

print(type(arr2))

arange()函数

类似python的range函数，通过指定开始值、终值和步长来创建一个一维数组，注意：最终创建的数组不包含终值。

numpy.arange(start,stop,step,dtype)

arr = np.arange(5,dtype = float)

print(arr)

linspace()函数

通过指定开始值、终值和元素个数来创建一个一维数组，数组的数据元素符合等差数列，可以通过endpoint关键字指定是否包含终值，默认包含终值。

等差数列

numpy.linspace(start,stop,num,endpoint,retstep,dtype)

序号

参数

描述

1

start

起始值

2

stop

结束值

3

num

生成等间隔样例的数量，默认为50

4

endpoint

序列中是否包含stop 值 默认为 Truearr = np.linspace(10,20,9)

print(arr)

arr = np.linspace(10,20,5,endpoint=False)

print(arr)

arr = np.linspace(10,20,5,retstep=True)

print(arr) #返回步长

logspace()函数

和linspace函数类似，不过创建的是等比数列数组。

numpy.logscale(start, stop, num, endpoint, base, dtype)

序号

参数

描述

1

start

起始值是base ** start

2

stop

终止值是base ** stop

3.

num

范围内的数值数量，默认为50

4

endpoint

如果为true，终止值包含在输出数组当中

5

base

对数空间的底数，默认为10

6

dtype

输出数组的数据类型，如果没有提供，则取决于其它参数arr = np.logspace(0,2,5)

# 0表示10的0次方，2表示10的2次方，5表示最终生成元素数量为5

print(arr)

arr1 = np.logspace(1,10,5,base = 2)

print(arr1)

random()函数

使用随机数填充数组，即使用numpy.random中的random()函数来创建0-1之间的随机元素，数组包含的元素数量由参数决定。

序号

参数

描述

1

rand

返回 0 - 1 随机值

2

randn

返回一个样本具有标准正态分布

3

randint

返回随机的整数，位于半开区间[low,hight)size = 10 (3,3)

4

random_integers(low[, high, size])

返回随机的整数，位于闭区间

5

random

返回随机浮点数arr = np.random.rand(9).reshape(3,3)

print(arr)

arr = np.random.rand(3,2,3)

print(arr)

arr = np.random.randn(9).reshape(3,3)

print(arr)

arr = np.random.randn(3,2,3)

print(arr)

arr = np.random.randint(1,9,size = (2,4))

print(arr)

arr = np.random.random_integers(1,9,size =(2,4))

print(arr)

arr = np.random.random((3,2,3))

print(arr)

arr = np.random.randn(3,2,3)

print(arr)

ndarray对象属性

shape

数组的维度。

这个数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小。

a = np.array([[1,2,3],[4,5,6]])

print(a) # [[1 2 3]

#[4 5 6]]

print(a.shape) # (2, 3)

调整数组大小

a = np.array([[1,2,3],[4,5,6]])

a.shape=(3,2)

print(a)

reshape 调整数组大小。

a = np.array([[1,2,3],[4,5,6]])

b = a.reshape(3,2)

print(b)

ndim

数组轴(维度)的个数。

a = np.arange(24)

print(a)

print(a.ndim)

b = a.reshape(2,4,3)

print(b)

print(b.ndim)

print(b.shape)

itemsize

数组中每个元素的字节大小。

#数组的int8 一个字节

x = np.array([1,2,3,4,5], dtype = np.int8)

print(x.itemsize)

数组的float32 4个字节

x = np.array([1,2,3,4,5], dtype = np.float32)

print(x.itemsize)

size

数组元素的总个数,等于shape属性中元组元素的乘积。

arr = np.arange(18).reshape(2,3,3)

print(type(str(arr)))

print(arr.shape)

print(arr.size)

dtype

描述数组中元素类型的对象。

数据类型

类型简写

说明

int_

默认整形

intc

等价于long的整形

int8

i1

字节整形，1个字节，范围:[-128,127]

int16

i2

整形,2个字节,范围:[-32768,32767]

int32

i3

整形,4个字节,范围:[-2^31, 2^31-1]

int64

i4

整形,8个字节,范围:[-2^63, 2^63-1]

uint8

u1

无符号整形, 1个字节, 范围:[0,255]

uint16

u2

无符号整形, 2个字节, 范围:[0,65535]

uint32

u3

无符号整形, 1个字节, 范围:[0, 2^32-1]

uint64

u4

无符号整形, 1个字节, 范围:[0,2^64-1]

bool_

以一个字节形成存储的布尔值(True或者False)

float_

float64简写形式

float16

f2

半精度浮点型(2字节)：1符号位+5位指数+10位的小数部分

float32

f4或者f

单精度浮点型(4字节)：1符号位+8位指数+23位的小数部分

float64

f8或者d

双精度浮点型(8字节)：1符号位+11位指数+52位的小数部分

complex_

c16

complex128的简写形式

complex64

c8

complex128的简写形式

complex128

c16

复数，由两个64位的浮点数来表示

object

O

Python对象类型

String_

S

固定长度的字符串类型(每个字符1个字节)，比如：要创建一个长度为8的字符串，应该使用S8

Unicode_

U

固定长度的unicode类型的字符串(每个字符占用字节数由平台决定)，长度定义类似String_类型import numpy as np

# 使用数组标量类型

dt = np.dtype(np.int32)

print(dt)

# int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。

dt = np.dtype('i4')

print(dt)

结构化数据类型

dt = np.dtype([('age',np.int8)])

print(dt)

#将结构化数据应用于ndarray对象

dt = np.dtype([('age',np.int8)])

a = np.array([(10,),(20,),(30,)],dtype = dt)

print(a)

#访问age列内容

dt = np.dtype([('age','i1')])

a = np.array([(10,),(20,),(30,)],dtype = dt)

print(a['age'])

#结构化数据包含多个字段

student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])

a = np.array([('joe',20,80),('susan',22,85),('tom',23,90),('fank',23,33)],dtype=student)

print(a)

print(a['name'])

每个数据类型都有一个类型代码，即简写方式!

布尔值

符号整数

无符号整数

浮点

复数浮点

时间间隔

日期时间

Python 对象

字节串

Unicode

原始数据(void)

b

i

u

f

c

m

M

O

S\a

U

V