List（列表）

List（列表） 是 Python 中使用最頻繁的資料型別。

列表可以完成大多數集合類的資料結構實現。列表中元素的型別可以不相同，它支援數字，字串甚至可以包含列表（所謂巢狀）。

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

和字串一樣，列表同樣可以被索引和擷取，列表被擷取後返回一個包含所需元素的新列表。

列表擷取的語法格式如下：

變數[頭下標:尾下標]

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

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

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

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

Tuple（元組）

元組（tuple）與列表類似，不同之處在於元組的元素不能修改。元組寫在小括號 () 裡，元素之間用逗號隔開。元組中的元素型別也可以不相同。

Set（集合）

集合（set）是由一個或數個形態各異的大小整體組成的，構成集合的事物或物件稱作元素或是成員。

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

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

Dictionary（字典）

字典（dictionary）是Python中另一個非常有用的內建資料型別。

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

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

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

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

#!/usr/bin/python3

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

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


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

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

Python3註釋

Python中的註釋有單行註釋和多行註釋：
Python中單行註釋以 # 開頭
多行註釋用三個單引號 ''' 或者三個雙引號 """ 將註釋括起來，例如:

#!/usr/bin/python3 
'''
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號 
這是多行註釋，用三個單引號
'''
print("Hello, World!")

#!/usr/bin/python3 
"""
這是多行註釋，用三個雙引號
這是多行註釋，用三個雙引號 
這是多行註釋，用三個雙引號
"""
print("Hello, World!")

Python算術運算子

Python比較運算子

Python賦值運算子

Python邏輯運算子

Python身份運算子

Python運算子優先順序

Python3數字(Number)

您可以使用del語句刪除一些數字物件的引用。
del語句的語法是：
del var_a,var_b

Python 支援三種不同的數值型別：

1、整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 型別使用，所以 Python3 沒有 Python2 的 Long 型別。
2、浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
3、複數( (complex)) - 複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。

Python 數字型別轉換

有時候，我們需要對資料內建的型別進行轉換，資料型別的轉換，你只需要將資料型別作為函式名即可。

int(x) 將x轉換為一個整數。

float(x) 將x轉換到一個浮點數。

complex(x) 將x轉換到一個複數，實數部分為 x，虛數部分為 0。

complex(x, y) 將 x 和 y 轉換到一個複數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。

Python3字串

Python 不支援單字元型別，單字元在 Python 中也是作為一個字串使用。

Python中的轉義字元

在需要在字元中使用特殊字元時，python 用反斜槓 \ 轉義字元。

Python中的字串運算子

Python三引號

python三引號允許一個字串跨多行，字串中可以包含換行符、製表符以及其他特殊字元。例項如下

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

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

Python列表指令碼操作符

Python3元組

Python 的元組與列表類似，不同之處在於元組的元素不能修改。

元組使用小括號 ( )，列表使用方括號 [ ]。

元組建立很簡單，只需要在括號中新增元素，並使用逗號隔開即可。

元組中只包含一個元素時，需要在元素後面新增逗號，否則括號會被當作運算子使用：

>>> tup1 = (50)
>>> type(tup1)     # 不加逗號，型別為整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗號，型別為元組
<class 'tuple'>

Python3字典

字典是另一種可變容器模型，且可儲存任意型別物件。

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

d = {key1 : value1, key2 : value2, key3 : value3 }

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

值可以取任何資料型別，但鍵必須是不可變的，如字串，數字。

一個簡單的字典例項：

dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

字典的特性

字典值可以是任何的 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'

Python3集合

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

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

while迴圈使用else語句

在 while … else 在條件語句為 false 時執行 else 的語句塊。

語法格式如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

for語句

Python for迴圈可以遍歷任何序列的專案，如一個列表或者一個字串。

for迴圈的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

#!/usr/bin/python3
 
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等於', x, '*', n//x)
            break
    else:
        # 迴圈中沒有找到元素
        print(n, ' 是質數')

2  是質數
3  是質數
4 等於 2 * 2
5  是質數
6 等於 2 * 3
7  是質數
8 等於 2 * 4
9 等於 3 * 3

Python3迭代器和生成器

迭代是Python最強大的功能之一，是訪問集合元素的一種方式。

迭代器是一個可以記住遍歷的位置的物件。

迭代器物件從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。

迭代器有兩個基本的方法：iter() 和 next()。

字串，列表或元組物件都可用於建立迭代器：

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 建立迭代器物件
for x in it:
    print (x, end=" ")

1 2 3 4

建立一個迭代器

把一個類作為一個迭代器使用需要在類中實現兩個方法 iter() 與 next() 。

如果你已經瞭解的面向物件程式設計，就知道類都有一個建構函式，Python 的建構函式為 init(), 它會在物件初始化的時候執行。

更多內容查閱：Python3 面向物件

iter() 方法返回一個特殊的迭代器物件， 這個迭代器物件實現了 next() 方法並通過 StopIteration 異常標識迭代的完成。

next() 方法（Python 2 裡是 next()）會返回下一個迭代器物件。

建立一個返回數字的迭代器，初始值為 1，逐步遞增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    x = self.a
    self.a += 1
    return x
 
myclass = MyNumbers()
myiter = iter(myclass)
 
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

1
2
3
4
5

Python3函式

定義一個函式

你可以定義一個由自己想要功能的函式，以下是簡單的規則：

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

關鍵字引數

關鍵字引數和函式呼叫關係緊密，函式呼叫使用關鍵字引數來確定傳入的引數值。

使用關鍵字引數允許函式呼叫時引數的順序與宣告時不一致，因為 Python 直譯器能夠用引數名匹配引數值。

以下例項在函式 printme() 呼叫時使用引數名：

#!/usr/bin/python3
 
#可寫函式說明
def printme( str ):
   "列印任何傳入的字串"
   print (str)
   return
 
#呼叫printme函式
printme( str = "菜鳥教程")

菜鳥教程

不定長引數

你可能需要一個函式能處理比當初宣告時更多的引數。這些引數叫做不定長引數，和上述 2 種引數不同，宣告時不會命名。基本語法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函式_文件字串"
   function_suite
   return [expression]

加了星號 * 的引數會以元組(tuple)的形式匯入，存放所有未命名的變數引數

def functionname([formal_args,] **var_args_dict ):
   "函式_文件字串"
   function_suite
   return [expression]

加了兩個星號 ** 的引數會以字典的形式匯入。

Python3資料結構

列表

Python中列表是可變的，這是它區別於字串和元組的最重要的特點，一句話概括即：列表可以修改，而字串和元組不能。

Python3模組

在前面的幾個章節中我們指令碼上是用 python 直譯器來程式設計，如果你從 Python 直譯器退出再進入，那麼你定義的所有的方法和變數就都消失了。

為此 Python 提供了一個辦法，把這些定義存放在檔案中，為一些指令碼或者互動式的直譯器例項使用，這個檔案被稱為模組。

模組是一個包含所有你定義的函式和變數的檔案，其後綴名是.py。模組可以被別的程式引入，以使用該模組中的函式等功能。這也是使用 python 標準庫的方法。

support.py程式碼：

#!/usr/bin/python3
# Filename: support.py
 
def print_func( par ):
    print ("Hello : ", par)
    return

test.py 引入 support 模組：

#!/usr/bin/python3
# Filename: test.py
 
# 匯入模組
import support
 
# 現在可以呼叫模組裡包含的函數了
support.print_func("Runoob")

$ python3 test.py 
Hello :  Runoob

Python3輸入輸出

舊字串格式化

% 操作符也可以實現字串格式化。 它將左邊的引數作為類似 sprintf() 式的格式化字串, 而將右邊的代入, 然後返回格式化後的字串，例如:

>>> import math
>>> print('常量 PI 的值近似為：%5.3f。' % math.pi)
常量 PI 的值近似為：3.142。

讀取鍵盤輸入

Python提供了 input() 內建函式從標準輸入讀入一行文字，預設的標準輸入是鍵盤。

input 可以接收一個Python表示式作為輸入，並將運算結果返回。

#!/usr/bin/python3

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

Python3錯誤和異常

異常處理

try/except

try/except...else

try-finally 語句

Python3面向物件

類物件

#!/usr/bin/python3
 
class MyClass:
    """一個簡單的類例項"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 例項化類
x = MyClass()
 
# 訪問類的屬性和方法
print("MyClass 類的屬性 i 為：", x.i)
print("MyClass 類的方法 f 輸出為：", x.f())

類有一個名為 init() 的特殊方法（構造方法），該方法在類例項化時會自動呼叫，像下面這樣：

def __init__(self):
    self.data = []

self代表類的例項，而非類

類的方法與普通的函式只有一個特別的區別——它們必須有一個額外的第一個引數名稱, 按照慣例它的名稱是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

<__main__.Test instance at 0x100771878>
__main__.Test

從執行結果可以很明顯的看出，self 代表的是類的例項，代表當前物件的地址，而 self.class 則指向類。

self 不是 python 關鍵字，我們把他換成 runoob 也是可以正常執行的。

類的方法

在類的內部，使用 def 關鍵字來定義一個方法，與一般函式定義不同，類方法必須包含引數 self, 且為第一個引數，self 代表的是類的例項。

繼承

派生類的定義如下所示:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

#!/usr/bin/python3
 
#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #呼叫父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

多繼承

Python同樣有限的支援多繼承形式。多繼承的類定義形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圓括號中父類的順序，若是父類中有相同的方法名，而在子類使用時未指定，python從左至右搜尋 即方法在子類中未找到時，從左到右查詢父類中是否包含方法。

#!/usr/bin/python3
 
#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行訪問
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #呼叫父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
#另一個類，多重繼承之前的準備
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
 
#多重繼承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，預設呼叫的是在括號中排前地父類的方法

執行以上程式輸出結果為：

我叫 Tim，我是一個演說家，我演講的主題是 Python

方法重寫

#!/usr/bin/python3
 
class Parent:        # 定義父類
   def myMethod(self):
      print ('呼叫父類方法')
 
class Child(Parent): # 定義子類
   def myMethod(self):
      print ('呼叫子類方法')
 
c = Child()          # 子類例項
c.myMethod()         # 子類呼叫重寫方法
super(Child,c).myMethod() #用子類物件呼叫父類已被覆蓋的方法

類的屬性和方法

類的私有屬性

__private_attrs：兩個下劃線開頭，宣告該屬性為私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。

類的方法

在類的內部，使用 def 關鍵字來定義一個方法，與一般函式定義不同，類方法必須包含引數 self，且為第一個引數，self 代表的是類的例項。

self 的名字並不是規定死的，也可以使用 this，但是最好還是按照約定是用 self。

類的私有方法

__private_method：兩個下劃線開頭，宣告該方法為私有方法，只能在類的內部呼叫 ，不能在類的外部呼叫。self.__private_methods。