python3學習筆記（一）

時間 2019-11-07

標籤 python3 python 學習筆記欄目 Python 简体版

原文原文鏈接

1、python與python的特色

一、python是一門編程語言，它是衆多編程語言中的一種； html

二、語法簡潔、優雅、編寫的程序容易閱讀； python

三、跨平臺，可運行在Windows、Linux以及MacOS； git

四、易於學習。站在非計算機專業的角度來說，若是把編程看成解決問題的工具，python確實相較於C++、Java、JavaScript等語言要易於學習和掌握；程序員

五、極爲強大的標準庫與第三方庫，好比電子郵件，好比圖形GUI界面；web

六、python是面向對象的語言；（面向對象就是一個思想）算法

2、我爲何喜歡python 那麼多語言，我爲何喜歡python？

一、簡潔，靈活，優雅，哲學；（python之禪） express

二、易於上手難於精通；編程

三、python既有動態腳本的特性，又有面向對象的特性，很是具備本身的特色； api

四、應用：爬蟲，大數據，測試，web，AI,腳本處理數組

python的缺點

一、慢（感受不到），相較於C、C++、Java，運行效率較慢編譯型語言（C,C++）、解釋型語言（JavaScript,python），Java和C##是一箇中間語言（他們的歸類不重要）運行效率與開發效率，魚和熊掌不可兼得，語言適合的纔是最好的一個學習編程的經典誤區世界上不是隻有web，還有許多的問題須要使用編程來解決。不要把思惟侷限在web上，這只是編程的一個應用方向

python能作什麼，

一、爬蟲

二、大數據與數據分析（Spark）

三、自動化運維與自動化測試

四、Web開發：Flask，Django

五、機器學習（Tensor Flow）

六、膠水語言：混合其餘如C++、Java等來編程。可以把用其餘語言製做的各類模塊（尤爲是C/C++）很輕鬆地聯合在一塊兒怎麼面對python：當你遇到問題是，隨手拿起python，編寫一個工具，這纔是python的正確打開方式

一、Python3 基礎語法

1.編碼

默認狀況下，Python 3 源碼文件以 UTF-8 編碼，全部字符串都是 unicode 字符串。固然你也能夠爲源碼文件指定不一樣的編碼：

# -*- coding: cp-1252 -*-複製代碼

上述定義容許在源文件中使用 Windows-1252 字符集中的字符編碼，對應適合語言爲保加利亞語、白羅斯語、馬其頓語、俄語、塞爾維亞語。

2.標識符

第一個字符必須是字母表中字母或下劃線 _ 。
標識符的其餘的部分由字母、數字和下劃線組成。
標識符對大小寫敏感。

在 Python 3 中，能夠用中文做爲變量名，非 ASCII 標識符也是容許的了。

3.python保留字

保留字即關鍵字，咱們不能把它們用做任何標識符名稱。Python 的標準庫提供了一個 keyword 模塊，能夠輸出當前版本的全部關鍵字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 
'del','elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 
'is', 'lambda', 'nonlocal','not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 
'yield']複製代碼

4.註釋

Python中單行註釋以 # 開頭，實例以下：

實例(Python 3.0+)

# 第一個註釋
print ("Hello, Python!") # 第二個註釋複製代碼

執行以上代碼，輸出結果爲：

Hello, Python!複製代碼

多行註釋能夠用多個 # 號，還有 ''' 和 """：

實例(Python 3.0+)

# 第一個註釋
# 第二個註釋
 
''' 第三註釋 第四註釋 '''
 
""" 第五註釋 第六註釋 """
print ("Hello, Python!")複製代碼

執行以上代碼，輸出結果爲：

Hello, Python!複製代碼

5.行與縮進

python最具特點的就是使用縮進來表示代碼塊，不須要使用大括號 {} 。

縮進的空格數是可變的，可是同一個代碼塊的語句必須包含相同的縮進空格數。實例以下：

實例(Python 3.0+)

if True:
    print ("True")
else:
    print ("False")複製代碼

如下代碼最後一行語句縮進數的空格數不一致，會致使運行錯誤：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 縮進不一致，會致使運行錯誤複製代碼

以上程序因爲縮進不一致，執行後會出現相似如下錯誤：

File "test.py", line 6
    print ("False")    # 縮進不一致，會致使運行錯誤
                                      ^
IndentationError: unindent does not match any outer indentation level複製代碼

6.多行語句

Python 一般是一行寫完一條語句，但若是語句很長，咱們可使用反斜槓(\)來實現多行語句，例如：

total = item_one + \
        item_two + \
        item_three複製代碼

在 [], {}, 或 () 中的多行語句，不須要使用反斜槓(\)，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']複製代碼

7.數字(Number)類型

python中數字有四種類型：整數、布爾型、浮點數和複數。

int (整數), 如 1, 只有一種整數類型 int，表示爲長整型，沒有 python2 中的 Long。
bool (布爾), 如 True。
float (浮點數), 如 1.2三、3E-2
complex (複數), 如 1 + 2j、 1.1 + 2.2j

8.字符串(String)

python中單引號和雙引號使用徹底相同。
使用三引號('''或""")能夠指定一個多行字符串。
轉義符 '\'
反斜槓能夠用來轉義，使用r可讓反斜槓不發生轉義。。如 r"this is a line with \n" 則\n會顯示，並非換行。
按字面意義級聯字符串，如"this " "is " "string"會被自動轉換爲this is string。
字符串能夠用 + 運算符鏈接在一塊兒，用 * 運算符重複。
Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
Python中的字符串不能改變。
Python 沒有單獨的字符類型，一個字符就是長度爲 1 的字符串。
字符串的截取的語法格式以下：變量[頭下標:尾下標:步長]

word = '字符串'
sentence = "這是一個句子。"
paragraph = """這是一個段落， 能夠由多行組成"""複製代碼

實例(Python 3.0+)

str='Runoob'
 
print(str)                 # 輸出字符串
print(str[0:-1])           # 輸出第一個到倒數第二個的全部字符
print(str[0])              # 輸出字符串第一個字符
print(str[2:5])            # 輸出從第三個開始到第五個的字符
print(str[2:])             # 輸出從第三個開始後的全部字符
print(str * 2)             # 輸出字符串兩次
print(str + '你好')        # 鏈接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜槓(\)+n轉義特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一個 r，表示原始字符串，不會發生轉義複製代碼

這裏的 r 指 raw，即 raw string。

輸出結果爲：

Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoob你好
------------------------------
hello
runoob
hello\nrunoob複製代碼

9.空行

函數之間或類的方法之間用空行分隔，表示一段新的代碼的開始。類和函數入口之間也用一行空行分隔，以突出函數入口的開始。

空行與代碼縮進不一樣，空行並非Python語法的一部分。書寫時不插入空行，Python解釋器運行也不會出錯。可是空行的做用在於分隔兩段不一樣功能或含義的代碼，便於往後代碼的維護或重構。

記住：空行也是程序代碼的一部分。

10.等待用戶輸入

執行下面的程序在按回車鍵後就會等待用戶輸入：

實例(Python 3.0+)

input("\n\n按下 enter 鍵後退出。")複製代碼

以上代碼中，"\n\n"在結果輸出前會輸出兩個新的空行。一旦用戶按下 enter 鍵時，程序將退出。

11.同一行顯示多條語句

Python能夠在同一行中使用多條語句，語句之間使用分號(;)分割，如下是一個簡單的實例：

實例(Python 3.0+)

import sys; x = 'runoob'; sys.stdout.write(x + '\n')複製代碼

使用腳本執行以上代碼，輸出結果爲：

runoob複製代碼

使用交互式命令行執行，輸出結果爲：

>>> import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7複製代碼

此處的 7 表示字符數。

12.多個語句構成代碼組

縮進相同的一組語句構成一個代碼塊，咱們稱之代碼組。

像if、while、def和class這樣的複合語句，首行以關鍵字開始，以冒號( : )結束，該行以後的一行或多行代碼構成代碼組。

咱們將首行及後面的代碼組稱爲一個子句(clause)。

以下實例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite複製代碼

13.Print 輸出

print 默認輸出是換行的，若是要實現不換行須要在變量末尾加上 end=""：

實例(Python 3.0+)

x="a"
y="b"
# 換行輸出
print( x )
print( y )
 
print('---------')
# 不換行輸出
print( x, end=" " )
print( y, end=" " )
print()複製代碼

以上實例執行結果爲：

a
b
---------
a b複製代碼

14.import 與 from...import

在 python 用 import 或者 from...import 來導入相應的模塊。

將整個模塊(somemodule)導入，格式爲： import somemodule

從某個模塊中導入某個函數,格式爲： from somemodule import somefunction

從某個模塊中導入多個函數,格式爲： from somemodule import firstfunc, secondfunc, thirdfunc

將某個模塊中的所有函數導入，格式爲： from somemodule import *

15.導入 sys 模塊

import sys
print('================Python import mode==========================')
print ('命令行參數爲:')
for i in sys.argv:
    print (i)
print ('\n python 路徑爲',sys.path)複製代碼

16.導入 sys 模塊的 argv,path 成員

from sys import argv,path  # 導入特定的成員
 
print('================python from import===================================')
print('path:',path) # 由於已經導入path成員，因此此處引用時不須要加sys.path複製代碼

17.命令行參數

不少程序能夠執行一些操做來查看一些基本信息，Python可使用-h參數查看各參數幫助信息：

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]複製代碼

二、Python3 基本數據類型

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

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

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

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

實例(Python 3.0+)

counter = 100          # 整型變量
miles   = 1000.0       # 浮點型變量
name    = "runoob"     # 字符串
 
print (counter)
print (miles)
print (name)複製代碼

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

100
1000.0
runoob複製代碼

1.多個變量賦值

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

a = b = c = 1複製代碼

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

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

a, b, c = 1, 2, "runoob"複製代碼

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

2.標準數據類型

Python3 中有六個標準的數據類型：

Number（數字）
String（字符串）
List（列表）
Tuple（元組）
Set（集合）
Dictionary（字典）

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

不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；
可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。

3.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 的區別在於：

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複製代碼

4.數值運算

實例

>>>5 + 4  # 加法
9
>>> 4.3 - 2 # 減法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，獲得一個浮點數
0.5
>>> 2 // 4 # 除法，獲得一個整數
0
>>> 17 % 3 # 取餘 
2
>>> 2 ** 5 # 乘方
32複製代碼

注意：

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

5.數值類型實例

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都是浮點型

6.String（字符串）

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

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

變量[頭下標:尾下標]複製代碼

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

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

實例

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'會致使錯誤。

注意：

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

7.List（列表）

List（列表）是 Python 中使用最頻繁的數據類型。

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

列表是寫在方括號 [] 之間、用逗號分隔開的元素列表。

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

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

變量[頭下標:尾下標]複製代碼

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

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

實例

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() 等等，這在後面會講到。

注意：

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

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

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

實例

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 runoob'    
rw = reverseWords(input)    
print(rw)複製代碼

輸出結果爲：

runoob like I複製代碼

8.Tuple（元組）

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

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

實例

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（序列）。

注意：

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

9.Set（集合）

集合（set）是由一個或數個形態萬千的大小總體組成的，構成集合的事物或對象稱做元素或是成員。

基本功能是進行成員關係測試和刪除重複元素。

可使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。

建立格式：

parame = {value01,value02,...}
或者
set(value)複製代碼

實例

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'}複製代碼

10.Dictionary（字典）

字典（dictionary）是Python中另外一個很是有用的內置數據類型。

列表是有序的對象集合，字典是無序的對象集合。二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。

字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合。

鍵(key)必須使用不可變類型。

在同一個字典中，鍵(key)必須是惟一的。

實例

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'])複製代碼

構造函數 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}複製代碼

另外，字典類型也有一些內置的函數，例如clear()、keys()、values()等。

注意：

一、字典是一種映射類型，它的元素是鍵值對。
二、字典的關鍵字必須爲不可變類型，且不能重複。
三、建立空字典使用 { }。

11.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)	將一個整數轉換爲一個八進制字符串

三、Python3 註釋

確保對模塊, 函數, 方法和行內註釋使用正確的風格

Python中的註釋有單行註釋和多行註釋：

Python中單行註釋以 # 開頭，例如：：

# 這是一個註釋 print("Hello, World!")

多行註釋用三個單引號 ''' 或者三個雙引號 """ 將註釋括起來，例如:

一、單引號（'''）

''' 這是多行註釋，用三個單引號 這是多行註釋，用三個單引號 這是多行註釋，用三個單引號 '''
print("Hello, World!")複製代碼

二、雙引號（"""）

""" 這是多行註釋，用三個雙引號 這是多行註釋，用三個雙引號 這是多行註釋，用三個雙引號 """
print("Hello, World!")複製代碼

四、Python3 運算符

1. 什麼是運算符？

本章節主要說明Python的運算符。舉個簡單的例子 4 +5 = 9 。例子中，4 和 5 被稱爲操做數，"+" 稱爲運算符。

Python語言支持如下類型的運算符:

接下來讓咱們一個個來學習Python的運算符。

2. Python算術運算符

如下假設變量a爲10，變量b爲21：

運算符	描述	實例
+	加 - 兩個對象相加	a + b 輸出結果 31
-	減 - 獲得負數或是一個數減去另外一個數	a - b 輸出結果 -11
*	乘 - 兩個數相乘或是返回一個被重複若干次的字符串	a * b 輸出結果 210
/	除 - x 除以 y	b / a 輸出結果 2.1
%	取模 - 返回除法的餘數	b % a 輸出結果 1
**	冪 - 返回x的y次冪	a**b 爲10的21次方
//	取整除 - 向下取接近除數的整數	>>> 9//2 4 >>> -9//2 -5複製代碼

如下實例演示了Python全部算術運算符的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值爲：", c)
 
c = a - b
print ("2 - c 的值爲：", c)
 
c = a * b
print ("3 - c 的值爲：", c)
 
c = a / b
print ("4 - c 的值爲：", c)
 
c = a % b
print ("5 - c 的值爲：", c)
 
# 修改變量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值爲：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值爲：", c)複製代碼

以上實例輸出結果：

1 - c 的值爲： 31
2 - c 的值爲： 11
3 - c 的值爲： 210
4 - c 的值爲： 2.1
5 - c 的值爲： 1
6 - c 的值爲： 8
7 - c 的值爲： 2複製代碼

3. Python比較運算符

如下假設變量a爲10，變量b爲20：

運算符	描述	實例
==	等於 - 比較對象是否相等	(a == b) 返回 False。
!=	不等於 - 比較兩個對象是否不相等	(a != b) 返回 True。
>	大於 - 返回x是否大於y	(a > b) 返回 False。
<	小於 - 返回x是否小於y。全部比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。	(a < b) 返回 True。
>=	大於等於 - 返回x是否大於等於y。	(a >= b) 返回 False。
<=	小於等於 - 返回x是否小於等於y。	(a <= b) 返回 True。

如下實例演示了Python全部比較運算符的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等於 b")
else:
   print ("1 - a 不等於 b")
 
if ( a != b ):
   print ("2 - a 不等於 b")
else:
   print ("2 - a 等於 b")
 
if ( a < b ):
   print ("3 - a 小於 b")
else:
   print ("3 - a 大於等於 b")
 
if ( a > b ):
   print ("4 - a 大於 b")
else:
   print ("4 - a 小於等於 b")
 
# 修改變量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print ("5 - a 小於等於 b")
else:
   print ("5 - a 大於 b")
 
if ( b >= a ):
   print ("6 - b 大於等於 a")
else:
   print ("6 - b 小於 a")複製代碼

以上實例輸出結果：

1 - a 不等於 b
2 - a 不等於 b
3 - a 大於等於 b
4 - a 大於 b
5 - a 小於等於 b
6 - b 大於等於 a複製代碼

4. Python賦值運算符

如下假設變量a爲10，變量b爲20：

運算符	描述	實例
=	簡單的賦值運算符	c = a + b 將 a + b 的運算結果賦值爲 c
+=	加法賦值運算符	c += a 等效於 c = c + a
-=	減法賦值運算符	c -= a 等效於 c = c - a
*=	乘法賦值運算符	c = a 等效於 c = c a
/=	除法賦值運算符	c /= a 等效於 c = c / a
%=	取模賦值運算符	c %= a 等效於 c = c % a
**=	冪賦值運算符	c = a 等效於 c = c a
//=	取整除賦值運算符	c //= a 等效於 c = c // a
:=	海象運算符，可在表達式內部爲變量賦值。Python3.8 版本新增運算符。	在這個示例中，賦值表達式能夠避免調用 len() 兩次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")複製代碼

如下實例演示了Python全部賦值運算符的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值爲：", c)
 
c += a
print ("2 - c 的值爲：", c)
 
c *= a
print ("3 - c 的值爲：", c)
 
c /= a 
print ("4 - c 的值爲：", c)
 
c = 2
c %= a
print ("5 - c 的值爲：", c)
 
c **= a
print ("6 - c 的值爲：", c)
 
c //= a
print ("7 - c 的值爲：", c)複製代碼

以上實例輸出結果：

1 - c 的值爲： 31
2 - c 的值爲： 52
3 - c 的值爲： 1092
4 - c 的值爲： 52.0
5 - c 的值爲： 2
6 - c 的值爲： 2097152
7 - c 的值爲： 99864複製代碼

5. Python位運算符

按位運算符是把數字看做二進制來進行計算的。Python中的按位運算法則以下：

下表中變量 a 爲 60，b 爲 13二進制格式以下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011複製代碼

運算符	描述	實例
&	按位與運算符：參與運算的兩個值,若是兩個相應位都爲1,則該位的結果爲1,不然爲0	(a & b) 輸出結果 12 ，二進制解釋： 0000 1100
\|	按位或運算符：只要對應的二個二進位有一個爲1時，結果位就爲1。	(a \| b) 輸出結果 61 ，二進制解釋： 0011 1101
^	按位異或運算符：當兩對應的二進位相異時，結果爲1	(a ^ b) 輸出結果 49 ，二進制解釋： 0011 0001
~	按位取反運算符：對數據的每一個二進制位取反,即把1變爲0,把0變爲1。~x 相似於 -x-1	(~a ) 輸出結果 -61 ，二進制解釋： 1100 0011，在一個有符號二進制數的補碼形式。
<<	左移動運算符：運算數的各二進位所有左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。	a << 2 輸出結果 240 ，二進制解釋： 1111 0000
>>	右移動運算符：把">>"左邊的運算數的各二進位所有右移若干位，">>"右邊的數指定移動的位數	a >> 2 輸出結果 15 ，二進制解釋： 0000 1111

如下實例演示了Python全部位運算符的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b;        # 12 = 0000 1100
print ("1 - c 的值爲：", c)
 
c = a | b;        # 61 = 0011 1101 
print ("2 - c 的值爲：", c)
 
c = a ^ b;        # 49 = 0011 0001
print ("3 - c 的值爲：", c)
 
c = ~a;           # -61 = 1100 0011
print ("4 - c 的值爲：", c)
 
c = a << 2;       # 240 = 1111 0000
print ("5 - c 的值爲：", c)
 
c = a >> 2;       # 15 = 0000 1111
print ("6 - c 的值爲：", c)複製代碼

以上實例輸出結果：

1 - c 的值爲： 12
2 - c 的值爲： 61
3 - c 的值爲： 49
4 - c 的值爲： -61
5 - c 的值爲： 240
6 - c 的值爲： 15複製代碼

6. Python邏輯運算符

Python語言支持邏輯運算符，如下假設變量 a 爲 10, b爲 20:

運算符	邏輯表達式	描述	實例
and	x and y	布爾"與" - 若是 x 爲 False，x and y 返回 False，不然它返回 y 的計算值。	(a and b) 返回 20。
or	x or y	布爾"或" - 若是 x 是 True，它返回 x 的值，不然它返回 y 的計算值。	(a or b) 返回 10。
not	not x	布爾"非" - 若是 x 爲 True，返回 False 。若是 x 爲 False，它返回 True。	not(a and b) 返回 False

以上實例輸出結果：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
b = 20
 
if ( a and b ):
   print ("1 - 變量 a 和 b 都爲 true")
else:
   print ("1 - 變量 a 和 b 有一個不爲 true")
 
if ( a or b ):
   print ("2 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
   print ("2 - 變量 a 和 b 都不爲 true")
 
# 修改變量 a 的值
a = 0
if ( a and b ):
   print ("3 - 變量 a 和 b 都爲 true")
else:
   print ("3 - 變量 a 和 b 有一個不爲 true")
 
if ( a or b ):
   print ("4 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
   print ("4 - 變量 a 和 b 都不爲 true")
 
if not( a and b ):
   print ("5 - 變量 a 和 b 都爲 false，或其中一個變量爲 false")
else:
   print ("5 - 變量 a 和 b 都爲 true")複製代碼

以上實例輸出結果：

1 - 變量 a 和 b 都爲 true
2 - 變量 a 和 b 都爲 true，或其中一個變量爲 true
3 - 變量 a 和 b 有一個不爲 true
4 - 變量 a 和 b 都爲 true，或其中一個變量爲 true
5 - 變量 a 和 b 都爲 false，或其中一個變量爲 false複製代碼

7. Python成員運算符

除了以上的一些運算符以外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。

運算符	描述	實例
in	若是在指定的序列中找到值返回 True，不然返回 False。	x 在 y 序列中 , 若是 x 在 y 序列中返回 True。
not in	若是在指定的序列中沒有找到值返回 True，不然返回 False。	x 不在 y 序列中 , 若是 x 不在 y 序列中返回 True。

如下實例演示了Python全部成員運算符的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("1 - 變量 a 在給定的列表中 list 中")
else:
   print ("1 - 變量 a 不在給定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 變量 b 不在給定的列表中 list 中")
else:
   print ("2 - 變量 b 在給定的列表中 list 中")
 
# 修改變量 a 的值
a = 2
if ( a in list ):
   print ("3 - 變量 a 在給定的列表中 list 中")
else:
   print ("3 - 變量 a 不在給定的列表中 list 中")複製代碼

以上實例輸出結果：

1 - 變量 a 不在給定的列表中 list 中
2 - 變量 b 不在給定的列表中 list 中
3 - 變量 a 在給定的列表中 list 中複製代碼

8. Python身份運算符

身份運算符用於比較兩個對象的存儲單元

運算符	描述	實例
is	is 是判斷兩個標識符是否是引用自一個對象	x is y, 相似 id(x) == id(y) , 若是引用的是同一個對象則返回 True，不然返回 False
is not	is not 是判斷兩個標識符是否是引用自不一樣對象	x is not y ，相似 id(a) != id(b)。若是引用的不是同一個對象則返回結果 True，不然返回 False。

注： id() 函數用於獲取對象內存地址。

如下實例演示了Python全部身份運算符的操做：

實例(Python 3.0+)

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的標識")
else:
   print ("1 - a 和 b 沒有相同的標識")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的標識")
else:
   print ("2 - a 和 b 沒有相同的標識")
 
# 修改變量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的標識")
else:
   print ("3 - a 和 b 沒有相同的標識")
 
if ( a is not b ):
   print ("4 - a 和 b 沒有相同的標識")
else:
   print ("4 - a 和 b 有相同的標識")複製代碼

以上實例輸出結果：

1 - a 和 b 有相同的標識
2 - a 和 b 有相同的標識
3 - a 和 b 沒有相同的標識
4 - a 和 b 沒有相同的標識複製代碼

is 與 == 區別：

is 用於判斷兩個變量引用對象是否爲同一個， == 用於判斷引用變量的值是否相等。

>>>a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True

9. Python運算符優先級

如下表格列出了從最高到最低優先級的全部運算符：

運算符	描述
**	指數 (最高優先級)
~ + -	按位翻轉, 一元加號和減號 (最後兩個的方法名爲 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法減法
>> <<	右移，左移運算符
&	位 'AND'
^ \|	位運算符
<= < > >=	比較運算符
== !=	等於運算符
= %= /= //= -= += = *=	賦值運算符
is is not	身份運算符
in not in	成員運算符
not and or	邏輯運算符

如下實例演示了Python全部運算符優先級的操做：

實例(Python 3.0+)

#!/usr/bin/python3
 
a = 20
b = 10
c = 15
d = 5
e = 0
 
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 運算結果爲：",  e)
 
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 運算結果爲：",  e)
 
e = (a + b) * (c / d);    # (30) * (15/5)
print ("(a + b) * (c / d) 運算結果爲：",  e)
 
e = a + (b * c) / d;      # 20 + (150/5)
print ("a + (b * c) / d 運算結果爲：",  e)複製代碼

以上實例輸出結果：

(a + b) * c / d 運算結果爲： 90.0
((a + b) * c) / d 運算結果爲： 90.0
(a + b) * (c / d) 運算結果爲： 90.0
a + (b * c) / d 運算結果爲： 50.0複製代碼

注意：Pyhton3 已不支持 <> 運算符，可使用 != 代替，若是你必定要使用這種比較運算符，可使用如下的方式：
>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True複製代碼

五、Python3 數字(Number)

Python 數字數據類型用於存儲數值。

數據類型是不容許改變的,這就意味着若是改變數字數據類型的值，將從新分配內存空間。

如下實例在變量賦值時 Number 對象將被建立：

var1 = 1
var2 = 10複製代碼

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

del語句的語法是：

del var1[,var2[,var3[....,varN]]]複製代碼

您能夠經過使用del語句刪除單個或多個對象的引用，例如：

del var
del var_a, var_b複製代碼

Python 支持三種不一樣的數值類型：

整型(Int) - 一般被稱爲是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，能夠看成 Long 類型使用，因此 Python3 沒有 Python2 的 Long 類型。
浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可使用科學計數法表示（2.5e2 = 2.5 x 10² = 250）
複數( (complex)) - 複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示，複數的實部a和虛部b都是浮點型。

咱們可使用十六進制和八進制來表明整數：

>>> number = 0xA0F # 十六進制
>>> number
2575

>>> number=0o37 # 八進制
>>> number
31複製代碼

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都是浮點型。

1. Python 數字類型轉換

有時候，咱們須要對數據內置的類型進行轉換，數據類型的轉換，你只須要將數據類型做爲函數名便可。

int(x) 將x轉換爲一個整數。
float(x) 將x轉換到一個浮點數。
complex(x) 將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) 將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。

如下實例將浮點數變量 a 轉換爲整數：

>>> a = 1.0
>>> int(a)
1複製代碼

2. Python 數字運算

Python 解釋器能夠做爲一個簡單的計算器，您能夠在解釋器裏輸入一個表達式，它將輸出表達式的值。

表達式的語法很直白： +, -, * 和 /, 和其它語言（如Pascal或C）裏同樣。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 老是返回一個浮點數
1.6複製代碼

注意：在不一樣的機器上浮點運算的結果可能會不同。

在整數除法中，除法 / 老是返回一個浮點數，若是隻想獲得整數的結果，丟棄可能的分數部分，可使用運算符 // ：

>>> 17 / 3  # 整數除法返回浮點型
5.666666666666667
>>>
>>> 17 // 3  # 整數除法返回向下取整後的結果
5
>>> 17 % 3  # ％操做符返回除法的餘數
2
>>> 5 * 3 + 2 
17複製代碼

注意：// 獲得的並不必定是整數類型的數，它與分母分子的數據類型有關係。

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 複製代碼

等號 = 用於給變量賦值。賦值以後，除了下一個提示符，解釋器不會顯示任何結果。

>>> width = 20
>>> height = 5*9
>>> width * height
900複製代碼

Python 可使用 ** 操做來進行冪運算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128複製代碼

變量在使用前必須先"定義"（即賦予變量一個值），不然會出現錯誤：

>>> n   # 嘗試訪問一個未定義的變量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined複製代碼

不一樣類型的數混合運算時會將整數轉換爲浮點數：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5複製代碼

在交互模式中，最後被輸出的表達式結果被賦值給變量 _ 。例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06複製代碼

此處， _ 變量應被用戶視爲只讀變量。

3. 數學函數

函數	返回值 ( 描述 )
abs(x)	返回數字的絕對值，如abs(-10) 返回 10
ceil(x)	返回數字的上入整數，如math.ceil(4.1) 返回 5
cmp(x, y)	若是 x < y 返回 -1, 若是 x == y 返回 0, 若是 x > y 返回 1。 Python 3 已廢棄，使用 (x>y)-(x<y) 替換。
exp(x)	返回e的x次冪(e^x),如math.exp(1) 返回2.718281828459045
fabs(x)	返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x)	返回數字的下舍整數，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10爲基數的x的對數，如math.log10(100)返回 2.0
max(x1, x2,...)	返回給定參數的最大值，參數能夠爲序列。
min(x1, x2,...)	返回給定參數的最小值，參數能夠爲序列。
modf(x)	返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
pow(x, y)	x**y 運算後的值。
round(x [,n])	返回浮點數x的四捨五入值，如給出n值，則表明舍入到小數點後的位數。
sqrt(x)	返回數字x的平方根。

4. 隨機數函數

隨機數能夠用於數學，遊戲，安全等領域中，還常常被嵌入到算法中，用以提升算法效率，並提升程序的安全性。

Python包含如下經常使用隨機數函數：

函數	描述
choice(seq)	從序列的元素中隨機挑選一個元素，好比random.choice(range(10))，從0到9中隨機挑選一個整數。
randrange ([start,] stop [,step])	從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數默認值爲 1
random()	隨機生成下一個實數，它在[0,1)範圍內。
seed([x])	改變隨機數生成器的種子seed。若是你不瞭解其原理，你沒必要特別去設定seed，Python會幫你選擇seed。
shuffle(lst)	將序列的全部元素隨機排序
uniform(x, y)	隨機生成下一個實數，它在[x,y]範圍內。

5. 三角函數

Python包括如下三角函數：

函數	描述
acos(x)	返回x的反餘弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回給定的 X 及 Y 座標值的反正切值。
cos(x)	返回x的弧度的餘弦值。
hypot(x, y)	返回歐幾里德範數 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	將弧度轉換爲角度,如degrees(math.pi/2) ，返回90.0
radians(x)	將角度轉換爲弧度

6. 數學常量

常量	描述
pi	數學常量 pi（圓周率，通常以π來表示）
e	數學常量 e，e即天然常數（天然常數）。

六、Python3 字符串

字符串是 Python 中最經常使用的數據類型。咱們可使用引號( ' 或 " )來建立字符串。

建立字符串很簡單，只要爲變量分配一個值便可。例如：

var1 = 'Hello World!' var2 = "Runoob"

1. Python 訪問字符串中的值

Python 不支持單字符類型，單字符在 Python 中也是做爲一個字符串使用。

Python 訪問子字符串，可使用方括號來截取字符串，以下實例：

實例(Python 3.0+)

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])複製代碼

以上實例執行結果：

var1[0]:  H
var2[1:5]:  unoo複製代碼

3. Python 字符串更新

你能夠截取字符串的一部分並與其餘字段拼接，以下實例：

實例(Python 3.0+)

#!/usr/bin/python3
 
var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')複製代碼

以上實例執行結果

已更新字符串 :  Hello Runoob!複製代碼

4. Python轉義字符

在須要在字符中使用特殊字符時，python用反斜槓(\)轉義字符。以下表：

轉義字符	描述
\(在行尾時)	續行符
\\	反斜槓符號
\'	單引號
\"	雙引號
\a	響鈴
\b	退格(Backspace)
\000	空
\n	換行
\v	縱向製表符
\t	橫向製表符
\r	回車
\f	換頁
\oyy	八進制數，yy 表明的字符，例如：\o12 表明換行，其中 o 是字母，不是數字 0。
\xyy	十六進制數，yy表明的字符，例如：\x0a表明換行
\other	其它的字符以普通格式輸出

5. Python字符串運算符

下表實例變量a值爲字符串 "Hello"，b變量值爲 "Python"：

操做符	描述	實例
+	字符串鏈接	a + b 輸出結果： HelloPython
*	重複輸出字符串	a*2 輸出結果：HelloHello
[]	經過索引獲取字符串中字符	a[1] 輸出結果 e
[ : ]	截取字符串中的一部分，遵循左閉右開原則，str[0,2] 是不包含第 3 個字符的。	a[1:4] 輸出結果 ell
in	成員運算符 - 若是字符串中包含給定的字符返回 True	'H' in a 輸出結果 True
not in	成員運算符 - 若是字符串中不包含給定的字符返回 True	'M' not in a 輸出結果 True
r/R	原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。原始字符串除在字符串的第一個引號前加上字母 r（能夠大小寫）之外，與普通字符串有着幾乎徹底相同的語法。	print( r'\n' ) print( R'\n' )複製代碼
%	格式字符串	請看下一節內容。

實例(Python 3.0+)

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 輸出結果：", a + b)
print("a * 2 輸出結果：", a * 2)
print("a[1] 輸出結果：", a[1])
print("a[1:4] 輸出結果：", a[1:4])
 
if( "H" in a) :
    print("H 在變量 a 中")
else :
    print("H 不在變量 a 中")
 
if( "M" not in a) :
    print("M 不在變量 a 中")
else :
    print("M 在變量 a 中")
 
print (r'\n')
print (R'\n')複製代碼

以上實例輸出結果爲：

a + b 輸出結果： HelloPython
a * 2 輸出結果： HelloHello
a[1] 輸出結果： e
a[1:4] 輸出結果： ell
H 在變量 a 中
M 不在變量 a 中
\n
\n複製代碼

6. Python字符串格式化

Python 支持格式化字符串的輸出。儘管這樣可能會用到很是複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用與 C 中 sprintf 函數同樣的語法。

實例(Python 3.0+)

#!/usr/bin/python3
 
print ("我叫 %s 今年 %d 歲!" % ('小明', 10))複製代碼

以上實例輸出結果：

我叫 小明 今年 10 歲!複製代碼

python字符串格式化符號:

符號	描述
%c	格式化字符及其ASCII碼
%s	格式化字符串
%d	格式化整數
%u	格式化無符號整型
%o	格式化無符號八進制數
%x	格式化無符號十六進制數
%X	格式化無符號十六進制數（大寫）
%f	格式化浮點數字，可指定小數點後的精度
%e	用科學計數法格式化浮點數
%E	做用同%e，用科學計數法格式化浮點數
%g	%f和%e的簡寫
%G	%f 和 %E 的簡寫
%p	用十六進制數格式化變量的地址

格式化操做符輔助指令:

符號	功能
*	定義寬度或者小數點精度
-	用作左對齊
+	在正數前面顯示加號( + )
<sp>	在正數前面顯示空格
#	在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決於用的是'x'仍是'X')
0	顯示的數字前面填充'0'而不是默認的空格
%	'%%'輸出一個單一的'%'
(var)	映射變量(字典參數)
m.n.	m 是顯示的最小總寬度,n 是小數點後的位數(若是可用的話)

Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它加強了字符串格式化的功能。

7. Python三引號

python三引號容許一個字符串跨多行，字符串中能夠包含換行符、製表符以及其餘特殊字符。實例以下

實例(Python 3.0+)

#!/usr/bin/python3
 
para_str = """這是一個多行字符串的實例 多行字符串可使用製表符 TAB ( \t )。 也可使用換行符 [ \n ]。 """
print (para_str)複製代碼

以上實例執行結果爲：

這是一個多行字符串的實例
多行字符串可使用製表符
TAB (    )。
也可使用換行符 [ 
 ]。複製代碼

三引號讓程序員從引號和特殊字符串的泥潭裏面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。

一個典型的用例是，當你須要一塊HTML或者SQL時，這時用字符串組合，特殊字符串轉義將會很是的繁瑣。

errHTML = ''' <HTML><HEAD><TITLE> Friends CGI Demo</TITLE></HEAD> <BODY><H3>ERROR</H3> <B>%s</B><P> <FORM><INPUT TYPE=button VALUE=Back ONCLICK="window.history.back()"></FORM> </BODY></HTML> '''
cursor.execute(''' CREATE TABLE users ( login VARCHAR(8), uid INTEGER, prid INTEGER) ''')複製代碼

8. f-string

f-string 是 python3.6 以後版本添加的，稱之爲字面量格式化字符串，是新的格式化字符串的語法。

以前咱們習慣用百分號 (%):

實例

>>> name = 'Runoob'
>>> 'Hello %s' % name'Hello Runoob'複製代碼

f-string 格式話字符串以 f 開頭，後面跟着字符串，字符串中的表達式用大括號 {} 包起來，它會將變量或表達式計算後的值替換進去，實例以下：

實例

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替換變量
>>> f'{1+2}'         # 使用表達式'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}''Runoob: www.runoob.com'複製代碼

用了這種方式明顯更簡單了，不用再去判斷使用 %s，仍是 %d。

在 Python 3.8 的版本中可使用 = 符號來拼接運算表達式與結果：

實例

>>> x = 1
>>> print(f'{x+1}')   # Python 3.62
>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8'x+1=2'複製代碼

9. Unicode 字符串

在Python2中，普通字符串是以8位ASCII碼進行存儲的，而Unicode字符串則存儲爲16位unicode字符串，這樣可以表示更多的字符集。使用的語法是在字符串前面加上前綴 u。

在Python3中，全部的字符串都是Unicode字符串。

10. Python 的字符串內建函數

Python 的字符串經常使用內建函數以下：

序號	方法及描述
1	capitalize() 將字符串的第一個字符轉換爲大寫
2	center(width, fillchar) 返回一個指定的寬度 width 居中的字符串，fillchar 爲填充的字符，默認爲空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 裏面出現的次數，若是 beg 或者 end 指定則返回指定範圍內 str 出現的次數
4	bytes.decode(encoding="utf-8", errors="strict") Python3 中沒有 decode 方法，但咱們可使用 bytes 對象的 decode() 方法來解碼給定的 bytes 對象，這個 bytes 對象能夠由 str.encode() 來編碼返回。
5	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的編碼格式編碼字符串，若是出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'
6	endswith(suffix, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，若是beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，若是是，返回 True,不然返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8 。
8	find(str, beg=0, end=len(string)) 檢測 str 是否包含在字符串中，若是指定範圍 beg 和 end ，則檢查是否包含在指定範圍內，若是包含返回開始的索引值，不然返回-1
9	index(str, beg=0, end=len(string)) 跟find()方法同樣，只不過若是str不在字符串中會報一個異常.
10	isalnum() 若是字符串至少有一個字符而且全部字符都是字母或數字則返回 True,不然返回 False
11	isalpha() 若是字符串至少有一個字符而且全部字符都是字母則返回 True, 不然返回 False
12	isdigit() 若是字符串只包含數字則返回 True 不然返回 False..
13	islower() 若是字符串中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是小寫，則返回 True，不然返回 False
14	isnumeric() 若是字符串中只包含數字字符，則返回 True，不然返回 False
15	isspace() 若是字符串中只包含空白，則返回 True，不然返回 False.
16	istitle() 若是字符串是標題化的(見 title())則返回 True，不然返回 False
17	isupper() 若是字符串中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是大寫，則返回 True，不然返回 False
18	join(seq) 以指定字符串做爲分隔符，將 seq 中全部的元素(的字符串表示)合併爲一個新的字符串
19	len(string) 返回字符串長度
20	ljust(width[, fillchar]) 返回一個原字符串左對齊,並使用 fillchar 填充至長度 width 的新字符串，fillchar 默認爲空格。
21	lower() 轉換字符串中全部大寫字符爲小寫.
22	lstrip() 截掉字符串左邊的空格或指定字符。
23	maketrans() 建立字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示須要轉換的字符，第二個參數也是字符串表示轉換的目標。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把將字符串中的 str1 替換成 str2,若是 max 指定，則替換不超過 max 次。
27	rfind(str, beg=0,end=len(string)) 相似於 find()函數，不過是從右邊開始查找.
28	rindex( str, beg=0, end=len(string)) 相似於 index()，不過是從右邊開始.
29	rjust(width,[, fillchar]) 返回一個原字符串右對齊,並使用fillchar(默認空格）填充至長度 width 的新字符串
30	rstrip() 刪除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) num=string.count(str)) 以 str 爲分隔符截取字符串，若是 num 有指定值，則僅截取 num+1 個子字符串
32	splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，若是參數 keepends 爲 False，不包含換行符，若是爲 True，則保留換行符。
33	startswith(substr, beg=0,end=len(string)) 檢查字符串是不是以指定子字符串 substr 開頭，是則返回 True，不然返回 False。若是beg 和 end 指定值，則在指定範圍內檢查。
34	strip([chars]) 在字符串上執行 lstrip()和 rstrip()
35	swapcase() 將字符串中大寫轉換爲小寫，小寫轉換爲大寫
36	title() 返回"標題化"的字符串,就是說全部單詞都是以大寫開始，其他字母均爲小寫(見 istitle())
37	translate(table, deletechars="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符, 要過濾掉的字符放到 deletechars 參數中
38	upper() 轉換字符串中的小寫字母爲大寫
39	zfill (width) 返回長度爲 width 的字符串，原字符串右對齊，前面填充0
40	isdecimal() 檢查字符串是否只包含十進制字符，若是是返回 true，不然返回 false。

七、Python3 列表

序列是Python中最基本的數據結構。序列中的每一個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。

Python有6個序列的內置類型，但最多見的是列表和元組。

序列均可以進行的操做包括索引，切片，加，乘，檢查成員。

此外，Python已經內置肯定序列的長度以及肯定最大和最小的元素的方法。

列表是最經常使用的Python數據類型，它能夠做爲一個方括號內的逗號分隔值出現。

列表的數據項不須要具備相同的類型

建立一個列表，只要把逗號分隔的不一樣的數據項使用方括號括起來便可。以下所示：

list1 = ['Google', 'Runoob', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"];

與字符串的索引同樣，列表索引從0開始。列表能夠進行截取、組合等。

1. 訪問列表中的值

使用下標索引來訪問列表中的值，一樣你也可使用方括號的形式截取字符，以下所示：

實例(Python 3.0+)

#!/usr/bin/python3
 
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])複製代碼

以上實例輸出結果：

list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]複製代碼

2. 更新列表

你能夠對列表的數據項進行修改或更新，你也可使用append()方法來添加列表項，以下所示：

實例(Python 3.0+)

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三個元素爲 : ", list[2])
list[2] = 2001
print ("更新後的第三個元素爲 : ", list[2])複製代碼

注意：咱們會在接下來的章節討論append()方法的使用

以上實例輸出結果：

第三個元素爲 :  1997
更新後的第三個元素爲 :  2001複製代碼

3. 刪除列表元素

可使用 del 語句來刪除列表的的元素，以下實例：

實例(Python 3.0+)

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("刪除第三個元素 : ", list)複製代碼

以上實例輸出結果：

原始列表 :  ['Google', 'Runoob', 1997, 2000]
刪除第三個元素 :  ['Google', 'Runoob', 2000]複製代碼

注意：咱們會在接下來的章節討論 remove() 方法的使用

4. Python列表腳本操做符

列表對 + 和 * 的操做符與字符串類似。+ 號用於組合列表，* 號用於重複列表。

以下所示：

Python 表達式	結果	描述
len([1, 2, 3])	3	長度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	組合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重複
3 in [1, 2, 3]	True	元素是否存在於列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

5. Python列表截取與拼接

Python的列表截取與字符串操做類型，以下所示：

L=['Google', 'Runoob', 'Taobao']

操做：

Python 表達式	結果	描述
L[2]	'Taobao'	讀取第三個元素
L[-2]	'Runoob'	從右側開始讀取倒數第二個元素: count from the right
L[1:]	['Runoob', 'Taobao']	輸出從第二個元素開始後的全部元素

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>複製代碼

列表還支持拼接操做：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>複製代碼

6. 嵌套列表

使用嵌套列表即在列表裏建立其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'複製代碼

7. Python列表函數&方法

Python包含如下函數:

序號	函數
1	len(list) 列表元素個數
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 將元組轉換爲列表

Python包含如下方法:

序號	方法
1	list.append(obj) 在列表末尾添加新的對象
2	list.count(obj) 統計某個元素在列表中出現的次數
3	list.extend(seq) 在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表）
4	list.index(obj) 從列表中找出某個值第一個匹配項的索引位置
5	list.insert(index, obj) 將對象插入列表
6	list.pop([index=-1]) 移除列表中的一個元素（默認最後一個元素），而且返回該元素的值
7	list.remove(obj) 移除列表中某個值的第一個匹配項
8	list.reverse() 反向列表中元素
9	list.sort( key=None, reverse=False) 對原列表進行排序
10	list.clear() 清空列表
11	list.copy() 複製列表

八、Python3 元組

Python 的元組與列表相似，不一樣之處在於元組的元素不能修改。

元組使用小括號，列表使用方括號。

元組建立很簡單，只須要在括號中添加元素，並使用逗號隔開便可。

實例(Python 3.0+)

>>>tup1 = ('Google', 'Runoob', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";   # 不須要括號也能夠
>>> type(tup3)
<class 'tuple'>複製代碼

建立空元組

tup1 = ();複製代碼

元組中只包含一個元素時，須要在元素後面添加逗號，不然括號會被看成運算符使用：

實例(Python 3.0+)

>>>tup1 = (50)
>>> type(tup1)     # 不加逗號，類型爲整型
<class 'int'>
 
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗號，類型爲元組
<class 'tuple'>複製代碼

元組與字符串相似，下標索引從0開始，能夠進行截取，組合等。

4. 訪問元組

元組可使用下標索引來訪問元組中的值，以下實例:

實例(Python 3.0+)

#!/usr/bin/python3
 
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])複製代碼

以上實例輸出結果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)複製代碼

5. 修改元組

元組中的元素值是不容許修改的，但咱們能夠對元組進行鏈接組合，以下實例:

實例(Python 3.0+)

#!/usr/bin/python3
 
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
 
# 如下修改元組元素操做是非法的。
# tup1[0] = 100
 
# 建立一個新的元組
tup3 = tup1 + tup2;
print (tup3)複製代碼

以上實例輸出結果：

(12, 34.56, 'abc', 'xyz')複製代碼

6. 刪除元組

元組中的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組，以下實例:

實例(Python 3.0+)

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup;
print ("刪除後的元組 tup : ")
print (tup)複製代碼

以上實例元組被刪除後，輸出變量會有異常信息，輸出以下所示：

刪除後的元組 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined複製代碼

7. 元組運算符

與字符串同樣，元組之間可使用 + 號和 * 號進行運算。這就意味着他們能夠組合和複製，運算後會生成一個新的元組。

Python 表達式	結果	描述
len((1, 2, 3))	3	計算元素個數
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	鏈接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	複製
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

8. 元組索引，截取

由於元組也是一個序列，因此咱們能夠訪問元組中的指定位置的元素，也能夠截取索引中的一段元素，以下所示：

元組：

L = ('Google', 'Taobao', 'Runoob')複製代碼

Python 表達式	結果	描述
L[2]	'Runoob'	讀取第三個元素
L[-2]	'Taobao'	反向讀取；讀取倒數第二個元素
L[1:]	('Taobao', 'Runoob')	截取元素，從第二個開始後的全部元素。

運行實例以下：

>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')複製代碼

9. 元組內置函數

Python元組包含了如下內置函數

序號	方法及描述	實例
1	len(tuple) 計算元組元素個數。	>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> 複製代碼
2	max(tuple) 返回元組中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> 複製代碼
3	min(tuple) 返回元組中元素最小值。	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> 複製代碼
4	tuple(seq) 將列表轉換爲元組。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')複製代碼

九、Python3 字典

字典是另外一種可變容器模型，且可存儲任意類型對象。

字典的每一個鍵值(key=>value)對用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式以下所示：

d = {key1 : value1, key2 : value2 }複製代碼

鍵必須是惟一的，但值則沒必要。

值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。

一個簡單的字典實例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}複製代碼

也可如此建立字典：

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }複製代碼

1. 訪問字典裏的值

把相應的鍵放入到方括號中，以下實例:

實例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])複製代碼

以上實例輸出結果：

dict['Name']:  Runoob
dict['Age']:  7複製代碼

若是用字典裏沒有的鍵訪問數據，會輸出錯誤以下：

實例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Alice']: ", dict['Alice'])複製代碼

以上實例輸出結果：

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'複製代碼

2. 修改字典

向字典添加新內容的方法是增長新的鍵/值對，修改或刪除已有鍵/值對以下實例:

實例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鳥教程"  # 添加信息
 
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])複製代碼

以上實例輸出結果：

dict['Age']:  8
dict['School']:  菜鳥教程複製代碼

3. 刪除字典元素

能刪單一的元素也能清空字典，清空只需一項操做。

顯示刪除一個字典用del命令，以下實例：

實例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 刪除鍵 'Name'
dict.clear()     # 清空字典
del dict         # 刪除字典
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])複製代碼

但這會引起一個異常，由於用執行 del 操做後字典再也不存在：

Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable複製代碼

注：del() 方法後面也會討論。

4. 字典鍵的特性

字典值能夠是任何的 python 對象，既能夠是標準的對象，也能夠是用戶定義的，但鍵不行。

兩個重要的點須要記住：

1）不容許同一個鍵出現兩次。建立時若是同一個鍵被賦值兩次，後一個值會被記住，以下實例：

實例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鳥'}
 
print ("dict['Name']: ", dict['Name'])複製代碼

以上實例輸出結果：

dict['Name']:  小菜鳥複製代碼

2）鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行，以下實例：

實例

#!/usr/bin/python3
 
dict = {['Name']: 'Runoob', 'Age': 7}
 
print ("dict['Name']: ", dict['Name'])複製代碼

以上實例輸出結果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'複製代碼

5. 字典內置函數&方法

Python字典包含了如下內置函數：

序號	函數及描述	實例
1	len(dict) 計算字典元素個數，即鍵的總數。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3複製代碼
2	str(dict) 輸出字典，以可打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"複製代碼
3	type(variable) 返回輸入的變量類型，若是變量是字典就返回字典類型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) <class 'dict'>複製代碼

序號

函數及描述

實例

len(dict)
計算字典元素個數，即鍵的總數。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3複製代碼

str(dict)
輸出字典，以可打印的字符串表示。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"複製代碼

type(variable)
返回輸入的變量類型，若是變量是字典就返回字典類型。

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(dict)
<class 'dict'>複製代碼

Python字典包含了如下內置方法：

序號	函數及描述
1	radiansdict.clear() 刪除字典內全部元素
2	radiansdict.copy() 返回一個字典的淺複製
3	radiansdict.fromkeys() 建立一個新字典，以序列seq中元素作字典的鍵，val爲字典全部鍵對應的初始值
4	radiansdict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回default值
5	key in dict 若是鍵在字典dict裏返回true，不然返回false
6	radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組
7	radiansdict.keys() 返回一個迭代器，可使用 list() 來轉換爲列表
8	radiansdict.setdefault(key, default=None) 和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default
9	radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict裏
10	radiansdict.values() 返回一個迭代器，可使用 list() 來轉換爲列表
11	pop(key[,default]) 刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。不然，返回default值。
12	popitem() 隨機返回並刪除字典中的最後一對鍵和值。

十、Python3 集合

集合（set）是一個無序的不重複元素序列。

可使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。

建立格式：

parame = {value01,value02,...}
或者
set(value)複製代碼

實例(Python 3.0+)

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 這裏演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判斷元素是否在集合內
True
>>> 'crabgrass' in basket
False
 
>>> # 下面展現兩個集合間的運算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的全部元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不一樣時包含於a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}複製代碼

相似列表推導式，一樣集合支持集合推導式(Set comprehension):

實例(Python 3.0+)

>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}複製代碼

集合的基本操做

一、添加元素

語法格式以下：

s.add( x )複製代碼

將元素 x 添加到集合 s 中，若是元素已存在，則不進行任何操做。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}複製代碼

還有一個方法，也能夠添加元素，且參數能夠是列表，元組，字典等，語法格式以下：

s.update( x )複製代碼

x 能夠有多個，用逗號分開。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>複製代碼

二、移除元素

語法格式以下：

s.remove( x )複製代碼

將元素 x 從集合 s 中移除，若是元素不存在，則會發生錯誤。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在會發生錯誤
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>複製代碼

此外還有一個方法也是移除集合中的元素，且若是元素不存在，不會發生錯誤。格式以下所示：

s.discard( x )複製代碼

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不會發生錯誤
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}複製代碼

咱們也能夠設置隨機刪除集合中的一個元素，語法格式以下：

s.pop() 複製代碼

腳本模式實例(Python 3.0+)

thisset = set(("Google", "Runoob", "Taobao", "Facebook")) x = thisset.pop() print(x)

輸出結果：

$ python3 test.py 
Runoob複製代碼

屢次執行測試結果都不同。

然而在交互模式，pop 是刪除集合的第一個元素（排序後的集合的第一個元素）。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> thisset.pop()
'Facebook'
>>> print(thisset)
{'Google', 'Taobao', 'Runoob'}
>>>複製代碼

三、計算集合元素個數

語法格式以下：

len(s)複製代碼

計算集合 s 元素個數。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3複製代碼

四、清空集合

語法格式以下：

s.clear()複製代碼

清空集合 s。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()複製代碼

五、判斷元素是否在集合中存在

語法格式以下：

x in s複製代碼

判斷元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

實例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>複製代碼

6. 集合內置方法完整列表

方法	描述
add()	爲集合添加元素
clear()	移除集合中的全部元素
copy()	拷貝一個集合
difference()	返回多個集合的差集
difference_update()	移除集合中的元素，該元素在指定的集合也存在。
discard()	刪除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判斷兩個集合是否包含相同的元素，若是沒有返回 True，不然返回 False。
issubset()	判斷指定集合是否爲該方法參數集合的子集。
issuperset()	判斷該方法的參數集合是否爲指定集合的子集
pop()	隨機移除元素
remove()	移除指定元素
symmetric_difference()	返回兩個集合中不重複的元素集合。
symmetric_difference_update()	移除當前集合中在另一個指定集合相同的元素，並將另一個指定集合中不一樣的元素插入到當前集合中。
union()	返回兩個集合的並集
update()	給集合添加元素

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。