数据分析第二章

2.1 Numpy 数组对象ndarray

# 代码 2-1
import numpy as np #导入 NumPy 库 
arr1 = np.array([1, 2, 3, 4]) #创建一维数组 
print(' 创建的数组为： ',arr1)

# 创建二维数组
arr2 = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]])
print('创建的数组为：\n',arr2)

print('数组类型为：',arr2.dtype)  #查看数组类型
print('数组元素个数为：',arr2.size)  #查看数组元素个数
print('数组每个元素大小为：',arr2.itemsize)  #查看数组每个元素大小

创建的数组为：  [1 2 3 4]
创建的数组为：
 [[ 1  2  3  4]
 [ 4  5  6  7]
 [ 7  8  9 10]]
数组类型为： int32
数组元素个数为： 12
数组每个元素大小为： 4

#代码2-2
arr2.shape = 4,3 #重新设置shape
print('重新设置shape 后的arr2 为：',arr2)

重新设置shape 后的arr2 为： [[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
# 代码 2-3
print('使用arange函数创建的数组为：\n',np.arange(0,1,0.1))
使用arange函数创建的数组为：
 [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
# 代码 2-4
print('使用linspace函数创建的数组为：',np.linspace(0, 1, 12))
使用linspace函数创建的数组为： [0.         0.09090909 0.18181818 0.27272727 0.36363636 0.45454545
 0.54545455 0.63636364 0.72727273 0.81818182 0.90909091 1.        ]
# 代码 2-5
print('使用logspace函数创建的数组为：',np.logspace(0, 2, 20))
使用logspace函数创建的数组为： [  1.           1.27427499   1.62377674   2.06913808   2.6366509
   3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
  11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
  37.92690191  48.32930239  61.58482111  78.47599704 100.        ]
# 代码 2-6
print('使用zeros函数创建的数组为：',np.zeros((2,3)))
使用zeros函数创建的数组为： [[0. 0. 0.]
 [0. 0. 0.]]

# 代码 2-7
print('使用eye函数创建的数组为：',np.eye(3))
使用eye函数创建的数组为： [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

# 代码 2-8
print('使用diag函数创建的数组为：',np.diag([1,2,3,4]))
使用diag函数创建的数组为： [[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]

# 代码 2-9
print('使用ones函数的数组为：',np.ones((5,3)))
使用ones函数的数组为： [[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
# 代码 2-10
print('转换结果为：',np.float64(42))  #整型转换为浮点型
print('转换结果为：',np.int8(42.0))  #浮点型转换为整型
print('转换结果为：',np.bool(42))  #整型转换为布尔型
print('转换结果为：',np.bool(0))  #整型转换为布尔型
print('转换结果为：',np.float(True))  #布尔型转换为浮点型
print('转换结果为：',np.float(False))  #布尔型转换为浮点型

# 代码 2-11
df = np.dtype([("name", np.str_, 40), ("numitems", np.int64),
    ("price",np.float64)])
print('数据类型为：',df)
转换结果为： 42.0
转换结果为： 42
转换结果为： True
转换结果为： False
转换结果为： 1.0
转换结果为： 0.0
# 代码 2-12
print('数据类型为：',df["name"])
print('数据类型为：',np.dtype(df["name"]))

# 代码 2-13
itemz = np.array([("tomatoes", 42, 4.14),("cabbages", 13, 1.72)],
    dtype=df)
print('自定义数据为：',itemz)
数据类型为： [('name', '<U40'), ('numitems', '<i8'), ('price', '<f8')]
数据类型为： <U40
数据类型为： <U40
自定义数据为： [('tomatoes', 42, 4.14) ('cabbages', 13, 1.72)]

# 代码 2-14
print('生成的随机数组为：',np.random.random(100))
生成的随机数组为： [0.29035712 0.55470355 0.99816392 0.33551347 0.08293463 0.44556531
 0.53178431 0.53789455 0.08234868 0.83595469 0.3726637  0.75765048
 0.84908519 0.78726763 0.72644826 0.52151699 0.28586194 0.21204481
 0.11809202 0.86587004 0.46615656 0.93567741 0.87892483 0.46163782
 0.12454961 0.22194019 0.01191737 0.98885821 0.64213461 0.47425751
 0.43595511 0.19188932 0.45667159 0.94831898 0.32661306 0.81921826
 0.08640067 0.45161776 0.24876485 0.7537096  0.34926257 0.99958294
 0.3468626  0.32769651 0.50291438 0.92793596 0.27697293 0.85170313
 0.94097034 0.04905478 0.3437512  0.26775942 0.62776722 0.24521679
 0.15484687 0.47635257 0.21294752 0.99159322 0.4599956  0.6910366
 0.62033643 0.5342566  0.18285407 0.02461278 0.29537463 0.99051524
 0.17719616 0.53491538 0.61218246 0.32800622 0.21922365 0.70199982
 0.22475512 0.33735773 0.416338   0.7015899  0.02271632 0.85216232
 0.36213282 0.0810605  0.12005646 0.04658047 0.37149021 0.30841899
 0.1747147  0.28758972 0.0799932  0.64748883 0.46751371 0.95372788
 0.10631499 0.39197466 0.12525545 0.74674668 0.68179737 0.07544131
 0.36196381 0.12442483 0.0824717  0.95521567]

# 代码 2-15
print('生成的随机数组为：\n',np.random.rand(10,5))
生成的随机数组为：
 [[0.32647198 0.51157664 0.81547476 0.20857105 0.18865529]
 [0.23704684 0.12060751 0.88961965 0.79585654 0.51432557]
 [0.57116832 0.55927659 0.1208306  0.78855248 0.37623374]
 [0.62105789 0.77303539 0.24961779 0.12021282 0.68787783]
 [0.44852622 0.3030715  0.45309526 0.18388185 0.99304243]
 [0.25515836 0.42006589 0.37400662 0.65236982 0.09921883]
 [0.79292742 0.00420025 0.66580352 0.49676793 0.12497231]
 [0.49485876 0.27306417 0.1897283  0.77697491 0.85439833]
 [0.49187305 0.69534968 0.65651651 0.40353288 0.17448197]
 [0.20280328 0.48615179 0.81480625 0.658735   0.4912505 ]]

# 代码 2-16
print('生成的随机数组为：\n',np.random.randn(10,5))
生成的随机数组为：
 [[-1.20040011  0.96614597  1.21709002  0.1595595   0.5086843 ]
 [-0.39222159  1.38469982  0.54565327 -0.05214325  0.37604684]
 [ 1.04510832 -0.43135193  0.09638756  0.19038356 -0.17510115]
 [-2.15550747  0.61733181  0.14047216 -0.52478051 -0.55958629]
 [-0.20052432 -1.43286048  0.62342899  0.8130792  -0.69504517]
 [ 1.97910891  0.01510512  0.72718736 -0.21584009 -0.1021117 ]
 [ 0.89979072  0.1266896  -0.02685013  0.29770082  0.47358179]
 [ 0.03862873  0.31637127 -1.75891469  1.04143655 -0.08164326]
 [ 0.85707273 -0.17493711  0.35506853  0.07412862  0.02447039]
 [-0.7488764  -0.50040087 -0.51384774  0.12427226 -1.79689403]]

# 代码 2-17
print('生成的随机数组为：',np.random.randint(2,10,size = [2,5]))
生成的随机数组为： [[2 2 9 8 3]
 [4 3 5 3 5]]
# 代码 2-18
arr = np.arange(10)
print('索引结果为：',arr[5])  #用整数作为下标可以获取数组中的某个元素
#用范围作为下标获取数组的一个切片，包括arr[3]不包括arr[5]
print('索引结果为：',arr[3:5])
print('索引结果为：',arr[:5])  #省略开始下标，表示从arr[0]开始
#下标可以使用负数，-1表示从数组后往前数的第一个元素
print('索引结果为：',arr[-1])

arr[2:4] = 100,101
print('索引结果为：',arr)  #下标还可以用来修改元素的值
#范围中的第三个参数表示步长，2表示隔一个元素取一个元素
print('索引结果为：',arr[1:-1:2])
print('索引结果为：',arr[5:1:-2])  #步长为负数时，开始下标必须大于结束下标
索引结果为： 5
索引结果为： [3 4]
索引结果为： [0 1 2 3 4]
索引结果为： 9
索引结果为： [  0   1 100 101   4   5   6   7   8   9]
索引结果为： [  1 101   5   7]
索引结果为： [  5 101]
# 代码 2-19
arr = np.array([[1, 2, 3, 4, 5],[4, 5, 6, 7, 8], [7, 8, 9, 10, 11]])
print('创建的二维数组为：',arr)
print('索引结果为：',arr[0,3:5])  #索引第0行中第3和第4列的元素
#索引第2和第3行中第3列、第4列和第5列的元素
print('索引结果为：\n',arr[1:,2:])
print('索引结果为：',arr[:,2])  #索引第2列的元素
创建的数组1为： [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
创建的数组2为： [[ 0  3  6  9]
 [12 15 18 21]
 [24 27 30 33]]

# 代码 2-20
#从两个序列的对应位置取出两个整数组成下标：arr[0,1], arr[1,2], arr[2,3]
print('索引结果为：',arr[[(0,1,2),(1,2,3)]])
print('索引结果为：',arr[1:,(0,2,3)])  #索引第2、3行中第0、2、3列的元素

mask = np.array([1,0,1],dtype = np.bool)
#mask是一个布尔数组，它索引第1、3行中第2列的元素
print('索引结果为：',arr[mask,2])


# 代码 2-21
'''
arr = np.arange(12)  #创建一维数组
print('创建的一维数组为：',arr)
print('新的一维数组为：',arr.reshape(3,4))  #设置数组的形状
print('数组维度为：',arr.reshape(3,4).ndim)  #查看数组维度
'''

# 代码 2-22
arr = np.arange(12).reshape(3,4)
print('创建的二维数组为：',arr)
print('数组展平后为：',arr.ravel())

# 代码 2-23
print('数组展平为：',arr.flatten())  #横向展平
print('数组展平为：',arr.flatten('F'))  #纵向展平

# 代码 2-24
arr1 = np.arange(12).reshape(3,4)
print('创建的数组1为：',arr1)

arr2 = arr1*3
print('创建的数组2为：',arr2)
print('横向组合为：',np.hstack((arr1,arr2)))  #hstack函数横向组合

# 代码 2-25
print('纵向组合为：',np.vstack((arr1,arr2)))  #vstack函数纵向组合

# 代码 2-26
print('横向组合为：',np.concatenate((arr1,arr2),axis = 1))  #concatenate函数横向组合
print('纵向组合为：',np.concatenate((arr1,arr2),axis = 0))  #concatenate函数纵向组合

# 代码 2-27
arr = np.arange(16).reshape(4,4)
print('创建的二维数组为：',arr)
print('横向分割为：',np.hsplit(arr, 2))  #hsplit函数横向分割

# 代码 2-28
print('纵向分割为：',np.vsplit(arr, 2))  #vsplit函数纵向分割

# 代码 2-29
'''
print('横向分割为：',np.split(arr, 2, axis=1))  #split函数横向分割
print('纵向分割为：',np.split(arr, 2, axis=0))  #split函数纵向分割

横向分割为： [array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

纵向分割为： [array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]