Python PostgreSQL 教程 · ZetCode 中文系列教程

# Python PostgreSQL 教程 > 原文： [http://zetcode.com/python/psycopg2/](http://zetcode.com/python/psycopg2/) 帶有`psycopg2`模塊的 Python PostgreSQL 教程展示了如何使用`psycopg2`模塊在 Python 中編程 PostgreSQL 數據庫。 ## PostgreSQL PostgreSQL 是一個功能強大的開源對象關系數據庫系統。它是一個多用戶數據庫管理系統。它可以在包括 Linux，FreeBSD，Solaris，Microsoft Windows 和 Mac OS X 在內的多個平臺上運行。PostgreSQL 由 PostgreSQL 全球開發小組開發。 ## `psycopg2`模塊 PostgreSQL 有幾個 Python 庫。語言。在本教程中，我們使用`psycopg2`模塊。它是用于 Python 編程語言的 PostgreSQL 數據庫適配器。它主要在 C 中作為`libpq`包裝器實現。 ```py $ pip install psycopg2 ``` 我們安裝`psycopg2`模塊。 ## Python psycopg2 版本示例在第一個代碼示例中，我們獲得 PostgreSQL 數據庫的版本。 `version.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys con = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() cur.execute('SELECT version()') version = cur.fetchone()[0] print(version) except psycopg2.DatabaseError as e: print(f'Error {e}') sys.exit(1) finally: if con: con.close() ``` 在程序中，我們連接到先前創建的`testdb`數據庫。我們執行一條 SQL 語句，該語句返回 PostgreSQL 數據庫的版本。 ```py import psycopg2 ``` `psycopg2`是一個 Python 模塊，用于與 PostgreSQL 數據庫一起使用。 ```py con = None ``` 我們將`con`變量初始化為`None`。如果無法創建與數據庫的連接（例如磁盤已滿），則不會定義連接變量。這將導致`finally`子句中的錯誤。 ```py con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') ``` `connect()`方法創建一個新的數據庫會話并返回一個連接對象。用戶創建時沒有密碼。在 localhost 上，我們可以省略`password`選項。否則，必須指定它。 ```py cur = con.cursor() cur.execute('SELECT version()') ``` 從連接中，我們得到游標對象。游標用于遍歷結果集中的記錄。我們調用游標的`execute()`方法并執行 SQL 語句。 ```py version = cur.fetchone()[0] ``` 我們獲取數據。由于只檢索一條記錄，因此我們稱為`fetchone()`方法。 ```py print(version) ``` 我們將檢索到的數據打印到控制臺。 ```py except psycopg2.DatabaseError as e: print(f'Error {e}') sys.exit(1) ``` 如果發生異常，我們將輸出一條錯誤消息并以錯誤代碼 1 退出程序。 ```py finally: if con: con.close()) ``` 在最后一步，我們釋放資源。 ```py $ version.py PostgreSQL 11.1, compiled by Visual C++ build 1914, 64-bit ``` 這是輸出。在第二個示例中，我們再次獲得 PostgreSQL 數據庫的版本。這次我們使用`with`關鍵字。 `version2.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute('SELECT version()') version = cur.fetchone()[0] print(version) ``` 程序返回 PostgreSQL 數據庫的當前版本。與`with`關鍵字一起使用。代碼更緊湊。 ```py with con: ``` 使用`with`關鍵字，Python 自動釋放資源。它還提供錯誤處理。 ## Python psycopg2 `execute` 我們創建`cars`表并在其中插入幾行。 `execute()`執行數據庫操作（查詢或命令）。 `create_table.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("DROP TABLE IF EXISTS cars") cur.execute("CREATE TABLE cars(id SERIAL PRIMARY KEY, name VARCHAR(255), price INT)") cur.execute("INSERT INTO cars(name, price) VALUES('Audi', 52642)") cur.execute("INSERT INTO cars(name, price) VALUES('Mercedes', 57127)") cur.execute("INSERT INTO cars(name, price) VALUES('Skoda', 9000)") cur.execute("INSERT INTO cars(name, price) VALUES('Volvo', 29000)") cur.execute("INSERT INTO cars(name, price) VALUES('Bentley', 350000)") cur.execute("INSERT INTO cars(name, price) VALUES('Citroen', 21000)") cur.execute("INSERT INTO cars(name, price) VALUES('Hummer', 41400)") cur.execute("INSERT INTO cars(name, price) VALUES('Volkswagen', 21600)") ``` 該程序將創建`cars`表，并將八行插入到該表中。 ```py cur.execute("CREATE TABLE cars(id SERIAL PRIMARY KEY, name VARCHAR(20), price INT)") ``` 該 SQL 語句創建一個新的`cars`表。該表有三列。 ```py cur.execute("INSERT INTO cars(name, price) VALUES('Audi', 52642)") cur.execute("INSERT INTO cars(name, price) VALUES('Mercedes', 57127)") ``` 這兩行將兩輛車插入表。 ```py $ psql -U postgres testdb psql (11.1) Type "help" for help. testdb=# SELECT * FROM cars; id | name | price ----+------------+-------- 1 | Audi | 52642 2 | Mercedes | 57127 3 | Skoda | 9000 4 | Volvo | 29000 5 | Bentley | 350000 6 | Citroen | 21000 7 | Hummer | 41400 8 | Volkswagen | 21600 (8 rows) ``` 我們使用`psql`工具驗證寫入的數據。 ## Python Psycopg2 `executemany` `executemany()`方法是一種方便的方法，用于針對在提供的序列中找到的所有參數元組或映射啟動數據庫操作（查詢或命令）。該函數對更新數據庫的命令最有用：查詢返回的任何結果集都將被丟棄。 `execute_many.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 cars = ( (1, 'Audi', 52642), (2, 'Mercedes', 57127), (3, 'Skoda', 9000), (4, 'Volvo', 29000), (5, 'Bentley', 350000), (6, 'Citroen', 21000), (7, 'Hummer', 41400), (8, 'Volkswagen', 21600) ) con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("DROP TABLE IF EXISTS cars") cur.execute("CREATE TABLE cars(id SERIAL PRIMARY KEY, name VARCHAR(255), price INT)") query = "INSERT INTO cars (id, name, price) VALUES (%s, %s, %s)" cur.executemany(query, cars) con.commit() ``` 本示例刪除`cars`表（如果存在）并（重新）創建它。 ```py cur.execute("DROP TABLE IF EXISTS cars") cur.execute("CREATE TABLE cars(id SERIAL PRIMARY KEY, name VARCHAR(255), price INT)") ``` 第一個 SQL 語句刪除`cars`表（如果存在）。第二條 SQL 語句創建`cars`表。 ```py query = "INSERT INTO cars (id, name, price) VALUES (%s, %s, %s)" ``` 這是我們使用的查詢。 ```py cur.executemany(query, cars) ``` 我們使用便捷的`executemany()`方法將八行插入到表中。此方法的第一個參數是參數化的 SQL 語句。第二個參數是數據，以元組的形式顯示。 ## Python `psycopg2`最后插入的行 ID `psycopg2`不支持`lastrowid`屬性。要返回最后插入的行的 ID，我們必須使用 PostgreSQL 的`RETURNING id`子句。 `lastrowid.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("DROP TABLE IF EXISTS words") cur.execute("CREATE TABLE words(id SERIAL PRIMARY KEY, word VARCHAR(255))") cur.execute("INSERT INTO words(word) VALUES('forest') RETURNING id") cur.execute("INSERT INTO words(word) VALUES('cloud') RETURNING id") cur.execute("INSERT INTO words(word) VALUES('valley') RETURNING id") last_row_id = cur.fetchone()[0] print(f"The last Id of the inserted row is {last_row_id}") ``` 該程序將創建一個新的`words`表并打印最后插入的行的 ID。 ```py $ lastrowid.py The last Id of the inserted row is 3 ``` 這是輸出。 ## Python Psycopg2 `fetchall` `fetchall()`獲取查詢結果的所有（剩余）行，并將它們作為元組列表返回。如果沒有更多記錄可獲取，則返回一個空列表。 `fetch_all.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("SELECT * FROM cars") rows = cur.fetchall() for row in rows: print(f"{row[0]} {row[1]} {row[2]}") ``` 在此示例中，我們從`cars`表中檢索所有數據。 ```py cur.execute("SELECT * FROM cars") ``` 該 SQL 語句從`cars`表中選擇所有數據。 ```py rows = cur.fetchall() ``` `fetchall()`方法獲取所有記錄。它返回一個結果集。從技術上講，它是一個元組的元組。每個內部元組代表表中的一行。 ```py for row in rows: print(f"{row[0]} {row[1]} {row[2]}") ``` 我們將數據逐行打印到控制臺。 ```py $ fetch_all.py 1 Audi 52642 2 Mercedes 57127 3 Skoda 9000 4 Volvo 29000 5 Bentley 350000 6 Citroen 21000 7 Hummer 41400 8 Volkswagen 21600 ``` 這是示例的輸出。 ## Python Psycopg2 `fetchone` `fetchone()`返回查詢結果集的下一行，返回單個元組，或者在沒有更多數據可用時返回`None`。 `fetchone.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("SELECT * FROM cars") while True: row = cur.fetchone() if row == None: break print(f"{row[0]} {row[1]} {row[2]}") ``` 在此示例中，我們連接到數據庫并一張一張地獲取`cars`表的行。 ```py while True: ``` 我們從`while`循環訪問數據。當我們讀取最后一行時，循環終止。 ```py row = cur.fetchone() if row == None: break ``` `fetchone()`方法返回表的下一行。如果沒有剩余數據，則返回`None`。在這種情況下，我們打破了循環。 ```py print(f"{row[0]} {row[1]} {row[2]}") ``` 數據以元組的形式返回。在這里，我們從元組中選擇記錄。第一個是 ID，第二個是汽車名稱，第三個是汽車的價格。 ## Python `psycopg2`字典游標默認游標檢索元組中的數據。使用字典游標，數據以 Python 字典的形式發送。然后，我們可以通過列名稱來引用數據。 `dictionary_cursor` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import psycopg2.extras con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cursor = con.cursor(cursor_factory=psycopg2.extras.DictCursor) cursor.execute("SELECT * FROM cars") rows = cursor.fetchall() for row in rows: print(f"{row['id']} {row['name']} {row['price']}") ``` 在此示例中，我們使用字典游標打印`cars`表的內容。 ```py import psycopg2.extras ``` 字典游標位于`extras`模塊中。 ```py cursor = con.cursor(cursor_factory=psycopg2.extras.DictCursor) ``` 我們創建一個`DictCursor`。 ```py for row in rows: print(f"{row['id']} {row['name']} {row['price']}") ``` 通過列名訪問數據。列名在 PostgreSQL 中（除非加引號）被折疊成小寫并且區分大小寫。因此，我們必須以小寫形式提供列名稱。 ## Python `psycopg2`參數化查詢當使用參數化查詢時，我們使用占位符，而不是直接將值寫入語句。參數化查詢可提高安全性和性能。 Python `psycopg2`模塊支持兩種類型的占位符：ANSI C `printf`格式和 Python 擴展格式。 `parameterized_query.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') uId = 1 uPrice = 62300 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("UPDATE cars SET price=%s WHERE id=%s", (uPrice, uId)) print(f"Number of rows updated: {cur.rowcount}") ``` 我們更新了一輛車的價格。在此代碼示例中，我們使用問號占位符。 ```py cur.execute("UPDATE cars SET price=%s WHERE id=%s", (uPrice, uId)) ``` 字符（`%s`）是值的占位符。這些值將添加到占位符。 ```py print(f"Number of rows updated: {cur.rowcount}") ``` `rowcount`屬性返回更新的行數。在我們的情況下，一行已更新。 ```py $ parameterized_query.py Number of rows updated: 1 testdb=> SELECT * FROM cars WHERE id=1; id | name | price ----+------+------- 1 | Audi | 62300 (1 row) ``` 汽車的價格已更新。我們使用`psql`工具檢查更改。第二個示例使用 Python 擴展格式的參數化語句。 `parameterized_query2.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 uid = 3 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("SELECT * FROM cars WHERE id=%(id)s", {'id': uid } ) row = cur.fetchone() print(f'{row[0]} {row[1]} {row[2]}') ``` 我們使用`pyformat`參數化語句選擇汽車的名稱和價格。 ```py cur.execute("SELECT * FROM cars WHERE id=%(id)s", {'id': uid } ) ``` 命名的占位符以冒號開頭。 ```py $ parameterized_query2.py 3 Skoda 9000 ``` 這是輸出。 ## Python `psycopg2`遷移 `mogrify`是 Python DB API 的`psycopg2`擴展，在參數綁定后返回查詢字符串。返回的字符串恰好是將發送到運行`execute()`方法或類似方法的數據庫的字符串。 `mogrify.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = None with con: cur = con.cursor() print(cur.mogrify("SELECT name, price FROM cars WHERE id=%s", (2,))) # cur.execute("SELECT name, price FROM cars WHERE id=%s", (2,) ) # row = cur.fetchone() # print(f"{row[0]} {row[1]}") ``` 在將參數與`mogrify()`綁定后，程序顯示`SELECT`查詢字符串。 ```py $ mogrify.py b'SELECT name, price FROM cars WHERE id=2' ``` 這是輸出。 ## Python `psycopg2`插入圖像在本節中，我們將圖像插入 PostgreSQL 數據庫。 ```py testdb=> CREATE TABLE images(id SERIAL PRIMARY KEY, data BYTEA); ``` 對于此示例，我們創建一個名為`images`的新表。對于圖像，我們使用`BYTEA`數據類型。它允許存儲二進制字符串。 `insert_image.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys def readImage(): fin = None try: fin = open("sid.jpg", "rb") img = fin.read() return img except IOError as e: print(f'Error {e.args[0]}, {e.args[1]}') sys.exit(1) finally: if fin: fin.close() con = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() data = readImage() binary = psycopg2.Binary(data) cur.execute("INSERT INTO images(data) VALUES (%s)", (binary,)) con.commit() except psycopg2.DatabaseError as e: if con: con.rollback() print(f'Error {e}') sys.exit(1) finally: if con: con.close() ``` 在程序中，我們從當前工作目錄中讀取圖像，并將其寫入 PostgreSQL `testdb`數據庫的`images`表中。 ```py try: fin = open("sid.jpg", "rb") img = fin.read() return img ``` 我們從文件系統讀取二進制數據。我們有一個名為`sid.jpg`的 JPEG 圖像。 ```py binary = psycopg2.Binary(data) ``` 使用`psycopg2` `Binary`對象對數據進行編碼。 ```py cur.execute("INSERT INTO images(data) VALUES (%s)", (binary,)) ``` 該 SQL 語句用于將映像插入數據庫。 ## Python `psycopg2`讀取圖像在本節中，我們將執行相反的操作。我們從數據庫表中讀取圖像。 `read_image.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys def writeImage(data): fout = None try: fout = open('sid2.jpg', 'wb') fout.write(data) except IOError as e: print(f"Error {0}") sys.exit(1) finally: if fout: fout.close() try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() cur.execute("SELECT data FROM images LIMIT 1") data = cur.fetchone()[0] writeImage(data) except psycopg2.DatabaseError as e: print(f'Error {e}') sys.exit(1) finally: if con: con.close() ``` 我們從圖像表中讀取圖像數據并將其寫入另一個文件，我們稱為`sid2.jpg`。 ```py try: fout = open('sid2.jpg', 'wb') fout.write(data) ``` 我們以寫入模式打開一個二進制文件。來自數據庫的數據被寫入文件。 ```py cur.execute("SELECT data FROM images LIMIT 1") data = cur.fetchone()[0] ``` 這兩行從`images`表中選擇并獲取數據。我們從第一行獲取二進制數據。 ## Python PostgreSQL 元數據元數據是有關數據庫中數據的信息。 PostgreSQL 數據庫中的元數據包含有關表和列的信息，我們在其中存儲數據。受 SQL 語句影響的行數是元數據。結果集中返回的行數和列數也屬于元數據。可以使用游標對象的`description`屬性或`information_schema`表獲取 PostgreSQL 中的元數據。接下來，我們打印`cars`表中的所有行及其列名。 `column_names.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute('SELECT * FROM cars') col_names = [cn[0] for cn in cur.description] rows = cur.fetchall() print(f'{col_names[0]} {col_names[1]} {col_names[2]}') ``` 我們將`cars`表的內容打印到控制臺。現在，我們也包括列的名稱。 ```py col_names = [cn[0] for cn in cur.description] ``` 我們從游標對象的`description`屬性獲得列名。 ```py print(f'{col_names[0]} {col_names[1]} {col_names[2]}') ``` 此行打印`cars`表的三個列名。我們使用`for`循環打印行。數據與列名對齊。 ```py $ column_names.py id name price ``` 這是輸出。在下面的示例中，我們列出了`testdb`數據庫中的所有表。 `list_tables.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') with con: cur = con.cursor() cur.execute("""SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'""") rows = cur.fetchall() for row in rows: print(row[0]) ``` 該代碼示例將當前數據庫中的所有可用表打印到終端。 ```py cur.execute("""SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'""") ``` 表名存儲在系統`information_schema`表中。 ```py $ list_tables.py cars countries projects employees users tasks images ``` 這些是我們系統上的表。 ## Python `psycopg2`導出和導入數據我們可以使用`copy_to()`和`copy_from()`導出和導入數據。 `copy_to.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys con = None fout = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() fout = open('cars.csv', 'w') cur.copy_to(fout, 'cars', sep="|") except psycopg2.DatabaseError as e: print(f'Error {e}') sys.exit(1) except IOError as e: print(f'Error {e}') sys.exit(1) finally: if con: con.close() if fout: fout.close() ``` 該代碼示例將數據從`cars`表復制到`cars.csv`文件中。 ```py fout = open('cars.csv', 'w') ``` 我們打開一個文件，在其中寫入`cars`表中的數據。 ```py cur.copy_to(fout, 'cars', sep="|") ``` `copy_to`方法將數據從`cars`表復制到打開的文件。這些列用`|`字符分隔。 ```py $ cat cars.csv 2|Mercedes|57127 3|Skoda|9000 4|Volvo|29000 5|Bentley|350000 6|Citroen|21000 7|Hummer|41400 8|Volkswagen|21600 1|Audi|62300 ``` 這些是`cars`文件的內容。現在，我們將執行反向操作。我們將轉儲的表重新導入數據庫表。 ```py testdb=> DELETE FROM cars; DELETE 8 ``` 我們從`cars`表中刪除數據。 `copy_from.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys con = None f = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() f = open('cars.csv', 'r') cur.copy_from(f, 'cars', sep="|") con.commit() except psycopg2.DatabaseError as e: if con: con.rollback() print(f'Error {e}') sys.exit(1) except IOError as e: if con: con.rollback() print(f'Error {e}') sys.exit(1) finally: if con: con.close() if f: f.close() ``` 在程序中，我們讀取`cars`文件的內容，并將其復制回`cars`表。 ```py f = open('cars.csv', 'r') cur.copy_from(f, 'cars', sep="|") con.commit() ``` 我們打開`cars.csv`文件進行讀取，然后將內容復制到`cars`表中。所做的更改已提交。 ```py SELECT * FROM cars; id | name | price ----+------------+-------- 2 | Mercedes | 57127 3 | Skoda | 9000 4 | Volvo | 29000 5 | Bentley | 350000 6 | Citroen | 21000 7 | Hummer | 41400 8 | Volkswagen | 21600 1 | Audi | 62300 (8 rows) ``` 輸出顯示我們已經成功地重新創建了已保存的`cars`表。 ## Python `psycopg2`事務事務是針對一個或多個數據庫中數據的數據庫操作的基本單位。事務中所有 SQL 語句的影響可以全部提交給數據庫，也可以全部回滾。在`psycopg2`模塊中，事務由連接類處理。連接游標的第一個命令啟動事務。（我們不需要用`BEGIN`和`END`語句來封裝 SQL 命令來創建事務。這將由`psycopg2`自動處理。）以下命令在此新事務的上下文中執行。發生錯誤時，事務將中止，并且直到`rollback()`方法都不再執行其他命令。 `psycopg2`模塊的文檔說，該連接負責終止其事務，并調用`commit()`或`rollback()`方法。提交的更改將立即持久化到數據庫中。使用`close()`方法關閉連接或破壞連接對象（使用`del`或使其超出范圍）將導致隱式的`rollback()`調用。 `psycopg2`模塊還支持自動提交模式，其中對表的所有更改均立即生效。為了在自動提交模式下運行，我們將連接對象的`autocommit`屬性設置為`True`。 `no_commit.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys con = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') cur = con.cursor() cur.execute("DROP TABLE IF EXISTS friends") cur.execute("CREATE TABLE friends(id SERIAL PRIMARY KEY, name VARCHAR(255))") cur.execute("INSERT INTO friends(name) VALUES ('Tom')") cur.execute("INSERT INTO friends(name) VALUES ('Rebecca')") cur.execute("INSERT INTO friends(name) VALUES ('Jim')") cur.execute("INSERT INTO friends(name) VALUES ('Robert')") con.commit() except psycopg2.DatabaseError as e: if con: con.rollback() print('Error {e}') sys.exit(1) finally: if con: con.close() ``` 我們創建`friends`表，并嘗試用數據填充它。但是，正如我們將看到的，數據不會被提交。 ```py #con.commit() ``` 注釋`commit()`方法。如果我們取消注釋該行，則數據將被寫入表中。 ```py finally: if con: con.close() ``` `finally`塊始終執行。如果我們尚未提交更改，并且沒有發生錯誤（會回滾更改），則該事務仍將打開。使用`close()`方法關閉連接，并通過隱式調用`rollback()`方法終止事務。 ```py testdb=# \dt List of relations Schema | Name | Type | Owner --------+-----------+-------+---------- public | cars | table | postgres public | countries | table | postgres public | employees | table | postgres public | images | table | postgres public | projects | table | postgres public | tasks | table | postgres public | users | table | postgres (7 rows) ``` 僅在取消注釋該行之后，才創建`friends`表。 ### Python `psycopg2`自動提交在自動提交模式下，將立即執行一條 SQL 語句。 `autocommit.py` ```py #!/usr/bin/env python # -*- coding: utf-8 -*- import psycopg2 import sys con = None try: con = psycopg2.connect(database='testdb', user='postgres', password='s$cret') con.autocommit = True cur = con.cursor() cur.execute("DROP TABLE IF EXISTS friends") cur.execute("CREATE TABLE friends(id serial PRIMARY KEY, name VARCHAR(10))") cur.execute("INSERT INTO friends(name) VALUES ('Jane')") cur.execute("INSERT INTO friends(name) VALUES ('Tom')") cur.execute("INSERT INTO friends(name) VALUES ('Rebecca')") cur.execute("INSERT INTO friends(name) VALUES ('Jim')") cur.execute("INSERT INTO friends(name) VALUES ('Robert')") cur.execute("INSERT INTO friends(name) VALUES ('Patrick')") except psycopg2.DatabaseError as e: print(f'Error {e}') sys.exit(1) finally: if con: con.close() ``` 在此示例中，我們以自動提交模式連接到數據庫。我們既不調用`commit()`，也不調用`rollback()`方法。 ```py con.autocommit = True ``` 我們將連接設置為自動提交模式。 ```py $ autocommit.py testdb=# select * from friends; id | name ----+--------- 1 | Jane 2 | Tom 3 | Rebecca 4 | Jim 5 | Robert 6 | Patrick (6 rows) ``` 數據已成功提交到`friends`表。這是 PostgreSQL Python 教程。您可能也對 [SQLite Python 教程](/python/sqlite/)和 [MySQL Python 教程](/python/pymysql/)感興趣