YS_20190801_Python

Numpy相关内容

1.numpy.empty ()

创建指定形状和dtype的未初始化数组
numpy.empty(shape, dtype = float, order = ‘C’)
1.Shape 空数组的形状，整数或整数元组
2. Dtype 所需的输出数组类型，可选
3. Order 'C’为按行的C风格数组，'F’为按列的Fortran风格数组

#数组大小随机
arr = np.empty ((3,3),dtype = 'i1')
print(arr)

numpy.zeros ():

#返回特定大小，以0填充
arr = np.zeros((3,3))
print(arr)

numpy.ones:

#返回特定大小，以1填充
arr = np.ones((2,3,4))
print(arr)
arr = np.ones((3,3), dtype =  [('x',  'i4'),  ('y',  'i4')])
print(arr)

2.来自现有数据的数组

Numpy.asarray ()
列表：

`arr = [1,2,3,4]
arr2 = np.asarray(arr)
print(arr2)
print(type(arr))
print(type(arr2))

结果

3.来自数值范围的数组

Numpy,arange () 这个函数返回ndarray对象，包含给定范围内的等间隔值.
numpy.arange(start,stop,step,dtype)

arr = np.arange(5,dtype = float)
print(arr)

arr = np.arange(1,11,2,dtype = float)
print(arr)
print(type(arr))

此结果可以减小数学误差，在数据挖掘、数据分析中使用可以减小数据误差
Numpy.linspace（） 类似arange函数的等差数列，numpy.linspace(start,stop,num,endpoint,retstep,dtype)
start 起始值
stop 结束值
num 生成等间隔样例的数量，默认为50
endpoint 序列中是否包含stop 值 默认为 True
retstep 返回步长

arr = np.linspace(10,20,9)
print(arr)

arr = np.linspace(10,20,5,endpoint=False)
print(arr)

arr = np.linspace(10,20,5,retstep=True)
print(arr) #返回步长

Numpy.logspace（） 等比数列（对数）
numpy.logscale(start, stop, num, endpoint, base, dtype)
1. start 起始值是base ‘ ** ’ start
2. stop 终止值是base “ ** ”stop
3. num 范围内的数值数量，默认为50
4. endpoint 如果为true，终止值包含在输出数组当中
5. base 对数空间的底数，默认为10
6. dtype 输出数组的数据类型，如果没有提供，则取决于其它参数

arr = np.logspace(1,10,10,base = 2)
print(arr)

其他方式
random模块

arr = np.random.rand(9).reshape(3,3)
print(arr)  # rand  返回 0 - 1 随机值

arr = np.random.rand(3,2,3)
print(arr)

arr = np.random.randn(9).reshape(3,3)
print(arr) # randn 返回一个样本具有标准正态分布

arr = np.random.randn(3,2,3)
print(arr) 

arr = np.random.randint(1,9,size = (2,4))
print(arr)  #randint 返回随机的整数

arr = np.random.random_integers(1,9,size =(2,4))
print(arr) #random_integers(low[, high, size])  返回随机的整数，位于闭区间

arr = np.random.random((3,2,3))
print(arr)  #返回随机浮点数

arr = np.random.randn(3,2,3)
print(arr)

4.数组属性

ndarray.shape () 这个数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小

a = np.array([[1,2,3],[4,5,6]])
print(a)
print(a.shape)

#调整数组大小
# a = np.array([[1,2,3],[4,5,6]])
# a.shape=(3,2)
# print(a)

#ndarray.ndim 返回数组的维数
a = np.arange(24)
print(a)
print(a.ndim)
b = a.reshape(2,4,3)
print(b)
print(b.ndim)
print(b.shape)

#numpy.itemsize  返回数组中每个元素的字节单位长度
# 数组的int8 一个字节
x = np.array([1,2,3,4,5], dtype = np.int8)
print(x.itemsize)
#数组的float32 4个字节
x = np.array([1,2,3,4,5], dtype = np.float32)
print(x.itemsize)

# ndarray.size 返回数组的大小，即shape中的乘积
arr = np.arange(18).reshape(2,3,3)
print(type(str(arr)))
print(arr.shape)
print(arr.size)

5.结构化数据类型

dt = np.dtype([('age',np.int8)])
print(dt)

#将结构化数据应用于ndarray对象
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)],dtype = dt)
print(a)

#结构化数据包含多个字段
student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])
a = np.array([('joe',20,80),('susan',22,85),('tom',23,90),('fank',23,33)],dtype=student)
print(a)
print(a['name'])

每个内建类型都有一个唯一定义它的字符代码：
‘b’：布尔值
‘i’：符号整数
‘u’：无符号整数
‘f’：浮点
‘c’：复数浮点
‘m’：时间间隔
‘M’：日期时间
‘O’：Python 对象
‘S’, ‘a’：字节串
‘U’：Unicode
‘V’：原始数据(void)

切片和索引

ndarray 对象的内容可以通过索引或者切片来访问和修改，就像python的内置容器对象一样。
有三种行可用的索引方法类型：1.字段访问 2.基本切片 3.高级索引

字段访问和切片

arr = np.arange(10)
arr2 = arr[2:7:2]
print(arr2)

arr=np.array([
        [
            [1,2,3,4],
            [2,3,4,5],
            [3,4,5,6]
        ],
        [
            [10,20,30,40],
            [20,30,40,50],
            [30,40,50,60]
        ]
    ])
print(arr[1])#取到三维数组中的第一个二维
print(arr[1][1])
print(arr[1][1][2])

#取40 50
# print(arr[1][1][2:])
# print(arr[1,1,2:])

# print(arr[1][:1][0][0:1:1])  #获取第二维所有的数据加第三维的第一第二个数据失败
# print(arr[1][:3:1,:4:3])    #获取成功
# print(arr[1,:1:1,0:2])      #先横切再竖切

高级索引

a = np.arange(9).reshape(3,3)
# print(a)
# a[[0,1,2],[0,1,2]] = 9
# num = a[[0,1,2],[0,1,2]]
#使用索引器 np.ix_()
# num = a[np.ix_([0,1,2],[0,1])]  # 十字相乘法 00,01,10,11,20，21
# print(num)
print(a)
num2 = a[[[0,0],[2,2]],[[0,2],[0,2]]]#起始值 终止值   步长
print(num2)


arr = np.arange(18).reshape(2,3,3)
print(arr)
arr[...,[0,1,2],[0,1,2]] = 9
num = arr[[0,1],[0,1,2],[0,1,2]]
num = arr[...,[0,1,2],[0,1,2]]

Numpy广播

Numpy算数运算
用于执行算数运算的输入数组必须具有相同的行列或符合数组广播规则

import numpy as np
a = np.arange(9).reshape(3,3)
b = np.array([2,3,4])
print(a)
print(b)
print('*****')
#两个数组相加
print(np.add(a,b))
print(a+b)
print('******')
#两个数组相减
print(a-b)
print(np.subtract(a,b))
print('********')
#两个数组相乘
print(a*b)
print(np.multiply(a,b))
print('***********')
print(a/b)
print(np.divide(a,b))
print('******')

#两个数组取幂
print(a**b)
print(np.power(a,b))
print('***')
print()

print()
print('***两个数组取余***')
#mod 两个数组取余
a = np.array([10,20,30])
b = np.array([3,5,7])
print(np.mod(a,b))
print(np.remainder(a,b))
print('*******************')
print()

数组的矩阵积：两个二位矩阵，满足第一个矩阵的列数与第二个矩阵的行数相同，那么就可以进行矩阵的乘法，即矩阵积

print()
arr1 = np.array([
    [110,60,220],
    [115,45,180],
    [132,67,209]
])
arr2 = np.array([
    [12.3,0.04],
    [204,2.34],
    [9.98,0.45]
])
print(arr2)
print(arr1.dot(arr2))
print('********************')

a = np.array([1,2,3,4])
b = np.array([[10,20,30,40],[1,2,3,4]])
c = a * b
print(c)

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。如果满足以下规则，可以进行广播：
1. 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
2. 输出数组的shape是输入数组shape的各个轴上的最大值
3.如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错。当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

部分内容引用于老师代码