python3基本數據類型

時間 2019-11-12

標籤 python3 python 基本數據類型欄目 Python 简体版

原文原文鏈接

python3基本數據類型html

源於：https://www.runoob.com/python3/python3-data-type.htmlpython

python中的變量不須要聲明。每一個變量在使用前都必須賦值，變量賦值之後該變量纔會被建立。linux

在python中，變量就是變量，它沒有類型，咱們所說的」類型「是變量所致的內存中對象的類型。數據結構

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

等號（=）運算符左邊是一個變量名，等號（=）右邊是存儲在變量中的值。函數

例如:測試

>>> counter = 100   #整型變量
>>> miler   = 100.00 #浮點型變量
>>> name    = "jack"  #字符串
>>> 
>>> print (counter)
100
>>> print (miler)
100.0
>>> print (name)
jack
>>>

多個變量賦值spa

python容許你同時爲多個變量賦值。例如：code

a = b = b = 1

以上實例，建立一個整型對象，值爲 1，從後向前賦值，三個變量被賦予相同的數值。htm

也能夠爲多個對象指定多個變量。例如：

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

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

標準數據類型

python3中有六個標準數據類型：

number（數字）
string（字符串）
list（列表）
tuple（元組）
set（集合）
dictionary（字典）

python3的六個標準數據類型中：

不可變數據（3個）：number（數字），string（字符串），tuple（元組）
可變數據（3個）：list（列表），dictionary（字典），set（集合）

number（數字）

python3支持int，float，bool，complex。

在python3裏，只有一種數據類型int，表示爲長整型，沒有python2中的long。

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

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

>>> a, b, c, d = 20, 1.1, True, 1+2j
>>> 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 的區別在於：

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

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

注意：在 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.1 - 1 #減法
3.0999999999999996
>>> 
>>> 3 * 7  #乘法
21
>>> 
>>> 2 / 4  #除法，獲得一個浮點數
0.5
>>> 
>>> 2 // 4  #除法，獲得一個整數
0
>>> 17 % 3  #取餘
2
>>> 2 ** 3  #乘方
8
>>>

注意：

python能夠同時爲多個變量賦值，如 a, b = 1, 2。
一個變量能夠經過賦值指向不一樣類型的對象。
數值的除法包含兩個運算符：/ 返回一個浮點數，// 返回一個整數。
在混合計算時，python會把整型轉換成爲浮點數。

string（字符串）

python中的字符串用單引號'或者雙引號"括起來，同時用反斜槓\轉義特殊字符

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

變量[頭下標：尾下標]

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

加號 + 是字符串的鏈接符，星號 * 表示複製當前字符串，緊跟的數字爲複製的次數。實例以下：

#!/usr/bin/python

str = "string"

print (str)     #輸出字符串
print (str[0:-1])       #輸出第一個到倒數第二個的全部字符
print (str[0])          #輸出字符串的第一個字符
print (str[2:5])        #輸出字符串的第三個到第五個的字符
print (str[2:])         #輸出從第三個開始後的全部字符
print (str * 2)         #輸出字符串兩次
print (str + "TEST")    #鏈接字符串

執行結果

string
strin
s
rin
ring
stringstring
stringTEST

Python 使用反斜槓(\)轉義特殊字符，若是你不想讓反斜槓發生轉義，能夠在字符串前面添加一個 r，表示原始字符串：

>>> print ("tes\ttest")
tes     test
>>> print (r"tes\ttest")
tes\ttest
>>>

另外，反斜槓(\)能夠做爲續行符，表示下一行是上一行的延續。也可使用 """...""" 或者 '''...''' 跨越多行。

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

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

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

注意：

反斜槓能夠用來轉義，使用r可讓反斜槓不發生轉義
字符串能夠用+運算符鏈接在一塊兒，用*運算符重複
python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始
python中的字符串不能改變

list（列表）

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

列表是卸載方括號[]之間、用逗號隔開的元素列表。

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

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

變量[頭下標:尾下標]

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

加號 + 是列表鏈接運算符，星號 * 是重複操做。以下實例：

#!/usr/bin/python

list = [ 'abcd', 1234, 1.11, 'test', 8.01 ]
tinylist = [ 'efdh', 123 ]

print (list)            #輸出完整列表
print (list[0])         #輸出列表第一個元素
print (list[1:3])       #輸出列表第二個開始到第三個元素
print (list[2:])                #輸出從第三個開始的全部元素
print (tinylist * 2)    #輸出兩次列表
print (list + tinylist) #鏈接列表

執行結果

['abcd', 1234, 1.11, 'test', 8.01]
abcd
[1234, 1.11]
[1.11, 'test', 8.01]
['efdh', 123, 'efdh', 123]
['abcd', 1234, 1.11, 'test', 8.01, 'efdh', 123]

與python字符串不同的是，列表中的元素是能夠改變的：

>>> a = [1,2,3,4,5]
>>> a[0] = 'a'
>>> a[2:4] = [11,12,13]
>>> a
[a, 2, 11, 12, 13, 5]
>>> 
>>> a[2:4] = [] 
>>> 
>>> a
['a', 2, 13, 5]
>>>

List 內置了有不少方法，例如 append()、pop() 等等，這在後面會講到。

注意：

list寫在方括號直接，元素用逗號隔開
和字符串同樣，list能夠被索引和切片
list可使用+操做符進行拼接
list中的元素是能夠改變的

Python 列表截取能夠接收第三個參數，參數做用是截取的步長，如下實例在索引 1 到索引 4 的位置並設置爲步長爲 2（間隔一個位置）來截取字符串

若是第三個參數爲負數表示逆向讀取，如下實例用於翻轉字符串：

#!/usr/bin/python

def reverseWords(input):

        #經過空格將字符串分隔，把各個單詞分隔爲列表
        inputWords = input.split(" ")

        #翻轉字符串
        #假設列表list = [1,2,3,4],
        #list[0]=1, list[1]=2 ，而 -1 表示最後一個元素 list[-1]=4 ( 與 list[3]=4 同樣)
        #inputWords[-1::-1] 有三個參數
        # 第一個參數 -1 表示最後一個元素
        # 第二個參數爲空，表示移動到列表末尾
        # 第三個參數爲步長，-1 表示逆向
        inputWords=inputWords[-1::-1]

        # 從新組合字符串
        output = ' '.join(inputWords)

        return output

if __name__ == '__main__':
        input = 'I like PYTHON'
        rw = reverseWords(input)
        print(rw)
~

輸出結果爲

PYTHON like I

Tuple（元組）

元組（tuple）與列表相似，不一樣之處在於元組的元素不能修改。元組寫在小括號 () 裏，元素之間用逗號隔開。

元組中的元素類型也能夠不相同：

#!/usr/bin/python
 
tuple = ( 'abcd', 786 , 2.23, 'test', 70.2  )
tinytuple = (123, 'test')
 
print (tuple)             # 輸出完整元組
print (tuple[0])          # 輸出元組的第一個元素
print (tuple[1:3])        # 輸出從第二個元素開始到第三個元素
print (tuple[2:])         # 輸出從第三個元素開始的全部元素
print (tinytuple * 2)     # 輸出兩次元組
print (tuple + tinytuple) # 鏈接元組

執行結果

('abcd', 786, 2.23, 'test', 70.2)
abcd
(786, 2.23)
(2.23, 'test', 70.2)
(123, 'test', 123, 'test')
('abcd', 786, 2.23, 'test', 70.2, 123, 'test')

元組與字符串相似，能夠被索引且下標索引從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（序列）

注意：

與字符串同樣，元組的元素不能修改
元組也能夠被索引和切片，方法同樣
注意構造包含0或1個元素的元組的特殊語法規則
元組也可使用+操做符進行拼接

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/python 

dict = {}
dict['one'] = "1_python"
dict[2] = "linux"

tinydict = { "name":'he',"code":'zhang',"site":'abc' }

print (dict['one'])         # 輸出鍵爲 'one' 的值
print (dict[2])             # 輸出鍵爲 '2' 的值
print (tinydict)            # 輸出完整的字典
print (tinydict.keys())     # 輸出全部的鍵
print (tinydict.values())   # 輸出全部值

執行結果

1_python
linux
{'name': 'he', 'code': 'zhang', 'site': 'abc'}
dict_keys(['name', 'code', 'site'])
dict_values(['he', 'zhang', 'abc'])

構造函數 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)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}