Python3NumPy——ndarray對象

 

Python3NumPy——ndarray對象

1.前沿

• 推薦導入語法：import numpy as np
• NumPy中使用ndarray對象表示數組，ndarray是NumPy庫的核心對象

2.建立ndarray對象

• 函數array()傳遞Python序列建立數組

import numpy as np #導入Numpy庫，給出別名爲np
x1 = np.array([1,2,3,4,5,6])
print('-'*20 + '第EX1個例子' + '-'*20)
print('EX1=>傳遞參數爲單列表，建立的1維數組x1爲： {}'.format(x1))
print('EX1=>x1的形狀爲元組類型： {}'.format(x1.shape))
print('-'*20 + '第EX2個例子' + '-'*20)
x2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print('EX2=>傳遞參數爲嵌套列表，建立的2維數組x2爲： \n{}'.format(x2))
print('EX2=>x2的形狀爲元組類型： {}'.format(x2.shape))
print('-'*20 + '第EX3個例子' + '-'*20)
x3 = np.array((7,8,9,10))
print('EX3=>傳遞參數爲單元組，建立的1維數組x3爲： {}'.format(x3))
print('EX3=>x3的形狀爲元組類型： {}'.format(x3.shape))
print('-'*20 + 'End' + '-'*20)

--------------------第EX1個例子--------------------
EX1=>傳遞參數爲單列表，建立的1維數組x1爲： [1 2 3 4 5 6]
EX1=>x1的形狀爲元組類型： (6,)
--------------------第EX2個例子--------------------
EX2=>傳遞參數爲嵌套列表，建立的2維數組x2爲：
[[1 2 3]
 [4 5 6]
 [7 8 9]]
EX2=>x2的形狀爲元組類型： (3, 3)
--------------------第EX3個例子--------------------
EX3=>傳遞參數爲單元組，建立的1維數組x3爲： [ 7 8 9 10]
EX3=>x3的形狀爲元組類型： (4,)
--------------------End--------------------

Note:補充知識=》修改數組形狀，修改後的形狀後，其元素在內存中的位置並未改變；只是改變了軸的長度。

X = np.array([[1,2,3,4],[5,6,7,8],[7,8,9,10]])#X傳遞參數爲嵌套列表，建立的2維
print('原型狀數組X爲(3行,4列)： \n{}'.format(X))
print('X的形狀爲元組類型(0軸長度爲3，1軸爲4)： {}'.format(X.shape))
print('-'*20 + '第一次修改X的形狀' + '-'*20)
X.shape = 4, 3
print('第一次修改形狀後數組X爲(4行,3列)： \n{}'.format(X))
print('-'*20 + '第二次修改X的形狀' + '-'*20)
X.shape = 2, -1 # -1表示自動計算1軸的長度，結果爲6
print('第二次修改形狀後數組X爲(2行,6列)： \n{}'.format(X))
print('='*50)
print('-'*20 + '指定形狀數組：reshape()方法' + '-'*20)
a = np.array([1,2,3,4,5,6,7,8,9])
print('原型狀數組a爲(1行,9列)： \n{}'.format(a))
a1 = a.reshape((3,3))
print('變換爲3X3數組a1爲(3行,3列)： \n{}'.format(a1))
print('再次打印a數組爲： \n{}'.format(a))
a[0] = 100
print('修改a的第一個元素的值爲100後a爲： \n{}'.format(a))
print('修改a的第一個元素的值爲100後a1爲： \n{}'.format(a1))
print('代表：a和a1共享存儲空間')

原型狀數組X爲(3行,4列)：
[[ 1 2 3 4]
 [ 5 6 7 8]
 [ 7 8 9 10]]
X的形狀爲元組類型(0軸長度爲3，1軸爲4)： (3, 4)
--------------------第一次修改X的形狀--------------------
第一次修改形狀後數組X爲(4行,3列)：
[[ 1 2 3]
 [ 4 5 6]
 [ 7 8 7]
 [ 8 9 10]]
--------------------第二次修改X的形狀--------------------
第二次修改形狀後數組X爲(2行,6列)：
[[ 1 2 3 4 5 6]
 [ 7 8 7 8 9 10]]
==================================================
--------------------指定形狀數組：reshape()方法--------------------
原型狀數組a爲(1行,9列)：
[1 2 3 4 5 6 7 8 9]
變換爲3X3數組a1爲(3行,3列)：
[[1 2 3]
 [4 5 6]
 [7 8 9]]
再次打印a數組爲：
[1 2 3 4 5 6 7 8 9]
修改a的第一個元素的值爲100後a爲：
[100 2 3 4 5 6 7 8 9]
修改a的第一個元素的值爲100後a1爲：
[[100 2 3]
 [ 4 5 6]
 [ 7 8 9]]
代表：a和a1共享存儲空間

3.元素類型

• 採用dtype屬性獲取
• 建立ndarray對象時，能夠指定元素類型
• 元素數據類型轉換方法：astype()

xi = np.array([1,2,3,4],dtype=np.int32) #指定整形
print('xi的類型爲： {}'.format(xi.dtype))
print('-'*20 + 'End' + '-'*20)
xf = np.array([1,2,3,4],dtype=np.float) #指定浮點型
print('xf的類型爲： {}'.format(xf.dtype))
print('-'*20 + 'End' + '-'*20)
xc = np.array([1,2,3,4],dtype=np.complex) #指定爲複數型
print('xc的類型爲： {}'.format(xc.dtype))
print('-'*20 + 'End' + '-'*20)

xi的類型爲： int32
--------------------End--------------------
xf的類型爲： float64
--------------------End--------------------
xc的類型爲： complex128
--------------------End--------------------

print("numpy中去重的數據類型：")
set(np.typeDict.values())

numpy中去重的數據類型：

{numpy.uint16,
 numpy.complex64,
 numpy.complex128,
 numpy.timedelta64,
 numpy.int32,
 numpy.uint8,
 numpy.float64,
 numpy.void,
 numpy.int64,
 numpy.uint32,
 numpy.object_,
 numpy.int8,
 numpy.int32,
 numpy.uint64,
 numpy.int16,
 numpy.uint32,
 numpy.str_,
 numpy.datetime64,
 numpy.float32,
 numpy.bool_,
 numpy.float64,
 numpy.complex128,
 numpy.float16,
 numpy.bytes_}

print('xi.dtype的爲： {}'.format(xi.dtype))
print('xi.dtype.type的爲： {}'.format(xi.dtype.type))

xi.dtype的爲： int32
xi.dtype.type的爲： <class 'numpy.int32'>

print('-'*20 + '數據類型致使的溢出問題' + '-'*20)
xi16 = np.int16(200)
print('xi16 X xi16的結果溢出，計算出現錯誤： {}'.format(xi16*xi16))

--------------------數據類型致使的溢出問題--------------------
xi16 X xi16的結果溢出，計算出現錯誤： -25536

C:\Anaconda3\lib\site-packages\ipykernel\__main__.py:3: RuntimeWarning: overflow encountered in short_scalars
  app.launch_new_instance()

NumPy的數值對象的運算速度比Python的內置類型的運算速度慢不少，若是程序中須要大量地單個數值運算，避免使用NumPy的數值對象。

print('-'*20 + '數據類型致使的時間問題' + '-'*20)
v1 = 3.14
v2 = np.float64(v1)
%timeit v1*v1
%timeit v2*v2

--------------------數據類型致使的時間問題--------------------
10000000 loops, best of 3: 46.6 ns per loop
The slowest run took 35.90 times longer than the fastest. This could mean that an intermediate result is being cached.
10000000 loops, best of 3: 129 ns per loop

t1 = np.array((1,2,3,4,5), dtype=np.float)
print('轉換數據類型爲int32')
t11 = t1.astype(np.int32)
print(t11)
print('-'*40)
t2 = np.array((1,2,3,4), dtype=np.complex)
print('轉換數據類型爲complex64')
t22 = t2.astype(np.complex64)
print(t22)

轉換數據類型爲int32
[1 2 3 4 5]
----------------------------------------
轉換數據類型爲complex64
[1.+0.j 2.+0.j 3.+0.j 4.+0.j]