Python3的基本數據類型

Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創建。

在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內存中對象的類型。

等號(=)用來給變量賦值。

等號(=)運算符左邊是一個變量名,等號(=)運算符右邊是存儲在變量中的值。

多個變量賦值

Python允許你同時為多個變量賦值。例如：

a = b = c = 1

以上實例，創建一個整型對象，值為1，三個變量被分配到相同的內存空間上。

您也可以為多個對象指定多個變量。例如：

a, b, c = 1, 2, "runoob"

以上實例，兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "runoob" 分配給變量 c。

標準數據類型

Python3 中有六個標準的數據類型：

Number(數字)

String(字符串)

List(列表)

Tuple(元組)

Sets(集合)

Dictionary(字典)

Number(數字)

Python3 支持?int(整型)、float(雙精度浮點型)、bool(布爾型)、complex(復數)。

在Python 3里，只有一種整數類型 int，表示為長整型，沒有 python2 中的 Long。

像大多數語言一樣，數值類型的賦值和計算都是很直觀的。

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

>>> a, b, c, d = 20, 5.5, True, 4+3j

>>> print(type(a), type(b), type(c), type(d))

此外還可以用 isinstance(isinstance是Python中的一個內建函數。是用來判斷一個對象的變量類型，類似 type()) 來判斷：

>>>a = 111

>>>isinstance(a, int)

True

>>>

isinstance() 與 type() 區別：

type() 不會認為子類是一種父類類型，不考慮繼承關系。

isinstance() 會認為子類是一種父類類型，考慮繼承關系。

如果要判斷兩個類型是否相同推薦使用 isinstance()。

classA:

pass

classB(A):

passisinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

注意：在 Python2 中是沒有布爾型的，它用數字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加。

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

var1 = 1var2 = 10

您也可以使用del語句刪除一些對象引用。

del語句的語法是：

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

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

delvar

del var_a, var_b

數值運算

>>>5 + 4 # 加法

9

>>> 4.3 - 2 # 減法

2.3

>>> 3 * 7 # 乘法

21

>>> 2 / 4 # 除法，得到一個浮點數

0.5

>>> 2 // 4 # 除法，得到一個整數

0

>>> 17 % 3 # 取余

2

>>> 2 ** 5 # 乘方

32

注意：

1、Python可以同時為多個變量賦值，如a, b = 1, 2。

2、一個變量可以通過賦值指向不同類型的對象。

3、數值的除法(/)總是返回一個浮點數，要獲取整數使用//操作符。

4、在混合計算時，Python會把整型轉換成為浮點數。

String(字符串)

Python中的字符串用單引號(')或雙引號(")括起來，同時使用反斜杠(\)轉義特殊字符。

字符串的截取的語法格式如下：

變量[頭下標:尾下標]

索引值以 0 為開始值，-1 為從末尾的開始位置。

加號 (+) 是字符串的連接符， 星號 (*) 表示復制當前字符串，緊跟的數字為復制的次數。實例如下：

#!/usr/bin/python3

str = 'Runoob'

print (str) # 輸出字符串

print (str[0:-1]) # 輸出第一個到倒數第二個的所有字符

print (str[0]) # 輸出字符串第一個字符

print (str[2:5]) # 輸出從第三個開始到第五個的字符

print (str[2:]) # 輸出從第三個開始的后的所有字符

print (str[0:]) # 輸出第一個到最后一個的所有字符

print (str * 2) # 輸出字符串兩次

print (str + "TEST") # 連接字符串

Python 使用反斜杠(\)轉義特殊字符，如果你不想讓反斜杠發生轉義，可以在字符串前面添加一個 r，表示原始字符串：

>>> print('Ru\noob')

Ru

oob

>>> print(r'Ru\noob')

Ru\noob

>>>

另外，反斜杠(\)可以作為續行符，表示下一行是上一行的延續。也可以使用 '''或者?...?跨越多行

>>> a='aaaa'\

... 'bbbbbb'

>>> printa

aaaabbbbbb

>>> a = '''

... 123

... 456

... '''

>>> print(a)

123

456

>>>

(),[],{},'''可以不用續行

>>> b=('bbbbbb'... 'ssssss')

>>> printb

bbbbbbssssss

注意，Python 沒有單獨的字符類型，一個字符就是長度為1的字符串。

與 C 字符串不同的是，Python 字符串不能被改變。向一個索引位置賦值，比如word[0] = 'm'會導致錯誤。

注意：

1、反斜杠可以用來轉義，使用r可以讓反斜杠不發生轉義。

2、字符串可以用+運算符連接在一起，用*運算符重復。

3、Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。

4、Python中的字符串不能改變。

List(列表)

List(列表) 是 Python 中使用最頻繁的數據類型。

列表可以完成大多數集合類的數據結構實現。列表中元素的類型可以不相同，它支持數字，字符串甚至可以包含列表(所謂嵌套)。

列表是寫在方括號([])之間、用逗號分隔開的元素列表。

和字符串一樣，列表同樣可以被索引和截取，列表被截取后返回一個包含所需元素的新列表。

列表截取的語法格式如下：

變量[頭下標:尾下標]

索引值以 0 為開始值，-1 為從末尾的開始位置。

加號(+)是列表連接運算符，星號(*)是重復操作。如下實例：

#!/usr/bin/python3

list= [ 'abcd', 786 , 2.23, 'runoob', 70.2]

tinylist= [123, 'runoob']print (list) #輸出完整列表

print (list[0]) #輸出列表第一個元素

print (list[1:3]) #從第二個開始輸出到第三個元素

print (list[2:]) #輸出從第三個元素開始的所有元素

print (tinylist * 2) #輸出兩次列表

print (list + tinylist) #連接列表

以上實例輸出結果：

['abcd', 786, 2.23, 'runoob', 70.2]

abcd

[786, 2.23]

[2.23, 'runoob', 70.2]

[123, 'runoob', 123, 'runoob']

['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

與Python字符串不一樣的是，列表中的元素是可以改變的：

>>>a = [1, 2, 3, 4, 5, 6]>>> a[0] = 9

>>> a[2:5] = [13, 14, 15]>>>a

[9, 2, 13, 14, 15, 6]>>> a[2:5] = [] #將對應的元素值設置為 []

>>>a

[9, 2, 6]

List內置了有很多方法，例如append()、pop()等等，這在后面會講到。

注意：

1、List寫在方括號之間，元素用逗號隔開。

2、和字符串一樣，list可以被索引和切片。

3、List可以使用+操作符進行拼接。

4、List中的元素是可以改變的。

Tuple(元組)

元組(tuple)與列表類似，不同之處在于元組的元素不能修改。元組寫在小括號(())里，元素之間用逗號隔開。

元組中的元素類型也可以不相同：

#!/usr/bin/python3

tuple= ( 'abcd', 786 , 2.23, 'runoob', 70.2)

tinytuple= (123, 'runoob')print (tuple) #輸出完整元組

print (tuple[0]) #輸出元組的第一個元素

print (tuple[1:3]) #輸出從第二個元素開始到第三個元素

print (tuple[2:]) #輸出從第三個元素開始的所有元素

print (tinytuple * 2) #輸出兩次元組

print (tuple + tinytuple) #連接元組

元組與字符串類似，可以被索引且下標索引從0開始，-1 為從末尾開始的位置。也可以進行截取(看上面，這里不再贅述)。

其實，可以把字符串看作一種特殊的元組。

>>>tup = (1, 2, 3, 4, 5, 6)>>> print(tup[0])1

>>> print(tup[1:5])

(2, 3, 4, 5)>>> tup[0] = 11 #修改元組元素的操作是非法的

Traceback (most recent call last):

File"", line 1, in TypeError:'tuple' object does notsupport item assignment>>>

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

>>> tup = (1,[1,2,3])>>> printtup

(1, [1, 2, 3])>>> tup[1][0]=0>>> printtup

(1, [0, 2, 3])

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = () #空元組

tup2 = (20,) #一個元素，需要在元素后添加逗號

string、list和tuple都屬于sequence(序列)。

注意：

1、與字符串一樣，元組的元素不能修改。

2、元組也可以被索引和切片，方法一樣。

3、注意構造包含0或1個元素的元組的特殊語法規則。

4、元組也可以使用+操作符進行拼接。

Set(集合)

集合(set)是一個無序不重復元素的序列。

基本功能是進行成員關系測試和刪除重復元素。

可以使用大括號?{ }?或者?set()?函數創建集合，注意：創建一個空集合必須用set()?而不是{ }，因為{ }?是用來創建一個空字典。

創建格式：

parame ={value01,value02,...}

或者

set(value)

實例：

#!/usr/bin/python3

student= {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}print(student) #輸出集合，重復的元素被自動去掉

#成員測試

if('Rose' instudent) :print('Rose 在集合中')else:print('Rose 不在集合中')#set可以進行集合運算

a = set('abracadabra')

b= set('alacazam')print(a)print(a - b) #a和b的差集

print(a | b) #a和b的并集

print(a & b) #a和b的交集

print(a ^ b) #a和b中不同時存在的元素

以上實例輸出結果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

Rose 在集合中

{'b', 'a', 'c', 'r', 'd'}

{'b', 'd', 'r'}

{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}

{'a', 'c'}

{'l', 'r', 'z', 'm', 'b', 'd'}

Dictionary(字典)

字典(dictionary)是Python中另一個非常有用的內置數據類型。

列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

字典是一種映射類型，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value)對集合。

鍵(key)必須使用不可變類型。

在同一個字典中，鍵(key)必須是唯一的。

實例：

#!/usr/bin/python3

dict={}

dict['one'] = "1 - 菜鳥教程"dict[2] = "2 - 菜鳥工具"tinydict= {'name': 'runoob','code':1, 'site': 'www.runoob.com'}print (dict['one']) #輸出鍵為 'one' 的值

print (dict[2]) #輸出鍵為 2 的值

print (tinydict) #輸出完整的字典

print (tinydict.keys()) #輸出所有鍵

print (tinydict.values()) #輸出所有值

以上實例輸出結果：

1 -菜鳥教程2 -菜鳥工具

{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}

dict_keys(['name', 'site', 'code'])

dict_values(['runoob', 'www.runoob.com', 1])

構造函數 dict() 可以直接從鍵值對序列中構建字典如下：

實例：

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

{'Taobao': 3, 'Runoob': 1, 'Google': 2}>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}>>> dict(Runoob=1, Google=2, Taobao=3)

{'Taobao': 3, 'Runoob': 1, 'Google': 2}

Python字典的構造函數有三個，dict()、dict(**args)、dict(mapping)

1、dict()構造函數可以返回一個空的字典

>>> d=dict()>>> print(d)

{}

2、dict(**arg)構造函數，傳入參數用賦值表達式，可多個復制表達式，用逗號間隔即可。

>>> d = dict(a=12,b=13,c=15)>>> print(d)

{'a': 12, 'b': 13, 'c': 15}

3、dict(mapping)構造python字典構造函數，怎么傳入這個mapping參數呢？Python下的mapping到底是什么呢？

看下邊這個例子：

deffmap(a, b):return(a, b)

lik= range(1, 11)

liv= list("abcdefghij")print map(fmap, lik, liv)

運行結果如下：

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]

map函數的作用是：每次從可迭代對象(這里是列表lik和liv)取出一個元素值，經過fmap自定義函數的處理后作為新的(返回)列表的元素，故這個map函數的操作方式很像列表解析的概念。

理解了map函數后，便可將返回值作為dict的傳入參數了，從而得到一個字典。

deff_map(a, b):return(a, b)

lik= range(1, 11)

liv= list("abcdefghij")print(dict(map(f_map, lik, liv)))

執行結果如下所示：

{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j'}

以上的實現也用zip來構造一個mapping對象,代碼如下所示：

k = list("abcdefghij")print(k)

v= range(11, 21)print(list(v))print(dict(zip(k, v)))

執行結果如下所示：

['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

{'a': 11, 'b': 12, 'c': 13, 'd': 14, 'e': 15, 'f': 16, 'g': 17, 'h': 18, 'i': 19, 'j': 20}

另外，字典類型也有一些內置的函數，例如clear()、keys()、values()等。

注意：

1、字典是一種映射類型，它的元素是鍵值對。

2、字典的關鍵字必須為不可變類型，且不能重復。

3、創建空字典使用?{ }。

Python數據類型轉換

有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。

以下幾個內置的函數可以執行數據類型之間的轉換。這些函數返回一個新的對象，表示轉換的值。

函數描述

int(x [,base])

將x轉換為一個整數

float(x)

將x轉換到一個浮點數

complex(real [,imag])

創建一個復數

str(x)

將對象 x 轉換為字符串

repr(x)

將對象 x 轉換為表達式字符串

eval(str)

用來計算在字符串中的有效Python表達式,并返回一個對象

tuple(s)

將序列 s 轉換為一個元組

list(s)

將序列 s 轉換為一個列表

set(s)

轉換為可變集合

dict(d)

創建一個字典。d 必須是一個序列 (key,value)元組。

frozenset(s)

轉換為不可變集合

chr(x)

將一個整數轉換為一個字符

ord(x)

將一個字符轉換為它的整數值

hex(x)

將一個整數轉換為一個十六進制字符串

oct(x)

將一個整數轉換為一個八進制字符串

Python?int() 函數

描述

int() 函數用于將一個字符串或數字轉換為整型。

語法

以下是 int() 方法的語法:

class int(x, base=10)

參數

x -- 字符串或數字(字符串必須是能按照進制方式轉換成數字的)。

base -- 進制數，默認十進制。

返回值

返回整型數據。

實例

以下展示了使用 int() 方法的實例：

>>int() #不傳入參數時，得到結果0

0>>> int(3)3

>>> int(3.6)3

>>> int('12',16) #如果是帶參數base的話，12要以字符串的形式進行輸入，12 為 16進制

18

>>> int('0xa',16)10

>>> int('10',8)8

Python float() 函數

描述

float()?函數用于將整數和字符串(必須是可以轉成數字的字符串)轉換成浮點數。

語法

float()方法語法：

class float([x])

參數

x -- 整數或字符串

返回值

返回浮點數。

實例

以下實例展示了 float() 的使用方法：

>>float(1)1.0

>>> float(112)112.0

>>> float(-123.6)-123.6

>>> float('123') #字符串

123.0

Python complex() 函數

描述

complex()?函數用于創建一個值為 real + imag * j 的復數或者轉化一個字符串或數為復數。如果第一個參數為字符串，則不需要指定第二個參數。。

語法

complex 語法：

class complex([real[, imag]])

參數說明：

real -- int, long, float或字符串；

imag -- int, long, float；

返回值

返回一個復數。

實例

以下實例展示了 complex 的使用方法：

>>>complex(1, 2)

(1 + 2j)>>> complex(1) #數字

(1 +0j)>>> complex("1") #當做字符串處理

(1 +0j)#注意：這個地方在"+"號兩邊不能有空格，也就是不能寫成"1 + 2j"，應該是"1+2j"，否則會報錯

>>> complex("1+2j")

(1 + 2j)

Python?str() 函數

描述

str() 函數將對象轉化為適于人閱讀的形式。

語法

以下是 str() 方法的語法:

class str(object='')

參數

object -- 對象。

返回值

返回一個對象的string格式。

實例

以下展示了使用 str() 方法的實例：

>>>s = 'RUNOOB'

>>>str(s)'RUNOOB'

>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};>>>str(dict)"{'google': 'google.com', 'runoob': 'runoob.com'}"

>>>

Python?repr() 函數

描述

repr() 函數將對象轉化為供解釋器讀取的形式。

語法

以下是 repr() 方法的語法:

repr(object)

參數

object -- 對象。

返回值

返回一個對象的 string 格式。

實例

以下展示了使用 repr() 方法的實例：

>>>s = 'RUNOOB'

>>>repr(s)"'RUNOOB'"

>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};>>>repr(dict)"{'google': 'google.com', 'runoob': 'runoob.com'}"

>>>

Python?eval() 函數

描述

eval() 函數用來執行一個字符串表達式，并返回表達式的值。官方文檔里面給出來的功能解釋是：將字符串string對象轉化為有效的表達式參與求值運算返回計算結果。

語法

以下是 eval() 方法的語法:

eval(expression[, globals[, locals]])

參數

expression -- 表達式(是一個參與計算的python表達式)。

globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象(可選，必須是dictionary)。

locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象(可選，任意map對象)。

返回值

返回表達式計算結果。

實例

以下展示了使用 eval() 方法的實例：

>>>x = 7

>>> eval( '3 * x')21

>>> eval('pow(2,2)') #pow()?方法返回 xy(x的y次方) 的值。4

>>> eval('2 + 2')4

>>> n=81

>>> eval("n + 4")85

可以把list,tuple,dict和string相互轉化。#################################################

字符串轉換成列表>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"

>>>type(a)

>>> b =eval(a)>>> printb

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]>>>type(b)

#################################################

字符串轉換成字典>>> a = "{1: 'a', 2: 'b'}"

>>>type(a)

>>> b =eval(a)>>> printb

{1: 'a', 2: 'b'}>>>type(b)

#################################################

字符串轉換成元組>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"

>>>type(a)

>>> b =eval(a)>>> printb

([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))>>>type(b)

eval() 函數擴展

python是用命名空間來記錄變量的軌跡的，命名空間是一個dictionary，鍵是變量名，值是變量值。

當一行代碼要使用變量?x?的值時，Python?會到所有可用的名字空間去查找變量，按照如下順序:

1)局部名字空間 - 特指當前函數或類的方法。如果函數定義了一個局部變量?x, 或一個參數?x，Python?將使用它，然后停止搜索。

2)全局名字空間 - 特指當前的模塊。如果模塊定義了一個名為?x?的變量，函數或類，Python?將使用它然后停止搜索。

3)內置名字空間 - 對每個模塊都是全局的。作為最后的嘗試，Python?將假設?x?是內置函數或變量。

python的全局名字空間存儲在一個叫globals()的dict對象中；局部名字空間存儲在一個叫locals()的dict對象中。我們可以用print (locals())來查看該函數體內的所有變量名和變量值。

eval()使用原因：

1)在編譯語言里要動態地產生代碼，基本上是不可能的，但動態語言是可以，意味著軟件已經部署到服務器上了，但只要作很少的更改，只好直接修改這部分的代碼，就可立即實現變化，不用整個軟件重新加載。

2)在machin learning里根據用戶使用這個軟件頻率，以及方式，可動態地修改代碼，適應用戶的變化。

實例：

a=1g={'a':20}

eval("a+1",g)

返回21

#test eval() and locals()

x = 1y= 1num1= eval("x+y")print(num1)defg():

x= 2y= 2num3= eval("x+y")print(num3)

num2= eval("x+y",globals())#num2 = eval("x+y",globals(),locals())

print(num2)

g()print locals()["x"]print locals()["y"]print globals()["x"]print globals()["y"]

num1的值是2；num3的值也很好理解，是4；num2的值呢？由于提供了globals()參數，那么首先應當找全局的x和y值，也就是都為1，那么顯而易見，num2的值也是2。如果注釋掉該句，執行下面一句呢？根據第3)點可知，結果為4

locals()對象的值不能修改，globals()對象的值可以修改

#test globals() and locals()

z=0deff():

z= 1

print(locals())

locals()["z"] = 2

print(locals())

f()

globals()["z"] = 2

print (z)

可以得出，兩個print (locals())的結果是一樣的，說明沒有修改成功。而print (z)的值是2，說明修改成功了

eval()?安全性問題

eval有安全性問題,比如用戶惡意輸入就會獲得當前目錄文件

eval("__import__('os').system('dir')")

>>> importos>>> 'os' inglobals()

True>>> os.system('whoami')

root

0

怎么避免安全問題？

1、自行寫檢查函數；

2、使用ast.literal_eval

一般來說Python的eval()函數可以把字符串“123”變成數字類型的123，但是PP3E上說它很危險，還可以執行其他命令！

對此進行一些試驗。果然，如果python寫的cgi程序中如果使用eval()而非int()來轉換諸如年齡這樣的輸入框中的內容時是非常危險的。不僅可以看見列出系統的全部文件，還可以執行刪除文件，察看文件源代碼等危險操作！

網頁里有一個提交名字的窗口，這里只是以改它為例，否則名字是不會用eval函數轉換的，不過年齡到是很容易出問題。這個文件(http://localhost/tutor4.html)導入了os。

line1 = "Hello, %s." % eval(form['user'].value)

(1)刪除當前目錄下所有文件

os.system('del * /q') #刪除當前目錄下所有文件(不包括文件夾)。

os.system調用當前系統的命令(如windows)

/q ?指定強制狀態。不提示您確認刪除。

(2)若刪除文件夾，使用rmdir

os.system('rmdir d:/workspace /s/q')

/s ?刪除指定目錄和所有子目錄以及包含的所有文件。使用 /s 來刪除目錄樹。

/q ?在安靜模式中運行 rmdir。不經確認即刪除目錄。

(3)列出所有文件os.system('dir')。因為成功執行了dir命令后，系統返回0，所以看到的返回內容只能是Hello,0.而在服務器上，倒是真的列出來了，如果有日志，可能被發現。提交os.system('dir >dir.txt')，那么訪問http://localhost/dir.txt那么所有的文件和文件夾都暴露了，想看源代碼嗎？如果再使用os.system('type target.py').命令如果成功完成同樣會返回Hello, 0.的。難道再放進一個文件，再訪問那個文件嗎？open('target.py').read()

由此，可以在列出和察看其他文件夾里面的內容了。

如果沒干別的壞事，那么可刪除dir.txt以免被人發現了。os.system('del dir.txt /q')

導入os并執行命令：

__import__('os').system('dir >dir.txt')

Python3?tuple 函數

描述

tuple 函數將列表轉換為元組。

語法

以下是 tuple 的語法:

tuple( seq )

參數

seq -- 要轉換為元組的序列。

返回值

返回元組。

實例

以下展示了使用 tuple 的實例：

>>>list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>>tuple1

('Google', 'Taobao', 'Runoob', 'Baidu')

Python3 List list()方法

描述

list() 方法用于將元組轉換為列表。

注：元組與列表是非常類似的，區別在于元組的元素值不能修改，元組是放在括號中，列表是放于方括號中。

語法

list()方法語法：

list( seq )

參數

list -- 要轉換為列表的元組。

返回值

返回列表。

實例

以下實例展示了 list()函數的使用方法：

#!/usr/bin/python3

aTuple= (123, 'Google', 'Runoob', 'Taobao')

list1=list(aTuple)print ("列表元素 :", list1)

str="Hello World" #字符串可以看作是元組list2=list(str)print ("列表元素 :", list2)

以上實例輸出結果如下：

列表元素 : [123, 'Google', 'Runoob', 'Taobao']

列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

Python set() 函數

描述

set()?函數創建一個無序不重復元素集，可進行關系測試，刪除重復數據，還可以計算交集、差集、并集等。

語法

set 語法：

class set([iterable])

參數說明：

iterable -- 可迭代對象對象；

返回值

返回新的集合對象。

實例

以下實例展示了 set 的使用方法：

>>>x = set('runoob')>>> y = set('google')>>>x, y

(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) #重復的被刪除

>>> x & y #交集

set(['o'])>>> x | y #并集

set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])>>> x - y #差集

set(['r', 'b', 'u', 'n'])>>>

Python dict() 函數

描述

dict()?函數用于創建一個字典。

語法

dict 語法：

class dict(**kwarg)class dict(mapping, **kwarg)class dict(iterable, **kwarg)

參數說明：

**kwargs -- 關鍵字

mapping -- 元素的容器。

iterable -- 可迭代對象。

返回值

返回一個字典。

實例

以下實例展示了 dict 的使用方法：

>>>dict() #創建空字典

{}>>> dict(a='a', b='b', t='t') #傳入關鍵字

{'a': 'a', 'b': 'b', 't': 't'}>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) #映射函數方式來構造字典

{'three': 3, 'two': 2, 'one': 1}>>> dict([('one', 1), ('two', 2), ('three', 3)]) #可迭代對象方式來構造字典

{'three': 3, 'two': 2, 'one': 1}

Python frozenset() 函數

描述

frozenset()?返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。

語法

frozenset() 函數語法：

class frozenset([iterable])

參數

iterable --可迭代的對象，比如列表、字典、元組等等。

返回值

返回新的 frozenset 對象，如果不提供任何參數，默認會生成空集合。

實例

以下實例展示了 frozenset() 的使用方法：

>>>a = frozenset(range(10)) #生成一個新的不可變集合

>>>a

frozenset([0,1, 2, 3, 4, 5, 6, 7, 8, 9])>>> b = frozenset('runoob')>>>b

frozenset(['b', 'r', 'u', 'o', 'n']) #創建不可變集合

Python?chr() 函數

描述

chr() 用一個范圍在 range(256)內的(就是0～255)整數作參數，返回一個對應的字符。

語法

以下是 chr() 方法的語法:

chr(i)

參數

i -- 可以是10進制也可以是16進制的形式的數字。

返回值

返回值是當前整數對應的ascii字符。

實例

以下展示了使用 chr() 方法的實例：

>>>print chr(0x30), chr(0x31), chr(0x61) #十六進制

0 1a>>> print chr(48), chr(49), chr(97) #十進制

0 1 a

Python?ord() 函數

描述

ord() 函數是 chr() 函數(對于8位的ASCII字符串)或 unichr() 函數(對于Unicode對象)的配對函數，它以一個字符(長度為1的字符串)作為參數，返回對應的 ASCII 數值，或者 Unicode 數值，如果所給的 Unicode 字符超出了你的 Python 定義范圍，則會引發一個 TypeError 的異常。

語法

以下是 ord() 方法的語法:

ord(c)

參數

c -- 字符。

返回值

返回值是對應的十進制整數。

實例

以下展示了使用 ord() 方法的實例：

>>>ord('a')97

>>> ord('b')98

>>> ord('c')99

Python hex() 函數

描述

hex()?函數用于將10進制整數轉換成16進制，以字符串形式表示。

語法

hex 語法：

hex(x)

參數說明：

x -- 10進制整數

返回值

返回16進制數，以字符串形式表示。

實例

以下實例展示了 hex 的使用方法：

>>>hex(255)'0xff'

>>> hex(-42)'-0x2a'

>>> hex(1L)'0x1L'

>>> hex(12)'0xc'

>>> type(hex(12)) #字符串

Python oct() 函數

描述

oct()?函數將一個整數轉換成8進制字符串。

語法

oct 語法：

oct(x)

參數說明：

x -- 整數。

返回值

返回8進制字符串。

實例

以下實例展示了 oct 的使用方法：

>>>oct(10)'012'

>>> oct(20)'024'

>>> oct(15)'017'

總結

以上是生活随笔為你收集整理的python内置数字类型转换函数_Python学习 Day2-2 Python3的基本数据类型、数据内置类型转换函数...的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。