Python3 基本數據類型

本文轉載自查看原文 2017-12-19 10:12 3282 python（3.6.x）

Python3 基本數據類型

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

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

等號（=）用來給變量賦值。

等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：

實例(Python 3.0+)

以下實例均要保存為 .py 文件

#!/usr/bin/python3
 
counter = 100          # 整型變量
miles   = 1000.0       # 浮點型變量
name    = "runoob"     # 字符串
 
print (counter)
print (miles)
print (name)

執行以上程序會輸出如下結果：

100
1000.0
runoob

多個變量賦值

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

a = b = c = 1; print(a,b,c);

以上實例，創建一個整型對象，值為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))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外還可以用 isinstance 來判斷：

實例

>>>a = 111 >>> isinstance(a, int) True >>>

isinstance 和 type 的區別在於：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

區別就是:

type()不會認為子類是一種父類類型。
isinstance()會認為子類是一種父類類型。

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

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

var1 = 1
var2 = 10

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

del語句的語法是：

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

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

del var
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會把整型轉換成為浮點數。

數值類型實例

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3e+18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

Python還支持復數，復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示，復數的實部a和虛部b都是浮點型

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 * 2)      # 輸出字符串兩次
print (str + "TEST") # 連接字符串

執行以上程序會輸出如下結果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

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

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

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

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

實例

>>>word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

與 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) # 連接元組

以上實例輸出結果：

('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')

元組與字符串類似，可以被索引且下標索引從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 "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

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

構造包含 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' in student) :
    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}

另外，字典類型也有一些內置的函數，例如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)	將一個整數轉換為一個字符
unichr(x)	將一個整數轉換為Unicode字符
ord(x)	將一個字符轉換為它的整數值
hex(x)	將一個整數轉換為一個十六進制字符串
oct(x)	將一個整數轉換為一個八進制字符串

元組（小拓展）

一般來說，函數的返回值一般為一個。

而函數返回多個值的時候，是以元組的方式返回的。

示例（命令行下）：
```
>>>def example(a,b):
...     return (a,b)
...
>>>type(example(3,4))
<class 'tuple'>
>>>
```
python中的函數還可以接收可變長參數，比如以 "*" 開頭的的參數名，會將所有的參數收集到一個元組上。

例如：
```
def test(*args):
    print(args)
    return args

print(type(test(1,2,3,4)))    #可以看見其函數的返回值是一個元組
```
字典（小拓展）

python中的字典是使用了一個稱為散列表（hashtable）的算法（不具體展開），

其特點就是：不管字典中有多少項，in操作符花費的時間都差不多。

如果把一個字典對象作為for的迭代對象，那么這個操作將會遍歷字典的鍵：
```
def example(d):
    # d 是一個字典對象
    for c in d:
        print(c)
        #如果調用函數試試的話，會發現函數會將d的所有鍵打印出來;
        #也就是遍歷的是d的鍵，而不是值.
```
針對樓上的字典拓展，做測試的時候，想要輸出 kye:value的組合發現可以這樣：
```
for c in dict:
    print(c,':',dict[c])
或者

for c in dict:
    print(c,end=':');
    print(dict[c])
```
於是發現 print()函數其實可以添加多個參數，用逗號隔開。

本來想要用
```
for c in dict:
    print(c+':');
    print(dict[c])
```
這樣的方式打印 key：value結果發現其實 key不一定是 string類型，所以用+ 號會出問題。
在list的使用中，開始時很容易忽視的一點是：
```
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[1:3])       # 從第二個開始輸出到第三個元素
```
list[1:3] 其實輸出的只有兩個變量，即list中第二個元素到第三個元素，並不是第1 第2 第3三個元素，而且要注意的是
```
print (list[2])
print (list[2:3])
```
這兩句話打印的內容其實是一樣的，
```
2.23
[2.23]
```
但是第二句話有中括號
python 與 C 語言和 Java 語言的一點不同，表現在它的變量不需要聲明變量類型，這是因為像 C 語言和 Java 語言來說，它們是靜態的，而 python 是動態的，變量的類型由賦予它的值來決定，例如：
```
>>> a = 1
>>> a = 1.001
>>> a = "python"
>>> print(a)
python
>>>
```
第一次為變量 a 賦值為整型，第二次賦值是浮點數，第三次是一個字符串，最后輸出時只保留了最后一次的賦值。
參考地址
type 是用於求一個未知數據類型對象，而 isinstance 是用於判斷一個對象是否是已知類型。

type 不認為子類是父類的一種類型，而isinstance會認為子類是父類的一種類型。

可以用 isinstance 判斷子類對象是否繼承於父類，type 不行。

綜合以上幾點，type 與 isinstance 雖然都與數據類型相關，但兩者其實用法不同，type 主要用於判斷未知數據類型，isinstance 主要用於判斷 A 類是否繼承於 B 類：
```
# 判斷子類對象是否繼承於父類
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))
```
運行結果：
```
False
True
<class '__main__.son'>
<type 'type'>
```

字典（小拓展）

輸入 dict 的鍵值對，可直接用 items() 函數：

dict1 = {'abc':1,"cde":2,"d":4,"c":567,"d":"key1"}
for k,v in dict1.items():
    print(k,":",v)

字典（小拓展）

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

其實d不一定必須為一個序列元組，如下：

>>> dict_1 = dict([('a',1),('b',2),('c',3)]) #元素為元組的列表
>>> dict_1
{'a': 1, 'b': 2, 'c': 3}
>>> dict_2 = dict({('a',1),('b',2),('c',3)})#元素為元組的集合
>>> dictc_2
{'b': 2, 'c': 3, 'a': 1}
>>> dict_3 = dict([['a',1],['b',2],['c',3]])#元素為列表的列表
>>> dict_3
{'a': 1, 'b': 2, 'c': 3}
>>> dict_4 = dict((('a',1),('b',2),('c',3)))#元素為元組的元組
>>> dict_4
{'a': 1, 'b': 2, 'c': 3}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Python3基本數據類型 python3 基本數據類型轉換 python3:基本數據類型（int，bool，str） python的基本數據類型（一） Python基本數據類型 python基本數據類型 Python基本數據類型之str Python基本數據類型之dict Python基本數據類型(元組) Python基本語法（一）基本數據類型