數字並不是一個真正的物件型別，而是一組類似型別的分類，其中有很多中型別被包含在這個大類裡面，包含了如下：
    1. 整數 integer：我們最一般看到的樣子，123這種純粹數字
    2. 浮點數 float：有小數點是最直觀可辨認的，還有加了科學記號 E 或 e 的那種數
    3. 複數 complex：實部 + 虛部，其中虛部以 j 或是 J 表示，內部看來就是以浮點數表示，但實際演算法不同
    4. 無窮精度整數
    5. 固定精度十進位制數
    6. 集合
    7. bool 值 ... etc

長整型數：整數部分用長整型，浮點數用雙精度浮點型來記錄，至少有32位，跟 C 語言的編譯精度一樣。其電腦記憶體空間有多大，就會有多少位數字。一般在數字後面加上 L 可以變成長整型，but if the number is too big for calculating, python would automaticallychanges the type of the number into a proper corresponding one. This is reallyconvenient to calculate huge amount of data if the computer is supportive.
長整型數常量

表示式的 operators： + - * /  >>  ** 等
內建數學函式：pow, abs 等
內建數學模組：random, math 等
更多的 operators 要查詢的話參照如下網址：http://www.runoob.com/python/python-operators.html
The operational sequence of the operators are all intuitivelypreset in Python already. No extra worries about this. For example, * is prior than +.

如果需要一些嚴謹的數字運算，Numpy提供了進階的計算拓展包，裡面包含了矩陣，向量等多樣的數學運算工具。

這些數字在運算中的複雜程度依序為，整數 --> 長整數 --> 浮點數 --> 複數。

而如果兩個不同型別的數做了運算，那 python 會自動把結果升級成為最複雜的那個型別，例如 1+3.14 ，結果就會是個浮點數。

數字顯示格式
有些時候計算機的好壞（就是電腦的好壞）會影響浮點數顯示出來的位數結果，他可能算不到那麼後面因此顯示一個四捨五入過後的值。下面兩種方式可以 transform number into a string: 
    1. repr(num)  >>>  '0.333331' 如同上面長整數常量型別的結尾方式

    2. str(num)  >>>  'o.333333' 程式設計了字串而不再是數字

要特別注意的操作符作用：

>>> x = 1
>>> X << 2
4   # 因為從二進位制的角度看 1 為 0001，左邊整串數字向左邊平移兩格，移出去的忽略，空出來的補 0 ，結果就是0100，答案為 4 。
>>> X | 2
3   #｜為 or 的意思，2 表示 0010，與 1 的 0001 疊在一起則為 0011，答案為 3 。
>>> X & 1
1   # & 為 and 的意思，答案為 1。

Octal and hex literals (八進位制與十六進位制):

# 我們也可以直接函式定義進位制的種類
>>> oct(64), hex(64), hex(255)
('0100', '0x40' ,'0xff')
# 又或者可以直接用 int 函式的第二個引數定義種類
>>> int('0100'), int('0100', 8), int('0x40', 16)
(100, 64, 64)

內建運算子：

# Except for the math tool named NumPy, there are also some useful intrinsic tools already existing in python.So we better be familiar with these operators.
>>> import math

>>> math.pi, math.e, math.sin(2*math.pi/180),math.sqrt(144), abs(-42)
(3.1425926…, 2.71828182…,0.0348996…, 12.0, 42)
>>> 2**4, pow(2,4), int(2.567), round(2.567),round(2.567, 2)
(2, 3.0, 2.57)

>>> import ramdom

>>> random.random()
0.4974…..
>>> random.randint(1, 10)
5  # pick up a random integer from 1 to 10 andprint it out
>>> random.choice(['life of brian', holy grail','meaning of life'])
'life of brian'

小數字數 decimal number：

# 小數就如同浮點數，有固定的精度，但是在運算方面有個缺陷， eg：
>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125…-017

# The result is approaching zero but actually it is not zero. This flaw is caused by the fundamental limit of thehardware. The way to fix this problem is to import function of decimal.
>>> from decimal import Decimal

>>> Decimal('0.1') + Decimal('0.1') +Decimal('0.1') - Decimal('0.3')
Decimal('0')

集合set：

# Create a set object, 將一個序列或其他的迭代物件傳遞給內建 set 函式
>>> x = set('abcde')
>>> y = set('bdxyz')
>>> x
Set(['a', 'c', 'b', 'd','e'])     # mind that the sequence is notguarantee

When using this function 'set' to create a list, the mathematical set calculation would be executable. If there is only a list created by simple statement, the list won't support this operator such as | and &. 這個 set 功能很方便大資料的分選與精煉。

布林型 bool： True and False
是一個預先定義的內建變數名稱，實際上僅僅是整數型別 int 的一個子類，(True, False) = (1, 0)，行為和 0 與 1 是一樣的，但他有特殊的邏輯列印形式，以 Ture 或 False 顯示。

可將此 Ture 或 False 但作為整數 1 和 0 的變數，所以 True ＋ 3 ＝ 4。

而 python 裡面的變數型別也是動態的，不用通過宣告來定義。例如鍵入 a = 3，那麼 a 這個變數就被建立了。

• Variable is an element within the system list, possessing the space for object oriental appointment.
• Object is a piece of distributed memory, having enough space to represent the declared value
• 引用是自動形成的，從變數到物件的指標
  

變數型別
型別的概念存在於物件中，而非變數名本身，因此變數不會被任何與之關聯的型別約束，他只是在一個特定的時間點簡單引用了特定物件而已。例如：

>>>  a = 3          #it's an integer
>>>  a = 'spam'         #now it's a string
>>>  a = 1.23        #not it's a floating point

當從新給 a 賦值的時候，之前佔用的物件空間就被自動回收了，也稱作垃圾蒐集。

變數使用
邏輯上來說，如果鍵入了 a = 3，則過程如下：
    1. 建立物件 object 來代表 3
    2. 建立一個變數 variable 為 a
    3. 把建立的 object and variable 做一個關聯

Mind that the variable is always linked to the object. Technically, object is more complex with its structure, 而不是有足夠空間表達它的值那麼簡單，每個物件都有它的標準頭部訊息。一個是「型別標志符」標註物件型別，另一個是引用的「計數器」用來決定是否能夠回收這個物件。

引用共享

繼續剛才 a 的例子，再新增一個變數 b ，如下指令：

>>>  b = a
# 雖然 b 沒有被賦值，但變數 a 因為這個指令成了物件 3 的一個引用，在內部實際上指向了物件的記憶體空間，通過執行常量表達式建立。

# If we set a more complex situation below:
>>>  a = 3
>>>  b = a
>>>  a ='spam'
# Then, b will still be 3 but not affected by the newobject orientation that happened to a.

>>>  x = [1, 2, 3, 4]
>>>  y = x
>>>  y
[1, 2, 3, 4]        # now the y variable is the same as x variable
>>>  x[0] = 99      # change the first parameter of the list into 99
>>>  x
[99, 2, 3, 4]
>>>  y
[99, 2, 3, 4]        # y is affected by the change of x list
# This is the part we have to bare in mind for the developing process. devil is always hidden in the details.
 
# What if we don't want this situation happens to us? The only little difference is to link y as the copy one of x. Eg:
>>>  y = x[:]        # make a copy of x
# Then, whatever the x is changed next, the change won't affect y anymore.
# But this approach has it own limit too. This can only be used to the object with sequence. Dictionary would not be probable for this way. We should therefore use function 「copy」
 
>>>  import copy
>>>  y = copy.copy(x)          # make a top-level 'shallow' copy of any object Y
>>>  y = copy.deepcopy(x)         # make a deep copy of any object Y:copy all nested parts

共享引用與相等的差別
如果說 y 共享了 x 的物件，並不代表 x 就是 y，只能說他們兩個值一樣。以下例證：

>>>  x = 42
>>>  y = x
>>>  x == y
True
>>>  y is x
False        #they are just different object but linked together
 
# But if both x and y are pointed to the same object individually, x would be y.
>>>  y = 42
>>>  x == y
True
>>>  y is x
True

When writing code by using python, it's not necessary to trace the type of the object constantly. The type of the object will constantly be changed by our latest update.