python基础学习--数据分析之Numpy

最新推荐文章于 2022-10-20 09:25:12 发布

长江水鸟

最新推荐文章于 2022-10-20 09:25:12 发布

阅读量559

点赞数 1

分类专栏：数据分析 python Numpy

本文链接：https://blog.csdn.net/weixin_42385497/article/details/98235102

版权

python 同时被 3 个专栏收录

7 篇文章 0 订阅

订阅专栏

数据分析

2 篇文章 0 订阅

订阅专栏

Numpy

1 篇文章 0 订阅

订阅专栏

python基础学习–数据分析之Numpy

介绍

用于处理数值类型的数据
NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库
一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算
NumPy 是一个运行速度非常快的数学库，主要用于数组计算。
功能：

一个强大的N维数组对象 ndarray
广播功能函数
整合 C/C++/Fortran 代码的工具
线性代数、傅里叶变换、随机数生成等功能

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用
使用Numpy，必须下载Numpy包，并且进行导包：import numpy

使用

1.数组

数组创建

创建的方式（两种）

arr1 = numpy.array([1,2,3,5,7,8,10])
numpy.arange(10)
#从0到20每隔3个数取一个，放入数组中
arr2 = numpy.array(range(0,20,3))
#结果为：[ 1  2  3  5  7  8 10]
#[ 0  3  6  9 12 15 18]

创建全零数组（zeros）
公式：zeros(行，列的元组，类型)
```
arr=numpy.zeros(5,dtype="int")
print(arr)
```
创建全1数组
公式：ones(行列元组，类型)
```
arr = numpy.ones((2,3),dtype="int64")
print(arr)
```

随机生成数组

#随机生成零一下小数的多维数组
arr = numpy.random.rand(3,5)
print(arr)
#让每一次随机的数组相同seed（类似编号）
numpy.random.seed(1)
arr = numpy.random.rand(3,5)
print(arr)
numpy.random.seed(1)
arr = numpy.random.rand(3,5)
print(arr)
#随机整数np.random.randint(范围,size=(行,列))
arr = numpy.random.randint(10,size=(3,5))
print(arr)
结果为：
[[0.61723691 0.58199128 0.06299019 0.01141148 0.51517736]
 [0.66561976 0.68815946 0.90278371 0.4519576  0.22508727]
 [0.70553975 0.81664587 0.68952145 0.14555441 0.28012767]]
[[0.417022   0.72032449 0.00011437 0.30233257 0.14675589]
 [0.09233859 0.18626021 0.34556073 0.39676747 0.53881673]
 [0.41919451 0.6852195  0.20445225 0.87811744 0.02738759]]
[[0.417022   0.72032449 0.00011437 0.30233257 0.14675589]
 [0.09233859 0.18626021 0.34556073 0.39676747 0.53881673]
 [0.41919451 0.6852195  0.20445225 0.87811744 0.02738759]]
[[2 4 7 7 9]
 [1 7 0 6 9]
 [9 7 6 9 1]]

查看数组类型
类型表
在这里插入图片描述

 #创建指定类型的数组
 arr1 = numpy.array([0,1,1,0],dtype=bool)
 arr2 = numpy.array([0.55,1.9,1,0],dtype=float)
 arr3 = numpy.array([0,1,1,0],dtype="?")
 #查看数组类型
 print(arr1.dtype)
 print(arr2.dtype)
 print(arr3.dtype)
 #打印
 print(arr1)
 print(arr2)
 print(arr3)

查看数组类名

#使用type查看数组名
arr = numpy.array([1,4,5])
print(type(arr))
结果为：
<class 'numpy.ndarray'>

数组属性

属性名	解释
dtype	数组类型
size	数组的长度，即数组中的元素个数
shape	数组的形状
reshape	一维数组转二维数组
flatten	二维数组转一维数组
itemsize	每个元素占用的字节数
ndim	数组的维数
nbytes	显示数组中所有数组占用的字节数，但是实际数组所占空间会稍大一些

举例：

arr7 = numpy.array([[1, 2, 3, 4, 5],
                    [6, 7, 8, 9, 10]], dtype="int64")

print(arr7.size)  # 总元素个数
print(arr7.dtype)  # 类型
print(arr7.itemsize)  # 每个元素所占字节数64/8=8，32/8=4
print(arr7.shape)  # 查看数组形状
# 数组一维转二维
arr = numpy.ones(10)
print(arr)
arr = arr.reshape(2, 5)
print(arr)
# 数组二维转一维
arr1 = arr.reshape(1, 10)
print(arr1.flatten())
print(arr7.ndim)  # 维数
print(arr7.nbytes)  # 占总字节数
结果为：
10
int64
8
(2, 5)
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
2
80

切片与索引

基本切片
注意：这里的切片大多数以下标来计算

获取某个范围从第几个元素到第几个
arr[2:7]：获取从下标为2到下标为7的元素，但不包含下标为7的
获取某个范围每隔几个选一个
arr2 = arr[2:7:2]：获取从下标为2到下标为7的元素，但不包含下标为7，且每下标加2个取一个

指定获取

获取所有行的哪一列 ndarray[:,列数]
arr = np.array([[3,6,8],[4,9,7],[5,9,4]])
print(arr[:,2])
获取某一行的第几个元素[行,列]
arr = np.array([[3, 6, 8], [4, 9, 7], [5, 9, 4]])
print(arr[0, 2])
获取0到1行的第2个元素结果为6
arr = np.array([[3, 6, 8], [4, 9, 7], [5, 9, 4]])
print(arr[0:1, 1])
第2行的 0到1的范围结果为4
arr = np.array([[3, 6, 8], [4, 9, 7], [5, 9, 4]])
print(arr[1, 0:1])
每隔两行挑选一个每隔两列挑选一个结果为[[3,8],[5,4]]
arr = np.array([[3, 6, 8], [4, 9, 7], [5, 9, 4]])
print(arr[::2, ::2])

举例：

a = numpy.arange(15)
print(a)
#整个数组中  每隔三  挑一个数字出来
print(a[::3])
#在某个区间范围内  每隔4  挑一个数字出来
print(a[1:10:4])

#行列
arr = numpy.array([[3,6,8],[4,9,7],[5,9,4]])
print(arr[:2])#获取到下标为2的行，但不包括下标为2的行
print(arr[:,2])#获取每行的下标为2的行
arr = numpy.array([
    [3,6,8],
    [4,9,7],
    [5,9,4],
    [4,9,1],
    [5,9,4]
])
#获取6，9，9，9，9
print(arr[:,1])
#获取4，9，1
print(arr[3:4])
#获取1
print(arr[3:4,2])
print(arr[3,2])
结果为：
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

[ 0  3  6  9 12]

[1 5 9]

[[3 6 8]
 [4 9 7]]
 
[8 7 4]

[6 9 9 9 9]

[[4 9 1]]

[1]

1

高级索引

缺省索引


 a = np.arange(0, 100, 10)
b = a[:5]
c = a[a >= 50]
print(b) # >>>[ 0 10 20 30 40]
print(c) # >>>[50 60 70 80 90]

整数索引
这种机制有助于基于 N 维索引来获取数组中任意元素。每个整数数组表示该维度的下标值。当索引的元素个数就是目标ndarray的维度时，会变得相当直接。

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
y = x[[0,1,2],  [0,1,0]]  
print (y)
输出结果为：
[1  4  5]

布尔索引
通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组
把小于5的替换

names = np.array(['joe','susan','tom'])
scores = np.array([
    [98,86,88,90],
    [70,86,90,99],
    [82,88,89,86]
])
classic = np.array(['语文','数学','英语','科学'])
print('susan的成绩是:')
# print(names=='susan')
print(scores[names=='susan'])
print('susan的数学成绩:')
# print(scores[names=='susan',classic=='数学'])
print(scores[names=='susan'].reshape(-1,)[classic=='数学'])
print('joe和susan的成绩是：')
print(scores[(names=='joe')|(names=='susan')])
print('非joe和susan的成绩')
print(scores[(names!='joe')&(names!='susan')])

花式索引
花式索引是NumPy用来描述使用整型数组作为索引，
根据索引数组的值作为目标数组的某个轴的下标来取值。
使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行
如

例子一：
arr = np.array(['zero','one','two','three','four'])
print(arr[[1,3，-1]]) ->对应一维数组的位置
['one' 'three' 'four']
例子二：
 x = np.array([
   [0, 1, 2], 
   [3, 4, 5], 
   [6, 7, 8], 
   [9, 10, 11]
])
print(x[[0,1],[0,2]])-> x[[都找哪行],[都找哪列]]
[0 5]
例子三：
arr = numpy.array([
   [3,6,8],
   [4,9,7],
   [5,9,4],
   [4,9,1],
   [5,9,4]
])
#输出[6,1]
print(arr[[0,3],[1,2]])#输出的是arr[0][1]和arr[3][2],前面是行后面是列
#where函数
print(numpy.where(narr>120))#取出大于120数的下标

where函数
where() 函数是另外一个根据条件返回数组中的值下标的元组（下标数组，数组类型）。

a = np.arange(0, 100, 10)
b = np.where(a < 50)
c = np.where(a >= 50)
print(a)
print(b)--》(array([0, 1, 2, 3, 4], dtype=int64),)
print(c)--》(array([5, 6, 7, 8, 9], dtype=int64),)

数组计算

全局设置不使用科学记数法
全局设置不是用科学计数法

numpy.set_printoptions(suppress=True)

自动与数组的每一个元素进行计算（广播机制）
数组与数组的计算

#+ 让几个数组每行每列互加
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a+b)
[[24 33 69 17]
 [80 14 28 48]]
#- 让几个数组每行每列互减
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a-b)
[[ 20 -27 -57  -1]
 [ 30 -10 -20 -30]]
#*让几个数组每行每列互乘
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a*b)
[[  44   90  378   72]
 [1375   24   96  351]]
#/ 让几个数组每行每列互除
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a / b)
[[11.          0.1         0.0952381   0.88888889]
 [ 2.2         0.16666667  0.16666667  0.23076923]]
#% 让几个数组每行每列互取余
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a % b)
#做判断
 a = np.array([[22, 3, 6, 8], [55, 2, 4, 9]])
b = np.array([[2, 30, 63, 9], [25, 12, 24, 39]])
print(a > b)
[[ True False False False]
 [ True False False False]]

数组的运算符

a = numpy.arange(10)
print(a.sum()) # >>>45
print(a.min()) # >>>0
print(a.max()) # >>>9
print(a.cumsum()) # >>>[ 0  1  3  6 10 15 21 28 36 45]

cumsum()函数像sum()这样的每个元素相加，但是它首先将第一个元素和第二个元素相加，并将计算结果存储在一个列表中，然后将该结果添加到第三个元素中，然后再将该结果存储在一个列表中。这将对数组中的所有元素执行此操作，并返回作为列表的数组之和的运行总数。

不同维度的计算
一维与多维

arr1 = np.array([
    [1,1,2],
    [2,3,4]
])
arr2 = np.array([1,2,3])
print(arr2+arr1)
[[2 3 5]
 [3 5 7]]

nan和inf

什么时候numpy中会出现nan：
当我们读取本地的文件为float的时候，如果有缺失，就会出现nan
当做了一个不合适的计算的时候(比如无穷大(inf)减去无穷大)
什么时候回出现inf包括（-inf，+inf）
比如一个数字除以0，（python中直接会报错，numpy中是一个inf或者-inf）
inf(-inf,inf):infinity,inf表示正无穷，-inf表示负无穷
注意

 #是不相等的
print(numpy.nan == numpy.nan)
 #nan与任何值计算都是nan
a = numpy.array([22,33,55])
print(a+numpy.nan)
 #统计数组中nan 的个数
a = numpy.array([22,33,numpy.nan,55,numpy.nan])
print(numpy.count_nonzero(a!=a))
 #判断数组中元素是不是nan
print(numpy.isnan(a))
结果为：
False
[nan nan nan]
2
[False False  True False  True]

有关函数

算数运算

#加----add
arr1 = numpy.array([2,3,4,5,6])
arr2 = numpy.array([1,3,12,3,5])
print(numpy.add(arr1,arr2))
print(arr1+arr2)
#减----subtract
print(numpy.subtract(arr1,arr2))
print(arr1-arr2)
#乘----multiply
print(numpy.multiply(arr1,arr2))
print(arr1*arr2)
#除----divede
print(numpy.divide(arr1,arr2))
print(arr1/arr2)
#幂----power
print(numpy.power(arr1,2))
print(arr1 **2)
#余----mod,remainder
print(numpy.mod(arr1,2))
print(arr1 % 2)
print(numpy.remainder(arr1,arr2))
结果为：
[ 3  6 16  8 11]
[ 3  6 16  8 11]
[ 1  0 -8  2  1]
[ 1  0 -8  2  1]
[ 2  9 48 15 30]
[ 2  9 48 15 30]
[2.         1.         0.33333333 1.66666667 1.2       ]
[2.         1.         0.33333333 1.66666667 1.2       ]
[ 4  9 16 25 36]
[ 4  9 16 25 36]
[0 1 0 1 0]
[0 1 0 1 0]
[0 0 4 2 1]

数组的矩阵积
两个二位矩阵，满足第一个矩阵的列数与第二个矩阵的行数相同，那么就可以进行矩阵的乘法，即矩阵积

arr1 = np.array([
    [110,60,220],
    [115,45,180],
    [132,67,209]
])
arr2 = np.array([
    [12.3,0.04],
    [204,2.34],
    [9.98,0.45]
])
print(arr2)
print(arr1.dot(arr2))
结果为：
[[ 12.3    0.04]
 [204.     2.34]
 [  9.98   0.45]]
[[15788.6    243.8 ]
 [12390.9    190.9 ]
 [17377.42   256.11]]

数学算数函数

一元函数

#绝对值---abs
#abs fabs计算整数、浮点数或者复数的绝对值，对于非复数，可以使用更快的fabs
arr1 = numpy.random.randint(-100,100,size=(10))
print("绝对值：")
print(numpy.abs(arr1))
print(numpy.fabs(arr1))
#平方根---sqrt
#sqrt()计算各个元素的平方根，相当于arr ** 0.5， 要求arr的每个元素必须是非负数
arr1 = numpy.random.randint(100,size=(10))
print("平方根：")
print(arr1)
print(numpy.sqrt(arr1))
#平方---square
#square()计算各个元素的平方，相当于arr ** 2
arr1= numpy.array([2,2,2,2,2,])
print("平方：")
print(numpy.square(arr1))
#自然指数的x次方，（自然指数为e）---exp
#exp()计算各个元素的指数e的x次方,自然底数e： e ≈ 2.71828 。。。
arr1= numpy.array([1,2,3,4,2,])
print("自然指数的x次方：")
print(numpy.exp(arr1))
#自然对数---log
#log()分别计算自然对数、底数为10的log、底数为2的log以及log(1+x);要求arr中的每个元素必须为正数
arr1= numpy.array([1,2,3,4,2,])
print("自然对数：")
print(numpy.log(arr1))
#正负号---sign
#sign()计算各个元素的正负号: 1 正数，0：零，-1：负数
arr1=numpy.random.randint(-100,100,size=10)
print("正负号：")
print(arr1)
print(numpy.sign(arr1))
#四舍五入---around
#四舍五入函数，这个函数返回四舍五入的所需精度的值。numpy.around(a,decimals)-->
    #a:输入的数组
    #decimals:要舍入的小数位，默认值位0，负数讲四舍五入到小数点左侧位置
arr1 =numpy.array([1.1,2.8,5,6.9,7.4])
print("四舍五入：")
print(numpy.around(arr1))
#向下取整---floor
arr1 = numpy.array([1.1,2.8,5,6.9,7.4])
print("向下取整：")
print(numpy.floor(arr1))
#向上取整---ceil
arr1 = numpy.array([1.1,2.8,5,6.9,7.4])
print("向上取整：")
print(numpy.ceil(arr1))
#分离小数与整数---modf
#modf()将数组中元素的小数位和整数位以两部分独立数组的形式返回
boxNum = numpy.array([40,20,15,35])
data = numpy.array([200,500,300,1000])
result = data/boxNum
print("分离小数与整数：")
print(numpy.modf(result))
#判断Nan---isnan
#isnan()返回一个表示“那些值是NaN(不是一个数字)”的布尔类型数组
num = numpy.random.random(6).reshape(2,3)
print("判断nan：")
print(num)
print(numpy.isnan(num))
#判断有穷与无穷---isfinite,isinf
#isfinite()、isinf()：分别一个表示”那些元素是有穷的(非inf、非NaN)”或者“那些元素是无穷的”的布尔型数组
num = numpy.random.random(6).reshape(2,3)
print("判断有穷与无穷：")
print(num)
print(numpy.isfinite(num))
print(numpy.isinf(num))
结果为：
绝对值：
[78 62 27 82 40 45 63 42 10 40]
[78. 62. 27. 82. 40. 45. 63. 42. 10. 40.]
平方根：
[66 48 71 95 89 37 45 21 33  6]
[8.1240384  6.92820323 8.42614977 9.74679434 9.43398113 6.08276253
 6.70820393 4.58257569 5.74456265 2.44948974]
平方：
[4 4 4 4 4]
自然指数的x次方：
[ 2.71828183  7.3890561  20.08553692 54.59815003  7.3890561 ]
自然对数：
[0.         0.69314718 1.09861229 1.38629436 0.69314718]
正负号：
[ 20 -69  50  40  58  45  25 -27 -70 -60]
[ 1 -1  1  1  1  1  1 -1 -1 -1]
四舍五入：
[1. 3. 5. 7. 7.]
向下取整：
[1. 2. 5. 6. 7.]
向上取整：
[2. 3. 5. 7. 8.]
分离小数与整数：
(array([0.        , 0.        , 0.        , 0.57142857]), array([ 5., 25., 20., 28.]))
判断nan：
[[0.94140953 0.16923979 0.36199461]
 [0.67049243 0.62321041 0.84414654]]
[[False False False]
 [False False False]]
判断有穷与无穷：
[[0.79501229 0.22366797 0.77106734]
 [0.86361412 0.58957692 0.38286773]]
[[ True  True  True]
 [ True  True  True]]
[[False False False]
 [False False False]]

三角函数：Numpy拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值


#获取某个数组 中 所有元素 角度的正弦
arr=numpy.array([15,30,60,90])
#角度*pi/180=弧度
def toA(d):
    return d*numpy.pi/180
print(numpy.sin(toA(arr)))
#获取元素的反正弦
print(numpy.arcsin(numpy.sin(toA(arr))))
#获取余弦
print(numpy.cos(toA(arr)))
#反余弦
print(numpy.arccos(numpy.cos(toA(arr))))
#正切
print(numpy.tan(toA(arr)))
#反正切
print(numpy.arctan(toA(arr)))
#获取角度
sinArr = numpy.sin(toA(arr))
print(numpy.degrees(sinArr))

二元函数

"""
mod()元素级的取模
将将数组中元素的小数位和整数位以两部分独立数组的形式返回
"""
num1 = numpy.random.randint(15,22,size = (2,3))
num2 = numpy.random.randint(1,7,size = (2,3))
print(num1)
print(num2)
print(numpy.mod(num1,num2))
"""
dot()求两个数组的点积
#点积的计算方式
#[[1*11+2*13,1*12+2*14],[3*11+4*13,3*12+4*14]]
"""
a = numpy.array([[1,2],[3,4]])
b = numpy.array([[11,12],[13,14]])
print(numpy.dot(a,b))
"""
   greater() 大于
   less()    小于
   equal()   等于
   执行元素级别的比较运算，最终返回一个布尔型数组
"""
arr = numpy.array([55,2,88,3,99])
arr2 = numpy.array([15,40,89,55,39])
print(numpy.greater(arr,arr2))
print(numpy.less(arr2,arr))
print(numpy.equal(arr2,arr))
"""
shape函数可以了解数组的结构；
reshape()函数可以对数组的结构进行改变。
"""
arr1 = numpy.array([1,2,3,4,5,6,7,8,9,10])
print(arr1.reshape(2, 5))
print(arr1.shape)
"""
逻辑与，或，非，可以放0和None，不报错
执行元素级别的布尔逻辑运算，相当于中缀运算符&、|、^
"""
print(numpy.logical_and(arr,arr2))
print(numpy.logical_or(arr,arr2))
print(numpy.logical_not(arr,arr2))
print('xor:') #两者不同返回 Ture 否则返回false
print(np.logical_xor(arr,arr2))
'''
   power()对数组中的每个元素进行给定次数的指数值，类似于: arr ** 3
'''
print()
print('power函数：')
num1 = numpy.random.randint(1,7,size = (2,3))
print(num1)
print(numpy.power(num1,2))
print()

统计函数

NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等

arr = numpy.array([
    [5,88,4,65,33],
    [76,57,43,2,1],
    [2,5,7,9,33]
])
#0为求一列的，1为求一行的
print(numpy.amax(arr,0))#求最大值
print(numpy.amin(arr,0))#求最大值
print(numpy.sum(arr,axis=0))#求和
print(numpy.max(arr,axis=1))#求最大值，是amax的别名
print(numpy.min(arr,axis=1))#求最小值，是amin的别名
print(numpy.ptp(arr))#求极值，即最大值与最小值之差
print(numpy.mean(arr,axis = 1)) #求行平均值

随机函数，需要导入随机模块random
- random模块
- rand 返回 0 - 1 随机值
- randn 返回一个样本具有标准正态分布
- randint 返回随机的整数，位于半开区间[low,hight)size = 10 (3,3)
- random_integers(low[, high, size]) 返回随机的整数，位于闭区间
- random 返回随机浮点数

a = numpy.random.randint(1,15,size = (3,3))

标准差

"""
    标准差---std  
    是与平均值的偏差的平方的平均值的平方根
    std = sqrt(mean((x-x.mean())**2))
    如果数组是[1,2,3,4] 则平均值是 2.5 因此偏差是[1.5,0.5,0.5,1.5],
    偏差的平方是[2.25,0.25,0.25,2.25]
    并且其平均值的平方根，即sqrt(5/4)
"""
arr2 = numpy.array([[1,2,3,4],[7,8,9,10]])
print(arr2)
print(arr2-arr2.mean()) #平均值的偏差
print(((arr2-arr2.mean())**2).sum()/arr2.size)#平均值的偏差的平方的平均值
print(numpy.mean(((arr2-arr2.mean())**2)))#平均值的偏差的平方的平均值
print(numpy.sqrt(((arr2-arr2.mean())**2).sum()/arr2.size))
print(numpy.sqrt(numpy.mean(((arr2-arr2.mean())**2))))
print(numpy.std(arr2,0))

排序函数

NumPy中提供了各种排序相关功能。这些排序函数实现不同的排序算法，

"""
    每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 
    下表显示了三种排序算法的比较：
    种类                 速度    最坏情况        工作空间     稳定性
    'quicksort'(快速排序)  1     O(n^2)           0           否
    'mergesort'(归并排序)  2     O(n*log(n))     ~n/2         是
    'heapsort'(堆排序)     3     O(n*log(n))      0           否
"""
"""
    numpy.sort()
    函数返回输入数组的排序副本
    numpy.sort(a,axis,kind,order)
    a :要排序的函数
    axis：压着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
    kind:默认为’quicksort’快速排序
    order：如果数组包含字段，则是要排序的字段
"""
#例子1：
arr = numpy.array([
    [5,88,4,65,33],
    [76,57,43,2,1],
    [2,5,7,9,33]
])
print(numpy.sort(arr,axis=0))#没有改变数组
print(arr)
arr.sort(axis=0)#改变了数组
print(arr)
#例子2：
arrType = numpy.dtype([("title",str),("page","int32")])
arr = numpy.array([("ttt1",0),("ttt2",5),("ttt3",8),("ttt4",3)],dtype=arrType)
print(numpy.sort(arr,order="page"))#根据page排序
print(numpy.sort(arr,order="title"))#根据title排序
#例子3：

去重函数

np.uunique函数，即去重函数
主要的作用是将数组中的元素进行去重操作（也就是只保存不重复的数据）

arr = numpy.array([
    [5,88,4,65,33],
    [76,57,43,2,1],
    [2,5,7,9,33]
])
#去重并排序输出到一个一维数组中
print(numpy.unique(arr))
#view（视图）相当于传引用，view和原始数据共享一份数据，修改一个会影响另一个。地址改变
#可以说是：创建了一个新的对象，但是这两个对象共享相同的数据。
arr1 = arr.view()
#copy（副本）地址也变了，相当于重新建了一个数组，且不与原数组产生任何关系
arr2 = arr.copy()
print(id(arr))
print(id(arr1))
print(id(arr2))
结果为：
[ 1  2  4  5  7  9 33 43 57 65 76 88]
2141673011840
2141674757456
2141673153440

三元函数

numpy.where
是三元表达式 x if condition else y 的矢量化版本
传统的三元表达式
zip 函数接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）

#例子1：
xarr = np.array([1,2,3,4,5])
yarr = np.array([6,7,8,9,10])
condition = xarr < yarr
result1 = [x if c else y for (x,y,c) in zip(xarr,yarr,condition)]
print(result1)
result2 = np.where(condition,xarr,yarr)
print(result2)
#例子2：将数组中的所有异常数字替换为0，比如将NaN替换为0
arr = numpy.array([
    [1,2,numpy.NaN,4],
    [4,5,6,numpy.NaN],
    [numpy.inf,7,8,9],
    [numpy.inf,numpy.e,numpy.pi,4]
])
print('原数组：')
print(arr)
#设置条件
condition = numpy.isnan(arr) | numpy.isinf(arr)
print('结果：')
print(numpy.where(condition,0,arr))

广播Broadcasting

基本概念

Broadcasting允许通用函数以有意义的方式处理具有不完全相同形状的输入。
Broadcasting的第一个规则是，如果所有输入数组不具有相同数量的维度，则“1”将被重复地添加到较小数组的形状，直到所有数组具有相同数量的维度。
Broadcasting的第二个规则确保沿着特定维度具有大小为1的数组表现得好像它们具有沿着该维度具有最大形状的数组的大小。假定数组元素的值沿“Broadcasting”数组的该维度相同。
在应用广播规则之后，所有阵列的大小必须匹配。

广播规则

这些阵列都具有完全相同的形状。
阵列都具有相同的维数，每个维度的长度是常用长度或1。
尺寸太小的阵列可以使其形状前面加上长度为1的尺寸以满足属性2。

广播示例

一维数组在轴0上的广播
多维数组在轴0上的广播
二维数组在轴1上的广播

轴的概念

2.副本与视图

在执行函数时，其中一些返回输入数组的副本，而另一些返回视图。当物理存储在
另一位置时，称为副本，另一方面，如果提供了相同内存内容的我们将其称为视图
无复制（即用等号赋值）
简单的赋值不会创建对象的副本。相反，它使用原始数组的相同id()来访问它。
id()返回python对象的同用标识符，类似于C中的指针

视图
视图或浅复制
NUmpy拥有ndarray.view()方法它是一个新的数组对象，并课查看原始数据的相同数据。与赋值不同的是，新数组的位数更改不会影响原始数据的维数，数组的切片也会创建视图

arr = numpy.arange(6).reshape(2,3)
print('原数组：')
print(arr)
print('查看原数组的ID:')
print(id(arr))
print('创建arr的视图brr，brr = arr.view()')
brr = arr.view()
print('brr的id与arr的不相同:')
print(brr)
print(id(brr))
print('修改brr的形状arr的不会改变，但是更改brr里面的值arr的也会改变：')
brr.shape = (3,2)
brr[0,0] = 10
print('brr:')
print(brr)
print('arr:')
print(arr)

副本
副本深复制
ndarray.copy()函数创建一个深层副本。它是数组及其数据的完整副本，不与原始数组共享。

arr = numpy.array([
    [5,88,4,65,33],
    [76,57,43,2,1],
    [2,5,7,9,33]
])
#去重并排序输出到一个一维数组中
print(numpy.unique(arr))
#view（视图）相当于传引用，view和原始数据共享一份数据，修改一个会影响另一个。地址改变
#可以说是：创建了一个新的对象，但是这两个对象共享相同的数据。
arr1 = arr.view()
#copy（副本）地址也变了，相当于重新建了一个数组，且不与原数组产生任何关系
arr2 = arr.copy()
print(id(arr))
print(id(arr1))
print(id(arr2))
结果为：
[ 1  2  4  5  7  9 33 43 57 65 76 88]
2141673011840
2141674757456
2141673153440

3.numpy读写数据

csv
.csv----->一种文件格式的后缀名
Comma-Separated Value,逗号分隔值文件
换行和逗号分隔行列的格式化文本,每一行的数据表示一条记录
由于csv便于展示,读取和写入,所以很多地方也是用csv的格式存储和传输中小型的数据
这里之使用loadtxt和savetxt来说明，它们对应的文件格式都为txt和csv
读取

numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)

在这里插入图片描述

#如果全部售完，卖家可以获得的钱的数目
#计算单价
data = numpy.loadtxt("data.csv",delimiter=",",skiprows=3,usecols=7)
print(data)
#计算数目
nums = numpy.loadtxt("data.csv",delimiter=",",skiprows=3,usecols=9,dtype="int32")
print(nums)
#得出结果
result = data*nums
print(result)

写入

np.savetxt("./dd.txt",res,fmt="%.2f", delimiter=",")

frame : 文件、字符串或产生器，可以是.gz或.bz2的压缩文件
array : 存入文件的数组
fmt : 写入文件的格式，例如：%d %.2f %.18e
delimiter : 分割字符串，默认是任何空格

例子：
import numpy as np 
a=np.arange(0,10,0.5).reshape(4,-1)
np.savetxt("out.txt",a,fmt="%d",delimiter=",") # 改为保存为整数，以逗号分隔
b = np.loadtxt("out.txt",delimiter=",") # load 时也要指定为逗号分隔
print(b)
结果为：
[[0. 0. 1. 1. 2.]
 [2. 3. 3. 4. 4.]
 [5. 5. 6. 6. 7.]
 [7. 8. 8. 9. 9.]]

长江水鸟

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
python基础学习--数据分析之Numpy

python基础学习–数据分析之Numpy介绍用于处理数值类型的数据 NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库一个在Python中做科学计算的基础库，重在数值计算，也是大部分PYTHON科学计算库的基础库，多用于在大型、多维数组上执行数值运算NumPy 是一个运行速...
复制链接

扫一扫