numpy学习笔记

学了一下数据分析中的numpy，这是一下笔记

'''import numpy as np
import matplotlib.pyplot as plt'''


'''data = [1, 2, 3, 4, 5]
ndarray_data = np.array(data)           #生成一个数组，这是一个ndarray对象
print(ndarray_data)
print(ndarray_data.dtype)           #dtype类型用来表示数组的数据类型
print(ndarray_data.shape)           #shape用来表示每一维度的数组的数量
'''
'''
data_2 = [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0]]
ndarray_data_2 = np.array(data_2)           #将其转换成排列时默认转换成为三行四列的多维数组
print(ndarray_data_2)
print(ndarray_data_2.dtype)
print(ndarray_data_2.shape)         #第一维度，就是外面的三个列表，有三个，第二维度，就是列表里面的数，每个列表里有四个数，第二维度的数量就是四
print(ndarray_data_2.ndim)
#ndim表示这个数组是几维的，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维，这里是一个三行四列的二维数组
'''
'''
data_3 = np.arange(0, 10)           #numpy中的arange相当于Python中的range一样，其可以创建数组类型的数据，返回一个数组
print(data_3)
print(data_3.dtype)
print(data_3.shape)
'''
'''num = np.random.randn(10)           #numpy.random.randn()随机生成数组，输入第一个数字意味着第一维的数量，第二个是第二维的数量，不输入则返回一个浮点数
#numpy.random.randn()从均值为0，方差为1的数据中抽取样本
print(num)
print(num.dtype)
'''
'''data_4 = [1.1, 2.2, 3.3, 4.4]
ndarray_4 = np.array(data_4)
print(ndarray_4)
print(ndarray_4.dtype)          #浮点型数组
int_num_4 = ndarray_4.astype(np.int32)          #通过astype将数组的类型转换
print(int_num_4)
print(int_num_4.dtype)          #整形数组
'''

'''data_5 = [1, 2, 3, 4, 13]
ndarray_5 = np.array(data_5)
print(ndarray_5 ** 2)           #这里将数组中的每一个成员都平方
ndarray_6 = np.arange(6, 11)
print(ndarray_5 + ndarray_6)       #将两个数组里的数对应相加
print(ndarray_5 > ndarray_6)        #将两个数组进行比较，会对两个数组对应的数进行比较，每个位置返回一个布尔类型的结果
data_5[1:3] = 20, 6       #对数组的切片进行操作时会改变原数组，切片是原数组的视图，对视图的修改会映射到原数组中，切片后面的那个数值是取不到的
print(data_5)'''

'''name = ['张三', '李四', '王五', '张三', '李四', '王五']
ndarray_name = np.array(name)
point = [[100, 100, 100], [90, 90, 90], [95, 95, 95], [85, 85, 85], [60, 60, 60], [77, 77, 77]]
ndarray_point = np.array(point)
# print(ndarray_name == '张三')         #通过这个可以返回一个布尔数组，判断每个元素是否与所给的值相等
# zhangsan_point = ndarray_point[ndarray_name == '张三']        #通过这个可以寻找到姓名为张三的位置上的point数组
# print(zhangsan_point)
# print(zhangsan_point.shape)
# print(zhangsan_point[0])            #通过这个寻找二维数中的第一个数组，这里返回的是一个一维数组
# print(zhangsan_point[0].shape)
# names = (ndarray_name == '李四') | (ndarray_name == '王五')         #通过这种方法可以生成一个判断这两个人的数组
# #Python中的关键字and和or对布尔类型的数组并没有用，所以这里用&或|
# print(names)
# print(ndarray_point[names])
ndarray_point[ndarray_name == '张三'] = 0         #可以通过这种方式来修改数组的值
print(ndarray_point)
ndarray_point[ndarray_name == '张三'] = [1, 1, 1], [0, 1, 0]
print(ndarray_point)'''
#神奇索引
'''num = [[x+i for x in range(4)] for i in range(5)]
ndarray_num = np.array(num)
print(ndarray_num)
print(ndarray_num[[2, 3]])      #通过传递一个列表可以访问第三四行的内容，将会打印一个包含完整列表三四列的二维数组
print(ndarray_num[[-1, -2]])    #可以从后面开始访问，这里将返回最后一行和倒数第二行的一个二维数组
print(ndarray_num[[2, 3], [1, 2]])          #传递两个列表会进行对应访问，这里访问的是索引为[2][1]和[3][2]的值，返回一个一维数组
'''
#数组的转置
'''num = [[i + x**2 for i in range(5)] for x in range(4)]
ndarray_num = np.array(num)
print(ndarray_num)
print(ndarray_num.T)            #通过数组名.T对数组进行转置
'''
#通用函数
'''num = [x for x in range(10)]
ndarray_num = np.array(num)
print(ndarray_num)
num_2 = np.sqrt(ndarray_num)        #numpy.sqrt()函数用于计算数组里面的平方根，返回一个浮点型的数组（一元通用函数）
print(num_2)
print(num_2.dtype)'''
'''num_1 = [x for x in range(0, 5)]
num_2 = [y for y in range(5, 10)]
ndarray_1 = np.array(num_1)
ndarray_2 = np.array(num_2)
print(ndarray_1)
print(ndarray_2)
add = np.add(ndarray_1, ndarray_2)          #处理两个数组相加（二元通用函数）
print(add)
print(add.dtype)'''
#数组的向量化
'''num_1 = [1, 2, 3, 4, 5]
num_2 = [0, 1]
array_1 = np.array(num_1)
array_2 = np.array(num_2)
print(array_1)
print(array_2)
array_x, array_y = np.meshgrid(array_1, array_2)            #这个方法返回一个坐标矩阵（网格点），将所给的x和y一一对应，返回x和y
print(array_x)
print(array_x.shape)
print(array_y)
print(array_y.shape)
fig, ax = plt.subplots()
ax.scatter(array_x, array_y)
ax.set_title('num', fontsize=15)
ax.set_xlabel('x', fontsize=10)
ax.set_ylabel('y', fontsize=10)
ax.grid(True)           #让matplotlib将画面的网格绘画出来

plt.show()
'''
#数组操作之条件逻辑
'''num_1 = np.array([1, 3, 5, 7, 9])
num_2 = np.array([2, 4, 6, 8, 10])
choice = np.array([True, True, False, True, False])
num_3 = [(num_1 if choice else num_2) for num_1, num_2, choice in zip(num_1, num_2, choice)]    #如果choice为真就取num_1,否则取num_2
print(num_3)
#在numpy中可以使用numpy.where()来实现这个功能，在算速和多维数组上都有提升
num_4 = np.where(choice, num_1, num_2)
print(num_4)
print(num_4.dtype)
#在numpy.where()中，第二第三个参数可以不是数组，因为where()是根据第一个数组来产生所要的数组
num_5 = np.where(choice, 1, -1)     #如果是真则为1，如果是假则为-1
print(num_5)
print(num_5.dtype)
'''
#数组和统计方法
'''num = np.random.randn(4, 5)     #随机生成一个shape为（0，5）的数组
print(num)
add = 0
add_line = 0
number = 0
add_3 = []
for nums in num:
    for n in nums:
        add += n
        number += 1
print(f"mean:{add / number}")
add_2 = np.mean(num)            #numpy.mean()用于计算数组的平均值，可以接收一个参数axis，用于降维
print(f"mean:{add_2}")
for nums in num:
    add_line = 0
    for n in nums:
        add_line += n
    add_3.append(add_line / len(nums))
print(f"all kind of line mean:{add_3}")
num_4 = np.mean(num, axis=1)            #接收参数axis=1让其算出每一行的平均值
print(num_4)
num = np.array([1, 2, 3, 4, 5])
num_r1 = np.cumsum(num)         #计算累加，每一次结果都返回，形成的是一个数组返回的是一个ndarray
print(num_r1)
print(num_r1.dtype)
num_r2 = np.sum(num)        #计算最后累加的结果
print(num_r2)
'''
#布尔类型数组
'''num_1 = np.random.randn(50)
n = 0
for number in num_1:
    if number > 0:
        n += 1
print(n)
num_2 = np.array([(True if num > 0 else False) for num in num_1])       #由于True的值为1，False的值为0，所以可以用统计这个的和的方式来计算数组里到底有多少个大于0的值
print(np.sum(num_2))
print((num_1 > 0).sum())        #这个的作用也是计算有多少个大于0的数值
print((num_1 > 0).any())        #.any()判断数组里是否至少有一个True
print((num_1 > 0).all())        #.all()判断数组里是否全部是True
'''
#数组的排序和其他集合逻辑
'''num_1 = np.random.randn(20)
print(num_1)
num_1.sort()            #sort给数组进行排序，sort没有返回值，直接对数组进行操作
print(num_1)
num_2 = np.array([1, 1, 4, 3, 7, 9, 10, 5, 3])
num_3 = np.unique(num_2)            #numpy.unique()寻找列表中的唯一值，并给他们排序
print(num_3)
'''
#使用数组对文件进行操作
'''num = np.array([x for x in range(10)])
np.save('number', num)          #将数组存于文件中
number = np.load('number.npy')          #从文件中读取数组
print(number)
'''
#行列式,矩阵的运算
'''num_1 = np.random.randn(3, 4)
num_2 = np.random.randn(4, 3)
print(f"{num_1} * {num_2} = ")
num = np.dot(num_1, num_2)          #numpy.dot()用于求两个矩阵的相乘
print(num)
'''
#随机数的生成
'''num_1 = np.random.randn(10)
num_2 = np.random.normal(size=(3, 4))           #使用normal来生成一个正态分布样本的数组
print(num_1)
print(num_2)
np.random.seed(2)           #numpy.random.seed()可以给随机生成器传递种子
num_3 = np.random.normal(size=(3, 4))
num = np.sum(num_3)
print(num)
#生成随机器
rng = np.random.RandomState(1234)           #通过这个生成一个随机器，输入的是随机器的种子
num = rng.randn(10)
print(num)
'''
#随机漫步
'''from random import randint


step = 100
num = 0
x = range(step)
y = [0]
for i in range(step - 1):
    dire = 1 if randint(-1, 1) >= 0 else -1
    num += dire
    y.append(num)
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title("run to everywhere", fontsize=20)
ax.set_xlabel("x", fontsize=15)
ax.set_ylabel("y", fontsize=15)

plt.show()
            #在random.randint()中，其随机值是包括两边的，在numpy.random.randint()中，其返回的随机值是不包括右端的
    #使用numpy实现随机漫步
step = 100
x = np.array([x for x in range(step)])
tem = np.random.randint(-1, 1, size=step)       #在[-1,1)里随机选取整数，走100次
tem_2 = np.where(tem == 0, 1, -1)           #因为结果只有-1和0，判断如果等于0就写为为1，如果为-1就写为-1
y = np.cumsum(tem_2)            #通过numpy.sumsum()进行逐步累加求得y轴的坐标

fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title("run", fontsize=20)
ax.set_xlabel("x", fontsize=15)
ax.set_ylabel("y", fontsize=15)

plt.show()
'''
#一次创建多组随机数据
    #要一次性生成50组30个的随机漫步
'''num = np.random.randint(0, 2, size=(50, 30))    #获取0或1
dire = np.where(num > 0, 1, -1)
y = np.cumsum(dire, axis=1)         #通过逐个累加来求得漫步后y的值，通过传参axis=1让其分别计算每一行的累加
print(y.max())      #求出漫步后的最大值
print(y.min())      #漫步后的最小值
max = []
min = []
for i in y:
    max.append(i.max())
    min.append(i.min())
print(len(max))
print(min)
'''