ZetCode

Python PostgreSQL

最后修改于 2024 年 1 月 29 日

在本文中，我们将展示如何使用 psycopg2 模块在 Python 中编程 PostgreSQL 数据库。

PostgreSQL

PostgreSQL 是一个强大、开源的对象关系数据库系统。它是一个多用户数据库管理系统。它运行在多种平台，包括 Linux、FreeBSD、Solaris、Microsoft Windows 和 Mac OS X。PostgreSQL 由 PostgreSQL 全球开发组开发。

psycopg2 模块

有几个 Python 库用于 PostgreSQL。在本文中，我们使用 psycopg2 模块。它是 Python 编程语言的 PostgreSQL 数据库适配器。它主要用 C 实现为 libpq 的包装器。

$ pip install psycopg2

我们安装 psycopg2 模块。

Python psycopg2 版本示例

在第一个代码示例中，我们获取 PostgreSQL 数据库的版本。

version.py 
#!/usr/bin/python

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 数据库的版本。

import psycopg2

psycopg2 是一个用于操作 PostgreSQL 数据库的 Python 模块。

con = None

我们将 con 变量初始化为 None。万一我们无法创建数据库连接（例如磁盘已满），我们将没有连接变量。这将在 finally 子句中导致错误。

con = psycopg2.connect(database='testdb', user='postgres',
    password='s$cret')

connect 方法创建新的数据库会话并返回一个连接对象。用户创建时没有密码。在 localhost 上，我们可以省略密码选项。否则，必须指定它。

cur = con.cursor()
cur.execute('SELECT version()')

从连接中，我们获取游标对象。游标用于遍历结果集中的记录。我们调用游标的 execute 方法并执行 SQL 语句。

version = cur.fetchone()[0]

我们获取数据。由于我们只检索一条记录，我们调用 fetchone 方法。

print(version)

我们将检索到的数据打印到控制台。

except psycopg2.DatabaseError as e:

    print(f'Error {e}')
    sys.exit(1)

在发生异常的情况下，我们打印错误消息并以错误代码 1 退出程序。

finally:

    if con:
        con.close()

在最后一步，我们释放资源。

$ version.py
PostgreSQL 11.1, compiled by Visual C++ build 1914, 64-bit

在第二个示例中，我们再次获取 PostgreSQL 数据库的版本。这次我们使用 with 关键字。

version2.py 
#!/usr/bin/python

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 关键字。代码更简洁。

with con:

使用 with 关键字，Python 会自动释放资源。它还提供错误处理。

Python psycopg2 execute

我们创建 cars 表并向其中插入多行。execute 执行数据库操作（查询或命令）。

create_table.py 
#!/usr/bin/python

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 表并将八行插入表中。

cur.execute("CREATE TABLE cars(id SERIAL PRIMARY KEY, name VARCHAR(20), price INT)")

此 SQL 语句创建一个新的 cars 表。该表有三列。

cur.execute("INSERT INTO cars(name, price) VALUES('Audi', 52642)")
cur.execute("INSERT INTO cars(name, price) VALUES('Mercedes', 57127)")

这两行将两辆汽车插入表中。

$ 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 
#!/usr/bin/python

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 表并（重新）创建它。

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 表。

query = "INSERT INTO cars (id, name, price) VALUES (%s, %s, %s)"

这是我们使用的查询。

cur.executemany(query, cars)

我们使用便捷的 executemany 方法将八行插入表中。此方法的第一参数是参数化 SQL 语句。第二个参数是数据，形式是元组的元组。

Python psycopg2 最后插入的行 ID

psycopg2 不支持 lastrowid 属性。要返回最后插入行的 ID，我们必须使用 PostgreSQL 的 RETURNING id 子句。

lastrowid.py 
#!/usr/bin/python

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。

$ lastrowid.py
The last Id of the inserted row is 3

Python psycopg2 fetchall

fetchall 获取查询结果的所有（剩余）行，将它们作为元组列表返回。如果没有更多要获取的记录，则返回空列表。

fetch_all.py 
#!/usr/bin/python

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 表中检索所有数据。

cur.execute("SELECT * FROM cars")

此 SQL 语句从 cars 表中选择所有数据。

rows = cur.fetchall()

fetchall 方法获取所有记录。它返回一个结果集。严格来说，它是一个元组的元组。每个内部元组代表表中的一行。

for row in rows:
    print(f"{row[0]} {row[1]} {row[2]}")

我们将数据逐行打印到控制台。

$ 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 
#!/usr/bin/python

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 表的行。

while True:

我们从 while 循环访问数据。当我们读取最后一行时，循环终止。

row = cur.fetchone()

if row == None:
    break

fetchone 方法返回表中的下一行。如果没有更多数据，它返回 None。在这种情况下，我们中断循环。

print(f"{row[0]} {row[1]} {row[2]}")

数据以元组的形式返回。在这里我们从元组中选择记录。第一个是 ID，第二个是汽车名称，第三个是汽车价格。

Python psycopg2 字典游标

默认游标以元组的元组检索数据。使用字典游标，数据以 Python 字典的形式发送。然后我们可以按列名引用数据。

dictionary_cursor 
#!/usr/bin/python

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 表的内容。

import psycopg2.extras

字典游标位于 extras 模块中。

cursor = con.cursor(cursor_factory=psycopg2.extras.DictCursor)

我们创建一个 DictCursor。

for row in rows:
    print(f"{row['id']} {row['name']} {row['price']}")

数据通过列名访问。列名在 PostgreSQL 中被折叠为小写（除非加引号）并且区分大小写。因此，我们必须以小写形式提供列名。

Python psycopg2 参数化查询

当我们使用参数化查询时，我们使用占位符而不是直接将值写入语句。参数化查询可提高安全性和性能。

Python psycopg2 模块支持两种类型的占位符：ANSI C printf 格式和 Python 扩展格式。

parameterized_query.py 
#!/usr/bin/python

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}")

我们更新一辆汽车的价格。在这个代码示例中，我们使用问号占位符。

cur.execute("UPDATE cars SET price=%s WHERE id=%s", (uPrice, uId))

字符 (%s) 是值的占位符。值被添加到占位符。

print(f"Number of rows updated: {cur.rowcount}")

rowcount 属性返回更新的行数。在我们的例子中，更新了一行。

$ 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 
#!/usr/bin/python

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 参数化语句选择汽车的名称和价格。

cur.execute("SELECT * FROM cars WHERE id=%(id)s", {'id': uid } )

命名占位符以冒号字符开头。

$ parameterized_query2.py
3 Skoda 9000

Python psycopg2 mogrify

mogrify 是 psycopg2 对 Python DB API 的扩展，它在参数绑定后返回查询字符串。返回的字符串与运行 execute 方法或类似方法发送到数据库的字符串完全相同。

mogrify.py 
#!/usr/bin/python

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 查询字符串。

$ mogrify.py
b'SELECT name, price FROM cars WHERE id=2'

Python psycopg2 插入图像

在本节中，我们将向 PostgreSQL 数据库插入图像。

注意： 通常不建议将二进制数据插入数据库表中。
testdb=> CREATE TABLE images(id SERIAL PRIMARY KEY, data BYTEA);

在这个例子中，我们创建了一个名为 images 的新表。对于图像，我们使用 BYTEA 数据类型。它允许存储二进制字符串。

insert_image.py 
#!/usr/bin/python

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 表中。

try:
    fin = open("sid.jpg", "rb")
    img = fin.read()
    return img

我们从文件系统中读取二进制数据。我们有一个名为 sid.jpg 的 JPEG 图像。

binary = psycopg2.Binary(data)

数据使用 psycopg2 Binary 对象进行编码。

cur.execute("INSERT INTO images(data) VALUES (%s)", (binary,))

这个 SQL 语句用于将图像插入数据库。

Python psycopg2 读取图像

在本节中，我们将执行相反的操作。我们从数据库表中读取图像。

read_image.py 
#!/usr/bin/python

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()

我们从 images 表读取图像数据并将其写入另一个文件，我们称之为 sid2.jpg。

try:
    fout = open('sid2.jpg', 'wb')
    fout.write(data)

我们以写入模式打开一个二进制文件。来自数据库的数据将被写入该文件。

cur.execute("SELECT data FROM images LIMIT 1")
data = cur.fetchone()[0]

这两行从 images 表中选择并获取数据。我们从第一行获取二进制数据。

Python PostgreSQL 元数据

元数据是关于数据库中数据的信息。PostgreSQL 数据库中的元数据包含有关表和列的信息，我们在其中存储数据。SQL 语句影响的行数是元数据。结果集中返回的行数和列数也属于元数据。

PostgreSQL 中的元数据可以通过游标对象的 description 属性或 information_schema 表获得。

接下来，我们打印 cars 表中的所有行及其列名。

column_names.py 
#!/usr/bin/python

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 表的内容打印到控制台。现在，我们还包括列名。

col_names = [cn[0] for cn in cur.description]

我们从游标对象的 description 属性获取列名。

print(f'{col_names[0]} {col_names[1]} {col_names[2]}')

这一行打印了 cars 表的三个列名。

我们使用 for 循环打印行。数据与列名对齐。

$ column_names.py
id name price

在下面的示例中，我们列出 testdb 数据库中的所有表。

list_tables.py 
#!/usr/bin/python

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])

该代码示例将当前数据库中所有可用的表打印到终端。

cur.execute("""SELECT table_name FROM information_schema.tables
    WHERE table_schema = 'public'""")

表名存储在系统 information_schema 表中。

$ list_tables.py
cars
countries
projects
employees
users
tasks
images

这些是我们系统上的表。

Python psycopg2 数据导出和导入

我们可以使用 copy_to 和 copy_from 来导出和导入数据。

copy_to.py 
#!/usr/bin/python

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 文件中。

fout = open('cars.csv', 'w')

我们打开一个文件，我们将数据从 cars 表写入其中。

cur.copy_to(fout, 'cars', sep="|")

copy_to 方法将数据从 cars 表复制到打开的文件中。列以 | 字符分隔。

$ 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 文件的内容。

现在我们将执行一个相反的操作。我们将转储的表导入回数据库表中。

testdb=> DELETE FROM cars;
DELETE 8

我们从 cars 表中删除数据。

copy_from.py 
#!/usr/bin/python

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 表。

f = open('cars.csv', 'r')
cur.copy_from(f, 'cars', sep="|")
con.commit()

我们打开 cars.csv 文件进行读取，并将内容复制到 cars 表中。更改已提交。

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 模块中，事务由连接类处理。连接游标的第一个命令启动一个事务。（我们不需要将 SQL 命令用 BEGIN 和 END 语句括起来来创建事务。这由 psycopg2 自动处理。）后续命令在此新事务的上下文中执行。如果发生错误，事务将被中止，并且在调用 rollback 方法之前，不会执行任何进一步的命令。

psycopg2 模块的文档指出，连接负责终止其事务，调用 commit 或 rollback 方法。已提交的更改将立即持久化到数据库中。使用 close 方法关闭连接或销毁连接对象（使用 del 或让它超出范围）将导致隐式调用 rollback。

psycopg2 模块还支持自动提交模式，在该模式下，对表的所有更改都立即生效。要在自动提交模式下运行，我们将连接对象的 autocommit 属性设置为 True。

no_commit.py 
#!/usr/bin/python

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 表并尝试用数据填充它。但是，正如我们将看到的，数据不会被提交。

#con.commit()

commit 方法被注释掉了。如果我们取消注释该行，数据将被写入表中。

finally:

    if con:
        con.close()

finally 块始终执行。如果我们没有提交更改并且没有发生错误（这会导致回滚更改），事务仍然是打开的。连接通过 close 方法关闭，事务通过隐式调用 rollback 方法终止。

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 
#!/usr/bin/python

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 方法。

con.autocommit = True

我们将连接设置为自动提交模式。

$ autocommit.py

testdb=# select * from friends;
 id |  name
----+---------
  1 | Jane
  2 | Tom
  3 | Rebecca
  4 | Jim
  5 | Robert
  6 | Patrick
(6 rows)

数据已成功提交到 friends 表中。

来源

Python psycopg2 项目页面

在本文中，我们展示了如何使用 psycopg2 模块在 Python 中编程 PostgreSQL 数据库。

作者

我叫 Jan Bodnar，是一名充满激情的程序员，拥有丰富的编程经验。我自 2007 年以来一直在撰写编程文章。到目前为止，我已撰写了 1400 多篇文章和 8 本电子书。我在编程教学方面有十多年的经验。

列出所有 Python 教程。