对于想了解Python数据分析：numpy的读者，本文将提供新的信息，我们将详细介绍python数据分析numpy和pandas，并且为您提供关于numpy.random.random&numpy.n
对于想了解Python数据分析：numpy的读者，本文将提供新的信息，我们将详细介绍python数据分析numpy和pandas，并且为您提供关于numpy.random.random & numpy.ndarray.astype & numpy.arange、numpy.ravel()/numpy.flatten()/numpy.squeeze()、Numpy：数组创建 numpy.arrray() , numpy.arange()、np.linspace ()、数组基本属性、Python数据分析 - numpy的有价值信息。
本文目录一览：- Python数据分析：numpy（python数据分析numpy和pandas）
- numpy.random.random & numpy.ndarray.astype & numpy.arange
- numpy.ravel()/numpy.flatten()/numpy.squeeze()
- Numpy：数组创建 numpy.arrray() , numpy.arange()、np.linspace ()、数组基本属性
- Python数据分析 - numpy
Python数据分析：numpy（python数据分析numpy和pandas）
numpy创建数组(矩阵)
创建数组
import numpy as np
a = np.array([1, 2, 3, 4, 5])
b = np.array(range(1, 6))
c = np.arange(1, 6) # np.arange用法：arange(start,stop,step,dtype=None)数组的类名和数据的类型
In [1]: type（a）
Out[1]: numpy.ndarray
In [2]: a.dtype
Out[2]: dtype(''int64'') # 常见类型有int,uint(8,16,32,64),float(16,32,64,128),complex(64,128,256),bool数据类型的操作
a = np.array([1,0,1,0], dtype=np.bool) # 创建数组时指定数据类型
a.astype(np.int8) # 修改数组的数据类型
b = np.array([0.0485,0.2689,1.8567,0.8754])
np.round(b, 2) # 修改浮点型小数位数数组的形状
a.shape # 查看数组形状
a.reshape(2,2) # 修改数组形状
a.flatten（） # 把多维数组转化为一维数组数组的计算
数组和数的计算
a = np.array([1, 2, 3, 4, 5])
b = a + 1 # 按位相加
c = a * 3 # 按位相乘数组与数组的计算
a = np.array([[1, 2, 3, 4],
[5, 6, 7, 8]])
b = np.array([[1, 1, 1, 1],
[1, 1, 1, 1]])
c = np.array([1, 1, 1, 1])
d = np.array([[1],
[1]])
O1 = a + b # 形状相同按位相加
O2 = a + c
O3 = a + d # 形状不同，只有满足广播原则才可计算，O1=O2=O3数组的转置
a.transpose()
a.swapaxes(1,0)
a.T以上的三种方法都可以实现二维数组的转置的效果，转置和交换轴的效果一样。
numpy索引和切片
a[1,:] # 取一行，可简写为a[1]
a[:,2] # 取一列
a[1:3,:] # 取连续多行，可简写为a[1：3]
a[:,2:4] # 取连续多列
a[[1,3],:] # 取离散多行，可简写为a[[1,3]]
a[:,[2,4]] # 取离散多行
a[a<2] # bool索引
np.where(a<2,0,4) # 三元运算符,满足条件1替换为0，不满足替换为4
a.clip(2,3) # 裁剪，大于3替换为3，小于2替换为2numpy中的nan和inf
nan(NAN,Nan):not a number，表示不是一个数字，type类型为float。（两个nan是不相等的）
inf:infinity，inf表示正无穷，-inf表示负无穷，type类型为float
np.count_nonzero(a!=a) # 判断a中nan个数
np.isnan(a) # 判断是否为nan，返回bool类型
a[np.isnan(a)] = 0 # nan 替换为0numpy中常用统计函数
求和：t.sum(axis=None)
均值：t.mean(axis=None)
中值：np.median(t,axis=None)
最大值：t.max(axis=None)
最小值：t.min(axis=None)
极值：np.ptp(t,axis=None) 即最大值和最小值之差
标准差：t.std(axis=None)
默认返回多维数组的全部的统计结果,如果指定axis则返回一个当前轴上的结果
数组的拼接
np.vstack(a,b) # 竖直拼接
np.hstack(a,b) # 水平拼接数组的行列交换
a[[1,2],:] = a[[2,1],:] # 行交换
a[:,[0,2]] = a[:,[2,0]] # 列交换其他实用方法
1.获取最大值最小值的位置
np.argmax(t,axis=0)
np.argmin(t,axis=1)
2.创建一个全0的数组: np.zeros((3,4))
3.创建一个全1的数组:np.ones((3,4))
4.创建一个对角线为1的正方形数组(方阵)：np.eye(3)
5.numpy生成随机数
注意：numpy的copy和view
- a=b 完全不复制，a和b相互影响
- a = b[:],视图的操作，一种切片，会创建新的对象a，但是a的数据完全由b保管，他们两个的数据变化是一致的，
a = b.copy(),复制，a和b互不影响
本次分享就到这啦，如果对您有帮助的话，麻烦点个关注再走哦~
numpy.random.random & numpy.ndarray.astype & numpy.arange
今天看到这样一句代码：
xb = np.random.random((nb, d)).astype(''float32'') #创建一个二维随机数矩阵（nb行d列）
xb[:, 0] += np.arange(nb) / 1000. #将矩阵第一列的每个数加上一个值要理解这两句代码需要理解三个函数
1、生成随机数
numpy.random.random(size=None)
size为None时，返回float。
size不为None时，返回numpy.ndarray。例如numpy.random.random((1,2))，返回1行2列的numpy数组
2、对numpy数组中每一个元素进行类型转换
numpy.ndarray.astype(dtype)
返回numpy.ndarray。例如 numpy.array([1, 2, 2.5]).astype(int)，返回numpy数组 [1, 2, 2]
3、获取等差数列
numpy.arange([start,]stop,[step,]dtype=None)
功能类似python中自带的range()和numpy中的numpy.linspace
返回numpy数组。例如numpy.arange(3)，返回numpy数组[0, 1, 2]
numpy.ravel()/numpy.flatten()/numpy.squeeze()
numpy.ravel(a, order=''C'')
Return a flattened array
numpy.chararray.flatten(order=''C'')
Return a copy of the array collapsed into one dimension
numpy.squeeze(a, axis=None)
Remove single-dimensional entries from the shape of an array.
相同点: 将多维数组 降为 一维数组
不同点:
ravel() 返回的是视图(view)，意味着改变元素的值会影响原始数组元素的值;
flatten() 返回的是拷贝，意味着改变元素的值不会影响原始数组;
squeeze()返回的是视图(view)，仅仅是将shape中dimension为1的维度去掉;
ravel()示例:
1 import matplotlib.pyplot as plt
2 import numpy as np
3
4 def log_type(name,arr):
5 print("数组{}的大小:{}".format(name,arr.size))
6 print("数组{}的维度:{}".format(name,arr.shape))
7 print("数组{}的维度:{}".format(name,arr.ndim))
8 print("数组{}元素的数据类型:{}".format(name,arr.dtype))
9 #print("数组:{}".format(arr.data))
10
11 a = np.floor(10*np.random.random((3,4)))
12 print(a)
13 log_type(''a'',a)
14
15 a1 = a.ravel()
16 print("a1:{}".format(a1))
17 log_type(''a1'',a1)
18 a1[2] = 100
19
20 print(a)
21 log_type(''a'',a)
flatten()示例
1 import matplotlib.pyplot as plt
2 import numpy as np
3
4 def log_type(name,arr):
5 print("数组{}的大小:{}".format(name,arr.size))
6 print("数组{}的维度:{}".format(name,arr.shape))
7 print("数组{}的维度:{}".format(name,arr.ndim))
8 print("数组{}元素的数据类型:{}".format(name,arr.dtype))
9 #print("数组:{}".format(arr.data))
10
11 a = np.floor(10*np.random.random((3,4)))
12 print(a)
13 log_type(''a'',a)
14
15 a1 = a.flatten()
16 print("修改前a1:{}".format(a1))
17 log_type(''a1'',a1)
18 a1[2] = 100
19 print("修改后a1:{}".format(a1))
20
21 print("a:{}".format(a))
22 log_type(''a'',a)
squeeze()示例：
1. 没有single-dimensional entries的情况
1 import matplotlib.pyplot as plt
2 import numpy as np
3
4 def log_type(name,arr):
5 print("数组{}的大小:{}".format(name,arr.size))
6 print("数组{}的维度:{}".format(name,arr.shape))
7 print("数组{}的维度:{}".format(name,arr.ndim))
8 print("数组{}元素的数据类型:{}".format(name,arr.dtype))
9 #print("数组:{}".format(arr.data))
10
11 a = np.floor(10*np.random.random((3,4)))
12 print(a)
13 log_type(''a'',a)
14
15 a1 = a.squeeze()
16 print("修改前a1:{}".format(a1))
17 log_type(''a1'',a1)
18 a1[2] = 100
19 print("修改后a1:{}".format(a1))
20
21 print("a:{}".format(a))
22 log_type(''a'',a)从结果中可以看到，当没有single-dimensional entries时，squeeze()返回额数组对象是一个view,而不是copy。
2. 有single-dimentional entries 的情况
1 import matplotlib.pyplot as plt
2 import numpy as np
3
4 def log_type(name,arr):
5 print("数组{}的大小:{}".format(name,arr.size))
6 print("数组{}的维度:{}".format(name,arr.shape))
7 print("数组{}的维度:{}".format(name,arr.ndim))
8 print("数组{}元素的数据类型:{}".format(name,arr.dtype))
9 #print("数组:{}".format(arr.data))
10
11 a = np.floor(10*np.random.random((1,3,4)))
12 print(a)
13 log_type(''a'',a)
14
15 a1 = a.squeeze()
16 print("修改前a1:{}".format(a1))
17 log_type(''a1'',a1)
18 a1[2] = 100
19 print("修改后a1:{}".format(a1))
20
21 print("a:{}".format(a))
22 log_type(''a'',a)
Numpy：数组创建 numpy.arrray() , numpy.arange()、np.linspace ()、数组基本属性
一、Numpy数组创建
part 1：np.linspace(起始值，终止值，元素总个数
import numpy as np
''''''
numpy中的ndarray数组
''''''
ary = np.array([1, 2, 3, 4, 5])
print(ary)
ary = ary * 10
print(ary)
''''''
ndarray对象的创建
''''''
# 创建二维数组
# np.array([[],[],...])
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(a)
# np.arange(起始值, 结束值, 步长（默认1）)
b = np.arange(1, 10, 1)
print(b)
print("-------------np.zeros(数组元素个数, dtype=''数组元素类型'')-----")
# 创建一维数组：
c = np.zeros(10)
print(c, ''; c.dtype:'', c.dtype)
# 创建二维数组：
print(np.zeros ((3,4)))
print("----------np.ones(数组元素个数, dtype=''数组元素类型'')--------")
# 创建一维数组：
d = np.ones(10, dtype=''int64'')
print(d, ''; d.dtype:'', d.dtype)
# 创建三维数组：
print(np.ones( (2,3,4), dtype=np.int32 ))
# 打印维度
print(np.ones( (2,3,4), dtype=np.int32 ).ndim) # 返回：3（维）
结果图：
part 2 :np.linspace ( 起始值，终止值，元素总个数）
import numpy as np
a = np.arange( 10, 30, 5 )
b = np.arange( 0, 2, 0.3 )
c = np.arange(12).reshape(4,3)
d = np.random.random((2,3)) # 取-1到1之间的随机数，要求设置为诶2行3列的结构
print(a)
print(b)
print(c)
print(d)
print("-----------------")
from numpy import pi
print(np.linspace( 0, 2*pi, 100 ))
print("-------------np.linspace(起始值，终止值，元素总个数）------------------")
print(np.sin(np.linspace( 0, 2*pi, 100 )))
结果图：
二、Numpy的ndarray对象属性：
数组的结构：array.shape
数组的维度：array.ndim
元素的类型：array.dtype
数组元素的个数：array.size
数组的索引（下标）:array[0]
''''''
数组的基本属性
''''''
import numpy as np
print("--------------------案例1：------------------------------")
a = np.arange(15).reshape(3, 5)
print(a)
print(a.shape) # 打印数组结构
print(len(a)) # 打印有多少行
print(a.ndim) # 打印维度
print(a.dtype) # 打印a数组内的元素的数据类型
# print(a.dtype.name)
print(a.size) # 打印数组的总元素个数
print("-------------------案例2：---------------------------")
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
# 测试数组的基本属性
print(''a.shape:'', a.shape)
print(''a.size:'', a.size)
print(''len(a):'', len(a))
# a.shape = (6, ) # 此格式可将原数组结构变成1行6列的数据结构
# print(a, ''a.shape:'', a.shape)
# 数组元素的索引
ary = np.arange(1, 28)
ary.shape = (3, 3, 3) # 创建三维数组
print("ary.shape:",ary.shape,"\n",ary )
print("-----------------")
print(''ary[0]:'', ary[0])
print(''ary[0][0]:'', ary[0][0])
print(''ary[0][0][0]:'', ary[0][0][0])
print(''ary[0,0,0]:'', ary[0, 0, 0])
print("-----------------")
# 遍历三维数组:遍历出数组里的每个元素
for i in range(ary.shape[0]):
for j in range(ary.shape[1]):
for k in range(ary.shape[2]):
print(ary[i, j, k], end='' '')
结果图：
Python数据分析 - numpy
前言
NUMPY（以下简称NP）是Python数据分析必不可少的第三方库，np的出现一定程度上解决了Python运算性能不佳的问题，同时提供了更加精确的数据类型。如今，np被Python其它科学计算包作为基础包，已成为Python 数据分析的基础，可以说，NP是SciPy、Pandas等数据处理或科学计算库最基本的函数功能库。因此，理解np的数据类型对python数据分析十分有帮助。
下面，本文将介绍Np的常用操作和基本数据类型。
NP提供了以下重点功能。
- 一个强大的N维数组对象ndarray
- 广功能函数
- 整合C/C++/Fortran代码的工具
- 提供了线性代数、傅里叶变换、随机数生成的相关功能
为了更加直观的了解Np的强大与作用，我们先看作用再看方法：
使用NUMPY操作数据集
在操作数据之前，我们先来理解什么是维度：
什么是维度
维度是一组数据的组织形式，不同数据维度可能表示不同的含义。
一维数据由对等关系的有序或无序数据构成，采用线性方式组织，可以用数组表示。
通俗来讲，
1，2，3，4
这么一行数据就可以称之为一维数据，但如果我们再对其折叠：
1，2，
3，4
那么他就成为了二维数据，又可以称之为矩阵。
什么是数据集
数据集，顾名思义就是数据的集合，是用以训练程序的数据集合，一般是二维或者多维数表。
如果我们想自己手工新建一个数据集，可以直接新建一个文本文件，只要有恰当的数据，都可以称之为数据集：
城市,环比,同比,定基
北京,100.1,100.2,100.3
上海,111.1,111.2,111.3
南京,133.0,133.3,133.4比如这样，我们就可以称上面的文件称之为数据集。
我们还注意到，上面数据是使用逗号作为分隔符分隔数据的，它简单描述了数据的内容和含义，并使用半角逗号作为分隔符。
像这样，用逗号分隔的数据集就称之为CSV（Comma-Separated Value,逗号分隔值）数据集，它是一种常见的文件格式，用来存储批量的数据。它就像一张excel表，用来存储简单结构的数据。
怎么样，数据集的概念是否特别简单呢？
生成数据集
数据集是一个简单的概念，但每次使用手工的方式去写毕竟不方便，所以，我们可以使用np的内置函数来生成数据集：
np.savetxt(frame,array,fmt=''%.18e",delimiter=None)- frame：文件、字符串、或产生器的名字，可以是.gz，.bz2的压缩文件
- arrray：存入文件的NP的数组
- fmt(format):写入文件的格式，如%d,%.2f,%.18e(默认，科学计数法保留18位)
- delemiter:分割字符串，默认是任何空格。
我们可以这样写下代码：
a= np.arange(20).reshape(4,5)
np.savetxt(''demo.csv'',a,fmt=''%d'',delimiter='','')这样，我们就会在当前的工作目录下发现一个新的demo.csv，用记事本打开，里面是一个4 * 5的矩阵，元素0~19。
读取数据集
既然生成，那就可以读取，同样使用np：
np.loadtxt(frame,dtype=np.float,delimiter=None,inpack=False)- frame:指定读入的文件来源
- dtype:数据类型，默认为np.float。
- delimiter:分割字符串
- unpack：默认为False读入文件写入一个数组，如果为True，读入属性将分别写入不同变量
同样的我们只需要写下代码：
np.loadtxt("demo.csv",delimiter=",")就可以查看到我们先前写入的数组a。
CSV文件的局限
可以发现，CSV文件只能有效存储和读取一维和二维数组，因为更高的维度无法更直观的文本下显现出来，这时，更加灵活的存取方式就呼之欲出了，但讲之前先卖个关子，再介绍一个不太常用的方法：tofile：
对于NP中的ndarray数组，我们可以使用NP中的tofile方法。
a.tofile(frame,sep='''',format=''%d'')- frame:文件，字符串
- 数据分割字符串，如果不写，将使用二进制文件存储
- format：写入数据的格式
同样，我们只需要命令：
import numpy as np
a = np.arange(100).reshape(5,10,2)
a.tofile("a.dat",sep='','',format=''%d'')
就可以生成新的CSV数据集。
此时，我们如果打开a.dat文件，我们可以看到数组1,2,3……99。但是与CSV不同，这个文件并没有包含数字的维度信息，他只是将数组所有元素逐一的列出。而且如果我们不指定sep，将保存为二进制文件，虽然对人不可读，但将占用更小的空间。
既然tofile可以保存文本文件，那么也很容易猜到对应的fromfile可以还原这些信息。
np.fromfile(frame,dtype=float,count=-1,sep='''')- frame：文件
- dtype：读取元素使用的数据类型，默认为float
- count：读文件的个数，默认-1，读取全部
- sep:数据分割字符串，如果是空串，写入文件为二进制。
如果我们想要重新恢复数据的维度信息，我们需要重新使用reshape来恢复维度信息：
c = np.fromfile("b.dat",sep='','',dtype=np.int).reshape(5,10,2)
不得不说，当我看到这个方法时感觉这两个真是蠢爆了，使用savetxt / loadtxt 至少还能保存个二维信息，而使用了tofile / fromfile 方法居然把数被伸展为一维的，然后自己记住维度信息(╯‵□′)╯︵┻━┻。
因此，为了保存更复杂的数据类型，二维以上的数据信息，save / load 函数成功解决了这个问题：（为了方便，两个函数就放到一起了）
保存 / 读取高维度数据
np.save(frame,array)或np.savez(fname,array)(压缩)
+ frame：文件名，以.npy为扩展名，压缩扩展名为.npz
+ array：数组变量
np.load(fname)Demo:
a = np.arange(100).reshape(5,10,2)
np.save("a.npy",a)
b=np.load("a.npy")附录
附录中提供NP的常用方法及注释，做查询用。
np数组定义
>>>lst = [[1,3,5],[2,4,6]]
>>>np_lst = np.array(lst,dtype=np.float)
>>>print(np_lst.shape)#返回数组的行列
>>>print(np_lst.ndim)#返回数组的维数
>>>print(np_lst.dtype)#返回数据类型，float默认为64
>>>print(np_lst.itemsize)#np.array每个元素的大小，float64占8个字节
>>>print(np_lst.size)#大小，6个元素
(2, 3)
2
float64
8
6
初始化数组
>>>print(np.zeros([2,4])#初始化一个2行4列的数组
>>>print(np.ones([2,4])
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]随机序列
>>>print(np.random.rand(2,4))#将生成一个处于0~1之间2行4列的随机数序列（不加参数将只返回一个）
[[ 0.39531286 0.4845 0.1463168 0.82327991]
[ 0.89042255 0.65049931 0.43890163 0.89577744]]如果想要多个随机整数：
print(np.random.randint(22,55,3))#必须有（前两个参数）指定范围，第三个参数用于指定生成的个数
[27 40 29]
print(np.random.randn(2，4))#生成标准正态随机数
[[-1.15561548 0.3689953 0.38253231 -1.16346441]
[-1.32625322 -0.41707673 -0.11822205 -0.95807535]]
print(np.random.choice([10,20,40,33]))#从指定可迭代的数组中生成随机数
20
print(np.random.beta(1,10,4))#生成4个beta分布
[ 0.02258548 0.25848896 0.00696899 0.0609543 ]多维数组运算
print(np.arange(1,11,2))#得到step为2的range序列
[1 3 5 7 9]还可以使用reshape函数，对数组结构重定义：
print(np.arange(1,11).reshape(2,5))#（5可以缺省为-1）
[[ 1 2 3 4 5]
[ 6 7 8 9 10]]下面介绍一些常用的运算操作：
lst=np.arange(1,11).reshape(2,5)
print(np.exp(lst))#自然指数操作
[[ 2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01 1.48413159e+02]
[ 4.03428793e+02 1.09663316e+03 2.98095799e+03 8.10308393e+03 2.20264658e+04]]此外，还可以sqrt、log、sin、sum、max等操作：
我们下定义一个三维数组：
lst = np.array([
[[1,2,3,4],[4,5,6,7]],
[[7,8,9,10],[10,11,12,13]],
[[14,15,16,17],[18,19,20,21]]
])
print(lst.sum())
252我们可以看到sum方法对lst的所有元素都进行了求和，此外我们还可以通过对sum方法增加参数axis的方式来设置求和的深入维度：
print(lst.sum(axis=0))
[[22 25 28 31]#22=1+7+14；25=2+8+15
[32 35 38 41]]
print(lst.sum(axis=1))
[[ 5 7 9 11]#5=1+4；7=2+5
[17 19 21 23]
[32 34 36 38]]
print(lst.sum(axis=2))
[[10 22]#10=1+2+3+4；22=4+5+6+7
[34 46]
[62 78]]这里的axis取值为数组维数-1，axis可以理解为进行运算操作时的深入程度，axis越大，深入程度越大。同理，不仅sum函数，max等函数也可以一样理解。
相加运算
numpy.array是np最简单的数据结构。np.array相比与Python原生列表其强大之处在于可以实现对数组数据的运算。我们知道，list只能对元素的追加。而numpy是真正意义上的数据运算。
例如
In [1]: import numpy as np
In [2]: list1 = np.array([10,20,30,40])
In [3]: list2 = np.array([4,3,2,1])
In [4]: print(list1)
[10 20 30 40]
In [5]: print(list1+list2)
[14 23 32 41] 但np最强大的地方不在于简单的一维运算，Np对矩阵也能进行基本的运算操作：
lst1 =np.array([10,20,30,40])
lst2 = np.array([4,3,2,1])
print(np.dot(lst1.reshape([2,2]),lst2.reshape([2,2])))
[[10 22]
[34 46]
[62 78]]
[[ 80 50]
[200 130]]
此外，由于原生list没有确定的数据类型，所以维护起来成本较高，而使用C编写的numpy，则可以声明各种常见的数据类型：
lst = [[1,3,5],[2,4,6]]
np_lst = np.array(lst,dtype=np.float)np所支持的数据类型都有bool、int8/16/32/64/128/、uint8/16/32/64/128、float16/32/43、complex64/128、string。
总结
Python作为一门弱类型语言，有其不可避免的缺点。但NP的出现，弥补了这些缺点，使其具备了构造复杂数据类型的能力，为Python数据分析提供了基础。
今天关于Python数据分析：numpy和python数据分析numpy和pandas的分享就到这里，希望大家有所收获，若想了解更多关于numpy.random.random & numpy.ndarray.astype & numpy.arange、numpy.ravel()/numpy.flatten()/numpy.squeeze()、Numpy：数组创建 numpy.arrray() , numpy.arange()、np.linspace ()、数组基本属性、Python数据分析 - numpy等相关知识，可以在本站进行查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
