numpy

http://docs.scipy.org

pip install numpy
import numpy
print(numpy.__version__)
# '1.11.1'
array([1, 2, 3])[1:]
# array([2,  3])

array([1, 2, 3])[0]
# 1

array([
    [1,2,3],
    [4,5,6]
])[1,2]
# 6

array(
    [
        [2, 4, 6, 8],
        [3, 3, 2, 1],
        [2, 6, 3, 4],
        [5, 2, 3, 5]
    ]
)[0:1, :]
# array([[2, 4, 6, 8]])

array(
    [
        [2, 4, 6, 8],
        [3, 3, 2, 1],
        [2, 6, 3, 4],
        [5, 2, 3, 5]
    ]
)[:, 0:1]
# array([[2], [3], [2], [5]])

array(
    [
        [2, 4, 6, 8],
        [3, 3, 2, 1],
        [2, 6, 3, 4],
        [5, 2, 3, 5]
    ]
)[0:2, 0:2]
# array([[2,4], [3, 3]])

arange()

numpy.arange(start, end, step)

Возвращает массив ndarray, в указанном проежутке с указанным шагом

arange(1, 2, 0.1)
# array([ 1. ,  1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9])

array()

numpy.array(items: list[, dtype: str])

Возвращает массив ndarray

array([1, 4, 2, 5, 3])
# array([1, 4, 2, 5, 3])

array([1, 2, 3, 4], dtype='float32')
# array([ 1., 2., 3., 4.], dtype=float32)

concatenate()

numpy.concatenate(list_arrays: list[, axis])

Соединяет массивы и возвращает новый, результат объелдинения

concatenate([
    array([1, 2, 3]),
    array([4, 5, 6]),
])
# array([1, 2, 3, 4, 5, 6])

concatenate([
    array([
        [1, 2, 3],
        [4, 5, 6],
    ]),
    array([
        [6, 7, 8],
        [7, 8, 9]
    ]),
])
"""
array([
    [1, 2, 3],
    [4, 5, 6],
    [6, 7, 8],
    [7, 8, 9],
])
"""

concatenate([
    array([
        [1, 2, 3],
        [4, 5, 6],
    ]),
    array([
        [6, 7, 8],
        [7, 8, 9]
    ]),
], axis=1)
"""
array([
    [1, 2, 3, 6, 7, 8],
    [4, 5, 6, 7, 8, 9],
])
"""

dot()

numpy.dot(*arrays)
dot(
    array([
        [1, 1],
        [2, 2]
    ]),
    array([
        [4, 4],
        [6, 6]
    ]),
)
# array([[10, 10], [20, 20]])

dsplit()

numpy.dsplit()

dstack()

numpy.dstack()

Аналогично встроенной функции zip()

ndstack((
    array([1, 2, 3]),
    array([10, 20, 30])
))
"""
array([
    [
        [1, 10],
        [2, 20],
        [3, 30]
    ]
])

einsum()

numpy.einsum()
einsum(
    'i,i',
    array([2, 2]),
    array([4, 4])
)
# 16

einsum(
    'ij,jk',
    array([[1,1], [2, 2]]),
    array([[4,4], [6, 6]])
)
"""
array([
    [10, 10],
    [20, 20]
])

empty()

numpy.empty(size: int)

Возвращает массив указанной размерности

eye()

numpy.eye(size: int[, k=0, dtype])

Возвращает единичную матрицу указанной размерности

eye(2)
"""
array([
    [1., 0.],
    [0., 1.]
])

eye(4, k=1)
"""
array([
    [0., 1., 0., 0.],
    [0., 0., 1., 0.],
    [0., 0., 0., 1.],
    [0., 0., 0., 0.],
])

full()

numpy.full(size, defualt)

Возвращает массив указанного размера, заполненного дефолтными значениями

full((2, 3), 3.14)
"""
array([
    [3.14., 3.14, 3.14],
    [3.14, 3.14, 3.14]
])

hsplit()

numpy.hsplit(array: ndarray, size: tuple)
hsplit(
    arange(16).reshape((4, 4)),
    [2]
)
"""
[
    [0, 1],
    [4, 5],
    [8, 9],
    [12, 13]
]
[
    [2, 3],
    [6, 7],
    [10, 11],
    [14, 15]
]
"""

hstack()

numpy.hstack(array_list: list)
hstack([
    array([
        [9, 8, 7],
        [6, 5, 4],
    ]),
    array([
        [99],
        [99]
    ])
])
"""
array([
    [9, 8, 7, 99],
    [6, 5, 4, 99]
])
"""

identity()

numpy.identity(size, dtype)

Возвращает квадратную матрицу

identity(4)
"""
array(
    [
        [1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.],
    ]
)
"""

inner()

numpy.inner(*arrays)
inner(
    array([2, 2]),
    array([4, 4])
)
# 16

linspace

numpy.linspace(start, stop, step)

Возвращает массив из указанного промежукта, с равномерным распределнием значений

numpy.linspace(0, 1, 5)
# array([0., 0.25, 0.5, 0.75, 1.])

load

numpy.load(file_name)

Загружает массив из файла, сохраненный через метод numpy.save()

array = numpy.load('numbers.npy')

ones()

numpy.ones(size: tuple, dtype: int)

Создает многомерный массив заполненный единицами

numpy.ones((2, 3), dtype=int)
"""
array([
    [1., 1., 1.],
    [1., 1., 1.]
])

ones_like()

numpy.ones_like(array)

Возвращает массив, заполненный единицами по указанному массиву

ones_like(array([1, 2, 3]))
# array([1, 1, 1])

reshape()

numpy.reshape(array, new_shape)
reshape(arange(9), (3, 3))
"""
array([
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8]
])
"""

reshape(arange(9), (3, 2))
# ValueError: cannot reshape array of size 9 into shape (3,2)

save()

numpy.save(name, array)

Сохраняет массив в файл, который потом можно загрузить через numpy.load()

numpy.save('numbers.npy', array([1, 2, 3]))

split()

numpy.split(items: list, size: tuple)
x1, x2, x3 = split(
    [1, 2, 3, 99, 99, 3, 2, 1],
    (3, 5)
)
"""
x1 = [1, 2, 3]
x2 = [99, 99]
x3 = [3, 2, 1]
"""

uniq()

numpy.uniq(array)

Возвращает массив уникальных значений

unique(array([1, 1, 4, 5, 5, 5, 7]))
# array([ 1, 4, 5, 7])

vsplit()

numpy.vsplit(array: ndarray, size: tuple)
vsplit(
    arange(16).reshape((4, 4)),
    [2]
)
"""
[
    [0, 1, 2, 3],
    [4, 5, 6, 7]
]
[
    [8, 9, 10, 11],
    [12, 13, 14, 15]
]
"""

vstack()

numpy.vstack()
vstack([
    array(1, 2, 3),
    array([
        [9, 8, 7],
        [6, 5, 4],
    ])
])
"""
array([
    [1, 2, 3],
    [9, 8, 7],
    [6, 5, 4],
])
"""

zeros()

numpy.zeros(count: int[, dtype])

Создает массив из нулей

zeros(10, dtype=int)
# array[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

zeros_like()

numpy.zeros_like(array)

Возвращает массив, заполненный нулями по указанному массиву

zeros_like(array([1, 2, 3]))
# array([0, 0, 0])