Python中的基本數據類型講解

  • A+
所屬分類：百科知識

這篇文章介紹了Python中的基本數據類型，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下

一、數據類型分類

1、按存值個數區分

  • 單個值：數字，字符串
  • 多個值(容器)：列表，元組，字典，集合

2、按可變不可變區分

  • 可變：列表[]，字典{}，集合{}
  • 不可變：數字，字符串，元組()、bool，None

3、有序無序區分

  • 有序(可按索引取值)：字符串，列表，元組
  • 無序：字典，集合

二、整型(int)

1
2
3
4
age = 18? # age=int(18)
print(id(age))#<code>4530100848</code>
print(type(age))#<class 'int'>
print(age)#18

1、四種進制表示形式

  • 十進制：1010, 99, -217
  • 二進制，以0b或0B開頭：0b010, -0B101
  • 八進制，以0o或0O開頭：0o123, -0O456
  • 十六進制，以0x或0X開頭：0x9a, –0X89

我們可以使用二進制、十六進制和八進制來代表整數

1
2
3
4
5
6
7
8
9
10
11
number = 0b101011 # 二進制
print(number)
# 43
number = 0xA0F # 十六進制
print(number)
# 2575
number = 0o37? # 八進制
print(number)
# 31

2、int()方法

可將純數字的字符串轉為十進制的整型

int(x):將x變成整數，舍棄小數部分。

1
2
3
4
5
print(int("123"))? # 123
x = int('111')
print(type(x))? # <class 'int'>
# print( int('11.1') ) # 報錯
print(int(123.45))? # 123

3、type和isinstance

內置的type()函數可以用來查詢變量所指的對象類型。

1
2
3
a, b, c, d = 20, 5.5, True, 4 + 3j
print(type(a), type(b), type(c), type(d))
# <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外還可以用isinstance來判斷：

1
2
3
a = 111
isinstance(a, int)
# True

type和isinstance的區別在于：

  • type()不會認為子類是一種父類類型。
  • isinstance()會認為子類是一種父類類型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class A:
????pass
class B(A):
????pass
isinstance(A(), A)
# True
type(A()) == A
# True
isinstance(B(), A)
# True
type(B()) == A
# False

4、對象的創建和刪除

當你指定一個值時，Number對象就會被創建：

1
2
3
var = 2
var_a =
var_b = 10

您可以通過使用del語句刪除單個或多個對象。

del語句的語法是：

del var1[, var2[, var3[...., varN]]]

例如：

1
2
3
del var
del var_a, var_b
print(var) # name 'var' is not defined

4、在交互模式中，最后被輸出的表達式結果被賦值給變量 _

例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price +?_
113.0625
>>> round(_, 2)
113.06

此處， _ 變量應被用戶視為只讀變量。

5、注意：

  • Python可以同時為多個變量賦值，如a, b = 1, 2。
  • 一個變量可以通過賦值指向不同類型的對象。
  • 數值的除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。
  • Python 可以使用 ** 操作來進行冪運算：5 ** 2 表示 5 的平方
  • 在混合計算時，Python會把整型轉換成為浮點數。

注意第3點：// 得到的并不一定是整數類型的數，它與分母分子的數據類型有關系。

1
2
3
4
5
6
print(7 // 2)
# 3
print(7.0 // 2)
# 3.0
print(7 // 2.0)
# 3.0

三、浮點型(float)

1
2
3
4
5
salary = 2.1? # salary=float(2.1)
print(id(salary))#<code>4569240656 </code>
print(type(salary))#<code><class 'float'> </code>
print(salary)# <code>2.1

1、float()方法

將純數字的字符串轉為浮點型數字。

float(x):將x變成浮點數，增加小數部分。

1
2
3
4
5
6
7
8
9
10
11
print(float("1.23"))? # 1.23
x = float('111')
print(x)? # 111.0
print(type(x))? # <class 'float'>
x = float('11.1')
print(x)? # 11.1
print(type(x))? # <class 'float'>
print(float(12))? # 12.0；

2、round（）函數

1.浮點數間運算存在不確定尾數，一般發生在10的16次冪左右
2.round(x, d)函數：對x四舍五入，d是小數截取位數
3.浮點數間運算及比較，用round()函數輔助

1
0.1 + 0.2 == 0.3? # False

round(0.1+0.2, 1) == 0.3?#?True

3、科學計數法

  • 使用字母e或E作為冪的符號，以10為基數，
    格式如下：<a>e<b>，表示?a*10b
  • 例如：4.3e-3?值為0.0043，9.6E5?值為?960000.0

4、數字運算函數

abs(x)：絕對值。x的絕對值。

1
print(abs(-10.01))? # 10.01

divmod(x,y)：商余。(x//y, x%y)，同時輸出商和余數。

1
print(divmod(10, 3))? # (3, 1)

pow(x, y[, z]):冪余。(x**y)%z，[..]表示參數z可省略。

1
2
3
4
print(pow(3, 2))? # 9
print(pow(3, 2, 2))? # 1
print(pow(3, pow(3, 2)))? # 19683
print(pow(3, pow(3, 2), 10000))? # 9683

round(x[, d]):四舍五入。d是保留小數位數，默認值為0。

1
print(round(-10.123, 2))? # -10.12

max(x1,x2,?,xn):最大值。返回x1,x2,?,xnx1,x2,?,xn中的最大值，n不限。

1
print(max(1, 9, 5, 4, 3))? # 9

min(x1,x2,?,xn):最小值。返回x1,x2,?,xnx1,x2,?,xn中的最小值，n不限。

1
print(min(1, 9, 5, 4, 3))? # 1

以下為數學函數，需要導入math模塊

exp(x):返回e的x次冪(ex)

1
2
import math
print(math.exp(1))? # 2.718281828459045

fabs(x):返回數字的絕對值

1
2
import math
print(math.fabs(-10))? # 10.0

ceil(x):返回數字的上入整數

1
2
import math
print(math.ceil(4.1))? # 5

floor(x): 返回數字的下舍整數

1
2
import math
print(math.floor(4.9))? # 4

log(x):返回以e為基數的對象

1
2
3
4
import math
print(math.log(math.e))? # 1.0
print(math.log(100, 10))? # 2.0

log10(x): 返回以10為基數的x的對數

1
2
3
import math
print(math.log10(100))? # 2.0

modf(x):返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。

1
2
import math
print(math.modf(-100.1))? # (-0.09999999999999432, -100.0)

sqrt(x):返回數字x的平方根。

1
2
import math
print(math.sqrt(81))? # 9.0

四、復數型（complex）

a+bj?被稱為復數，其中，a是實部，b是虛部

  • real 獲得實部
  • imag 獲得虛部
1
2
3
z = 1.23e-4 + 5.6e+89j
print(z.real)? # 0.000123
print(z.imag)? # 5.6e+89

1、complex(x):將x變成復數

  • complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0。
  • complex(x, y) 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。
1
print(complex(4))? # (4+0j)

五、布爾型（Bool）

True、False通常情況不會直接引用，需要使用邏輯運算得到結果。

1
2
print(type(True))# <code><class 'bool'></code>
print(True)# True

注意：Python中所有數據類型的值自帶布爾值。

如此多的數據類型中只需要記住只有0、None、空、False的布爾值為False，其余的為True。

1
2
3
4
5
6
7
8
print(bool(0))? # False
print(bool(None))? # False
print(bool(''))? # False
print(bool(False))? # False
print(bool('nick'))? # True
print(bool(1 > 2))? # False
print(bool(1 == 1))? # True

六、字符串(str)

字符串就是一串被串起來的字符，在單引號、雙引號或三引號內包裹的一串字符。同時使用反斜杠 \ 轉義特殊字符。

1
2
3
4
5
name1 = 'nick'
name2 = "egon"
print(id(name1)) # <code>4418849624</code>
print(type(name1))# <class 'str'>
print(name1)# nick

需要注意的是：三引號內的字符可以換行，而單雙引號內的字符不可以。

1
name3 = """nick

egon"""

1
print(name3)
1
2
nick
egon

1、特殊字符串：

  • u'unicode': unicode編碼的字符串
  • b'101': 二進制編碼的字符串

轉義符：

Python 使用反斜杠(\)轉義特殊字符。

1
print("這里有個雙引號(\")")? # 這里有個雙引號(")

轉義符形成一些組合，表達一些不可打印的含義：
\(在行尾時) ：續行符
\\ ：反斜杠符號
\' ：單引號
\" ：雙引號
\a ：響鈴
\b ：退格(Backspace)
\000 ：空
\n ：換行
\v ：縱向制表符
\t ：橫向制表符
\r ：回車(光標移動到本行首)
\f ：換頁
\oyy ：八進制數，yy 代表的字符，例如：\o12 代表換行，其中 o 是字母，不是數字 0。
\xyy :十六進制數，yy代表的字符，例如：\x0a代表換行
\other :其它的字符以普通格式輸出

  • r'\n': 原生字符串，也就是說'\n'這是普通的兩個字符，并沒有換行的意思。
    Python 使用反斜杠(\)轉義特殊字符，如果你不想讓反斜杠發生轉義，可以在字符串前面添加一個 r，表示原始字符串：
1
2
3
4
5
6
print('Ru\noob')
# Ru
# oob
print(r'Ru\noob')
# Ru\noob

注意:

  • Python?沒有單獨的字符類型，一個字符就是長度為1的字符串。
  • 反斜杠(\)可以作為續行符，表示下一行是上一行的延續。
  • Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
  • Python中的字符串不能改變,向一個索引位置賦值，比如word[0] = 'm'會導致錯誤。

2、字符串連接：x+y

連接兩個字符串x和y。如果字符串內有引號，則包裹字符串的引號和字符串內部的引號不能相同。

1
2
3
4
msg2 = "my name is 'nick'"
msg3 = 'my name is "nick"'
print(msg2 + msg3)? # my name is 'nick'my name is "nick"

3、字符串重復：x * n

只能乘以數字。

1
2
name = 'nick '
print(name * 10)# <code>nick nick nick nick nick nick nick nick nick nick

4、字符串比較大小:x>y

按照ASCII碼比較.字符串的比較是字母的順序。

1
2
3
4
5
msg1 = 'hello'
msg2 = 'z'
print(msg1 > msg2) #False
print('Z' > 'A') #True
print('Z' > 'a') #False

5、可以使用str()、hex()、chr()、ord（）方法轉為特殊字符串。

str(x)：任意類型x所對應的字符串形式

1
2
print(str(1.23))? # “1.23”
print(str([1, 2]))? # “[1, 2]”

hex(x)?或?oct(x)：整數x的十六進制或八進制小寫形式字符串：

1
2
print(hex(425))? # "0x1a9"
print(oct(425))? # "0o651"

chr(u)：x為Unicode編碼，返回其對應的字符

ord(x)：x為字符，返回其對應的Unicode編碼

1
2
print(chr(21704))? # "哈"
print(ord('哈'))? # "21704"

6、常用函數：

1、str[n]：按索引取值

1
2
3
4
msg = 'hello nick'
#????? 0123456789? # 索引序號
print(msg[6] ) #索引為6: n
print(msg[-3]) # 索引為-3: i

你可以截取字符串的一部分并與其他字段拼接，如下實例：

1
2
var1 = 'Hello World!'
print("已更新字符串 : ", var1[:6] + 'Runoob!')? # 已更新字符串 :? Hello Runoob!

舉例：輸入整數對應的星期字符串

1
2
3
weekStr = "一二三四五六日"
weekId = eval(input("請輸入星期數字(1-7)："))
print("星期" + weekStr[weekId - 1])? # 7? 星期日

2、str[x:y:step]：切片（顧頭不顧尾，步長） :

遵循左閉右開原則，str[0,2] 是不包含第 3 個字符的。

1
2
3
4
5
6
7
8
9
10
11
12
msg = 'hello_nick'
#????? 0123456789? # 索引序號
print(msg[3:] )? # 切片3-最后: lo_nick
print(msg[3:8])? # 切片3-8: lo_ni
print(msg[3:8:2] )? # 切片3-8，步長為2: l_i
print(msg[3::2])? # 切片3-最后，步長為2: l_ik
# 了解，步長為正，從左到右；步長為負，從右到左
print(msg[:])? # 切片所有: hello_nick
print(msg[::-1] )? # 反轉所有: kcin_olleh
print(msg[-5:-2:1] )? # 切片-5--2: _ni
print(msg[-2:-5:-1] )? # 切片-2--5: cin

3、len:長度

1
2
msg = 'hello nick嗯'
print(len(msg)) # 11

4、in、not in:成員運算

1
2
3
4
5
msg = 'my name is nick, nick handsome'
print('nick' in msg) # True
print('jason' not in msg) # True
print(not 'jason' in msg) # True

5、移除空白

  • 移除左右空白：strip(chars)
  • 移除左空白：?lstrip(chars)
  • 移除右空白：rstrip(chars)
1
2
3
4
5
name = '&&&n ick?????? '
print(name.strip())? # &&&n ick,注意 strip()默認為‘ '
print(name.strip('&'))? # n ick?????? ,strip并且不修改原值，新創建空間
print(name)? # name: &&&n ick?????? ,
print('*-& nick+'.strip('*-& +'))? # nick

6、拆分,split,返回一個列表

  • 拆分：split(str="", num=string.count(str))：以 str 為分隔符截取字符串，如果 num 有指定值，則僅截取 num+1 個子字符串，返回一個列表；
  • 右拆分：rsplit
1
2
3
4
info = 'nick:male:19'
info_list1 = info.split(':')? # ['nick', 'male', '19']
info_list2 = info.split(':', 1)? # ['nick', 'male:19']
print(info.rsplit(':', 1))? # ['nick:male', '19']。 從右開始切割
  • 拆分行：splitlines([keepends])：按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。
1
2
3
4
5
6
info = """aaa
bbb
ccc
"""
print(info.splitlines())? # ['aaa', 'bbb', 'ccc']
print(info.splitlines(True))? # ['aaa\n', 'bbb\n', 'ccc\n']

7、for循環

1
2
msg = 'hello nick'
for i in msg: print(i) # 一個一個字符打印出來

8、大小寫，返回字符串的副本

  • lower：轉成小寫
  • upper：轉成小寫
1
2
3
name = 'Nick Chen'
print(name.lower())? # nick chen
print(name.upper())? # NICK CHEN
  • captalize：將字符串的第一個字符轉換為大寫
  • swapcase：將字符串中大寫轉換為小寫，小寫轉換為大寫
  • title：返回"標題化"的字符串,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle())
1
2
3
4
name = 'nick handsome sWAPCASE'
print(name.capitalize())? # Nick handsome swapcase
print(name.swapcase())? # NICK HANDSOME Swapcase? 大小寫互轉
print(name.title())? # Nick Handsome Swapcase

9、首末字符判斷

  • startswith：首字符判斷
  • endswith：末字符判斷
1
2
3
name = 'Nick Chen'
print(name.startswith('Nick'))? # True
print(name.endswith('chen'))? # False

10、join(seq)：以此字符串作為分隔符，連接字符串。

以指定字符串作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串

1
2
3
4
5
6
7
lis = ['nick', 'male', '19']
print(':'.join(lis))? # nick:male:19
print(",".join("12345"))? # 1,2,3,4,5
str = "-"
seq = ("a", "b", "c")? # 字符串元組
print(str.join(seq))? # a-b-c

11、替換：replace

replace(old, new [, max])：把 將字符串中的 str1 替換成 str2,如果 max 指定，則替換不超過 max 次。

1
2
name = 'nick shuai'
print(name.replace('shuai', 'handsome'))? # nick handsome

12、is***：數據類型判斷

1
2
salary = '111.1'
print(salary.isdigit())? # False
  • isdecimal(): 檢查字符串是否值包含十進制字符，如果是返回True，否則返回False。
  • isdigit(): 如果字符串只包含數字則返回True，否則返回False。
  • isnumeric(): 如果字符串中只包含數字字符，則返回True，否則返回False。
  • isalnum(): 如果字符串所有字符都是字母或數字則返回True，否則返回False。
  • isalpha(): 如果字符串所有字符都是字母則返回True，否則返回False。
  • isupper(): 如果字符串中(區分大小寫的)字符都是大寫，則返回True，否則返回False。
  • islower(): 如果字符串中(區分大小寫的)字符都是小寫，則返回True，否則返回False。
  • isspace(): 如果字符串中只包含空白，則返回True，否則返回False
  • istitle(): 如果字符串是標題類型的(見title())，則返回True，否則返回False。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
num = "1"? # unicode
num.isdigit()? # True
num.isdecimal()? # True
num.isnumeric()? # True
num = "1"? # 全角
num.isdigit()? # True
num.isdecimal()? # True
num.isnumeric()? # True
num = b"1"? # byte
num.isdigit()? # True
num.isdecimal()? # 屬性錯誤 'bytes' object has no attribute 'isdecimal'
num.isnumeric()? # 屬性錯誤 'bytes' object has no attribute 'isnumeric'
num = "IV"? # 羅馬數字
num.isdigit()? # True
num.isdecimal()? # False
num.isnumeric()? # True
num = "四"? # 漢字
num.isdigit()? # False
num.isdecimal()? # False
num.isnumeric()? # True

13、unicodeData

  • 1.unicodedata.lookup()：通過索引中的名稱查找相應的字符
  • 2.unicodedata.name()：通過字符查找名稱，與unicodedata.lookup()相反
  • 4.unicodedata.digit():把一個合法的數字字符串轉換為數字值
  • 3.unicodedata.decimal()：返回表示數字字符的數值
  • 5.unicodedata.numeric():把一個表示數字的字符串轉換為浮點數返回，與unicodedata.digit()不同的是：它可以任意表示數值的字符都可以，不僅僅限于0到9的字符
  • 6.unicodedata.category():把一個字符返回它在UNICODE里分類的類型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import unicodedata
unicodedata.digit("2")? # 2
unicodedata.decimal("2")? # 2
unicodedata.numeric("2")? # 2.0
unicodedata.digit("2")? # 2
unicodedata.decimal("2")? # 2
unicodedata.numeric("2")? # 2.0
unicodedata.digit(b"3")? # TypeError: must be str, not bytes
unicodedata.decimal(b"3")? # TypeError: must be str, not bytes
unicodedata.numeric(b"3")? # TypeError: must be str, not bytes
unicodedata.digit("Ⅷ")? # ValueError: not a digit
unicodedata.decimal("Ⅷ")? # ValueError: not a decimal

unicodedata.numeric("Ⅷ")?#?8.0

1
2
unicodedata.digit("四")? # ValueError: not a digit
unicodedata.decimal("四")? # ValueError: not a decimal

unicodedata.numeric("四")?#?4.0

14、查找：find、 index

  • find(str, beg=0, end=len(string))：檢測 str 是否包含在字符串中。如果指定范圍 beg 和 end ，則檢查是否包含在指定范圍內，如果包含返回開始的索引值，否則返回-1。
  • rfind(str, beg=0,end=len(string))：類似于 find()函數，不過是從右邊開始查找
  • index(str, beg=0, end=len(string))：跟find()方法一樣，只不過如果str不在字符串中會報一個異常
  • rindex：類似于 index()，不過是從右邊開始
  • count(str, beg= 0,end=len(string))：返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數
1
2
3
4
5
6
7
msg = 'my name is tank, tank shi sb, hha'
print(msg.find('tank'))? # 11
print(msg.find('tank', 0, 3))? # -1,找不到返回-1
print(msg.rfind('tank'))? # 17,找不到返回-1
print(msg.index('tank'))? # 11.找不到報錯
print(msg.rindex('tank'))? # 17 找不到報錯
print(msg.count('tank'))? # 2

15、填充

  • center(width[, fillchar])：返回一個原字符串居中對齊,并使用 fillchar 填充至長度。width 的新字符串，fillchar 默認為空格。
  • ljust(width[, fillchar])：返回一個原字符串左對齊,并使用 fillchar 填充至長度。
  • rjust(width[, fillchar])：返回一個原字符串右對齊,并使用空格填充至長度 width 的新字符串。
  • zfill(width)：返回長度為 width 的字符串，原字符串 string 右對齊，前面填充0。
1
2
3
4
print('info nick'.center(20, '*'))? # *****info nick******
print('info nick'.ljust(20, '*'))? # info nick***********
print('info nick'.rjust(20, '*'))? # ***********info nick
print('info nick'.zfill(20))? # 00000000000info nick, 默認用0填充

16、expandtabs(tabsize=8)：把字符串中的 tab 符號轉為空格

tab 符號默認的空格數是 8 。

1
2
print('a\tb\tc\t')? # a??? b??? c??? ,默認制表符8個空格
print('a\tb\tc\t'.expandtabs(10)) # a???????? b???????? c???????? .

17、encode、decode：字符編碼解碼

Python3中字符串默認為Unicode編碼。

str類型的數據可以編碼成其他字符編碼的格式，編碼的結果為bytes類型。

1
2
3
4
5
6
7
# coding:gbk
x = '上'? # 當程序執行時，無需加u，'上'也會被以Unicode形式保存新的內存空間中,
print(type(x))? # <class 'str'>
# x可以直接encode成任意編碼格式
print(x.encode('gbk'))? # b'\xc9\xcf'
print(type(x.encode('gbk')))? # <class 'bytes'>
  • str.encode(encoding='UTF-8',errors='strict')：以 encoding 指定的編碼格式編碼字符串，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'
  • bytes.decode(encoding="utf-8", errors="strict")：解碼給定的 bytes 對象，這個 bytes 對象可以由 str.encode() 來編碼返回。
1
2
3
4
5
6
7
8
a = "asdfasdfffsa師德師風的"
b = a.encode(encoding='UTF-8', errors='strict')
print(type(b))? # <class 'bytes'>
print(b)? # b'asdfasdfffsa\xe5\xb8\x88\xe5\xbe\xb7\xe5\xb8\x88\xe9\xa3\x8e\xe7\x9a\x84'
c = b.decode(encoding="utf-8", errors="strict")
print(type(c))? # <class 'str'>
print(c)? # asdfasdfffsa師德師風的

18、字符串與列表，元組的互相轉換。

1、字符串轉換為列表：for循環

1
2
3
var='菜鳥教程'
list=[]
list= [i for i in var]

2、列表轉化為字符串：使用 join 來實現:

1
var1=' ,'.join(list)

3、字符串轉化為元組，使用 tuple() 函數。

1
tup=tuple(var)

七、其他數據類型

1、分數類型：Fraction

構造函數：

  • class fractions.Fraction(numerator=0, denominator=1)
  • class fractions.Fraction(int|float|str|Decimal|Fraction)

可以同時提供分子（numerator）和分母（denominator）給構造函數用于實例化Fraction類，但兩者必須同時是int類型或者numbers.Rational類型，否則會拋出類型錯誤。當分母為0，初始化的時候會導致拋出異常ZeroDivisionError。

分數類型：

1
2
3
4
5
6
7
8
from fractions import Fraction
x = Fraction(1, 3)
y = Fraction(4, 6)
print(x + y)? # 1
print(1 / 3 + 4 / 6)? # 1.0
print(Fraction('.25'))? # 1/4

浮點數與分數的轉換：

1
2
3
4
5
6
7
8
from fractions import Fraction
f = 2.5
z = Fraction(*f.as_integer_ratio())
print(z)? # 5/2
x = Fraction(1, 3)
print(float(x))? # 0.3333333333333333

2、小數：Decimal類型

decimal 模塊提供了一個 Decimal 數據類型用于浮點數計算，擁有更高的精度。

1
2
3
4
5
6
7
8
import decimal
decimal.localcontext().prec= 4? # 指定精度（4位小數）
print(decimal.Decimal(1) / decimal.Decimal(7))? # 0.1429
with decimal.localcontext() as ctx:? # 小數上下文管理器
????ctx.prec = 2
????print(decimal.Decimal('1.00') / decimal.Decimal('3.00'))? # 0.33

到此這篇關于Python數據類型的文章就介紹到這了。希望對大家的學習有所幫助

歷史上的今天:

推薦應用

發表評論

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: