python基礎文法學習

簡介

Python 是一個高層次的結合了解釋性、編譯性、互動性和面向對象的腳本語言。 Python 的設計具有很強的可讀性，相比其他語言經常使用英文關鍵字，其他語言的一些标點符号，它具有比其他語言更有特色文法結構。

文章目錄

• • 簡介
  • 一、基礎文法
  • • 1.辨別符
    • 2.注釋
  • 二、資料類型
  • • 1.标準資料類型
    • 2.Number
    • 3.String（字元串）
    • 4.清單
    • 5.元組
    • 6.字典
    • 7.集合
  • 三、語句結構
  • • 1.條件控制
    • 2.循環語句
  • 四、輸入輸出
  • • 1.輸出
    • 2.輸入
  • 五、函數
  • • 1.函數的定義
    • 2.參數傳遞
    • 3.匿名函數
  • 六、File(檔案) 方法
  • • 1.open()方法
    • 2.file對象
  • 七、子產品
  • • 1.import語句
    • 2.from...import語句
    • 3.from … import * 語句
  • 八、面向對象
  • • 1.類定義
    • 2.類的屬性與方法
    • 3.構造方法
    • 4.類的方法
    • 5.繼承
    • 6.方法重寫

一、基礎文法

1.辨別符

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

2.注釋

Python中單行注釋以 # 開頭，執行個體如下：

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

多行注釋可以用多個 # 号，還有 ‘’’ 和 “”"：

# 第一個注釋
# 第一個注釋
# 第二個注釋
 
'''
第三注釋
第四注釋
'''
 
"""
第五注釋
第六注釋
"""
print ("Hello, Python!")
           

二、資料類型

1.标準資料類型

Python3 中有六個标準的資料類型：

• Number（數字）
• String（字元串）
• List（清單）
• Tuple（元組）
• Set（集合）
• Dictionary（字典）
• Python3 的六個标準資料類型中：

不可變資料（3 個）：Number（數字）、String（字元串）、Tuple（元組）；

可變資料（3 個）：List（清單）、Dictionary（字典）、Set（集合）。

2.Number

Python3 支援 int、float、bool、complex（複數）。（在Python 3裡，隻有一種整數類型 int，表示為長整型。）

代碼如下（示例）：

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

Python 數字類型轉換：

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

注意：

1、Python可以同時為多個變量指派，如a, b = 1, 2。

2、一個變量可以通過指派指向不同類型的對象。

3、數值的除法包含兩個運算符：/ 傳回一個浮點數，// 傳回一個整數。

4、在混合計算時，Python會把整型轉換成為浮點數。

3.String（字元串）

• 字元串的定義

  可以使用引号( ’ 或 " )來建立字元串，示例如下：

str1 = 'Hello World!'
str2 = "Hello Python!"
           

• 通路字元串中的值

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

  Python 通路子字元串，可以使用方括号 [] 來截取字元串，字元串的截取的文法格式如下：

#變量[頭下标:尾下标]
str1 = 'Hello World!'
str2 = "Hello Python!"
print(str1[0]) #H
print(str2[1:5) #ello
           

• 字元串運算符

  +：字元串的連接配接

  *：重複輸出字元串

  []：通過索引擷取字元

  [:] : 截取字元串中的一部分，遵循左閉右開原則，str[0:2] 是不包含第 3 個字元的。

  in: 成員運算符 - 如果字元串中包含給定的字元傳回 True

  not in: 成員運算符 - 如果字元串中不包含給定的字元傳回 True

  %: 格式字元串

• 字元串格式化

  1. %c ：格式化字元及其ASCII碼

  2. %s ： 格式化字元串

  3. %d ： 格式化整數

  4. %u ： 格式化無符号整型

  5. %o ： 格式化無符号八進制數

  6. %x ： 格式化無符号十六進制數

  7. %X： 格式化無符号十六進制數（大寫）

  8. %f ： 格式化浮點數字，可指定小數點後的精度

  9. %e ： 用科學計數法格式化浮點數

  10. %E ： 作用同%e，用科學計數法格式化浮點數

  11. %g ：%f和%e的簡寫

  12. %G ：%f 和 %E 的簡寫

  13. %p ：用十六進制數格式化變量的位址

示例代碼：

4.清單

1. 清單建立

   建立一個清單，隻要把逗号分隔的不同的資料項使用方括号括起來即可。如下所示：

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

1. 通路清單中的值

   與字元串的索引一樣，清單索引從 0 開始,執行個體：

list = ['hello', 'World', 1997, 2000]
 print( list[0] ) #hello
 print( list[1] ) #World
 print( list[2] ) #1997
 print(	list[-1]) #2000
 print( list[-2] ) #1997
 # 從第二位開始（包含）截取到倒數第一位（不包含）
print ("list[1:-2]: ", list[1:-1]) #World 1997
           

1. 删除清單中的元素

list = ['hello', 'World', 1997, 2000]
 print ("原始清單 : ", list) #['hello', 'World', 1997, 2000]
 del list[2]
 print ("删除第三個元素 : ", list) #['hello', 'World',2000]
           

1. 清單函數&方法

   1，len(list)

   清單元素個數

   2，max(list)

   傳回清單元素最大值

   3，min(list)

   傳回清單元素最小值

   4，list(seq)

   将元組轉換為清單

   5，list.append(obj)

   在清單末尾添加新的對象

   6，list.count(obj)

   統計某個元素在清單中出現的次數

   7，list.extend(seq)

   在清單末尾一次性追加另一個序列中的多個值（用新清單擴充原來的清單）

   8，list.index(obj)

   從清單中找出某個值第一個比對項的索引位置

   9，list.insert(index, obj)

   将對象插入清單

   10，list.remove(obj)

   移除清單中某個值的第一個比對項

   11， list.sort( key=None, reverse=False)

   對原清單進行排序

   12，list.clear()

   清空清單

   13，list.copy()

   複制清單

5.元組

元組與清單類似，不同之處在于元組的元素不能修改。

1. 建立元組

tup1 = () #空元組
	tup2 = (30,) #元組中隻包含一個元素時，需要在元素後面添加逗号，否則括号會被當作運算符使用
           

1. 通路元組

tup1 = ('hello', 'world', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
           

1. 修改元組

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

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

#建立一個新的元組
tup3 = tup1 + tup2
print (tup3)
           

1. 删除元組

tup = ('hello', 'world', 1997, 2000)

print (tup)
del tup
print ("删除後的元組 tup : ")
print (tup)
           

1. 元組内置函數

• tuple(iterable)

  将可疊代系列轉換為元組。

• len(tuple)

  計算元組元素個數。

• max(tuple)

  傳回元組中元素最大值。

• min(tuple)

  傳回元組中元素最小值。

1. 元組是不可變的

   所謂元組的不可變指的是元組所指向的記憶體中的内容不可變。

6.字典

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

1. 建立字典

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
           

1. 通路字典中的值

dict = {'Name': '張三', 'Age': 7, 'Class': 'Six'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
           

1. 修改字典

dict = {'Name': '張三', 'Age': 7, 'Class': 'Six'}

dict['Age'] = 8               # 更新 Age

           

1. 删除字典元素

dict = {'Name': '張三', 'Age': 7, 'Class': 'Six'}

del dict['Name']  # 删除鍵 'Name'
dict.clear()      # 清空字典
del dict          # 删除字典
           

1. 字典内置函數&方法

• len(dict)

  計算字典元素個數，即鍵的總數。

• str(dict)

  輸出字典，以可列印的字元串表示。

• type(variable)

  傳回輸入的變量類型，如果變量是字典就傳回字典類型。

• radiansdict.clear()

  删除字典内所有元素

• radiansdict.copy()

  傳回一個字典的淺複制

• radiansdict.get(key, default=None)

  傳回指定鍵的值，如果鍵不在字典中傳回 default 設定的預設值

• key in dict

  如果鍵在字典dict裡傳回true，否則傳回false

1. 字典鍵的特性
   • 不允許同一個鍵出現兩次。建立時如果同一個鍵被指派兩次，後一個值會被記住.
   • 鍵必須不可變，是以可以用數字，字元串或元組充當，而用清單就不行

7.集合

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

1. 建立集合

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

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) #集合具有去重功能
           

1. 添加元素

   将元素 x 添加到集合 s 中，如果元素已存在，則不進行任何操作。

還有一個方法，也可以添加元素，且參數可以是清單，元組，字典等，文法格式如下：

1. 移除元素

   将元素 x 從集合 s 中移除，如果元素不存在，則會發生錯誤。

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

1. 計算集合元素個數

   計算集合 s 元素個數。

1. 清空集合

   清空集合s。

1. 集合内置方法
   • add() 為集合添加元素
   • clear() 清空集合
   • discard() 删除集合中指定的元素
   • pop() 随機移除元素
   • remove() 移除指定元素
   • update() 給集合添加元素

三、語句結構

1.條件控制

1. if語句的一般形式如下所示：

if condition_1:
   執行語句1
elif condition_2:
   執行語句2
else:
   執行語句3
           

1. if嵌套

   在嵌套 if 語句中，可以把 if…elif…else 結構放在另外一個 if…elif…else 結構中。

if 表達式1:
    語句1
    if 表達式2:
        語句2
    elif 表達式3:
        語句3
    else:
        語句4
elif 表達式4:
    語句5
else:
    語句6
           

注意：

1、每個條件後面要使用冒号 :，表示接下來是滿足條件後要執行的語句塊。

2、使用縮進來劃分語句塊，相同縮進數的語句在一起組成一個語句塊。

3、在Python中沒有switch – case語句。

2.循環語句

1. while循環語句格式如下：

   while 判斷條件：
   	 執行語句
              

   需要注意冒号和縮進。另外，在 Python 中沒有 do…while 循環。

2. while 循環使用 else 語句

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

   文法格式如下：

'''while 條件1:
    語句1
else:
    語句2'''
    count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")
           

1. for語句

   for循環可以周遊任何序列的項目，如一個清單或者一個字元串。

   for循環的一般格式如下：

'''for item in 序列:
   語句1
else:
   語句2''
   list = ['hello','world',1997,2000]
   for item in list:
   	print(item)
           

1. range()函數

   如果你需要周遊數字序列，可以使用内置range()函數。它會生成數列，例如:

for i in range(5):
   print(i)	# 0 1 2 3 4
for i in range(5,9) :
   print(i)  #5,6,7,8
           

四、輸入輸出

1.輸出

Python兩種輸出值的方式: 表達式語句和 print() 函數。

第三種方式是使用檔案對象的 write() 方法，标準輸出檔案可以用 sys.stdout 引用。

• str()： 函數傳回一個使用者易讀的表達形式。
• repr()： 産生一個解釋器易讀的表達形式。

#輸出方式一
print('hello','world')	#hello	world
#輸出方式二
print('{0} and {1}'.format('hello','world') 	hello and world
#輸出方式三
age=10
print(f'我的年齡為{age}歲')	#我的年齡為10歲
#輸出小數1.234
print('x={:.3f}'.format(1.234)	#1.234
           

2.輸入

input可以接收一個表達式作為輸入，并将運算結果傳回。

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

五、函數

1.函數的定義

• 函數代碼塊以 def 關鍵詞開頭，後接函數辨別符名稱和圓括号 ()。
• 任何傳入參數和自變量必須放在圓括号中間，圓括号之間可以用于定義參數。
• 函數的第一行語句可以選擇性地使用文檔字元串—用于存放函數說明。
• 函數内容以冒号 : 起始，并且縮進。

• return [表達式] 結束函數，選擇性地傳回一個值給調用方，不帶表達式的return 相當于傳回 None。

  代碼示例：

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))
           

2.參數傳遞

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。

• 傳不可變對象執行個體

def change(a):
   print(id(a))   # 指向的是同一個對象
   a=10
   print(id(a))   # 一個新對象

a=1
change(a)
'''輸出結果
140708062561968
140708062561968
140708062562256'''
           

從結果可以看出：形參和實參指向的是同一個對象（對象 id 相同），在函數内部修改形參後，形參指向的是不同的 id。

• 傳可變對象執行個體

  可變對象在函數裡修改了參數，那麼在調用這個函數的函數裡，原始的參數也被改變了。

# 可寫函數說明
def change( list ):
   list.append([1,2,3,4])
   print ("改變後的值: ", list)
   return
 
# 調用changeme函數
mylist = [10,20,30]
change( mylist )
print ("改變前的值: ", mylist)
'''輸出結果：
改變後的值:  [10, 20, 30, [1, 2, 3, 4]]
改變前的值:  [10, 20, 30, [1, 2, 3, 4]]
           

3.匿名函數

python 使用 lambda 來建立匿名函數。

所謂匿名，意即不再使用 def 語句這樣标準的形式定義一個函數。

• lambda 隻是一個表達式，函數體比 def 簡單很多。
• lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
• lambda 函數擁有自己的命名空間，且不能通路自己參數清單之外或全局命名空間裡的參數。

• 雖然lambda函數看起來隻能寫一行，卻不等同于C或C++的内聯函數，後者的目的是調用小函數時不占用棧記憶體進而增加運作效率。

  執行個體：

sum = lambda arg1, arg2: arg1 + arg2
 
# 調用sum函數
print ("相加後的值為 : ", sum( 10, 20 ))
print ("相加後的值為 : ", sum( 20, 20 ))
           

六、File(檔案) 方法

1.open()方法

open() 方法用于打開一個檔案，并傳回檔案對象，在對檔案進行處理過程都需要使用到這個函數，如果該檔案無法被打開，會抛出 OSError。

open() 函數常用形式是接收兩個參數：檔案名(file)和模式(mode)。

open(file, mode='r')
#完整格式為
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
           

參數說明:

• file: 必需，檔案路徑（相對或者絕對路徑）。
• mode: 可選，檔案打開模式
• buffering: 設定緩沖
• encoding: 一般使用utf8
• errors: 報錯級别
• newline: 區分換行符
• closefd: 傳入的file參數類型
• opener: 設定自定義開啟器，開啟器的傳回值必須是一個打開的檔案描述符。

mode常用參數值有：

• w： 打開一個檔案隻用于寫入。如果該檔案已存在則打開檔案，并從開頭開始編輯，即原有内容會被删除。如果該檔案不存在，建立新檔案。
• w+： 打開一個檔案用于讀寫。如果該檔案已存在則打開檔案，并從開頭開始編輯，即原有内容會被删除。如果該檔案不存在，建立新檔案。
• a： 打開一個檔案用于追加。如果該檔案已存在，檔案指針将會放在檔案的結尾。也就是說，新的内容将會被寫入到已有内容之後。如果該檔案不存在，建立新檔案進行寫入。
• a+： 打開一個檔案用于讀寫。如果該檔案已存在，檔案指針将會放在檔案的結尾。檔案打開時會是追加模式。如果該檔案不存在，建立新檔案用于讀寫。
• r： 以隻讀方式打開檔案。檔案的指針将會放在檔案的開頭。這是預設模式。
• r+： 打開一個檔案用于讀寫。檔案指針将會放在檔案的開頭。

2.file對象

1. file.close()

   關閉檔案。關閉後檔案不能再進行讀寫操作。

2. file.read([size])

   從檔案讀取指定的位元組數，如果未給定或為負則讀取所有。

3. file.readline([size])

   讀取整行，包括 “\n” 字元。

4. file.readlines([sizeint])

   讀取所有行并傳回清單，若給定sizeint>0，傳回總和大約為sizeint位元組的行, 實際讀取值可能比 sizeint 較大, 因為需要填充緩沖區。

5. file.write(str)

   将字元串寫入檔案，傳回的是寫入的字元長度。

6. file.writelines(sequence)

   向檔案寫入一個序列字元串清單，如果需要換行則要自己加入每行的換行符。

七、子產品

子產品是一個包含所有你定義的函數和變量的檔案，其字尾名是.py。子產品可以被别的程式引入，以使用該子產品中的函數等功能。這也是使用 python 标準庫的方法。

1.import語句

import sys
 
print('指令行參數如下:')
for i in sys.argv:
   print(i)
 
print('\n\nPython 路徑為：', sys.path, '\n')
           

1. import sys 引入 python 标準庫中的 sys.py 子產品；這是引入某一子產品的方法。
2. sys.argv 是一個包含指令行參數的清單。
3. sys.path 包含了一個 Python 解釋器自動查找所需子產品的路徑的清單。

2.from…import語句

Python 的 from 語句讓你從子產品中導入一個指定的部分到目前命名空間中，文法如下：

3.from … import * 語句

把一個子產品的所有内容全都導入到目前的命名空間也是可行的，隻需使用如下聲明：

八、面向對象

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的執行個體。
• 方法：類中定義的函數。
• 類變量：類變量在整個執行個體化的對象中是公用的。類變量定義在類中且在函數體之外。類變量通常不作為執行個體變量使用。
• 資料成員：類變量或者執行個體變量用于處理類及其執行個體對象的相關的資料。
• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆寫（override），也稱為方法的重寫。
• 局部變量：定義在方法中的變量，隻作用于目前執行個體的類。
• 執行個體變量：在類的聲明中，屬性是用變量來表示的，這種變量就稱為執行個體變量，執行個體變量就是一個用 self 修飾的變量。
• 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模拟"是一個（is-a）"關系（例圖，Dog是一個Animal）。
• 執行個體化：建立一個類的執行個體，類的具體對象。
• 對象：通過類定義的資料結構執行個體。對象包括兩個資料成員（類變量和執行個體變量）和方法。

1.類定義

類執行個體化後，可以使用其屬性，實際上，建立一個類之後，可以通過類名通路其屬性。

class 類名(object):
	語句
           

2.類的屬性與方法

1. 類的私有屬性

   __private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類的外部被使用或直接通路。在類内部的方法中使用時 self.__private_attrs。

2. 類的方法

   在類的内部，使用 def 關鍵字來定義一個方法，與一般函數定義不同，類方法必須包含參數 self，且為第一個參數，self 代表的是類的執行個體。

3. 類的私有方法

   __private_method：兩個下劃線開頭，聲明該方法為私有方法，隻能在類的内部調用 ，不能在類的外部調用。self.__private_methods。

   執行個體：

class People(object):
	__sex = '男'	#私有變量
	work = '程式猿'	#公開變量
    def __init__(self, name, age):
        self.name = name      # public
        self.age = age   # private
 
    def who(self):
        print('name  : ', self.name)
        print('sex : ', self.__sex)
        print('work : ', self.work)
        print('age : ', self.age)
 
    def __foo(self):          # 私有方法
        print('這是私有方法')
 
    def foo(self):            # 公共方法
        print('這是公共方法')
        #調用私有方法
        self.__foo()
p = People('張三',28)
p.who()	
p.foo()
p.__foo()
'''運作結果：
name  :  張三
sex :  男
work :  程式猿
age :  28
這是公共方法
這是私有方法
報錯
'''
           

3.構造方法

類有一個名為 init() 的特殊方法（構造方法），該方法在類執行個體化時會自動調用，像下面這樣：

def __init__(self): #self代表類的執行個體，而非類
    self.data = []
           

4.類的方法

在類的内部，使用 def 關鍵字來定義一個方法，與一般函數定義不同，類方法必須包含參數 self, 且為第一個參數，self 代表的是類的執行個體。

#類定義
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))
 
# 執行個體化類
p = people('張三',10,30)
p.speak()
           

5.繼承

派生類的定義如下所示:

#格式
class DerivedClassName(BaseClassName):

#執行個體
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()
           

6.方法重寫

class Instrument(object):

    def make_sound(self):
        pass

class Erhu(Instrument):

    def make_sound(self):
        print('二胡在演奏...')

class Violin(Instrument):

    def make_sound(self):
        print('小提琴在演奏...')

class Guitar(Instrument):

    def make_sound(self):
        print('吉他在演奏...')

def play(instrument):
    instrument.make_sound()

if __name__ == '__main__':
    play(Erhu())
    play(Violin())
    play(Guitar())