安装numpy

pip install numpy

numpy的ndarray对象

ndarray 和 list 效率比较

import numpy as np
import time
import random

a = []
for i in range(100000000):
    a.append(random.random())
t1 = time.time()
sum1 = sum(a)
t2 = time.time()

b = np.array(a)
t4 = time.time()
sum2 = np.sum(b)
t5 = time.time()
print("list处理一个亿的速度为：  " + str(t2 - t1))
print("numpy处理一个亿的速度为：  " + str(t5 - t4))

注：numpy的大部分代码都是C语言写的，底层算法设计有优异的性能

创建一/二维数组

import numpy as np

# 创建一维数组
print("方式一------------np.array(list)----------------------")
list = [1, 2, 3]
oneArray = np.array(list)
print(type(oneArray))
print(oneArray)  # [1 2 3]   注意和列表的区别  没有 ,

print("方式二------------np.array([4, 5, 6])----------------------")
oneArray1 = np.array([4, 5, 6])
print(type(oneArray1))
print(oneArray1)

print("方式三---------------np.array(range(10))-------------------")
oneArray2 = np.array(range(10))
print(type(oneArray2))
print(oneArray2)

print("方式四---------------np.arange()-------------------")
oneArray3 = np.arange(0,10,2)
print(type(oneArray3))
print(oneArray3)

# 创建二维数组
print("二维数组--------------------------------------------")
arr = [[1,2,3],[4,5,6],[7,8,9]]
twoArray = np.array(arr)
print(type(twoArray))
print(twoArray)

ndarray的常用属性

import numpy as np

# 看ndarray的各种属性
list1 = [[1, 2], [3, 4], [5, 6], [7, 8]]

twoArray = np.array(list1)
print(twoArray)

# 获取数组的维度（注意  和函数的参数很像）
print("维度--------------------- ndim ------------------------------------ ")
print(twoArray.ndim)

# 形状（行，列）
print("形状--------------------- shape ------------------------------------ ")
print(twoArray.shape)

# 有多少元素
print("元素个数--------------------- size ------------------------------------ ")
print(twoArray.size)

调整数组形状

import numpy as np

four = np.array([[1, 2, 3], [4, 5, 6]])

four1 = four  # 直接 = 相当于引用的同一个对象(id)
print(id(four))
print(id(four1))
print(four)
print("---" * 20)

four3 = four.copy() # ndarray.copy()  id不同  不是一个对象
print(id(four))
print(id(four3))
print("---" * 20)

# shape  直接改变 four 和 four1 的形状
four.shape = (3, 2)
print(four)
print(four1)
print("---" * 20)

# reshape 直接返回一个新数组
four2 = four1.reshape(2, 3)
print(four1)  # reshape four1 和 four 不变
print(four2)
print("---" * 20)

# 将多维数组变成一维数组  flatten(order='F/C')
# 'C' 按行展开      'F' 按列展开    默认是 'C'
five = four.reshape((6,), order='C')
print("按行展开为："+ str(five))
six = four.flatten(order='F')
print("按列展开为：" + str(six))

ndarray转list

import numpy as np

# 将ndarray数组转换成python列表
a = np.array([1, 2, 3, 4])
print(a)
print(type(a))
# tolist 快速转换成python列表
list_a = a.tolist()
print(list_a)
print(type(list_a))

numpy的数据类型

import numpy as np
import random

# dtype 可以减少内存的使用  提高运算效率
# np.int8 - np.int64
f = np.array([1, 2, 3, 4, 5], dtype=np.int16)
print(f.itemsize)  # 占多少字节
print(f.dtype)  # 获取数据类型

# 调整数据类型 astype
print("-------调整数据类型 astype ------------")
f1 = f.astype(np.int32)
print(f1.itemsize)
print(f1.dtype)

print('-' * 50)

# 小数
# float32 精度 6-7位    float64 精度 15-16位
print(round(random.random(), 2))  # round(xxx,y) 保留y位小数
arr = np.array([random.random() for i in range(10)])
print(arr)
print(arr.itemsize)
print(arr.dtype)

print("-------调整数据类型 astype ------------")
arr1 = arr.astype(np.float32)
print(arr1)
print(arr1.itemsize)
print(arr1.dtype)

# 取小数点后两位
print("------数组的所有元素都取小数点后两位 np.round(ndarray,2)---------")
print(np.round(arr, 2))

数组的运算

数组和数的计算

import numpy as np

# 数组（ndarray）   的加减乘除
t = np.arange(24).reshape((6, 4))
print(t)
print("*" * 20)
t1 = t.tolist()
print(t + 2)
print(type(t1))
# print(t1+2)   # python列表不能 加减乘除
print("*" * 20)
print(t * 2)
print("*" * 20)
print(t // 2)  # 整除 //

数组和数组的计算

import numpy as np

# 维度相同的两个数组可以计算
arr1 = np.arange(12).reshape(3, 4)
arr2 = np.arange(12).reshape(3, 4)
print(arr1 + arr2)
print("--" * 30)

# 维度 必须有一个相同且（另一个是0或者1才行） 才能 加减乘除
t1 = np.arange(24).reshape(4, 6)
t2 = np.arange(6).reshape(1, 6)
# t4 = np.arange(6).reshape(6)
# t3 = np.arange(18).reshape(3,6)   不能和 t1运算  只能和t2运算

print(t1 + t2)
# print(t1+t4)   和 t1+t2 相同

数组的轴

import numpy as np

# arange(a,b) 左闭右开
# axis轴   按哪个轴相加  最后的结果shape是去掉该轴剩余的情况
t = np.arange(1, 19).reshape((3, 2, 3))  # 18 = 3 * 2 * 3
print(t)
print("*" * 20)
a = np.sum(t, axis=0)
print(a)
print(a.shape)  # (2, 3)
print("*" * 20)
b = np.sum(t, axis=1)
print(b)
print(b.shape)  # (3, 3)
print("*" * 20)
c = np.sum(t, axis=2)
print(c)
print(c.shape)  # (3, 2)

数组的索引和切片

import numpy as np

t = np.arange(24).reshape(4, 6)
print(t)
# 注意t[a:b] a能取到 b取不到
print("*" * 20)
print(t[1])  # 取一行
print("*" * 20)
print(t[1:])  # 取连续的多行
print("*" * 20)
print(t[1:3])  # 取连续多行
# print(t[1:3,:]) # 取连续多行   和上面那句效果一样
print("*" * 20)
print(t[[0, 2, 3]])  # 取不连续的多行  注意两个[[]]
# print(t[[0, 2, 3], :])  # 取不连续的多行  注意两个[[],:]    和上面那句效果一样
print("-" * 60)
print(t[:, 1])  # 取一列
print("*" * 20)
print(t[:, 1:])  # 取连续多列
print("*" * 20)
print(t[:, [0, 2, 4]])  # 取不连续多列
print("-" * 60)
print(t[2, 3])  # 取某行某列的值   注意python列表写法 py[2][3]
print("*" * 20)
print(t[[0, 1, 2], [1, 2, 4]])  # 取多个不连续的值 (0,1)(1,2)(2,4)位置的值

数组的与或非和三目运算符

import numpy as np

t = np.arange(24).reshape(4, 6)
print(t)
t1 = t.copy()
t2 = t.copy()
t3 = t.copy()
t[t < 10] = 0  # 把小于10的值改掉
print(t)
print("*" * 20)
t1[(t1 > 2) & (t1 < 6)] = 0  # 与  两个都满足
print(t1)
t2[(t2 < 2) | (t2 > 6)] = 0  # 或  满足一个就行
print(t2)
t3[~(t3 > 6)] = 0  # 非
print(t3)
print("---" * 20)

# 三目运算符
# np.where(condition, x, y)  满足条件（condition）输出x，不满足条件输出y
score = np.array([[80, 88], [82, 81], [75, 81]])
result = np.where(score > 80, True, False)
print(result)

numpy的插入、删除、去重

插入

import numpy as np

# append 在数组末尾添加数据
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
# 当axis轴无定义时，默认为None  返回值是一个一维数组
print(np.append(a, [7, 8, 9]))
print("--" * 20)
# 延轴0添加元素 [[]]
print(np.append(a, [[7, 8, 9]], axis=0))
print("--" * 20)
# 延轴1添加元素  [[]]
print(np.append(a, [[10, 11], [13, 14]], axis=1))
print("----------  下面是insert -------------------------")

# insert 在插入 位置之前  （位置都是从0开始）
b = np.array([[1, 2], [3, 4], [5, 6]])
print(b)
print("未传递axis参数，在插入 位置之前（从左到右数）  输入数组会被展开")
print(np.insert(b, 3, [11, 12]))  # [ 1  2  3 11 12  4  5  6]
print("传递了axis参数，会广播 值数组 来配 输入数组")
print("延轴0广播")
print(np.insert(b, 2, [11, 12], axis=0))
print("延轴1广播")
print(np.insert(b, 1, [4], axis=1))

删除

import numpy as np

# 数组中的删除
a = np.arange(12).reshape(3, 4)
print(a)
b = a.copy()
c = a.copy()
print("未传递axis参数，在删除之前输入数组会被展开")
print(np.delete(a, 5))
print("删除每一行中的第二列")
print(np.delete(b, 1, axis=1))
print("删除第三行（下标为2）")
print(np.delete(c, 2, axis=0))

去重

import numpy as np

# 数组去重 unique
a = np.array([2, 3, 4, 1, 2, 5, 6, 7])
print(a)
print("第一个数组的去重值：")
b = np.unique(a)
print(b)
print("---" * 20)
# return_index  返回 新列表在 旧列表中的位置（下标）
c, indices = np.unique(a, return_index=True)
print(c, indices)
print("---" * 20)
# return_inverse  返回 旧列表元素在 新列表中的位置（下标）
d, indices = np.unique(a, return_inverse=True)
print(d, indices)
print("---" * 20)
# return_counts  返回去重数组中的元素在原数组中出现次数
e, indices = np.unique(a, return_counts=True)
print(e, indices)

numpy的运算公式

import numpy as np

score = np.array([[80, 88], [12, 81], [75, 80]])
print(score)
print(np.max(score))
print(np.max(score, axis=0))  #  [82 88]
print(np.max(score, axis=1))  #  [88 82 81]
# np.min 最小值类似最大值
print("---" * 20)
# 第一个参数和第二个参数比  返回大的 注：会把原先的列表值改变
print(np.maximum([-2, -1, 0, 1, 2], 0))
# 第一个参数和第二个参数比  返回小的 注：会把原先的列表值改变
print(np.minimum([-2, -1, 0, 1, 2], 0))
# 第一个参数和第二个参数比  返回大的 注：会把原先的列表值改变
print(np.maximum([-2, -1, 0, 1, 2], [1, 2, 0, -1, -2]))
print("---" * 20)

# 求平均值  np.mean
print(np.mean(score))
print("---" * 20)

# 求前缀和
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.cumsum(0))  # 0轴  从上往下加
print(arr.cumsum(1))  # 1轴  从左往右加
print("---" * 20)

# 求最小值索引
print(np.argmin(score, axis=0))  # [1 2]
print(np.min(score, axis=0))  # [12 80]
print("---" * 20)

# 标准差
print(np.std(score, axis=0))

# 极值
print(np.ptp(score, axis=None))

注: 求前缀和

数组的拼接和分割

拼接

import numpy as np

# np.stack() 增加维数

# 数组的拼接
a = np.array([[1, 2], [3, 4]])
b = np.array([[7, 8], [11, 12]])
# 延0轴[[7, 8]] 就行   延1轴[[7, 8], [11, 12]] 才行
print(np.concatenate((a, b), axis=0))
print(np.concatenate((a, b), axis=1))
print("---" * 20)

# 根据轴进行堆叠
print(np.stack((a, b), axis=0))
print(np.stack((a, b), axis=0).shape)

print(np.stack((a, b), axis=1))
print(np.stack((a, b), axis=1).shape)
print("---" * 20)

# 矩阵垂直拼接
v1 = [[0, 1, 2], [3, 4, 5]]
v2 = [[10, 11, 12], [13, 14, 15]]
print("矩阵垂直拼接为：")
print(np.vstack((v1, v2)))
print("矩阵水平拼接为：")
print(np.hstack((v1, v2)))

分割

import numpy as np

# 数组的分割
arr = np.arange(9).reshape(3, 3)
print(arr)
print("将数组分成三个大小相等的子数组")
print(np.split(arr, 3))

# 水平分割数组
print(np.hsplit(arr, 3))

# 垂直分割数组
print(np.vsplit(arr, 3))

数组中的nan和inf

import numpy as np

# inf  正数除以0    -inf  负数除以零   都是无穷大
# nan  -->  not a number
# 注意：  只有float才有 nan和inf
a = np.nan
b = np.inf
print(a, type(a))
print(b, type(b))

t = np.arange(24, dtype=float).reshape(4, 6)
print(t)
t[3, 4] = np.nan
t[2, 4] = np.nan
print(t)
print("--" * 20)
# nan 不相等
print(np.nan == np.nan)  # False
print(np.nan != np.nan)  # True

# inf相等
print(np.inf == np.inf)  # True
print(-np.inf == np.inf)  # False
print(-np.inf == -np.inf)  # True
print(np.inf != np.inf)  # False
print("--" * 20)
print(np.count_nonzero(t))  # 判断非0个数  nan也是非0
print(t != t)
print(np.count_nonzero(t != t))  # 判断nan的个数  因为只有 nan!=nan 为非0 True
# 将nan替换为0
# t[np.isnan(t)] = 0
# # t[t!=t] = 0   # 只有为 True 才进行替换
# print(t)
print("---" * 20)
# 将 nan 替换为这一列的平均值
for i in range(t.shape[1]):
    temp_col = t[:, i]  # 获取当前列数据
    # 判断当前列是否有nan
    nan_num = np.count_nonzero(temp_col != temp_col)
    if nan_num:  # 条件成立说明nan_num不为0
        # 获取不为nan的所有值并且存在一个列表里
        temp_col_not_nan = temp_col[temp_col == temp_col]
        # 将nan替换为这一列的平均值 np.mean
        temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)
        # temp_col[temp_col != temp_col] = np.mean(temp_col_not_nan)
print(t)

数组转置

import numpy as np

# 转置和轴滚动
a = np.arange(12).reshape(3, 4)
print(a)
print("np.transpose(ndarrary)  转置后为：")
print(np.transpose(a))
print("***" * 20)
b = np.arange(12).reshape(3, 4)
print(b)
print("ndarrary.T  转置后为：")
print(b.T)

轴交换和轴滚动

轴交换

t1 = np.arange(24).reshape((2, 3, 4))
print(t1.shape)
print(t1)
print("交换0轴和2轴")
t1 = np.swapaxes(t1, 0, 2)
print(t1.shape)
print(t1)

轴滚动

# 轴滚动
# rollaxis(ndarrary, b, start=a)  轴b的位置 必须大于 轴a的位置
# 相当于 b 往 a 的位置滚动
a = np.ones((3, 4, 5, 6))  # ones 都填充为 float的 1.
print(np.rollaxis(a, 2, start=0).shape)  # (5, 3, 4, 6)
print(np.rollaxis(a, 2, start=1).shape)  # (3, 5, 4, 6)
# print(np.rollaxis(a, 1, start=2).shape)  # (3, 4, 5, 6)  轴的大小不对 不滚动

读取csv数据

import numpy as np

# numpy 读取数据
us_file_path = "./archive/GBvideos.csv"

# delimiter 分隔符 默认为 空格   unpack 默认为False   文件里不能有任何字符串
t2 = np.loadtxt(us_file_path, delimiter=",", skiprows=True, encoding="utf8")
print(t2)
print(t2.shape)