numpy的使用方法

import numpy #看上去没有区别
n1=numpy.array(['aa','bb','cc','dd','ee'])
list1=['aa','bb','cc','dd','ee']
print(n1[0])
print(list1[0]) print(n1[1:3])
print(list1[1:3]) for i in n1:
print(i) for i in list1:
print(i)

#ndarray和python list不同之处
#ndarray里面的元素必须是同一种类型
n1=numpy.array(['aa','bb','cc','dd','ee',100])
print(type(n1[-1]))
print(n1[-1]) #矢量运算
#相加
a1=numpy.array([1,2,3])
a2=numpy.array([2,3,4])
print(a1+a2)#>>:[3,5,7] #相乘
a1=numpy.array([1,2,3])
print(a1*3)#>>:[3,6,9] #比如乘方
#先产生3*3的矩阵,每个数字都是0-9之间
a1=numpy.random.randint(0,10,(3,3))
print(a1)#随机产生>>:[[7 2 6][4 5 5][0 5 0]] a2=a1**2
print(a2)#>>:[[49 4 36][16 25 25][ 0 25 0]]

#题目一:
a=numpy.array([1,2,3,4,5])
b=a
a+=numpy.array([1,1,1,1,1])
print(b)#>>:[2 3 4 5 6]
print(id(a),id(b)) #题目二;
a=numpy.array([1,2,3,4,5])
b=a
a=a+numpy.array([1,1,1,1,1])
print(b)#>>:[1 2 3 4 5]
print(id(a),id(b))
#由于a=a+[]是被从新定义了新的内存地址

j=numpy.array([[1,2,3],[1,1,1]])
#普通列表方式访问
print(j[0])
print(j[0][1])
#矩阵的方式访问
print(j[0,1])

s=mat([1,2,3])
print(s)
#矩阵类型
print(type(s))
#访问矩阵中的第一元素
print(s[0,0]) #把普通列表转成矩阵类型
lis=[111,234,534]
m=mat(lis)
print(type(m))
#矩阵类型与矩阵类型相乘会报错
#矩阵数据类型的运算会强制执行数学中的矩阵运算,1*3的矩阵是不能与1*3的矩阵相乘的
#需要左矩阵的列数和右矩阵的行数必须相等才能相乘
#这是需要将其中一个矩阵转置,使得可以3*1的矩阵乘以1*3的矩阵,或是1*3的矩阵乘以3*1的矩阵
# print(s*m)
#numpy数据类型中有一个转置方法,能方便的进行矩阵乘法运算
print(s*m.T) #查看数组和矩阵的维数
print(shape(m)) #矩阵中每个元素的相乘法需要multiply方法
print(multiply(s,m))

#数组,矩阵的排序,默认快速排序方法
m=mat([3,2,5,8,4])
m.sort()
print(m) #得到矩阵中每个元素的排序序号
m=mat([3,2,5,8,4])
res=m.argsort()
print(res)#[[1 0 4 2 3]] #计算矩阵的均值
res=m.mean()
print(res)

j=mat([[1,2,3],[8,8,8]])
#查看维数组,这是一个2*3的矩阵
print(shape(j))
#取出第一行元素
print(j[1,:])
#取出第0行,第0列的元素
print(j[0,0])

numpy.tile(A,reps)#将A重复reps次的输出 tile共有2个参数，A指待输入数组，reps则决定A重复的次数。整个函数用于重复数组A来构建新的数组。 函数格式tile(A,reps) A和reps都是array_like A的类型众多，几乎所有类型都可以：array, list, tuple, dict, matrix以及基本数据类型int, string, float以及bool类型。 reps的类型也很多，可以是tuple，list, dict, array, int, bool.但不可以是float, string, matrix类型。 假设reps的维度为d，那么新数组的维度为max（d，A.ndim）。下面分三种情况进行讨论： (1）A.dim < d 则向A中添加新轴扩充A的维度。维度大小可以从shape中看出，一般通过向shape对应的元组中添加1完成对A维度的扩充。扩充完成后，则可根据reps的值对A中相应维度的值进行重复。 例如，一维数组shape为（3，），扩充至2维则shape值为（1,3），扩充至3维则shape值为（1,1,3） （2）A.dim > d 将reps扩充至与A相同的维度。扩充方法同上，也是向shape对应元组中添1，然后再进行重复。 例如，4维数组A的shape为（2,3,4,5），而reps为（2,2）只有2维，那么就要对reps添维进行扩充，得到（1,1,2,2） （3）A.dim = d 不需要扩充，直接按reps的值对相应维度的值进行重复

#结果相同
#一维重复输出
print(tile((1,2,3),3))
print(array([1,2,3,1,2,3,1,2,3])) #结果相同
b=[1,3,5]
print(tile(b,[2,3]))
print(array([[1,3,5,1,3,5,1,3,5],[1,3,5,1,3,5,1,3,5]])) #二位重复输出
a=[[1,2,3],[5,4]]
print(tile(a,[2,3]))
print([[[1,2,3],[5,4],[1,2,3],[5,4],[1,2,3],[5,4]],
[[1,2,3],[5,4],[1,2,3],[5,4],[1,2,3],[5,4]]])

from numpy import *
a=array([0,1,2,3,4])
b=array([0,1,2,3,4])
c=arange(5)
d=linspace(0,2*pi,5)print(a)#[0 1 2 3 4]
print(b)#[0 1 2 3 4]
print(c)#[0 1 2 3 4]
print(d)#[0. 1.57079633 3.14159265 4.71238898 6.28318531]arr1=array([
[
[1,2,3,4,5],
[2,3,4,5,6],
[4,5,6,7,7],
[3,4,5,6,8]
],
[
[1,8,6,7,7],
[1,6,6,7,10],
[1,2,5,7,32],
[1,4,6,2,33]
]
])
#
print(arr1.shape)#array函数:接收一个普通的python序列,转成ndarray
res=array([1,2,3,4,5,6,7,8])
print(type(res))#zeros函数:创建指定长度或形状的全零数组
print(zeros((3,4)))#ones函数:创建指定长度或形状的全1数组
print(ones((3,3,3)))#empty函数:创建一个没有任何具体指的数组(准备的说是一些未初始化的垃圾值)
print(empty((5,5)))#nan代表空值,或缺失值#arrange函数:类似于python的range函数,通过指定开始值,结束值和步长
#来创建一维数组,注意:数组不包括结束值,顾头不顾尾
print(arange(2,30,3))#linspace函数:通过指定开始值,结束值和元素个数创建一维数组,
# 可以通过endpoint关键字指定是否包括结束值,缺省设置是包括结束值
#第一个参数是起始数,第二个参数是结束数,第三个参数是元素的个数
#生成的是等差数列
print(linspace(1,20,3))#logspace函数:和linspace类似,不过它创建等比数列
#生成的是等比数列
#第一个数是代表10的2次方,第二个数是代表10的20次方,第三个是元素个数
print(logspace(2,20,3))#使用随机数填充数组,即使用numpy.random模块和random()函数,数组所包含
#的元素数量由参数决定
res=random.random((2,3,4))
print(res)# #-1会自动计算
# res=arange(2,20,2)
# print(res)
# res=arange(2,20,2).reshape((3,-1))
# print(res)#总结:
# 1.先规范显示出数组
# 2.层层去中括号,值到2无中括号,每去一层,一个维度,去掉一层[],后的元素个数(逗号隔开)即该维度的元素个数#创建numpy数组可以通过dtype属性显示指定数据类型,如果不指定,
# numpy会自己推断出合适的数据类型,所以一般无需显示指定
# astype方法,可以转换数组的元素数据类型,得到一个新数组
arr2=array([1,2,3,4])
print(arr2)
print(arr2.dtype)#改变arr2的数据类型,重新赋值给arr2
arr2=arr2.astype('float')
print(arr2)
print(arr2.dtype)#使用unicode编码,每个元素长度为2,U为大写
arr3=arr2.astype('|U2')
print(arr3)
print(arr3.dtype)#使用string进行编码(转换为十六进制编码),每个元素长度为2,S为大写
arr4=arr2.astype('|S2')
print(arr4)
print(arr4.dtype)#自动转换数据类型
arr5=array([1,2,3,''],dtype=float)
print(arr5)
print(arr5.dtype)#改变数组的形状
#1.reshape不会改变原来的数组元素个数,但会得到新的ndarry视图
arr6=arange(20)
print(arr6)
arr6=arr6.reshape((4,5))
print(arr6)#拷贝,生成一个副本,修改副本不会影响原数组
arr=arange(20)
print(arr)
arr_copy=arr.copy()
arr_copy[0]=88
print(arr_copy)
print(arr)
print('========================')#视图会改变原数组的值,视图的变量名都指向同一个内存地址空间
arr=arange(20)
print(arr)
arr2=arr.reshape((4,-1))
arr2[0][1]=88
print(arr2)
print(arr)#数值型dtype的命名方式:
# 一个类型名(比如int,float),后面接着一个用于表示各元素位长度的数字
# 比如:表中的双精度浮点值,即python中的float对象,需要占用8个字节(即64位)
# 因此该类型在numpy中就记为float64
# 每种类型有一个相对应的类型代码,即简写方式,参照下面的表#numpy基本操作# 算术运算
# 数组不用循环即可对每个元素执行批量运算,这通常就叫做矢量化,即用数组表达式代替循环的做法
# 矢量化数组运算性能要比纯python方式快上一两个数量级
# 大小相等的数组之间的任何运算都会将运算应用到元素级
# 加法:
arr=arange(0,20,2)
print(arr)
arr1=arr+2
print(arr1)
print(arr+arr1)
print(arr*2)
#会显示不能被0除错误信息
# print(arr1/arr)arr1=random.random((2,3))
arr2=random.random((3,2))
print(arr1,arr2)#数组形状不同不能相加
# print(arr1+arr2)#转换相同形状后计算
print(arr1+arr2.reshape((2,3)))#元素级的运算
# 加,减,乘,除,幂运算等,可以用于数组与标量,大小相等数组之间
# 在numpy中,大小相等的数组之间运算,为元素级运算,即只用于位置相同的元素之间
# 所得到的运算结果组成一个新的数组,运算结果的位置跟操作数位置相同print('=============================')# 两个二维矩阵(多维数组即矩阵)满足第一个矩阵的列数与第二个矩阵的行数相同
# 那么可以进行矩阵乘法,即矩阵积,矩阵积不是元素级的运算# 两个矩阵相乘结果所得到的数组中每个元素为,\
# 第一个矩阵中与该元素行号相同的元素与第二个矩阵中与该元素列号相同的元素,两两相乘后求和
#矩阵积
arr1=random.random((2,3))
arr2=random.random((3,2))
print(arr1.shape,arr2.shape)
print(arr1)
print(arr2)
print('------------------')
print(arr1.dot(arr2))# (2, 3) (3, 2)
# [[0.34504786 0.05553567 0.12492583]
# [0.63312505 0.20942331 0.14286747]]# [[0.90689695 0.61868066]
# [0.71365305 0.91594229]
# [0.38928685 0.54340045]]
# ------------------
# 计算方式:0.34504786*0.90689695+0.05553567*0.71365305+0.12492583*0.38928685=0.40118803
# [[0.40118803 0.33222666]
# [0.77925118 0.66115613]]#在矩阵中,竖着的叫行轴axis[0],横着的叫列轴axis[1]#矩阵积在生活中的应用
# 产品A 产品B 产品C
# 公司1 89 95 83
# 公司2 79 75 77
# 公司3 74 51 88
# 单价 体积
# 产品A 10 1
# 产品B 6 10
# 产品C 9 1# 算出,公司1,公司2,公司3,各自的总产品总金额和总体积
arr1=array([
[89,95,83],[79,75,77],[74,51,88]
])
arr2=array([
[10,1],[6,10],[9,1]
])print(arr1.dot(arr2))
# 产品 体积
# 公司1 [2207 1122]
# 公司2 [1933 906]
# 公司3 [1838 672]#多维数组的索引
arr3=random.random((2,3,4))
print(arr3)
print(arr3[0,1:3,0:3])#0表示第一组,1:3表示第一组中的第2行,第3行,[0:2]表示取第0个,和第2个索引位置,[0,2]加中括号表示选择,不是范围
# [
# [
# [0.76639132 0.59079559 0.23644078 0.00451106]
# [0.45136272 0.24304024 0.83266546 0.04835091]
# [0.73851614 0.44415277 0.1467127 0.19508756]
# ]
#
# [
# [0.96947774 0.95681595 0.8278818 0.71830521]
# [0.35352713 0.92370433 0.78588604 0.12943099]
# [0.58588268 0.70987566 0.85868567 0.85980889]
# ]
# ]
#
#
# [[0.45136272 0.73851614]
# [0.83266546 0.1467127 ]]#花式索引
arr1=arange(32).reshape((4,8))
print(arr1)
# [[ 0 1 2 3 4 5 6 7]
# [ 8 9 10 11 12 13 14 15]
# [16 17 18 19 20 21 22 23]
# [24 25 26 27 28 29 30 31]]
# [[ 8 9 10 11 12 13 14 15]
print(arr1[[1,2,3]])
# [[ 8 9 10 11 12 13 14 15]
# [16 17 18 19 20 21 22 23]
# [24 25 26 27 28 29 30 31]]print(arr1[[0,1,2],[0,1,2]])
# [ 0 9 18]print(arr1[[1,2],1:3])
# [[ 9 10]
# [17 18]]# ix_函数产生一个索引器
print(ix_([0,2],[1,3]))
# (array([[0],#0表示取第一行
# [2]]),#2表示取第三行 array([[1, 3]]))#表示取第一行的第2个,第三行的第4个
print(arr1[[0,2],[1,3]])#布尔索引
names=array(['maple','ffm','jerry',nan ])
names[names=='maple']='angel'
print(names)names[names=='nan']='marry'
print(nan)
print(names)# 数组转置与轴对换
# transpose函数用于数组转置,对于二维 数组来说就是行列互换
# 数组的T属性,也是转置
arr1=arange(32).reshape((4,8))
print(arr1)
# 横轴与纵轴的转变,修改时视图
arr2=arr1.T
print(arr2)
# 横轴与纵轴的转变,修改时视图
arr3=arr1.transpose()
print(arr3)# 通用函数:快速的元素级数组函数
# ufunc:一种对ndarray中的数据执行元素级运算的函数,也可以看做是简单函数
# (接受一个或多个标量值,并产生一个或多个标量值)的矢量化包装器
arr=random.random((2,3,4))
res=abs(arr)
print(res)
print(sqrt(res))arr=arange(10).reshape((2,-1))
arr2=arange(10).reshape((2,-1))
# x的y次方
print(power(arr,arr2))# 判断是否为空值,如果为空就是True,不为空就是False
arr3=array([
[nan,1,2,3],
[1,2,3,4]
])
print(isnan(arr3))# 聚合函数
# 聚合函数是对一组值(比如一个数组)进行操作,返回一个单一值作为结果的函数,
# 因此求数组所有元素之和,求所有元素的最大最小值以及标准差的函数就是聚合函数
arr=array([1,2,3,4])
print(arr.max())
print(arr.min())
print(arr.mean())
print(arr.std())
print(sqrt(power(arr-arr.mean(),2).sum()/arr.size))# 聚合函数可以指定对数值的某个轴元素进行操作
arr=array([
[1,2,3,4],
[3,4,5,6]
])
# 对同一列上的元素进行聚合
print(arr.mean(axis=0))
# 对同一行上的元素进行聚合
print(arr.mean(axis=1))
print(arr.sum(axis=0))
print(arr.max(axis=1))
print(arr.std(axis=0))# where
arr1=array([1.1,2.2,3.3,4.4])
arr2=array([1.2,2.3,3.4,4.5])
arr_bool=array([True,False,False,True])
# 数组合并成一个zip对象
res=zip(arr1,arr2,arr_bool)
print(res)
result=[x if bl else y for x,y,bl in res]
print(result)
result=[(x if bl else y )for x,y,bl in res if x>2 ]
print(result)
# where(表达式数组,当前表达式为True提取的数组,当前表达式为False提取的数组)
print(where(arr_bool,arr1,arr2))# unique去重功能
arr=array(['中国','美国','英国','印度','毛里求斯','梵蒂冈','梵蒂冈','中国','美国'])
print(arr)
arr2=unique(arr)
print(arr2)# 数组的存取
# 存数组
arr=random.random((2,3,4))
# 保存为二进制格式
save('data',arr)
# 读取数据需要文件后缀
arr1=load('data.npy')
print(arr1)# 存取文本文件.可以自定义文件(array.txt)
# 读取数据操作
# faname 文件名
# dtype 数据类型
# comments 注释行的符号定义
# converters 转换函数
# skiprows 跳过行数
# usecols 使用哪些列
arr=loadtxt('array.txt',delimiter=',')
print(arr)res=genfromtxt('array.txt',delimiter=',')
print(res)from io import StringIO
c=StringIO('0 1\n2 3')
print(c)
print(loadtxt(c))savetxt('array1.txt',arr,delimiter=',',fmt='%d')#fmt='%.2f'保留2位小数
savetxt('array2.txt',arr.reshape((4,3)),delimiter=',',fmt='%d')