numpy数组（一）

import numpy as ny

a = ny.array([1, 2, 3, 4])
b = ny.array([5, 6, 7, 8])
c = ny.array([[1, 2, 3, 4], [2, 3, 4, 3], [4, 5, 6, 7]])
d = ny.array([[1, 2, 3], [2, 3, 4, 3], [4, 5, 6, 7]])
# 数组的形状可以通过其shape 属性获得，它是一个描述数组各个轴长度的元组(tuple)：
print('a.shape:  ', a.shape)
print('c.shape:  ', c.shape)
print('d.shape   ', d.shape)  # 不等的时候宽度无法获取
c.shape = 4, 3
print('after change c:  ', c)
# 当设置某个轴的元素个数为-1 时，将自动计算此轴的长度。
c.shape = 2, -1
print('after change c:  ', c)
# 使用数组的 reshape()方法，
# 可以创建指定形状的新数组，而原数组的形状保持不变：
e = a.reshape((2, 2))
print('e:  ', e)
print('a:  ', a)
# 数组 e 和a 其实共享数据存储空间，因此修改其中任意一个数组
# 的元素都会同时修改另外一个数组的内容
a[0] = 100
print('after change a:  ', a)
print('after change e:  ', e)
# 数组的元素类型可以通过 dtype 属性获得
print('c.type:  ', c.dtype)
# 可以通过dtype 参数在创建数组时指定元素类型，
# 注意 float 是 64 bit 的双精度浮点类型，
# 而 complex 是 128 bit 的双精度复数类型：
f = ny.array([1, 2, 3, 4], dtype=ny.float)
g = ny.array([1, 2, 3, 4], dtype=ny.complex)
print('f:', f)
print('g:', g)
# NumPy 中的数据类型都有几种字符串表示方式，字符串和类型之间的对应关系
# 都存储在typeDict 字典中，例如'd'、'double'、'float64'都表示双精度浮点类型：
print('ny.typeDict["d"]:  ', ny.typeDict["d"])

# arange()类似于内置函数 range()，通过指定开始值、终值和步长创建表示
# 等差数列的一维数组，注意得到的结果数组不包含终值。
print('ny.arrange(0,1,0.2):  ', ny.arange(0, 1, 0.1))

# linspace()通过指定开始值、终值和元素个数创建表示等差数列的一维数组，可以通过
# endpoint参数指定是否包含终值，默认值为True，即包含终值。下面两个例子分别演示了endpoint
# 为True 和 False 时的结果，注意 endpoint 的值会改变数组的等差步长
print('ny.linspace(0, 1, 10):  ', ny.linspace(0, 1, 10))
print('ny.linspace(0, 1, 10, endpoint=False):  ', ny.linspace(0, 1, 10, endpoint=False))

# logspace()和 linspace()类似，不过它所创建的数组是等比数列。下面的例子产生从 10 0 到
# 10 2 、有 5 个元素的等比数列，注意起始值0 表示 10 0 ，而终值2 表示 10 2 ：
print('ny.logspace(0, 2, 5):  ', ny.logspace(0, 2, 5))

# 基数可以通过base 参数指定，默认值为10。下面通过将base 参数设置为2，并设置 endpoint
# 参数为 False，创建一个比例为 2 1/12 等比数组
print('ny.logspace(0, 1, 12, base=2, endpoint=False):  ', ny.logspace(0, 1, 12, base=2, endpoint=False))



a.shape:   (4,)
c.shape:   (3, 4)
d.shape    (3,)
after change c:   [[1 2 3]
 [4 2 3]
 [4 3 4]
 [5 6 7]]
after change c:   [[1 2 3 4 2 3]
 [4 3 4 5 6 7]]
e:   [[1 2]
 [3 4]]
a:   [1 2 3 4]
after change a:   [100   2   3   4]
after change e:   [[100   2]
 [  3   4]]
c.type:   int32
f: [1. 2. 3. 4.]
g: [1.+0.j 2.+0.j 3.+0.j 4.+0.j]
ny.typeDict["d"]:   <class 'numpy.float64'>
ny.arrange(0,1,0.2):   [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
ny.linspace(0, 1, 10):   [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
ny.linspace(0, 1, 10, endpoint=False):   [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
ny.logspace(0, 2, 5):   [  1.           3.16227766  10.          31.6227766  100.        ]
ny.logspace(0, 1, 12, base=2, endpoint=False):   [1.         1.05946309 1.12246205 1.18920712 1.25992105 1.33483985
 1.41421356 1.49830708 1.58740105 1.68179283 1.78179744 1.88774863]