numpy学习笔记

最新推荐文章于 2024-03-25 23:57:12 发布

波西塔塔Y

最新推荐文章于 2024-03-25 23:57:12 发布

阅读量177

点赞数

分类专栏： Python数据分析

本文链接：https://blog.csdn.net/u012881559/article/details/79984261

版权

Python数据分析专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细探讨了numpy库在Python中的重要地位，深入解析了其基本数据结构ndarray，包括数组创建、索引操作和基本数学运算。同时，介绍了ufunc函数的应用，以及如何利用numpy进行高效的数组操作和矩阵运算。通过实例分析，进一步阐述了numpy在数据分析和科学计算中的强大功能。

摘要由CSDN通过智能技术生成

'''

#numpy的快速入门

'''

import numpy as np

data1= [6,7.3,8,0,1]
arr1 = np.array(data1)

data2 =[[1,2,3,4],[5,6,7,8]]
arr2 = np.array(data2)
arr3 = np.zeros_like(data2)
arr4 = np.ones_like(data2)

print(arr2.ndim,'\t',arr2.shape,'\n',arr2,'\n')
#print(np.zeros((2,3)))

##数组之间的标量运算

print(arr2 * arr3,'\n\n',arr2+arr4,'\n\n',arr4/arr2,'\n\n',arr2**2)

2    (2, 4) 
 [[1 2 3 4]
 [5 6 7 8]] 

[[0 0 0 0]
 [0 0 0 0]] 

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

 [[1.         0.5        0.33333333 0.25      ]
 [0.2        0.16666667 0.14285714 0.125     ]] 

 [[ 1  4  9 16]
 [25 36 49 64]]

np.multiply(arr2,arr3)  #数组元素相乘

array([[0, 0, 0, 0],
       [0, 0, 0, 0]])

np.power(arr2,arr3)

array([[1, 1, 1, 1],
       [1, 1, 1, 1]], dtype=int32)

np.mod(arr2,arr4)

array([[0, 0, 0, 0],
       [0, 0, 0, 0]], dtype=int32)


#### range()
#print(range(10))
#print(np.arange(10))


'''
##布尔型索引
'''

names = np.array(['bob','joe','will','joe','bob','joe','bob'])
data = np.random.randn(7,4) # 生成一些正态分布的随机数据

data

array([[-0.36445702, -0.10862503, -0.35411939, -0.36823   ],
       [ 1.58130675,  0.39197103,  1.23420862,  0.82778729],
       [ 0.11581275, -0.65302218, -2.76921464,  0.23295303],
       [ 0.76543605,  0.53558976,  0.43695188, -0.26642543],
       [ 0.02011056, -0.5956487 , -1.65221849,  0.46018221],
       [ 0.48787813,  1.18691301, -0.24028017,  0.16541201],
       [-0.55061254,  1.19822697,  1.5480699 ,  0.53932534]])

data[names=='bob'] 
'''
#取 0，5 ，6行（轴）的数据，
#因为names数组上0，5，6上的数据为bob，names==‘bob’的返回值为1
'''

array([[-0.36445702, -0.10862503, -0.35411939, -0.36823   ],
       [ 0.02011056, -0.5956487 , -1.65221849,  0.46018221],
       [-0.55061254,  1.19822697,  1.5480699 ,  0.53932534]])

data[data <0]=0  # =赋值，==比较，！=，&，|，- 不等，与，或，非

data

array([[0.        , 0.        , 0.        , 0.        ],
       [1.58130675, 0.39197103, 1.23420862, 0.82778729],
       [0.11581275, 0.        , 0.        , 0.23295303],
       [0.76543605, 0.53558976, 0.43695188, 0.        ],
       [0.02011056, 0.        , 0.        , 0.46018221],
       [0.48787813, 1.18691301, 0.        , 0.16541201],
       [0.        , 1.19822697, 1.5480699 , 0.53932534]])


'''
##花式索引
'''

arr5=data[[1,6]][:,[3,1]]   #取特定行上的特定数据，并且返回矩阵形式。这里是复制数组。

arr6=data[[1,6],[3,1]]      #取第一行的第三个元素，第6行的第一个元素
print (arr5,'\n',arr6)

[[0.82778729 0.39197103]
 [0.53932534 1.19822697]] 
 [0.82778729 1.19822697]

'''
矩阵转置
'''
arr7 = np.arange(15).reshape((3,5))
arr7

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

arr7.sum(axis=0)

array([15, 18, 21, 24, 27])

arr7.sum(axis=1)

array([10, 35, 60])

arr7.T

array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])

np.dot(arr7.T,arr7)

array([[125, 140, 155, 170, 185],
       [140, 158, 176, 194, 212],
       [155, 176, 197, 218, 239],
       [170, 194, 218, 242, 266],
       [185, 212, 239, 266, 293]])

'''
通用函数 ufunc
一元函数：sqrt()\exp()\abs()\
二元函数：add()\maximum()  可以接受俩个数组，并返回一个结果数组
'''
arr8 = np.arange(4)

np.sqrt(arr8)

array([0.        , 1.        , 1.41421356, 1.73205081])

np.exp(arr8)

array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692])

np.maximum(2,3)

np.modf(arr8)  #对于浮点数，返回小数部分和整数部分，返回俩个数组

(array([0., 0., 0., 0.]), array([0., 1., 2., 3.]))

'''
np.where()
# x if condition else y

'''
np.where(data>0,1,-1)

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],
       [-1,  1,  1,  1]])

'''
统计
sum(求和)、mean(平均数),std(标准差),var(方差)
argmin,argmax (最大最小元素索引)

'''
print(arr8.mean(),np.mean(arr8))

1.5 1.5

'''
文件读取
np.load \ np.save
np.loadtxt \ np.savetxt
矩阵运算
array.T \ np.dot(X,Y)
随机数生成
numpy.random normal() ,randn() 

'''

nsteps =1000
draws = np.random.randint(0,2,size=nsteps)
steps = np.where(draws>0,1,-1)
walk=steps.cumsum()

draws

array([1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0,
       0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1,
       0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0,
       1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0,
       0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0,
       0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0,
       0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,
       1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1,
       0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1,
       1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1,
       0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1,
       0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1,
       0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
       1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1,
       0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0,
       0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1,
       1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1,
       0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0,
       1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1,
       0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0,
       0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0,
       1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0,
       0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1,
       1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1,
       0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0,
       1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0,
       0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0,
       0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1,
       1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0,
       0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1,
       1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1,
       1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1,
       0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
       0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0,
       0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1,
       0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0,
       0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1,
       1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1,
       0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1,
       0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0,
       1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1,
       0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1,
       0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0,
       0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0,
       0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
       0, 1, 1, 0, 0, 1, 0, 1, 1, 1])

draws = np.random.randint(0,2,size=(2,nsteps))
draws

array([[0, 0, 0, ..., 1, 1, 1],
       [0, 1, 1, ..., 0, 0, 1]])

walk.min()

-2

walk.max()

(np.abs(walk)>=10).argmax()

波西塔塔Y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录