技術文章 » Python 基礎面試第四彈

Python 基礎面試第四彈

2023-09-01 06:00:46

1. Python中常用的庫有哪些，作用分別是什麼

  1. requests: requests 是一個用於傳送 HTTP 請求的庫，它提供了簡單而優雅的 API，可以輕鬆地傳送 GET、POST、PUT、DELETE 等請求，並處理響應資料。它支援對談管理、身份驗證、檔案上傳等常見的 HTTP 功能，是進行 Web 開發和 API 呼叫的常用選擇。

  2. math: math 是 Python 的標準庫之一，提供了許多數學運算相關的函數和常數。它包括基本的數學運算（如三角函數、指數函數、對數函數）、數學常數（如π和自然對數的基數e）、數學操作（如取整、絕對值、冪運算）等。math 庫是進行數學計算和科學計算的基礎。

  3. websocket: websocket 是一個用於建立和管理 WebSocket 連線的庫。WebSocket 是一種在使用者端和伺服器之間實現全雙工通訊的協定，它允許伺服器主動向使用者端推播資料，而不需要使用者端傳送請求。websocket 庫提供了用於建立 WebSocket 伺服器和使用者端的功能，使得在 Web 應用程式中實現實時通訊變得更加容易。

  4. time: time 是 Python 的標準庫之一，提供了與時間相關的功能。它包括獲取當前時間、日期和時間的轉換、時間戳的操作、睡眠（延遲執行）等功能。time 庫廣泛用於需要處理時間和日期的應用程式，例如定時任務、紀錄檔記錄、效能分析等。

  5. pymysql: pymysql 是一個用於連線和操作 MySQL 資料庫的庫。它是 Python 的一個流行的資料庫介面，提供了在 Python 中執行 SQL 語句、連線資料庫、事務管理等功能。pymysql 庫可以用於許多與資料庫相關的任務，如資料查詢、資料插入、資料更新等。

2. Python中的垃圾回收機制

    在Python中，垃圾回收（Garbage Collection）是自動管理記憶體的過程，它負責檢測和回收不再使用的物件佔用的記憶體空間。Python使用了一種稱為參照計數（Reference Counting）的垃圾回收機制，以及一個可選的迴圈垃圾回收器（Cycle Detector）來處理迴圈參照的物件。

參照計數：
Python中的每個物件都有一個參照計數器，用於記錄當前有多少個參照指向該物件。當一個物件被參照時，它的參照計數增加；當一個參照被刪除或超出作用域時，參照計數減少。當物件的參照計數變為0時，說明該物件沒有被參照，即成為垃圾物件，可以被垃圾回收機制回收。

參照計數機制的優點是實時性高，當物件不再被參照時，可以立即回收記憶體。但它也存在一些缺點，例如無法處理迴圈參照的情況。

迴圈垃圾回收器：
為了解決迴圈參照的問題，Python中引入了迴圈垃圾回收器。迴圈垃圾回收器通過週期性地檢測物件之間的參照關係，找到不再被參照的迴圈參照物件，並將其回收。它的工作原理如下：

  1. 標記階段（Marking Phase）：從根物件（如全域性變數、活動棧、呼叫棧等）開始，通過遍歷物件之間的參照關係，標記所有可以存取到的物件。
  2. 清除階段（Sweeping Phase）：遍歷整個堆記憶體，清除未被標記的物件，並回收它們佔用的記憶體空間。
  3. 壓縮階段（Compacting Phase）：對堆記憶體進行整理，將存活的物件向一端移動，以便釋放連續的記憶體空間。

迴圈垃圾回收器可以解決參照計數無法處理的迴圈參照問題，但它會增加垃圾回收的開銷，並且在回收垃圾時可能會導致一些暫停。

其他優化技術：
除了參照計數和迴圈垃圾回收器之外，Python還使用了其他一些優化技術來改善垃圾回收的效能，例如：

  1. 分代回收（Generational Collection）：根據物件的存活時間將其分為不同的代，採用不同的回收策略。大部分物件往往很快就變成垃圾，而只有少部分物件存活更久。通過針對不同代採用不同的回收頻率，可以減少垃圾回收的開銷。
  2. 增量回收（Incremental Collection）：將垃圾回收過程分解為多個階段，在每個階段之間允許程式繼續執行。這樣可以將垃

 3. python中的物件和參照的理解

    在Python中，物件是資料的抽象表示，可以是數位、字串、列表、函數等。物件在記憶體中佔據一定的空間，幷包含了資料和運算元據的方法。每個物件都有一個唯一的身份（Identity），可以通過內建函數id()獲取。

參照是指向物件的識別符號，可以將其視為指標或者別名。在Python中，通過變數名、資料結構中的元素、函數引數等方式建立參照。參照允許我們存取和操作物件，但並不直接儲存物件本身，而是指向物件所在的記憶體地址。

下面我們詳細討論Python中的物件和參照的一些特性：

1. 物件的建立和銷燬：
物件的建立是通過使用相應的建構函式或者字面值來實現的。例如，使用str()建構函式建立字串物件，使用[]符號建立列表物件等。物件的銷燬是通過垃圾回收機制來自動處理的，當物件不再被參照時，垃圾回收機制會回收其佔用的記憶體空間。

2. 物件的身份（Identity）：
每個物件在建立時都會分配一個唯一的身份，可以通過id()函數獲取。物件的身份是在其生命週期中保持不變的，即使物件的值發生變化，其身份也不會改變。

3. 可變物件和不可變物件：
在Python中，物件可以分為可變（Mutable）物件和不可變（Immutable）物件。可變物件的值可以被修改，而不可變物件的值是不可改變的。例如，列表（list）是可變物件，可以通過修改元素來改變其值；而字串（str）是不可變物件，一旦建立，其值就不能被修改。

4. 參照的賦值和傳遞：
在Python中，參照可以通過賦值操作進行建立和修改。當我們將一個物件賦值給一個變數時，實際上是將該物件的參照賦值給了變數。這意味著變數和物件之間建立了關聯，但並不表示變數與物件是同一個實體。

在函數呼叫時，引數傳遞也是通過參照進行的。當我們將一個物件作為引數傳遞給函數時，函數內部的引數將參照該物件。這意味著函數內部對引數進行的修改可能會影響到原始物件。

5. 參照計數的影響：
參照計數是Python垃圾回收機制的核心。每個物件都有一個參照計數器，記錄有多少個參照指向該物件。當參照計數變為0時，說明物件不再被參照，可以被垃圾回收器回收。參照計數機制的優點是實時性高，能夠及時回收不再使用的物件，但無法處理迴圈參照的情況。

綜上所述，Python中的物件是資料的抽象表示，通過參照來存取和操作物件。參照提供了對物件的別名或指標，允許我們在程式中使用物件。同時，垃圾回收機制通過參照計數和迴圈垃圾回收器來管理和回收不再使用的物件，確保記憶體的有效利用。

4. Python中單例模式的實現

    在Python中，單例模式是一種設計模式，用於確保類只有一個範例，並提供全域性存取點以獲取該範例。單例模式通常用於需要共用資源或全域性狀態的情況，以避免建立多個範例造成資源浪費或狀態不一致的問題。

下面是一種常見的Python單例模式的實現方式：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

在這個實現中，使用了類變數 _instance 來儲存唯一的範例。在 __new__ 方法中判斷 _instance 是否已經存在範例，如果不存在則建立一個新的範例，並將其賦值給 _instance。如果 _instance 已經存在範例，則直接返回該範例。

下面通過一個例子來說明如何使用該單例類：

class Logger(Singleton):
    def __init__(self):
        self.log = []

    def add_log(self, message):
        self.log.append(message)

    def print_log(self):
        for message in self.log:
            print(message)


# 建立多個 Logger 範例
logger1 = Logger()
logger2 = Logger()

# logger1 和 logger2 是同一個範例
print(logger1 is logger2)  # 輸出: True

# 向 logger1 新增紀錄檔
logger1.add_log('Log message 1')
logger1.add_log('Log message 2')

# logger2 也能存取到 logger1 新增的紀錄檔
logger2.print_log()

# 輸出:
# Log message 1
# Log message 2

5. Python 中常用的表示式：

    1. 匹配數位：\d
      這個表示式可以匹配一個任意數位字元。例如，"\d"可以匹配字串中的"1"、"2"、"3"等數位字元。

    2. 匹配字母：[a-zA-Z]
      這個表示式可以匹配一個任意字母字元。"[a-zA-Z]"可以匹配字串中的大寫字母和小寫字母。

    3. 匹配空白字元：\s
      這個表示式可以匹配一個任意空白字元，包括空格、製表符和換行符。

    4. 匹配單詞邊界：\b
      這個表示式可以匹配一個單詞的邊界。例如，"\bword\b"可以匹配字串中獨立的單詞"word"。

    5. 匹配重複字元：+
      這個表示式可以匹配一個或多個重複的前一個字元或表示式。例如，"a+"可以匹配一個或多個連續的字母"a"。

    6. 匹配任意字元：.
      這個表示式可以匹配除換行符外的任意字元。

    7. 匹配起始位置：^
      這個表示式可以匹配字串的起始位置。例如，"^Hello"可以匹配以"Hello"開頭的字串。

    8. 匹配結束位置：$
      這個表示式可以匹配字串的結束位置。例如，"world$"可以匹配以"world"結尾的字串。

6. 在 Python 中，什麼是上下文管理器（Context Manager）？如何實現一個上下文管理器？ 

　　在Python中，上下文管理器（Context Manager）是一種用於管理資源的機制，確保在程式碼塊執行前後正確地獲取和釋放資源。上下文管理器通常與 with 語句一起使用，以確保資源的正確開啟和關閉，即使在發生異常的情況下也能進行適當的清理。

要實現一個上下文管理器，需要定義一個類，並在該類中實現兩個特殊方法：__enter__() 和 __exit__()。

  1. __enter__() 方法：該方法在進入程式碼塊之前被呼叫，並返回一個值，該值將由 as 語句後的變數接收。通常在該方法中進行資源的獲取和初始化操作。

  2. __exit__() 方法：該方法在程式碼塊執行完成後被呼叫，無論是否發生異常。它負責資源的釋放和清理操作。__exit__() 方法接收三個引數：異常型別、異常值和跟蹤資訊。如果程式碼塊正常執行完畢，這些引數都為 None。如果發生異常，可以在 __exit__() 方法中處理異常並返回 True，以指示異常已被處理。如果返回 False 或引發新的異常，則異常將向上層傳播。

下面是一個簡單的範例，展示瞭如何實現一個上下文管理器：

class MyContextManager:
    def __enter__(self):
        # 在進入程式碼塊之前進行資源的獲取和初始化
        print("Entering the context")
        return self  # 可選擇性地返回一個值給 as 語句後的變數

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 在程式碼塊執行完成後進行資源的釋放和清理
        print("Exiting the context")
        if exc_type is not None:
            # 處理異常並返回 True 表示異常已被處理
            print(f"Exception occurred: {exc_type}, {exc_val}")
            return True

# 使用上下文管理器
with MyContextManager() as cm:
    # 在這裡執行需要進行資源管理的程式碼塊
    print("Inside the context")
    # 可以在程式碼塊中引發異常來驗證例外處理
    # raise ValueError("Something went wrong")

 

7.  Python 中的非同步程式設計，包括 async/await 關鍵字和 asyncio 模組的使用

在 Python 中，非同步程式設計是一種程式設計模式，用於編寫高效的非阻塞（non-blocking）並行程式碼。它允許程式在等待某些操作完成時繼續執行其他任務，而不會阻塞整個程式的執行流程。

非同步程式設計的關鍵部分是 async/await 關鍵字和 asyncio 模組。

  1. async/await 關鍵字：

    • async：用於定義一個非同步函數。非同步函數可以包含 await 關鍵字，表示在等待某些非同步操作完成時暫停函數的執行。
    • await：用於等待一個非同步操作的完成。它可以用於非同步函數內部，暫停函數的執行並允許其他任務執行，直到非同步操作完成並返回結果。

  2. asyncio 模組：

    • asyncio 是 Python 標準庫中用於非同步程式設計的模組。它提供了一組工具和函數，用於編寫非同步程式碼。
    • 主要的元件是事件迴圈（event loop），它負責排程和執行非同步任務。事件迴圈允許多個任務並行執行，並在需要時掛起和恢復任務的執行。
    • asyncio 還提供了一些輔助函數和類，用於處理非同步操作，例如非同步 I/O 操作、定時器等。
    • 通過使用 asyncio 模組，可以編寫基於回撥、協程和任務的非同步程式碼。

下面是一個簡單的範例，展示瞭如何使用 async/await 和 asyncio 進行非同步程式設計：

import asyncio

# 定義一個非同步函數
async def greet(name):
    print(f"Hello, {name}!")
    await asyncio.sleep(1)  # 模擬一個耗時的非同步操作
    print(f"Goodbye, {name}!")

# 建立一個事件迴圈
loop = asyncio.get_event_loop()

# 呼叫非同步函數
tasks = [greet("Alice"), greet("Bob")]
# 將非同步函數包裝成任務物件
# 可以使用 asyncio.create_task() 或 loop.create_task() 建立任務
# create_task() 是 Python 3.7 之後的新語法，推薦使用
# tasks = [asyncio.create_task(greet("Alice")), asyncio.create_task(greet("Bob"))]

# 執行任務並等待完成
loop.run_until_complete(asyncio.wait(tasks))

# 關閉事件迴圈
loop.close()

在上面的範例中，greet() 是一個非同步函數，使用 async 關鍵字進行定義。在函數內部，使用 await 關鍵字等待 asyncio.sleep(1) 的完成。通過建立任務物件，並使用事件迴圈的 run_until_complete() 方法來執行這些任務。最後，通過呼叫 loop.close() 關閉事件迴圈。

非同步程式設計在處理 I/O 密集型任務（如網路請求、資料庫存取等）時特別有效，因為可以在等待響應時充分利用 CPU 完成其他任務，從而提高程式的效能和響應能力。