來源：三分惡

大家好，我是老三，我最近在看一些人工智慧相關的東西，大部分相關的框架，都是用Pyhon寫的。

老三會用Python，但談不上多熟練，最近準備拿Python作為自己的第二語言，那麼這期我們來一起快速梳理一下Python基礎。

起步

Python簡介

Python是一門解釋性程式語言，既年長又年輕的語言，它誕生於1989年，近些年，人工智慧的復興，給它注入了新的活力。

“Python”的中文翻譯“蟒蛇”，因為Python之父Guido van Rossum，就是這位頭髮濃密的大叔，喜歡蟒蛇。

Python的主流版本又分為2.X和3.X，2.X已經停止維護，目前Python已經發布到了3.11.2版本。

環境準備

我們來看一下在Windows環境下Python的安裝。

從官網下載Python，版本我們選擇3.9.6：

下載完成之後就可以安裝了，安裝過程選擇Add Pytyon 3.9 to PATH,這樣就可以在任意路徑使用Python了，同時也可以自定義一下Python的安裝路徑，我一般都是安裝在D盤。
Win+R開啟命令列介面，輸入Python，會顯示Python的版本號，至此Pytyon安裝就已經完成，並且開啟了Python Shell。

我們還預設安裝了一個重要的工具——pip，它是Python的包管理工具，類似Java的Maven、Node的npm，在命令列介面輸入pip -V，可以看到pid的版本：

編輯器準備

Python提供了互動式執行工具Python Shell，直接輸入一行程式碼：

 print('Hello World.')

萬物之始：Hello World.

當然，日常開發肯定不會使用這種互動式的方式，而是使用檔案的方式，那麼Python檔案的編輯器一般使用什麼呢？

Python因為是解釋性語言，可選的編輯器有很多：Pycharm、Jupyter、Sbulime Text、VSCode……

功能最強大的肯定是Pycharm，但是因為佔記憶體，最重要的是得花錢，所以我一般用VSCode。

VSCode的安裝就不多說，直接下載安裝就可以了
為了更好地利用VSCode開發Python，推薦安裝一些外掛：

Python：VS Code官方自帶外掛
LiveCode for python：可以實時顯示每一個變數值
Sourcery：可以自動審查和改進程式碼
IntelliCode：官方提供的AI輔助開發外掛，提供比較充分的程式碼提示
Python Indent：更好地進行Python程式碼的縮排
Python Test Explorer：視覺化程式碼測試
Python Snippets：自動補全程式碼片段

還有其它的一些好用的外掛，大家可以自行探索—— 如果有的選，建議Pycharm。

我們來簡單體驗一下VSCode編寫Python程式碼：

建立資料夾python-demo

使用VSCode開啟資料夾，新建檔案hello.py

編寫程式碼

print('Hello World.')

可以直接在右上角點選執行

至此，Python開發環境就已經準備好了，那麼我們開始學習Python基礎語法。

入門

基本命令

Python是一門非常簡單的語言，我們前面的print就是非常簡單的列印操作。

Python是一門解釋性語言，有點類似shell，對縮排要求比較嚴格，以Tab鍵或者4個空格進行縮排。

例如，這一段程式碼就有語法錯誤：

需要改成：

Python的註釋，使用#：

在VSCode裡可以使用快捷鍵Ctrl+/快速註釋：

資料型別

Python是一種物件導向的程式語言，所有的資料型別都是類，每個資料值都是類的“例項”，並且不需要顯式宣告變數的型別。

在Python中有6種主要的內建資料型別：數字（Number）、字串（string）、列表（list）、元組（tuple）、集合（set）和字典（dict）。

數字（Number）

Python中常用的數字型別有兩種：整數(int)、浮點(float)。

我們在Python Shell裡進行一些數字的操作：

定義和輸出

>>> num=1
>>> print(num)
1

+,-,*,/,%,//,

>>> 2+2
4
>>> 60+3*2
66
>>> 36/2
18.0
>>> 33%10
3   
>>> (66-30)*2/4
18.0
>>> 19//3
6

其中/會永遠返回浮點數float，Python只支援雙精度的浮點數float，返回int需要用//

int和float轉換

>>> int_num=int(8.8)
>>> print(int_num)
8

Python 支援其他型別的數字，例如Decimal and Fraction。 Python 還內建了對複數（complex）的支援，當然，用的也不多。

字串（string）

字串是最常用的資料型別，它可以放在單引號''裡，也可以放在雙引號“”裡。

>>> 'Good man'
'Good man'
>>> "Good man"
'Good man'

字串連線可以直接使用+

>>> "Python is"+"good"
'Python isgood'

如果字串本身包含單引號''或者雙引號“”，可以使用轉義符\

>>> "I say:\"Python is good\"."
'I say:"Python is good".'

字串可以和數字相互轉化，字串轉數字可以用int()或float()，數字轉字串可以用str()

>>> int("666")
666
>>> float("66.6")
66.6
>>> str(888)
'888'

字串支援下標訪問，包括正向索引（正數），和反向索引（負數）

>>> str="The world is so greate."
>>> str[5]
'o'
>>> str[-2]
'e'

字串使用find()查詢，replace()替換，split()切割

>>> str="There is a hard people."
>>> str.find('hard')
11
>>> str.replace(' ','|')   
'There|is|a|hard|people.'
>>> str.split('|')
['There is a hard people.']

列表（list）

線性表這種資料結構我們都比較熟悉，Python中的實現是list，類似於Java中的ArrayList，list中可以放入任意型別的變數：

>>> list1=["Python","Good","Study"]
>>> list2=[1,2,3,4,5]
>>> list3=["Python",4,"is",12.3,"Good"]

元素可以直接透過下標訪問：

>>> list1[2] 
'Study'

透過append()方法新增元素

>>> list1.append("World")
>>> print(list1)
['Python', 'Good', 'Study', 'World']

透過insert(i，x)方法在指定位置插入元素

>>> list1.insert(1,"Should")
>>> print(list1)
['Python', 'Should', 'Good', 'Study']

替換元素，可以直接list[i]=x

>>> list=[60,80,30,70] 
>>> list[2]=90
>>> print(list)
[60, 80, 90, 70]

刪除元素，使用remove(x)方法

>>> list.remove(60)
>>> print(list)
[80, 90, 70]

元組（tuple）

列表（list）是一種可變的序列型別，元組（tuple）是一種不可變的序列型別，由多個用逗號隔開的值組成：

>>> t=1314,"love",3,666
>>> t[0]
1314
>>> t
(1314, 'love', 3, 666)

集合（set）

集合（set）是一種可迭代的、無序的、不能包含重複元素的容器型別的資料，類似於Java中的Set。

>>> set={50,50,60,90,70,60}
>>> print(set)
{50, 60, 90, 70}

集合的新增用add()，刪除用remove()

>>> set.add(100)
>>> set.remove(50)
>>> print(set)
{100, 70, 90, 60}

字典（dict）

字典（dict）是一種key，value型別的資料結構，類似於Java中的Map。

>>> tel = {'jack': 4098, 'sape': 4139}
>>> print(tel)
{'jack': 4098, 'sape': 4139}

可以直接根據key找到value

>>> tel['jack']
4098

新增和更新元素都可以直接透過key

>>> tel['Tommy']=9876
>>> tel['sape']=5925 
>>> print(tel)
{'jack': 4098, 'sape': 5925, 'Tommy': 9876}

使用pop()刪除元素

>>> tel.pop('Tommy')
9876
>>> print(tel)
{'jack': 4098, 'sape': 5925}

好了，基本的資料結構我們都盤點完了，還有一些api，這裡沒有給出，建議大家可以直接檢視api doc。

流程控制

每個語言裡都有條件語句、迴圈語句等等流程控制語句，我們來看看Python中的條件語句和迴圈語句。

條件語句

if語句

# 從控制檯獲取輸入
score=int(input("請輸入你的分數："))

if score>=90:
    print("優秀")  
if score>=80 and score<90:
    print("良好") 
if score>=60 and score<80:
    print("及格")      
if score<60:
    print("不及格")

執行結果：

在Python裡，有三種邏輯運算子：
not：邏輯非
and：邏輯與
or：邏輯或
其中and和or都是短路運算。

if-else

# 從控制檯獲取輸入
score=int(input("請輸入你的分數："))

if score>=60:
    print('及格')
else:
    print("不及格")

if-elif-else

# 從控制檯獲取輸入
score=int(input("請輸入你的分數："))

if score>=90:
    print("優秀")  
elif score>=80:
    print("良好") 
elif score>=60:
    print("及格")      
else:
    print("不及格")

迴圈語句

Python支援兩種迴圈語句：while和for。

while

i=0
sum=0

# 0到100的總和
while i<100:
  sum+=i
  i+=1
   
print(sum)

for

Python中的for比較特殊，只能迭代列表、字串等任意序列，不能迭代算數遞增值，或者定義結束條件。

names=['張三','李四','王五','趙六']

for name in names:
  print(name)

執行結果：

如果想對數字序列進行迭代呢？那就得用到range()函式：

for i in range(6):
  print(i)

如果想要跳出迴圈，或者跳過本次迴圈呢？

break/continue

break：break用於跳出 for 或 while 迴圈

for i in range(10):
    if i>3:
        #跳出迴圈
        break
    print(i)

continue：continue用於結束本次迴圈

for i in range(10):
    if i%2==0:
        #跳出本次迴圈
        continue
    print(i)

容器型別迴圈

一些集合型別的迴圈，比如列表、字典，還是非常常用的。

列表迴圈

for迴圈列表

nums=[1,3,5,7,9]

for i in nums:
    print(i)

while迴圈，根據下標迴圈list，和string遍歷基本一樣

nums=[1,3,5,7,9]

len=len(nums)
i=0

while i<len:
    print(nums[i])
    i=i+1;

用enumerate() 函式可以同時取出位置索引和對應的值：

persons=['張三','李四','王五']

for i,v in enumerate(persons):
    print(i,v)

字典遍歷

字典是

items()遍歷：可以同時取出鍵和對應的值

person_dict={'張三':26,'李四':22,'王五':33}

# 遍歷字典中的元素
for k,v in person_dict.items():
    print(k,v)

遍歷keys：可以用keys()函式，當然不用也可以

person_dict={'張三':26,'李四':22,'王五':33}

# 遍歷keys
for k in person_dict.keys():
   print(k,person_dict[k]) 

# 不用keys()也可以   
for k in person_dict:
   print(k,person_dict[k])

遍歷values：用values()函式可以直接遍歷values

person_dict={'張三':26,'李四':22,'王五':33}

# 遍歷values
for v in person_dict.values():
   print(v)

函式

我們在寫程式碼的過程中，有很多重複的邏輯，這時候就應該考慮複用這些邏輯，那麼就應該定義一些函式（Functions）。

比如下面一段程式碼，建立一個函式，計算長方形的面積：

# 定義函式，計算長方形面積
def get_area(height,width):
    area=height*width
    return area

# 呼叫函式：實參順序和形參一致
area=get_area(12,8)
print(area)

# 呼叫函式：直接指定形參，順序無限制
area=get_area(width=9,height=15)
print(area)

在這個簡單的函式里：

def: Python中用def關鍵字定義函式
get_area：函式名
height,width:函式的形參
area=height*width：函式體
return area：函式的返回值

在呼叫的時候，如果不直接指定形參，那麼實參的順序要和形參一致。

模組

上面我們學習了Python的函式，透過函式我們可以實現很多程式碼的複用，但是問題來了，所有的函式我們也不能都寫在一個檔案裡，那到後面這個檔案就膨脹地不像話了，必須拆分檔案。

那麼檔案拆分後，裡面的函式怎麼呼叫呢？這就得用到Python的模組了。

寫一個calculate.py，很簡單，裡面定義一個簡單的函式add，這時候calculate.py就可以理解為一個模組
```
# 加法
def add(a,b):
    return a+b;
```

再寫一個main.py，匯入模組，呼叫函式

# 匯入模組
import calculate

# 使用模組名呼叫函式
print(calculate.add(5,6))

如果模組名太長了，也可以給模組設定別名：

# 匯入模組
import calculate as cal

# 使用模組名呼叫函式
print(cal.add(5,6))

假如模組裡定義的函式太多了，而我們只需要用某一個函式，或者某幾個函式，怎麼辦？可以只匯入模組中的函式：

# 匯入模組中的函式
from calculate import add

#使用模組名呼叫函式
print(add(5,6))

Python中也內建了很多模組，常用的有math、datetime、os等等。

例如，利用datetime獲取當前年月：

#匯入日期模組
import datetime

# 獲取當前年、月
def get_year_and_month():
    now = datetime.datetime.now()
    year=now.year
    month=now.month
    return year,month

year,month=get_year_and_month();
print(f'{year}:{month}')

更多的標準庫，可以直接檢視官方的api文件。

物件導向

Python是一門物件導向的語言，物件導向是為了更好地複用程式碼，接下里，我們看看物件導向的三大特徵：封裝、繼承、多型在Python裡是怎麼實現的。

類和物件

所謂類就是某個型別，比如人類，所謂物件，就是類的例項，比如張三。

class Person:
    
def say_hello(n):
    print('你好')

zhansan=Person()
zhansan.say_hello()

這段程式碼裡定義了一個類Person，類裡定義了一個方法say_hello，例項化了一個物件zhangsan，呼叫了方法。

類裡可以有這些成員：

class Person:
    # 類變數
    planet='地球'
    
    # 構造方法，初始化成員變數
    def __init__(self,name,sex,age):
        # 成員變數：姓名，性別，年齡
        self.name=name
        self.sex=sex
        self.age=age
    
    # 例項方法，使用成員變數     
    def say_hello(self):
       print(f'{self.name}:你好')
       
    #類方法
    @classmethod
    def breath(cls):
        print('人需要呼吸')  

# 使用構造方法例項化物件並賦值        
zhansan=Person(name='張三',sex='男',age=22)
# 呼叫例項方法
zhansan.say_hello()   
# 呼叫類方法
Person.breath()

在類中：

成員變數也被稱為資料成員，類變數屬於類，例項變數屬於例項。
構造方法用於初始化類的成員變數。
成員方法是在類中定義的函式，包含類方法和例項方法。

我們接下來，看看物件導向的三大特徵在Python裡是怎麼實現的。

封裝/繼承/多型

封裝

封裝就是隱藏物件的內部細節，外部只管呼叫就行了。

Python中的變數預設是公開的，可以在外部的類中訪問它們，如果想讓它們變為私有變數，在變數前加上雙雙下畫線（__）就行了，變數的獲取和設定可以透過get()、set()方法。

class Programer:
    
    # 構造方法，初始化成員變數
    def __init__(self,name):
        # 建立初始化例項變數：姓名
        self.name=name
        # 建立和初始化私有例項變數：_level
        self._level=''
    
    # 例項方法  
    def write_bug(self):
        print(self._level+self.name+'正在寫bug中。。')
        
    # get方法
    def get_level(self):
        return self._level
    
    # get方法
    def set_level(self,level):
        self._level=level
      
# 例項化
programer =Programer('張三') 
# 設定私有變數
programer.set_level('高階工程師') 
# 呼叫成員方法  
programer.write_bug() 
# 使用get方法獲取私有變數  
print(programer.get_level())

繼承

我們現在讓Programer繼承Person，繼承語法很簡單，在類後()裡指定繼承的類就行了，可以一個，也可以多個。

from Person import Person


# 繼承Person
class Programer(Person):
    
    # 構造方法，初始化成員變數
    def __init__(self,name):
        # 建立初始化例項變數：姓名
        self.name=name
        # 建立和初始化私有例項變數：_level
        self._level=''
    
    # 例項方法  
    def write_bug(self):
        print(self._level+self.name+'正在寫bug中。。')
        
    # get方法
    def get_level(self):
        return self._level
    
    # get方法
    def set_level(self,level):
        self._level=level
      
# 例項化
programer =Programer('張三') 
# 設定私有變數
programer.set_level('高階工程師') 
# 呼叫成員方法  
programer.write_bug() 
# 使用get方法獲取私有變數  
print(programer.get_level())    

# 呼叫父類方法
programer. say_hello()

多型

Python同樣支援多型，對於繼承，實現多型的方式，就是重寫父類的方法：

from Person import Person


# 繼承Person
class Programer(Person):
    
    # 構造方法，初始化成員變數
    def __init__(self,name):
        # 建立初始化例項變數：姓名
        self.name=name
        # 建立和初始化私有例項變數：_level
        self._level=''
    
    # 例項方法  
    def write_bug(self):
        print(self._level+self.name+'正在寫bug中。。')
        
    # get方法
    def get_level(self):
        return self._level
    
    # get方法
    def set_level(self,level):
        self._level=level
        
    # 重寫父類方法
    def say_hello(self):
        print(f"一介開發{self.name}向您問好！")   

      
# 例項化
programer =Programer('張三') 
# 設定私有變數
programer.set_level('高階工程師') 
# 呼叫成員方法  
programer.write_bug() 
# 使用get方法獲取私有變數  
print(programer.get_level())    

# 呼叫重寫了的父類方法
programer. say_hello()

異常處理

對於開發工程師而言，日常最苦惱的事情大概就是寫bug和找bug了。

有些時候，我們不希望因為某些錯誤，導致整個程式停止，那麼我們就可以利用try/except語句來捕獲異常。

比如下面的程式碼，用5/0：

num=5/0

結果就發生了異常：

ZeroDivisionError: division by zero

我們可以捕獲這個異常：

try:
    num=5/0
except Exception as e:
    print(e)

在這段程式碼裡，我們捕獲了異常，並把它列印了出來，我們也可以用pass空語句，不對異常做任何處理：

try:
    num=5/0
except Exception as e:
    pass

我們還可以使用finally子句，定義所有情況下都必須執行的操作：

try:
    num=5/0
except Exception as e:
    print(e)
finally:
    print('end')

小結

這一篇幾千字的小文章到此就結束了，在這篇文章裡，我們快速過了一遍Python環境的搭建，以及各種基礎語法，包括資料型別、流程控制語句、函式、模組、物件導向、異常處理。

大家可以看到，Python是一門相對比較好上手的語言，我有個同事這麼說——“Python有什麼好學的，看看不就會了”。雖然他有吹的成分，但也可以看到，如果有一些程式語言基礎，Python上手還是比較簡單的。

我們可以先掌握Python基礎，把它用起來，用的過程中，再透過文件、搜尋引擎、ChatGPT等等，不斷加深對細節的掌握。

參考：

[1]. 《Python網路爬蟲從入門到實踐》

[2].

[3].

[4].《看漫畫學Python》

Python快速入門，看這一篇就夠了！

起步