python内置数字类型转换函数_Python学习 Day2-2 Python3的基本数据类型、数据内置类型转换函数...
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的基本数据类型、数据内置类型转换函数...的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: labuladong的算法小抄pdf_随
- 下一篇: 阿里工作流引擎_免费开源,一款快速开发模