Python 数据访问 - 快速指南

---

---

Python MySQL - 简介

Python 数据库接口的标准是 Python DB-API。大多数 Python 数据库接口都遵循此标准。

您可以为您的应用程序选择合适的数据库。Python 数据库 API 支持各种数据库服务器，例如：

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase

以下是可用的 Python 数据库接口列表：Python 数据库接口和 API。您必须为需要访问的每个数据库下载单独的 DB API 模块。例如，如果您需要访问 Oracle 数据库和 MySQL 数据库，则必须同时下载 Oracle 和 MySQL 数据库模块。

什么是 mysql-connector-python？

MySQL Python/Connector 是一个用于从 Python 连接到 MySQL 数据库服务器的接口。它实现了 Python 数据库 API，并且构建在 MySQL 之上。

如何安装 mysql-connector-python？

首先，您需要确保您的机器上已安装 python。为此，请打开命令提示符并在其中键入 python 并按 Enter。如果您的系统中已安装 python，则此命令将显示其版本，如下所示：

C:\Users\Tutorialspoint>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

现在按ctrl+z然后按 Enter 退出 python shell 并创建一个名为 Python_MySQL 的文件夹（您打算在其中安装 Python-MySQL 连接器）如下：

>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL

验证 PIP

PIP 是 python 中的一个包管理器，您可以使用它在 Python 中安装各种模块/包。因此，要安装 Mysql-python mysql-connector-python，您需要确保您的计算机上已安装 PIP 并且其位置已添加到路径中。

您可以通过执行 pip 命令来做到这一点。如果您的系统中没有 PIP，或者您没有将其位置添加到Path环境变量中，您将收到一条错误消息，如下所示：

D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.

要安装 PIP，请将get-pip.py下载到上面创建的文件夹中，然后从命令导航到该文件夹并按如下方式安装 pip：

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
Downloading https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
|████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
Downloading https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

安装 mysql-connector-python

安装 Python 和 PIP 后，打开命令提示符并升级 pip（可选），如下所示：

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Python Data Access
4
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

然后以管理员模式打开命令提示符并安装 python MySQL 连接，如下所示：

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
Using cached https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

验证

要验证安装是否成功，请创建一个包含以下行的示例 python 脚本。

import mysql.connector

如果安装成功，当您执行它时，您不应该收到任何错误：

D:\Python_MySQL>python test.py
D:\Python_MySQL>

从头开始安装 python

简单来说，如果您需要从头开始安装 Python。请访问Python 主页。

点击下载按钮，您将被重定向到下载页面，该页面提供各种平台上最新版 python 的链接，选择一个并下载它。

例如，我们下载了 python-3.7.4.exe（适用于 Windows）。通过双击下载的.exe文件启动安装过程。

选中“将 Python 3.7 添加到 PATH”选项，然后继续安装。此过程完成后，python 将安装到您的系统中。

Python MySQL - 数据库连接

要连接到 MySQL，（一种方法是）在您的系统中打开 MySQL 命令提示符，如下所示：

它在此处要求输入密码；您需要键入在安装时为默认用户（root）设置的密码。

然后与 MySQL 建立连接，显示以下消息：

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

您可以随时使用 mysql> 提示符下的 exit 命令断开与 MySQL 数据库的连接。

mysql> exit
Bye

使用 python 建立与 MySQL 的连接

在使用 python 建立与 MySQL 数据库的连接之前，假设：

• 我们已创建一个名为 mydb 的数据库。

• 我们已创建一个名为 EMPLOYEE 的表，其中包含列 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME。

• 我们用于连接 MySQL 的凭据是用户名：root，密码：password。

您可以使用connect()构造函数建立连接。它接受用户名、密码、主机和需要连接的数据库名称（可选），并返回 MySQLConnection 类的对象。

示例

以下是连接到 MySQL 数据库“mydb”的示例。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()

输出

执行此脚本后，将产生以下输出：

D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)

您还可以通过将凭据（用户名、密码、主机名和数据库名）传递给connection.MySQLConnection()来建立与 MySQL 的连接，如下所示：

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(user='root', password='password', host='127.0.0.1', database='mydb')

#Closing the connection
conn.close()

Python MySQL - 创建数据库

您可以使用 CREATE DATABASE 查询在 MYSQL 中创建数据库。

语法

以下是 CREATE DATABASE 查询的语法：

CREATE DATABASE name_of_the_database

示例

以下语句在 MySQL 中创建一个名为 mydb 的数据库：

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)

如果您使用 SHOW DATABASES 语句观察数据库列表，您可以在其中观察新创建的数据库，如下所示：

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| logging            |
| mydatabase         |
| mydb               |
| performance_schema |
| students           |
| sys                |
+--------------------+
26 rows in set (0.15 sec)

使用 python 在 MySQL 中创建数据库

在与 MySQL 建立连接后，要对其进行数据操作，您需要连接到数据库。您可以连接到现有数据库或创建自己的数据库。

您需要特殊的权限才能创建或删除 MySQL 数据库。因此，如果您有权访问 root 用户，则可以创建任何数据库。

示例

以下示例与 MYSQL 建立连接并在其中创建一个数据库。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

List of databases:
[('information_schema',), ('dbbug61332',), ('details',), ('exampledatabase',), ('mydatabase',), ('mydb',), ('mysql',), ('performance_schema',)]

Python MySQL - 创建表

CREATE TABLE 语句用于在 MYSQL 数据库中创建表。在这里，您需要指定表名以及每列的定义（名称和数据类型）。

语法

以下是创建 MySQL 表的语法：

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

示例

以下查询在 MySQL 中创建一个名为 EMPLOYEE 的表，其中包含五个列，即 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME。

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.42 sec)

DESC 语句为您提供指定表的描述。使用它，您可以验证表是否已创建，如下所示：

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

使用 python 在 MySQL 中创建表

名为execute()（在游标对象上调用）的方法接受两个变量：

• 表示要执行的查询的字符串值。

• 一个可选的 args 参数，它可以是元组或列表或字典，表示查询的参数（占位符的值）。

它返回一个整数值，表示查询影响的行数。

建立数据库连接后，您可以通过将 CREATE TABLE 查询传递给execute()方法来创建表。

简而言之，要使用 python 创建表：

• 导入mysql.connector包。

• 使用mysql.connector.connect()方法创建一个连接对象，通过将用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过在上面创建的连接对象上调用cursor()方法创建一个游标对象。

• 然后，通过将其作为参数传递给execute()方法来执行CREATE TABLE语句。

示例

以下示例在数据库 mydb 中创建一个名为Employee的表。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

Python MySQL - 插入数据

您可以使用INSERT INTO语句向 MySQL 的现有表中添加新行。在此，您需要指定表名、列名和值（与列名相同的顺序）。

语法

以下是 MySQL INSERT INTO 语句的语法。

INSERT INTO TABLE_NAME (column1, column2,column3,...columnN)
VALUES (value1, value2, value3,...valueN);

示例

以下查询将一条记录插入名为 EMPLOYEE 的表中。

INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('
   Mac', 'Mohan', 20, 'M', 2000
);

您可以使用 SELECT 语句验证插入操作后的表记录，如下所示：

mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Mac        | Mohan     | 20   | M    | 2000   | 
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)

并非总是必须指定列名，如果您按照表列的相同顺序传递记录值，则可以如下所示执行 SELECT 语句而不使用列名：

INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);

使用 python 在 MySQL 表中插入数据

execute()方法（在游标对象上调用）接受查询作为参数并执行给定的查询。要插入数据，您需要将 MySQL INSERT 语句作为参数传递给它。

cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")

要在 MySQL 中使用 python 将数据插入表中：

• 导入mysql.connector包。

• 使用mysql.connector.connect()方法创建一个连接对象，通过将用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过在上面创建的连接对象上调用cursor()方法创建一个游标对象

• 然后，通过将其作为参数传递给execute()方法来执行INSERT语句。

示例

以下示例执行 SQL INSERT 语句以将记录插入 EMPLOYEE 表中：

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""

try:
   # Executing the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

# Closing the connection
conn.close()

动态插入值

您还可以使用“%s”代替 MySQL 的INSERT查询中的值，并将值作为列表传递给它们，如下所示：

cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""", 
   ('Ramya', 'Ramapriya', 25, 'F', 5000))

示例

以下示例动态地将记录插入 Employee 表中。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)

try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   
   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

print("Data inserted")

# Closing the connection
conn.close()

输出

Data inserted

Python MySQL - 查询数据

您可以使用 SELECT 查询从 MySQL 中的表中检索/获取数据。此查询/语句以表格形式返回指定表的内容，称为结果集。

语法

以下是 SELECT 查询的语法：

SELECT column1, column2, columnN FROM table_name;

示例

假设我们在 MySQL 中创建了一个名为 cricketers_data 的表，如下所示：

CREATE TABLE cricketers_data(
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Date_Of_Birth date,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

insert into cricketers_data values(
   'Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values(
   'Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values(
   'Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

以下查询从表中检索 FIRST_NAME 和 Country 值。

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     |
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

您还可以使用 * 代替列名来检索每条记录的所有值，如下所示：

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

使用 Python 从 MYSQL 表中读取数据

对任何数据库执行读取操作都意味着从数据库中获取一些有用的信息。您可以使用 mysql-connector-python 提供的 fetch() 方法从 MYSQL 中获取数据。

cursor.MySQLCursor 类提供了三种方法，即 fetchall()、fetchmany() 和 fetchone()，其中：

• fetchall() 方法检索查询结果集中的所有行，并将其作为元组列表返回。（如果我们在检索了几行后执行此操作，它将返回剩余的行）。

• fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。

• fetchmany() 方法类似于 fetchone()，但它检索查询结果集中的下一组行，而不是单个行。

注意 - 结果集是在使用游标对象查询表时返回的对象。

rowcount - 这是一个只读属性，返回受 execute() 方法影响的行数。

示例

以下示例使用 SELECT 查询获取 EMPLOYEE 表的所有行，并从获得的结果集中首先使用 fetchone() 方法检索第一行，然后使用 fetchall() 方法检索剩余的行。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

输出

('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]

以下示例使用 fetchmany() 方法检索 EMPLOYEE 表的前两行。

示例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Python MySQL - Where 子句

如果要获取、删除或更新 MySQL 表中的特定行，则需要使用 where 子句指定条件来过滤表的行以进行操作。

例如，如果您的 SELECT 语句带有 where 子句，则只会检索满足指定条件的行。

语法

以下是 WHERE 子句的语法：

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

示例

假设我们在 MySQL 中创建了一个名为 EMPLOYEES 的表，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

如果我们使用 INSERT 语句向其中插入了 4 条记录，如下所示：

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

以下 MySQL 语句检索收入大于 4000 的员工的记录。

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Raj        | Kandukuri | 20   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

使用 python 的 WHERE 子句

要使用 python 程序从表中获取特定记录：

• 导入mysql.connector包。

• 使用mysql.connector.connect()方法创建一个连接对象，通过将用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过在上面创建的连接对象上调用cursor()方法创建一个游标对象。

• 然后，通过将其作为参数传递给 execute() 方法，执行带有 WHERE 子句的 SELECT 语句。

示例

以下示例创建一个名为 Employee 的表并填充它。然后使用 where 子句检索年龄值小于 23 的记录。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 19, 'M', 2000), ('Raj', 'Kandukuri', 20, 'M', 7000),
('Ramya', 'Ramapriya', 25, 'F', 5000),('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Python MySQL - Order By

在使用 SELECT 查询获取数据时，您可以使用 OrderBy 子句按所需顺序（升序或降序）对结果进行排序。默认情况下，此子句按升序对结果进行排序，如果需要按降序排列，则需要显式使用“DESC”。

语法

以下是语法 SELECT column-list

FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:

示例

假设我们在 MySQL 中创建了一个名为 EMPLOYEES 的表，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

如果我们使用 INSERT 语句向其中插入了 4 条记录，如下所示：

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

以下语句按年龄的升序检索 EMPLOYEE 表的内容。

mysql> SELECT * FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
| Mac        | Mohan     |   26 |    M |   2000 |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

您还可以使用 DESC 按降序检索数据，如下所示：

mysql> SELECT * FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Mac        | Mohan     |   26 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

使用 python 的 ORDER BY 子句

要按特定顺序检索表的内容，请在游标对象上调用 execute() 方法，并将 SELECT 语句以及 ORDER BY 子句作为参数传递给它。

示例

在以下示例中，我们正在创建一个名为 Employee 的表并填充它，并使用 ORDER BY 子句按其年龄的（升序）顺序检索其记录。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 26, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]

同样，您可以使用 ORDER BY 子句按降序从表中检索数据。

示例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving specific records using the ORDERBY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY INCOME DESC")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0)
]

Python MySQL - 更新表

对任何数据库执行更新操作都会更新一个或多个数据库中已存在的记录。您可以使用 UPDATE 语句更新 MySQL 中现有记录的值。要更新特定行，您需要与之一起使用 WHERE 子句。

语法

以下是 MySQL 中 UPDATE 语句的语法：

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

您可以使用 AND 或 OR 运算符组合 N 个条件。

示例

假设我们在 MySQL 中创建了一个名为 EMPLOYEES 的表，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

如果我们使用 INSERT 语句向其中插入了 4 条记录，如下所示：

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

以下 MySQL 语句将所有男性员工的年龄增加一年：

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec)
Rows matched: 3 Changed: 3 Warnings: 0

如果检索表的内容，您可以看到更新后的值，如下所示：

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
| Mac        | Mohan     | 27   | M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

使用 Python 更新表的内容

要在 MySQL 中使用 python 更新表中的记录：

• 导入mysql.connector包。

• 使用mysql.connector.connect()方法创建一个连接对象，通过将用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过在上面创建的连接对象上调用cursor()方法创建一个游标对象。

• 然后，通过将其作为参数传递给 execute() 方法，执行 UPDATE 语句。

示例

以下示例将所有男性的年龄增加一年。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''
try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()
   
#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]

Python MySQL - 删除数据

要从 MySQL 表中删除记录，您需要使用 DELETE FROM 语句。要删除特定记录，您需要与之一起使用 WHERE 子句。

语法

以下是 MYSQL 中 DELETE 查询的语法：

DELETE FROM table_name [WHERE Clause]

示例

假设我们在 MySQL 中创建了一个名为 EMPLOYEES 的表，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

如果我们使用 INSERT 语句向其中插入了 4 条记录，如下所示：

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

以下 MySQL 语句删除 FIRST_NAME 为“Mac”的员工的记录。

mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)

如果检索表的内容，您只会看到 3 条记录，因为我们删除了一条。

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

如果在没有 WHERE 子句的情况下执行 DELETE 语句，则将删除指定表中的所有记录。

mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)

如果检索表的内容，您将获得一个空集，如下所示：

mysql> select * from EMPLOYEE;
Empty set (0.00 sec)

使用 python 删除表中的记录

当您要从数据库中删除某些记录时，需要 DELETE 操作。

要删除表中的记录：

• 导入mysql.connector包。

• 使用mysql.connector.connect()方法创建一个连接对象，通过将用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过在上面创建的连接对象上调用cursor()方法创建一个游标对象。

• 然后，通过将其作为参数传递给 execute() 方法，执行 DELETE 语句。

示例

以下程序删除 EMPLOYEE 中所有年龄超过 20 的记录：

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)

try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

Contents of the table:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0), 
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)]

Contents of the table after delete operation:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0)]

Python MySQL - 删除表

您可以使用 DROP TABLE 语句删除整个表。您只需要指定要删除的表的名称。

语法

以下是 MySQL 中 DROP TABLE 语句的语法：

DROP TABLE table_name;

示例

在删除表之前，请使用 SHOW TABLES 语句获取表的列表，如下所示：

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| sample          |
| tutorials       |
+-----------------+
5 rows in set (0.00 sec)

以下语句完全删除数据库中名为 sample 的表：

mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)

由于我们已从 MySQL 中删除了名为 sample 的表，因此如果您再次获取表的列表，则在其中将找不到表名 sample。

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| tutorials       |
+-----------------+
4 rows in set (0.00 sec)

使用 python 删除表

您可以随时使用 MYSQL 的 DROP 语句删除表，但在删除任何现有表时需要非常小心，因为删除表后数据将无法恢复。

要使用 python 从 MYSQL 数据库中删除表，请在游标对象上调用 execute() 方法，并将 drop 语句作为参数传递给它。

示例

以下表从数据库中删除名为 EMPLOYEE 的表。

import mysql.connector

#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method 
cursor = conn.cursor()

#Retrieving the list of tables print("List of tables in the database: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute
   ("DROP TABLE EMPLOYEE") print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection conn.close()

输出

List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]

仅当存在时才删除表

如果您尝试删除数据库中不存在的表，则会发生错误，如下所示：

mysql.connector.errors.ProgrammingError: 1051 (42S02): 
   Unknown table 'mydb.employee'

您可以通过在删除之前验证表是否存在来防止此错误，方法是在 DELETE 语句中添加 IF EXISTS。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

输出

List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]

Python MySQL - Limit

在获取记录时，如果要将它们限制为特定数量，则可以使用 MYSQL 的 LIMIT 子句。

示例

假设我们在 MySQL 中创建了一个名为 EMPLOYEES 的表，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

如果我们使用 INSERT 语句向其中插入了 4 条记录，如下所示：

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

以下 SQL 语句使用 LIMIT 子句检索 Employee 表的前两条记录。

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 19   | M    | 2000   |
| Raj        | Kandukuri | 20   | M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

使用 python 的 Limit 子句

如果通过将 SELECT 查询以及 LIMIT 子句作为参数传递给游标对象上的 execute() 方法，则可以检索所需数量的记录。

要使用 python 从 MYSQL 数据库中删除表，请在游标对象上调用 execute() 方法，并将 drop 语句作为参数传递给它。

示例

以下 python 示例创建一个名为 EMPLOYEE 的表并填充它，并使用 LIMIT 子句获取其前两条记录。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

带 OFFSET 的 LIMIT

如果需要从第 n 条记录（而不是第 1 条）开始限制记录，则可以使用 OFFSET 以及 LIMIT。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

输出

[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]

Python MySQL - Join

当您将数据分成两个表时，您可以使用联接从这两个表中获取组合的记录。

示例

假设我们创建了一个名为 EMPLOYEE 的表，并向其中填充了数据，如下所示：

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES ('Ramya', 'Rama Priya', 27, 'F', 9000, 101), 
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102), 
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103), 
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104), 
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

然后，如果我们创建了另一个表并将其填充为：

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai');
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

以下语句检索这两个表中值的组合数据：

mysql> SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | [email protected] | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | [email protected]    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | [email protected] | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | [email protected]    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

使用 python 的 MYSQL JOIN

以下示例从上述两个表中检索数据，这两个表通过 EMPLOYEE 表的 contact 列和 CONTACT 表的 ID 列组合。

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, '[email protected]', 9848022338, 'Hyderabad'), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'), 
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')]

Python MySQL - 游标对象

mysql-connector-python（以及类似库）的 MySQLCursor 用于执行与 MySQL 数据库通信的语句。

使用它的方法，您可以执行 SQL 语句、从结果集中获取数据、调用过程。

您可以使用 Connection 对象/类的 cursor() 方法创建 Cursor 对象。

示例

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

方法

以下是 Cursor 类/对象提供的各种方法。

属性

以下是 Cursor 类的属性：

Python PostgreSQL - 简介

安装

PostgreSQL 是一个功能强大的开源对象关系数据库系统。它拥有超过 15 年的活跃开发阶段，以及久经考验的架构，使其赢得了可靠性、数据完整性和正确性方面的良好声誉。

要使用 Python 与 PostgreSQL 通信，您需要安装 psycopg，这是一个为 Python 编程提供的适配器，其当前版本为 psycog2。

psycopg2 的编写目标是体积小、速度快且稳定可靠。它可以通过 PIP（Python 的包管理器）获得。

使用 PIP 安装 Psycog2

首先，确保 Python 和 PIP 已正确安装在您的系统中，并且 PIP 已更新到最新版本。

要升级 PIP，请打开命令提示符并执行以下命令：

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

然后，以管理员模式打开命令提示符并执行 pip install psycopg2-binary 命令，如下所示：

C:\WINDOWS\system32>pip install psycopg2-binary
Collecting psycopg2-binary
Using cached https://files.pythonhosted.org/packages/80/79/d0d13ce4c2f1addf4786f4a2ded802c2df66ddf3c1b1a982ed8d4cb9fc6d/psycopg2_binary-2.8.3-cp37-cp37m-win32.whl
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.3

验证

要验证安装，请创建一个包含以下行的 Python 脚本示例。

import mysql.connector

如果安装成功，当您执行它时，您不应该收到任何错误：

D:\Python_PostgreSQL>import psycopg2
D:\Python_PostgreSQL>

Python PostgreSQL - 数据库连接

PostgreSQL 提供了自己的 Shell 来执行查询。要建立与 PostgreSQL 数据库的连接，请确保您已在系统中正确安装了它。打开 PostgreSQL Shell 提示符并传递服务器、数据库、用户名和密码等详细信息。如果您提供的详细信息都正确，则将与 PostgreSQL 数据库建立连接。

传递详细信息时，您可以使用 Shell 建议的默认服务器、数据库、端口和用户名。

使用 Python 建立连接

psycopg2 的 connection 类表示/处理连接实例。您可以使用 connect() 函数创建新的连接。它接受基本的连接参数，例如 dbname、user、password、host、port，并返回一个连接对象。使用此函数，您可以建立与 PostgreSQL 的连接。

示例

以下 Python 代码演示了如何连接到现有数据库。如果数据库不存在，则将创建它，最后返回一个数据库对象。PostgreSQL 的默认数据库名为 postrgre。因此，我们将其作为数据库名称提供。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("select version()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()
Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

输出

Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

Python PostgreSQL - 创建数据库

您可以使用 CREATE DATABASE 语句在 PostgreSQL 中创建数据库。您可以在 PostgreSQL Shell 提示符下执行此语句，并在命令后指定要创建的数据库的名称。

语法

以下是 CREATE DATABASE 语句的语法。

CREATE DATABASE dbname;

示例

以下语句在 PostgreSQL 中创建一个名为 testdb 的数据库。

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

您可以使用 \l 命令列出 PostgreSQL 中的数据库。如果您验证数据库列表，则可以找到新创建的数据库，如下所示：

postgres=# \l
                                           List of databases
Name       | Owner    | Encoding | Collate                    | Ctype       |
-----------+----------+----------+----------------------------+-------------+
mydb       | postgres | UTF8     | English_United States.1252 | ........... |
postgres   | postgres | UTF8     | English_United States.1252 | ........... |
template0  | postgres | UTF8     | English_United States.1252 | ........... |
template1  | postgres | UTF8     | English_United States.1252 | ........... |
testdb     | postgres | UTF8     | English_United States.1252 | ........... |
(5 rows)

您也可以使用 createdb 命令（CREATE DATABASE SQL 语句的包装器）从命令提示符在 PostgreSQL 中创建数据库。

C:\Program Files\PostgreSQL\11\bin> createdb -h localhost -p 5432 -U postgres sampledb
Password:

使用 Python 创建数据库

psycopg2 的 cursor 类提供了各种方法来执行各种 PostgreSQL 命令、获取记录和复制数据。您可以使用 Connection 类的 cursor() 方法创建游标对象。

此类的 execute() 方法接受 PostgreSQL 查询作为参数并执行它。

因此，要在 PostgreSQL 中创建数据库，请使用此方法执行 CREATE DATABASE 查询。

示例

以下 Python 示例在 PostgreSQL 数据库中创建了一个名为 mydb 的数据库。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing query to create a database
sql = '''CREATE database mydb''';

#Creating a database
cursor.execute(sql)
print("Database created successfully........")

#Closing the connection
conn.close()

输出

Database created successfully........

Python PostgreSQL - 创建表

您可以使用 CREATE TABLE 语句在 PostgreSQL 中的数据库中创建新表。在执行此操作时，您需要指定表名、列名及其数据类型。

语法

以下是 PostgreSQL 中 CREATE TABLE 语句的语法。

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

示例

以下示例在 PostgreSQL 中创建一个名为 CRICKETERS 的表。

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

您可以使用 \dt 命令获取 PostgreSQL 中数据库中的表列表。创建表后，如果您验证表列表，则可以在其中观察新创建的表，如下所示：

postgres=# \dt
            List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

同样，您可以使用 \d 获取创建表的描述，如下所示：

postgres=# \d cricketers
               Table "public.cricketers"
Column          | Type                   | Collation | Nullable | Default
----------------+------------------------+-----------+----------+---------
first_name      | character varying(255) |           |          |
last_name       | character varying(255) |           |          |
age             | integer                |           |          |
place_of_birth  | character varying(255) |           |          |
country         | character varying(255) |           |          |
postgres=#

使用 Python 创建表

要使用 Python 创建表，您需要使用 pyscopg2 的 Cursor 的 execute() 方法执行 CREATE TABLE 语句。

示例

以下 Python 示例创建一个名为 employee 的表。

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")
conn.commit()
#Closing the connection
conn.close()

输出

Table created successfully........

Python PostgreSQL - 插入数据

您可以使用 INSERT INTO 语句将记录插入 PostgreSQL 中的现有表中。在执行此操作时，您需要指定表名以及其中列的值。

语法

以下是 INSERT 语句的推荐语法：

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

其中，column1、column2、column3... 是表的列名，value1、value2、value3... 是您需要插入表中的值。

示例

假设我们已使用 CREATE TABLE 语句创建了一个名为 CRICKETERS 的表，如下所示：

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

以下 PostgreSQL 语句在上面创建的表中插入一行：

postgres=# insert into CRICKETERS (
   First_Name, Last_Name, Age, Place_Of_Birth, Country) 
   values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=#

使用 INSERT INTO 语句插入记录时，如果您跳过任何列名，则将插入记录，并在您跳过的列处留出空位。

postgres=# insert into CRICKETERS (First_Name, Last_Name, Country) 
   values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1

如果传递的值的顺序与表中各自的列名相同，则您也可以在不指定列名的情况下将记录插入表中。

postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1
postgres=#

将记录插入表后，您可以使用 SELECT 语句验证其内容，如下所示：

postgres=# SELECT * from CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      |     |                | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)

使用 Python 插入数据

psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行它。

因此，要使用 Python 在 PostgreSQL 中将数据插入表中：

• 导入 psycopg2 包。

• 使用 connect() 方法创建一个连接对象，将其用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过将 false 作为值设置为属性 autocommit 来关闭自动提交模式。

• psycopg2 库的 Connection 类的 cursor() 方法返回一个游标对象。使用此方法创建一个游标对象。

• 然后，通过将其作为参数传递给 execute() 方法来执行 INSERT 语句。

示例

以下 Python 程序在 PostgreSQL 数据库中创建一个名为 EMPLOYEE 的表，并使用 execute() 方法将记录插入其中。

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

输出

Records inserted........

Python PostgreSQL - 查询数据

您可以使用 SELECT 语句检索 PostgreSQL 中现有表的内容。在此语句中，您需要指定表名，它将以表格格式返回其内容，这称为结果集。

语法

以下是 PostgreSQL 中 SELECT 语句的语法：

SELECT column1, column2, columnN FROM table_name;

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下 SELECT 查询检索 CRICKETERS 表中 FIRST_NAME、LAST_NAME 和 COUNTRY 列的值。

postgres=# SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
first_name  | last_name  | country
------------+------------+-------------
Shikhar     | Dhawan     | India
Jonathan    | Trott      | SouthAfrica
Kumara      | Sangakkara | Srilanka
Virat       | Kohli      | India
Rohit       | Sharma     | India
(5 rows)

如果要检索每条记录的所有列，则需要将列名替换为 "*"，如下所示：

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)
postgres=#

使用 Python 检索数据

对任何数据库执行读取操作都意味着从数据库中获取一些有用的信息。您可以使用 psycopg2 提供的 fetch() 方法从 PostgreSQL 中获取数据。

Cursor 类提供三种方法，即 fetchall()、fetchmany() 和 fetchone()，其中：

• fetchall() 方法检索查询结果集中的所有行，并将它们作为元组列表返回。（如果我们在检索几行后执行此操作，它将返回其余行）。

• fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。

• fetchmany() 方法类似于 fetchone()，但它检索查询结果集中的下一组行，而不是单个行。

注意 - 结果集是在使用游标对象查询表时返回的对象。

示例

以下 Python 程序连接到 PostgreSQL 的名为 mydb 的数据库，并从名为 EMPLOYEE 的表中检索所有记录。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python PostgreSQL - Where 子句

在执行 SELECT、UPDATE 或 DELETE 操作时，您可以使用 WHERE 子句指定条件来过滤记录。该操作将对满足给定条件的记录执行。

语法

以下是 PostgreSQL 中 WHERE 子句的语法：

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

您可以使用比较或逻辑运算符指定 search_condition。例如 >、<、=、LIKE、NOT 等。以下示例将使此概念更加清晰。

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下 SELECT 语句检索年龄大于 35 的记录：

postgres=# SELECT * FROM CRICKETERS WHERE AGE > 35;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(2 rows)
postgres=#

使用 Python 的 WHERE 子句

要使用 Python 程序从表中获取特定记录，请执行带有 WHERE 子句的 SELECT 语句，并将其作为参数传递给 execute() 方法。

示例

以下 Python 示例演示了使用 Python 的 WHERE 命令。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'M', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

Python PostgreSQL - Order By

通常，如果您尝试从表中检索数据，您将按照插入它们的顺序获得记录。

使用 ORDER BY 子句，在检索表的记录时，您可以根据所需的列按升序或降序对结果记录进行排序。

语法

以下是 PostgreSQL 中 ORDER BY 子句的语法。

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下 SELECT 语句按年龄的升序检索 CRICKETERS 表的行：

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)es:

您可以使用多个列对表的记录进行排序。以下 SELECT 语句根据年龄和 FIRST_NAME 列对 CRICKETERS 表的记录进行排序。

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)

默认情况下，ORDER BY 子句按升序对表的记录进行排序。您可以使用 DESC 将结果排列为降序，如下所示：

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE DESC;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Shikhar     | Dhawan     | 33  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Virat       | Kohli      | 30  | Delhi          | India
(5 rows)

使用 python 的 ORDER BY 子句

要按特定顺序检索表的内容，请在游标对象上调用 execute() 方法，并将 SELECT 语句以及 ORDER BY 子句作为参数传递给它。

示例

在以下示例中，我们正在创建一个名为 Employee 的表，对其进行填充，并使用 ORDER BY 子句按其年龄的（升序）顺序检索其记录。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME, CONTACT) VALUES 
   (%s, %s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 26, 'M', 2000, 101), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102),
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103),
   ('Mac', 'Mohan', 26, 'M', 2000, 104)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

Python PostgreSQL - 更新表

您可以使用 UPDATE 语句修改 PostgreSQL 中现有表中现有记录的内容。要更新特定行，您需要与之一起使用 WHERE 子句。

语法

以下是 PostgreSQL 中 UPDATE 语句的语法：

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下语句修改了名为 Shikhar 的板球运动员的年龄：

postgres=# UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
UPDATE 1
postgres=#

如果您检索 FIRST_NAME 为 Shikhar 的记录，您会发现年龄值已更改为 45：

postgres=# SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
Shikhar     | Dhawan    | 45  | Delhi          | India
(1 row)
postgres=#

如果您未使用 WHERE 子句，则所有记录的值都将更新。以下 UPDATE 语句将 CRICKETERS 表中所有记录的年龄增加 1：

postgres=# UPDATE CRICKETERS SET AGE = AGE+1;
UPDATE 5

如果您使用 SELECT 命令检索表的内容，则可以看到更新后的值，如下所示：

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 39  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 42  | Matale         | Srilanka
Virat       | Kohli      | 31  | Delhi          | India
Rohit       | Sharma     | 33  | Nagpur         | India
Shikhar     | Dhawan     | 46  | Delhi          | India
(5 rows)

使用 Python 更新记录

psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行它。

因此，要使用 Python 在 PostgreSQL 中将数据插入表中：

• 导入 psycopg2 包。

• 使用 connect() 方法创建一个连接对象，将其用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过将 false 作为值设置为属性 autocommit 来关闭自动提交模式。

• psycopg2 库的 Connection 类的 cursor() 方法返回一个游标对象。使用此方法创建一个游标对象。

• 然后，通过将其作为参数传递给 execute() 方法来执行 UPDATE 语句。

示例

以下 Python 代码更新 Employee 表的内容并检索结果：

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Updating the records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'"
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]

Python PostgreSQL - 删除数据

您可以使用 PostgreSQL 数据库的 DELETE FROM 语句删除现有表中的记录。要删除特定记录，您需要与之一起使用 WHERE 子句。

语法

以下是 PostgreSQL 中 DELETE 查询的语法：

DELETE FROM table_name [WHERE Clause]

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下语句删除了姓氏为“Sangakkara”的板球运动员的记录。−

postgres=# DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
DELETE 1

如果您使用 SELECT 语句检索表的内容，您只会看到 4 条记录，因为我们删除了一条。

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+-------------
Jonathan    | Trott     | 39  | CapeTown       | SouthAfrica
Virat       | Kohli     | 31  | Delhi          | India
Rohit       | Sharma    | 33  | Nagpur         | India
Shikhar     | Dhawan    | 46  | Delhi          | India
(4 rows)

如果您在没有 WHERE 子句的情况下执行 DELETE FROM 语句，则指定表中的所有记录都将被删除。

postgres=# DELETE FROM CRICKETERS;
DELETE 4

由于您已删除所有记录，如果您尝试使用 SELECT 语句检索 CRICKETERS 表的内容，您将获得一个空的结果集，如下所示 −

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)

使用 Python 删除数据

psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行它。

因此，要使用 Python 在 PostgreSQL 中将数据插入表中：

• 导入 psycopg2 包。

• 使用 connect() 方法创建一个连接对象，将其用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数传递给它。

• 通过将 false 作为值设置为属性 autocommit 来关闭自动提交模式。

• psycopg2 库的 Connection 类的 cursor() 方法返回一个游标对象。使用此方法创建游标对象。

• 然后，通过将其作为参数传递给 execute() 方法来执行 UPDATE 语句。

示例

以下 Python 代码删除 EMPLOYEE 表中年龄值大于 25 的记录 −

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]
Contents of the table after delete operation:
[('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0)]

Python PostgreSQL - 删除表

您可以使用 DROP TABLE 语句从 PostgreSQL 数据库中删除表。

语法

以下是 PostgreSQL 中 DROP TABLE 语句的语法 −

DROP TABLE table_name;

示例

假设我们使用以下查询创建了两个名为 CRICKETERS 和 EMPLOYEES 的表 −

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#
postgres=# CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
CREATE TABLE
postgres=#

现在，如果您使用“\dt”命令验证表列表，您可以看到上面创建的表，如下所示 −

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
public  | employee   | table | postgres
(2 rows)
postgres=#

以下语句删除数据库中名为 Employee 的表 −

postgres=# DROP table employee;
DROP TABLE

由于您已删除 Employee 表，如果您再次检索表列表，您会发现其中只有一个表。

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

如果您尝试再次删除 Employee 表，由于您已经删除了它，您将收到一条错误消息，提示“表不存在”，如下所示 −

postgres=# DROP table employee;
ERROR: table "employee" does not exist
postgres=#

要解决此问题，您可以将 IF EXISTS 子句与 DELTE 语句一起使用。如果表存在，则删除该表，否则跳过 DLETE 操作。

postgres=# DROP table IF EXISTS employee;
NOTICE: table "employee" does not exist, skipping
DROP TABLE
postgres=#

使用 Python 删除整个表

您可以根据需要使用 DROP 语句删除表。但在删除任何现有表时，您需要非常小心，因为删除表后，丢失的数据将无法恢复。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

#Table dropped...

Python PostgreSQL - Limit

在执行 PostgreSQL SELECT 语句时，您可以使用 LIMIT 子句限制其结果中的记录数。

语法

以下是 PostgreSQL 中 LMIT 子句的语法 −

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

以下语句使用 LIMIT 子句检索 Cricketers 表的前 3 条记录 −

postgres=# SELECT * FROM CRICKETERS LIMIT 3;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(3 rows)

如果您想从特定记录（偏移量）开始获取记录，您可以使用 OFFSET 子句与 LIMIT 一起执行此操作。

postgres=# SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+----------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(3 rows)
postgres=#

使用 python 的 Limit 子句

以下 Python 示例检索名为 EMPLOYEE 的表的内容，并将结果中的记录数限制为 2 −

示例

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

Python PostgreSQL - Join

当您将数据分成两个表时，您可以使用联接从这两个表中获取组合的记录。

示例

假设我们创建了一个名为 CRICKETERS 的表，并在其中插入了 5 条记录，如下所示 −

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
postgres=# insert into CRICKETERS values (
   'Shikhar', 'Dhawan', 33, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica'
);
postgres=# insert into CRICKETERS values (
   'Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka'
);
postgres=# insert into CRICKETERS values (
   'Virat', 'Kohli', 30, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Rohit', 'Sharma', 32, 'Nagpur', 'India'
);

并且，如果我们创建了另一个名为 OdiStats 的表并在其中插入了 5 条记录，如下所示 −

postgres=# CREATE TABLE ODIStats (
   First_Name VARCHAR(255), Matches INT, Runs INT, AVG FLOAT, 
   Centuries INT, HalfCenturies INT
);
postgres=# insert into OdiStats values ('Shikhar', 133, 5518, 44.5, 17, 27);
postgres=# insert into OdiStats values ('Jonathan', 68, 2819, 51.25, 4, 22);
postgres=# insert into OdiStats values ('Kumara', 404, 14234, 41.99, 25, 93);
postgres=# insert into OdiStats values ('Virat', 239, 11520, 60.31, 43, 54);
postgres=# insert into OdiStats values ('Rohit', 218, 8686, 48.53, 24, 42);

以下语句检索这两个表中值的组合数据：

postgres=# SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
first_name  | last_name  | country     | matches | runs  | centuries | halfcenturies
------------+------------+-------------+---------+-------+-----------+---------------
Shikhar     | Dhawan     | India       | 133     | 5518  | 17        | 27
Jonathan    | Trott      | SouthAfrica | 68      | 2819  | 4         | 22
Kumara      | Sangakkara | Srilanka    | 404     | 14234 | 25        | 93
Virat       | Kohli      | India       | 239     | 11520 | 43        | 54
Rohit       | Sharma     | India       | 218     | 8686  | 24        | 42
(5 rows)
postgres=#

使用 Python 连接

当您将数据分成两个表时，您可以使用联接从这两个表中获取组合的记录。

示例

以下 Python 程序演示了 JOIN 子句的使用 −

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, '[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected] ', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Python PostgreSQL - 游标对象

psycopg 库的 Cursor 类提供方法，可以使用 Python 代码在数据库中执行 PostgreSQL 命令。

使用它的方法，您可以执行 SQL 语句、从结果集中获取数据、调用过程。

您可以使用 Connection 对象/类的 cursor() 方法创建 Cursor 对象。

示例

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

方法

以下是 Cursor 类/对象提供的各种方法。

属性

以下是 Cursor 类的属性：

Python SQLite - 简介

安装

SQLite3 可以使用 sqlite3 模块与 Python 集成，该模块由 Gerhard Haring 编写。它提供了一个符合 PEP 249 描述的 DB-API 2.0 规范的 SQL 接口。您无需单独安装此模块，因为它默认与 Python 2.5.x 及更高版本一起提供。

要使用 sqlite3 模块，您必须首先创建一个表示数据库的连接对象，然后您可以选择创建一个游标对象，这将帮助您执行所有 SQL 语句。

Python sqlite3 模块 API

以下是重要的 sqlite3 模块例程，它们足以满足您从 Python 程序中使用 SQLite 数据库的要求。如果您正在寻找更复杂的应用程序，则可以查看 Python sqlite3 模块的官方文档。

Python SQLite - 建立连接

要与 SQLite 建立连接，请打开命令提示符，浏览到您已安装 SQLite 的位置，然后只需执行命令sqlite3，如下所示 −

使用 Python 建立连接

您可以使用 SQLite3 python 模块与 SQLite2 数据库通信。为此，首先需要建立连接（创建连接对象）。

要使用 python 与 SQLite3 数据库建立连接，您需要 −

• 使用 import 语句导入 sqlite3 模块。

• connect() 方法接受您需要连接到的数据库的名称作为参数，并返回一个 Connection 对象。

示例

import sqlite3
conn = sqlite3.connect('example.db')

输出

print("Connection established ..........")

Python SQLite - 创建表

使用 SQLite CREATE TABLE 语句，您可以在数据库中创建表。

语法

以下是创建 SQLite 数据库中表的语法 −

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

示例

以下 SQLite 查询/语句在 SQLite 数据库中创建了一个名为CRICKETERS的表 −

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

让我们再创建一个名为 OdiStats 的表，描述 CRICKETERS 表中每个球员的一日板球统计数据。

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite

您可以使用.tables命令获取 SQLite 数据库中表的列表。创建表后，如果您验证表列表，您可以在其中看到新创建的表，如下所示 −

sqlite> . tables
CRICKETERS ODIStats
sqlite>

使用 Python 创建表

Cursor 对象包含执行查询和获取数据等的所有方法。connection 类的 cursor 方法返回一个游标对象。

因此，要使用 python 在 SQLite 数据库中创建表 −

• 使用 connect() 方法与数据库建立连接。

• 通过在上面创建的连接对象上调用 cursor() 方法来创建游标对象。

• 现在使用 Cursor 类的 execute() 方法执行 CREATE TABLE 语句。

示例

以下 Python 程序在 SQLite3 中创建了一个名为 Employee 的表 −

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

# Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Table created successfully........

Python SQLite - 插入数据

您可以使用 INSERT INTO 语句向 SQLite 的现有表中添加新行。在此，您需要指定表的名称、列名和值（与列名相同的顺序）。

语法

以下是 INSERT 语句的推荐语法：

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

其中，column1、column2、column3、.. 是表的列名，value1、value2、value3、.. 是您需要插入表中的值。

示例

假设我们已使用 CREATE TABLE 语句创建了一个名为 CRICKETERS 的表，如下所示：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

以下 PostgreSQL 语句在上面创建的表中插入一行。

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Age, Place_Of_Birth, Country) values
   ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>

在使用 INSERT INTO 语句插入记录时，如果您跳过任何列名，则此记录将被插入，在您跳过的列处留下空白。

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Country) values 
   ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>

如果传递的值的顺序与表中各自的列名相同，则您也可以在不指定列名的情况下将记录插入表中。

sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

将记录插入表后，您可以使用 SELECT 语句验证其内容，如下所示：

sqlite> select * from cricketers;
Shikhar  | Dhawan     | 33 | Delhi  | India
Jonathan | Trott      |    |        | SouthAfrica
Kumara   | Sangakkara | 41 | Matale | Srilanka
Virat    | Kohli      | 30 | Delhi  | India
Rohit    | Sharma     | 32 | Nagpur | India
sqlite>

使用 Python 插入数据

要向 SQLite 数据库中的现有表添加记录 −

• 导入 sqlite3 包。

• 使用 connect() 方法创建连接对象，并将数据库的名称作为参数传递给它。

• cursor()方法返回一个游标对象，您可以使用它与 SQLite3 通信。通过在（上面创建的）Connection 对象上调用 cursor() 对象来创建游标对象。

• 然后，在游标对象上调用 execute() 方法，并将 INSERT 语句作为参数传递给它。

示例

以下 python 示例将记录插入到名为 EMPLOYEE 的表中 −

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama Priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

输出

Records inserted........

Python SQLite - 查询数据

您可以使用 SELCT 查询从 SQLite 表中检索数据。此查询/语句以表格形式返回指定关系（表）的内容，并称为结果集。

语法

以下是 SQLite 中 SELECT 语句的语法 −

SELECT column1, column2, columnN FROM table_name;

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下 SELECT 查询检索 CRICKETERS 表中 FIRST_NAME、LAST_NAME 和 COUNTRY 列的值。

sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar  |Dhawan     |India
Jonathan |Trott      |SouthAfrica
Kumara   |Sangakkara |Srilanka
Virat    |Kohli      |India
Rohit    |Sharma     |India
sqlite>

正如您所观察到的，SQLite 数据库的 SELECT 语句仅返回指定表的记录。要获得格式化的输出，您需要在 SELECT 语句之前使用相应的命令设置header和mode，如下所示：

sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name Last_Name            Country
---------- -------------------- ----------
Shikhar    Dhawan               India
Jonathan   Trott                SouthAfric
Kumara     Sangakkara           Srilanka
Virat      Kohli                India
Rohit      Sharma               India
sqlite>

如果您想检索每条记录的所有列，则需要将列名替换为“*”，如下所示：

sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age        Place_Of_Birth Country
---------- ---------- ---------- -------------- ----------
Shikhar    Dhawan     33         Delhi          India
Jonathan   Trott      38         CapeTown       SouthAfric
Kumara     Sangakkara 41         Matale         Srilanka
Virat      Kohli      30         Delhi          India
Rohit      Sharma     32         Nagpur         India
sqlite>

在SQLite中，默认情况下，列的宽度为 10 个值，超过此宽度的值将被截断（观察上表中第 2 行的国家/地区列）。您可以使用.width命令在检索表内容之前将每列的宽度设置为所需的值，如下所示：

sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

使用 Python 检索数据

对任何数据库的读取操作都意味着从数据库中获取一些有用的信息。您可以使用 sqlite python 模块提供的 fetch() 方法从 MYSQL 中获取数据。

sqlite3.Cursor 类提供了三种方法，即 fetchall()、fetchmany() 和 fetchone()，其中：

• fetchall() 方法检索查询结果集中的所有行，并将它们作为元组列表返回。（如果我们在检索几行后执行此操作，它将返回剩余的行）。

• fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。

• fetchmany() 方法类似于 fetchone()，但它检索查询结果集中的下一组行，而不是单个行。

注意 - 结果集是在使用游标对象查询表时返回的对象。

示例

以下示例使用 SELECT 查询获取 EMPLOYEE 表的所有行，并从获得的结果集中首先使用 fetchone() 方法检索第一行，然后使用 fetchall() 方法检索剩余的行。

以下 Python 程序演示了如何从上面示例中创建的 COMPANY 表中获取和显示记录。

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

Python SQLite - Where 子句

如果您想获取、删除或更新 SQLite 中表中的特定行，则需要使用 where 子句指定条件来过滤表的行以进行操作。

例如，如果您的 SELECT 语句带有 where 子句，则只会检索满足指定条件的行。

语法

以下是 SQLite 中 WHERE 子句的语法：

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

您可以使用比较或逻辑运算符指定 search_condition。例如 >、<、=、LIKE、NOT 等。以下示例将使此概念更加清晰。

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下 SELECT 语句检索年龄大于 35 的记录：

sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

使用 Python 的 WHERE 子句

Cursor 对象/类包含执行查询和获取数据等的所有方法。连接类的 cursor 方法返回一个游标对象。

因此，要使用 python 在 SQLite 数据库中创建表 −

• 使用 connect() 方法与数据库建立连接。

• 通过在上面创建的连接对象上调用 cursor() 方法来创建游标对象。

• 现在使用 Cursor 类的 execute() 方法执行 CREATE TABLE 语句。

示例

以下示例创建一个名为 Employee 的表并填充它。然后使用 where 子句检索年龄值小于 23 的记录。

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Vinay', 'Battacharya', 20, 'M', 6000.0)]

Python SQLite - Order By

在使用 SELECT 查询获取数据时，您将按照插入它们的顺序获得记录。

您可以使用Order By子句按所需顺序（升序或降序）对结果进行排序。默认情况下，此子句按升序对结果进行排序，如果您需要按降序排列它们，则需要显式使用“DESC”。

语法

以下是 SQLite 中 ORDER BY 子句的语法。

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下 SELECT 语句按年龄的升序检索 CRICKETERS 表的行：

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

您可以使用多个列对表的记录进行排序。以下 SELECT 语句根据AGE和FIRST_NAME列对 CRICKETERS 表的记录进行排序。

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

默认情况下，ORDER BY子句按升序对表的记录进行排序，您可以使用 DESC 将结果排列为降序，如下所示：

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE DESC;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Jonathan   Trott      38   CapeTown   SouthAfrica
Shikhar    Dhawan     33   Delhi      India
Rohit      Sharma     32   Nagpur     India
Virat      Kohli      30   Delhi      India
sqlite>

使用 python 的 ORDER BY 子句

要按特定顺序检索表的内容，请在游标对象上调用 execute() 方法，并将 SELECT 语句以及 ORDER BY 子句作为参数传递给它。

示例

在以下示例中，我们正在创建一个名为 Employee 的表并填充它，并使用 ORDER BY 子句按其年龄的（升序）顺序检索其记录。

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Vinay', 'Battacharya', 20, 'M', 6000, None),
   ('Tripthi', 'Mishra', 24, 'F', 6000, None),
   ('Sharukh', 'Sheik', 25, 'M', 8300, None),
   ('Sarmista', 'Sharma', 26, 'F', 10000, None),
   ('Ramya', 'Rama priya', 27, 'F', 9000, None)]

Python SQLite - 更新表

对任何数据库的更新操作都意味着修改表中一个或多个已存在于数据库中的记录的值。您可以使用 UPDATE 语句更新 SQLite 中现有记录的值。

要更新特定行，您需要与之一起使用 WHERE 子句。

语法

以下是 SQLite 中 UPDATE 语句的语法：

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下语句修改了名为Shikhar的板球运动员的年龄：

sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>

如果您检索 FIRST_NAME 为 Shikhar 的记录，您会发现年龄值已更改为 45：

sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name  Age Place_Of_B  Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     45   Delhi      India
sqlite>

如果您没有使用 WHERE 子句，所有记录的值都将被更新。以下 UPDATE 语句将 CRICKETERS 表中所有记录的年龄增加 1：

sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>

如果您使用 SELECT 命令检索表的内容，则可以看到更新后的值，如下所示：

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Kumara     Sangakkara 42   Matale     Srilanka
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

使用 python 更新现有记录

要向 SQLite 数据库中的现有表添加记录 −

• 导入 sqlite3 包。

• 使用connect()方法创建连接对象，并将数据库名称作为参数传递给它。

• cursor()方法返回一个游标对象，您可以使用它与 SQLite3 通信。通过在（上面创建的）Connection 对象上调用 cursor() 对象来创建游标对象。

• 然后，通过将 UPDATE 语句作为参数传递给它，在游标对象上调用 execute() 方法。

示例

以下 Python 示例创建一个名为 EMPLOYEE 的表，向其中插入 5 条记录，并将所有男性员工的年龄增加 1：

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python SQLite - 删除数据

要从 SQLite 表中删除记录，您需要使用 DELETE FROM 语句。要删除特定记录，您需要与之一起使用 WHERE 子句。

要更新特定行，您需要与之一起使用 WHERE 子句。

语法

以下是 SQLite 中 DELETE 查询的语法：

DELETE FROM table_name [WHERE Clause]

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下语句删除姓氏为“Sangakkara”的板球运动员的记录。

sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>

如果您使用 SELECT 语句检索表的内容，您只会看到 4 条记录，因为我们删除了一条。

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

如果您在没有 WHERE 子句的情况下执行 DELETE FROM 语句，则将删除指定表中的所有记录。

sqlite> DELETE FROM CRICKETERS;
sqlite>

由于您已删除所有记录，如果您尝试使用 SELECT 语句检索 CRICKETERS 表的内容，您将获得一个空的结果集，如下所示 −

sqlite> SELECT * FROM CRICKETERS;
sqlite>

使用 Python 删除数据

要向 SQLite 数据库中的现有表添加记录 −

• 导入 sqlite3 包。

• 使用connect()方法创建连接对象，并将数据库名称作为参数传递给它。

• cursor()方法返回一个游标对象，您可以使用它与 SQLite3 通信。通过在（上面创建的）Connection 对象上调用 cursor() 对象来创建游标对象。

• 然后，通过将 DELETE 语句作为参数传递给它，在游标对象上调用 execute() 方法。

示例

以下 python 示例从 EMPLOYEE 表中删除年龄值大于 25 的记录。

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Contents of the table after delete operation
[('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Python SQLite - 删除表

您可以使用 DROP TABLE 语句删除整个表。您只需要指定要删除的表的名称。

语法

以下是 PostgreSQL 中 DROP TABLE 语句的语法 −

DROP TABLE table_name;

示例

假设我们使用以下查询创建了两个名为 CRICKETERS 和 EMPLOYEES 的表 −

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
sqlite>

现在，如果您使用.tables命令验证表列表，您可以在其中看到上面创建的表（列表），如下所示：

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

以下语句删除数据库中名为 Employee 的表 −

sqlite> DROP table employee;
sqlite>

由于您已删除 Employee 表，如果您再次检索表列表，您会发现其中只有一个表。

sqlite> .tables
CRICKETERS
sqlite>

如果您尝试再次删除 Employee 表，因为您已经删除了它，您将收到一个错误消息，提示“没有这样的表”，如下所示：

sqlite> DROP table employee;
Error: no such table: employee
sqlite>

要解决此问题，您可以将 IF EXISTS 子句与 DELTE 语句一起使用。如果表存在，则删除该表，否则跳过 DLETE 操作。

sqlite> DROP table IF EXISTS employee;
sqlite>

使用 Python 删除表

您可以随时使用 MYSQL 的 DROP 语句删除表，但在删除任何现有表时需要非常小心，因为删除表后数据将无法恢复。

示例

要使用 python 从 SQLite3 数据库中删除表，请在游标对象上调用execute()方法，并将 drop 语句作为参数传递给它。

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

Table dropped...

Python SQLite - Limit

在获取记录时，如果您想将它们限制在特定数量，则可以使用 SQLite 的 LIMIT 子句来实现。

语法

以下是 SQLite 中 LIMIT 子句的语法：

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

如果我们使用 INSERT 语句向其中插入了 5 条记录，如下所示：

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

以下语句使用 LIMIT 子句检索 Cricketers 表的前 3 条记录 −

sqlite> SELECT * FROM CRICKETERS LIMIT 3;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

如果您需要从第 n 条记录（而不是第 1 条）开始限制记录，则可以使用 OFFSET 以及 LIMIT 来实现。

sqlite> SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

使用 Python 的 LIMIT 子句

如果您通过将 SELECT 查询以及 LIMIT 子句作为参数传递给它，在游标对象上调用 execute() 方法，则可以检索所需数量的记录。

示例

以下 python 示例使用 LIMIT 子句检索 EMPLOYEE 表的前两条记录。

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0)]

Python SQLite - Join

当您将数据分成两个表时，您可以使用联接从这两个表中获取组合的记录。

示例

假设我们已使用以下查询创建了一个名为 CRICKETERS 的表：

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

让我们再创建一个名为 OdiStats 的表，描述 CRICKETERS 表中每个球员的一日板球统计数据。

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite>

以下语句检索这两个表中值的组合数据：

sqlite> SELECT
   Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
   OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
   from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name Last_Name    Country  Matches    Runs          Centuries  HalfCenturies
---------- ----------   -------  ---------- ------------- ---------- ----------
Shikhar    Dhawan       Indi     133        5518          17         27
Jonathan   Trott        Sout     68         2819          4          22
Kumara     Sangakkara   Sril     404        14234         25         93
Virat      Kohli        Indi     239        11520         43         54
Rohit      Sharma       Indi     218        8686          24         42
sqlite>

使用 python 的 Join 子句

以下 SQLite 示例演示了使用 python 的 JOIN 子句：

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

输出

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Python SQLite - 游标对象

sqlite3.Cursor 类是一个实例，您可以使用它来调用执行 SQLite 语句、从查询结果集中获取数据的方法。您可以使用 Connection 对象/类的 cursor() 方法创建Cursor对象。

示例

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

方法

以下是 Cursor 类/对象提供的各种方法。

属性

以下是 Cursor 类的属性：

Python MongoDB - 简介

Pymongo 是一个 python 发行版，它提供用于处理 MongoDB 的工具，它是从 python 与 MongoDB 数据库通信的首选方法。

安装

要安装 pymongo，首先确保您已正确安装 python3（以及 PIP）和 MongoDB。然后执行以下命令。

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

验证

安装 pymongo 后，打开一个新的文本文档，将以下行粘贴到其中，并将其另存为 test.py。

import pymongo

如果您已正确安装 pymongo，如果您按如下所示执行 test.py，则不应该出现任何问题。

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

Python MongoDB - 创建数据库

与其他数据库不同，MongoDB 没有提供单独的命令来创建数据库。

通常，use 命令用于选择/切换到特定的数据库。此命令首先验证我们指定的数据库是否存在，如果存在，则连接到它。如果我们使用 use 命令指定的数据库不存在，则将创建一个新数据库。

因此，您可以使用Use命令在 MongoDB 中创建数据库。

语法

use DATABASE语句的基本语法如下：

use DATABASE_NAME

示例

以下命令创建一个名为 mydb 的数据库。

>use mydb
switched to db mydb

您可以使用 db 命令验证您的创建，这将显示当前数据库。

>db
mydb

使用 python 创建数据库

要使用 pymongo 连接到 MongoDB，您需要导入并创建一个 MongoClient，然后您可以直接访问您需要在属性 passion 中创建的数据库。

示例

以下示例在 MangoDB 中创建一个数据库。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

输出

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

您还可以在创建 MongoClient 时指定端口和主机名，并以字典样式访问数据库。

示例

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

输出

Database created........

Python MongoDB - 创建集合

MongoDB 中的集合保存一组文档，类似于关系数据库中的表。

您可以使用createCollection()方法创建集合。此方法接受一个表示要创建的集合名称的字符串值和一个选项（可选）参数。

使用它，您可以指定以下内容：

• 集合的大小。
• 限制集合中允许的最大文档数。
• 我们创建的集合是否应该是限制集合（固定大小的集合）。
• 我们创建的集合是否应该是自动索引的。

语法

以下是创建 MongoDB 中集合的语法。

db.createCollection("CollectionName")

示例

以下方法创建一个名为 ExampleCollection 的集合。

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

类似地，以下是一个使用 createCollection() 方法的选项创建集合的查询。

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

使用 python 创建集合

以下 python 示例连接到 MongoDB 中的数据库（mydb），并在其中创建一个集合。

示例

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

输出

Collection created........

Python MongoDB - 插入文档

您可以使用insert()方法将文档存储到 MongoDB 中。此方法接受 JSON 文档作为参数。

语法

以下是 insert 方法的语法。

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

示例

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

类似地，您还可以使用insert()方法插入多个文档。

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = 
[
   {
      "_id": "1001", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   }, 
   {
      "_id": "1002", 
      "name" : "Rahim", 
      "age" : 27, 
      "city" : "Bangalore" 
   }, 
   {
      "_id": "1003", 
      "name" : "Robert", 
      "age" : 28, 
      "city" : "Mumbai" 
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

使用 python 创建集合

Pymongo 提供了一个名为 insert_one() 的方法来在 MangoDB 中插入文档。对于此方法，我们需要以字典格式传递文档。

示例

以下示例在名为 example 的集合中插入一个文档。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

输出

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

要使用 pymongo 将多个文档插入 MongoDB，您需要调用 insert_many() 方法。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = 
[
   {
      "_id": "101", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   },
   {
      "_id": "102", 
      "name": "Rahim", 
      "age": "27", 
      "city": "Bangalore"
   },
   {
      "_id": "103", 
      "name": "Robert", 
      "age": "28", 
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

输出

Data inserted ......
['101', '102', '103']

Python MongoDB - 查找

您可以使用find()方法读取/检索存储在 MongoDB 中的文档。此方法以非结构化的方式检索并显示 MongoDB 中的所有文档。

语法

以下是find()方法的语法。

>db.CollectionName.find()

示例

假设我们使用以下查询将 3 个文档插入到名为 testDB 的数据库中的名为 sample 的集合中：

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

您可以使用 find() 方法检索插入的文档，如下所示：

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

您还可以使用 findOne() 方法检索集合中的第一个文档，如下所示：

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

使用 python 检索数据（find）

pymongo 的find_One()方法用于根据您的查询检索单个文档，如果没有匹配项，此方法将不返回任何内容，如果您不使用任何查询，它将返回集合的第一个文档。

当您只需要检索一个结果文档或确定您的查询仅返回一个文档时，此方法非常方便。

示例

以下 python 示例检索集合的第一个文档：

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

输出

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

要在一个查询中获取多个文档（find 方法的单个调用），您可以使用 pymongo 的find()方法。如果没有传递任何查询，这将返回集合的所有文档，如果您已将查询传递给此方法，它将返回所有匹配的文档。

示例

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

输出

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python MongoDB - 查询

在使用find()方法检索时，您可以使用查询对象过滤文档。您可以将指定所需文档条件的查询作为参数传递给此方法。

运算符

以下是 MongoDB 中查询中使用的运算符列表。

示例 1

以下示例检索集合中名为 sarmista 的文档。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

输出

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

示例 2

以下示例检索集合中年龄值大于 26 的文档。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

输出

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python MongoDB - 排序

在检索集合的内容时，您可以使用sort()方法对它们进行排序并按升序或降序排列。

对于此方法，您可以传递字段和排序顺序，该顺序为 1 或 -1。其中，1 表示升序，-1 表示降序。

语法

以下是sort()方法的语法。

>db.COLLECTION_NAME.find().sort({KEY:1})

示例

假设我们已经创建了一个集合并在其中插入了5个文档，如下所示：

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

以下代码检索集合中所有根据年龄按升序排序的文档。

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

使用Python对文档进行排序

为了按升序或降序对查询结果进行排序，pymongo提供了sort()方法。在此方法中，传递一个数字值，表示您需要结果中的文档数量。

默认情况下，此方法根据指定的字段按升序对文档进行排序。如果您需要按降序排序，请将-1与字段名称一起传递：

coll.find().sort("age",-1)

示例

以下示例检索集合中所有根据年龄值按升序排列的文档：

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

输出

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Python MongoDB - 删除文档

您可以使用MongoDB的remove()方法删除集合中的文档。此方法接受两个可选参数：

• 删除条件，指定删除文档的条件。

• 只有一个，如果您将true或1作为第二个参数传递，则只会删除一个文档。

语法

以下是remove()方法的语法：

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

示例

假设我们已经创建了一个集合并在其中插入了5个文档，如下所示：

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

以下查询删除集合中名称值为Sarmista的文档。

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

如果您调用remove()方法而不传递删除条件，则集合中的所有文档都将被删除。

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

使用Python删除文档

要从MangoDB的集合中删除文档，您可以使用delete_one()和delete_many()方法从集合中删除文档。

这些方法接受一个查询对象，指定删除文档的条件。

delete_one()方法删除单个文档（如果匹配）。如果未指定查询，则此方法将删除集合中的第一个文档。

示例

以下Python示例删除集合中id值为1006的文档。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

输出

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

类似地，pymongo的delete_many()方法删除满足指定条件的所有文档。

示例

以下示例删除集合中所有年龄值大于26的文档：

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

输出

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

如果您调用delete_many()方法而不传递任何查询，则此方法将删除集合中的所有文档。

coll.delete_many({})

Python MongoDB - 删除集合

您可以使用MongoDB的drop()方法删除集合。

语法

以下是drop()方法的语法：

db.COLLECTION_NAME.drop()

示例

以下示例删除名为sample的集合：

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

使用Python删除集合

您可以通过调用drop()方法删除当前数据库中的集合。

示例

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

输出

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

Python MongoDB - 更新

您可以使用update()方法或save()方法更新现有文档的内容。

update方法修改现有文档，而save方法用新文档替换现有文档。

语法

以下是MangoDB的update()和save()方法的语法：

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

示例

假设我们在数据库中创建了一个集合并在其中插入了3条记录，如下所示：

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

以下方法更新id为1002的文档的城市值。

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

类似地，您可以使用save()方法保存具有相同id的新数据来替换文档。

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

使用Python更新文档

类似于检索单个文档的find_one()方法，pymongo的update_one()方法更新单个文档。

此方法接受一个查询，指定要更新的文档和更新操作。

示例

以下Python示例更新集合中某个文档的location值。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

输出

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

类似地，pymongo的update_many()方法更新满足指定条件的所有文档。

示例

以下示例更新集合中所有文档的location值（空条件）：

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

输出

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

Python MongoDB - Limit

在检索集合内容时，您可以使用limit()方法限制结果中的文档数量。此方法接受一个数字值，表示您希望结果中包含的文档数量。

语法

以下是limit()方法的语法：

>db.COLLECTION_NAME.find().limit(NUMBER)

示例

假设我们已经创建了一个集合并在其中插入了5个文档，如下所示：

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

以下代码检索集合中的前3个文档。

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

使用Python限制文档

为了将查询结果限制为特定数量的文档，pymongo提供了limit()方法。在此方法中，传递一个数字值，表示您需要结果中的文档数量。

示例

以下示例检索集合中的前三个文档。

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

输出

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}