建站
咨詢
售后
建站咨詢
新聞中心
Python3 基本數(shù)據(jù)類型
Python 中的變量不需要聲明。每個變量在使用前都必須賦值，變量賦值以后該變量才會被創(chuàng)建。
成都創(chuàng)新互聯(lián)是一家網(wǎng)站制作、網(wǎng)站建設，提供網(wǎng)頁設計，網(wǎng)站設計，網(wǎng)站制作，建網(wǎng)站，按需設計網(wǎng)站，網(wǎng)站開發(fā)公司，自2013年起是互聯(lián)行業(yè)建設者，服務者。以提升客戶品牌價值為核心業(yè)務，全程參與項目的網(wǎng)站策劃設計制作，前端開發(fā)，后臺程序制作以及后期項目運營并提出專業(yè)建議和思路。
在 Python 中，變量就是變量，它沒有類型，我們所說的"類型"是變量所指的內存中對象的類型。
等號（=）用來給變量賦值。
等號（=）運算符左邊是一個變量名,等號（=）運算符右邊是存儲在變量中的值。例如：
實例(Python 3.0+)
#!/usr/bin/python3
counter
=
100
# 整型變量
miles
=
1000.0
# 浮點型變量
name
=
"runoob"
# 字符串
print
(counter
)
print
(miles
)
print
(name
)
執(zhí)行以上程序會輸出如下結果：
100 1000.0 runoob
多個變量賦值
Python允許你同時為多個變量賦值。例如：
a = b = c = 1
以上實例，創(chuàng)建一個整型對象，值為 1，從后向前賦值，三個變量被賦予相同的數(shù)值。
您也可以為多個對象指定多個變量。例如：
a, b, c = 1, 2, "runoob"
以上實例，兩個整型對象 1 和 2 的分配給變量 a 和 b，字符串對象 "runoob" 分配給變量 c。
標準數(shù)據(jù)類型
Python3 中常見的數(shù)據(jù)類型有：
- Number（數(shù)字）
- String（字符串）
- bool（布爾類型）
- List（列表）
- Tuple（元組）
- Set（集合）
- Dictionary（字典）
Python3 的六個標準數(shù)據(jù)類型中：
- 不可變數(shù)據(jù)（3 個）：Number（數(shù)字）、String（字符串）、Tuple（元組）；
- 可變數(shù)據(jù)（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
此外還有一些高級的數(shù)據(jù)類型，如: 字節(jié)數(shù)組類型(bytes)。
Number（數(shù)字）
Python3 支持 int、float、bool、complex（復數(shù)）。
在Python 3里，只有一種整數(shù)類型 int，表示為長整型，沒有 python2 中的 Long。
像大多數(shù)語言一樣，數(shù)值類型的賦值和計算都是很直觀的。
內置的 type() 函數(shù)可以用來查詢變量所指的對象類型。
>>> a, b, c, d = 20, 5.5, True, 4+3j >>> print(type(a), type(b), type(c), type(d))
此外還可以用 isinstance 來判斷：
實例
>>> a
=
111
>>>
isinstance
(a
,
int
)
True
>>>
isinstance 和 type 的區(qū)別在于：
- 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
注意：Python3 中，bool 是 int 的子類，True 和 False 可以和數(shù)字相加， True==1、False==0 會返回 True，但可以通過 is 來判斷類型。
>>> issubclass(bool, int) True >>> True==1 True >>> False==0 True >>> True+1 2 >>> False+1 1 >>> 1 is True False >>> 0 is False False在 Python2 中是沒有布爾型的，它用數(shù)字 0 表示 False，用 1 表示 True。
當你指定一個值時，Number 對象就會被創(chuàng)建：
var1 = 1 var2 = 10
您也可以使用del語句刪除一些對象引用。
del語句的語法是：
del var1[,var2[,var3[....,varN]]]
您可以通過使用del語句刪除單個或多個對象。例如：
del var del var_a, var_b
數(shù)值運算
實例
>>>
5 +
4
# 加法
9
>>>
4.3 -
2
# 減法
2.3
>>>
3 *
7
# 乘法
21
>>>
2 /
4
# 除法，得到一個浮點數(shù)
0.5
>>>
2 //
4
# 除法，得到一個整數(shù)
0
>>>
17 %
3
# 取余
2
>>>
2 **
5
# 乘方
32
注意：
- 1、Python可以同時為多個變量賦值，如a, b = 1, 2。
- 2、一個變量可以通過賦值指向不同類型的對象。
- 3、數(shù)值的除法包含兩個運算符：/ 返回一個浮點數(shù)，// 返回一個整數(shù)。
- 4、在混合計算時，Python會把整型轉換成為浮點數(shù)。
數(shù)值類型實例
| 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 還支持復數(shù)，復數(shù)由實數(shù)部分和虛數(shù)部分構成，可以用 a + bj，或者 complex(a,b) 表示， 復數(shù)的實部 a 和虛部 b 都是浮點型。
String（字符串）
Python中的字符串用單引號 ' 或雙引號 " 括起來，同時使用反斜杠 \ 轉義特殊字符。
字符串的截取的語法格式如下：
變量[頭下標:尾下標]
索引值以 0 為開始值，-1 為從末尾的開始位置。
加號 + 是字符串的連接符， 星號 * 表示復制當前字符串，與之結合的數(shù)字為復制的次數(shù)。實例如下：
實例
#!/usr/bin/python3
str
=
'Runoob'
print
(
str
)
# 輸出字符串
print
(
str
[
0:-
1
]
)
# 輸出第一個到倒數(shù)第二個的所有字符
print
(
str
[
0
]
)
# 輸出字符串第一個字符
print
(
str
[
2:
5
]
)
# 輸出從第三個開始到第五個的字符
print
(
str
[
2:
]
)
# 輸出從第三個開始的后的所有字符
print
(
str *
2
)
# 輸出字符串兩次，也可以寫成 print (2 * str)
print
(
str +
"TEST"
)
# 連接字符串
執(zhí)行以上程序會輸出如下結果：
Runoob Runoo R noo noob RunoobRunoob RunoobTEST
Python 使用反斜杠 \ 轉義特殊字符，如果你不想讓反斜杠發(fā)生轉義，可以在字符串前面添加一個 r，表示原始字符串：
實例
>>>
print
(
'Ru\noob'
)
Ru
oob
>>>
print
(r
'Ru\noob'
)
Ru\noob
>>>
另外，反斜杠(\)可以作為續(xù)行符，表示下一行是上一行的延續(xù)。也可以使用 """...""" 或者 '''...''' 跨越多行。
注意，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可以讓反斜杠不發(fā)生轉義。
- 2、字符串可以用+運算符連接在一起，用*運算符重復。
- 3、Python中的字符串有兩種索引方式，從左往右以0開始，從右往左以-1開始。
- 4、Python中的字符串不能改變。
bool（布爾類型）
布爾類型即 True 或 False。
在 Python 中，True 和 False 都是關鍵字，表示布爾值。
布爾類型可以用來控制程序的流程，比如判斷某個條件是否成立，或者在某個條件滿足時執(zhí)行某段代碼。
布爾類型特點：
-
布爾類型只有兩個值：True 和 False。
-
布爾類型可以和其他數(shù)據(jù)類型進行比較，比如數(shù)字、字符串等。在比較時，Python 會將 True 視為 1，F(xiàn)alse 視為 0。
-
布爾類型可以和邏輯運算符一起使用，包括 and、or 和 not。這些運算符可以用來組合多個布爾表達式，生成一個新的布爾值。
-
布爾類型也可以被轉換成其他數(shù)據(jù)類型，比如整數(shù)、浮點數(shù)和字符串。在轉換時，True 會被轉換成 1，F(xiàn)alse 會被轉換成 0。
實例
a
=
True
b
=
False
# 比較運算符
print
(
2
<
3
)
# True
print
(
2
==
3
)
# False
# 邏輯運算符
print
(a
and b
)
# False
print
(a
or b
)
# True
print
(
not a
)
# False
# 類型轉換
print
(
int
(a
)
)
# 1
print
(
float
(b
)
)
# 0.0
print
(
str
(a
)
)
# "True"
注意: 在 Python 中，所有非零的數(shù)字和非空的字符串、列表、元組等數(shù)據(jù)類型都被視為 True，只有 0、空字符串、空列表、空元組等被視為 False。因此，在進行布爾類型轉換時，需要注意數(shù)據(jù)類型的真假性。
List（列表）
List（列表） 是 Python 中使用最頻繁的數(shù)據(jù)類型。
列表可以完成大多數(shù)集合類的數(shù)據(jù)結構實現(xiàn)。列表中元素的類型可以不相同，它支持數(shù)字，字符串甚至可以包含列表（所謂嵌套）。
列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。
和字符串一樣，列表同樣可以被索引和截取，列表被截取后返回一個包含所需元素的新列表。
列表截取的語法格式如下：
變量[頭下標:尾下標]
索引值以 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中的元素是可以改變的。
Python 列表截取可以接收第三個參數(shù)，參數(shù)作用是截取的步長，以下實例在索引 1 到索引 4 的位置并設置為步長為 2（間隔一個位置）來截取字符串：
如果第三個參數(shù)為負數(shù)表示逆向讀取，以下實例用于翻轉字符串：
實例
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] 有三個參數(shù)
# 第一個參數(shù) -1 表示最后一個元素
# 第二個參數(shù)為空，表示移動到列表末尾
# 第三個參數(shù)為步長，-1 表示逆向
inputWords
=inputWords
[-
1::-
1
]
# 重新組合字符串
output
=
' '.
join
(inputWords
)
return output
if __name__
==
"__main__":
input
=
'I like runoob'
rw
= reverseWords
(
input
)
print
(rw
)
輸出結果為：
runoob like I
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
"
, line
1
,
in
TypeError:
'tuple'
object does
not support item assignment
>>>
雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。
構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規(guī)則：
tup1 = () # 空元組 tup2 = (20,) # 一個元素，需要在元素后添加逗號
string、list 和 tuple 都屬于 sequence（序列）。
注意：
- 1、與字符串一樣，元組的元素不能修改。
- 2、元組也可以被索引和切片，方法一樣。
- 3、注意構造包含 0 或 1 個元素的元組的特殊語法規(guī)則。
- 4、元組也可以使用+操作符進行拼接。
Set（集合）
Python 中的集合（Set）是一種無序、可變的數(shù)據(jù)類型，用于存儲唯一的元素。
集合中的元素不會重復，并且可以進行交集、并集、差集等常見的集合操作。
在 Python 中，集合使用大括號 {} 表示，元素之間用逗號 , 分隔。
另外，也可以使用 set() 函數(shù)創(chuàng)建集合。
注意：創(chuàng)建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創(chuàng)建一個空字典。
創(chuàng)建格式：
parame = {value01,value02,...}
或者
set(value)
實例
#!/usr/bin/python3
sites
=
{
'Google'
,
'Taobao'
,
'Runoob'
,
'Facebook'
,
'Zhihu'
,
'Baidu'
}
print
(sites
)
# 輸出集合，重復的元素被自動去掉
# 成員測試
if
'Runoob'
in sites :
print
(
'Runoob 在集合中'
)
else :
print
(
'Runoob 不在集合中'
)
# 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 中不同時存在的元素
以上實例輸出結果：
{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}
Dictionary（字典）
字典（dictionary）是Python中另一個非常有用的內置數(shù)據(jù)類型。
列表是有序的對象集合，字典是無序的對象集合。兩者之間的區(qū)別在于：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(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', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
構造函數(shù) dict() 可以直接從鍵值對序列中構建字典如下：
實例
>>>
dict
(
[
(
'Runoob'
,
1
)
,
(
'Google'
,
2
)
,
(
'Taobao'
,
3
)
]
)
{
'Runoob':
1
,
'Google':
2
,
'Taobao':
3
}
>>>
{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
}
{x: x**2 for x in (2, 4, 6)} 該代碼使用的是字典推導式，更多推導式內容可以參考：。
另外，字典類型也有一些內置的函數(shù)，例如 clear()、keys()、values() 等。
注意：
- 1、字典是一種映射類型，它的元素是鍵值對。
- 2、字典的關鍵字必須為不可變類型，且不能重復。
- 3、創(chuàng)建空字典使用 { }。
bytes 類型
在 Python3 中，bytes 類型表示的是不可變的二進制序列（byte sequence）。
與字符串類型不同的是，bytes 類型中的元素是整數(shù)值（0 到 255 之間的整數(shù)），而不是 Unicode 字符。
bytes 類型通常用于處理二進制數(shù)據(jù)，比如圖像文件、音頻文件、視頻文件等等。在網(wǎng)絡編程中，也經(jīng)常使用 bytes 類型來傳輸二進制數(shù)據(jù)。
創(chuàng)建 bytes 對象的方式有多種，最常見的方式是使用 b 前綴：
此外，也可以使用 bytes() 函數(shù)將其他類型的對象轉換為 bytes 類型。bytes() 函數(shù)的第一個參數(shù)是要轉換的對象，第二個參數(shù)是編碼方式，如果省略第二個參數(shù)，則默認使用 UTF-8 編碼：
x = bytes("hello", encoding="utf-8")與字符串類型類似，bytes 類型也支持許多操作和方法，如切片、拼接、查找、替換等等。同時，由于 bytes 類型是不可變的，因此在進行修改操作時需要創(chuàng)建一個新的 bytes 對象。例如：
實例
x
= b
"hello"
y
= x
[
1:
3
]
# 切片操作，得到 b"el"
z
= x + b
"world"
# 拼接操作，得到 b"helloworld"
需要注意的是，bytes 類型中的元素是整數(shù)值，因此在進行比較操作時需要使用相應的整數(shù)值。例如：
實例
x
= b
"hello"
if x
[
0
]
==
ord
(
"h"
):
print
(
"The first element is 'h'"
)
其中 ord() 函數(shù)用于將字符轉換為相應的整數(shù)值。
Python數(shù)據(jù)類型轉換
有時候，我們需要對數(shù)據(jù)內置的類型進行轉換，數(shù)據(jù)類型的轉換，你只需要將數(shù)據(jù)類型作為函數(shù)名即可，在下一章節(jié) 會具體介紹。
以下幾個內置的函數(shù)可以執(zhí)行數(shù)據(jù)類型之間的轉換。這些函數(shù)返回一個新的對象，表示轉換的值。
| 函數(shù) | 描述 |
|---|---|
將x轉換為一個整數(shù) | |
將x轉換到一個浮點數(shù) | |
創(chuàng)建一個復數(shù) | |
將對象 x 轉換為字符串 | |
將對象 x 轉換為表達式字符串 | |
用來計算在字符串中的有效Python表達式,并返回一個對象 | |
將序列 s 轉換為一個元組 | |
將序列 s 轉換為一個列表 | |
轉換為可變集合 | |
創(chuàng)建一個字典。d 必須是一個 (key, value)元組序列。 | |
轉換為不可變集合 | |
將一個整數(shù)轉換為一個字符 | |
將一個字符轉換為它的整數(shù)值 | |
將一個整數(shù)轉換為一個十六進制字符串 | |
將一個整數(shù)轉換為一個八進制字符串 |
分享名稱：Python3基本數(shù)據(jù)類型
文章鏈接：http://fisionsoft.com.cn/article/dpcdojo.html
