numpy实例【还可以在线读取并显示图片】

可以查看原链接看更详细的输出

import numpy as np

# # 创建一维数组（0-9）
# arr = np.arange(10)
# # 创建一维数组（都是1）
# arr = np.repeat(1, 10)
# # 创建一维数组（输出：[1 1 1 2 2 2 3 3 3]）
# out_arr = np.repeat(np.array([1, 2, 3]), 3)
# # 创建一维数组（输出：[1 2 3 1 2 3 1 2 3]）
# out_arr = np.tile(np.array([1, 2, 3]), 3)
# # 创建一个布尔数组
# arr = np.full((3, 3), True, dtype=bool)
# # 创建一个布尔数组
# arr = np.ones((3, 3), dtype=bool)
# 生成自定义序列而不进行硬编码的数组
# a = np.array([1,2,3])
# arr = np.r_[np.repeat(a, 3), np.tile(a, 3)]
# # 创建一个时间数组
# arr = np.arange(np.datetime64('2018-02-01'), np.datetime64('2018-02-25'), 2)


# # 创建一个包含1到50之间的随机浮点数的2D数组
# arr = np.random.uniform(1, 50, 20)  # 20和数值
# # 创建一个包含5到10之间的随机浮点数的2D数组
# arr = np.random.uniform(5, 10, size=(5, 3))  # 5行3列
# print(arr.ravel())# 将二维变成一维
# arr = np.random.randint(low=5, high=10, size=(5,3)) + np.random.random((5,3))
# # 通过抑制科学计数法（如1e10）来漂亮地打印一个numpy数组
# np.random.seed(100)  # 保持数值统一(数值多或者浮点数)
# np.set_printoptions(suppress=True, precision=6)  # 抑制科学计数法，仅打印6个小数位
# arr = np.random.random([3, 3]) / 1e3


# # 将多个一维数组转换为一维数组
# arr1 = np.arange(3)
# arr2 = np.arange(3, 7)
# arr3 = np.arange(7, 10)
# out_arr = np.hstack([arr1, arr2, arr3])
# out_arr = np.concatenate([arr1, arr2, arr3], axis=0)
# array_of_arrays = np.array([arr1, arr2, arr3])
# out_arr = np.hstack(array_of_arrays)
# out_arr = np.concatenate(array_of_arrays, axis=0)


# # 将对数组进行排序的索引
# a = np.array([3, 1, 4])
# out_arr = np.argsort(out_arr)  # 左边比右边大的话，0在右边
# # 将所有奇数替换arr为-1（操作原始数组）
# arr[arr % 2 == 1] = -1
# # 将所有奇数替换arr为-1（新的数组）
# out_arr = np.where(arr % 2 == 1, -1, arr)
# # 将一维数组转换为具有两行的二维数组
# new_arr = arr.reshape(2, -1)
# # 堆叠数组a和b垂直
# out_arr = np.concatenate([a, b], axis=0)
# out_arr = np.vstack([a, b])
# out_arr = np.r_[a, b]  # 扩展：自定义序列而不进行硬编码
# # 堆叠阵列a并b水平
# out_arr = np.concatenate([a, b], axis=1)
# out_arr = np.hstack([a, b])
# out_arr = np.c_[a, b]
# # 获取两个python numpy数组之间的公共项
# out_arr = np.intersect1d(np.repeat(1, 10), np.arange(10))
# # 从一个数组中删除另一个数组中存在的那些项
# out_arr = np.setdiff1d(np.arange(1, 6), np.arange(5, 10))
# # 获得两个数组的元素匹配的位置
# a = np.arange(1, 6)
# b = np.arange(5, 10)
# out_arr = np.where(a == b)  # 不能一行式
# # 提取给定范围内的所有数字
# a = np.arange(15)
# out_arr = a[(a >= 5) & (a <= 10)]
# 获取两个数组中，对比相同下标的值，取出最大的值，合成一个新的数组
# def maxx(x, y):
#     """获取两个数值中最大的"""
#     if x >= y:
#         return x
#     else:
#         return y
# pair_max = np.vectorize(maxx, otypes=[float])
# a = np.array([5, 7, 9, 8, 6, 4, 5])
# b = np.array([6, 3, 4, 8, 9, 7, 1])
# out_arr = pair_max(a, b)
# # 交换两列的数值
# arr = np.arange(9).reshape(3, 3)  # 创建二维数组
# out_arr = arr[:, [1, 0, 2]]  # 切换二维数组的下标
# # 交换两行的数值
# arr = np.arange(9).reshape(3, 3)
# out_arr = arr[[1, 0, 2], :]
# # 反转2D数组的行
# arr = np.arange(9).reshape(3, 3)
# out_arr = arr[::-1, :]
# # 反转2D数组的列
# arr = np.arange(9).reshape(3, 3)
# out_arr = arr[:, ::-1]
# # 在python numpy数组中仅打印3个小数位
# np.set_printoptions(precision=3)
# arr = np.random.random((5, 3))
# out_arr = arr[:4]
# # 限制numpy数组输出中打印的项目数
# np.set_printoptions(threshold=6)
# np.set_printoptions(threshold=np.nan)  # 解除打印限制
# arr = np.arange(15)
# # 从一维数组中删除所有缺少的值
# a = np.array([1, 2, 3, np.nan, 5, 6, 7, np.nan])
# out_arr = a[~np.isnan(a)]
# # 计算两个数组之间的欧式距离
# a = np.array([1, 2, 3, 4, 5])
# b = np.array([4, 5, 6, 7, 8])
# out_arr = np.linalg.norm(a - b)


# # 找到一维数组中的所有局部最大值（或峰值）
# a = np.array([1, 3, 7, 1, 2, 6, 0, 1])
# doublediff = np.diff(np.sign(np.diff(a)))
# out_arr = np.where(doublediff == -2)[0] + 1


# # 将大于给定值的所有值替换为给定截止值
# np.set_printoptions(precision=2)
# np.random.seed(100)
# a = np.random.uniform(1, 50, 20)
# out_arr = np.clip(a, a_min=10, a_max=30)


# 获取给定数组中前5个最大值的位置a
# np.set_printoptions(precision=2)
# np.random.seed(100)
# a = np.random.uniform(1, 50, 20)
# print(a[a.argsort()][-5:]) # argsort：返回值大小的索引值
# print(np.sort(a)[-5:])


# 导入带有数字和文本的数据集，以使python numpy中的文本保持完整
# url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'
# 读取数据--------------------------------------------------------------------
# iris = np.genfromtxt(url, delimiter=',', dtype='object')
# print(iris.shape)  # (150, 5) 150行，5列
# out_arr = iris[:3]  # 获取前三行
# out_arr = np.array([row[4] for row in iris])[:3]  # 获取前三行的第4+1列数据
# 在numpy数组中查找唯一值的计数
# species = np.array([row.tolist()[4] for row in iris])
# out_arr = np.unique(species, return_counts=True)
# # 当被另一个数组分组时，如何获得数组的第二大值
# petal_len_setosa = iris[iris[:, 4] == b'Iris-setosa', [2]].astype('float')
# out_arr = np.unique(np.sort(petal_len_setosa))[-2]
# # 按列对二维数组排序
# out_arr = iris[iris[:, 0].argsort()][:20] # argsort：返回值大小的索引值
# # 在numpy数组中查找最频繁的值
# vals, counts = np.unique(iris[:, 2], return_counts=True)
# out_arr = vals[np.argmax(counts)]
# # 找到第一次出现的值大于给定值的位置
# out_arr = np.argwhere(iris[:, 3].astype(float) > 1.0)[0]
# 按usecols读取数据，自定义类型-------------------------------------------------
# iris = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0])
# out_arr = iris[:4]  # 读取前四行的第一列
# mu, med, sd = np.mean(out_arr), np.median(out_arr), np.std(out_arr)
# print(mu, med, sd)  # 平均值，中位数和标准偏差
# out_arr = np.percentile(iris, q=[5, 95])  # 找到一个numpy数组的百分位数
# -----------------------------------------------------------------------------
# iris = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0, 1, 2, 3])
# out_arr = iris[:4]  # 读取前四行的第一道第四列
# # 在数组的随机位置插入值
# np.random.seed(100)
# iris[np.random.randint(150, size=20), np.random.randint(4, size=20)] = np.nan
# print(iris[:10])
# # 在numpy数组中查找缺失值的数量和位置(查找nan)
# print("缺失值数: \n", np.isnan(iris[:, 0]).sum())
# print("缺失值的位置: \n", np.where(np.isnan(iris[:, 0])))
# # 根据两个或多个条件过滤一个numpy数组
# out_arr = iris[(iris[:, 2] > 1.5) & (iris[:, 0] < 5.0)]
# # 从numpy数组中删除包含缺失值的行
# index = np.array([~np.any(np.isnan(row)) for row in iris])
# out_arr = iris[index][:10]
# out_arr = iris[np.sum(np.isnan(iris), axis=1) == 0][:10]
# # 找到一个numpy数组的两列之间的相关性
# out_arr = np.corrcoef(iris[:, 0], iris[:, 2])[0, 1]
# out_arr = np.isnan(iris).any()
# print("是否具有空值：", out_arr)
# # 在numpy数组中将所有缺失值替换为0
# index = np.isnan(iris)  # 返回True,False
# iris[index] = 0  # 通过真假识别是否为空，等于True就把值换成0


# 创建6个1到4的随机数，在一个0矩阵显示1(以随机数为下标)
# np.random.seed(101)
# arr = np.random.randint(1, 4, size=6)
# def one_hot_encodings(arr):
#     uniqs = np.unique(arr)  # [1 2 3]
#     out = np.zeros((arr.shape[0], uniqs.shape[0]))  # 6行3列
#     for i, k in enumerate(arr):
#         out[i, k - 1] = 1  # 填充数值
#     return out
# out_arr = one_hot_encodings(arr)


# # 计算每行的比例（最小值/最大值）
# np.random.seed(10)
# a = np.random.randint(1, 10, [5, 3])
# min_arr = np.amin(a, axis=1)
# print(min_arr)  # 每行中找出最小值
# max_arr = np.amax(a, axis=1)
# print(max_arr)  # 每行中找出最大值
# out_arr = np.apply_along_axis(lambda x: np.min(x) / np.max(x), arr=a, axis=1)
# print(out_arr)  # 计算每行的比例（最小值/最大值）


# # 在numpy数组中查找重复记录,第一次出现为True
# np.random.seed(100)
# a = np.random.randint(0, 5, 10)  # 创建10个0到5的数值组成一维数组
# out_arr = np.full(a.shape[0], True)  # 创建10个True值型一维数组
# unique_positions = np.unique(a, return_index=True)[1]  # 返回数值第一次出现的下标
# out_arr[unique_positions] = False
# print(out_arr)

# # 显示在线图片
# from io import BytesIO
# from PIL import Image
# import PIL
# import requests
# URL = 'https://upload.wikimedia.org/wikipedia/commons/8/8b/Denali_Mt_McKinley.jpg'
# response = requests.get(URL)
# I = Image.open(BytesIO(response.content))
# I = I.resize([150, 150])
# arr = np.asarray(I)
# im = PIL.Image.fromarray(np.uint8(arr))
# Image.Image.show(im)


# # 从2d数组中减去1d数组，其中1d数组的每一项都从相应的行中减去
# arr_01 = np.array([[3, 3, 3], [4, 4, 4], [5, 5, 5]])
# arr_02 = np.array([1, 2, 3])
# print(np.vstack(arr_02))  # 一维变二维
# print(arr_02[:, None])  # 同上
# print(arr_01 - arr_02[:, None])


# # 找到数组中第n个重复项的索引
# x = np.array([1, 2, 1, 1, 3, 4, 3, 1, 1, 2, 1, 1, 2])
# n = 5
# out_arr = [i for i, v in enumerate(x) if v == 1][n - 1]
# out_arr = np.where(x == 1)[0][n - 1]


# # 将numpy的datetime64对象转换为datetime的datetime对象
# from datetime import datetime
# dt64 = np.datetime64('2018-02-25 22:10:10')
# print(type(dt64))  # <class 'numpy.datetime64'>
# out_arr = dt64.tolist()
# print(type(out_arr))  # <class 'datetime.datetime'>
# out_arr = dt64.astype(datetime)
# print(type(out_arr))  # <class 'datetime.datetime'>

# # 仅给出起点，长度和步长来创建一个numpy数组序列
# start, step, length = 5, 3, 10  # 创建一个长度为10，从5开始，步长为3的数组
# end = start + (step * length)
# out_arr = np.arange(start, end, step)

# # 从给定的一维数组创建步幅
# def gen_strides(arr, stride_len=5, window_len=5):
#     # ((15-4)//2)+1=6
#     n_strides = ((arr.size - window_len) // stride_len) + 1
#     # np.range(0,6*4,2)
#     datas = np.arange(0, n_strides * stride_len, stride_len)
#     print(datas)
#     result = [arr[s:(s + window_len)] for s in datas]
#     print(result)
#     return np.array(result)


# out_arr = gen_strides(np.arange(15), stride_len=2, window_len=4)