Numpy入门

1 、Jupiter基本操作

常用快捷键

代码执行:control+enter,alt+enter执行并再开始新的一行。

shift+ tab 查看函数的具体信息

绿色:编辑状态,enter

蓝色:命令状态,esc

命令状态下,按m是由代码模式转换成markdown模式,按y则是由markdown模式转换成代码模式。

命令状态下:b是向下插入一行,a是向上插入一行。

2、初识Numpy

2.1 Numpy是什么?

numpy:numeric python (数字化的python),是python中的数值计算的基础包。大部分提供科学计算的包都依赖于numpy。

2.2 Numpy 的特点

功能强大的N维数组对象。

ndarray支持矢量化运算,不需要循环,可以节省时间和空间。

实现线性代数、随机数生成以及傅里叶变换。

用C、C++等其它的代码编写的C API。

利器1:Ndarray

numpy中最重要的一个形式叫ndarray n 意为是n个 d dimension 维度 array 数组

利器2:切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改,与 Python 中 list 的切片操作一样。ndarray 数组可以基于 0 - n 的下标进行索引,切片对象可以通过内置的 slice 函数,并设置 start, stop 及 step 参数进行,从原数组中切割出一个新数组。

2.3 Numpy 数组

ndarray(N 维数组类型)是NumPy 中定义的最重要的对象,它是描述相同类型的元素集合。ndarray 中的每个元素都是数据类型对象(dtype)的对象。ndarray 中的每个元素在内存中使用相同大小的块。

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

参数描述


2.3.1 Numpy数组属性

NumPy 数组的维度(又称维数)称为秩(rank),一维数组的秩为 1,二维数组的秩为 2,以此类推。每一个线性的数组称为是一个轴(axis,也就是维度(dimensions


2.4 Numpy 数据类型


3、今天涉及的线代

3.1 基础概念

标量:一个标量就是一个单独的数,一般用小写的的变量名称表示。

向量:一个向量就是一列数,这些数是有序排列的。用过次序中的索引,我们可以确定每个单独的数。向量看作空间中的点,每个元素是不同的坐标轴上的坐标。

矩阵:矩阵是二维数组,其中的每一个元素被两个索引而非一个所确定。

张量:几何代数中定义的张量是基于向量和矩阵的推广,通俗一点理解的话,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。 例如,可以将任意一张彩色图片表示成一个三阶张量,三个维度分别是图片的高度、宽度和色彩数据。

秩:秩是线性代数术语,在线性代数中,一个矩阵A的列秩是 A线性无关的纵列的极大数目。类似地,行秩是 A的线性无关的横行的极大数目。

矩阵的列秩和行秩总是相等的,因此它们可以简单地称作矩阵 A的秩。通常表示为 rk(A) 或 rank A

3.2运算规则(自己去网上找更清晰)

3.2.1 向量的运算

3.2.2 矩阵的运算

3.2.3 张量的运算

4、Numpy 数组的基本操作

1、Numpy 数组的基本操作

1.1、索引

一维与列表完全一致

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

li[1][0]                 #结果为4

import numpy as np

arr = np.array(li)   =======>array([[1, 2, 3],

                                    [4, 5, 6]])

arr[1,0]/arr[1][0]   =======>结果为4

array支持list和tuple类型的索引

#arr[y,x]

arr[1,0]

arr[[1,1,1]] ==========》array([[4, 5, 6],

[4, 5, 6],

[4, 5, 6]])

arr[[1,0,1],[1,2,0]] ====>array([5, 3, 4])

| |

| |

 行的下标列的下标 # 行列的下标数目要一致,它取下标时是一个行           一个列作为一组然后再去取值的。

1.2、重设形状

reshape 可以在不改变数组数据的同时,改变数组的形状。其中,numpy.reshape() 等效于 ndarray.reshape()。

reshape(a, newshape, order='C')

Givesanewshapetoanarraywithoutchangingitsdata.


Parameters

----------

a: array_like

Arraytobereshaped.

newshape: intortupleofints

Thenewshapeshouldbecompatiblewiththeoriginalshape. If

aninteger, thentheresultwillbea1-Darrayofthatlength.

Oneshapedimensioncanbe-1.Inthiscase, thevalueis

inferredfromthelengthofthearrayandremainingdimensions.

order: {'C', 'F', 'A'}, optional

Readtheelementsof`a` usingthisindexorder, andplacethe

elementsintothereshapedarrayusingthisindexorder.'C'

meanstoread/writetheelementsusingC-likeindexorder,

withthelastaxisindexchangingfastest, backtothefirst

axisindexchangingslowest. 'F'meanstoread/writethe

elementsusingFortran-likeindexorder, withthefirstindex

changingfastest, andthelastindexchangingslowest. Notethat

the'C'and'F'optionstakenoaccountofthememorylayoutof

theunderlyingarray, andonlyrefertotheorderofindexing.

'A'meanstoread/writetheelementsinFortran-likeindex

orderif`a` isFortran*contiguous*inmemory, C-likeorder

otherwise.


Returns

-------

reshaped_array: ndarray

Thiswillbeanewviewobjectifpossible; otherwise, itwill

beacopy.Notethereisnoguaranteeofthe*memorylayout*(C-or

Fortran-contiguous) ofthereturnedarray.

eg:

 >>>a= np.zeros((10, 2))

 # A transpose makes the array non-contiguous

 >>>b= a.T

 # Taking a view makes it possible to modify the shape without modifying

 # the initial object.

 >>>c= b.view()

 >>>c.shape= (20)

 AttributeError: incompatibleshapeforanon-contiguousarray


The`order` keywordgivestheindexorderingbothfor*fetching*thevalues

from`a`, andthen*placing*thevaluesintotheoutputarray.

Forexample, let's say you have an array:


>>>a= np.arange(6).reshape((3, 2))

>>>a

array([[0, 1],

[2, 3],

[4, 5]])


Youcanthinkofreshapingasfirstravelingthearray(usingthegiven

indexorder), theninsertingtheelementsfromtheraveledarrayintothe

newarrayusingthesamekindofindexorderingaswasusedforthe

raveling.


>>>np.reshape(a, (2, 3)) # C-like index ordering

array([[0, 1, 2],

[3, 4, 5]])

>>>np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape

array([[0, 1, 2],

[3, 4, 5]])

>>>np.reshape(a, (2, 3), order='F') # Fortran-like index ordering

array([[0, 4, 3],

[2, 1, 5]])

>>>np.reshape(np.ravel(a, order='F'), (2, 3), order='F')

array([[0, 4, 3],

[2, 1, 5]])


Examples

--------

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

>>>np.reshape(a, 6)

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

>>>np.reshape(a, 6, order='F')

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


>>>np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2

array([[1, 2],

[3, 4],

[5, 6]])

importmatplotlib.pyplotasplt

cat= plt.imread('cat.jpg')

cat.shape=====>(456, 730, 3)====>元素个数:456*730*3=998640

#图片的形状进行改变

#形状可以改变,但是元素的总量不能改变

#二维的时黑白图片,透光率0时黑的,255时白的

#a.reshape(shape, order='C') newshape : int or tuple of ints

plt.imshow(cat.reshape(456,730*3),cmap='gray')

(456, 2190)=====>456*2190=998640

#在形状改变中 -1 代表的是剩余的元素总和

cat.reshape(cat.shape[0],-1).shape

#将数组展开成一维

cat.reshape(-1)

#把数组转换成 多行一列

cat.reshape(-1,1).shape

1.3.1 数组展开

ravel 的目的是将任意形状的数组扁平化,变为 1 维数组。ravel 方法如下:

不管是几维的数组都会变成1维的数据

cat.ravel()

结果为:

array([231, 186, 131, ..., 188,95,62], dtype=uint8)

1.3.2 级联

np.concatenate() 级联需要注意的点:

级联的参数是列表:一定要加中括号或小括号

维度必须相同

形状相符

【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向

可通过axis参数改变级联的方向,默认为0, (0表示列相连,行发生改变,表示的Y轴的事情,1表示列相连,列发生改变,X轴的事情)

cat2 = cat[:,:,::-1]

#检查形状

cat.shape,cat2.shape ======》((456, 730, 3), (456, 730, 3))

#第一个参数是序列数据类型

#第二个参数是拼接的方向axis=0代表列拼接

plt.imshow(np.concatenate([cat,cat2],axis=0))

结果如下图:


cat在上,cat2在下的上下拼接。

1.3.3  numpy.[hstack|vstack]

堆 做级联

分别代表水平级联与垂直级联,填入的参数必须被小括号或中括号包裹

vertical垂直的 horizontal水平的 stack层积

这两个函数的值也是一个list或tuple

1.3.4 副本

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效。

可使用ndarray.copy()函数创建副本

1.3.5 ndarray的聚合函数

1. 累加np.sum

ndarray.sum(axis),axis不写则为所有的元素求和,为0表示行求和,1表示列求和

axis是轴的方向

2. 最大最小值:nd.max/ nd.min

#列中的最大值

A.max(axis=0)

3.平均值:nd.mean()

#行方向求平均值

A.mean(axis=1)

灰度化

cat.shape

#彩色图片去除RGB就会变成黑白照片

#图片的行列不能相加

plt.imshow(cat.max(axis=-1),cmap='gray')

#(456, 730, 3) 456:0   730:1   3:2 (-1代表最后一个) 

plt.imshow(cat.min(axis=-1),cmap='gray')

plt.imshow(cat.mean(axis=-1),cmap='gray')#实际中会用这个灰度化

4.其他聚合操作

FunctionNameNaN-safeVersionDescription

np.sumnp.nansumComputesumofelements

np.prodnp.nanprodComputeproductofelements

np.meannp.nanmeanComputemeanofelements

np.stdnp.nanstdComputestandarddeviation

np.varnp.nanvarComputevariance

np.minnp.nanminFindminimumvalue

np.maxnp.nanmaxFindmaximumvalue

np.argminnp.nanargminFindindexofminimumvalue找到最小数的下标

np.argmaxnp.nanargmaxFindindexofmaximumvalue找到最大数的下标

np.mediannp.nanmedianComputemedianofelements

np.percentilenp.nanpercentileComputerank-basedstatisticsofelements

np.anyN/AEvaluatewhetheranyelementsaretrue

np.allN/AEvaluatewhetherallelementsaretrue

np.powersquare

np.argwhere(nd1<0)

np.bincount计数

np.argsort()返回排序后的下标

带有nan前缀的函数都不会计算nan

带有arg的函数返回的是元素的下标

1.4、轴移动

moveaxis 可以将数组的轴移动到新的位置。其方法如下:

numpy.moveaxis(a, source, destination)

其中:

a:数组。

source:要移动的轴的原始位置。

destination:要移动的轴的目标位置。

1.5、轴交换

和 moveaxis 不同的是,swapaxes 可以用来交换数组的轴。其方法如下:

numpy.swapaxes(a, axis1, axis2) 

其中:

a:数组。

axis1:需要交换的轴 1 位置。

axis2:需要与轴 1 交换位置的轴 1 位置。

moveaxis是在指定位置后面插入

而s...是直接交换,它俩都是一次只能换一次

1.6、数组转置

4.5 数组转置

transpose 类似于矩阵的转置,它可以将 2 维数组的水平轴和垂直交换。其方法如下:

numpy.transpose(a, axes=None) 

其中:

a:数组。

axis:该值默认为 none,表示转置。如果有值,那么则按照值替换轴。

1.7、数组'循环'

数组元素的循环

tile 与 repeat没啥意思

np.tile([[1,2,3],[4,5,6]],3)

array([[1, 2, 3, 1, 2, 3, 1, 2, 3],

      [4, 5, 6, 4, 5, 6, 4, 5, 6]])

np.repeat([[2,1,3],[4,5,6]],3,axis=0)

array([[2, 1, 3],

      [2, 1, 3],

      [2, 1, 3],

      [4, 5, 6],

      [4, 5, 6],

      [4, 5, 6]])

2、ndarray的矩阵操作

下面👇代码自己填呀

运算时注意操作对象的行列是否一致问题!!!!

2.1 基本矩阵操作

加减乘除

1、np.add() 求和

2、np.subtract()相减

3、np.multiply() 乘积

4、np.divide()相除

5、矩阵的点积 np.dot()

2.2 不同维度之间的运算

2.2.1 矩阵和向量之间的运算

矩阵乘以向量会降维

2.2.2 三维张量和矩阵(假设这个矩阵叫A)之间的点积

也会降维

张量和矩阵的运算 相当于  把每一个矩阵和A.T矩阵做一个点积

2.2.3 三维张量和向量运算

会降维

3、经典排序的数组中的实现

冒泡,选择,插入,希尔,堆,归并,快速,基数

反面意义的:冒泡,选择,复杂度高 O(n^2) 正面意义的:快速,堆,归并 O(n*log2(n))

3.2 实现冒泡排序

arr1 = np.random.randint(0,20,10)

for j in range(len(arr1)-1):

    for i in range(0,len(arr1)-1-j):

        if arr1[i] > arr1[i+1]:

            arr1[i],arr1[i+1] = arr1[i+1],arr1[i]

3.2 实现快速排序

def quickSort(a, left, right):

    if left>right:

        return -1

    temp=a[left]

    i=left

    j=right

    while i!=j:

        while a[j]>=temp and i<j:

            j-=1

        while a[i]<=temp and i<j:

            i+=1

        if i<j:

            a[i],a[j]=a[j],a[i]

    a[left]=a[i]

    a[i]=temp   

    quickSort(a,left,i-1)

    quickSort(a,i+1,right)


arr2 = np.random.randint(12,64,10)

quickSort(arr2,0,arr2.shape[0]-1)

arr2

3.3 实现希尔排序

arr3 = np.random.randint(10,100,10)

def shellSort(arr,n):

    # 设定步长

    step = int(n/2)

    while step > 0:

        for i in range(step, n):

            while i >= step and arr[i-step] > arr[i]:

                arr[i], arr[i-step] = arr[i-step], arr[i]

                i -= step

        step = int(step/2)

    return arr

shellSort(arr3,arr3.shape[0])

3.4 实现插入排序

def insertionSort(arr,n):

    for i in range(1, n):


        k = arr[i]


        j = i-1

        while j >=0 and k < arr[j] :

                arr[j+1] = arr[j]

                j -= 1

        arr[j+1] = k

    return arr

arr3=np.random.randint(10,60,10)

insertionSort(arr3,arr3.shape[0])

3.5  实现归并排序

#列表

def mergeSort(arr):

    mid = len(arr) // 2

    n = len(arr)

    if n <= 1:

        return arr

    lft = mergeSort(arr[:mid])

    rgt = mergeSort(arr[mid:])

    res = []

    while lft and rgt:

        if lft[-1] >= rgt[-1]:

            res.append(lft.pop())

        else:

            res.append(rgt.pop())

    res.reverse()

    return lft + rgt + res

#数组,这个有点问题还没解决哦,啊啊啊

def mergeSort(arr):

    n = arr.shape[0]

    mid = int(n // 2)

    if n <= 1:

        return arr

    lft = mergeSort(arr[:mid])

    print(lft)

    rgt = mergeSort(arr[mid:])

    print(rgt)

    res = []

    while lft.shape[0] and rgt.shape[0]:

        if lft[-1] >= rgt[-1]:

            res.append(lft[-1])

            lft = lft[:-1]

        else:

            res.append(rgt[-1])

            rgt = rgt[:-1]

    a = res[::-1]

    res = np.array(a)

    arr_s = np.hstack((lft, rgt, res))

    return arr_s

推荐阅读更多精彩内容