數字常量
Python中常用的數字類型是整數和浮點數。
在Python2.6中整數又分爲一般整數（32位）和長整數（無窮精度），並且一個整數可以用L或l結尾，讓其轉化成爲長整數。但是在Python3.0上，這兩者已經合二爲一，成爲一個單獨的類型-整數類型。
python2.6中的數字常量：
>>> lxm=123l
>>> type(lxm)
<type 'long'>
>>> lxm2=123
>>> type(lxm2)
<type 'int'>
>>> python3.5中的數字常量
>>> lxm=123L
File "<stdin>", line 1
lxm=123L
^
SyntaxError: invalid syntax
>>> lxm=123
>>> type(lxm)
<class 'int'>
>>> 還有一些其它數字類型：
- 十六進制：數字以0x或者0X開頭，數字的中a~f不區分大小寫。
- 八進制：數字以0o或者0O開頭。
- 二級制：數字0b或0B開頭。
這些數字在操作符的作用下做運算，還有內置或第三方擴展很多數學工具：
變量和基本的表達式
在python中：
- 變量在它第一次賦值時創建。
- 變量在表達式中使用將會替代爲它們的值。
- 變量在表達式中使用之前必須已賦值。
- 變量像對象一樣，不需要在一開始進行聲明。
數字的比較（連續的和一般的）
數字類型可以進行大小比較，可以用運算符合連續運算或者一般的單獨運算：
>>> 1 != 2 #在python3的版本中，不等判斷只能用"!="，而在一起版本還可以用"<>"
True
>>> 1<2
True
>>> 2<3
True
>>> 1<2 and 2<3
True
>>> 1>2>3
False
>>> 1<2<3 #數字的連續判斷，這並不是把1<2的結果與3比較，而是單純的判斷這個連續不等式是否正確。
True
>>> 除法
- X / Y：在以前的Python2版本中，這樣的除法操作會去掉小數部分，但是在python3中，將會變成真除法（任何情況下都會保留小數部分）。
- X // Y : Floor除法，這樣的操作無論在Python2和Python3中都會省略結果的小數部分。
>>> 25 / 8
3.125
>>> 25 // 8
3
>>> 25 // 8.0 #無論是什麼類型做除法，都會捨去小數部分。
3.0
>>> 十六進制，八進制和二進制記數
>>> 0xf,0o7,0b1 ＃十六進制，八進制，二進制
(15, 7, 1)
>>> 把十進制分別轉化爲其它進制數：
>>> oct(64),hex(64),bin(64) #這種方法轉化出來的是相應的字符串。
('0o100', '0x40', '0b1000000')
>>> int('100',8),int('40',16),int('1000000',2) #可以用int將相應進制的數字轉化爲整型
(64, 64, 64)
>>> int('0o100',8),int('0x40',16),int('0b1000000',2)
(64, 64, 64)
>>> 最後，可以使用字符串格式化方法，將一些數字轉化成爲固定的進制來記數。
>>> "{0:o},{1:x},{2:b}".format(64,64,64)
'100,40,1000000'
>>> python3.1+版本可以使用bit_length方法，查看一個整數所佔的字節長度:
>>> (4).bit_length()
3
>>> (1).bit_length()
1
>>> (2).bit_length()
2
>>> (9999).bit_length()
14
>>> 還有其它的一些數學內置工具和函數，在使用時需要導入模塊，math、random等。他們中都有很多常規的數學運算，比如開方，冪運算等等。
小數數字
在計算機中，浮點數學缺乏精確性。因爲用來存儲數值的空間有限。
>>> 0.1+0.1+0.1
0.30000000000000004
>>> print(0.1+0.1+0.1)
0.30000000000000004
>>> 以上程序的正確結果應該是0.3，用打印結果也不能產生正確的結果，這與硬件相關浮點數運算在精度方面有內在的缺陷。
可以使用python的小數模塊解決該問題：
>>> from decimal import Decimal
>>> Decimal('0.1')+Decimal('0.1')+Decimal('0.1')
Decimal('0.3')
>>> 對於無限的小數，有限的內存無法表示，浮點數的侷限尤爲明顯。分數和小數都提供了得到精確結果的辦法，但是還是要付出速度上的代價。
分數
在python中使用分數時，需要導入模塊：
>>> from fractions import Fraction
>>> x=Fraction(1,3)
>>> x
Fraction(1, 3)
>>> y=Fraction(1,4)
>>> x+y
Fraction(7, 12)
>>> 分數也可以通過一些浮點數來創建：
>>> f=Fraction(0.25)
>>> f
Fraction(1, 4)但是有些情況下浮點數不能總是可以用來創建分數，因爲有些時候，這裏的浮點數表示出來是不精確的：
>>> Fraction(0.33)
Fraction(5944751508129055, 18014398509481984)
>>> Fraction(0.33).limit_denominator(100) #可以限制分母的大小來限制精度，來簡化這樣的效果。
Fraction(33, 100)
>>> Fraction(0.33).limit_denominator(10)
Fraction(1, 3)集合
在python2.4版本中，引入相關的集合概念，它是唯一的，不可變的對象的無序集合。這些對象支持數學上集合概念的相關操作（比如並集，交集等）。
>>> x=set("abcdefg")
>>> y=set("fghijkl")
>>> x={'a','b','c','d','e','f','g'}
>>> y={'f','g','h','i','j','k','l'} #支持兩種聲明方式
>>> x - y
{'a', 'd', 'c', 'b', 'e'}
>>> x | y
{'b', 'a', 'h', 'k', 'l', 'e', 'd', 'j', 'g', 'c', 'i', 'f'}
>>> x & y #效果與 x.intersection(y)一致
{'g', 'f'}
>>> y - x
{'j', 'i', 'h', 'l', 'k'}
>>> x.add('z') #集合中加入元素
>>> x
{'b', 'a', 'e', 'd', 'z', 'g', 'c', 'f'}
>>> 集合作爲一種可迭代的容器。也可以使用循環或者解析這樣的操作：
>>> for i in x :
... print(i)
...
b
a
e
d
z
g
c
f
>>> {i**2 for i in {1,2,3,4,5,6}} # 集合解析
{1, 4, 36, 9, 16, 25}
>>> 集合是一種強大而靈活的工具，但是需要注意的是：集合只能夠包含不可變的對象類型，因此列表和字典不能嵌入到集合中，具有不可變性的數據類型（數字 字符串 元組）都能加入到集合中，所以需要嵌入複合值時，只能嵌入元組來達到目的。集合本身也是不能加入到另一個集合中的，因爲集合是可變的。
集合的使用
集合中的元素具有唯一性，利用這個特點，可以去掉其它類型中，重複的元素。
>>> l=[1,2,3,4,5,6,7,7,7,7,8,8,9,9]
>>> l
[1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 8, 8, 9, 9]
>>> set(l)
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> list(set(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 利用集合的運算達到一些查找共同對象等。
布爾型
Python中的布爾型數據類型，包含了2個值：True和False。它們的值是Python預先定義的內置變量名。實際上僅僅是整數類型上的1和0。內部的定製效果讓布爾型就只是輸出True和False而不是1和0。
>>> type(True)
<class 'bool'>
>>> isinstance(True,int) #True是int實例
True
>>> True==1 #True的值等於1
True
>>> True is 1 #但是True與1並不是同一個對象
False
>>> True + 4
5
>>> Python還有很多其他數字擴展，最廣泛的就是numpy，往往比作爲免費，靈活的matlab。
總結
Python中的數字對象和他們的操作是比較簡單，使用時，需要多多注意浮點數的精度問題，表達式，和類型轉化。