Python 基本資料型別(一): 數值型別
阿新 • • 發佈：2018-11-21
content
- 整數型int
- 布林型bool
- 浮點型float
- 複數型complex
- 以及上述型別的轉化
一、數值型別
1. 整數型int
（1）整數的定義
# 數學上定義的整數 1 2 -50
# 變數名 = 整數數值
a = 10
print(type(a))
# int
（2）取值範圍
"""
python底層是c語言 int long
python 2.2版本之後，就取消long，直接將整型歸結int
"""
（3）四種進位制
"""
N進位制，逢N進1
1. 二進位制（使用 0b或者0B做字首）
2. 八進位制（使用0o或者0O做字首）
3. 十進位制
4. 十六進位制（使用0x或者0X做字首）
""" （4）四種進位制之間的轉換
"""
1) 十進位制轉換成其他進位制
將x轉換成2進位制？
x=25
使用下除法
被除數：十進位制的數
除數：要轉換成的進位制
取商和餘數，方向，從下往上
"""
"""
2) 其他進位制轉換成十進位制
乘冪法
將y轉換成十進位制
y=0b1100
底數：當前的進位制
冪：從右到左，從0開始計位，當前的位
練習：
（1）x=58 轉換成8進位制，16進位制
（2）y=0b1010，轉換成10進位制 1*2**3+1*2**1=10
底數：當前的進位制 2
冪：從右到左，從0開始計位，當前的位 3 1
""" """
3) 其他進位制之間轉換
*手演算法*
二進位制和八進位制：二進位制的三位對應八進位制的一位
z=0o765
111110101
z=0b10101111111
0o2577
二進位制和十六進位制：二進位制的四位對應十六進位制的一位
z=0x765
011101100101
z=0b10101111111
57f
"""
# *引用函式*
# bin():將數值轉換成二進位制
z=0o765
print(bin(z),type(bin(z)))
# z結果：0b111110101 <class 'str'>
# 注意：python中對於進位制轉換使用的函式，只有int的返回值是數值型別，其他都是str型別 # *關於int的進位制用法print(int(字串,n))*
# 關於int的進位制用法print(int(字串,n))
# 就是將字串看成n進位制的數，進行int轉換
print(int("100",8)) # 可以 將100看成8進位制，做int轉換
print(int("9800",2)) # ValueError: invalid literal for int() with base 2: '9800'
print(int("100")) # 100 因為預設就是十進位制
2. 布林型 bool
# 布林型別是整數型別的子型別
# True False
# 整數型別 0（False） 1（True）
# 定義布林型別
# 變數名=變數值
# 在實際的開發中不要這樣
x=True
print(x,type(x))
print(x+1)
# bool主要的應用：
a=3
b=5
print(a<b)
浮點型 float
（1）浮點的定義
"""
小數 0.1 2.2
python的浮點型別只支援十進位制
變數名=浮點數
# 浮點型別定義時，前面可以加0，整數型別不可以
"""
f=01.1
print(f,type(f))
# 1.1 <class 'float'>
（2）浮點型別的科學計數法
print(1.2E8)
print(1.2e-8)
# 1.2*10**8 120000000.0
# 1.2e-08
（3）取值範圍
# 浮點數是有範圍的
import sys
print(sys.float_info.max)
print(sys.float_info.min)
print(1.2e1001)
# 1.7976931348623157e+308
# 2.2250738585072014e-308
# inf
（4）特殊的浮點數
"""
# inf： 無窮 +inf 無窮大 -inf 無窮小
# nan : 不是一個數字,表示一個數，但是是一個無效的數字
"""
# nan的應用
print(float("inf"),type(float("inf")))
print(float("nan"),type(float("nan")))
a=float("inf")
print(a*0)
print(a/a)
# inf <class 'float'>
# nan <class 'float'>
# nan
# nan
# nan跟誰都不相等
a=float("nan")
b=float("nan")
print(a==b) # False
# math模組中isnan函式可以判斷物件是否是nan
import math
c=1
print(math.isnan(c))
# False
（5）浮點型別的不精確性
# 浮點型別在計算機中是近似儲存
print(1/3)
print(10/3)
# 0.3333333333333333
# 3.3333333333333335
# 為什麼浮點型別不精確？二進位制
# 小數的二進位制規則 ：小數位*2，取整數位，從上到下
# 例子
"""
0.1
0.1*2=0.2 0
0.2*2=0.4 0
0.4*2=0.8 0
0.8*2=1.6 1
0.6*2=1.2 1
0.2*2=0.4 0
原因：小數在計算機中真實的儲存，有可能是無限的二進位制小數。
0.25
0.25*2=0.5 0
0.5*2=1.0 1
"""
# 使用浮點數的時候要注意：
# (1)避免數量級相差很大的浮點數之間進行運算
# 運算的時候無法跨越到下一個數量級
f1=5e20
f2=1
print(f1+f2)
#（2）浮點數避免進行等量判斷
f1=0.1
f2=0.2
print(f1+f2==0.3)
# print(f1+f2)
# 解決浮點型別的不精確性
print(f1)
# 需要使用decimal模組顯示浮點型別的原型
import decimal
print(decimal.Decimal(0.1))
print(decimal.Decimal("inf"))
print(decimal.Decimal("nan"))
print(decimal.Decimal(0.25))
# 0.1000000000000000055511151231257827021181583404541015625
# Infinity
# NaN
# 0.25
# 希望數學0.1+0.2
# 使用字串傳入浮點型別，使得浮點型別變得精確
x=decimal.Decimal("0.1")
y=decimal.Decimal("0.2")
print(x+y)
print(x+y==0.3)
print(x+y==decimal.Decimal("0.3"))
# 0.3
# False
# True
# 慎用，需要佔用記憶體
print(decimal.Decimal(0.1))
#獲得浮點數保留的位數
print(decimal.getcontext().prec)
# 永遠是28位
# 可以自行設定decimal.getcontext().prec保留位數
import decimal
decimal.getcontext().prec=5
x=decimal.Decimal(0.1)
print(x)
# 0.1000000000000000055511151231257827021181583404541015625
y=decimal.Decimal(0.2)
print(y)
# 0.200000000000000011102230246251565404236316680908203125
# 特別注意：只有在參與運算之後才生效。
print(x+y)
# 0.30000
4. 複數型 complex
# 4 === 2**2
# 數學上 實部+虛部 a+bi
# python 實部+虛部j
# 定義： 變數名= 複數
c=2+1j
print(c,type(c))
# (2+1j) <class 'complex'>
# 複數中的實部和虛部都是使用浮點數表示
print(c.real)
print(c.imag)
# 2.0
# 1.0
import cmath
print(cmath.sqrt(-4))
# import math
# print(math.sqrt(-1))
5. 型別轉換
"""
int(value)-----將value轉換成整數型別
float(value)---將value轉換成浮點型別
bool(value)---將value轉換成布林型別
complex(value)---將value轉換成複數型別
"""
i=2
f=-2.0
c=0j
b=True
# (1) int(value)-----將value轉換成整數型別
print(int()) # value如果不寫引數，預設會得到0
print(int(f)) # -2 將浮點型別中的小數部分去掉
# print(int(c)) # 不能將個複數型別轉換成整數型別
print(int(b)) # 1
# (2)float(value)---將value轉換成浮點型別
print(float()) # value如果不寫引數 ，預設得到0.0
print(float(i)) # 2.0
# print(float(c)) # 複數型別也不能轉換成浮點型別
print(float(b)) # 1.0
#（3）bool(value)---將value轉換成布林型別
# 任何一種資料型別都可以轉換成布林型別
# 整數0、浮點0.0、複數0j 對應的布林型別都是False，除此之外都是True
print(bool()) # value如果不寫引數，預設得到False
print(bool(i)) # True
print(bool(c)) # False
print(bool(f)) # True
#（4）complex(value)---將value轉換成複數型別
print(complex()) # 如果value不寫，預設返回是0j
print(complex(i)) # (2+0j)
print(complex(f)) # (-2+0j)
print(complex(b)) # (1+0j)
# 兩種型別之間做運算，結果取級別高的進行儲存
# 複數型別 > 浮點型別> 整數
i=3
f=-2.0
c=0j
b=True
print(i+f) # 1.0
print(c+f) # (-2+0j)