python工具包--Numpy小练习

简介: python工具包--Numpy小练习
import numpy as np


1.打印当前Numpy版本


print(np.__version__)


1.18.1


2.构造一个全零的矩阵,并打印其占用的内存大小


Clichong = np.zeros((5,5))
Clichong


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


# 数组的数量
Clichong.size


25


# 数组每个元素的大小
Clichong.itemsize


8


# 数组的类型
Clichong.dtype


dtype('float64')


# 可以知道Clichong这个二维变量的大小
print("size:",Clichong.size*Clichong.itemsize)


size: 200


3.打印一个函数的帮助文档,比如numpy.add


print(help(np.add))


4.创建一个10-49的数组,并将其倒序排列


# arange(10,50,1)是numpy语句部分,后面的[::-1]是python语句部分,所以可以使用一句就可以实现倒序排序
Clichong = np.arange(10,50,1)[::-1]
Clichong


[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26
 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10]
array([49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,
       32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
       15, 14, 13, 12, 11, 10])


5.找到一个数组中不为0的索引


# 测试数组
test = np.array([2,3,5,7,0,2,0,4,2,6,0,5,26,7,0,6,0,0])
print("test.size:",test.size)


test.size: 18


# 方法1:利用where语句
a = np.where(test != 0)
print("position:",a)


position: (array([ 0,  1,  2,  3,  5,  7,  8,  9, 11, 12, 13, 15], dtype=int64),)


# 方法2:利用nonzero函数
a = np.nonzero(test)
print("position:",a)


position: (array([ 0,  1,  2,  3,  5,  7,  8,  9, 11, 12, 13, 15], dtype=int64),)


6.随机构造一个3*3矩阵,并打印其中最大与最小值


# randint创建一个取值为0-100,3x3的随机矩阵
Clichong = np.random.randint(100,size = (3,3))
print("Clichong:\n",Clichong)
# 全部元素进行对比
print("max:",Clichong.max())
print("min:",Clichong.min())
# 对列进行对比
print("max:",Clichong.max(axis = 0))
# 对行进行对比
print("min:",Clichong.min(axis = 1))


Clichong:
 [[95 15 84]
 [55 22 28]
 [ 2 29 91]]
max: 95
min: 2
max: [95 29 91]
min: [15 22  2]


7.构造一个5*5的矩阵,令其值都为1,并在最外层加上一圈0


#利用numpy的pad函数,其相关参数API文档如下,可以print(help(np.pad))来打印出来查看
Clichong = np.ones((5,5))
Clichong = np.pad(Clichong,1,mode='constant',constant_values = 0)
Clichong
#print(help(np.pad))


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


8.构建一个shape为(6,7,8)的矩阵,并找到第100个元素的索引值


# 使用unravel_index函数来找到索引值,print(help(np.unravel_index))
Clichong = np.random.randint(10,size = (6,7,8))
print(Clichong.shape)
# 100是索引值,(6,7,8)是矩阵的形状,只能写出来,不能用Clichong替代,具体参考文档
np.unravel_index(100,(6,7,8))
# print(help(np.unravel_index))


(6, 7, 8)
(1, 5, 4)


9.对一个5*5的矩阵做归一化操作


归一化的定义与功能:归一化就是要把你需要处理的数据经过处理后(通过某种算法)限制在你需要的一定范围内。首先归一化是为了后面数据处理的方便,其


次是保证模型运行时收敛加快。


# Clichong = np.random.randint(10,size = (5,5))
Clichong = np.random.random((5,5))
print("before:\n",Clichong)
max = Clichong.max()
min = Clichong.min()
Clichong = (Clichong-min)/(max-min)
print("After:\n",Clichong)


before:
 [[0.42707272 0.81047186 0.91071421 0.23840794 0.3771108 ]
 [0.90182748 0.90802103 0.61158242 0.00489321 0.21548403]
 [0.64966355 0.65816033 0.04054501 0.00760435 0.44263836]
 [0.84498916 0.47003901 0.77073106 0.38147171 0.50009968]
 [0.65061004 0.79489827 0.84465063 0.94343758 0.4159035 ]]
After:
 [[0.4498237  0.85832772 0.96513392 0.24880521 0.3965903 ]
 [0.95566528 0.96226438 0.64641505 0.         0.22438025]
 [0.68698972 0.69604287 0.03798627 0.00288866 0.46640859]
 [0.89510521 0.49560342 0.81598471 0.40123676 0.52763245]
 [0.68799819 0.84173438 0.89474451 1.         0.43792313]]


10.找到两个数组中相同的值或者是相同值的位置


# 定义两个随机数组取值为0-10,数目为30个
a = np.random.randint(0,20,10)
b = np.random.randint(0,20,10)
print("a:",a)
print("b:",b)


a: [18  1 10 15  6  8 16 10 12 14]
b: [ 5 12  5  0 19  5 18 15  0  0]


# 找出两个数组相同值的位置
np.where(a == b)


(array([], dtype=int64),)


# 找出两个数组中共有的值,利用intersect1d函数
np.intersect1d(a,b)


array([12, 15, 18])


11.得到今天 明天 昨天的日期


# 利用datetime64函数 print(help(np.datetime64))
today = np.datetime64('today','D')
yesterday = np.datetime64('today','D') - np.timedelta64(1,'D')
tomorrow = np.datetime64('today','D') + np.timedelta64(1,'D')
print("today:",today)
print("yesterday:",yesterday)
print("tomorrow:",tomorrow)


today: 2021-01-20
yesterday: 2021-01-19
tomorrow: 2021-01-21


12.得到一个数的整数部分


# 定义一个小数数组,范围是0-10,个数为10个
z = np.random.uniform(0,10,10)
print(z)
# 去除小数部分的函数floor
np.floor(z)


[9.78465077 2.07504483 8.34613494 2.81205194 2.97713123 0.26551266
 6.33476669 6.13764817 5.38474901 0.57251498]
array([9., 2., 8., 2., 2., 0., 6., 6., 5., 0.])


13.构造一个数组,让它不能被改变


Clichong = np.array([1,2,3,4,5,6,7,8,9,0])
# 关闭可改标志
Clichong.flags.writeable = False
Clichong[1] = 0


---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-59-7fa6a686b7d3> in <module>
      2 # 关闭可改标志
      3 Clichong.flags.writeable = False
----> 4 Clichong[1] = 0
ValueError: assignment destination is read-only


14.打印大数据的部分值,全部值(无需全部打印出来)


# 通过set_printoptions函数来设置,都只是显示6行6列
# np.set_printoptions(threshold=10000) # 这个参数填的是你想要多少行显示
# np.set_printoptions(linewidth=100) # 这个参数填的是横向多宽
np.set_printoptions(threshold=20)
z = np.zeros((15,15))
z


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


15.找到在一个数组中,最接近一个数的索引


# 函数argmin返回沿轴的最小值的索引。如果多次出现最小值,则索引对应于第一次出现的返回。
a = np.random.uniform(0,10)
b = np.arange(10)
print("a:",a)
print("b:",b)
# abs()的操作的去绝对值的操作,所以一个很小的负数取绝对值会变成一个很大的数
print((np.abs(b-a)))
print("最接近的索引是:",(np.abs(b-a)).argmin())
#(np.abs(b-a)).argmin()
#print(help(np.argmin))


a: 6.430836025704295
b: [0 1 2 3 4 5 6 7 8 9]
[6.43083603 5.43083603 4.43083603 3.43083603 2.43083603 1.43083603
 0.43083603 0.56916397 1.56916397 2.56916397]
最接近的索引是: 6


16.32位float类型和32位int类型转换


Clichong = np.array([1,2,3,4,5,6,7,8,9],dtype = np.float32)
print("before_type",Clichong.dtype)
Clichong = Clichong.astype(np.int32)
print("After_type",Clichong.dtype)


before_type float32
After_type int32


17.打印数组元素位置坐标与数值


# ndenumerate函数与python中的enumerate类似,reshape可以重新改变数组的结构
Clichong = np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(Clichong):
    print (index,value)
print(np.ndenumerate(Clichong)


(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 3
(1, 1) 4
(1, 2) 5
(2, 0) 6
(2, 1) 7
(2, 2) 8
<numpy.ndenumerate object at 0x00000270CE55DA88>


18.按照数组的某一列进行排序(比较抽象,需要多看几遍)


# 按照第二列升序
Clichong = np.array([[1,2,4],[3,5,2],[4,3,1],[2,4,0]])
print(Clichong)


[[1 2 4]
 [3 5 2]
 [4 3 1]
 [2 4 0]]


# 方法:lexsort函数
# 其中的 1 表示升序; 若是是 -1 则表示降序
index = np.lexsort([1*Clichong[:,1]])
print("index:",index)
Clichong[index]


index: [0 2 3 1]
array([[1, 2, 4],
       [4, 3, 1],
       [2, 4, 0],
       [3, 5, 2]])


# 方法2:argsort函数
# z[z[:,1].argsort()]
print("index:",Clichong[:,1].argsort())
Clichong[Clichong[:,1].argsort()]


index: [0 2 3 1]
array([[1, 2, 4],
       [4, 3, 1],
       [2, 4, 0],
       [3, 5, 2]])


19.统计数组中每个数值出现的次数


在python中,统计数值出现的次数有直接的函数来完成,不需要再自己写一个复杂的函数


Clichong = np.array([1,0,1,0,1,2,0,2,3,3,4,5,8])
print(np.bincount(Clichong))


[3 3 2 2 1 1 0 0 1]


20.找到一个数组中最常出现的数字


Clichong = np.array([1,0,6,6,1,0,1,6,2,6,0,2,3,0,6,3,4,6,0,5,8])
# 统计数组中每个数值出现的次数
Clichong = np.bincount(Clichong)
print(Clichong)
# 返回最多出现数字的下标,也就打印出最常出现的数字
np.argmax(Clichong)


[5 3 2 2 1 1 6 0 1]
6


21.交换矩阵中的两行


Clichong = np.random.randint(10,size = (5,5))
print("Clichong_before:\n",Clichong)
Clichong[[0,1]] = Clichong[[1,0]]
print("Clichong_after:\n",Clichong)


Clichong_before:
 [[1 9 5 5 5]
 [0 5 8 2 9]
 [7 0 3 8 0]
 [3 5 0 7 3]
 [1 5 3 4 3]]
Clichong_after:
 [[0 5 8 2 9]
 [1 9 5 5 5]
 [7 0 3 8 0]
 [3 5 0 7 3]
 [1 5 3 4 3]]




目录
打赏
0
0
0
0
20
分享
相关文章
【01】做一个精美的打飞机小游戏,浅尝阿里云通义灵码python小游戏开发AI编程-之飞机大战小游戏上手实践-优雅草央千澈-用ai开发小游戏尝试-分享源代码和游戏包
【01】做一个精美的打飞机小游戏,浅尝阿里云通义灵码python小游戏开发AI编程-之飞机大战小游戏上手实践-优雅草央千澈-用ai开发小游戏尝试-分享源代码和游戏包
131 47
【01】做一个精美的打飞机小游戏,浅尝阿里云通义灵码python小游戏开发AI编程-之飞机大战小游戏上手实践-优雅草央千澈-用ai开发小游戏尝试-分享源代码和游戏包
【02】做一个精美的打飞机小游戏,python开发小游戏-鹰击长空—优雅草央千澈-持续更新-分享源代码和游戏包供游玩-记录完整开发过程-用做好的素材来完善鹰击长空1.0.1版本
【02】做一个精美的打飞机小游戏,python开发小游戏-鹰击长空—优雅草央千澈-持续更新-分享源代码和游戏包供游玩-记录完整开发过程-用做好的素材来完善鹰击长空1.0.1版本
Python装饰器实战:打造高效性能计时工具
在数据分析中,处理大规模数据时,分析代码性能至关重要。本文介绍如何使用Python装饰器实现性能计时工具,在不改变现有代码的基础上,方便快速地测试函数执行时间。该方法具有侵入性小、复用性强、灵活度高等优点,有助于快速发现性能瓶颈并优化代码。通过设置循环次数参数,可以更准确地评估函数的平均执行时间,提升开发效率。
88 61
Python装饰器实战:打造高效性能计时工具
如何在Python中管理模块和包的依赖关系?
在实际开发中,通常会结合多种方法来管理模块和包的依赖关系,以确保项目的顺利进行和可维护性。同时,要及时更新和解决依赖冲突等问题,以保证代码的稳定性和可靠性
79 4
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
【03】做一个精美的打飞机小游戏,规划游戏项目目录-分门别类所有的资源-库-类-逻辑-打包为可玩的exe-练习python打包为可执行exe-优雅草卓伊凡-持续更新-分享源代码和游戏包供游玩-1.0.2版本
Python时间序列分析工具Aeon使用指南
**Aeon** 是一个遵循 scikit-learn API 风格的开源 Python 库,专注于时间序列处理。它提供了分类、回归、聚类、预测建模和数据预处理等功能模块,支持多种算法和自定义距离度量。Aeon 活跃开发并持续更新至2024年,与 pandas 1.4.0 版本兼容,内置可视化工具,适合数据探索和基础分析任务。尽管在高级功能和性能优化方面有提升空间,但其简洁的 API 和完整的基础功能使其成为时间序列分析的有效工具。
66 37
Python时间序列分析工具Aeon使用指南
如何在Python中解决模块和包的依赖冲突?
解决模块和包的依赖冲突需要综合运用多种方法,并且需要团队成员的共同努力和协作。通过合理的管理和解决冲突,可以提高项目的稳定性和可扩展性
剖析文件共享工具背后的Python哈希表算法奥秘
在数字化时代,文件共享工具不可或缺。哈希表算法通过将文件名或哈希值映射到存储位置,实现快速检索与高效管理。Python中的哈希表可用于创建简易文件索引,支持快速插入和查找文件路径。哈希表不仅提升了文件定位速度,还优化了存储管理和多节点数据一致性,确保文件共享工具高效运行,满足多用户并发需求,推动文件共享领域向更高效、便捷的方向发展。
手动解决Python模块和包依赖冲突的具体步骤是什么?
需要注意的是,手动解决依赖冲突可能需要一定的时间和经验,并且需要谨慎操作,避免引入新的问题。在实际操作中,还可以结合使用其他方法,如虚拟环境等,来更好地管理和解决依赖冲突😉。
如何在Python中自动解决模块和包的依赖冲突?
完全自动解决所有依赖冲突可能并不总是可行,特别是在复杂的项目中。有时候仍然需要人工干预和判断。自动解决的方法主要是提供辅助和便捷,但不能完全替代人工的分析和决策😉。

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等