# Numpy学习之数组

#### Numpy类型

```# --*--coding:utf-8--*--
from numpy import *
"""

"""
a = array([1 + 1j, 2, 3, 4])
# 数组类型
print('type:', a.dtype)
# 实部
print(a.real)
# 虚部
print(a.imag)
# 复共轭
print(a.conj())

"""

"""
a = array([1, 2, 4, 9, 10], dtype=float32)
print(a)

a = array([0, 1.8, 3.3, 4.1], dtype=uint8)
print(a)

"""

"""
a = array([1.5, -3, -3.3],
dtype=float32)
b = asarray(a, dtype=float64)
print('asarray类型转换：', b)

c = a.astype(uint8)
print('astype类型转换：', c)

a = array((1,2,3,4), dtype=int32)
d = a.view(uint8)
print('view类型转换：', d)```

```# --*--coding:utf-8--*--
from numpy import *
from numpy.random import rand
"""

"""
a = array([[1,2,3], [4,5,6]])
# 所有元素和
print('all:', sum(a))
# 指定求和维度
print('维度和：', sum(a, axis=0))
print('维度和：', sum(a, axis=-1))

"""

"""
# 所有元素积
print('all:', prod(a))
# 指定求积维度
print('维度积：', prod(a, axis=0))
print('维度积：', prod(a, axis=1))

"""

"""
a = rand(3, 4)
print(a)
# 全局最小
print('all:', a.min())
# 某个轴最小
print('axis:', a.min(axis=1))
# 全局最大
print('all:', a.max())
# 某个轴最大
print('axis:', a.max(axis=-1))

# 最大最小值的位置
print('max in: ', a.argmax())
print('min in ', a.argmin())

"""

"""
a = array([[1,2,3],[4,5,6]])
print('avg:', a.mean())
print('avg: ', average(a, axis=0))

"""

"""
# 标准差
print('std: ', a.std(axis=1))
# 方差
print(a.var(axis=1))
print(var(a, axis=-1))
print(std(a, axis=-1))

# clip方法,将数值限制在某个范围
print(a)
# 小于2的变成2，大于4的变成4
print(a.clip(2, 4))

# ptp方法，计算最大值和最小值之差
print(a.ptp(axis=1))
print(a.ptp())

# round方法
a = array([1.35, 2.5, 1.5])
print(a.round())
# 近似到一位小数
print(a.round(decimals=1))```

```# --*-- coding:utf-8 --*--
from numpy import *
"""

"""

# sort函数
names = array(['Bob', 'Sue', 'Jan', 'Ad'])
print('names sort:', sort(names))
weights = array([20, 93, 53, 62])
print('weights sort:', sort(weights))

# argsort函数
ordered_indices = argsort(weights)
print(ordered_indices)
print(weights[ordered_indices])

"""

"""
a = array([
[.2, .1, .5],
[.4, .8, .3],
[.9, .6, .7]
])
print('all: \n', sort(a))
print('axis: \n', sort(a, axis=0))

"""
searchsorted函数，接受两个参数，第一个必须是已排序的数组
"""
sorted_array = linspace(0, 1, 5)
values = array([.1, .8, .3, .31, .9, .45])
print('searcgsorted: ', searchsorted(sorted_array, values))```

```"""

"""
# --*-- coding:utf-8 --*--
from numpy import *
# 修改数组形状
a = arange(6)
print('origin: \n', a)
a.shape = 2, 3
print('after modified: \n', a)
print('after reshape: \n', a.reshape(3, 2))

# 使用newaxis增加数组维数
a = arange(3)
print('shape:', shape(a))
y = a[newaxis, :]
print(shape(y))
print(y)
y = a[newaxis, newaxis, :]
print(shape(y))
print(y)

# squeeze方法去除多余的轴
a = arange(6)
a.shape = (2, 1, 3)
b = a.squeeze()
print('shape of b:', b.shape)

# 数组转置
"""
PS:
1、对于复述数组，转置不返回复共轭，只是单纯交换轴的位置
2、转置可以作用于多维数组
"""
print(a)
print('transpose: \n', a.transpose())

print(a.T)

# 数组连接
x = array([
[0,1,2],
[10,11,12]
])
y = array([
[50,51,52],
[60,61,62]
])

z = concatenate((x, y))
print(z)

# Flatten数组，将多维数组转化为1维数组,返回数组的复制，不改变原数组的值
a = array([[0,1],
[2,3]])
b = a.flatten()
print(b)

# flat属性，相当于返回所有元组组成的一个迭代器
print(a.flat)

# reval方法,将多位数组转化为1维数组
b = a.ravel()
print(b)

# atleast_xd函数，保证数组至少有x维
x = 1
print('1d:',atleast_1d())

a = array([1,2,3])
b = atleast_2d(a)
print('2d:', b)

c = atleast_3d(b)
print('3d: ', c)```

```# --*--coding:utf-8--*--
import numpy as np
"""

"""
a = np.array([11,22,33,44,55,66,77,88,99])
a.shape = 3, 3
print(a)

# 对角线元素
print('all :\n', a.diagonal())

# 对角线元素偏移，正数代表右移，负数代表左移
print('左移：\n', a.diagonal(offset=-1))
print('右移：\n', a.diagonal(offset=1))

# 更新对角线的值
i = [0, 1, 2]
a[i, i] = 20
print('update: \n', a)

# 修改次对角线的值
i = np.array([0, 1])
a[i, i+1] = 21
print('修改次对角线：\n', a)```

```# --*--coding:utf-8--*--
import numpy as np
"""

"""
# tostring方法
a = np.array([[1, 2], [3, 4]], dtype = np.uint8)
print('a: ', a.tostring())
# 按照列读取数据
print('a Fortran:', a.tostring(order='F'))

# fromstring函数，从字符串中独处数据，但要指定类型
s = a.tostring()
a = np.fromstring(s, dtype=np.uint8)
a.shape = 2, 2
print(a)```

```# --*--coding:utf-8--*--
import numpy as np
"""

"""
# arange(start, stop=None, step=1, dtype=None)，类似range函数，返回数组
# 允许非整数值输入，产生一个菲整形的数组
a = np.arange(5)
print(a)

# linspace(start, stop, N)，产生N个等距分布与【】
print(np.linspace(0, 10, 5))

# logspace(start, stop, N),产生N个对数等距分布的数组，默认以10为底
print(np.logspace(0, 8, 5))

# meshgrid，二维平面中生成一个网格
x_lable = np.linspace(-1, 1, 5)
y_lable = np.linspace(-1, 1, 5)
x, y = np.meshgrid(x_lable, y_lable)
print(x, y, end='\n')

# 1、ogrid(start:end:step)：meshgrid(indexing='ij', sparse=True)，生成列矩阵
# 2、mgrid(start:end:step): meshgrid(indexing='ij', sparse=False)，生成行矩阵
x, y = np.ogrid[-10:10:5, 10:30:5]
print('{} \n {}'.format(x, y))

# r_:产生行向量
# c_:产生列向量

print(np.r_[1:10:2])
print(np.c_[1:10:2])

# ones(shape, dtype)，定制一个全1的数组，数组类型可指定
# zeros(shape, dtype),定制一个全0的数组，数组类型可指定
# empty(shape, dtype, order)，产生一个指定大小的数组(指向的内存未初始化，故值随机)
print('全1:\n', ones([3, 5], dtype = np.float32))
print('全0:\n', zeros([3, 5], dtype = np.float32))
print(np.empty(5))

# empty_like(array)、ones_like(array)、zeros_like(array),产生一个与a大小一样，类型一样的对应数组
a = np.arange(0, 10, 2)
print(a)
print('empty like:\n', np.empty_like(a))
print('zeros like:\n', np.zeros_like(a))
print('ones like:\n', np.ones_like(a))

# identity(n, dtype)，产生一个n*n的单位矩阵
print('identity: \n', np.identity(5))```

0 条评论

• ### NLTK相关知识介绍

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

• ### Python中的条件判断、循环以及循环的终止

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

• ### 动手学深度学习-数据操作

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

• ### Python入门(案例)

#python注释有两种 #1.单行注释 #这是单行注释 #2.多行注释 ''' 这是多行注释 '''

• ### Python数据类型

整型 a=10 b=0 b+=a c=-100 c-=a print (a, b ,c) print (dir(a)) print (abs(a)+abs(c)...

• ### python 文件

#写进文件 myfile = open('myfile.txt', 'w') myfile.write('hello textfile\n') myfile.w...

• ### 第三天-基本数据类型 int bool

在python3中所有的整数都是int类型. 但在python2中如果数据量比较⼤. 会使⽤long类型. 在python3中不存在long类型

• ### python从入门到放弃（二）

如果是文字或者字母需要在括号内加上单引号，或者双引号，如果字母中带引号则使用双引号，避免冲突 数字则不加

• ### Python基础入门视频课程——笔记

视频课程链接：http://edu.51cto.com/course/14859.html