python之numpy的简单使用

import numpy as np


'''生成0-1之间符合条件的数组'''
#生成一个随机浮点数
a1 = np.random.rand()
# print(a1)
#生成一个二维数组
a2 = np.random.rand(3,4)
# print(a2)


'''查看数组的维度、大小、数据类型'''
# print('数组的维度：',a2.ndim)
# print('数组的大小：',a2.shape)
# print('数组的数据类型：',a2.dtype)


'''生成指定元素区间的数组，并且可以指定大小'''
#前两个参数代表数据的区间，第三个参数为数组大小shape
a3 = np.random.uniform(2,3,(2,5))
# print(a3)

#生成随机整型数组
a4 = np.random.randint(2,size=5)
# print(a4)
a5 = np.random.randint(2,size=(2,4))
# print(a5)


'''序列创建'''
a6 = np.array([2,4,5,3])
# print(a6)
a7 = np.array([[3,4],[7,2]],dtype='int32')
# print(a7)


'''创建全是0的额数组，但是shape必须指定，元组类型，如果是一个整型数字，代表是一个一维数组'''
#如果不指定类型，默认使用numpy.float64
a8 = np.zeros((4,4),dtype='int8')
# print(a8)
a9 = np.zeros((4,4))
# print(a9)

a10 = np.ones((4,4),dtype='int8')
# print(a10)
a11 = np.ones((4,4))
# print(a11)


'''按照范围，顺序生成'''
# arange  (start, stop, step,dtype)
# np.arange(1,100,10) ==  np.array(range(1,100,10))
a12 = np.arange(1,100,10)
# print(a12)
a13 = np.array(range(1,100,10))
# print(a13)


'''重新调整维度'''
'''方法一'''
a14 = np.zeros((3,4))
# print(a14)
a15 = a14.reshape((2,2,3))
# print(a15)
# print(a15.ndim)
# print(a15.shape)
a16 = a14.reshape((2,6))
# print(a16)
'''方法二'''
# print(a16.T)



'''打乱顺序'''
a17 = np.arange(1,100,10)
a18 = np.random.shuffle(a17)
# print(a17)
# print(a18)
#舒服之后，原来的数据做了打乱处理，慎重，在原有数组基础上


'''numpy的数据类型'''
'''
   名称	         描述
    bool_	布尔型数据类型（True 或者 False）
    int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
    intc	与 C 的 int 类型一样，一般是 int32 或 int 64
    intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
    int8	字节（-128 to 127）
    int16	整数（-32768 to 32767）
    int32	整数（-2147483648 to 2147483647）
    int64	整数（-9223372036854775808 to 9223372036854775807）
    uint8	无符号整数（0 to 255）
    uint16	无符号整数（0 to 65535）
    uint32	无符号整数（0 to 4294967295）
    uint64	无符号整数（0 to 18446744073709551615）
    float_	float64 类型的简写
    float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
    float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
    float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
    complex_	complex128 类型的简写，即 128 位复数
    complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
    complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

'''


'''astype更改数据类型，如果没有设置copy，返回值为一个新的数组'''
a19 = np.random.randint(1,12,(1,2),dtype='uint8')
# print(a19)
# print(a19.dtype)
a20 = a19.astype(np.float64)
# print(a20)
# print(a20.dtype)


'''数组运算'''
a21 = [[1,2,3,4],[1,2,3,4]]
a22 = [[5,2,3,4],[5,2,3,4]]
#列表相加
# print(a21+a22)
s1 = np.array(a21)
s2 = np.array(a22)
#数组乘以一个常数
s3 = s1*10
# print(s3)
#多维数组和多维数组相乘
# print(s1*s2)
#数组加法
# print(s1+s2)
'''    
    一维数组与一维数组：保证元素的个数必须相同
    多维数组与多维数组：注意形状，相同的维度大小和维度个数
    一维数组与多维数组：注意一维数组的形状问题
'''



'''一维数组的切片和索引'''
s4 = np.array([1,2,3])
# 索引类似列表，下标从0 开始
# print(s4[2])
#全部截取
# print(s4[:])
#从2位开始，截取到最后
# print(s4[1:])
#从开始截取到最后，步长为2
# print(s4[::2])



'''多维数组的切片和取值'''
s5 = np.array([[1,2,3],[4,5,6],[7,8,9]])
# print(s5)

#取单值
#按照列表思想取值
# print(s5[1][1])
#按照数组思维取值
# print(s5[1,1])

#取多值
#以，为界，前面的是列标，后面的是行标，注意，索引以0开始，并且类似左闭又开
# print(s5[0:2,1:3])
#截取所有一维数组的第2、3个
# print(s5[:,1:3])
#截取不连续的多行多列
# print(s5[::2,1:])


'''numpy 的计算函数'''
#向上取整数，并保持数据类型不改变
s6 = np.random.uniform(-5,10,(3,4))
s7 = np.ceil(s6)
# print(s6)
# print(s7)
#向下取整 np.floor()
#四舍五入 np.rint()
#平方   np.square()
#平方根  np.sqrt()



'''将数组分为两个部分，一个是小数部分，一个是整数部分'''
# print(s6)
# print(np.modf(s6)[0])
# print(np.modf(s6)[1])



'''判断是否为空值，判断每一个元素'''
s8 = np.isnan(s6)
# print(s8)


'''条件筛选'''
s9 = np.array([ 0, -1,  2, -1,  4,-1,  6, -1,  8, -1]).reshape((2,5))
# print(s9)
#where的用法：迭代判断数组的每一个元素是否符合条件判断，如果符合，返回该元素，不符合，则返回默认值
s10 = np.where((s9%2==0),s9,9)
# print(s10)



'''zip的用法'''
#2 zip(o1,o2)把对应位置上的两个对象压缩成一个元组
# 将数组转列表：s2.tolist（）
s11 = np.array([1,3,2,4,9,8,7,-1,-2,-2]).reshape((2,5))
# print(s11)
s12 = np.array([1,2,-7,8,9,4,7,-1,3,-2]).reshape((2,5))
# print(s12)

#where
s13 = np.where(s11>s12,s11,s12)
# print(s13)

#zip
s11_list = s11.reshape(10,).tolist()
# print(s11_list)
s12_list = s12.reshape(10,).tolist()
# print(s12_list)
list3 = [x if x>y else y for x,y in zip(s11_list,s12_list)]
# print(list3)
# print(np.array(list3).reshape((2,5)))



'''使用uniform，生成10,40之间的数组，组成（3,4）数组，找出所有四舍五入之后，大于20 ，并且小于30的数字，修改成50，其他数字不变，组成新的数组'''
#（1）
s17 = np.random.uniform(10,40,(3,4)).round()
# print(s17)
s14 = np.where((s17>20)&(s17<30),50,s17)
# print(s14)
#（2）
s15 = np.random.uniform(10,40,(3,4))
# print(s15)
s16 = np.where((np.rint(s15)>20)&(np.rint(s15)<30),50,np.rint(s15))
# print(s16)



'''numpy的常用函数'''
'''
#里面可以添加参数axis选择行列的数据
    求和： np.sum
    求平均：np.mean
    求最大值：np.max
    求最小值：np.min
    求方差：np.var
    求标准差: np.std
    求最大值的下标：np.argmax
'''



'''元素判断'''
s20 = np.array([1,2,-7,8,9,4,7,-1,3,-2]).reshape((2,5))
# print(s20)
#如果可迭代对象中有一个符合条件就输出True
# print(np.any(s20<5,axis=0))
#如果可迭代对象中全部符合条件就输出True
# print(np.all(s20<5,axis=0))



'''数组的操作'''
#    追加一个元素，会对多维数组进行降维操作
#     一维数组追加单个元素，列表或者数组，返回的也是一维数组
#     多维数组也是一样返回一维数组
d1 = np.arange(10,20)
d2 = d1.reshape((2,5))
# print(d1)
# print(d2)
#追加元素 ,如果是一维数组，不需要调用到axis这个参数
d3 = np.append(d1,20)
# print(d3)
# 多维数组的追加，降维成一维数组，将元素追加到末尾
d4 = np.append(d2,20)
# print(d4)
# 一维数组追加列表
d5 = np.append(d1,[20,21])
# print(d5)
# 一维数组和多维数组相追加，降维，加入到末尾
d6 = np.append(d2,d1)
d7 = np.append(d1,d2)
# print(d6)
# print(d7)



#insert的运用
d8 = np.insert(d1,0,100)
# print(d8)
d9 = np.insert(d1,0,100,axis=0)
# print(d9)
d10 = np.insert(d2,0,100)
# print(d10)
d11 = np.insert(d2,0,100,axis=0)
# print(d11)


#delete函数的使用问题
#一维数组
d12 = np.delete(d1,0,axis=0)
# print(d12)
d13 = np.delete(d1,[0,1],axis=0)
# print(d13)
#多维数组
d12 = np.delete(d2,0,axis=1)
# print(d12)
d13 = np.delete(d2,[0,1],axis=1)
# print(d13)



'''数组合并'''
f1 = np.arange(10,20)
f2 = np.arange(30,40)
# 二维数组
f3 = f1.reshape((2,5))
f4 = f2.reshape((2,5))
# print(f1)
# print(f2)
# print(f3)
# print(f4)
f5 = np.concatenate((f1,f2))
# print(f5)
f6 = np.concatenate((f3,f4))
# print(f6)



'''集合的问题'''
list01 = [1,1,1,1,2,3,4,5,12,12,13,7,8,9,9,9]
# print(list01)
# print(len(list01))
q1 = np.array(list01)
#一维数组去重
q2 = np.unique(q1)
# print(q2)
#多维数组去重，降维成一位数组去重



#求并集的情况
# 一维数组的并集，去重并且排序
# 多维数组求并集降维，去重并且排序
# np.union1d()


#求交集的情况
# np.intersect1d()