python数据分析

Anaconda安装

官网

numpy(Numerical Python)

 numpy:一个开源的python科学计算库,使用Numpy可以方便的使用数组、矩阵进行计算,包含线性代数、傅里叶变换、随机数生成等大量函数

jupyter

jupyter：可直接通过浏览器运行代码，同时在代码块下方展示运行结果
启动jupyter:目录中输入cmd,在cmd中输入jupyter notebook

	实现两个数组的加法
		数组A是0到N-1的平方
		数组B是0到N-1的立方
		对比使用numpy和原生的python性能
#引入numpy包
import numpy as np 		
#查看numpy版本
np.__version__	#return'1.21.5'

原生python实现代码
def python_sum(n):
    '''
    原生python实现2个数组的加法
    '''
    # 使用列表生成式创建1到N的平方
    a = [i**2 for i in range(n)]
    # 使用列表生成式创建1到N的立方
    b = [i**3 for i in range(n)]
    # 新创建新列表
    ab_sum = []
    # 循环a的索引
    for i in range(n):
        # 将a中的对应元素与b中对应的元素相加
        ab_sum.append(a[i]+b[i])
    return ab_sum
# 调用实现函数
python_sum(10)#[0, 2, 12, 36, 80, 150, 252, 392, 576, 810]

numpy 实现代码
def numpy_sum(n):
    '''
    numpy实现2个数组的加法
    '''
    a = np.arange(n) ** 2
    b = np.arange(n) ** 3
    return a + b
# 调用numpy实现函数
numpy_sum(10)#[0, 2, 12, 36, 80, 150, 252, 392, 576, 810]
对比实现1000次
%timeit python_sum(1000)#513 µs ± 7.51 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
%timeit numpy_sum(1000)#6.46 µs ± 167 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
对比实现10W次
%timeit python_sum(100000)#56.8 ms ± 714 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit numpy_sum(100000)#321 µs ± 3.58 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
对比实现100W次
%timeit python_sum(1000000)#610 ms ± 8.28 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit numpy_sum(1000000)#6.19 ms ± 65.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

绘图对比

import pandas as pd#导入pandas包
# 获取数据
python_times = [0.513*1000,56.8*1000,610*1000*1000]
numpy_times = [6.46,3.21*1000,6.19*1000]
# 创建pandas的DataFrame类型数据
charts_data = pd.DataFrame({
    'python_times':python_times,
    'numpy_times':numpy_times,
})
charts_data #表格形式显示
# 线性图
charts_data.plot()
# 柱状图
charts_data.plot.bar()

创建数组和属性

创建ndarray对象
通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：
numpy.array(object, dtype = None, copy = True, order = None,subok=False,ndmin = 0)
序号	参数	描述说明
1	object	表示一个数组序列。
2	dtype	可选参数，通过它可以更改数组的数据类型。
3	copy	可选参数，表示数组能否被复制，默认是 True。
4	ndmin	用于指定数组的维度。
5	subok	可选参数，类型为bool值，默认False。为True，使用object的内部数据类型；False：使用object数组的数据类型。
引入numpy
[1]
# 注意默认都会给numpy包设置别名为np
import numpy as np
array创建数组：
[2]
#array()函数，括号内可以是列表、元祖、数组、迭代对象,生成器等
np.array([1,2,3,4,5]) #return array([1, 2, 3, 4, 5])
[3]
# 元组
np.array((1,2,3,4,5)) # return array([1, 2, 3, 4, 5])
[4]
a = np.array([1,2,3,4,5])
# 数组
np.array(a) # return array([1, 2, 3, 4, 5])
[5]
# 迭代对象
np.array(range(10)) # return array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
[6]
# 生成器
np.array([i**2 for i in range(10)]) # return array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])
[7]
# 列表中元素类型不相同,数组类型必须一样，自动转为最大的类型
np.array([1,1.5,3,4.5,'5']) #return array(['1', '1.5', '3', '4.5', '5'], dtype='
[8]
ar1 = np.array(range(10))   # 整型
ar1 # return array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
[9]
ar2 = np.array([1,2,3.14,4,5])   # 浮点型
ar2 #return array([1.  , 2.  , 3.14, 4.  , 5.  ])
[10]
ar3 = np.array([
                [1,2,3],
                ('a','b','c')
               ])   # 二维数组：嵌套序列（列表，元祖均可）
ar3
#return array([['1', '2', '3'],
       		   ['a', 'b', 'c']], dtype=')
[11]
# 注意嵌套序列数量不一会怎么样
ar4 = np.array([[1,2,3],('a','b','c','d')])   
ar4#return array([list([1, 2, 3]), ('a', 'b', 'c', 'd')], dtype=object)元素自动变为list的一维数组
[12]
# 注意嵌套序列数量不一会怎么样
ar4 = np.array([[1,2,3],[1,2,3,4]]) 
ar4
array([list([1, 2, 3]), list([1, 2, 3, 4])], dtype=object)
练习1
创建10以内的偶数的数组
np.array([i for i in range(10) if i % 2 == 0]) # return array([0, 2, 4, 6, 8])
[13]
a = np.array([1,2,3,4,5])
print(a) #return array([1, 2, 3, 4, 5])
# 设置数组元素类型
has_dtype_a = np.array([1,2,3,4,5],dtype='float')
has_dtype_a #return  array([1., 2., 3., 4., 5.])
[14]
np.array([1.1,2.5,3.8,4,5],dtype='int') # return array([1, 2, 3, 4, 5])向下取整，精度丢失
2.设置copy参数,默认为True

[16]
a = np.array([1,2,3,4,5])
# 定义b，复制a,非引用复制，地址不一样，新建b数组
b = np.array(a)
# 输出a和b的id
print('a:', id(a), '  b:', id(b)) #return a: 2200433338864   b: 2200433337328
print('以上看出a和b的内存地址')

# a =--复制
# b ---未复制
b[0] = 10
print(a) #return [1 2 3 4 5]

a: 2066732212352   b: 2066732213152
以上看出a和b的内存地址
[1 2 3 4 5]

[17]
# 当修改b的元素时，a不会发生变化
b[0] = 10
print('a:', a,'  b:', b)
print('='*10) #return a: [1 2 3 4 5]   b: [10  2  3  4  5]
			#		  ==========
[18]
a = np.array([1,2,3,4,5])
# 定义b，当设置copy参数为Fasle时，不会创建副本，
# 两个变量会指向相同的内容地址，没有创建新的对象
b = np.array(a, copy=False)
# 输出a和b的id
print('a:', id(a), '  b:', id(b)) #return a: 2200433338768   b: 2200433338768
# 由于a和b指向的是相同的内存地址，因此当修改b的元素时，a会发生变化
b[0] = 10
print('a:',a,'  b:',b) # return a: [10  2  3  4  5]   b: [10  2  3  4  5]

ndmin 用于指定数组的维度
[20]
a = np.array([1,2,3])
print(a) #return [1 2 3]
a = np.array([1,2,3], ndmin=2) # array([[1, 2, 3]]),变成二维，里面元素为数组

4.subok参数，类型为bool值，默认False。为True，使用object的内部数据类型；False：使用object数组的数据类型。

[21]
# 创建一个矩阵
a = np.mat([1,2,3,4])#return matrix([[1, 2, 3, 4]])
# 输出为矩阵类型
print(type(a))# return 

#既要复制一份副本，又要保持原类型
at = np.array(a,subok=True)# return matrix([[1, 2, 3, 4]])
af = np.array(a)  # 默认为False	array([[1, 2, 3, 4]])
print('at,subok为True:',type(at))#return at,subok为True: 
print('af,subok为False:',type(af))#return af,subok为False: 
print(id(at),id(a)) #2200433545392 2200432741840
[22]
#定义个数组
a = np.array([2,4,3,1])
# 在定义b时，如果想复制a的几种方案：

# 1.使用np.array()
b = np.array(a)
print('b = np.array(a)：',id(b),id(a))

# 2.使用数组的copy()方法
c = a.copy()
print('c = a.copy()：',id(c),id(a))

# 注意不能直接使用=号复制，直接使用=号，会使2个变量指向相同的内存地址
d = a
# 修改d也会相应的修改a
print('d = a：',id(d),id(a))
b = np.array(a)： 2066731363744 2066731901216
c = a.copy()： 2066732267520 2066731901216
d = a： 2066731901216 2066731901216

练习

创建一个一维数组
创建一个二维数组
创建嵌套序列数量不一样的数组，查看结果
测试数组a，将数组赋值给b，修改b中的一个元素，查看a是否变化。
紧接着4.如果想让b变化不影响a，如何实现
arange()生成区间数组
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

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

参数说明

序号	参数	描述说明
1	start	起始值，默认为0
2	stop	终止值（不包含）
3	step	步长，默认为1
4	dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
[23]
np.arange(10)#效果等同 np.array(range(10))不包括stop
# return array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
[24]
# 可以使用浮点型数值
np.arange(3.1)# return array([0., 1., 2., 3.])
[25]
# 这个的结果？
range(3.1)# 报类型错误TypeError，只能是整型
[27]
# 返回浮点型的，也可以指定类型
x = np.arange(5, dtype =  float)  #return array([0., 1., 2., 3., 4.])
设置了起始值、终止值及步长：
[28]
# 起始10 ，终止值20 步长2
np.arange(10,20,2)#return array([10, 12, 14, 16, 18])
[29]
# 起始0 ，终止值10 步长3

ar2 = np.arange(20,3) #return array([], dtype=int32),起始位置为20，终止位置为3，为空
[31]
#正确的书写格式是什么
# 起始0 ，终止值10 步长3
ar2 = np.arange(0,20,3) #return array([ 0,  3,  6,  9, 12, 15, 18])
ar3 = np.arange(20,step=3) #return array([ 0,  3,  6,  9, 12, 15, 18])
[32]
# 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：
np.arange(10000)#return array([   0,    1,    2, ..., 9997, 9998, 9999])
题目：
在庆祝教师节活动中，学校为了烘托节日气氛，在200米长的校园主干道一侧，

从起点开始，每间隔3米插一面彩旗，由近到远排成一排，

问：1.最后一面彩旗会插到终点处吗？

2.一共应插多少面彩旗？

[34]
# 1最后一面彩旗会插到终点处吗？
np.arange(0,200+1,3)
len(np.arange(0,200+1,3))# 67
如何防止 float 不精确影响numpy.arange
注意：ceil((stop - start)/step)确定项目数，小浮点不精确(stop = .400000001)可以向列表中添加意外值。

想得到一个长度为3的、从0.1开始的、间隔为0.1的数组，想当然地如下coding，结果意料之外：
np.arange(0.1,0.4,0.1)#return array([0.1, 0.2, 0.3, 0.4])
np.arange(0.1,0.5,0.1)#return array([0.1, 0.2, 0.3, 0.4])

等差数列

linspace() 创建等差数列
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等差数列构成

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明

序号	参数	描述说明
1	start	必填项，序列的起始值，
2	stop	必填项，序列的终止值，如果endpoint为true，该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True。
5	retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
6	dtype	ndarray 的数据类型
[36]
# 以下实例用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
a = np.linspace(1,10,10)#return array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
[37]
a = np.linspace(1,10,endpoint=False)
len(a)#50
"""
array([1.  , 1.18, 1.36, 1.54, 1.72, 1.9 , 2.08, 2.26, 2.44, 2.62, 2.8 ,
       2.98, 3.16, 3.34, 3.52, 3.7 , 3.88, 4.06, 4.24, 4.42, 4.6 , 4.78,
       4.96, 5.14, 5.32, 5.5 , 5.68, 5.86, 6.04, 6.22, 6.4 , 6.58, 6.76,
       6.94, 7.12, 7.3 , 7.48, 7.66, 7.84, 8.02, 8.2 , 8.38, 8.56, 8.74,
       8.92, 9.1 , 9.28, 9.46, 9.64, 9.82])
"""

[38]
# 使用等差数列 实现输出0 0.5 1 1.5 2 2.5 3 3.5 4
A = np.linspace(0, 4, 9)
print(A) # return array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. ])

[39]
# 一下实例用到三个参数，设置起始位置为2.0，终点为3,0 数列个数为5
ar1 = np.linspace(2.0, 3.0, num=5)#return array([2.  , 2.25, 2.5 , 2.75, 3.  ])
[40]
# 设置参数endpoint 为False时，不包含终止值
ar1 = np.linspace(2.0, 3.0, num=5, endpoint=False)#return array([2. , 2.2, 2.4, 2.6, 2.8])
[42]
#设置retstep显示计算后的步长
ar1 = np.linspace(2.0,3.0,num=5, retstep=True)#(array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25)
type(ar1)#元组类型 tuple

#设置retstep显示计算后的步长
ar1 = np.linspace(2.0,3.0,num=5,endpoint=False,retstep=True)#return (array([2. , 2.2, 2.4, 2.6, 2.8]), 0.2)
[43]
#想得到一个长度为10的、从0.1开始的、间隔为0.1的数组
np.linspace(0.1,1,10)
array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
等差数列 在线性回归经常作为样本集

等比数列

等比数列
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等比数列构成

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数说明

序号	参数	描述说明
1	start	必填项，序列的起始值，
2	stop	必填项，序列的终止值，如果endpoint为true，该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True。
5	base	对数 log 的底数
6	dtype	ndarray 的数据类型
[46]
a = np.logspace(0,9,10,base=2)# array([  1.,   2.,   4.,   8.,  16.,  32.,  64., 128., 256., 512.])  2**9=512
np.logspace(A,B,C,base=D)

A: 生成数组的起始值为D的A次方
B:生成数组的结束值为D的B次方
C:总共生成C个数
D:指数型数组的底数为D，当省略base=D时，默认底数为10
[47]
# 我们先使用前3个参数，将[1,5]均匀分成3个数，得到{1,3,5}，
# 然后利用第4个参数base=2(默认是10）使用指数函数可以得到最终输出结果 {2^1,2^3,2^5}
np.logspace(1,5,3,base=2)# return array([ 2.,  8., 32.])
[48]
# 取得1到2之间10个常用对数
np.logspace(1.0,2.0,num=10)
array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,
        27.82559402,  35.93813664,  46.41588834,  59.94842503,
        77.42636827, 100.        ])
[49]
a =  np.linspace(1.0,2.0,num=10)
print(a)
10 ** a
[1.         1.11111111 1.22222222 1.33333333 1.44444444 1.55555556
 1.66666667 1.77777778 1.88888889 2.        ]

array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,
        27.82559402,  35.93813664,  46.41588834,  59.94842503,
        77.42636827, 100.        ])

全0数列

创建指定大小的数组，数组元素以 0 来填充
numpy.zeros(shape, dtype = float, order = 'C')
参数说明
序号	参数	描述说明
1	shape	数组形状
2	dtype	数据类型，可选
[50]
# 默认为浮点数
np.zeros(5)
array([0., 0., 0., 0., 0.])
[51]
# 设置为整形
np.zeros((5,), dtype = 'int')# return array([0, 0, 0, 0, 0])
np.zeros((5), dtype = 'int') #return array([0, 0, 0, 0, 0])
[52]
# 2行2列的全0数组
np.zeros((2,2))
array([[0., 0.],
       [0., 0.]])
[53]
#zeros_like返回具有与给定数组相同的形状和类型的零数组
ar1 = np.array([[1,2,3],[4,5,6]])#二维数组
np.zeros_like(ar1)
array([[0, 0, 0],
       [0, 0, 0]])

全1数列

# 全为1的数列
ar5 = np.ones(9)# return array([1., 1., 1., 1., 1., 1., 1., 1., 1.])
ar6 = np.ones((2,3,4))#2块3行4列
		array([[[1., 1., 1., 1.],
		        [1., 1., 1., 1.],
		        [1., 1., 1., 1.]],
		
		       [[1., 1., 1., 1.],
		        [1., 1., 1., 1.],
		        [1., 1., 1., 1.]]])
ar7 = np.ones_like(ar3)#将ar3里面元素变为1

NumPy 数组属性

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
1.ndarray.shape
返回一个包含数组维度的元组，对于矩阵，n 行 m 列，它也可以用于调整数组维度

[55]
a = np.array([1,2,3,4,5,6])
print('一维数组：',a.shape)#return 一维数组： (6,) 一维数组以元组类型返回列的个数

b = np.array([[1, 2, 3], [4, 5, 6]])
print('二维数组：', b.shape)#return 二维数组： (2, 3)

c = np.array([
    [
        [1, 2, 3],
        [4, 5, 6]
    ],
    [
        [11, 22, 33],
        [44, 55, 66]
        ]
    ])
print('三维数组：', c.shape)#return 三维数组： (2, 2, 3) 2块2行3列

调整维度 reshape

调整维度 reshape：返回调整维度后的副本，而不改变原 ndarray。
a = np.array([1,2,3,4,5, 6])
print('一维数组a：',a.shape)# return 一维数组a： (6,)
b = a.reshape((2,3))# 使用a数组，创建一个新的数组b，并向形状修改为2行3列
print('b的形状：',b.shape)#return b的形状： (2, 3)
print('b：', b) #return 
#					b： [[1 2 3]
#						 [4 5 6]]
print('a的形状：',a.shape)#return a的形状： (6,)
print('a：', a)#return  a： [1 2 3 4 5 6]
c = a.reshape((2,4))# 不可以修改(2,4)，因为2*4 = 8，需要至少八个元素，元素不够，报错 ValueError ：size 6 into shape (2,4)

调整维度 resize

numpy.resize(a, new_shape) 如果新数组大于原始数组，则新数组将填充a的重复副本。
请注意，此行为与a.resize(new_shape)不同，后者用零而不是重复的a填充。
# a 为2行2列
a=np.array([
        [0,1],
        [2,3]
    ])
# 一a为原数组创建2行3列的新数组
b_2_3 = np.resize(a,(2,10))
  return array([[0, 1, 2, 3, 0, 1, 2, 3, 0, 1],
		       [2, 3, 0, 1, 2, 3, 0, 1, 2, 3]])

ndarray.ndim

返回数组的维度（秩）:轴的数量，或者维度的数量，是一个标量，一维数组的秩为 1，二维数组的秩为 2
a = np.array([1,2,3,4,5, 6])#一维数组
b = a.reshape((2,3))#二维数组
#(2,2,3)三维数组
c = np.array([
    [
        [1, 2, 3],
        [4, 5, 6]
    ],
    [
        [11, 22, 33],
        [44, 55, 66]
        ]
    ])
print('a的ndim：',a.ndim)#return a的ndim： 1
print('b的ndim：', b.ndim)#return a的ndim： 2
print('c的ndim：', c.ndim)#return a的ndim： 3

ndarray.size

数组元素的总个数，相当于 .shape 中 n*m 的值
a = np.array([1,2,3,4,5,6])
print('[1,2,3,4,5,6]的size:', a.size)#[1,2,3,4,5,6]的size: 6

b = np.array([[1,2,3],[4,5,6]])
print('[[1,2,3],[4,5,6]]的size:', b.size)#[[1,2,3],[4,5,6]]的size: 6
len(a)#6
len(b)#2

ndarray.dtype

ndarray 对象的元素类型
a = np.array([1,2,3,4,5,6])
print(a.dtype)# return int32
b = np.array([1.1,2,3,4,5,6])
print(b.dtype) #return float64

方法astype()

方法astype():numpy数据类型转换，调用astype返回数据类型修改后的数据，但是源数据的类型不会变
a=np.array([1.1, 1.2])
print('a数据类型：',a.dtype)  # return a数据类型： float64
print('astype修改数据类型:',a.astype('float32').dtype)#return astype修改数据类型: float32
print('原数据类型未改变',a.dtype) #return 原数据类型未改变 float64
# 正确操作
a = a.astype('float32')
print('修改类型后再次操作，类型改变:',a.dtype)#return 修改类型后再次操作，类型改变: float32

ndarray.itemsize

ndarray.itemsize:以字节的形式返回数组中每一个元素的大小。
例如，一个元素类型为 float64 的数组 itemsize 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节）
a = np.array([1.1,2.2,3.3])
print('dtype:',a.dtype,' itemsize:',a.itemsize) #return dtype: float64  itemsize: 8
b = np.array([1,2,3,4,5])
print('dtype:',b.dtype,' itemsize:',b.itemsize) #dtype: int32  itemsize: 4

数据类型

# 将数组中的类型存储为浮点型
a = np.array([1,2,3,4],dtype=np.float64) #return array([1., 2., 3., 4.])
# 将数组中的类型存储为布尔类型
a = np.array([0,1,2,3,4],dtype=np.bool_)#return array([False,  True,  True,  True,  True])
a = np.array([0,1,2,3,4],dtype=np.float_)#return array([0., 1., 2., 3., 4.])
# str_和string_区别
str1 = np.array([1,2,3,4,5,6],dtype=np.str_)
string1 = np.array([1,2,3,4,5,6],dtype=np.string_)
str2 = np.array(['我们',2,3,4,5,6],dtype=np.str_)
print(str1,str1.dtype)#return ['1' '2' '3' '4' '5' '6'] 
print(string1,string1.dtype)#return [b'1' b'2' b'3' b'4' b'5' b'6'] |S1
print(str2,str2.dtype)#return ['我们' '2' '3' '4' '5' '6'] 
在内存里统一使用unicode， 记录到硬盘或者编辑文本的时候都转换成了utf8 UTF-8 将Unicode编码后的字符串保存到硬盘的一种压缩编码方式

定义结构化数据

还可以将两个字符作为参数传给数据类型的构造函数。此时，第一个字符表示数据类型， 第二个字符表示该类型在内存中占用的字节数（2、4、8分别代表精度为16、32、64位的 浮点数）：
# 首先创建结构化数据类型
dt = np.dtype([('age','i1')]) 
print(dt)#return [('age', 'i1')]
# 将数据类型应用于 ndarray 对象
students = np.array([(18),(19)],dtype=dt)
students#return array([(18,), (19,)], dtype=[('age', 'i1')])
以下示例描述一位老师的姓名、年龄、工资的特征，该结构化数据其包含以下字段：
str 字段：name
int 字段：age
float 字段：salary
import numpy as np
teacher = np.dtype([('name',np.str_,2), ('age', 'i1'), ('salary', 'f4')])
#输出结构化数据teacher
print(teacher)#return [('name', '
#将其应用于ndarray对象
b = np.array([('wl', 32, 8357.50),('lh', 28, 7856.80)], dtype = teacher) 
print(b)#return [('wl', 32, 8357.5) ('lh', 28, 7856.8)]

切片和索引

ndarray对象索引或切片与 Python 中 list 的切片操作一样。
区别在于：数组切片是原始数组视图（做任何修改，原始都会跟着更改）。不想更改原始数组，我们需要进行显式的复制，从而得到它的副本（.copy())。
冒号分隔切片参数 [start:stop:step]

一维数组

ar1 = np.arange(10)#return array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 从索引 2 开始到索引 7 停止，间隔为 2(不包含结束7)
ar2 = ar1[2:7:2]#return array([2, 4, 6])
冒号 : 的解释：
1.如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
2.如果为 [2:]，表示从该索引开始以后的所有项都将被提取。
3.如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项
# 返回索引对应的数据，（注意是从0开始的）
print('ar1[4]:',ar1[4]) #return 4
ar3 = np.arange(1,20,2)#return array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19])  不包含结束end--20

二维数组

# 定义4行5列的数据
ar4_5 = np.arange(20).reshape(4,5)
		return			array([[ 0,  1,  2,  3,  4],
						       [ 5,  6,  7,  8,  9],
						       [10, 11, 12, 13, 14],
						       [15, 16, 17, 18, 19]])
# 返回ar4_5的秩（几维）
ar4_5.ndim #return 2
# 切片为下一维度的一个元素，所以是一维数组
ar4_5[2] #return array([10, 11, 12, 13, 14])
# 二次索引取得，一维数组中的元素
ar4_5[2][2] #return 12
ar4_5[2:]
		return array([[10, 11, 12, 13, 14],
		      		 [15, 16, 17, 18, 19]])
s = ar4_5[:][0]#[:]取出所有行，然后[0]取第一个(即第一行)   return array([0, 1, 2, 3, 4])
注意：切片还可以使用省略号“…”，如果在行位置使用省略号，那么返回值将包含所有行元素，反之，则包含所有列元素。
# 需要取得第二列数据
ar4_5[...,1] #[行,列] return array([ 1,  6, 11, 16])
#返回第二列后的所有项
ar4_5[...,1:]
			return 			array([[ 1,  2,  3,  4],
							       [ 6,  7,  8,  9],
							       [11, 12, 13, 14],
							       [16, 17, 18, 19]])							      

索引的高级操作

整数数组索引

在 NumPy 中还可以使用高级索引方式，比如整数数组索引、布尔索引
#创建二维数组
x = np.array([
        [1,2,1,1],
        [3,4,1,2],
        [5,6,2,3]
    ])
#[0,1,2]代表行索引;[0,1,0]代表列索引, y分别获取x中的(0,0)、(1,1) 和(2,0)的数据[行,列],行[进行选择]，列[进行选择]
y = x[
    [0,1,2],[0,1,0]
] 	#return array([1, 4, 5])
#取出0行所有列，1行所有列，2行所有列
x[
    [0,1,2],:
] 
			return		array([[1, 2, 1, 1],
						       [3, 4, 1, 2],
						       [5, 6, 2, 3]])
获取了 4*3 数组中的四个角上元素，它们对应的行索引是 [0,0] 和 [3,3]，列索引是 [0,2] 和 [0,2]， # (0,0)(0,2) (3,0) (3,2)
b = np.array([[ 0, 1, 2],
              [ 3, 4, 5],
              [ 6, 7, 8],
              [ 9,10,11]])
a = b[[0,0,3,3],[0,2,0,2]] #return array([ 0,  2,  9, 11])
r = np.array([[0,0] ,[3,3]]).reshape(4)#return array([0, 0, 3, 3])
l = np.array([[0,2] ,[0,2]]).reshape(4)#return array([0, 2, 0, 2])
s = b[r,l].reshape((2,2))#取出(0,0)(0,2) (3,0) (3,2)，变成2行2列二维
			return					array([[ 0,  2],
								          [9, 11]])
a = np.array([
        [1,2,3], 
        [4,5,6],
        [7,8,9]
    ])
# 行取得2行和3行，列取得2列和3列
b = a[1:3, 1:3]
			return				array([[5, 6],
								       [8, 9]])
c = a[1:3,[1,2]]
				return 			array([[5, 6],
								       [8, 9]])							      							       
# ... 表示所有行，1: 表示从第二列开始的所有列
d = a[...,1:]
			return 		array([[2, 3],
						       [5, 6],
						       [8, 9]])

布尔数组索引

布尔索引: 实现的是通过一维数组中的每个元素的布尔型数值对一个与一维数组有着同样行数或列数的矩阵进行符合匹配。 这种作用，其实是把一维数组中布尔值为True的相应行或列给抽取了出来
（注意：一维数组的长度必须和想要切片的维度或轴的长度一致）。
# #返回所有大于6的数字组成的数组
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]])
print(x.shape)#return (4, 3)
x[x>6]#return array([ 7,  8,  9, 10, 11])
提取出数组中所有奇数
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]])
x[x%2 == 1]#return array([ 1,  3,  5,  7,  9, 11]) 
x[x%2 == 1] = -1#修改奇数值修改为-1
				return 			array([[ 0, -1,  2],
								       [-1,  4, -1],
								       [ 6, -1,  8],
								       [-1, 10, -1]])
& 和		| 或		
x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]])
# 以上x中大于4并且小于9的数据
x[(x>4) & (x<9)]	#return array([5, 6, 7, 8])
# 以上x中小于4或者大于9的数据
x[(x<4) | (x>9)]	#return array([ 0,  1,  2,  3, 10, 11])	
注意：True和False的形式表示需要和不需要的数据		
# 创建3*4的数组
a3_4 = np.arange(12).reshape((3,4))
				array([[ 0,  1,  2,  3],
				       [ 4,  5,  6,  7],
				       [ 8,  9, 10, 11]])
# 行变量 存在3个元素
row1 = np.array([False,True,True])
a3_4[row1]# a3_4 是3行, 做切片时也提供3个元素的数组,轴的长度一致
			return array([[ 4,  5,  6,  7],
			       		 [ 8,  9, 10, 11]])
# 列变量 存在4个元素
column1 = np.array([True,False,True,False])				       
a3_4[:,column1]#所有行，列进行刷选
				return			array([[ 0,  2],
								       [ 4,  6],
								       [ 8, 10]])
a3_4[row1,column1]#return array([ 4, 10])
注意：索引形状不匹配，两个一维布尔数组中True的个数需要相等
	# 行变量 2个True元素
	row2 = np.array([False,True,True])
	# 列变量 存在3 个True元素
	column2 = np.array([True,False,True,True])
	# 行列中的True个数不一致,会导致错误，行true必须==列的true
	a3_4[row2, column2] # 相当于 a3_4[[1,2],[0,2,3]]   报错IndexError Traceback (most recent call last)	
解决方案：是因为所选索引形状不匹配：
			例如我需要选择第1行和最后一行的第1，3，4列时，先选择行，再选择列。
			先读取数组 a3_4 的第一行和最后一行，保存到 temp ，然后再筛选相应的列即可。       
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
# 选择第1行和最后一行的第1，3，4列,操作步骤
temp = a3_4[[0,-1],:]# 第一步:先选行
				return			array([[ 0,  1,  2,  3],
								       [ 8,  9, 10, 11]])
# 第二步:再选择列
temp[:,[0,2,3]] 
				return	array([[ 0,  2,  3],
						       [ 8, 10, 11]])
# 合并一条
a3_4[[0,-1],:][:,[0,2,3]]	

数组索引及切片的值更改会修改原数组

# 一个标量赋值给一个索引/切片时，会自动改变/传播原始数组
	ar = np.arange(10)
	print(ar)
	ab = ar[:]
	ar[5] = 100
	print(ab)
	print(ar)
			return 		[0 1 2 3 4 5 6 7 8 9]
						[  0   1   2   3   4 100   6   7   8   9]
						[  0   1   2   3   4 100   6   7   8   9]
# 可以使用复制操作
	ar = np.arange(10)
	b = ar.copy()# 复制
	# 或者 b = np.array(ar)
	b[7:9] = 200
	print('ar:',ar)#ar: [0 1 2 3 4 5 6 7 8 9]
	print('b:',b)#b: [  0   1   2   3   4   5   6 200 200   9]

广播机制

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

	理解2：
		将两个数组的维度大小右对齐，然后比较对应维度上的数值
	    如果数值相等或其中有一个为1或者为空，则能进行广播运算
	    输出的维度大小为取数值大的数值。否则不能进行数组运算
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
为了保持数组形状相同，NumPy 设计了一种广播机制， 这种机制的核心是对形状较小的数组，在横向或纵向上进行一定次数的重复，使其与形状较大的数组拥有相同的维度。
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)
			return 			[[ 1  2  3]
							 [11 12 13]
							 [21 22 23]
							 [31 32 33]]
广播的规则:
	让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
	输出数组的形状是输入数组形状的各个维度上的最大值。
	如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
	当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
#两个数组的形状为 M.shape=(2,3),a.shape=(3,)
#可以看到，根据规则1,数组a的维度更小，所以在其左边补1,变为M.shape -> (2,3), a.shape -> (1,3)
#根据规则2,第一个维度不匹配，因此扩展这个维度以匹配数组：M.shape ->(2,3), a.shape -> (2,3)
#现在两个数组的形状匹配了，可以看到它们的最终形状都为(2,3):
M = np.ones((2,3))
	[[1. 1. 1.]
 	[1. 1. 1.]]
a = np.arange(3)
	[0 1 2]

M + a
		return	array([[1., 2., 3.],
		       		  [1., 2., 3.]])
#两个数组的形状为：a.shape=(3,1), b.shape=(3,)
#规则1告诉我们，需要用1将b的形状补全：a.shape -> (3,1), b.shape -> (1,3)
#规则2告诉我们，需要更新这两个数组的维度来相互匹配：a.shape -> (3,3), b.shape -> (3,3)
#因为结果匹配，所以这两个形状是兼容的
a = np.arange(3).reshape((3,1))
	return 		[[0]
				 [1]
				 [2]]
b = np.arange(3)#return [0 1 2]
a + b
	return 	array([[0, 1, 2],
		       [1, 2, 3],
		       [2, 3, 4]])
对于广播规则另一种简单理解
		将两个数组的维度大小右对齐，然后比较对应维度上的数值，
		如果数值相等或其中有一个为1或者为空，则能进行广播运算，
		输出的维度大小为取数值大的数值。否则不能进行数组运算。
数组a大小为(2, 3)
数组b大小为(1,)
		首先右对齐：
		   2   3
		       1
		----------
		   2   3
所以最后两个数组运算的输出大小为：（2， 3）
[65]
# 数组a大小为(2, 3)
a = np.arange(6).reshape(2, 3)
	return [[0 1 2]
		    [3 4 5]]
# 数组b大小为(1,)
b = np.array([5])
	return [5]
c = a * b 
		# 输出的大小为(2, 3)
		array([[ 0,  5, 10],
		       [15, 20, 25]])		

数组a大小为(2, 1, 3)
数组b大小为(4, 1)
首先右对齐：
 2  1  3
    4  1
----------
 2  4  3
所以最后两个数组运算的输出大小为：（2, 4, 3）
[66]
# 数组大小为(2, 1, 3)
a= np.arange(6).reshape(2, 1, 3)
	return 		[[[0 1 2]]
				 [[3 4 5]]]
# 数组大小为(4, 1)
b = np.arange(4).reshape(4, 1)
	return [[0]
			[1]
			[2]
		    [3]]
c = a + b#变成（2,4,3）二块四行三列
print(c,c.shape)		return [[[0 1 2]
								 [1 2 3]
								 [2 3 4]
								 [3 4 5]]
					
							   [[3 4 5]
								[4 5 6]
								[5 6 7]
								[6 7 8]]] (2, 4, 3)
两个数组右对齐以后，对应维度里的数值要么相等，要么有一个为1，要么缺失取大值。
除此之外就会报错。像下面的两个数组就不能做运算。
数组a大小为(2, 1, 3)
数组b大小为(4, 2)
首先右对齐：
 2  1  3
    4  2
----------
2跟3不匹配，此时就不能做运算,报错ValueError Traceback (most recent call last)

统计函数

求平均值 mean()

m1 = np.arange(20).reshape((4,5))
	[[ 0  1  2  3  4]
 	 [ 5  6  7  8  9]
	 [10 11 12 13 14]
 	 [15 16 17 18 19]]
# 默认求出数组所有元素的平均值
m1.mean()#return 9.5
若想求某一维度的平均值，设置 axis 参数，多维数组的元素指定
axis = 0,将从上往下计算
axis = 1,将从左往右计算
m1 = np.arange(20).reshape((4,5))
	[[ 0  1  2  3  4]
 	 [ 5  6  7  8  9]
	 [10 11 12 13 14]
 	 [15 16 17 18 19]]	
# axis=0将从上往下计算平均值
m1.mean(axis=0)#return array([ 7.5,  8.5,  9.5, 10.5, 11.5])
# axis=1 将从左往右计算平均值
m1.mean(axis=1)#return array([ 2.,  7., 12., 17.])

中位数 np.median

又称中点数，中值
是按顺序排列的一组数据中居于中间位置的数，代表一个样本、种群或概率分布中的一个数值
平均数：是一个"虚拟"的数，是通过计算得到的，它不是数据中的原始数据。. 中位数：是一个不完全"虚拟"的数。
平均数：反映了一组数据的平均大小，常用来一代表数据的总体 "平均水平"。. 中位数：像一条分界线，将数据分成前半部分和后半部分，因此用来代表一组数据的"中等水平"
ar1 = np.array([1,3,5,6,8]) #return 5
ar1 = np.array([1,3,5,6,8,9]) #return 5.5

求标准差 ndarray.std

在概率统计中最常使用作为统计分布程度上的测量,是反映一组数据离散程度最常用的一种量化形式，是表示精确度的重要指标
		标准差定义是总体各单位标准值与其平均数离差平方的算术平均数的平方根。
简单来说，标准差是一组数据平均值分散程度的一种度量。
		一个较大的标准差，代表大部分数值和其平均值之间差异较大；
		一个较小的标准差，代表这些数值较接近平均值。
a = np.array([95,85,75,65,55,45])
b = np.array([73,72,71,69,68,67])#成绩稳定，差别不大
print('A组的标准差为:',a.std())#return A组的标准差为: 17.07825127659933
print('B组的标准差为:',b.std())#return B组的标准差为: 2.160246899469287

方差ndarray.var()

衡量随机变量或一组数据时离散程度的度量
a = np.array([95,85,75,65,55,45])
b = np.array([73,72,71,69,68,67])
print('A组的方差为:',a.var()) #return A组的方差为: 291.6666666666667
print('B组的方准差为:',b.var()) #return B组的方准差为: 4.666666666666667
标准差有计量单位，而方差无计量单位，但两者的作用一样，虽然能很好的描述数据与均值的偏离程度，但是处理结果是不符合我们的直观思维的。

求最大值 ndarray.max(),最小值 ndarray.min()

print(m1)
		[[ 0  1  2  3  4]
		 [ 5  6  7  8  9]
		 [10 11 12 13 14]
		 [15 16 17 18 19]]	
print(m1.max())#return 19
print('axis=0,从上往下查找:',m1.max(axis=0)) #return axis=0,从上往下查找: [15 16 17 18 19]
print('axis=1,从左往右查找',m1.max(axis=1)) #return axis=1,从左往右查找 [ 4  9 14 19]

求和 ndarray.sum()

print(m1.sum()) #return 190
print('axis=0,从上往下查找:',m1.sum(axis=0))#return axis=0,从上往下查找: [30 34 38 42 46]
print('axis=1,从左往右查找',m1.sum(axis=1)) #return axis=1,从左往右查找 [10 35 60 85]

加权平均值 numpy.average()

即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数
numpy.average(a, axis=None, weights=None, returned=False)
weights： 数组，可选
`与 a 中的值关联的权重数组。 a 中的每个值都根据其关联的权重对平均值做出贡献。权重数组可以是一维的
(在这种情况下，它的长度必须是沿给定轴的 a 的大小)或与 a 具有相同的形状。如果 weights=None，则假定 a 中的所有数据的权重等于 1。一维计算是：
avg = sum(a * weights) / sum(weights)
对权重的唯一限制是 sum(weights) 不能为 0。
average_a1 = [20,30,50]
print(np.average(average_a1))#return 33.333333333333336
print(np.mean(average_a1))# return  33.333333333333336

xiaoming = np.array([80,90,95])
xiaogang = np.array([95,90,80])
# 权重:
weights = np.array([0.2,0.3,0.5])
# 分别计算小明和小刚的平均值
print(np.mean(xiaoming))#return 88.33333333333333
print(np.mean(xiaogang))#return 88.33333333333333
# 分别计算小明和小刚的加权平均值
print(np.average(xiaoming,weights = weights))#return 90.5
print(np.average(xiaogang,weights = weights))# return 86.0

操作文件 loadtxt

loadtxt读取txt文本、、csv文件

loadtxt(fname, dtype=<type 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0,encoding='bytes')

参数：

fname：指定文件名称或字符串。支持压缩文件，包括gz、bz格式。

dtype：数据类型。 默认float。

comments：字符串或字符串组成的列表。表示注释字符集开始的标志，默认为#。

delimiter：字符串。分隔符。

converters：字典。将特定列的数据转换为字典中对应的函数的浮点型数据。例如将空值转换为0，默认为空。

skiprows：跳过特定行数据。例如跳过前1行（可能是标题或注释）。默认为0。

usecols：元组。用来指定要读取数据的列，第一列为0。例如（1， 3， 5），默认为空。

unpack：布尔型。指定是否转置数组，如果为真则转置，默认为False。

ndmin：整数型。指定返回的数组至少包含特定维度的数组。值域为0、1、2，默认为0。

encoding:编码, 确认文件是gbk还是utf-8 格式

返回：从文件中读取的数组。

# 读取csv文件 ,取药设置分隔符,csv默认为,号
data = np.loadtxt('csv_test.csv',dtype=np.int32,delimiter=',')

不同列标识不同信息 数据读取

姓名 年龄 性别 身高
小王 21 男 170
.....
老王 50 男 180
文件:has_title.txt
# 1. 以上数据由于不同列数据标识的含义和类型不同,因此需要自定义数据类型
user_info = np.dtype([('name','U10'),('age','i1'),('gender','U1'),('height','i2')])
# 2. 使用自定义的数据类型 读取数据,
data = np.loadtxt('has_title.txt',dtype=user_info,skiprows=1, encoding='utf-8')
#dtype=int表示第2，4列数据类型为整型,skiprows=1跳过一行,usecols=(1,3)选择第2，4列(0,1,2,3)
#data = np.loadtxt('has_title.txt',dtype=int,skiprows=1,usecols=(1,3), encoding='utf-8')
# 注意以上参数中:a.设置类型;  b.跳过第一行; c.跳过第一行;  d.编码
print(data['age']) #return  [21 25 19 40 24 21 19 26 21 21 19 20]
# 计算女生的平均身高
isgirl = data['gender'] == '女'#return [False  True  True False False  True  True False False  True  True  True]
print(data['height'])#return [170 165 167 180 168 167 159 170 168 175 160 167]
print(data['height'][isgirl])#return [165 167 167 159 175 160 167]
girl_mean = np.mean(data['height'][isgirl])#return 165.71428571428572
'{:.2f}'.format(girl_mean)#return '165.71'

读取指定的列

# 读取指定的列 usecols=(1,3) 标识只读取第2列和第4列
user_info = np.dtype([('age','i1'),('height','i2')])#return [('age', 'i1'), ('height', '
# 使用自定义的数据类型 读取数据,dtype代表usecols的数据类型
data = np.loadtxt('has_title.csv',dtype=user_info,delimiter=',',skiprows=1,usecols=(1,3))#return [(22, 170) (25, 165) (19, 167) (20, 169) (21, 161) (19, 159) (27, 177)]

数据中存在空值进行处理

# 读取指定的列 usecols=(1,3) 标识只读取第2列和第4列
user_info = np.dtype([('age','i1'),('height','i2')])
has_empty_data = np.loadtxt('has_empty_data.csv',dtype=user_info,delimiter=',',skiprows=1, usecols=(1,3))
has_empty_data #return ValueError Traceback (most recent call last)
#########################################################################
# 处理空数据,需要创建一个函数,接收列的参数,并加以处理.
def parse_age(age):
    try:
        return int(age)
    except:
        return 0
# 和之前一样的步骤
print(user_info)#return [('age', 'i1'), ('height', '
# 使用自定义的数据类型 读取数据,
data = np.loadtxt('has_empty_data.csv',dtype=user_info,delimiter=',',skiprows=1,usecols=(1,3),converters={1:parse_age,3:parse_age})
print(data)#return [(21, 170) (25, 165) (19, 167) ( 0, 169) (21, 161) (19,   0) (27, 177)]
age_arr = data['age']#return array([21, 25, 19,  0, 21, 19, 27], dtype=int8)
#age_arr == 0的位置用中位数替补
age_arr[age_arr == 0] = np.median(age_arr[age_arr != 0])#return array([21, 25, 19, 21, 21, 19, 27], dtype=int8)
age_arr.mean()#return 21.857142857142858平均数

随机函数和常用函数

随机函数

numpy.random.rand(d0,d1,…,dn)

numpy.random.rand(d0,d1,…,dn)，生成指定维度的随机数
		rand函数根据给定维度生成[0,1)之间的数据，包含0，不包含1
		dn表示每个维度
		返回值为指定维度的array
# 创建4行2列的随机数据
np.random.rand(4,2) 
		return 		array([[0.28344252, 0.96060635],
					       [0.00491531, 0.78328467],
					       [0.86121744, 0.20933359],
					       [0.12919677, 0.27799833]])
# 创建2块2行3列的随机数据
np.random.rand(2,2,3)
			array([[[0.67169909, 0.0457744 , 0.20893651],
			        [0.38986624, 0.19702793, 0.26994715]],
			
			       [[0.75576316, 0.30120561, 0.36700357],
			        [0.13657091, 0.78269401, 0.28614991]]])

numpy.random.randn(d0,d1,…,dn)

numpy.random.randn(d0,d1,…,dn)
	randn函数返回一个或一组样本，具有标准正态分布。
	dn表示每个维度
	返回值为指定维度的array
	标准正态分布又称为u分布，是以0为均值、以1为标准差的正态分布，记为N（0，1）。
from matplotlib import pyplot as plt
a = np.random.randn(10)
print(a)#return [-0.09138156  0.9822674  -1.42153955  0.65496346 -0.09985213  0.07374141  0.11449538  0.19677832 -0.1747699  -2.42638148]
# 直方图
plt.hist(a)

正态分布numpy.random.normal()

numpy.random.normal(loc=0.0, scale=1.0, size=None) 返回一个由size指定形状的数组，数组中的值服从 μ=loc,σ=scale 的正态分布。
	作用：返回一个由size指定形状的数组，数组中的值服从 μ=loc,σ=scale 的正态分布。
	参数：
		loc : float型或者float型的类数组对象，指定均值 μ
		scale : float型或者float型的类数组对象，指定标准差 σ
		size : int型或者int型的元组，指定了数组的形状。如果不提供size，且loc和scale为标量（不是类数组对象），则返回一个服从该分布的随机数。

# 标准正态分布，3行2列,均值u = 0,标准差 σ = 1；
a = np.random.normal(0, 1, (3, 2))
	[[-0.24937038  1.46210794]
	 [-2.06014071 -0.3224172 ]
	 [-0.38405435  1.13376944]]
# 均值为1，标准差为3
b = np.random.normal(1, 3, (3, 2))
	[[-2.2996738   0.48271538]
	 [-1.63357525  1.12664124]
	 [ 2.74844564 -2.30185753]]

numpy.random.randint()

numpy.random.randint(low, high=None, size=None, dtype=’l’)
	返回随机整数，范围区间为[low,high），包含low，不包含high
	参数：low为最小值，high为最大值，size为数组维度大小，dtype为数据类型，默认的数据类型是np.int
	high没有填写时，默认生成随机数的范围是[0，low)
# 返回[0,10)之间的整数，大小为5(数量)
np.random.randint(10,size=5) #return array([6, 0, 5, 1, 5])
# 返回[2,10)之间的整数,大小为5
np.random.randint(2,10,size=5) #return array([3, 5, 3, 8, 4])
# 返回1个[1,5)时间的随机整数
np.random.randint(1,5) #return 2
# 返回 -5到5之间不包含5的 2行2列数据
np.random.randint(-5,5,size=(2,2))
		array([[-5,  4],
	          [ 4,  1]])

numpy.random.sample(size = none)

numpy.random.sample(size=None) 返回半开区间内的随机浮点数[0.0，1.0)。
#返回二行三列，随机浮点数[0.0，1.0)
np.random.sample((2,3))
	array([[0.62979868, 0.44700457, 0.01811148],
	       [0.32144501, 0.23169499, 0.68568021]])

随机种子numpy.random.seed()

随机种子np.random.seed():使用相同的seed()值，则每次生成的随机数都相同,使得随机数可以预测
	但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同
np.random.seed(2)#设置种子
L1 = np.random.randn(3, 3)#产生三行三列随机数
	[[-0.41675785 -0.05626683 -2.1361961 ]
 	 [ 1.64027081 -1.79343559 -0.84174737]
	 [ 0.50288142 -1.24528809 -1.05795222]]
L2 = np.random.randn(3, 3)
	[[-0.90900761  0.55145404  2.29220801]
 	 [ 0.04153939 -1.11792545  0.53905832]
 	 [-0.5961597  -0.0191305   1.17500122]]
 	 
np.random.seed(1)
L1 = np.random.randn(3, 3)
	[[ 1.62434536 -0.61175641 -0.52817175]
 	 [-1.07296862  0.86540763 -2.3015387 ]
	 [ 1.74481176 -0.7612069   0.3190391 ]]
np.random.seed(1)
L2 = np.random.randn(3, 3)
	[[ 1.62434536 -0.61175641 -0.52817175]
	 [-1.07296862  0.86540763 -2.3015387 ]
	 [ 1.74481176 -0.7612069   0.3190391 ]]

数组的其他函数

函数名称	描述说明
resize	返回指定形状的新数组。
append	将元素值添加到数组的末尾。
insert	沿规定的轴将元素值插入到指定的元素前。
delete	删掉某个轴上的子数组，并返回删除后的新数组。
argwhere	返回数组内符合条件的元素的索引值。
unique	用于删除数组中重复的元素，并按元素值由大到小返回一个新数组。
sort()	对输入数组执行排序，并返回一个数组副本
argsort	沿着指定的轴，对输入数组的元素值进行排序，并返回排序后的元素索引数组

numpy.resize()

numpy.resize(arr, shape) 返回指定形状的新数组。
numpy.resize(arr,shape) 和ndarray.resize(shape, refcheck=False)区别:
	numpy.resize(arr,shape),有返回值,返回复制内容.如果维度不够,会使用原数组数据补齐
		a = np.array([[1,2,3],[4,5,6]])#(2,3)2行三列的数组
				[[1 2 3]
				 [4 5 6]]
		b = np.resize(a,(3,3))
			array([[1, 2, 3],
      			  [4, 5, 6],
      			  [1, 2, 3]])
	ndarray.resize(shape, refcheck=False),修改原数组,不会返回数据,如果维度不够,会使用0补齐
		a.resize((3,3),refcheck=False)
			array([[1, 2, 3],
	       		   [4, 5, 6],
	       		   [0, 0, 0]])

numpy.append()

numpy.append(arr, values, axis=None):在数组的末尾添加值，默认返回一个一维数组。
参数说明：
	arr：输入的数组；
	values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致；
	axis：默认为 None，返回的是一维数组；当 axis =0 时，从上往下，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反。
a = np.array([[1,2,3],[4,5,6]]) 
		[[1 2 3]
	 	 [4 5 6]]
#向数组a添加元素,默认返回一维数组
print (np.append(a, [7,8,9]))#return [1 2 3 4 5 6 7 8 9]
#沿轴 0 添加元素
print (np.append(a, [[7,8,9]],axis = 0))
			[[1 2 3]
			 [4 5 6]
			 [7 8 9]]
#沿轴 1 添加元素
print (np.append(a, [[5,5,5],[7,8,9]],axis = 1))	
			[[1 2 3 5 5 5]
			 [4 5 6 7 8 9]]		

numpy.insert()

numpy.insert(arr, obj, values, axis)：表示沿指定的轴，在给定索引值的前一个位置插入相应的值，如果没有提供轴，则输入数组被展开为一维数组。
参数说明：
	arr：要输入的数组
	obj：表示索引值，在该索引值之前插入 values 值；
	values：要插入的值；
	axis：指定的轴，如果未提供，则输入数组会被展开为一维数组。
a = np.array([[1,2],[3,4],[5,6]])
#不提供axis的情况，会将数组展开，在索引3之前插入
print (np.insert(a,3,[11,12]))#return [ 1  2  3 11 12  4  5  6]
#沿轴 0 垂直方向 ，将这个方向都变成这个值(第二行插入)
print (np.insert(a,1,[11],axis = 0))
			[[ 1  2]
		 	 [11 11]
		 	 [ 3  4]
			 [ 5  6]]
#沿轴 1 水平方向,将这个方向都插入成这个值(第二列插入)
print (np.insert(a,1,11,axis = 1))
		[[ 1 11  2]
		 [ 3 11  4]
		 [ 5 11  6]]

numpy.delete()

该方法表示从输入数组中删除指定的子数组，并返回一个新数组。它与 insert() 函数相似，若不提供 axis 参数，则输入数组被展开为一维数组。 numpy.delete(arr, obj, axis) 
参数说明：
	arr：要输入的数组；
	obj：整数或者整数数组，表示要被删除数组元素或者子数组；
	axis：沿着哪条轴删除子数组。
a = np.arange(12).reshape(3,4)
		[[ 0  1  2  3]
	     [ 4  5  6  7]
		 [ 8  9 10 11]]
#不提供axis参数情况，展开为一维数组，然后删除索引为5的元素
print(np.delete(a,5))# [ 0  1  2  3  4  6  7  8  9 10 11]
#删除第二列
a = np.arange(12).reshape(3,4)
		[[ 0  1  2  3]
	     [ 4  5  6  7]
		 [ 8  9 10 11]]
print(np.delete(a,1,axis = 1))
		[[ 0  2  3]
		 [ 4  6  7]
		 [ 8 10 11]]
#删除多行 删除索引为1，和2的元素
a = np.array([1,2,3,4,5,6,7,8,9,10])
print(np.delete(a,[1,2],axis = 0))#return [ 1  4  5  6  7  8  9 10]
# 注意不能使用切片的形式
#print(np.delete(a,[1:4]),axis = 0)#return SyntaxError: invalid syntax

numpy.argwhere()

该函数返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标。
x = np.arange(6).reshape(2,3)
	array([[0, 1, 2],
      	   [3, 4, 5]])
# 返回所有大于2的元素
x[x>2] #return array([3, 4, 5])
# 返回所有大于1的元素索引
y=np.argwhere(x>1)
		[[0 2]
		 [1 0]
		 [1 1]
		 [1 2]]
y.shape# return (4, 2)

numpy.unique()

用于删除数组中重复的元素，其语法格式如下： numpy.unique(arr, return_index, return_inverse, return_counts)

参数说明：

arr：输入数组，若是多维数组则以一维数组形式展开；
return_index：如果为 True，则返回新数组元素在原数组中的位置（索引）；
return_inverse：如果为 True，则返回原数组元素在新数组中的位置（索引）；
return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数。

Matplotlib

import matplotlib
matplotlib.__version__ #return '3.5.1'

第一个Matplotlib绘图程序

#首先导入 Matplotlib 包中的 Pyplot 模块,并以 as 别名的形式简化引入包的名称。
from matplotlib import pyplot as plt
#import matplotlib.pyplot as plt

#接下来，使用 NumPy 提供的函数 arange() 创建一组数据来绘制图像。
# 引入numpy包
import numpy as np
# 获得-50到50之间的ndarray对象
x = np.arange(-50,51)

#上述所得 x 的值作用到 x 轴上，而该值对应的平方值，也就是 y 值,使用以下方式获取
y = x **2

#使用 plt的plot()函数对 x、y 进行绘制。
# plot() 绘制线性图表 
plt.plot(x,y)

matplotlib的基本方法

方法名	       					 说明
title()	       					 设置图表的名称
xlabel()	   					 设置x轴名称
ylabel()	   					 设置y轴名称
xticks(ticks,label,rotation)	 设置x轴的刻度,rotation旋转角度
yticks()						 设置y轴的刻度
show()							 显示图表
legend()						 显示图例
text(x,y,text)					 显示每条数据的值 x,y值的位置

图表名称 plt.title()

import numpy as np
# x轴获得-50到50之间的ndarray对象
x = np.arange(-50,51)
# y轴的值是x轴的平方
y = x **2
# 设置图表的名称
plt.title("y= x^2")
# 绘制图形
plt.plot(x,y)

#默认不支持中文:missing from current font 字体丢失
plt.title("y等于x的平方-")
plt.plot(x,y)
"""
字体问题总结: 需要修改2个配置信息:
# 用来设置字体样式以正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei'] 
# 默认是使用Unicode负号，设置正常显示字符，如正
plt.rcParams['axes.unicode_minus']=False 
"""

# 使用中文需要进行配置信息的设置	正负号缺失
# 字体设置时,字体名称不区别大小写
plt.rcParams['font.sans-serif'] = ["FangSong"]

当字体设置支持中文后,必须设置负号,否则当数值中出现负值时,负号无法正常显示
# 解决方式: 修改轴中的负号编码
plt.rcParams['axes.unicode_minus'] = False

import numpy as np
# x轴获得-50到50之间的ndarray对象
x = np.arange(-50,51)
# y轴的值是x轴的平方
y = x **2
# 用来设置字体样式以正常显示中文标签
plt.rcParams['font.sans-serif']=['SimHei']
 # 默认是使用Unicode负号，设置正常显示字符，如正
plt.rcParams['axes.unicode_minus']=False
plt.title("y等于x的平方")
plt.plot(x,y)

x轴和y轴名称

# 创建x为-10到10的整数
x = np.arange(-10,10)
# y是x的平方
y = x ** 2
# 设置标题
plt.title('y=x^2 x取值范围为:[-10,10)')
# 设置x轴名称
plt.xlabel("x 轴")
# 设置y轴名称
plt.ylabel("y 轴")
plt.plot(x, y)

对于上面的图,如果觉得字体偏小或线条太细,可以设置标签文字大小和线条粗细
	fontsize参数: 设置文字大小
	linewidth参数: 设置线条
# 创建x为-10到10的整数
x = np.arange(-10,10)
# y是x的平方
y = x ** 2
# 设置标题
plt.title('y=x^2 x取值范围为:[-10,10)',fontsize=16)
# 设置x轴名称 ,值不能写"12px"
plt.xlabel("x 轴",fontsize=12)
# 设置y轴名称
plt.ylabel("y 轴")
# linewidth=5 设置线条宽度
plt.plot(x, y,linewidth=5)

设置x轴和y轴的刻度

matplotlib.pyplot.xticks(ticks=None, labels=None, **kwargs)

matplotlib.pyplot.yticks(ticks=None, labels=None, **kwargs)

ticks: 此参数是xtick位置的列表。和一个可选参数。如果将一个空列表作为参数传递，则它将删除所有xticks
label: 此参数包含放置在给定刻度线位置的标签。它是一个可选参数。，
**kwargs:此参数是文本属性，用于控制标签的外观
rotation:旋转角度 如:rotation=45
color:颜色 如:color="red"
# 显示x轴的刻标以及对应的标签
pltxticks( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )

# 日期
times = np.arange(2000,2022).astype(np.str_)
# 销量
sales = np.random.randint(500,2000,size=len(times))
# 绘图
plt.xticks(range(0,len(times),1),['%s年'%i for i in times],rotation=45)
plt.plot(times,sales)

# 每个时间点的销量绘图,如果x轴的数据是字符串,会将数据全部展示
times = ['2015/6/26', '2015/8/1', '2015/9/6', '2015/10/12', '2015/11/17','2015/12/23','2016/1/28','2016/3/4','2016/4/9',
'2016/5/15','2016/6/20','2016/7/26','2016/8/31','2016/10/6','2016/11/11','2016/12/17']
# 随机出销量
sales =np.random.randint(500,2000,size=len(times))
# 如果想只显示部分时间,或者按照某个规则展示,如何处理,这个时候就用到xticks
plt.xticks(range(0,len(times),2),rotation=45)
# 绘制图形
plt.plot(times,sales)

显示图表show()

jupyter notebooks会自动显示图形

图例 legend()

图例是集中于地图一角或一侧的地图上各种符号和颜色所代表内容与指标的说明，有助于更好的认识地图。