一、Python語言家族

1 Introduction

1.1 Python 簡介

Python 是一個高層次的結合瞭解釋性、編譯性、互動性和麵向物件的指令碼語言。

簡單來說，Python是一門程式語言，幫助我們更好的與計算機溝通，功能全面、易學易用、可擴充語言，所以說，人生苦短，我學Python。

Python 的設計具有很強的可讀性，相比其他語言經常使用英文關鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結構。

• Python 是一種解釋型高階語言: 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
• Python 是互動式語言: 這意味著，您可以在一個Python提示符，直接互動執行寫你的程式。
• Python 是面嚮物件語言: 這意味著Python支援物件導向的風格或程式碼封裝在物件的程式設計技術。
• Python 是初學者的語言: Python 對初級程式設計師而言，是一種偉大的語言，開發程式碼量少，模組擴充套件庫種類繁多，所以它支援廣泛的應用程式開發，從簡單的文書處理到 WWW 瀏覽器再到遊戲。

擴充套件：編譯型與解釋型的原理

• 編譯型：編譯器將原始碼逐條編譯成機器程式碼，任何一條語句 有錯，都不能通過編譯，最終形成目的碼，以後每次執行只執 行目的碼即可，因此執行速度快。
• 解釋型：直譯器逐條解釋原始碼，成功一條就執行一 條，每次執行時都需要解釋，所以速度稍慢

1.2 Python發展歷史

• Python的作者是荷蘭人Guido von Rossum（龜叔）
• 1982年，Guido從阿姆斯特丹大學(University of Amsterdam)獲得了數學和計算機碩士學位。然而，儘管他算得上是一位數學家，但他更加享受計算機帶來的樂趣。用他的話說，儘管擁有數學和計算機雙料資質，他總趨向於做計算機相關的工作，並熱衷於做任何和程式設計相關的活兒。
• 1989年，為了打發聖誕節假期，Guido開始寫Python語言的編譯/直譯器。Python來自Guido所摯愛的電視劇Monty Python’s Flying Circus (BBC1960-1970年代播放的室內情景幽默劇，以當時的英國生活為素材)。他希望這個新的叫做Python的語言，能實現他的理念(一種C和shell之間，功能全面，易學易用，可擴充的語言)。Guido作為一個語言設計愛好者，已經有過設計語言的(不很成功)的嘗試。這一次，也不過是一次純粹的hacking行為。
• Python正式誕生於1991年
• Python目前有兩個版本，Python2和Python3，程式碼不完全相容
• 原始檔.py檔案猴字尾名
• Python的直譯器如今有多個語言實現，通常用的是Cpython或者IPython（官方版本的C語言實現），其他還有Jpython（Java平臺）、IronPython（NET和Mono平臺）、PyPy（Python實現）

擴充套件：Python2還是Python3

• py2.7是2.x系列的最後一個版本，已經停止開發，不再增加新功能。2020年終止支援。所有的最新的標準庫的更新改進，只會在3.x的版本里出現。Guido決定清理Python2.x ，並且不再相容舊版本。
• 最大的一個改變就是使用Unicode作為預設編碼。Pyhton2.x中直接寫中文會報錯，Python3中可以直接寫中文了。從開源專案看，支援py3的比例已經大大提高，知名的專案一般都支援py2.7和py3+。
• py3比py2更規範統一、去掉了沒必要的關鍵字Python3.x還在持續改進。
• 所以我們還是推薦大家使用Python3.x。

2 Python的安裝與使用

2.1 Python環境搭建

• Python可應用於多平臺包括Windows、 Linux/Unix 和 Mac OS。

• Python有不同的搭建環境包括Python直譯器(CPython)、編輯器(（)IDLE，PyCharm，Sublime Text)、Python軟體包管理系統(pip)

2.1.1 環境下載

• Python最新原始碼，直譯器環境等最新下載

  Python官網:http://www.python.org/

• Python 權威使用技術文件等最新下載

  Python文件下載地址:http://www.python.org/doc/

2.1.2 Python編輯器

• Ipython IDLE
• Vim和macVim（linux，unix，macOSX）
• Eclipse+pyDEV
• Xcode（macOSX）
• Notepad++（win）
• Sublime Text（win，macOSX，linux，unix）
• PyCharm（全平臺）

2.1.3 Unix & Linux 平臺安裝 Python:(原始碼式安裝)

• 以下為在Unix & Linux 平臺上安裝 Python 的簡單步驟：
  • 開啟WEB瀏覽器訪問http://www.python.org/download/
  • 選擇適用於Unix/Linux的原始碼壓縮包。
  • 下載及解壓壓縮包。
  • 如果你需要自定義一些選項修改Modules/Setup
  • 執行 ./configure 指令碼
  • make
  • make install
• 執行以上操作後，Python會安裝在 /usr/local/bin 目錄中，Python庫安裝在/usr/local/lib/pythonXX，XX為你使用的Python的版本號。

2.1.4 通過ubuntu官方的apt工具包安裝

   $ sudo apt-get install python  
   $ sudo apt-get install python2.7  
   $ sudo apt-get install python3.6

2.1.5 Mac安裝Python3

   $ brew sreach python
   $ brew install python3
   //在/usr/local/Cellar/這個目錄下

2.1.6 windows下直接安裝

① 首先訪問http://www.python.org/download/ 下載最新環境

② 然後選擇最新版本，並適用於自己系統的環境

③ 下載後，雙擊安裝,選擇“Install Now”預設安裝，但一定勾選“Add Python 3.7 toPATH”

④ 如果沒有新增環境，在安裝之後，配置環境

3 Python的執行

執行Python的三種方式

1. 互動式直譯器

2. 命令列執行Python原始碼

3. 使用編輯器或整合開發環境（IDE）例如：pycharm

3.1 互動式直譯器

• 你可以通過命令列視窗進入python並開在互動式直譯器中開始編寫Python程式碼。
• 你可以在Unix，DOS或任何其他提供了命令列或者shell的系統進行python編碼工作。

$ python # Unix/Linux 
或者 
C:>python # Windows/DOS

• 以下為Python命令列引數：

選項	描述
-d	在解析時顯示除錯資訊
-O	生成優化程式碼 ( .pyo 檔案 )
-S	啟動時不引入查詢Python路徑的位置
-V	輸出Python版本號
-X	從 1.6版本之後基於內建的異常（僅僅用於字串）已過時。
-c cmd	執行 Python 指令碼，並將執行結果作為 cmd 字串。
file	在給定的python檔案執行python指令碼。

3.2 命令列指令碼

• 在記事本中輸入下列程式碼，另存為test.py檔案

import requests
response=requests.get(https://img-bss.csdnimg.cn/201906261028104896.png)
pic = open('photo.jpg','wb')
pic.write(response.content)

• 在你的應用程式中通過引入直譯器可以在命令列中執行Python指令碼，如下所示：

$ python test.py # Unix/Linux 
或者 
C:>python test.py # Windows/DOS

3.3 整合開發環境

• PyCharm 是由 JetBrains 打造的一款 Python IDE，支援 macOS、 Windows、 Linux 系統。
• PyCharm 功能 : 除錯、語法高亮、Project管理、程式碼跳轉、智慧提示、自動完成、單元測試、版本控制……
• PyCharm 下載地址 : https://www.jetbrains.com/pycharm/download/

3.3.1 Pycharm的基本使用

下載安裝後，新建一個專案

選擇Python直譯器，並確定專案名稱

新建一個Python原始碼檔案

給原始檔起名字

執行原始檔

得到執行結果

4 Python基礎語法

4.1 Python註釋

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

• python中單行註釋採用 # 開頭。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 檔名：test.py

# 第一個註釋
print("Hello, Python!")  # 第二個註釋

輸出結果：

Hello, Python!

註釋可以在語句或表示式行末：

name = "Madisetti" # 這是一個註釋

• python 中多行註釋使用三個單引號(’’’)或三個雙引號(""")。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 檔名：test.py

'''
這是多行註釋，使用單引號。
這是多行註釋，使用單引號。
這是多行註釋，使用單引號。
'''

"""
這是多行註釋，使用雙引號。
這是多行註釋，使用雙引號。
這是多行註釋，使用雙引號。
"""

4.2 Python語法格式-縮排

• python最具特色的就是使用縮排來表示程式碼塊，不需要使用大括號({})。
• 縮排的空格數是可變的，但是同一個程式碼塊的語句必須包含相同的縮排空格數。
• 縮排強迫大家寫出格式化的程式碼
• 當語句以’:’結尾時，縮排的語句視為程式碼塊
• 約定俗成管理，4個空格為一個縮排
• Python大小寫敏感

例項如下：

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

多行語句

• Python 通常是一行寫完一條語句，但如果語句很長，我們可以使用反斜槓()來實現多行語句，例如：

total = item_one + \
        item_two + \
        item_three

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

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

空行

• 函式之間或類的方法之間用空行分隔，表示一段新的程式碼的開始。類和函式入口之間也用一行空行分隔，以突出函式入口的開始。
• 空行與程式碼縮排不同，空行並不是Python語法的一部分。書寫時不插入空行，Python直譯器執行也不會出錯。但是空行的作用在於分隔兩段不同功能或含義的程式碼，便於日後程式碼的維護或重構。
• 記住：空行也是程式程式碼的一部分。

4.3 輸入和輸出：

input()輸入：

• input()的小括號中放入的是，提示資訊，用來在獲取資料之前給使用者的一個簡單提示
• input()在從鍵盤獲取了資料以後，會存放到等號右邊的變數中
• input()會把使用者輸入的任何值都作為字串來對待
• 注意：在python2中還有一個raw_input()輸入，但到python3中沒有了

#!/usr/bin/python3

str = input("請輸入：");
print ("你輸入的內容是: ", str)

• 這會產生如下的對應著輸入的結果：

請輸入：Hello Python!
你輸入的內容是:  Hello Python!

Print()輸出：

• print 預設輸出是換行的，如果要實現不換行需要在變數末尾加上 end=""：

#!/usr/bin/python3

x="a"
y="b"
# 換行輸出
print( x )
print( y )

print('---------')
# 不換行輸出
print( x, end=" " )
print( y, end=" " )
print()

# 同時輸出多個變數
print(x,y)

format的格式化函式（瞭解）

• 格式化字串的函式 str.format()，它增強了字串格式化的功能。
• 基本語法是通過 {} 和 : 來代替以前的 % 。

>>>"{} {}".format("hello", "world")    # 不設定指定位置，按預設順序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 設定指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 設定指定位置
'world hello world'

>>> print("網站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com")) #指定引數名
'網站名：百度, 地址 www.baidu.com'


>>>site = {"name": "百度", "url": "www.baidu.com"}
>>>print("網站名：{name}, 地址 {url}".format(**site)) # 通過字典設定引數
'網站名：百度, 地址 www.baidu.com' 

>>>my_list = ['百度', 'www.baidu.com']
>>>print("網站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必須的 通過列表索引設定引數
'網站名：百度, 地址 www.baidu.com'

>>> print("{:.2f}".format(3.1415926)); #數字格式化
3.14

數字	格式	輸出	描述
3.1415926	{:.2f}	3.14	保留小數點後兩位
3.1415926	{:+.2f}	+3.14	帶符號保留小數點後兩位
-1	{:+.2f}	-1.00	帶符號保留小數點後兩位
2.71828	{:.0f}	3	不帶小數
5	{:0>2d}	05	數字補零 (填充左邊, 寬度為2)
5	{:x<4d}	5xxx	數字補x (填充右邊, 寬度為4)
10	{:x<4d}	10xx	數字補x (填充右邊, 寬度為4)
1000000	{:,}	1,000,000	以逗號分隔的數字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指數記法
13	{:10d}	13	右對齊 (預設, 寬度為10)
13	{:<10d}	13	左對齊 (寬度為10)
13	{:^10d}	13	中間對齊 (寬度為10)
11	‘{:b}’.format(11) ‘{:d}’.format(11) ‘{?}’.format(11) ‘{:x}’.format(11) ‘{:#x}’.format(11) ‘{:#X}’.format(11)	1011 11 13 b 0xb 0XB	進位制

Python中的變數

• Python 中的變數不需要宣告。每個變數在使用前都必須賦值，變數賦值以後該變數才會被建立。
• 在 Python 中，變數就是變數，它沒有型別，我們所說的"型別"是變數所指的記憶體中物件的型別。
• 等號（=）用來給變數賦值。
• 等號（=）運算子左邊是一個變數名,等號（=）運算子右邊是儲存在變數中的值。例如：
• 例項(Python 3.0+)

#!/usr/bin/python3

counter = 100          # 整型變數
miles   = 1000.0       # 浮點型變數
name    = "demo"     # 字串

print (counter)
print (miles)
print (name)

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

  100
  1000.0
  demo
  

多個變數賦值

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

  a = b = c = 1
  

• 以上例項，建立一個整型物件，值為1，三個變數被分配到相同的記憶體空間上。

• 您也可以為多個物件指定多個變數。例如：

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

• 以上例項，兩個整型物件 1 和 2 的分配給變數 a 和 b，字串物件 “demo” 分配給變數 c。

變數的命名

• 在一個程式碼段內，儘量不要重名
• 變數名由字母、數字、下劃線組成,但不能以數字開頭
• Python 中的識別符號是區分大小寫
• Python保留字: 保留字即關鍵字，我們不能把它們用作任何變數名稱
• 變數命名要符合PEP8規範，駝峰命名法

例如：
teacherName = 'yh'
stu_self = MiddleStudent( 'yh',20)

識別符號

• 在Python裡，識別符號: 由字母、數字、下劃線組成,但不能以數字開頭。

• Python 中的識別符號是區分大小寫的。

• 特殊識別符號：

  • 以下劃線開頭的識別符號是有特殊意義的。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的介面進行訪問，不能用 from xxx import * 而匯入；
  • 以雙下劃線開頭的 __foo 代表類的私有成員；以雙下劃線開頭和結尾的 __foo__ 代表 Python 裡特殊方法專用的標識，如 __init__() 代表類的建構函式。

• 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', 
  'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'if',
  'return','try', 'while', 'with', 'yield']
  

5 資料型別

5.1 內建的基本資料型別

• Python3中，只有一種整型型別int
• 內建的type()函式可以查詢變數所指的物件型別
• 也可以使用內建的isinstance()函式來判斷
• Python3中True的值是1，False的值是0
• 浮點只有單精度float，沒有double雙精度

5.2 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

整數的進位制:

# 輸出其他進位制數值

>>> bin(255) #255的二進位制
'0b11111111'
>>> oct(255) #255的八進位制
'0o377'
>>> hex(255) #255的十六進位制
'0xff'

>>> a=0b10   #賦值二進位制數值
>>> a
2
>>> a=0o10   #賦值八進位制數值
>>> a
8
>>> a=0x10   #賦值十六進位制數值
>>> a
16

5.2 字串

• Python中字串三種標示

  • 使用單引號(’) str=‘this is string’
  • 使用雙引號(") str=“this is string”
  • 使用三引號(’’’) str=’’‘this is string’’’

• 字串切片擷取語法如下：

• 變數[起始下標：結束下標：步進]

• 反斜槓可以轉義特殊字元

• 常用字串操作函式 len(),replace(),index(),find(),split()等

• 加號 (+) 是字串的連線符， 星號 (*) 表示複製當前字串，緊跟的數字為複製的次數。例項如下：

#!/usr/bin/python3

str = 'zhangsan'

print (str)          # 輸出字串
print (str[0:-1])    # 輸出第一個到倒數第二個的所有字元
print (str[0])       # 輸出字串第一個字元
print (str[2:5])     # 輸出從第三個開始到第五個的字元
print (str[2:])      # 輸出從第三個開始的後的所有字元
print (str * 2)      # 輸出字串兩次
print (str + "TEST") # 連線字串

• 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中的字串不能改變。

5.3 列表

• List（列表）是一種有序集合，可以隨時新增和刪除其中元素

• 列表的元素可以不同

• 列表同樣支援切片擷取語法如下：

  • 變數[起始下標：結束下標：步進]

• 列表格式[“yh”,“micheal”,“jack”]，[]之間，元素逗號隔開

• 索引值從0開始，-1代表末尾

• 使用(+)可以連線兩個列表，(*)是重複操作

  #!/usr/bin/python3
  
  list = [ 'abcd', 786 , 2.23, 'demo', 70.2 ]
  tinylist = [123, 'demo']
  
  print (list)            # 輸出完整列表
  print (list[0])         # 輸出列表第一個元素
  print (list[1:3])       # 從第二個開始輸出到第三個元素
  print (list[2:])        # 輸出從第三個元素開始的所有元素
  print (tinylist * 2)    # 輸出兩次列表
  print (list + tinylist) # 連線列表
  

  • 以上例項輸出結果：

    ['abcd', 786, 2.23, 'demo', 70.2]
    abcd
    [786, 2.23]
    [2.23, 'demo', 70.2]
    [123, 'demo', 123, 'demo']
    ['abcd', 786, 2.23, 'demo', 70.2, 123, 'demo']
    

• 與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中的元素是可以改變的。

5.4 元組

• Tuple（元組）與列表類似，不同之處在於元組的元素不能修改
• 元組寫在小括號()裡，元素之 間用逗號隔開
• 元組中元素型別也可以不同
• 列表同樣支援切片
• 索引值從0開始，-1代表末尾
• 如果元組中的元素只有一個，那麼寫成(1,)，不要寫成(1)

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'demo', 70.2  )
tinytuple = (123, 'demo')

print (tuple)             # 輸出完整元組
print (tuple[0])          # 輸出元組的第一個元素
print (tuple[1:3])        # 輸出從第二個元素開始到第三個元素
print (tuple[2:])         # 輸出從第三個元素開始的所有元素
print (tinytuple * 2)     # 輸出兩次元組
print (tuple + tinytuple) # 連線元組

• 以上例項輸出結果：

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

• 元組與字串類似，可以被索引且下標索引從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個元素的元組的特殊語法規則。
  • 元組也可以使用+操作符進行拼接。

5.5 集合

• Set（集合），是一個無序不重複元素的序列

• 可以使用大括號 { } 或者set()函式建立集合

  • 注意:建立一個空集合必須用set()而不是 { }，因為 { } 是用來建立一個空字典

• 建立格式：

  • {value1, value2, value3, value4,….} 或者 set（value）

• 集合之間可以進行:-差集 &交集 |並集 ^反交集

• # 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'}
  

5.6 字典

• 字典（dictionary）是無序集合物件，元素是通過key-value鍵值對來存取的

• 字典是一種對映型別，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value) 對集合

• 鍵(key)必須使用不可變型別、在同一個字典中，鍵(key)必須是唯一的

• 另外，字典型別也有一些內建的函式，例如clear()、keys()、values()等。

• 字典方便我們使用查詢和搜尋功能

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - Python教程"
dict[2] = "2 - Python工具"

tinydict = {'name': 'demo','code':1, 'site': 'www.demo.com'}


print (dict['one'])       # 輸出鍵為 'one' 的值
print (dict[2])           # 輸出鍵為 2 的值
print (tinydict)          # 輸出完整的字典
print (tinydict.keys())   # 輸出所有鍵
print (tinydict.values()) # 輸出所有值

以上例項輸出結果：

1 - Python教程
2 - Python工具
{'name': 'demo', 'site': 'www.demo.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['demo', 'www.demo.com', 1])

• 建構函式 dict() 可以直接從鍵值對序列中構建字典如下：
• 例項

>>>dict([('demo', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'demo': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(demo=1, Google=2, Taobao=3)
{'Taobao': 3, 'demo': 1, 'Google': 2}

• 另外，字典型別也有一些內建的函式，例如clear()、keys()、values()等。
• 注意：
  • 1、字典是一種對映型別，它的元素是鍵值對。
  • 2、字典的關鍵字必須為不可變型別，且不能重複。
  • 3、建立空字典使用 { }。

5.7 資料型別轉換【擴充套件內容】

• 有時候，我們需要對資料內建的型別進行轉換，資料型別的轉換，你只需要將資料型別作為函式名即可。
• 以下幾個內建的函式可以執行資料型別之間的轉換。這些函式返回一個新的物件，表示轉換的值

函式	描述
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)	將一個整數轉換為一個八進位制字串

資料型別轉換分類：

• 資料型別轉換一共分為2類：自動資料型別轉換(隱式轉換)和強制資料型別轉換(顯示轉換)

自動資料型別轉換/隱式轉換

• 自動型別轉換是程式根據運算要求進行的轉換，不需要人工干預 1.自動型別轉換不需要人工干預 2.自動型別轉換多發生在運算或者判斷過程中 3.轉化時向著更加精確的型別轉換

強制型別轉換/顯示轉換

• 根據程式需要，由編寫程式人員人為改變資料型別的方式就是強制資料型別轉換。
• int() 將其他型別轉化為整型

1.數字整型轉化之後，還是原來的味道
2.浮點型別轉化之後，捨去小數部分
3.布林值轉化之後 True -> 1 False->0
4.字串轉換，僅純整型字串可以轉化（浮點型或者帶有其他字元都不可以轉化）
5.複數不可以轉換

• float() 將其他型別轉化為浮點型

1.整型轉換之後變為浮點型，後面+.0
2.浮點數不需要轉化，轉化也不會變化
3.布林值轉化 True->1.0  False ->0.0
4.字串，純整型字串和純浮點型字串可以轉換，其他都不可以

• complex() 將其他資料轉化為複數

1.整型轉換之後變為 （整型+0j）
2.浮點型轉換之後變為(浮點型 + 0j)
3.布林值轉化之後 True->（1+0j） False(0j)
4.字串，純整型和浮點型字串可以轉化，其他都不行
5.複數，無需轉換

• bool() 將其他型別轉化為布林值

#下面轉化為布林值false的情況
    1.整型   0
    2.浮點型  0.0
    3.複數  0+0j
    4.布林  False
    5.字串  '' 空字串
    6.列表   [] 空列表
    7.元組   ()空元組
    8.字典   {} 空字典
    9.集合   set() 空集合

• str() 將其他型別轉化為字串
  • 所有轉換均改變型別為字串，表示方式依舊不變
• list() 將其他型別轉化為列表型別
  • 在python中有5中可迭代序列，可以互相轉換，他們分別是：
  • 字串，列表，元組，字典，集合

var = ('張三','李四','王老五')

newvar = list(var)

newvar的值為 ['張三','李四','王老五']

• 注意：
  • 1.字串轉換時每個字元變成列表中的一個值
  • 2.字典型別轉換時，僅將字典的鍵部分轉換成列表，忽略值部分
• tuple() 將其他型別轉化為元組型別

var = {'張三','李四','王老五'}

newvar = tuple(var)

newvar的值為 ('張三','李四','王老五')

• 注意：

  • 1.字串轉換時每個字元變成元組中的一個值
  • 2.字典型別轉換時，僅將字典的鍵部分轉換成元組，忽略值部分

• set（） 將其他型別轉化為集合型別

var = ['張三','李四','王老五']
newvar = set(var)
newvar的值為 {'張三','李四','王老五'}  #值的順序不定

• 注意：

  • 1.字串轉換時每個字元變成集合中的一個值
  • 2.字典型別轉換時，僅將字典的鍵部分轉換集合，忽略值部分

• dict() 將其他型別轉換為字典型別

• 其他型別轉化為字典時需要按照指定的格式才可以轉化：（列表和元組的組合可以）

[['cat', '黑貓警長'], ['mouse', '一隻耳'], ['next', '請看夏季']]
[('cat', '黑貓警長'), （'mouse', '一隻耳'）, （'next', '請看夏季'）]

6 分支結構

• 流程: 計算機執行程式碼的順序就是流程
• 流程控制: 對計算機程式碼執行順序的管理就是流程控制 流程分類:
• 流程控制一共分為三類:
  • 順序結構
  • 分支結構/選擇結構
  • 迴圈結構
• 分支結構一共分為4類：
  • 單項分支
  • 雙項分支
  • 多項分支
  • 巢狀分支

6.1 單項分支

'''
if <條件判斷1>:
	 <執行1>
'''
# 例子
age = 30
if age >= 18:
	print('your age is', age) 
	print('adult')

• 特徵：
  • if條件表示式結果為真，則執行if之後所控制程式碼組，如果為假，則不執行後面的程式碼組（:後面的N行中有相同縮排的程式碼）
  • :之後下一行的內容必須縮排，否則語法錯誤！
  • if之後的程式碼中如果縮排不一致，則不會if條件表示式是的控制，也不是單項分支的內容，是順序結構的一部分
  • if:後面的程式碼是在條件表示式結果為真的情況下執行，所以稱之為真區間或者if區間、

6.2 雙項分支

'''
if <條件判斷1>:
	 <執行1>
else:
	<執行2>
'''
# 例子
age = 13
if age >= 16:
	print('your age is', age)
	print('adult')
else:
	print('your age is', age)
	print('teenager')

• 特徵:
  • 1.雙項分支有2個區間:分別是True控制的if區間和False控制的else區間（假區間）
  • 2.if區間的內容在雙項分支中必須都縮排，否則語法錯誤！

6.3 多項分支

'''
if <條件判斷1>:
	 <執行1>
elif <條件判斷2>: 
	<執行2>
elif <條件判斷3>:
	 <執行3>
else:
	<執行4>
'''
# 例子
age = 20
if age >= 6:
	print('teenager')
elif age >= 18:
	print('adult')
else:
	print('kid')

• 特徵：
  • 1.多項分支可以新增無限個elif分支，無論如何只會執行一個分支
  • 2.執行完一個分支後，分支結構就會結束，後面的分支都不會判斷也不會執行
  • 3.多項分支的判斷順序是自上而下逐個分支進行判斷
  • 4.在Python中沒有switch – case語句。
• 例項-演示了狗的年齡計算判斷：

#!/usr/bin/python3

age = int(input("請輸入你家狗狗的年齡: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相當於 14 歲的人。")
elif age == 2:
    print("相當於 22 歲的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("對應人類年齡: ", human)
### 退出提示
input("點選 enter 鍵退出")

6.4 巢狀分支【*擴充套件內容】

• 巢狀分支是其他分支結構的巢狀結構，無論哪個分支都可以巢狀

# !/usr/bin/python3

num=int(input("輸入一個數字："))
if num%2==0:
    if num%3==0:
        print ("你輸入的數字可以整除 2 和 3")
    else:
        print ("你輸入的數字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你輸入的數字可以整除 3，但不能整除 2")
    else:
        print  ("你輸入的數字不能整除 2 和 3")

• 上述程式，執行後輸出結果為：

輸入一個數字：6
你輸入的數字可以整除 2 和 3

7 迴圈結構

• 迴圈是讓計算機做重複任務的有效方法
• 迴圈結構分為2類：while迴圈 和 for..in迴圈

7.1 break語句與continue語句

• break作用:在迴圈中break的作用是終止當前迴圈結構的後續操作，一旦程式執行了break，迴圈也就終止了！

• break 語句可以跳出 for 和 while 的迴圈體。如果你從 for 或 while 迴圈中終止，任何對應的迴圈 else 塊將不執行。 例項如下

• continue語句被用來告訴Python跳過當前迴圈塊中的剩餘語句，然後繼續進行下一輪迴圈。

7.2 while迴圈和break

# 1到100求和
n = 1
while n <= 100:
	if n > 10: # 當n = 11時，條件滿足，執行break語句
		break # break語句會結束當前迴圈
	print(n)
	n = n + 1
print('END')

• while迴圈，只要條件滿足，就不斷迴圈，條件不滿足時退出迴圈
• 在迴圈中，break語句可以提前退出迴圈

注意：死迴圈就是迴圈不會終止的迴圈型別

7.3 while迴圈和continue

n = 0
while n < 10:
	n = n + 1
	if n % 2 == 0: # 如果n是偶數，執行continue語句
		continue # continue語句會直接繼續下一輪迴圈，後續的print()語句不會執行
	print(n)

• 在迴圈過程中，也可以通過continue語句，跳過當前的這次迴圈，直接開始下一次迴圈
• 執行上面的程式碼可以看到，列印的不再是1～10，而是1，3，5，7，9

7.4 for…in迴圈

# 1到10求和
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
	sum = sum + x
print(sum)

# 遍歷list
names = [’小紅‘, ’小軍‘, ’小明']
for name in names:
	print(name)

在for…in 迴圈用

在for…in 迴圈用於遍歷容器類的資料(字串，列表，元組，字典，集合)

7.5 range()函式

如果你需要遍歷數字序列，可以使用內建range()函式。它會生成數列，例如:

for i in range(5): # 遍歷出0~4的值
	print(i)
for i in range(5,9): # 遍歷出5~8的值
	print(i)
for i in range(0,10,3): # 遍歷出0,3,6,9的值
	print(i)
for i in range(5-10,-100,-30): # 遍歷出-10,-40,-70的值
	print(i) 
a = ['Google', 'Baidu', 'Sina', 'Taobao', 'QQ']
for i in range(len(a)): #遍歷列表
	print(i, a[i])

7.6 pass 語句 【擴充套件內容】

• Python pass是空語句，是為了保持程式結構的完整性。
• pass 不做任何事情，一般用做佔位語句，如下例項

8 函式

• 函式的本質就是功能的封裝。使用函式可以大大提高程式設計效率與程式的可讀性。
• 函式是能夠實現特定功能的計算機程式碼而已，他是一種特定的程式碼組結構。
• 函式的作用
  • 1.提升程式碼的重複利用率，避免重複開發相同程式碼
  • 2.提高程式開發效率
  • 3.便於程式維護

8.1 函式的定製

• 函式程式碼塊以 def 關鍵詞開頭，後接函式識別符號名稱和圓括號 ()。
• 任何傳入引數和自變數必須放在圓括號中間，圓括號之間可以用於定義引數。
• 函式的第一行語句可以選擇性地使用文件字串—用於存放函式說明。
• 函式內容以冒號起始，並且縮排。
• return [表示式] 結束函式，選擇性地返回一個值給呼叫方。不帶表示式的return相當於返回 None。

8.2 函式的命名

函式名的命名規則:和變數基本一樣

• 1.推薦使用英文或者拼音,禁止使用中文
• 2.可以使用數字，但是不能用數字開頭
• 3.不可以使用特殊字元，除了_
• 4.函式名嚴格區分大小寫
• 5.函式名必須要有意義。
• 6.不能和系統已經存在的保留關鍵字衝突!
• 7.禁止使用和系統提供函式相同的函式名

8.3 帶有引數的函式格式

def 函式名(引數,引數….): 
	函式功能程式碼...
	函式功能程式碼... 
	return（沒有return 預設返回None）
呼叫函式: 函式名(引數,引數….)

• 形參: 形式上的引數,宣告函式時()中的引數是形參
• 實參: 實際上的引數,呼叫函式時()中的引數是實參
• 注意: 實參將值傳遞給形參的過程本質上就是簡單的變數賦值僅此而已
• 引數須以正確的順序傳入函式。呼叫時的數量必須和宣告時的一樣

形參: 形式上的引數,宣告函式時()中的引數是形參
實參: 實際上的引數,呼叫函式時()中的引數是實參
注意: 實參將值傳遞給形參的過程本質上就是簡單的變數賦值僅此而已
引數須以正確的順序傳入函式。呼叫時的數量必須和宣告時的一樣

8.3.1 函式引數格式

1. 預設值的引數：可選擇性輸入的引數
2. 可變引數 ：可以輸入0到任意個引數，函式內組裝成tuple
3. 關鍵字引數：可以輸入0到任意個含引數名引數，函式內組裝成一個dict
4. 命名關鍵字引數
5. 多種引數混合：順序是必選，預設，可變，命名關鍵字，關鍵字

8.4 函式返回值

• 調函式根據執行完畢是否可以得到一個結果，將函式分為2個型別:
  • 執行過程函式: print()
  • 具有返回值的函式:id(),type()
• return的特徵:
  • 具有return語句的函式稱為具有返回值的函式
  • return可以為當前函式執行完畢返回一個結果，這樣的函式呼叫可以被接受
  • return執行之後，函式則會終止，所有return之後的語句不會被執行
  • 一個函式可以書寫多個return語句，但是一般會放入分支結構當中
  • 一個函式若要返回多個資料，可藉助複合資料型別(list，tuple，set，dict) 來操作即可!
  • 不帶引數值的return語句返回None

8.5 函式文件

• 函式文件就是用來檢視當前函式相關資訊介紹的一個特定格式而已
• 檢視函式文件的方法:
  • help(函式名稱) # 直接輸出顯示函式文件的內容字串
  • 函式名.doc # 直接輸出顯示函式文件的內容元字串(轉義字元不轉義)
  • 官方文件 http://docs.python.org/3/library/functions.html

def 函式名(引數...): 
	'''
	在此處宣告函式文件
	''' 
	函式功能程式碼... 

• 注意:函式文件的作用是對函式進行說明，便於閱讀和快速掌握函式的使用，通常函式文件需要具有以下資訊:
  • 函式的作用
  • 函式的引數介紹(個數，資料型別)
  • 函式的返回值(資料和型別)

8.6 區域性變數和全域性變數

• 定義在函式內部的變數擁有一個區域性作用域，定義在函式外的擁有全域性作用域。
• 區域性變數只能在其被宣告的函式內部訪問，而全域性變數可以在整個程式範圍內訪問。呼叫函式時，所有在函式內宣告的變數名稱都將被加入到作用域中。如下例項：

#!/usr/bin/python3

total = 0; # 這是一個全域性變數
# 可寫函式說明
def sum( arg1, arg2 ):
    #返回2個引數的和."
    total = arg1 + arg2; # total在這裡是區域性變數.
    print ("函式內是區域性變數 : ", total)
    return total;

#呼叫sum函式
sum( 10, 20 );
print ("函式外是全域性變數 : ", total)

• 以上例項輸出結果：

函式內是區域性變數 :  30
函式外是全域性變數 :  0

8.7 匿名函式【擴充套件內容】

• python 使用 lambda 來建立匿名函式。
• 所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函式。
• lambda 只是一個表示式，函式體比 def 簡單很多。
• lambda的主體是一個表示式，而不是一個程式碼塊。僅僅能在lambda表示式中封裝有限的邏輯進去。
• lambda 函式擁有自己的名稱空間，且不能訪問自己引數列表之外或全域性名稱空間裡的引數。
• 雖然lambda函式看起來只能寫一行，卻不等同於C或C++的行內函數，後者的目的是呼叫小函式時不佔用棧記憶體從而增加執行效率。
• 語法:
• lambda 函式的語法只包含一個語句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

• 如下例項：

#!/usr/bin/python3

# 可寫函式說明
sum = lambda arg1, arg2: arg1 + arg2;

# 呼叫sum函式
print ("相加後的值為 : ", sum( 10, 20 ))
print ("相加後的值為 : ", sum( 20, 20 ))

• 以上例項輸出結果：

相加後的值為 :  30
相加後的值為 :  40

9 檔案讀寫

9.1 Python 內建的檔案讀寫操作

• open（） 開啟或者建立一個檔案

    格式：open('檔案路徑','開啟模式')
    返回值：檔案io物件
    開啟模式一共N種：
        w模式 寫模式write  檔案不存在時會建立檔案，如果檔案已存在則會清空檔案
        r模式  讀模式read  檔案不存在就報錯，存在則準備讀取檔案
        a模式 追加模式 append 檔案不存在則新建，檔案存在則在檔案末尾追加內容
        x模式 抑或模式 xor 檔案存在則報錯，檔案 不存在則新建檔案
        b模式 二進位制模式 binary 輔助模式不能單獨使用
        +模式 增強模式plus  也是輔助模式不能單獨使用

• 以上模式可以互相組合：wrax不可以互相組合:

模式	說明
r	以只讀方式開啟檔案。檔案的指標將會放在檔案的開頭。這是預設模式。
w	開啟一個檔案只用於寫入。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
a	開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。
rb	以二進位制格式開啟一個檔案用於只讀。檔案指標將會放在檔案的開頭。這是預設模式。
wb	以二進位制格式開啟一個檔案只用於寫入。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
ab	以二進位制格式開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。也就是說，新的內容將會被寫入到已有內容之後。如果該檔案不存在，建立新檔案進行寫入。
r+	開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。
w+	開啟一個檔案用於讀寫。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
a+	開啟一個檔案用於讀寫。如果該檔案已存在，檔案指標將會放在檔案的結尾。檔案開啟時會是追加模式。如果該檔案不存在，建立新檔案用於讀寫。
rb+	以二進位制格式開啟一個檔案用於讀寫。檔案指標將會放在檔案的開頭。
wb+	以二進位制格式開啟一個檔案用於讀寫。如果該檔案已存在則將其覆蓋。如果該檔案不存在，建立新檔案。
ab+	以二進位制格式開啟一個檔案用於追加。如果該檔案已存在，檔案指標將會放在檔案的結尾。如果該檔案不存在，建立新檔案用於讀寫

• close() 關閉檔案

9.2 讀寫函式：

• read() 讀取檔案

'''
格式：檔案io物件.read()
返回值：整個檔案的字元

格式：檔案io物件.read(字元長度)
返回值：指定長度的字元
'''
f = open('test.txt', 'r')
content = f.read(5)
print(content)
print("-"*30)
content = f.read()
print(content)
f.close()

• readline() 讀取一行檔案

'''
格式:檔案io物件.readline()
返回值：一行內容的字串

格式：檔案io物件.readline（字元長度）
返回值：一行內容的字串

注意：字元長度<當前行內內容，則讀取指定長度的字串，並且下次再讀取還是在
這個一行中獲取沒有讀取的內容。字元長度>=當前行內容，直接讀取當前行
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()

• readlines() 將檔案中的內容讀取到序列當中。

'''
格式：檔案io物件.readlines()
返回值：列表

格式：檔案io物件.readlines(字元長度)
返回值：列表

注意：讀取的行數由字元長度決定，如果字元長度讀取了N行後，還有指定長度的字元
     沒有讀取，則直接讀取下一行進來
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
    print("%d:%s"%(i, temp))
    i+=1
f.close()

• write() 寫入檔案

格式：檔案io物件.write(字串)
返回值：寫入字串的長度

• writelines() 將序列寫入檔案中

格式：檔案io物件.writelines(序列)
返回值：None

• truncate() 字串擷取操作

格式：檔案io物件.truncate(位元組長度)
返回值：擷取的位元組長度

9.3 OS模組

• OS – 作業系統的簡稱
• os模組就是對作業系統進行操作
• 使用該模組必須先匯入模組：

import os

os模組中的函式:

序號	函式名稱	描述	格式
1	getcwd()	獲取當前的工作目錄	格式：os.getcwd() 返回值：路徑字串
2	chdir()	修改當前工作目錄	格式:os.chdir() 返回值:None
3	listdir()	獲取指定資料夾中的 所有檔案和資料夾組成的列表	格式:os.listdir(目錄路徑) 返回值：目錄中內容名稱的列表
4	mkdir()	建立一個目錄/資料夾	格式：os.mkdir(目錄路徑) 返回值：None
5	makedirs()	遞迴建立資料夾	格式:os.makedirs(路徑)
6	rmdir()	移除一個目錄（必須是空目錄）	格式：os.rmdir(目錄路徑) 返回值:None
7	removedirs()	遞迴刪除資料夾	格式：os.removedirs(目錄路徑) 返回值：None 注意最底層目錄必須為空
8	rename()	修改檔案和資料夾的名稱	格式：os.rename(原始檔或資料夾，目標檔案或資料夾) 返回值：None
9	stat()	獲取檔案的相關 資訊	格式：os.stat(檔案路徑) 返回值：包含檔案資訊的元組
10	system()	執行系統命令	格式:os.system() 返回值：整型 慎用！ 玩意來個rm -rf 你就爽了！
11	getenv()	獲取系統環境變數	格式：os.getenv(獲取的環境變數名稱) 返回值：字串
12	putenv()	設定系統環境變數	格式：os.putenv(‘環境變數名稱’,值) 返回值：無 注意：無法正常的getenv檢測到。
13	exit()	推出當前執行命令，直接關閉當前操作	格式:exit() 返回值：無

當前os模組的值:

序號	函式名稱	描述
1	curdir	os.curdir 獲取當前路徑 都是.
2	pardir	os.pardir 獲取上層目錄路徑 都是…
3	path	os.path os中的一個子模組，操作非常多
4	name	os.name 當前系統的核心名稱 win->nt linux/unix->posix
5	sep	os.sep 獲取當前系統的路徑分割符號 window -> \ linux/unix -> /
6	extsep	os.extsep 獲取當前系統中檔名和字尾之間的分割符號，所有系統都是.
7	linesep	os.linesep 獲取當前系統的換行符號 window -> \r\n linux/unix -> \n

os.environ模組

• os.environ 可以直接獲取所有環境變數的資訊組成的字典，如果希望更改環境變數，並且可以查詢得到，就需要對os.environ進行操作
• 該模組的所有方法均是字典的方法，可以通過字典的os.environ的結果進行操作。
• 注意：無論使用os.getenv，putenv 還是使用os.environ進行環境變數的操作，都是隻對當前指令碼，臨時設定而已，無法直接更新或者作業系統的環境變數設定。

os.path模組

• os.path是os模組中的子模組，包含很多和路徑相關的操作
• 函式部分:

序號	函式名稱	描述	格式
1	abspath()	將一個相對路徑轉化為絕對路徑	格式：os.path.abspath(相對路徑) 返回值：絕對路徑字串
2	basename()	獲取路徑中的資料夾或者檔名稱 （只要路徑的最後一部分）	格式：os.path.basename(路徑) 返回值：路徑的最後一部分(可能是檔名也可能是資料夾名)
3	dirname()	獲取路徑中的路徑部分(出去最後一部分)	格式:os.path.dirname(路徑) 返回值：路徑中除了最後一部分的內容字串
4	join()	將2個路徑合成一個路徑	格式：os.path.join(路徑1,路徑2) 返回值：合併之後的路徑
5	split（）	將一個路徑切割成資料夾和檔名部分	格式：os.path.split(路徑) 返回值：元組
6	splitext()	將一個檔名切成名字和字尾兩個部分	格式：os.path.splitext(檔名稱) 返回值：元組 （名稱,字尾）
7	getsize()	獲取一個檔案的大小	格式:os.path.getsize(路徑) 返回值：整數
8	isfile()	檢測一個路徑是否是一個檔案	格式：os.path.isfile(路徑) 返回值：布林值
9	isdir()	檢測一個路徑是否是一個資料夾	格式：os.path.isdir(路徑) 返回值：布林值
10	getctime()	獲取檔案的建立時間！ get create time	格式：os.path.getctime(檔案路徑) 返回值：時間戳浮點數
11	getmtime()	獲取檔案的修改時間！ get modify time	格式：os.path.getmtime(檔案路徑) 返回值：時間戳浮點數
12	getatime()	獲取檔案的訪問時間！ get active time	格式：os.path.getatime(檔案路徑) 返回值：時間戳浮點數
13	exists()	檢測指定的路徑是否存在	格式：os.path.exists(路徑) 返回值：布林值
14	isabs()	檢測一個路徑是否是絕對路徑	格式:os.path.isabs(路徑) 返回值：布林值
15	islink()	檢測一個路徑是否是連結	格式:os.path.islink(路徑) 返回值:布林值
16	samefile()	檢測2個路徑是否指向同一個檔案	格式:os.path.samefile(路徑1,路徑2) 返回值：布林值

10 Python運算子【擴充套件內容】

• 本章節主要說明Python的運算子。舉個簡單的例子 4 +5 = 9 。 例子中，4 和 5 被稱為運算元，"+" 稱為運算子。
• Python語言支援以下型別的運算子:
  1. 算術運算子
  2. 比較（關係）運算子
  3. 賦值運算子
  4. 邏輯運算子
  5. 位運算子
  6. 成員運算子
  7. 身份運算子
  8. 運算子優先順序

10.1 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.0//2.0 輸出結果 4.0

10.2 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。

10.3 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

10.4 Python位運算子：

• 按位運算子是把數字看作二進位制來進行計算的。Python中的按位運演算法則如下：
• 下表中變數 a 為 60，b 為 13二進位制格式如下：

>>> a=18        
>>> bin(a)      # 將變數a的數值轉成二進位制數值輸出
'0b10010'

>>> b = 0b10010  #將二進位制的數值賦給變數b
>>> b
18

# 下面是二進位制運算
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
l	按位或運算子：只要對應的二個二進位有一個為1時，結果位就為1。	(a l 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

(5). 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

10.5 Python成員運算子:

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

運算子	描述	例項
in	如果在指定的序列中找到值返回 True，否則返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中沒有找到值返回 True，否則返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

#!/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 中

10.6 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() 函式用於獲取物件記憶體地址。

#!/usr/bin/python3

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

10.7 Python運算子優先順序:

• 以下表格列出了從最高到最低優先順序的所有運算子：

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

11 Python資料型別的操作【擴充套件內容】

11.1 Number數字

11.1.1 數學函式

函式	返回值 ( 描述 )
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次冪(ex),如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的平方根。

11.1.2 隨機數函式

函式	描述
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]範圍內。

11.1.3 三角函式

函式	描述
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)	將角度轉換為弧度

11.1.4 數學常量

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

11.2 String字串

11.2.1 Python轉義字元

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

11.2.2 Python字串運算子

• 下表例項變數a值為字串 “Hello”，b變數值為 “Python”：

操作符	描述	例項
+	字串連線	a + b 輸出結果： HelloPython
*	重複輸出字串	a*2 輸出結果：HelloHello
[]	通過索引獲取字串中字元	a[1] 輸出結果 e
[ : ]	擷取字串中的一部分	a[1:4] 輸出結果 ell
in	成員運算子 - 如果字串中包含給定的字元返回 True	H in a 輸出結果 1
not in	成員運算子 - 如果字串中不包含給定的字元返回 True	M not in a 輸出結果 1
r/R	原始字串 - 原始字串：所有的字串都是直接按照字面 的意思來使用，沒有轉義特殊或不能列印的字元。 原始字串除在字串的第一個引號前加上字母"r"（可以大 小寫）以外，與普通字串有著幾乎完全相同的語法。	print r’\n’ prints \n 和 print R’\n’ prints \n
%	格式字串	請看下一節內容。

#!/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

11.2.3 Python字串格式化:

• Python 支援格式化字串的輸出 。儘管這樣可能會用到非常複雜的表示式，但最基本的用法是將一個值插入到一個有字串格式符 %s 的字串中。
• 在 Python 中，字串格式化使用與 C 中 sprintf 函式一樣的語法。

#!/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	用十六進位制數格式化變數的地址

• 格式化操作符輔助指令:

符號	功能
*	定義寬度或者小數點精度
-	用做左對齊
+	在正數前面顯示加號( + )
	在正數前面顯示空格
#	在八進位制數前面顯示零(‘0’)，在十六進位制前面顯示’0x’或者’0X’(取決於用的是’x’還是’X’)
0	顯示的數字前面填充’0’而不是預設的空格
%	‘%%‘輸出一個單一的’%’
(var)	對映變數(字典引數)
m.n.	m 是顯示的最小總寬度,n 是小數點後的位數(如果可用的話)

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

11.2.4 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 個子字串
32	splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一個包含各行作為元素的列表，如果引數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。
33	startswith(str, beg=0,end=len(string))	檢查字串是否是以 obj 開頭，是則返回 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。

11.3 List列表

• 序列是Python中最基本的資料結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
• 列表操作例項：

#!/usr/bin/python3

# 定義 
list0 = [] # 建立一個空列表 或者  變數 = list()
list1 = ['Google', 'Python', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

#輸出
print ("list1[0]: ", list1[0])  # Google
print ("list2[1:5]: ", list2[1:5]) # [2, 3, 4, 5]

#更新其中的值
print ("第三個元素為 : ", list[2])    # 2000
list[2] = 2001
print ("更新後的第三個元素為 : ", list[2])  # 2001

#刪除其中一個元素
del list[2]
print ("刪除第三個元素 : ", list)  #  ['Google', 'Python', 2000]

11.3.1 列表的遍歷操作:

1.使用for...in 遍歷列表

    for 變數 in 列表：
        使用變數

2.使用while迴圈遍歷列表

    i = 0
    while i<len(列表):
        使用列表中的元素(列表[i])
        i += 1

3.同等長度二級列表的遍歷

    列表 = [[值1,值2],[值1,值2],....]

    for 變數1,變數2 in 列表:
        使用變數1和變數2

    注意：變數1取二級列表中的第一個值，變數2取第二個值
4.非同等長度的二級列表的遍歷

    列表 = [[值1，值2]，[值1，值2,值3],[值]...]

    for 變數1 in 列表：
        for 變數2 in 變數1：
            使用變數2(變數2是二級列表中的每個值)

11.3.2 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	迭代

11.3.3 Python列表擷取與拼接：

• Python的列表擷取與字串操作型別，如下所示：L=[‘Google’, ‘Python’, ‘Taobao’]

Python	表示式 結果	描述
L[2]	‘Taobao’	讀取第三個元素
L[-2]	‘Python’	從右側開始讀取倒數第二個元素: count from the right
L[1:]	[‘Python’, ‘Taobao’]	輸出從第二個元素開始後的所有元素

• 使用巢狀列表即在列表裡建立其它列表，例如：

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

11.3.4 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(obj=list[-1])	移除列表中的一個元素（預設最後一個元素），並且返回該元素的值
7	list.remove(obj)	移除列表中某個值的第一個匹配項
8	list.reverse()	反向列表中元素
9	list.sort([func])	對原列表進行排序
10	list.clear()	清空列表
11	list.copy()	複製列表

11.4 Tuple元組

• Python 的元組與列表類似，不同之處在於元組的元素不能修改。
• 元組使用小括號，列表使用方括號。
• 元組建立很簡單，只需要在括號中新增元素，並使用逗號隔開即可。

# 定義元組的方式：
tup0 = ()  #定義一個空元組 或者 變數 = tuple()
tup1 = ('Google', 'Python', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

# 輸出元組：
print ("tup1[0]: ", tup1[0])       # tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])   # tup2[1:5]:  (2, 3, 4, 5)

# 注意下面這種定義不加逗號，型別為整型
tup4 = (50)
print(type(tup4))  # <class 'int'>

# 正確定義方式加上逗號，型別為元組
tup5 = (50,)
print(type(tup5))  # <class 'tuple'>

# 以下修改元組元素操作是非法的。
# tup1[0] = 100

#元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組
del tup0;

11.4.1 元組運算子：

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

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	迭代

11.4.2 元組索引，擷取：

• 因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以擷取索引中的一段元素
• 如下所示：L=(‘Google’, ‘Python’, ‘Taobao’)

Python	表示式 結果	描述
L[2]	‘Taobao’	讀取第三個元素
L[-2]	‘Python’	從右側開始讀取倒數第二個元素: count from the right
L[1:]	(‘Python’, ‘Taobao’)	輸出從第二個元素開始後的所有元素

11.4.3元組內建函式:

• Python元組包含了以下內建函式:

序號	函式名稱	說明
1	len(tuple)	元組元素個數
2	max(tuple)	返回元組元素最大值
3	min(tuple)	返回元組元素最小值
4	tuple(seq)	將元組轉換為元組

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']

tuple1=tuple(list1)

print(tuple1)

#('Google', 'Taobao', 'Runoob', 'Baidu')

11.5 set集合

• 集合（set）是一個無序不重複元素的序列。
• 基本功能是進行成員關係測試和刪除重複元素。
• 可以使用大括號 { } 或者 set() 函式建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。

# 集合的定義
set1 = set()  #定義一個空的集合
set2 = {1,2,3}

# 增加一個元素
set1.add(5)  

#增加多個：
set1.update([5,6,7,8])

#刪除某個值
set1.remove(1)

#查：無法通過下標索引

#改：不可變型別無法修改元素

a={10,20,30}
b={20,50}
print(a - b)     # a和b的差集 

print(a | b)     # a和b的並集

print(a & b)     # a和b的交集

print(a ^ b)     # a和b中不同時存在的元素

11.5.1 集合的遍歷:

1.普通序列的遍歷

    for 變數 in 集合：
        使用變數

2.多級集合

    集合 = {（值,值..）,（值，值..）。。。}

    for 變數1，變數2 in 集合：

        使用變數1和變數2

11.5.2 集合的序列函式：

• len() 計算集合的長度
• max() 獲取集合中的最大值
• min() 獲取集合中的最小值
• set() 建立空集合或者將其他資料轉換為集合

11.5.3 集合中的方法：

• add – 增加集合元素

name = {'d', 's'}
name.add('d')
name
返回結果：{'d', 's'}
name.add('sd')
name
返回結果：{'sd', 'd', 's'}

• update–更新已有集合

name = {'sd', 'd', 's'}
name.update('df')
name
返回結果：{'sd', 'd', 'f', 's'}

• remove–移除指定集合元素

name = {'sd','d','s'}
name.remove('s')
返回結果：name
{'sd', 'd'}

• discard–移除元素

name = {'sd', 'd', 's'}
name.discard('s')
返回結果：name 
        {'sd', 'd'}

# remove移除非成員值會報錯，discard移除非成員值，啥也不錯！

• clear–清空集合元素

name = {'d', 's'}
name.clear()
name
返回結果：{}

• copy–淺拷貝

name = {'sd', 'd', 's'}
li = name.copy()
返回結果：li
        {'sd', 'd', 's'}

• difference – 求差集

name.difference(li)
set()
>>> name.difference()
{'sd', 'd', 's'}

• union–並集，建立新的物件

name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回結果：{'h', 's', 'd', 'sd'}

• difference_update—刪除當前set中的所有包含在 new set 裡的元素

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回結果：{'sd'}

• intersection–取交集,建立新的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回結果：{'d', 's'}

• intersection_update–取交集,更新原來的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回結果：{'d', 's'}

• isdisjoint–判斷沒有交集，返回True,否則,返回False

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)

• issubset–判斷是否是子集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)  #判斷name是不是li的子集
返回結果：False
li.issubset(name)  #判斷li是不是name的子集
返回結果：True

• issuperset–判斷是否是父集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)  #判斷name是不是li的父集
返回結果：True
li.issuperset(name)  #判斷li是不是name的父集
返回結果：False

• pop–移除集合元素

name = {'sd', 'd', 's'}
name.pop()
返回結果：'sd' #同一個集合，刪除集合元素的順序固定
se1 = {'a','s','sb'}
se1.pop()
返回結果：'sb'

• symmetric_difference–去兩個集合的差集，建立新的set集合物件

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回結果：{'sd'}

• symmetric_difference_update–去兩個集合的差集，更新原來的集合物件

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回結果：{'sd'}

11.6 Dictionary字典

• 字典是另一種可變容器模型，且可儲存任意型別物件。
• 字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

• 鍵必須是唯一的，但值則不必。

11.6.1 建立字典:

1.建立空字典
    變數 = {} 或者 變數 = dict()

2.建立多個元素的字典：
    方法1：
        變數 = {鍵:值,鍵:值....}

    方法2：
        變數 = dict({鍵:值,鍵:值....})

    方法3：
        變數 = dict(鍵=值,鍵=值...)
        注意：該方式鍵作為形參名使用不可以新增引號，必須符合變數規則

    方法4：
        變數 = dict([(鍵,值),(鍵,值)...])
        變數 = dict([[鍵,值],[鍵,值]...])
        變數 = dict(((鍵,值),(鍵,值)...))

    方法5：
        變數 = dict(zip((鍵，鍵...),(值,值...)))

11.6.2 字典的基本操作:

訪問字典的元素：
    變數[鍵]

新增字典的元素
    變數[新鍵] = 值

修改字典元素
    變數[鍵] = 新值

刪除字典元素
    del 變數[鍵]

• 案例：

#!/usr/bin/python3

# 定義一個字典
dict = {'Name': 'Python', 'Age': 17, 'Class': 'First'}

# 輸出子典中的資訊
print ("dict['Name']: ", dict['Name']) #Python
print ("dict['Age']: ", dict['Age'])   #17

# 輸出錯誤資訊：KeyError: 'Alice'
#print ("dict['Alice']: ", dict['Alice'])


# 修改和新增內容
dict['Age'] = 18;              # 更新 Age
dict['School'] = "雲課堂"      # 新增資訊

# 刪除資訊
del dict['Name'] # 刪除鍵 'Name'一個元素值
dict.clear()     # 清空字典
del dict         # 刪除字典

11.6.3 字典的遍歷:

1.鍵的遍歷
    for 變數i in 字典：
        使用i遍歷所有的鍵，有鍵就可以通過變數訪問其值

2.鍵值遍歷
    for 變數i，變數j in 字典.items()：
        使用變數i遍歷所有鍵，通過變數j遍歷所有值

11.6.4 字典內涵/字典推導式:

1.普通的字典內涵
    變數= {key:value for key,value in 字典.items()}

2.帶有判斷條件的字典內涵
    變數= {key:value for key,value in 字典.items() if 條件表示式}

3，多個迴圈的字典內涵
    變數 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}

4.帶有判斷條件的多個迴圈的字典內涵
    變數 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 條件表示式}

11.6.5 字典內建函式&方法：

• Python字典包含了以下內建函式：

序號	函式名稱	描述	例項
1	len(dict)	計算字典元素個數， 即鍵的總數。	>>> dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} >>> len(dict) 3
2	str(dict)	輸出字典， 以可列印的字串表示。	>>> dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} >>> str(dict) “{‘Name’: ‘py’, ‘Class’: ‘First’, ‘Age’: 7}”
3	type(variable)	返回輸入的變數型別， 如果變數是字典 就返回字典型別。	>>> dict = {‘Name’: ‘py’, ‘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()	以列表返回一個字典所有的鍵
8	radiansdict.setdefault(key, default=None)	和get()類似, 但如果鍵不存在於字典中，將會新增鍵並將值設為default
9	radiansdict.update(dict2)	把字典dict2的鍵/值對更新到dict裡
10	radiansdict.values()	以列表返回字典中的所有值
11	pop(key[,default])	刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。
12	popitem()	隨機返回並刪除字典中的一對鍵和值(一般刪除末尾對)。