数据分析—numpy

（https://blog.csdn.net/taiyang5946/article/details/77859851）用numpy时要注意缩进，顶头写

否者报错。

a_list = range(10)

b_list = range(10)
# 把两个列表中的元素一一对应相乘,把结果放在列表中\n
c_list = []
for x in range(len(a_list)):
# 根据x的值  取出列表中的数据 相乘  结果放入c列表中\n",
    c = a_list[x] * b_list[x]
    c_list.append(c)
    print(c_list)

[0]
[0, 1]
[0, 1, 4]
[0, 1, 4, 9]
[0, 1, 4, 9, 16]
[0, 1, 4, 9, 16, 25]
[0, 1, 4, 9, 16, 25, 36]
[0, 1, 4, 9, 16, 25, 36, 49]
[0, 1, 4, 9, 16, 25, 36, 49, 64]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 引入numpy,重命名为np\n
import numpy as np
# 生成一个numpy中的一维数组
# numpy中的数组,存储的所有数据必须是同质(相同类型)的
a_arr = np.arange(10)
print(a_arr)
b_arr = np.arange(10)
    # 直接使用数组做向量运算的,会把运算作用到数组中的每一个元素中
c_arr = a_arr * b_arr

print(c_arr)

运行结果：

[0 1 2 3 4 5 6 7 8 9]
[ 0  1  4  9 16 25 36 49 64 81]

import numpy as np

data = np.random.rand(2,3)
print(data)
print('维度个数',data.ndim)
print('各维度大小',data.shape)

print('数据类型',data.dtype)

运行结果：

[[0.99220889 0.99680282 0.51083921]
 [0.98437702 0.9869212  0.82989925]]
维度个数 2
各维度大小 (2, 3)
数据类型 float64

 # python中列表转换numpy中的数组
l1 = range(10)
print(type(l1))
# 转换为数组
arr = np.array(l1)
print(type(arr))
print(arr.ndim)
print(arr.shape)
print(arr.dtype)

l2 = [range(10),range(10,20)]
print(type(l2))
arr = np.array(l2)
print(arr)
print(arr.ndim)
print(arr.shape)
print(arr.dtype)

<class 'list'>
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]]
2
(2, 10)
int32

#  zeros() \\ ones() \\ empty()函数  创建数组\n",
# 使用zeros()创建指定维度,指定数据类型的数组\n",
# 1.维度信息  2.指定类型\n",
# 如果不指定数据类型,默认全部是0.的float64的数据\n",
zeros_arr = np.zeros((2,3),np.int32)
print(zeros_arr)
print(zeros_arr.dtype)
   
# 使用ones()函数创建指定维度,指定数据类的数组\n",
# 不指定数据类型,默认是全部为1的float64类型的数据\n",
ones_arr = np.ones((2,3),np.int32)
print(ones_arr)
    
# 使用empty()函数创建指定为度的数组\n",
# 不指定数据类型,默认为全部为1的float64的数据\n",
empty_arr = np.empty((2,3))
print(empty_arr)
# 如果想要一个空字符串的数组,可以指定数据类型为np.str
empty_arr_str = np.empty((2,3),np.str)
print(empty_arr_str)
# 创建对角线数据全部为1的数组
identity_arr = np.identity(3,dtype=np.int64)
print(identity_arr)

[[0 0 0]
 [0 0 0]]
int32
[[1 1 1]
 [1 1 1]]
[[0.99220889 0.99680282 0.51083921]
 [0.98437702 0.9869212  0.82989925]]
[['' '' '']
 ['' '' '']]
[[1 0 0]
 [0 1 0]
 [0 0 1]]

zeros_arr = np.zeros((3,3),np.int64)
print(zeros_arr)
print(zeros_arr.dtype)
# astype()函数,转换数组中的数据类型
zeros_float_arr = zeros_arr.astype(np.float64)
print(zeros_float_arr)
print(zeros_float_arr.dtype)
    
# 存储数据为小数类型,转换为整数类型\n",
data_arr = np.array([1.45,2.34,3.14,5.5,6.6,3.1])
print(data_arr)
print(data_arr.dtype)
# 将float64数据类型转换为整数int64类型,只保留整数部分\n",
int_data_arr = data_arr.astype(np.int64)

print(int_data_arr)

[[0 0 0]
 [0 0 0]
 [0 0 0]]
int64
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
float64
[1.45 2.34 3.14 5.5  6.6  3.1 ]
float64
[1 2 3 5 6 3]

​

# 数组的运算
arr = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[4,5,6],[7,8,9]])
# 乘法运算   会把运算作用数组中的每一个元素中\n",
print('乘法运算',arr*3)
# 乘方
print('乘方运算',arr**2)
   
# 矩阵(数组)加减乘除运算\n",
print(arr+arr)
print(arr-arr2)
print(arr/arr2)

print(arr*arr2)

乘法运算 [[ 3  6  9]
 [12 15 18]]
乘方运算 [[ 1  4  9]
 [16 25 36]]
[[ 2  4  6]
 [ 8 10 12]]
[[-3 -3 -3]
 [-3 -3 -3]]
[[0.25       0.4        0.5       ]
 [0.57142857 0.625      0.66666667]]
[[ 4 10 18]
 [28 40 54]]

# BMI体重计算器,计算若干人员的身高体重比\n",
# BMI = 体重/身高(m)^2\n",
# 有两个数组,一个存放体重  一个存放身高  将身高体重一一计算,把计算结果放入数组\n",
# 1.列表进行运算\n",
weight_list = [65,75,85]
height_list = [1.7,1.75,1.8]
result =[]
for x in range(len(weight_list)):
    bmi = weight_list[x]/(height_list[x]*height_list[x])
    result.append(bmi)
    print(result)
    # 2.array数据运算\n",
    w_arr = np.array(weight_list)
    h_arr = np.array(height_list)
    # 直接使用数组做向量运算\n",
    rs_arr = w_arr/(h_arr**2)
    print(rs_arr)
    
    # 表达式返回的是存放布尔类型化数据数组\n",
    is_ok = rs_arr >=23
    print(is_ok)
    print(is_ok.dtype)
    # 通过is_ok数据可以将数组中数据取出来\n",
    # 取出bmi大于等23的身高和体重\n",
    # 把True对应的数据取出来\n",
    w_rs = w_arr[is_ok]
    print(w_rs)
    h_rs = h_arr[is_ok]

    print(h_rs)

[22.49134948096886]
[22.49134948 24.48979592 26.2345679 ]
[False  True  True]
bool
[75 85]
[1.75 1.8 ]
[22.49134948096886, 24.489795918367346]
[22.49134948 24.48979592 26.2345679 ]
[False  True  True]
bool
[75 85]
[1.75 1.8 ]
[22.49134948096886, 24.489795918367346, 26.234567901234566]
[22.49134948 24.48979592 26.2345679 ]
[False  True  True]
bool
[75 85]
[1.75 1.8 ]

year_arr = np.array([
       [2000,2013,2015],
       [2008,2019,2007],
       [2010,2012,2017]
    ])
    # 筛选出大于等于2015的年份\n",
is_year_after = year_arr >= 2015
print(is_year_after)
    # 根据筛选的结果布尔数据取出数据\n",
filter_year = year_arr[is_year_after]
print(filter_year)
    # 等同于上面的写法\n",
filter_year = year_arr[year_arr>=2015]
print(filter_year)
print('-----------------------------------------------')
    
    # 多个条件同时成立\n",
filter_year = year_arr[(year_arr>=2007) & (year_arr%4==0)]
print(filter_year)
    
    # 多个条件有一个成立即可 | 或者\n",
filter_year = year_arr[(year_arr>=2007) | (year_arr%2==0)]

print(filter_year)

[[False False  True]
 [False  True False]
 [False False  True]]
[2015 2019 2017]
[2015 2019 2017]
-----------------------------------------------
[2008 2012]
[2000 2013 2015 2008 2019 2007 2010 2012 2017]

# 数组的切片\n",
arr = np.arange(10)
print(arr)
    # 数据中的索引从0开始,依次+1\n",
print(arr[3])
    # 切片\
print(arr[2:5])
print(arr[:5])
print(arr[2:])

print(arr[2::3])

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

# reshape()把一维数组转换为多维数组\n",
# 转换之后的数据总个数必须等于转换之前的个数\n",
arr2 = np.arange(12).reshape(3,4)
print(arr2)
# 多维数组通过组合索引取值\n",
print(arr2[1,1])
    # 切片\n",
print(arr2[0:2])
print(arr2[0:2,2:])

print(arr2[:,1:3])

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
5
[[0 1 2 3]
 [4 5 6 7]]
[[2 3]
 [6 7]]
[[ 1  2]
 [ 5  6]
 [ 9 10]]

arr3 = np.random.rand(2,3)
print(arr3)
print(arr3.ndim),
print(arr3.shape)
# 转置之后,将数组中的各个索引数据对应结合\n",
arr4 = arr3.transpose()
print(arr4)
print(arr4.ndim)
print(arr4.shape)
    
# 多维数组转一维数组\n",
arr5 = arr4.reshape(6)

print(arr5)

[[0.32211391 0.7809368  0.28596324]
 [0.83252519 0.52694696 0.03446635]]
2
(2, 3)
[[0.32211391 0.83252519]
 [0.7809368  0.52694696]
 [0.28596324 0.03446635]]
2
(3, 2)
[0.32211391 0.83252519 0.7809368  0.52694696 0.28596324 0.03446635]

​