最近遇到numpy.zero()這個函式時有幾個疑惑的地方：

1、想生成5×2階的零矩陣時為什麼不是zeros(5,2)，而是多了個括號zeros((5,2))?

2、查到幫助文件的示例zeros((5,))=array([ 0.,  0.,  0.,  0.,  0.])，表示疑惑，（5，）代表什麼呢？後面，省略了什麼？0？1？

 1.從幫助文件得到答案：第一個引數表示矩陣的shape,如果是zeros(5,2)則給兩個引數賦值了shape=5, dytpe=2, 這是錯誤的，（5,2）代表一個引數而已。

help(numpy.zeros)
Help on built-in function zeros in module numpy.core.multiarray:

zeros(...)
    zeros(shape, dtype=float, order='C')
    
    Return a new array of given shape and type, filled with zeros.
    
    Parameters
    ----------
    shape : int or sequence of ints
        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
    dtype : data-type, optional
        The desired data-type for the array, e.g., `numpy.int8`.  Default is
        `numpy.float64`.
    order : {'C', 'F'}, optional
        Whether to store multidimensional data in C- or Fortran-contiguous
        (row- or column-wise) order in memory.
    
    Returns
    -------
    out : ndarray
        Array of zeros with the given shape, dtype, and order.
    
    Examples
    --------
np.zeros(5)
    array([ 0.,  0.,  0.,  0.,  0.])
    
np.zeros((5,), dtype=np.int)
    array([0, 0, 0, 0, 0])
    
np.zeros((2, 1))
    array([[ 0.],
           [ 0.]])
    
s = (2,2)
np.zeros(s)
    array([[ 0.,  0.],
           [ 0.,  0.]])
    
np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
    array([(0, 0), (0, 0)],
          dtype=[('x', '<i4'), ('y', '<i4')])

2、繼續查幫助文件

 help(numpy.zeros(5,))
Help on ndarray object:

class ndarray(__builtin__.object)
 |  ndarray(shape, dtype=float, buffer=None, offset=0,
 |          strides=None, order=None)
 |  
 |  An array object represents a multidimensional, homogeneous array
 |  of fixed-size items.  An associated data-type object describes the
 |  format of each element in the array (its byte-order, how many bytes it
 |  occupies in memory, whether it is an integer, a floating point number,
 |  or something else, etc.)
 |  
 |  Arrays should be constructed using `array`, `zeros` or `empty` (refer
 |  to the See Also section below).  The parameters given here refer to
 |  a low-level method (`ndarray(...)`) for instantiating an array.
 |  
 |  For more information, refer to the `numpy` module and examine the
 |  the methods and attributes of an array.
 |  
 |  Parameters
 |  ----------
 |  (for the __new__ method; see Notes below)
 |  
 |  shape : tuple of ints
 |      Shape of created array.
 |  dtype : data-type, optional
 |      Any object that can be interpreted as a numpy data type.
 |  buffer : object exposing buffer interface, optional
 |      Used to fill the array with data.
 |  offset : int, optional
 |      Offset of array data in buffer.
 |  strides : tuple of ints, optional
 |      Strides of data in memory.
 |  order : {'C', 'F'}, optional
 |      Row-major (C-style) or column-major (Fortran-style) order.
 |  
 ..................

這時才發現zeros的第一個引數shape是由整數或tuple表示，這時意識到（5，）表示的應該是tuple，於是查了tuple的用法及注意事項就明白了，答案在下面標紅標粗加大，簡單理解（5，）就代表5，隨便複習下tuple用法：

tuple

另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

現在，classmates這個tuple不能變了，它也沒有append()，insert()這樣的方法。其他獲取元素的方法和list是一樣的，你可以正常地使用classmates[0]

不可變的tuple有什麼意義？因為tuple不可變，所以程式碼更安全。如果可能，能用tuple代替list就儘量用tuple。

tuple的陷阱：當你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來，比如：

>>> t = (1, 2)
>>> t
(1, 2)

如果要定義一個空的tuple，可以寫成()：

>>> t = ()
>>> t
()

但是，要定義一個只有1個元素的tuple，如果你這麼定義：

>>> t = (1)
>>> t
1

定義的不是tuple，是1這個數！這是因為括號()既可以表示tuple，又可以表示數學公式中的小括號，這就產生了歧義，因此，Python規定，這種情況下，按小括號進行計算，計算結果自然是1。

所以，只有1個元素的tuple定義時必須加一個逗號,，來消除歧義：

>>> t = (1,)
>>> t
(1,)

Python在顯示只有1個元素的tuple時，也會加一個逗號,，以免你誤解成數學計算意義上的括號。

最後來看一個“可變的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

這個tuple定義的時候有3個元素，分別是'a'，'b'和一個list。不是說tuple一旦定義後就不可變了嗎？怎麼後來又變了？

別急，我們先看看定義的時候tuple包含的3個元素：

當我們把list的元素'A'和'B'修改為'X'和'Y'後，tuple變為：

表面上看，tuple的元素確實變了，但其實變的不是tuple的元素，而是list的元素。tuple一開始指向的list並沒有改成別的list，所以，tuple所謂的“不變”是說，tuple的每個元素，指向永遠不變。即指向'a'，就不能改成指向'b'，指向一個list，就不能改成指向其他物件，但指向的這個list本身是可變的！

理解了“指向不變”後，要建立一個內容也不變的tuple怎麼做？那就必須保證tuple的每一個元素本身也不能變。