数组和列表的区别：
数组：数组是用于储存多个相同类型数据的集合
列表：一个列表内可包好多种数据类型
数组：一旦创建，指定位置元素不能删除，除非重建数组对象
列表：列表内元素可以删除，删除后，后续元素会前移
数组
库名：numpy 别名：np
安装：pip install numpy
生成的数据类型：<class ‘numpy.ndarray’>
1. ndarray的创建：
方法1.np.arange():
语法结构：arange([start,] stop[, step,], dtype=None)
根据start与stop指定的范围以及step设定的步长，生成一个 ndarray。
特点：arange内部自动实现for循环：Arange函数可自动for循环
#实例1：
import numpy as np
array=np.arange(1,10,3)
print(array)
#输出：
[1 4 7]
#实例2：
import numpy as np
def numpysum(n):
A=np.arange(n)**2
B=np.arange(n)**3
C=A+B
return C
num=6
summ=numpysum(num)
print(summ)
#输出：
[ 0 2 12 36 80 150]
方法2. np.array(list/tuple):
例1：列表中全部是数字
import numpy as np
x=np.array([1,2,3,4,5])
print(x)
#输出：
[1 2 3 4 5]
例2：列表中有数字有字符串，全部当成字符串处理，确保数组中的数据类型一致
import numpy as np
x=np.array([1,'six',3,4,5])
print(x)
#输出：
['1' 'six' '3' '4' '5']
**方法3.numpy.linspace()
功能：在指定的间隔内返回均匀间隔的数字。
语法：np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)**
num:生成数据数量，默认为50
endpoint=True 是否包含endpoint 默认包含
retstep=True,返回生成的array和步长
实例：
import numpy as np
array=np.linspace(1,10,10,endpoint=False,retstep=True)
print(array)
#输出：
(array([1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1]), 0.9)
2. numpy的主要方法:
numpy.shape(int/矩阵):读取矩阵长度（矩阵，非数组）
#例1
import numpy as np
print(np.shape([[1,2,3],[4,5,6]]))
输出：
（3,2）#即这是一个三行而裂的矩阵
#例2：
import numpy as np
print(np.shape([[[0,1,2,3],
[4,5,6,7],
[8,9,10,11]],
[[12,13,14,15],
[16,17,18,19],
[20,21,22,23]]]))
#输出：
(2, 3, 4)
numpy.reshape()：重新定义数组阶数
语法：numpy.reshape(array_like, newshape, order=‘C’)
newshape是一个元祖，元祖参数数量无限制
注意：newshape元祖内数据的乘要等于原数组元素的个数
import numpy as np
a=np.arange(24) #创建一个24位的数组
b=np.array(a)#数组矢量化
c=b.reshape((2,3,4))#分成两组，每组三项，每项4位
print(c)
#输出：
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
numpy.resize(array_like, newshape, order=‘C’):功能和reshape一样，但调用方式不一样，resize是直接修改原数组
import numpy as np
a=np.arange(24) #创建一个24位的数组
b=np.array(a)#数组矢量化
c=b.resize((2,3,4))#分成两组，每组三项，每项4位
print(c)
print(b)
#输出：
None
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
numpy.dtype()定义数据类型
语法： numpy.dtype(obj, align=False, copy=False)
numpy的主要数据类型有：https://wizardforcel.gitbooks.io/ts-numpy-tut/content/3.html
#简单的定义数据类型
import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i4')
print(dt)
#输出：
int32
#将数据类型应用到数组：
import numpy as np
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
dt = np.dtype('i8')
array1=np.arange(5)
array2=np.arange(5,dtype=dt)
print(array1.dtype)
print(array2.dtype)
#输出：
int32
int64
#创建结构化的数据类型
import numpy as np
dt = np.dtype([('age',np.int64)])
#将结构化的数据类型应用到结构化的数组中
a=np.array([11,13,15],dtype=dt)
print(a)
print(a.dtype)
#输出：
[(11,) (13,) (15,)]
[('age', '<i8')]
#元组方式定义数据类型
import numpy as np
dt = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
#将数据类型传入数组
student = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = dt)
print(student)
print(student.dtype)
#输出：
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
补：在结构性数组中查看数据类型
print(student['name'].dtype)
#输出：
|S20
数组的索引和切片：同列表
#一维数组索引
#指定步长：
import numpy as np
a=np.arange(10)
num1=a[0:7:2] #072 分别代表起始位置，结束位置和步长
print(num1)
#输出：
[0 2 4 6]
#多维列表索引
import numpy as np
a=np.arange(24) #创建一个24位的数组
b=np.array(a).reshape((2,3,4))#数组矢量化
m=b[1][1][3]
print(b)
print(m)
#输出：
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
19
numpy.sort()"将数组排序：
语法：numpy.sort(a, axis=-1, kind=‘quicksort’, order=None)
a. 需要排序的数组
axis:按哪条轴排序:axis=1 按列排序，axis=0，按行排序
kind:
kind：数组排序时使用的方法，其中：
kind=′quicksort′kind=′quicksort′为快排；
kind=′mergesort′kind=′mergesort′为混排；
kind=′heapsort′kind=′heapsort′为堆排；
（概念见文末附录）
order:如果数组包含字段，则是要排序的字段
import numpy as np
dt = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
student = np.array([('a', 21, 50),('x', 18, 75),('b', 13, 43),('y', 25, 60)],dtype = dt)
print(student)
print(np.sort(student,order='age'))
#输出：
[(b'a', 21, 50.) (b'x', 18, 75.) (b'b', 13, 43.) (b'y', 25, 60.)]
[(b'b', 13, 43.) (b'x', 18, 75.) (b'a', 21, 50.) (b'y', 25, 60.)]
numpy.flatten():将多维数组展开成一维数组# 返回的是原数组的拷贝
import numpy as np
a=np.arange(24).reshape(4,6)
print(a)
print(a.flatten())
#输出：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
numpy.ravel():将多维数组展开成一维数组
区别：
flatten方法会生成原数组的copy，赋值后原数组不变
ravel不生成copy，赋值后原数组改变
import numpy as np
x = np.array([[1, 2], [3, 4]])
x.flatten()[1] = 100
print(x)
y = np.array([[1, 2], [3, 4]])
y.ravel()[1] = 100
print(y)
#输出：
#flatten
[[1 2]
[3 4]]
#ravel
[[ 1 100]
[ 3 4]]
numpy.transpose（): 矩阵转置
import numpy as np
a=np.array([["1","2","3","4"],["12","13","14","16"],["23","24","35","46"]])
print(a.transpose())
#输出：
[['1' '12' '23']
['2' '13' '24']
['3' '14' '35']
['4' '16' '46']]
numpy.hstack() 水平组合
import numpy as np
a=np.arange(25)
b=a.reshape(5,5)
c=b+1
m=np.hstack((b,c))#以元组形式传值到hstack
print(m)
#输出
[[ 0 1 2 3 4 1 2 3 4 5]
[ 5 6 7 8 9 6 7 8 9 10]
[10 11 12 13 14 11 12 13 14 15]
[15 16 17 18 19 16 17 18 19 20]
[20 21 22 23 24 21 22 23 24 25]]
numpy.vstack() 垂直组合
import numpy as np
a=np.arange(12)
c=a.reshape((3,4))
d=c+1
m=np.vstack((c,d))
#print(c,'\n',d)
print(m)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
numpy.dstack() 深度组合
深度组合
import numpy as np
a=np.arange(25)
b=a.reshape(5,5)
c=b+1
m=np.dstack((b,c))
print(m)
==================
[[[ 0 1]
[ 1 2]
[ 2 3]
[ 3 4]
[ 4 5]]
[[ 5 6]
[ 6 7]
[ 7 8]
[ 8 9]
[ 9 10]]
[[10 11]
[11 12]
[12 13]
[13 14]
[14 15]]
[[15 16]
[16 17]
[17 18]
[18 19]
[19 20]]
[[20 21]
[21 22]
[22 23]
[23 24]
[24 25]]]
numpy.column_stack() 列组合
import numpy as np
a=np.arange(24)
b=a.reshape(4,6)
c=b+1
m=np.column_stack((b,c))
print(m)
==================
[[ 0 1 2 3 4 5 1 2 3 4 5 6]
[ 6 7 8 9 10 11 7 8 9 10 11 12]
[12 13 14 15 16 17 13 14 15 16 17 18]
[18 19 20 21 22 23 19 20 21 22 23 24]]
numpy.row_stack行组合
import numpy as np
a=np.arange(24)
b=a.reshape(4,6)
m=np.hsplit(a,6)
print(m)
[array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8, 9, 10, 11]), array([12, 13, 14, 15]), array([16, 17, 18, 19]), array([20, 21, 22, 23])]
附录:
快速排序；quicksort
使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
步骤为：
- 从数列中挑出一个元素，称为“基准”（pivot），
- 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。
- 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
归并/混合排序:mergesort
算法思路：
把 n 个记录看成 n 个长度为 l 的有序子表
进行两两归并使记录关键字有序，得到 n/2 个长度为 2 的有序子表
重复第 2 步直到所有记录归并成一个长度为 n 的有序表为止。
以数组 array = [6, 5, 3, 1, 8, 7, 2, 4] 为例，首先将数组分为长度为 2 的子数组，并使每个子数组有序：
[6, 5] [3, 1] [8, 7] [2, 4]
↓ ↓ ↓ ↓
[5, 6] [1, 3] [7, 8] [2, 4]
然后再两两合并：
1 [6, 5, 3, 1] [8, 7, 2, 4]
2 ↓ ↓
3 [1, 3, 5, 6] [2, 4, 7, 8]
最后将两个子数组合并：
1 [6, 5, 3, 1, 8, 7, 2, 4]
2 ↓
3 [1, 2, 3, 4, 5, 6, 7, 8]
堆排序：heapsort
参考链接：https://www.cnblogs.com/kkun/archive/2011/11/23/2260286.html