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