腳本之家服務器常用軟件

快捷導航

Python變量、數(shù)據(jù)類型、數(shù)據(jù)類型轉換相關函數(shù)用法實例詳解

更新時間：2020年01月09日 09:48:19 作者：隨風行云

這篇文章主要介紹了Python變量、數(shù)據(jù)類型、數(shù)據(jù)類型轉換相關函數(shù)用法,結合實例形式詳細分析了Python變量類型、基本用法、變量類型轉換相關函數(shù)與使用技巧,需要的朋友可以參考下

本文實例講述了Python變量、數(shù)據(jù)類型、數(shù)據(jù)類型轉換相關函數(shù)用法。分享給大家供大家參考，具體如下：

python變量的使用不需要進行類型聲明（類型名變量名），給一個變量名賦什么值就是什么類型。

變量的賦值使用 =

說明：雖然python聲明變量時沒有一個類型來圈注，但它并不是弱類型語言，相反，它是一門強類型語言。

弱類型的語言的東西沒有明顯的類型，它能隨著環(huán)境的不同自動變換類型；
而強類型則沒這樣的規(guī)定，不同類型間的操作有嚴格定義，只有相同類型的變量才能操作

為什么說 Python 是強類型語言

Python變量命名規(guī)則：

變量名只能是字母、數(shù)字或下劃線的任意組合
變量名的第一個字符不能是數(shù)字
不能與關鍵字重名（關鍵字用著用著就記熟了）

數(shù)據(jù)類型

整數(shù)int類型：

python3中移除了python2中的long

Python3中沒有限制int數(shù)值的大小

可以用其他數(shù)制來表示數(shù)值：二進制是以0b開頭的，8進制是以0O(第二個是英文o，大小寫都可以)開頭的，16進制是以0x開頭的

>>> i=0b1111
>>> print(i)
15
>>> i=0x0010
>>> print(i)
16
>>> i=0o0010
>>> print(i)
8
>>> i=0O0010
>>> print(i)
8

小數(shù)float類型：

可以用小數(shù)表示：3.1415，1.5，.......
也可以用科學計數(shù)法表示（10用e替代，比如0.000012可以寫成 1.2e-5)

>>> a=1.5
>>> print(a)
1.5
>>> a=-9999.5
>>> print(a)
-9999.5
>>> a=1.5e5
>>> print(a)
150000.0
>>> a=1.5e-10
>>> print(a)
1.5e-10
>>> a=0.0000000000000001
>>> print(a)
1e-16

注：對于太小的數(shù)，會自動轉化成科學計數(shù)法表示，太大的數(shù)不會自動轉化

布爾bool類型：True、False

使用True和False兩個關鍵字來表示布爾類型
可以使用非零數(shù)值表示True,但總覺得這是一個不好的習慣

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>
>>> a=bool(2)
>>> a
True
>>> a=int(True)
>>> a
1
>>> print(int(False))
0

字符串str類型：

Python不支持字符類型; 字符會被視為長度為 1的字符串
可以使用兩個單引號，或兩個雙引號來代表字符串

>>> type("aaaa")
<class 'str'>
>>> type('aaaa')
<class 'str'>

可以使用下標來訪問字符串的值【-1代表最后一位】：

>>> str1="123"
>>> str1[0]
'1'
>>> str1[-1]
'3'

可以對字符串進行切片（切片方法:字符串名[左下標:右下標（不取到右下標）]）,返回值是切片后的字符串，但并不會改變原字符串的值

【 [:]代表完全切片，[:右下標]代表從零開始，[左下邊:]代表結尾是最后一位，-1下標代表最后一位】

【切片也可以有間隔，用法字符串名[左下標:右下標:間隔] 】

>>> hello="hello world!"
>>> new_hello=hello[:]
>>> new_hello
'hello world!'
>>> hello[:2]
'he'
>>> hello[1:3]
'el'
>>> hello[1:-1]
'ello world'

>>> hello[1:-1:1]
'ello world'
>>> hello[1:-1:2]
'el ol'

可以使用三引號（單引號或雙引號）來代表多行字符串

>>> type("""hahah
haha
hahah""")
<class 'str'>
>>> type('''第一行
第二行
第三行''')
<class 'str'>

列表list類型：

list是一種有序的集合，可以隨時添加和刪除其中的元素。
使用中括號包裹元素，表明這是一個列表。[元素,元素,元素,.......]

>>> i=['a',100,True]
>>> type(i)
<class 'list'>

列表的元素不限定數(shù)據(jù)類型，可以是字符串，可以是數(shù)值，可以是布爾類型，也可以是其他列表等等
列表可以是空的：list1=[]
可以使用list函數(shù)來創(chuàng)建列表

>>> list("abcd")
['a', 'b', 'c', 'd']

列表也可以使用下標來訪問元素，也可以切片，操作與字符串相同。
列表可以替換元素【使用 = 】：

>>> i
['a', 100, True]
>>> i[0]='b'
>>> i
['b', 100, True]

如果列表中包含列表時，如果要取子列表中的元素，相當于操作“二維數(shù)組”，使用列表名[索引][索引]:

>>> i
['b', 100, True]
>>> l=[i,"helloworld"]
>>> l
[['b', 100, True], 'helloworld']
>>> l[0][0]
'b'

可以使用“+”拼接列表，使用*重復列表

>>> l2=i*2
>>> l2
['b', 100, True, 'b', 100, True]
>>> l3=i+l
>>> l3
['b', 100, True, ['b', 100, True], 'helloworld']

列表常用函數(shù):補充
列表生成式：補充

元組tuple類型：

使用()跟,來表示元組，當tuple中只有一個元素時，逗號可以特別的說明這是一個tuple，實際上，python也允許tuple定義時沒有括號

>>> t1=('a',1,True)
>>> type(t1)
<class 'tuple'>
>>> t2=('a')
>>> type(t2)
<class 'str'>
>>> ####注意上面的類型###
>>> t3=('a',)
>>> type(t3)
<class 'tuple'>

>>> tuple2=1,2,3,4,5
>>> type(tuple2)
<class 'tuple'>
>>> tuple2
(1, 2, 3, 4, 5)

有序列表叫元組,tuple的元素一旦初始化就不能修改，但可以存儲list，因為tuple并不會復制一份list到自己的內存中，它只會存儲list的內存指向，只要list的內存指向不變，就不跟tuple的不變原則沖突。

>>> t1=('a',i)
>>> t1
('a', ['b', 100, True])
>>> id(t1[1])
1673650817160
>>> id(i)
1673650817160

tuple也可以可以使用下標來訪問元素，也可以切片，操作與字符串相同。
元組可以為空

元組常用函數(shù)

tuple一旦初始化就不能修改，所以它沒有append()、insert(),也沒有pop()等能增刪元素的方法

>>> tuple1=(1,2,3,4)
>>> print(tuple1.index(2))#查找指定元素的下標
1
>>> print(tuple1.count(2))#查找某元素存在的數(shù)量
1

字典dict類型：

使用鍵-值（key-value）存儲
由于其哈希特性，因此具有極快的查找速度
可以使用{鍵1:值1,鍵2:值2,鍵3:值3 ...}來定義一個字典

>>> d1={'a':'apple','b':'banana','c':'cabbage'}
>>> type(d1)
<class 'dict'>

字典是使用哈希算法來計算對應對應值的位置的，所以key必須是固定不可變的，在Python中，字符串、整數(shù)等都是不可變的，所以，可以作為key。其余元素可變的對象如list、set、dict就不能作為key，因為其元素結果不確定，無法確定哈希值。

>>> l1=['a']
>>> d1[l1]='c'
Traceback (most recent call last):
 File "<pyshell#5>", line 1, in <module>
  d1[l1]='c'
TypeError: unhashable type: 'list'

dict內部存放的順序和key放入的順序是沒有關系的
可以使用字典名[鍵] 快速查找出對應的值，鍵不存在則無法查找

>>> d1
{'a': 'apple', 'b': 'banana', 'c': 'cabbage', ('a',): 'c'}
>>> d1['a']
'apple'
>>> d1['d']
Traceback (most recent call last):
 File "<pyshell#17>", line 1, in <module>
  d1['d']
KeyError: 'd'

可以給某一個鍵的對應的值重新賦值，但由于一個key只能對應一個value，所以新的賦值會把就得值覆蓋掉【如果定義的時候出現(xiàn)多個同名的鍵，這個鍵的值以最后的賦值為準】

>>> d1
{'a': 'apple', 'b': 'banana', 'c': 'cabbage', ('a',): 'c'}
>>> d1['a']='apple pen'
>>> d1
{'a': 'apple pen', 'b': 'banana', 'c': 'cabbage', ('a',): 'c'}

可以使用字典名[一個未使用的鍵]=值來添加一個鍵值對：

>>> d1
{'a': 'apple pen', 'b': 'banana', 'c': 'cabbage', ('a',): 'c'}
>>> d1['ai']='python'
>>> d1
{'a': 'apple pen', 'b': 'banana', 'c': 'cabbage', ('a',): 'c', 'ai': 'python'}

注：直接迭代字典，只能迭代出key

>>> dict10={1:"蘋果","雪碧":"雪梨"}
>>> 
>>> for i in dict10:
  print(i)
1
雪碧

使用字典名[key] 獲取不存在的鍵時會拋出異常KeyError，可以使用成員運算符來避免或使用get()來避免

>>> dict10
{1: '蘋果', '雪碧': '雪梨'}
>>> 1 in dict10
True
>>> 3 in dict10
False
>>> print(dict10.get(3))
None
>>> print(dict10.get(1))
蘋果

字典常用函數(shù):補充

集合類型：

set和dict類似，也是使用大括號包裹
可以使用大括號來定義一個集合

>>> s1={'a','b','c'}
>>> s1
{'b', 'c', 'a'}
>>> type(s1)
<class 'set'>

可以使用set來定義一個集合，set函數(shù)的參數(shù)為一個可迭代對象(Iterable)

>>> s2=set()
>>> type(s2)
<class 'set'>
>>> s3=set(['a','b','c'])
>>> type(s3)
<class 'set'>

image_5a71b783_2fb0

image_5a71b783_40a0

set不能使用下標來取出元素
set的原理和dict一樣，所以，同樣不可以放入可變對象,因為它也是使用哈希來計算計算結果的，可以記作set與dict不同的是它只存儲key，不存儲value【set()函數(shù)傳入一個字典作為參數(shù)時，只取key作為結果】

>>> s3.add(['cbd'])
Traceback (most recent call last):
 File "<pyshell#37>", line 1, in <module>
  s3.add(['cbd'])
TypeError: unhashable type: 'list'

集合的常用函數(shù)：補充

數(shù)據(jù)類型轉換相關函數(shù)：

int()函數(shù)可以把其他數(shù)據(jù)類型轉換為整數(shù)：
float( )函數(shù)可以把其他數(shù)據(jù)類型轉換成浮點數(shù)
str( )函數(shù)可以把其他數(shù)據(jù)類型轉換成字符串類型
bool( )函數(shù)可以把其他數(shù)據(jù)類型轉換成布爾類型
tuple()將其他數(shù)據(jù)類型轉換為元組。
set()將其他數(shù)據(jù)類型轉換為集合。

>>> print(type(int("123")))
<class 'int'>
>>> print(type(float("123")))
<class 'float'>
>>> float("123")
123.0
>>> str(123)
'123'
>>> bool(2)
True
>>> list("123")
['1', '2', '3']
>>> tuple("123")
('1', '2', '3')

注：轉換是有規(guī)則的，要符合規(guī)則才能轉化，比如int()不能轉換"abc"