Python Data Access 简明教程
Python MySQL - Introduction
Python 数据库接口的 Python 标准是 Python DB-API。大多数 Python 数据库接口都遵守此标准。
您可以为您的应用程序选择合适的数据库。Python Database API 支持范围广泛的数据库服务器，例如−
-
GadFly
-
mSQL
-
MySQL
-
PostgreSQL
-
Microsoft SQL Server 2000
-
Informix
-
Interbase
-
Oracle
-
Sybase
以下是可用的 Python 数据库接口列表： Python Database Interfaces and APIs 。您必须为每个要访问的数据库下载一个单独的 DB API 模块。例如，如果您需要访问 Oracle 数据库和 MySQL 数据库，则必须下载 Oracle 和 MySQL 数据库模块。
What is mysql-connector-python?
MySQL Python/Connector 是一个接口，用于从 Python 连接到 MySQL 数据库服务器。它实现了 Python Database API，并建立在 MySQL 之上。
How do I Install 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 外壳并创建一个名为 Python_MySQL 的文件夹（您打算在其中安装 Python-MySQL 连接器），如下所示−
>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQLVerify PIP
PIP 是 Python 中的一个包管理器，使用 PIP 可以安装 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.6Installing 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 connect，如下所示：
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.0Installing python from scratch
简单来说，如果你需要从头开始安装 Python。请访问 Python Home Page 。
点击 Downloads 按钮，你将被重定向到下载页面，该页面提供各种平台的最新版 Python 链接，选择一个并下载。
例如，我们下载了 python-3.7.4.exe（适用于 Windows）。双击下载的 .exe 文件，开始安装过程。
选中“将 Python 3.7 添加到路径”选项并继续安装。完成此过程后，python 将安装在你的系统中。
Python MySQL - Database Connection
要连接到 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
ByeEstablishing connection with MySQL using python
在使用 Python 连接到 MySQL 数据库之前，假设：
-
我们已经创建了一个名为 mydb 的数据库。
-
我们已经使用 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME 列创建了一个 EMPLOYEE 表。
-
我们用于连接到 MySQL 的认证信息是用户名：root，密码： password 。
你可以使用 connect() 构造函数来建立连接。这接受用户名、密码、主机和你需要连接到的数据库名称（可选），并返回 MySQLConnection 类的对象。
Example
以下是连接到 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()Output
在执行此脚本后，将生成以下输出：
D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)你还可以通过将认证信息（用户名、密码、主机名和数据库名称）传递给 connection.MySQLConnection() 来建立连接，如下所示：
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 查询创建一个数据库。
Example
以下语句在 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)Creating a database in MySQL using python
在与 MySQL 建立连接后，你要在其中处理数据就需要连接到一个数据库。你可以连接到现有的数据库或创建你自己的数据库。
你要创建或删除 MySQL 数据库，需要具有特殊权限。因此，如果你可以访问 root 用户，则你可以创建任何数据库。
Example
以下示例建立与 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()Python MySQL - Create Table
CREATE TABLE 语句用于在 MySQL 数据库中创建表。在这里，你需要指定表的名称以及每个列的定义（名称和数据类型）。
Syntax
下面是创建 MySQL 表的语法：
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);Example
以下查询在 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)Creating a table in MySQL using python
名为 execute() （在游标对象上调用）的方法接受两个变量：
-
一个字符串值，表示要执行的查询。
-
可选的 args 参数，可以是元组、列表或字典，表示查询的参数（占位符的值）。
它返回一个整数值，表示受查询影响的行数。
一旦建立数据库连接，就可以通过将 CREATE TABLE 查询传递给 execute() 方法来创建表。
简而言之，要使用 python 7minus 创建表；
-
Import mysql.connector package.
-
使用 mysql.connector.connect() 方法创建一个连接对象，通过将用户名、密码、主机（可选，默认值：localhost）和数据库（可选）作为参数传递给该对象。
-
通过对上面创建的连接对象调用 cursor() 方法创建一个游标对象。
-
然后，通过将其作为参数传递给 execute() 方法来执行 CREATE TABLE 语句。
Example
以下示例在 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 Data
可以使用 INSERT INTO 语句向现有的 MySQL 表中添加新行。在这里，你需要指定表名、列名和值（与列名顺序相同）。
Syntax
以下是 MySQL 的 INSERT INTO 语句的语法。
INSERT INTO TABLE_NAME (column1, column2,column3,...columnN)
VALUES (value1, value2, value3,...valueN);Example
以下查询将记录插入名为 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);Inserting data in MySQL table using python
方法 execute() （在光标对象上调用）接受查询作为参数并执行给定的查询。要插入数据，需要将 MySQL INSERT 语句作为参数传递给它。
cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")使用 Python 向 MySQL 中的表插入数据：
-
import mysql.connector package.
-
使用 mysql.connector.connect() 方法创建一个连接对象，通过将用户名、密码、主机（可选，默认值：localhost）和数据库（可选）作为参数传递给该对象。
-
通过调用上述创建的连接对象中的 cursor() 方法来创建光标对象
-
然后，通过将其作为参数传递给 execute() 方法来执行 INSERT 语句。
Example
以下示例执行 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()Inserting values dynamically
您还可以使用 MySQL INSERT 查询中的值代替 “%s”，并将值作为列表传递给它们，如下所示 -
cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""",
('Ramya', 'Ramapriya', 25, 'F', 5000))Example
以下示例动态地在 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()Python MySQL - Select Data
您可以使用 SELECT 查询从 MySQL 中的表中检索/获取数据。此查询/语句以表格形式返回指定表的内容，并且称为结果集。
Example
假设我们在 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)Reading data from a MYSQL table using Python
对任何数据库的 READ 操作意味着从数据库获取一些有用的信息。您可以使用 mysql-connector-python 提供的 fetch() 方法从 MYSQL 提取数据。
cursor.MySQLCursor 类提供了三个方法，分别是 fetchall(), fetchmany() 和 fetchone() ，其中：
-
fetchall() 方法检索查询结果集中的所有行，并将其作为元组列表返回。（如果我们在检索几行后执行此操作，它将返回剩余的行。）
-
fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。
-
fetchmany() 方法类似于 fetchone()，但它检索结果集中下一组行，而不是单行。
Note - 结果集是在使用光标对象查询表格时返回的对象。
rowcount − 这是只读属性，并返回受 execute() 方法影响的列数。
Example
下面的示例使用 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()Output
('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]以下示例使用 fetchmany() 方法检索 EMPLOYEE 表的前两行。
Example
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()Python MySQL - Where Clause
如果您想获取 MySQL 表中的特定行，删除或更新这些行，您需要使用 where 从句指定条件以筛选表的行进行操作。
例如，如果您有带 where 从句的 SELECT 语句，则只有满足指定条件的行才会被检索。
Example
假设我们在 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)WHERE clause using python
从表中使用 python 程序获取特定记录 -
-
import mysql.connector package.
-
使用 mysql.connector.connect() 方法创建一个连接对象，通过将用户名、密码、主机（可选，默认值：localhost）和数据库（可选）作为参数传递给该对象。
-
通过对上面创建的连接对象调用 cursor() 方法创建一个游标对象。
-
然后，执行带 WHERE 从句的 SELECT 语句，方法是将其作为参数传递给 execute() 方法。
Example
以下示例创建一个名为 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()Python MySQL - Order By
在使用 SELECT 查询获取数据时， يمكنك使用 OrderBy 子句以所需的順序（升序或降序）对结果进行排序。默认情况下，此子句按升序对结果进行排序，如果你需要按降序排列结果，则需要明确使用“DESC”。
Syntax
以下是 SELECT column-list 的语法
FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:Example
假设我们在 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)ORDER BY clause using python
要按特定顺序检索表的某个内容，调用游标对象上的 execute() 方法，并将 SELECT 语句和 ORDER BY 子句作为参数传递给它。
Example
在以下示例中，我们使用 ORDER BY 子句创建了一个名为 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()
#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()Output
[('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 子句按降序从表中检索数据。
Example
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()Python MySQL - Update Table
任何数据库上的 UPDATE 操作都会更新一个或多个记录，这些记录已在数据库中可用。您可以使用 UPDATE 语句更新 MySQL 中现有记录的值。要更新特定行，您需要使用 WHERE 子句。
Syntax
以下是 MySQL 中 UPDATE 语句的语法：
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];您可以使用 AND 或 OR 运算符组合 N 个条件。
Example
假设我们在 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)Updating the contents of a table using Python
若要使用 Python 更新 MySQL 表中的记录：
-
import mysql.connector package.
-
使用 mysql.connector.connect() 方法创建一个连接对象，通过将用户名、密码、主机（可选，默认值：localhost）和数据库（可选）作为参数传递给该对象。
-
通过对上面创建的连接对象调用 cursor() 方法创建一个游标对象。
-
然后，通过将 UPDATE 语句作为参数传递到 execute() 方法来执行它。
Example
以下示例将所有男性的年龄增加 1 岁。
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()Python MySQL - Delete Data
要从 MySQL 表格中删除记录，需要使用 DELETE FROM 语句。要移除特定记录，需要同时使用 WHERE 子句。
Example
假设我们在 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)Removing records of a table using python
当需要从数据库删除某些记录时，需要 DELETE 操作。
要删除表格中的记录：
-
import mysql.connector package.
-
使用 mysql.connector.connect() 方法创建一个连接对象，通过将用户名、密码、主机（可选，默认值：localhost）和数据库（可选）作为参数传递给该对象。
-
通过对上面创建的连接对象调用 cursor() 方法创建一个游标对象。
-
然后，通过将 DELETE 语句作为参数传递给 execute() 方法执行该语句。
Example
以下程序删除了 EMPLOYEE 中 AGE 超过 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()Output
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
您可以使用 DROP TABLE 语句删除整个表。您只需指定需要删除的表的名称即可。
Example
在删除表之前，请使用 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)Removing a table using python
您可以根据需要使用 MYSQL 的 DROP 语句删除表，但您在删除任何现有表时需要非常小心，因为删除表后丢失的数据将无法恢复。
要使用 python 从 MYSQL 数据库中删除表，请在游标对象上调用 execute() 方法，并将 drop 语句作为参数传递给它。
Example
以下表从数据库中删除名为 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()Output
List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]Drop table only if exists
如果您尝试删除数据库中不存在的表，则会出现错误，例如：
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()Python MySQL - Limit
在获取记录时，如果您想按特定数量对它们进行限制，可以使用 MYSQL 的 LIMIT 子句来实现。
Example
假设我们在 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)Limit clause using python
如果您通过将 SELECT 查询与 LIMIT 子句一起传递给游标对象，来调用 execute() 方法，您可以检索所需数量的记录。
要使用 python 从 MYSQL 数据库中删除表，请在游标对象上调用 execute() 方法，并将 drop 语句作为参数传递给它。
Example
下面的 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()LIMIT with OFFSET
如果你需要从第 n 个记录开始限制记录（不是第一个），你可以使用 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()Python MySQL - Join
当你在两张表中划分数据时，你可以使用连接从这两张表中获取组合记录。
Example
假设我们创建了一个名为 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, 'Krishna@mymail.com', 'Hyderabad'),
(102, 'Raja@mymail.com', 'Vishakhapatnam'),
(103, 'Krishna@mymail.com', 'Pune'),
(104, 'Raja@mymail.com', '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 | Krishna@mymail.com | NULL | Hyderabad |
| Vinay | Bhattacharya | 20 | M | 6000 | 102 | 102 | Raja@mymail.com | NULL | Vishakhapatnam |
| Sharukh | Sheik | 25 | M | 8300 | 103 | 103 | Krishna@mymail.com | NULL | Pune |
| Sarmista | Sharma | 26 | F | 10000 | 104 | 104 | Raja@mymail.com | NULL | Mumbai |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)MYSQL JOIN using python
下面的示例从以上两个表中检索数据，这两个表通过 EMPLOYEE 表的联系方式列和 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()Output
[('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, 'Krishna@mymail.com', 9848022338, 'Hyderabad'),
('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, 'Raja@mymail.com', 9848022339, 'Vishakhapatnam'),
('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, 'Krishna@mymail.com', 9848022337, 'Pune'),
('Mac', 'Mohan', 26, 'M', 2000, 104, 104, 'Raja@mymail.com', 9848022330, 'Mumbai')]Python MySQL - Cursor Object
mysql-connector-python（和类似的库）的 MySQLCursor 用于执行语句以与 MySQL 数据库通信。
使用它的方法，您可以执行 SQL 语句、从结果集中获取数据、调用过程。
你可以使用 Connection 对象/类的 cursor() 方法来创建 Cursor 对象。
Example
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()Methods
以下是 Cursor 类/对象提供的各种方法。
Sr.No |
Method & Description |
1 |
callproc() 此方法用于调用现有程序 MySQL 数据库。 |
2 |
close() 该方法用于关闭当前游标对象。 |
3 |
Info() 此方法提供有关上次查询的信息。 |
4 |
executemany() 该方法接受一个列表系列的参数列表。准备一个 MySQL 查询，并用所有参数执行该查询。 |
5 |
execute() 该方法接受一个 MySQL 查询作为参数，并执行给定的查询。 |
6 |
fetchall() 该方法检索查询的结果集中的所有行，并以元组列表的形式返回它们。（如果在检索几行后执行此操作，它将返回剩余的行） |
7 |
fetchone() 该方法提取查询结果中的下一行，并以元组形式返回该行。 |
8 |
fetchmany() 该方法类似于 fetchone()，但它检索查询结果集中下一组行，而不是单行。 |
9 |
etchwarnings() 此方法返回最后执行的查询生成的警告。 |
Python PostgreSQL - Introduction
Installation
PostgreSQL 是一个功能强大的开源对象关系数据库系统。它拥有超过 15 年的积极开发阶段，并拥有经过验证的架构，使其享有很高的可靠性、数据完整性和正确性声誉。
要使用 Python 与 PostgreSQL 进行通信，您需要安装 psycopg，一个为 python 编程提供的适配器，它的当前版本是 psycog2 。
psycopg2 的编写目标是体积小、速度快且稳定。它在 PIP（python 的包管理器）中可用。
Installing Psycog2 using PIP
首先，确保系统中正确安装了 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.3Python PostgreSQL - Database Connection
PostgreSQL 提供了自己的 shell 来执行查询。要建立与 PostgreSQL 数据库的连接，请确保已将其正确安装在您的系统中。打开 PostgreSQL shell 提示符并传递服务器、数据库、用户名和密码等详细信息。如果您提供的详细信息全部正确，则与 PostgreSQL 数据库建立的连接。
在传递详细信息时，您可以使用 shell 建议的默认服务器、数据库、端口和用户名。
Establishing connection using python
psycopg2 的连接类表示/处理连接的实例。您可以使用 connect() 函数创建新连接。此函数接受基本连接参数，例如 dbname、user、password、host、port，并返回连接对象。使用此函数，您可以与 PostgreSQL 建立连接。
Example
以下 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',
)Python PostgreSQL - Create Database
你可以使用 CREATE DATABASE 语句在 PostgreSQL 中创建一个数据库。你可以通过在命令后指定要创建的数据库的名称，在 PostgreSQL shell 提示符中执行此语句。
Example
以下语句在 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:Creating a database using python
psycopg2 的游标类提供了各种方法来执行各种 PostgreSQL 命令、获取记录和复制数据。你可以使用 Connection 类的 cursor() 方法创建一个游标对象。
此类的 execute() 方法接受 PostgreSQL 查询作为参数并执行它。
因此，要在 PostgreSQL 中创建一个数据库，请使用此方法执行 CREATE DATABASE 查询。
Example
以下 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()Python PostgreSQL - Create Table
可以使用 CREATE TABLE 语句在 PostgreSQL 中创建一个新表。在执行此操作时，您需要指定表名、列名及其数据类型。
Syntax
以下是 PostgreSQL 中 CREATE TABLE 语句的语法。
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);Example
以下示例在 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=#Creating a table using python
要使用 Python 创建表，您需要使用 pyscopg2 的光标的 execute() 方法来执行 CREATE TABLE 语句。
Example
以下 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()Python PostgreSQL - Insert Data
你可以使用 INSERT INTO 语句将记录插入到 PostgreSQL 中现有的表中。执行此操作时，你需要指定表的名称以及其中的列值。
Syntax
以下是 INSERT 语句的建议语法 -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);其中，column1、column2、column3 等是表的列名称，value1、value2、value3 等是你需要插入到表中的值。
Example
假设我们使用 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)Inserting data using python
psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行该查询。
因此，要使用 python 将数据插入到 PostgreSQL 中的表中 -
-
Import psycopg2 package.
-
使用 connect() 方法创建连接对象，方法是向其传递用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数。
-
通过将 false 设置为属性 autocommit 的值来关闭自动提交模式。
-
psycopg2 库的 Connection 类的 cursor() 方法返回一个游标对象。使用此方法创建一个游标对象。
-
然后，通过将 INSERT 语句作为参数传递给 execute() 方法来执行它/它们。
Example
以下 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()Python PostgreSQL - Select Data
你可以使用 SELECT 语句来检索 PostgreSQL 中现有表的内容。在此语句中，你需要指定表的名称，它以表格形式返回其内容，这就是所谓的结果集。
Example
假设我们使用以下查询创建了一个名为 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=#Retrieving data using python
对任何数据库的读取操作意味着从数据库中获取一些有用的信息。你可以使用 psycopg2 提供的 fetch() 方法从 PostgreSQL 中获取数据。
游标类提供了三种方法，即 fetchall()、fetchmany() 和 fetchone()，其中：
-
fetchall() 方法检索查询结果集中的所有行，并以元组列表的形式返回它们。（如果我们在检索几行后执行此操作，它会返回其余行）。
-
fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。
-
fetchmany() 方法类似于 fetchone()，但是它检索结果集中的下一组行，而不是单行。
Note - 结果集是在使用光标对象查询表格时返回的对象。
Example
以下 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()Python PostgreSQL - Where Clause
在执行SELECT、UPDATE或DELETE操作时，可以使用WHERE子句指定条件以筛选记录。该操作将对满足给定条件的记录执行。
Syntax
以下是PostgreSQL中WHERE子句的语法 −
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]您可以使用比较或逻辑运算符（如>、<、=、LIKE、NOT等）指定search_condition。以下示例将阐明此概念。
Example
假设我们使用以下查询创建了一个名为 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=#Where clause using python
要使用python程序从表中获取特定记录，请使用WHERE子句执行SELECT语句，通过将其作为参数传递给 execute() 方法。
Example
以下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()Python PostgreSQL - Order By
通常，如果你尝试从表中检索数据，你将按照插入数据的顺序获取记录。
使用 ORDER BY 子句，在检索表记录时，你可以根据所需的列以升序或降序对结果记录进行排序。
Syntax
以下是 PostgreSQL 中 ORDER BY 子句的语法。
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Example
假设我们使用以下查询创建了一个名为 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选择语句检索 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 语句根据列 age 和 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)ORDER BY clause using python
要以特定顺序检索表的全表，请对光标对象调用 execute() 方法，并将 SELECT 语句连同 ORDER BY 子句作为参数传递给它。
Example
在下面的示例中，我们使用 ORDER BY 子句创建了一个名为 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()
#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()Python PostgreSQL - Update Table
您可以使用 UPDATE 语句修改 PostgreSQL 中现有表记录的内容。要更新特定行，您需要同时使用 WHERE 子句。
Syntax
以下是 PostgreSQL 中 UPDATE 语句的语法：
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Example
假设我们使用以下查询创建了一个名为 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 的记录，您会发现其 age 值已更改为 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)Updating records using python
psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行该查询。
因此，要使用 python 将数据插入到 PostgreSQL 中的表中 -
-
Import psycopg2 package.
-
使用 connect() 方法创建连接对象，方法是向其传递用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数。
-
通过将 false 设置为属性 autocommit 的值来关闭自动提交模式。
-
psycopg2 库的 Connection 类的 cursor() 方法返回一个游标对象。使用此方法创建一个游标对象。
-
然后，通过将 UPDATE 语句作为参数传递给 execute() 方法来执行它。
Example
以下 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()Output
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 - Delete Data
您可以使用PostgreSQL数据库中的 DELETE FROM 语句删除现有表中的记录。要删除特定记录，您需要与WHERE子句一起使用它。
Example
假设我们使用以下查询创建了一个名为 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)Deleting data using python
psycopg2 的 cursor 类提供了一个名为 execute() 的方法。此方法接受查询作为参数并执行该查询。
因此，要使用 python 将数据插入到 PostgreSQL 中的表中 -
-
Import psycopg2 package.
-
使用 connect() 方法创建连接对象，方法是向其传递用户名、密码、主机（可选，默认：localhost）和数据库（可选）作为参数。
-
通过将 false 设置为属性 autocommit 的值来关闭自动提交模式。
-
cursor() psycopg2库的Connection类的None方法返回一个游标对象。使用此方法创建一个游标对象。
-
然后，通过将 UPDATE 语句作为参数传递给 execute() 方法来执行它。
Example
以下Python代码删除了年龄值大于25岁的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 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()Output
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
你可以使用 DROP TABLE 语句从 PostgreSQL 数据库中删除一张表。
Example
假设我们已经使用以下查询创建了两个名为 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=#Removing an entire table using 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()Python PostgreSQL - Limit
在执行 PostgreSQL SELECT 语句时，你可以使用 LIMIT 子句限制其结果中的记录数。
Syntax
以下为 PostgreSQL 中 LMIT 从句的语法 -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Example
假设我们使用以下查询创建了一个名为 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=#Limit clause using python
以下 python 示例检索名为 EMPLOYEE 的表的表内容，将结果中的记录数量限制为 2 -
Example
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()Python PostgreSQL - Join
当你在两张表中划分数据时，你可以使用连接从这两张表中获取组合记录。
Example
假设我们已经创建了一个名为 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=#Joins using python
当你在两张表中划分数据时，你可以使用连接从这两张表中获取组合记录。
Example
下面的 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()Output
[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, 'Krishna@mymail.com', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, 'Raja@mymail.com', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, 'Krishna@mymail.com ', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, 'Raja@mymail.com', 'Mumbai')]Python PostgreSQL - Cursor Object
psycopg 库的 Cursor 类提供方法以使用 Python 代码在数据库中执行 PostgreSQL 命令。
使用它的方法，您可以执行 SQL 语句、从结果集中获取数据、调用过程。
你可以使用 Connection 对象/类的 cursor() 方法来创建 Cursor 对象。
Example
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()Methods
以下是 Cursor 类/对象提供的各种方法。
Sr.No |
Method & Description |
1 |
callproc() 该方法用于调用 PostgreSQL 数据库中的现有过程。 |
2 |
close() 该方法用于关闭当前游标对象。 |
3 |
executemany() 该方法接受一个列表系列的参数列表。准备一个 MySQL 查询，并用所有参数执行该查询。 |
4 |
execute() 该方法接受一个 MySQL 查询作为参数，并执行给定的查询。 |
5 |
fetchall() 该方法检索查询的结果集中的所有行，并以元组列表的形式返回它们。（如果在检索几行后执行此操作，它将返回剩余的行） |
6 |
fetchone() 该方法提取查询结果中的下一行，并以元组形式返回该行。 |
7 |
fetchmany() 该方法类似于 fetchone()，但它检索查询结果集中下一组行，而不是单行。 |
Properties
以下为 Cursor 类的属性：
Sr.No |
Property & Description |
1 |
description 这是一个只读属性，它返回结果集中包含的列描述的列表。 |
2 |
astrowid 这是一个只读属性，如果表中存在任何自动增量列，这将返回最近 INSERT 或 UPDATE 操作中为该列生成的的值。 |
3 |
rowcount 对于 SELECT 和 UPDATE 操作，它返回返回/更新的行数。 |
4 |
closed 该属性指定游标是否已关闭，如果是，则返回 true，否则返回 false。 |
5 |
connection 这会返回使用此游标创建的连接对象的引用。 |
6 |
name 该属性返回游标的名称。 |
7 |
scrollable 该属性指定特定游标是否可滚动。 |
Python SQLite - Introduction
Installation
SQLite3 可以使用 sqlite3 模块与 Python 集成，该模块由 Gerhard Haring 编写。它提供与 PEP 249 描述的 DB-API 2.0 规范兼容的 SQL 接口。您无需单独安装此模块，因为它默认随 Python 2.5.x 及更高版本一起提供。
要使用 sqlite3 模块，您必须首先创建一个表示数据库的连接对象，然后可以选择创建一个游标对象，它将帮助您执行所有 SQL 语句。
Python sqlite3 module APIs
以下是重要的 sqlite3 模块例程，它可以满足您使用 Python 程序处理 SQLite 数据库的要求。如果您正在寻找更复杂的应用程序，则可以查看 Python sqlite3 模块的官方文档。
Sr.No. |
API & Description |
1 |
sqlite3.connect(database [,timeout ,other optional arguments]) 此 API 打开与 SQLite 数据库文件的连接。您可以使用 ":memory:" 打开与驻留在 RAM 中而不是磁盘上的数据库的数据库连接。如果数据库打开成功，它将返回一个连接对象。 |
2 |
connection.cursor([cursorClass]) 此例程创建一个 cursor ，它将在您使用 Python 的整个数据库编程中使用。此方法接受单个可选参数 cursorClass。如果提供，则这必须是扩展 sqlite3.Cursor 的自定义游标类。 |
3 |
cursor.execute(sql [, optional parameters]) 此例程执行 SQL 语句。SQL 语句可以是参数化的（即占位符而不是 SQL 文字）。sqlite3 模块支持两种类型的占位符：问号和命名占位符（命名样式）。 For example − cursor.execute("insert into people values (?, ?)", (who, age)) |
4 |
connection.execute(sql [, optional parameters]) 此例程是游标对象提供的上述 execute 方法的快捷方式，它通过调用 cursor 方法创建一个中间游标对象，然后使用给定的参数调用游标的 execute 方法。 |
5 |
cursor.executemany(sql, seq_of_parameters) 此例程针对序列 sql 中找到的所有参数序列或映射执行 SQL 命令。 |
6 |
connection.executemany(sql[, parameters]) 此例程是创建一个中间游标对象的快捷方式，通过调用 cursor 方法，然后使用给定的参数调用 cursor.s executemany 方法。 |
7 |
cursor.executescript(sql_script) 此例程一次执行多个以脚本形式提供的 SQL 语句。它首先发出 COMMIT 语句，然后执行它作为参数获取的 SQL 脚本。所有 SQL 语句都应以分号 (;) 分隔。 |
8 |
connection.executescript(sql_script) 此例程是创建一个中间游标对象的快捷方式，通过调用 cursor 方法，然后使用给定的参数调用游标的 executescript 方法。 |
9 |
connection.total_changes() 此例程返回自打开数据库连接以来已修改、插入或删除的数据库行的总数。 |
10 |
connection.commit() 此方法提交当前事务。如果您不调用此方法，那么自上次调用 commit() 以来的任何操作对于其他数据库连接都是不可见的。 |
11 |
connection.rollback() 此方法回滚自上次调用 commit() 以来对数据库的任何更改。 |
12 |
connection.close() 此方法关闭数据库连接。请注意，这不自动调用 commit()。如果您在不先调用 commit() 的情况下关闭数据库连接，您的更改将会丢失！ |
13 |
cursor.fetchone() 此方法获取查询结果集的下一行，返回一个序列，或者在没有更多数据可用时返回 None。 |
14 |
cursor.fetchmany([size = cursor.arraysize]) 此例程获取查询结果的下一组行，返回一个列表。当没有更多行时，返回一个空列表。该方法尝试获取 size 参数指示的行数。 |
15 |
cursor.fetchall() 该例程获取查询结果的所有（剩余）行，并返回一个列表。当没有可用行时返回一个空列表。 |
Python SQLite - Establishing Connection
Python SQLite - Create Table
使用 SQLite CREATE TABLE 语句，可以在数据库中创建一个表。
Syntax
下面是创建 SQLite 数据库表的语法：
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);Example
以下 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>Creating a table using python
游标对象包含用于执行查询和获取数据等的所有方法。连接类的游标方法返回一个游标对象。
因此，要在 Python 中创建 SQLite 数据库中的表：
-
使用 connect() 方法与数据库建立连接。
-
通过在上述创建的连接对象上调用 cursor() 方法来创建一个 cursor 对象。
-
现在使用 Cursor 类的 execute() 方法执行 CREATE TABLE 语句。
Example
以下 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()Python SQLite - Insert Data
您可以使用 INSERT INTO 语句将新行添加到 SQLite 的现有表中。在此，您需要按顺序指定表名、列名和值（与列名相同）。
Syntax
以下是 INSERT 语句的建议语法 -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);其中，column1、column2、column3、… 是表中列的名称，value1、value2、value3、… 是您需要插入到表中的值。
Example
假设我们使用 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>Inserting data using python
要在 SQLite 数据库的现有表中添加记录：
-
Import sqlite3 package.
-
使用 connect() 方法创建一个连接对象，并将数据库名称作为参数传递给该对象。
-
cursor() 方法返回一个光标对象，您可以使用该光标对象与 SQLite3 进行通信。通过在（上述创建的）连接对象上调用 cursor() 对象来创建光标对象。
-
然后，通过将 INSERT 语句作为参数传递给光标对象，调用光标对象的 execute() 方法。
Example
以下 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()Python SQLite - Select Data
您可以使用 SELCT 查询从 SQLite 表中检索数据。此查询/语句以表格形式返回指定关系（表）的内容，并称为结果集。
Example
假设我们使用以下查询创建了一个名为 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 行 country 列）。可以在检索表格内容之前，使用 .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>Retrieving data using python
对任何数据库执行 READ 操作意味着从中获取一些有用的信息。可以使用 sqlite python 模块提供的 fetch() 方法从 MYSQL 中获取数据。
sqlite3.Cursor 类提供 fetchall()、fetchmany() 和 fetchone() 三个方法，其中：
-
fetchall() 方法检索查询结果集中的所有行，然后将它们作为元组列表返回。（如果执行此操作之后检索出几行，它将返回剩余的行）。
-
fetchone() 方法获取查询结果中的下一行，并将其作为元组返回。
-
fetchmany() 方法类似于 fetchone()，但是它检索结果集中的下一组行，而不是单行。
Note - 结果集是在使用光标对象查询表格时返回的对象。
Example
下面的示例使用 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()Python SQLite - Where Clause
如果要获取、删除或更新 SQLite 中表的特定行，您需要使用 where 子句来指定条件，以便筛选表的行以进行操作。
例如，如果您有带 where 从句的 SELECT 语句，则只有满足指定条件的行才会被检索。
Syntax
以下是 SQLite 中 WHERE 子句的语法：
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]您可以使用比较或逻辑运算符（如>、<、=、LIKE、NOT等）指定search_condition。以下示例将阐明此概念。
Example
假设我们使用以下查询创建了一个名为 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>Where clause using python
Cursor 对象/类包含执行查询和获取数据等的所有方法。连接类的 cursor 方法返回一个 cursor 对象。
因此，要在 Python 中创建 SQLite 数据库中的表：
-
使用 connect() 方法与数据库建立连接。
-
通过在上述创建的连接对象上调用 cursor() 方法来创建一个 cursor 对象。
-
现在使用 Cursor 类的 execute() 方法执行 CREATE TABLE 语句。
Example
以下示例创建一个名为 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()Python SQLite - Order By
使用 SELECT 查询获取数据时，您将按照插入记录的顺序获取记录。
您可以使用 Order By 子句按所需顺序（升序或降序）对结果进行排序。默认情况下，此子句按升序对结果进行排序。如果您需要按降序对结果进行排序，您需要显式使用 “DESC”。
Syntax
以下是 SQLite 中 ORDER BY 子句的语法。
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Example
假设我们使用以下查询创建了一个名为 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>选择语句检索 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>ORDER BY clause using python
要以特定顺序检索表的全表，请对光标对象调用 execute() 方法，并将 SELECT 语句连同 ORDER BY 子句作为参数传递给它。
Example
在以下示例中，我们使用 ORDER BY 子句创建了一个名为 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()
#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()Python SQLite - Update Table
对任何数据库的 UPDATE 操作意味着修改表中一个或多个已经存在于数据库中的记录的值。您可以使用 UPDATE 语句更新 SQLite 中现有记录的值。
要更新特定行，需要同时使用 WHERE 子句。
Syntax
以下是 SQLite 中 UPDATE 语句的语法：
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Example
假设我们使用以下查询创建了一个名为 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 的记录，您会发现其 age 值已更改为 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>Updating existing records using python
要在 SQLite 数据库的现有表中添加记录：
-
Import sqlite3 package.
-
使用 connect() 方法创建一个连接对象，并将数据库名称作为参数传递给该对象。
-
cursor() 方法返回一个 cursor 对象，您可以使用它与 SQLite3 通信。通过对（上述创建的）Connection 对象调用 cursor() 对象来创建一个 cursor 对象。
-
然后，通过将 UPDATE 语句作为参数传递给 cursor 对象，调用 execute() 方法。
Example
以下 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()Output
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 - Delete Data
要从 SQLite 表格中删除记录，需要使用 DELETE FROM 语句。要移除特定记录，需要同时使用 WHERE 子句。
要更新特定行，需要同时使用 WHERE 子句。
Example
假设我们使用以下查询创建了一个名为 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>Deleting data using python
要在 SQLite 数据库的现有表中添加记录：
-
Import sqlite3 package.
-
使用 connect() 方法创建一个连接对象，并将数据库名称作为参数传递给该对象。
-
cursor() 方法返回一个 cursor 对象，您可以使用它与 SQLite3 通信。通过对（上述创建的）Connection 对象调用 cursor() 对象来创建一个 cursor 对象。
-
然后，通过将 DELETE 语句作为参数传递给 cursor 对象，调用该对象上的 execute() 方法。
Example
以下 Python 示例从 EMPLOYEE 表中删除 age 值大于 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()Output
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
你可以使用 DROP TABLE 语句删除整个表。你只需指定要删除的表的名称即可。
Example
假设我们已经使用以下查询创建了两个名为 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>Dropping a table using Python
您可以根据需要使用 MYSQL 的 DROP 语句删除表，但您在删除任何现有表时需要非常小心，因为删除表后丢失的数据将无法恢复。
Example
要使用 Python 从 SQLite3 数据库中删除表，请在游标对象上调用 execute() 方法，并将删除语句作为参数传递给它。
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()Python SQLite - Limit
在获取记录时，如果你想通过某个特定的数字来限制它们，你可以使用 SQLite 的 LIMIT 子句来做到。
Syntax
以下是 SQLite 中的 LIMIT 子句的语法：
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Example
假设我们使用以下查询创建了一个名为 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 个记录开始限制记录（不是第一个），你可以使用 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>LIMIT clause using Python
如果你通过将 SELECT 查询与 LIMIT 子句一起传递给光标对象来调用 execute() 方法，则可以检索所需数量的记录。
Example
以下 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()Python SQLite - Join
当你在两张表中划分数据时，你可以使用连接从这两张表中获取组合记录。
Example
假设我们使用以下查询创建了一个名为 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>Join clause using python
以下 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()Output
[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, 'Krishna@mymail.com', 'Hyderabad'),
('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'Raja@mymail.com', 'Vishakhapatnam'),
('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, 'Krishna@mymail.com', 'Pune'),
('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, 'Raja@mymail.com', 'Mumbai')]Python SQLite - Cursor Object
sqlite3.Cursor 类是一个实例，您可以使用它调用执行 SQLite 语句的方法，从查询的结果集中获取数据。您可以使用连接对象/类的 cursor() 方法创建 Cursor 对象。
Example
import sqlite3
#Connecting to sqlite
conn = sqlite3.connect('example.db')
#Creating a cursor object using the cursor() method
cursor = conn.cursor()Methods
以下是 Cursor 类/对象提供的各种方法。
Sr.No |
Method & Description |
1 |
execute() 此例程执行一个 SQL 语句。SQL 语句可以参数化（即，使用占位符代替 SQL 文字）。psycopg2 模块使用 %s 标识支持占位符。例如：cursor.execute("insert into people values (%s, %s)", (who, age)) |
2 |
executemany() 此例程针对序列 sql 中找到的所有参数序列或映射执行 SQL 命令。 |
3 |
fetchone() 此方法获取查询结果集的下一行，返回单个序列，或在没有更多可用数据时返回 None。 |
4 |
fetchmany() 此例程获取查询结果的下一组行，返回一个列表。当没有更多可用行时，返回一个空列表。此方法尝试获取 size 参数指示的行数。 |
5 |
fetchall() 此例程获取查询结果的所有（剩余）行，返回一个列表。当没有可用行时，返回一个空列表。 |
Properties
以下为 Cursor 类的属性：
Sr.No |
Method & Description |
1 |
arraySize 这是一个读/写属性，您可以设置 fetchmany() 方法返回的行数。 |
2 |
description 这是一个只读属性，它返回结果集中包含的列描述的列表。 |
3 |
lastrowid 这是一个只读属性，如果表中存在任何自动增量列，则返回最后一次 INSERT 或 UPDATE 操作中为该列生成的值。 |
4 |
rowcount 对于 SELECT 和 UPDATE 操作，它返回返回/更新的行数。 |
5 |
connection 此只读属性提供光标对象使用的 SQLite 数据库连接。 |
Python MongoDB - Introduction
Pymongo是一个python发行版，提供了与MongoDB一起使用的工具，它是从python与MongoDB数据库进行通信的首选方式。
Installation
要安装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.0Python MongoDB - Create Database
与其他数据库不同的是，MongoDB 没有提供单独用于创建数据库的命令。
一般来说，use 命令用于选择/切换到指定的数据库。此命令最初会验证我们指定的数据库是否存在，如果存在，则会连接到该数据库。如果我们使用 use 命令指定的数据库不存在，则会创建一个新数据库。
因此，你可以在 MongoDB 中使用 @[s0] 命令创建一个数据库。
Example
以下命令创建一个名为 mydb 的数据库。
>use mydb
switched to db mydb你可以使用 db 命令验证你的创建操作，该命令会显示当前的数据库。
>db
mydbCreating database using python
要在使用 pymongo 连接到 MongoDB，你需要导入并创建一个 MongoClient，然后你可以直接访问你需要在属性 passion 中创建的数据库。
Example
以下示例在 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())Output
Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']你还可以创建 MongoClient 时指定端口和主机名，并可以使用字典风格访问数据库。
Python MongoDB - Create Collection
MongoDB中的集合包含一组文档，它类似于关系数据库中的表。
您可以使用 createCollection() 方法创建集合。此方法接受一个表示要创建的集合的名称的字符串值和一个选项（可选）参数。
使用此选项可以指定以下内容−
-
集合的大小。
-
截断集合中允许的最大文档数。
-
我们创建的集合应为截断集合（固定大小集合）。
-
我们创建的集合应为自动索引。
Example
以下方法创建一个名为 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 }
>Creating a collection using python
以下 Python 示例连接到 MongoDB 中的数据库 (mydb)，并在其中创建一个集合。
Python MongoDB - Insert Document
你可以使用 insert() 方法将文档存储到 MongoDB 中。此方法接收 JSON 文档作为参数。
Example
> 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" : [ ]
})
>Creating a collection using python
Pymongo 提供了一个名为 insert_one() 的方法来在 MangoDB 中插入文档。对于此方法，我们需要以字典格式传递文档。
Example
以下示例在名为 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())Output
{
'_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)Python MongoDB - Find
您可以使用 find() 方法读/取从 MongoDB 中存储的文档。此方法以非结构化方式检索和显示 MongoDB 中的所有文档。
Example
假设我们已使用以下查询将 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" }Retrieving data (find) using python
pymongo 的 find_One() 方法用于根据您的查询检索单个文档，如果没有匹配项，此方法将不返回任何内容，如果您未使用任何查询，它将返回集合的第一个文档。
每当您需要仅检索结果中的一个文档或确信您的查询只返回一个文档时，此方法都派上用场。
Example
以下 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"}))Output
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() 方法。如果没有传递任何查询，它将返回集合的所有文档，如果您已将查询传递给此方法，它将返回所有匹配的文档。
Example
#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)Output
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 - Query
在使用 find() 方法检索时，您可以使用查询对象过滤文档。您可以将指定所需文档条件的查询作为参数传递给此方法。
Operators
以下是 MongoDB 中查询中使用的运算符列表。
Operation |
Syntax |
Example |
Equality |
{"key" : "value"} |
db.mycol.find({"by":"tutorials point"}) |
Less Than |
{"key" :{$lt:"value"}} |
db.mycol.find({"likes":{$lt:50}}) |
Less Than Equals |
{"key" :{$lte:"value"}} |
db.mycol.find({"likes":{$lte:50}}) |
Greater Than |
{"key" :{$gt:"value"}} |
db.mycol.find({"likes":{$gt:50}}) |
Greater Than Equals |
{"key" {$gte:"value"}} |
db.mycol.find({"likes":{$gte:50}}) |
Not Equals |
{"key":{$ne: "value"}} |
db.mycol.find({"likes":{$ne:50}}) |
Example1
以下示例检索名称为 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)Output
Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}Example2
以下示例检索 age 值大于 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)Python MongoDB - Sort
在检索集合内容时，您可以使用 sort() 方法按升序或降序对它们进行排序和排列。
您可以将字段和排序顺序（1 或 -1）传递给此方法。其中，1 表示升序，-1 表示降序。
Example
假设我们已经创建了一个集合，并在其中插入了 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" }Sorting the documents using python
为了按升序或降序对查询结果进行排序，pymongo 提供了 sort() 方法。向此方法传递一个数字值，表示结果中所需文档的数量。
默认情况下，此方法根据指定字段将文档按升序排序。如果您需要按降序排序，则传递 -1 以及字段名称：
coll.find().sort("age",-1)Example
以下示例按升序根据年龄值排列检索集合的所有文档：
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)Output
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 - Delete Document
您可以使用 MongoDB 的 remove() 方法来删除集合中的文档。此方法接受两个可选参数：
-
删除标准，指定删除文档的条件。
-
只有一个，如果您将 true 或 1 作为第二个参数传递，则只删除一个文档。
Example
假设我们已经创建了一个集合，并在其中插入了 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" : [ ]
})以下查询将删除具有 name 值为 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()Deleting documents using python
要从 MangoDB 的集合中删除文档，你可以使用 delete_one() 和 delete_many() 方法从集合中删除文档。
这些方法接受一个查询对象来指定删除文档的条件。
detete_one() 方法删除单个文档（如果匹配）。如果未指定查询，则此方法将删除集合中的第一个文档。
Example
以下 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)Output
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() 方法删除满足指定条件的所有文档。
Example
以下示例删除了集合中 age 值大于 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)Output
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 - Drop Collection
你可以使用 MongoDB 的 drop() 方法删除集合。
Example
以下示例删除名为 sample 的集合：
> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myCollDropping collection using python
你可以通过调用 drop() 方法来从当前数据库中删除/删除集合。
Example
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)Python MongoDB - Update
你可以使用 update() 方法或 save() 方法更新现有文档的内容。
更新方法修改现有的文档，而保存方法用新文档替换现有的文档。
Syntax
以下为 MangoDB 的 update() 和 save() 方法的语法 −
>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})Example
假设我们在一个数据库中创建了一个集合，并在其中插入了 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" }Updating documents using python
与检索单个文档的 find_one() 方法类似，pymongo 的 update_one() 方法更新单个文档。
该方法接受一个查询，该查询指定要更新的文档和更新操作。
Example
以下 Python 示例更新集合中某个文档的位置值。
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)Output
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() 方法更新满足指定条件的所有文档。
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
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)Output
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() 方法限制结果中的文档数。此方法接受一个数字值，表示您希望在结果中显示的文档数。
Example
假设我们已经创建了一个集合，并在其中插入了 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" }Limiting the documents using python
为了将查询的结果限制为特定数量的文档，pymongo 提供了 limit() 方法。向此方法传递一个数字值，表示您希望在结果中显示的文档数。
Example
以下示例检索集合中的前三个文档。
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)