python類內置函數

Ⅰ python中字典的內建函數用法是什麼

字典內置函數&方法
Python字典包含了以下內置函數：
1 cmp(dict1, dict2)
比較兩個字典元素。
2 len(dict)
計算字典元素個數，即鍵的總數。
3 str(dict)
輸出字典可列印的字元串表示。
4 type(variable)
返回輸入的變數類型，如果變數是字典就返回字典類型。

Ⅱ 什麼是Python內置函數

所謂的內置函數，就是Python給你提供的，直接可以拿來使用的函數，比如說print、input等。常見的內置函數如下：
第一、help()函數
Help()函數的參數分為兩種：如果傳一個字元串做參數的話，它會自動搜索以這個字元串命名的模塊、方法等;如果傳入的是一個對象，就會顯示這個對象的類型的幫助。比如輸入help(『print』)，它就會尋找以『print』為名的模塊、類等，找不到就會看到提示信息;而print在Python里是一個保留字，和pass、return同等，而非對象，所以help(print)也會報錯。
第二、dir()函數
dir()函數返回任意對象的屬性和方法列表，包含模塊對象、函數對象、字元串對象、列表對象、字典對象等。盡管查找和導入模塊相對容易，但是記住每個模塊包含什麼卻不是這么簡單，您並不希望總是必須查看源代碼來找出答案。Python提供了一種方法，可以使用內置的dir()函數來檢查模塊的內容，當你為dir()提供一個模塊名的時候，它返回模塊定義的屬性列表。dir()函數適用於所有對象的類型，包含字元串、整數、列表、元組、字典、函數、定製類、類實例和類方法。
第三、input與raw_input函數
都是用於讀取用戶輸入的，不同的是input()函數期望用戶輸入的是一個有效的表達式，而raw_input()函數是將用戶的輸入包裝成一個字元串。
第四、Print()函數
Print在Python3版本之間是作為Python語句使用的，在Python3里print是作為函數使用的。
第五、type()函數
Type()函數返回任意對象的數據類型。在types模塊中列出了可能的數據類型，這對於處理多種數據類型的函數非常有用，它通過返回類型對象來做到這一點，可以將這個類型對象與types模塊中定義類型相比較。

Ⅲ 太全了！Python3常用內置函數總結

數學相關

abs(a) : 求取絕對值。abs(-1)

max(list) : 求取list最大值。max([1,2,3])

min(list) : 求取list最小值。min([1,2,3])

sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6

sorted(list) : 排序，返回排序後的list。

len(list) : list長度,len([1,2,3])

divmod(a,b): 獲取商和余數。 divmod(5,2) >>> (2,1)

pow(a,b) : 獲取乘方數。pow(2,3) >>> 8

round(a,b) : 獲取指定位數的小數。a代表浮點數，b代表要保留的位數。round(3.1415926,2) >>> 3.14

range(a[,b]) : 生成一個a到b的數組,左閉右開。range(1,10) >>> [1,2,3,4,5,6,7,8,9]

類型轉換

int(str) : 轉換為int型。int('1') >>> 1

float(int/str) : 將int型或字元型轉換為浮點型。float('1') >>> 1.0

str(int) : 轉換為字元型。str(1) >>> '1'

bool(int) : 轉換為布爾類型。 str(0) >>> False str(None) >>> False

bytes(str,code) : 接收一個字元串，與所要編碼的格式，返回一個位元組流類型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬蟲', 'utf-8') >>> b'xe7x88xacxe8x99xab'

list(iterable) : 轉換為list。 list((1,2,3)) >>> [1,2,3]

iter(iterable)： 返回一個可迭代的對象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>

dict(iterable) : 轉換為dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}

enumerate(iterable) : 返回一個枚舉對象。

tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) >>>(1,2,3)

set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}

hex(int) : 轉換為16進制。hex(1024) >>> '0x400'

oct(int) : 轉換為8進制。 oct(1024) >>> '0o2000'

bin(int) : 轉換為2進制。 bin(1024) >>> '0b10000000000'

chr(int) : 轉換數字為相應ASCI碼字元。 chr(65) >>> 'A'

ord(str) : 轉換ASCI字元為相應的數字。 ord('A') >>> 65

相關操作

eval****() : 執行一個表達式，或字元串作為運算。 eval('1+1') >>> 2

exec() : 執行python語句。 exec('print("Python")') >>> Python

filter(func, iterable) : 通過判斷函數fun，篩選符合條件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>

map(func, *iterable) : 將func用於每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]

zip(*iterable) : 將iterable分組合並。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]

type()：返回一個對象的類型。

id()： 返回一個對象的唯一標識值。

hash(object)：返回一個對象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780

help()：調用系統內置的幫助系統。

isinstance()：判斷一個對象是否為該類的一個實例。

issubclass()：判斷一個類是否為另一個類的子類。

globals() : 返回當前全局變數的字典。

next(iterator[, default]) : 接收一個迭代器，返回迭代器中的數值，如果設置了default，則當迭代器中的元素遍歷後，輸出default內容。

reversed(sequence) ： 生成一個反轉序列的迭代器。 reversed('abc') >>> ['c','b','a']

Ⅳ 什麼是python的內置函

python的函數有兩種，一種是你問的
內置函數
。另一種是外置函數。
內置函數就是python自帶的函數，像print
int
len這些函數，直接使用就可以。
但是在開發程序的過程中只有這些內置函數是不夠用的。所以需要
程序猿
自己定義函數。
這些自己定義的函數也就是外置函數。

Ⅳ python所有內置函數的定義詳解

1、定義函數

函數是可重用的程序。本書中已經使用了許多內建函數，如len()函數和range()函數，但是還沒自定義過函數。定義函數的語法格式如下：

def 函數名(參數):

函數體

定義函數的規則如下：

①關鍵字def用來定義一個函數，它是define的縮寫。

②函數名是函數的唯一標識，函數名的命名規則遵循標識符的命名規則。

③函數名後面一定要緊跟著一個括弧，括弧內的參數是可選的，括弧後面要有冒號。

④函數體(statement)為一個或一組Python語句，注意要有縮進。

⑤函數體的第一行可以有文檔字元串，用於描述函數的功能，用三引號括起來。

按照定義規則，可以定義第一個函數了：

• >>>defhello_world():

• ...print('Hello,world!')#注意函數體要有縮進

• ...

• >>>hello_world()

• Hello,world!

這個函數不帶任何參數，它的功能是列印出「Hello,world!」。最後一行代碼hello_world()是調用函數，即讓Python執行函數的代碼。

2、全局變數和局部變數

全局變數是定義在所有函數外的變數。例如，定義一個全局變數a，分別在函數test1()和test2()使用變數a：

• >>>a=100#全局變數

• >>>deftest1():

• ...print(a)

• ...

• >>>deftest2():

• ...print(a)

• ...

• >>>test1()

• 100

• >>>test2()

• 100

定義了全局變數a之後，在函數test1()和test2()內都可以使用變數a，由此可知，全局變數的作用范圍是全局。

局部變數是在函數內定義的變數，除了用關鍵字global修飾的變數以外。例如，在函數test1()內定義一個局部變數a，分別在函數外和另一個函數test2()內使用變數a：

• >>>deftest1():

• ...a=100#局部變數

• ...print(a)

• ...

• >>>deftest2():

• ...print(a)

• ...

• >>>test1()

• 100

• >>>print(a)

• Traceback(mostrecentcalllast):

• File"<stdin>",line1,in<mole>

• NameError:name'a'isnotdefined

• >>>test2()

• Traceback(mostrecentcalllast):

• File"<stdin>",line1,in<mole>

• File"<stdin>",line2,intest2

• NameError:name'a'isnotdefined

Python解釋器提示出錯了。由於局部變數a定義在函數test1()內，因此，在函數test1()內可以使用變數a，但是在函數外或者另一個函數test2()內使用變數a，都會報錯，由此可見，局部變數的作用范圍是定義它的函數內部。

一般情況下，在函數內聲明的變數都是局部變數，但是採用關鍵字global修飾的變數卻是全局變數：

• >>>deftest1():

• ...globala#全局變數

• ...a=100

• ...print(a)

• ...

• >>>deftest2():

• ...print(a)

• ...

• >>>test1()

• 100

• >>>print(a)

• 100

• >>>test2()

• 100

這個程序與上個程序相比，只是在函數test1()中多了一行代碼「global a」，程序便可以正確運行了。在函數test1()中，採用關鍵字global修飾了變數a之後，變數a就變成了全局變數，不僅可以在該函數內使用，還可以在函數外或者其他函數內使用。

如果在某個函數內局部變數與全局變數同名，那麼在該函數中局部變數會覆蓋全局變數：

• >>>a=100#全局變數

• >>>deftest1():

• ...a=200#同名局部變數

• ...print(a)

• ...

• >>>deftest2():

• ...print(a)

• ...

• >>>test1()

• 200

• >>>test2()

• 100

由於在函數test1()中定義了一個與全局變數同名的局部變數a，因此，在函數test1()中全局變數a的值被局部變數覆蓋了，但是在函數test2()中全局變數a的值沒有被覆蓋。

綜上所述，在Python中，全局變數保存的數據供整個腳本文件使用;而局部變數只用於臨時保存數據，變數僅供局部代碼塊使用。

Ⅵ python有多少內置函數

Python內置函數有很多，為大家推薦5個神仙級的內置函數：

(1)Lambda函數

用於創建匿名函數，即沒有名稱的函數。它只是一個表達式，函數體比def簡單很多。當我們需要創建一個函數來執行單個操作並且可以在一行中編寫時，就可以用到匿名函數了。

Lamdba的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

利用Lamdba函數，往往可以將代碼簡化許多。

(2)Map函數

會將一個函數映射到一個輸入列表的所有元素上，比如我們先創建了一個函數來返回一個大寫的輸入單詞，然後將此函數應有到列表colors中的所有元素。

我們還可以使用匿名函數lamdba來配合map函數，這樣可以更加精簡。

(3)Rece函數

當需要對一個列表進行一些計算並返回結果時，rece()是個非常有用的函數。舉個例子，當需要計算一個整數列表所有元素的乘積時，即可使用rece函數實現。

它與函數的最大的區別就是，rece()里的映射函數(function)接收兩個參數，而map接收一個參數。

(4)enumerate函數

用於將一個可遍歷的數據對象(如列表、元組或字元串)組合為一個索引序列，同時列出數據和數據下標，一般用在for循環當中。

它的兩個參數，一個是序列、迭代器或其他支持迭代對象;另一個是下標起始位置，默認情況從0開始，也可以自定義計數器的起始編號。

(5)Zip函數

用於將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表

當我們使用zip()函數時，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。

Ⅶ Python 幾個重要的內置函數

在學習Python的過程中，有幾個比較重要的內置函數：help()函數、dir()函數、input()與raw_input()函數、print()函數、type()函數。
第一、help()函數
Help()函數的參數分為兩種：如果傳一個字元串做參數的話，它會自動搜索以這個字元串命名的模塊、方法等;如果傳入的是一個對象，就會顯示這個對象的類型的幫助。比如輸入help(『print』)，它就會尋找以『print』為名的模塊、類等，找不到就會看到提示信息;而print在Python里是一個保留字，和pass、return同等，而非對象，所以help(print)也會報錯。
第二、dir()函數
dir()函數返回任意對象的屬性和方法列表，包含模塊對象、函數對象、字元串對象、列表對象、字典對象等。盡管查找和導入模塊相對容易，但是記住每個模塊包含什麼卻不是這么簡單，您並不希望總是必須查看源代碼來找出答案。Python提供了一種方法，可以使用內置的dir()函數來檢查模塊的內容，當你為dir()提供一個模塊名的時候，它返回模塊定義的屬性列表。dir()函數適用於所有對象的類型，包含字元串、整數、列表、元組、字典、函數、定製類、類實例和類方法。
第三、input與raw_input函數
都是用於讀取用戶輸入的，不同的是input()函數期望用戶輸入的是一個有效的表達式，而raw_input()函數是將用戶的輸入包裝成一個字元串。
第四、Print()函數
Print在Python3版本之間是作為Python語句使用的，在Python3里print是作為函數使用的。
第五、type()函數
Type()函數返回任意對象的數據類型。在types模塊中列出了可能的數據類型，這對於處理多種數據類型的函數非常有用，它通過返回類型對象來做到這一點，可以將這個類型對象與types模塊中定義類型相比較。

Ⅷ Python的函數都有哪些

Python 函數

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。

函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數。

定義一個函數

你可以定義一個由自己想要功能的函數，以下是簡單的規則：

• 函數代碼塊以def關鍵詞開頭，後接函數標識符名稱和圓括弧()。

• 任何傳入參數和自變數必須放在圓括弧中間。圓括弧之間可以用於定義參數。

• 函數的第一行語句可以選擇性地使用文檔字元串—用於存放函數說明。

• 函數內容以冒號起始，並且縮進。

• return [表達式]結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。

語法

def functionname( parameters ): "函數_文檔字元串"
function_suite
return [expression]

默認情況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的。

實例

以下為一個簡單的Python函數，它將一個字元串作為傳入參數，再列印到標准顯示設備上。

實例(Python 2.0+)

def printme( str ): "列印傳入的字元串到標准顯示設備上"
print str
return

函數調用

定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。

這個函數的基本結構完成以後，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。

如下實例調用了printme（）函數：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定義函數def printme( str ): "列印任何傳入的字元串"
print str
return
# 調用函數printme("我要調用用戶自定義函數!")printme("再次調用同一函數")

以上實例輸出結果：

• 我要調用用戶自定義函數!再次調用同一函數



參數傳遞

在 python 中，類型屬於對象，變數是沒有類型的：

a=[1,2,3]
a="Runoob"

以上代碼中，[1,2,3]是 List 類型，"Runoob"是 String 類型，而變數 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。

可更改(mutable)與不可更改(immutable)對象

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。

• 不可變類型：變數賦值a=5後再賦值a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。

• 可變類型：變數賦值la=[1,2,3,4]後再賦值la[2]=5則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。

python 函數的參數傳遞：

• 不可變類型：類似 c++ 的值傳遞，如 整數、字元串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。

• 可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響

python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。

python 傳不可變對象實例

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): a = 10
b = 2ChangeInt(b)print b # 結果是 2

實例中有 int 對象 2，指向它的變數是 b，在傳遞給 ChangeInt 函數時，按傳值的方式復制了變數 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它。

傳可變對象實例

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def changeme( mylist ): "修改傳入的列表"
mylist.append([1,2,3,4])
print "函數內取值: ", mylist
return
# 調用changeme函數mylist = [10,20,30]changeme( mylist )print "函數外取值: ", mylist

實例中傳入函數的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下：

• 函數內取值: [10, 20, 30, [1, 2, 3, 4]]函數外取值: [10, 20, 30, [1, 2, 3, 4]]



參數

以下是調用函數時可使用的正式參數類型：

• 必備參數

• 關鍵字參數

• 默認參數

• 不定長參數

必備參數

必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printme( str ): "列印任何傳入的字元串"
print str
return
#調用printme函數printme()

以上實例輸出結果：

• Traceback (most recent call last):


• File "test.py", line 11, in <mole>


• printme()TypeError: printme() takes exactly 1 argument (0 given)



關鍵字參數

關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。

使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

以下實例在函數 printme() 調用時使用參數名：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printme( str ): "列印任何傳入的字元串"
print str
return
#調用printme函數printme( str = "My string")

以上實例輸出結果：

• My string



下例能將關鍵字參數順序不重要展示得更清楚：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printinfo( name, age ): "列印任何傳入的字元串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數printinfo( age=50, name="miki" )

以上實例輸出結果：

• Name: mikiAge 50



默認參數

調用函數時，默認參數的值如果沒有傳入，則被認為是默認值。下例會列印默認的age，如果age沒有被傳入：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數說明def printinfo( name, age = 35 ): "列印任何傳入的字元串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數printinfo( age=50, name="miki" )printinfo( name="miki" )

以上實例輸出結果：

• Name: mikiAge 50Name: mikiAge 35



不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名。基本語法如下：

def functionname([formal_args,] *var_args_tuple ): "函數_文檔字元串"
function_suite
return [expression]

加了星號（*）的變數名會存放所有未命名的變數參數。不定長參數實例如下：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def printinfo( arg1, *vartuple ): "列印任何傳入的參數"
print "輸出: "
print arg1
for var in vartuple: print var
return
# 調用printinfo 函數printinfo( 10 )printinfo( 70, 60, 50 )

以上實例輸出結果：

• 輸出:10輸出:706050



匿名函數

python 使用 lambda 來創建匿名函數。

• lambda只是一個表達式，函數體比def簡單很多。

• lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

• lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。

• 雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率。

語法

lambda函數的語法只包含一個語句，如下：

• lambda [arg1 [,arg2,.....argn]]:expression



如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數print "相加後的值為 : ", sum( 10, 20 )print "相加後的值為 : ", sum( 20, 20 )

以上實例輸出結果：

• 相加後的值為 : 30相加後的值為 : 40



return 語句

return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示範如何返回數值，下例便告訴你怎麼做：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數說明def sum( arg1, arg2 ): # 返回2個參數的和."
total = arg1 + arg2
print "函數內 : ", total
return total
# 調用sum函數total = sum( 10, 20 )

以上實例輸出結果：

• 函數內 : 30



變數作用域

一個程序的所有的變數並不是在哪個位置都可以訪問的。訪問許可權決定於這個變數是在哪裡賦值的。

• 變數的作用域決定了在哪一部分程序你可以訪問哪個特定的變數名稱。兩種最基本的變數作用域如下：

• 全局變數

• 局部變數

全局變數和局部變數

定義在函數內部的變數擁有一個局部作用域，定義在函數外的擁有全局作用域。

局部變數只能在其被聲明的函數內部訪問，而全局變數可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變數名稱都將被加入到作用域中。如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 這是一個全局變數# 可寫函數說明def sum( arg1, arg2 ): #返回2個參數的和."
total = arg1 + arg2 # total在這里是局部變數.
print "函數內是局部變數 : ", total
return total
#調用sum函數sum( 10, 20 )print "函數外是全局變數 : ", total

以上實例輸出結果：

• 函數內是局部變數 : 30函數外是全局變數 : 0

Ⅸ 什麼是Python的內置函數

python的內置函數可以直接調用,無需import，例如int，str等。可以在python命令行中使用dir(__builtins__)列出查看，參考下圖。

Ⅹ python內置函數什麼用

Python內置函數有很多，下面給你例舉了幾種python3.4版本的內置函數：
1、abx(x)
返回一個數的絕對值。參數可以是普通的整數，長整數或者浮點數。如果參數是個復數，返回它的模
2、all(iterable)
如果iterable的所有元素為真（或者iterable為空）， 返回True。等同於:
def all(iterable):
for element in iterable:
if not element:
return False
return True
3、any(iterable)
如果iterable的任一元素為真，返回True。如果iterable為空，返回False。等同於：
def any(iterable):
for element in iterable:
if element:
return True
return False
4、ascii(object)
這個函數跟repr()函數一樣，返回一個可列印的對象字元串方式表示。當遇到非ASCII碼時，就會輸出\x，\u或\U等字元來表示。與Python 2版本里的repr()是等效的函數。
>>>print(ascii(10), ascii(9000000), ascii('b\31'), ascii('0x\1000'))
10 9000000 'b\x19' '0x@0'
5、bin(x)
將一個整數轉化成一個二進制字元串。結果是一個合法的Python表達式。如果x不是一個Python int對象，它必須定義一個返回整數的__index__()方法
6、bool([x])
將一個值轉化成布爾值，使用標準的真值測試常式。如果x為假或者沒有參數，它返回False；否則它返回True。bool也是一個類，它是int的子類。bool不能被繼承。它唯一的實例就是False和True