在Python 中連接MSSQL,MySQL,SQLite,Redis,ElasticSearch,Mongodb,PostgreSQL,Oracle,RabbitMQ等數據庫/中間件的方式
Python 中連接 MSSQL 數據庫
要在 Python 中連接 MSSQL 數據庫，可以使用 pyodbc 模塊。以下是一個簡單的示例：首先，需要安裝 pyodbc 模塊。可以使用 pip 命令進行安裝：
pip install pyodbc
然後，可以使用以下代碼連接到 MSSQL 數據庫：
import pyodbc
# 建立連接
conn = pyodbc.connect('DRIVER={SQL Server};'
'SERVER=server_name;'
'DATABASE=database_name;'
'UID=username;'
'PWD=password')
# 創建遊標
cursor = conn.cursor()
# 執行查詢
cursor.execute('SELECT * FROM table_name')
# 獲取查詢結果
for row in cursor:
print(row)
# 關閉連接
conn.close()
在上面的代碼中，將 server_name 替換爲 MSSQL 服務器的名稱，將 database_name 替換爲要連接的數據庫的名稱，將 username 和 password 替換爲登錄 MSSQL 的用戶名和密碼。
接下來，使用 pyodbc.connect() 方法建立連接，該方法需要指定連接字符串。在連接字符串中，使用 DRIVER={SQL Server} 指定要使用的驅動程序，SERVER 指定服務器名稱，DATABASE 指定要連接的數據庫名稱，UID 指定登錄的用戶名，PWD 指定登錄的密碼。
然後，使用 conn.cursor() 方法創建遊標，使用 cursor.execute() 方法執行查詢語句，使用 for 循環遍歷查詢結果，最後使用 conn.close() 方法關閉連接。
Python 中連接 MySQL 數據庫
要在 Python 中連接 MySQL 數據庫，可以使用 PyMySQL 模塊。以下是一個簡單的示例：
首先，需要安裝 PyMySQL 模塊。可以使用 pip 命令進行安裝：
pip install pymysql
然後，可以使用以下代碼連接到 MySQL 數據庫：
import pymysql
# 建立連接
conn = pymysql.connect(host='localhost', port=3306, user='username', password='password', database='database_name')
# 創建遊標
cursor = conn.cursor()
# 執行查詢
cursor.execute('SELECT * FROM table_name')
# 獲取查詢結果
for row in cursor:
print(row)
# 關閉連接
conn.close()
在上面的代碼中，將 host 替換爲 MySQL 服務器的地址，將 port 替換爲 MySQL 服務器的端口號，將 username 和 password 替換爲登錄 MySQL 的用戶名和密碼，將 database_name 替換爲要連接的數據庫的名稱。
接下來，使用 pymysql.connect() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用 host 指定 MySQL 服務器的地址，port 指定 MySQL 服務器的端口號，user 指定登錄的用戶名，password 指定登錄的密碼，database 指定要連接的數據庫名稱。
然後，使用 conn.cursor() 方法創建遊標，使用 cursor.execute() 方法執行查詢語句，使用 for 循環遍歷查詢結果，最後使用 conn.close() 方法關閉連接。
Python 中連接 SQLite 數據庫
要在 Python 中連接 SQLite 數據庫，可以使用內置的 sqlite3 模塊。以下是一個簡單的示例：
首先，需要使用以下代碼建立連接：
import sqlite3
# 建立連接
conn = sqlite3.connect('my_database.db')
# 創建遊標對象
cursor = conn.cursor()
在上面的代碼中，使用 sqlite3.connect() 方法建立連接。該方法需要指定數據庫文件的路徑。如果該文件不存在，則會自動創建一個新的數據庫文件。如果路徑爲 :memory:，則表示在內存中創建一個臨時數據庫。
接下來，使用 cursor() 方法創建遊標對象，該對象用於執行 SQL 查詢語句。
例如，可以使用以下代碼創建一個名爲 users 的表：
# 創建表格
cursor.execute('''
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT,
email TEXT
)
''')
在上面的代碼中，使用 execute() 方法執行 SQL 查詢語句。在該示例中，創建了一個包含 id、name 和 email 三個字段的表格。
接下來，可以使用以下代碼插入一些數據：
# 插入數據
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Alice', '[email protected]'))
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Bob', '[email protected]'))
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Charlie', '[email protected]'))
# 提交更改
conn.commit()
在上面的代碼中，使用 execute() 方法執行 SQL 查詢語句。在該示例中，插入了三條數據，每條數據包含 name 和 email 兩個字段的值。在插入數據後，使用 commit() 方法提交更改。
接下來，可以使用以下代碼查詢數據：
# 查詢數據
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
# 打印結果
for row in rows:
print(row)
在上面的代碼中，使用 execute() 方法執行 SQL 查詢語句。在該示例中，查詢了 users 表中的所有數據，並使用 fetchall() 方法獲取查詢結果。最後，使用循環遍歷查詢結果，並打印每行數據。
最後，可以使用以下代碼關閉連接：
# 關閉連接
cursor.close()
conn.close()
在上面的代碼中，使用 close() 方法關閉遊標對象和數據庫連接對象。
除了以上的連接方法外，還可以使用 SQLAlchemy 模塊來連接 SQLite 數據庫。SQLAlchemy 是一個 Python 的 SQL 工具包，支持多種 SQL 數據庫，包括 SQLite。以下是一個使用 SQLAlchemy 的示例：
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# 建立連接
engine = create_engine('sqlite:///my_database.db', echo=True)
# 創建 Session 類
Session = sessionmaker(bind=engine)
# 創建 Base 類
Base = declarative_base()
# 創建 User 類
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
# 創建表格
Base.metadata.create_all(engine)
# 創建 Session 對象
session = Session()
# 插入數據
session.add_all([
User(name='Alice', email='[email protected]'),
User(name='Bob', email='[email protected]'),
User(name='Charlie', email='[email protected]')
])
session.commit()
# 查詢數據
users = session.query(User).all()
for user in users:
print(user.id, user.name, user.email)
# 關閉 Session 對象
session.close()
在上面的代碼中，使用 create_engine() 方法建立連接。該方法需要指定數據庫文件的路徑。在該示例中，使用了 echo=True 參數，表示在控制檯輸出 SQL 查詢語句，方便調試。
接下來，使用 sessionmaker() 方法創建 Session 類，該類用於創建 Session 對象。使用 declarative_base() 方法創建 Base 類，該類用於定義數據模型。
在該示例中，定義了一個 User 類，該類繼承了 Base 類，並定義了 id
Python 中連接 Redis
要在 Python 中連接 Redis 數據庫，可以使用 redis 模塊。以下是一個簡單的示例：首先，需要安裝 redis 模塊。可以使用 pip 命令進行安裝：
pip install redis
然後，可以使用以下代碼連接到 Redis 數據庫：
import redis
# 建立連接
r = redis.Redis(host='localhost', port=6379, db=0)
# 設置鍵值對
r.set('key', 'value')
# 獲取鍵值對
value = r.get('key')
print(value)
# 關閉連接
r.close()
在上面的代碼中，將 host 替換爲 Redis 服務器的地址，將 port 替換爲 Redis 服務器的端口號，將 db 替換爲要連接的數據庫的編號。
接下來，使用 redis.Redis() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用 host 指定 Redis 服務器的地址，port 指定 Redis 服務器的端口號，db 指定要連接的數據庫的編號。
然後，使用 r.set() 方法設置鍵值對，使用 r.get() 方法獲取鍵值對，最後使用 r.close() 方法關閉連接。
除了以上的連接方法外，還可以使用 Redis 的連接池來提高連接的效率。連接池可以在多個線程之間共享連接，從而減少連接的開銷。以下是一個使用連接池的示例：
import redis
from redis import ConnectionPool
# 建立連接池
pool = ConnectionPool(host='localhost', port=6379, db=0)
# 獲取連接
r = redis.Redis(connection_pool=pool)
# 設置鍵值對
r.set('key', 'value')
# 獲取鍵值對
value = r.get('key')
print(value)
# 關閉連接
r.close()
在上面的代碼中，使用 redis.ConnectionPool() 方法創建連接池，然後使用 redis.Redis() 方法獲取連接，指定 connection_pool 參數爲連接池。其他操作與前面的示例相同。
使用連接池可以提高連接的效率，但需要注意連接池的大小，以免佔用過多的資源。可以使用 max_connections 參數來指定連接池的大小。
Python 中連接 ElasticSearch
要在 Python 中連接 ElasticSearch 數據庫，可以使用 elasticsearch 模塊。以下是一個簡單的示例：
首先，需要安裝 elasticsearch 模塊。可以使用 pip 命令進行安裝：
pip install elasticsearch
然後，可以使用以下代碼連接到 ElasticSearch 數據庫：
from elasticsearch import Elasticsearch
# 建立連接
es = Elasticsearch(['localhost:9200'])
# 創建索引
es.indices.create(index='my_index')
# 添加文檔
doc = {'title': 'Elasticsearch Tutorial', 'content': 'This is a tutorial for Elasticsearch'}
es.index(index='my_index', id=1, body=doc)
# 搜索文檔
res = es.search(index='my_index', body={'query': {'match': {'content': 'tutorial'}}})
print(res)
# 關閉連接
es.close()
在上面的代碼中，將 localhost:9200 替換爲 ElasticSearch 服務器的地址和端口號。
接下來，使用 Elasticsearch() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用一個包含 ElasticSearch 服務器地址的列表。
然後，使用 es.indices.create() 方法創建索引，使用 es.index() 方法添加文檔，使用 es.search() 方法搜索文檔，最後使用 es.close() 方法關閉連接。
除了以上的連接方法外，還可以使用 ElasticSearch 的連接池來提高連接的效率。連接池可以在多個線程之間共享連接，從而減少連接的開銷。以下是一個使用連接池的示例：
from elasticsearch import Elasticsearch
from elasticsearch import ConnectionPool, ConnectionSelector
# 創建連接池
pool = ConnectionPool([{'host': 'localhost', 'port': 9200}], maxsize=10)
# 創建連接選擇器
selector = ConnectionSelector([pool])
# 建立連接
es = Elasticsearch(connection_class=selector)
# 創建索引
es.indices.create(index='my_index')
# 添加文檔
doc = {'title': 'Elasticsearch Tutorial', 'content': 'This is a tutorial for Elasticsearch'}
es.index(index='my_index', id=1, body=doc)
# 搜索文檔
res = es.search(index='my_index', body={'query': {'match': {'content': 'tutorial'}}})
print(res)
# 關閉連接
es.close()
在上面的代碼中，使用 elasticsearch.ConnectionPool() 方法創建連接池，指定 ElasticSearch 服務器的地址和端口號。然後，使用 elasticsearch.ConnectionSelector() 方法創建連接選擇器，將連接池傳遞給選擇器。最後，使用 Elasticsearch() 方法建立連接，指定 connection_class 參數爲連接選擇器。
使用連接池可以提高連接的效率，但需要注意連接池的大小，以免佔用過多的資源。可以使用 maxsize 參數來指定連接池的大小。
Python 中連接 MongoDB
要在 Python 中連接 MongoDB 數據庫，可以使用 pymongo 模塊。以下是一個簡單的示例：首先，需要安裝 pymongo 模塊。可以使用 pip 命令進行安裝：
pip install pymongo
然後，可以使用以下代碼連接到 MongoDB 數據庫：
import pymongo
# 建立連接
client = pymongo.MongoClient('mongodb://localhost:27017/')
# 創建數據庫和集合
db = client['my_database']
col = db['my_collection']
# 插入文檔
doc = {'name': 'John', 'age': 30}
col.insert_one(doc)
# 查詢文檔
res = col.find({'name': 'John'})
for doc in res:
print(doc)
# 關閉連接
client.close()
在上面的代碼中，將 mongodb://localhost:27017/ 替換爲 MongoDB 服務器的地址和端口號。
接下來，使用 pymongo.MongoClient() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用 MongoDB 服務器的地址和端口號。
然後，使用 client['my_database'] 方法創建數據庫，使用 db['my_collection'] 方法創建集合。可以將 my_database 和 my_collection 替換爲要創建的數據庫和集合的名稱。
接下來，使用 col.insert_one() 方法插入文檔，使用 col.find() 方法查詢文檔，最後使用 client.close() 方法關閉連接。
除了以上的連接方法外，還可以使用 MongoDB 的連接池來提高連接的效率。連接池可以在多個線程之間共享連接，從而減少連接的開銷。以下是一個使用連接池的示例：
import pymongo
from pymongo import MongoClient, uri_parser
from pymongo.pool import Pool, PooledConnection
class ConnectionPool(Pool):
def __init__(self, uri, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uri = uri
self.client = MongoClient(uri, connect=False)
def create_connection(self):
return PooledConnection(self.client)
def get_uri(self):
return self.uri
# 建立連接池
uri = 'mongodb://localhost:27017/my_database'
pool = ConnectionPool(uri, max_size=10)
# 建立連接
client = MongoClient(pool=pool)
# 創建數據庫和集合
db = client.my_database
col = db.my_collection
# 插入文檔
doc = {'name': 'John', 'age': 30}
col.insert_one(doc)
# 查詢文檔
res = col.find({'name': 'John'})
for doc in res:
print(doc)
# 關閉連接
client.close()
在上面的代碼中，使用 ConnectionPool 類繼承自 pymongo.pool.Pool 類，重寫了 create_connection() 方法和 get_uri() 方法。在 create_connection() 方法中，使用 PooledConnection 類創建連接。在 get_uri() 方法中，返回 MongoDB 服務器的地址和端口號。
然後，使用 ConnectionPool 類創建連接池，指定 MongoDB 服務器的地址和端口號。使用 max_size 參數來指定連接池的大小。
最後，使用 MongoClient(pool=pool) 方法建立連接，指定 pool 參數爲連接池。使用 client.my_database 和 db.my_collection 方法創建數據庫和集合。可以將 my_database 和 my_collection 替換爲要創建的數據庫和集合的名稱。
Python 中連接 PostgreSQL
要在 Python 中連接 PostgreSQL 數據庫，可以使用 psycopg2 模塊。以下是一個簡單的示例：首先，需要安裝 psycopg2 模塊。可以使用 pip 命令進行安裝：
pip install psycopg2
然後，可以使用以下代碼連接到 PostgreSQL 數據庫：
import psycopg2
# 建立連接
conn = psycopg2.connect(host='localhost', port=5432, dbname='my_database', user='my_username', password='my_password')
# 創建遊標
cur = conn.cursor()
# 創建表
cur.execute('CREATE TABLE my_table (id SERIAL PRIMARY KEY, name VARCHAR(50), age INTEGER)')
# 插入數據
cur.execute("INSERT INTO my_table (name, age) VALUES (%s, %s)", ('John', 30))
# 查詢數據
cur.execute("SELECT * FROM my_table WHERE name = %s", ('John',))
rows = cur.fetchall()
for row in rows:
print(row)
# 提交事務
conn.commit()
# 關閉遊標和連接
cur.close()
conn.close()
在上面的代碼中，將 localhost 替換爲 PostgreSQL 服務器的地址，將 5432 替換爲 PostgreSQL 服務器的端口號，將 my_database、my_username 和 my_password 替換爲要連接的數據庫、用戶名和密碼。
接下來，使用 psycopg2.connect() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用 PostgreSQL 服務器的地址、端口號、數據庫、用戶名和密碼。
然後，使用 conn.cursor() 方法創建遊標，使用 cur.execute() 方法執行 SQL 命令。在上面的示例中，使用 CREATE TABLE 命令創建表，使用 INSERT INTO 命令插入數據，使用 SELECT 命令查詢數據。
最後，使用 conn.commit() 方法提交事務，使用 cur.close() 和 conn.close() 方法關閉遊標和連接。
除了以上的連接方法外，還可以使用 SQLAlchemy 模塊來連接 PostgreSQL 數據庫。SQLAlchemy 是一個 Python 的 SQL 工具和 ORM（對象關係映射）框架，支持多種數據庫，包括 PostgreSQL。以下是一個使用 SQLAlchemy 的示例：
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# 建立連接
engine = create_engine('postgresql://my_username:my_password@localhost:5432/my_database')
# 創建 Session
Session = sessionmaker(bind=engine)
session = Session()
# 定義模型
Base = declarative_base()
class MyTable(Base):
__tablename__ = 'my_table'
id = Column(Integer, primary_key=True)
name = Column(String(50))
age = Column(Integer)
# 創建表
Base.metadata.create_all(engine)
# 插入數據
my_data = MyTable(name='John', age=30)
session.add(my_data)
session.commit()
# 查詢數據
rows = session.query(MyTable).filter_by(name='John').all()
for row in rows:
print(row.id, row.name, row.age)
# 關閉 Session
session.close()
在上面的代碼中，將 my_username 和 my_password 替換爲要連接的用戶名和密碼，將 localhost 替換爲 PostgreSQL 服務器的地址，將 5432 替換爲 PostgreSQL 服務器的端口號，將 my_database 替換爲要連接的數據庫。
接下來，使用 create_engine() 方法建立連接，該方法需要指定連接字符串。在連接字符串中，使用 PostgreSQL 服務器的地址、端口號、用戶名、密碼和數據庫。
然後，使用 sessionmaker() 方法創建 Session，使用 Session() 方法創建一個 Session 對象。這裏使用 SQLAlchemy 的 ORM 功能，定義一個模型 MyTable，該模型對應一個名爲 my_table 的表。使用 Base.metadata.create_all() 方法創建表。
接下來，使用 session.add() 方法插入數據，使用 session.query() 方法查詢數據。在上面的示例中，使用 filter_by() 方法過濾數據，使用 all() 方法獲取所有結果。
最後，使用 session.close() 方法關閉 Session。
使用 SQLAlchemy 連接 PostgreSQL 數據庫可以提供更方便的 ORM 功能，並且可以支持更多的數據庫。
Python 中連接 Oracle
要在 Python 中連接 Oracle 數據庫，可以使用 cx_Oracle 模塊。以下是一個簡單的示例：首先，需要安裝 cx_Oracle 模塊。可以使用 pip 命令進行安裝：
pip install cx_Oracle
然後，可以使用以下代碼連接到 Oracle 數據庫：
import cx_Oracle
# 建立連接
conn = cx_Oracle.connect('my_username/my_password@my_host:my_port/my_service_name')
# 創建遊標
cur = conn.cursor()
# 創建表
cur.execute('CREATE TABLE my_table (id NUMBER(10), name VARCHAR2(50), age NUMBER(3))')
# 插入數據
cur.execute("INSERT INTO my_table (id, name, age) VALUES (:1, :2, :3)", (1, 'John', 30))
# 查詢數據
cur.execute("SELECT * FROM my_table WHERE name = :1", ('John',))
rows = cur.fetchall()
for row in rows:
print(row)
# 提交事務
conn.commit()
# 關閉遊標和連接
cur.close()
conn.close()
在上面的代碼中，將 my_username、my_password、my_host、my_port 和 my_service_name 替換爲要連接的用戶名、密碼、主機名、端口號和服務名。
接下來，使用 cx_Oracle.connect() 方法建立連接，該方法需要指定連接字符串。在連接字符串中，使用 Oracle 數據庫的用戶名、密碼、主機名、端口號和服務名。
然後，使用 conn.cursor() 方法創建遊標，使用 cur.execute() 方法執行 SQL 命令。在上面的示例中，使用 CREATE TABLE 命令創建表，使用 INSERT INTO 命令插入數據，使用 SELECT 命令查詢數據。
最後，使用 conn.commit() 方法提交事務，使用 cur.close() 和 conn.close() 方法關閉遊標和連接。
除了以上的連接方法外，還可以使用 SQLAlchemy 模塊來連接 Oracle 數據庫。SQLAlchemy 是一個 Python 的 SQL 工具和 ORM（對象關係映射）框架，支持多種數據庫，包括 Oracle。以下是一個使用 SQLAlchemy 的示例：
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# 建立連接
engine = create_engine('oracle+cx_oracle://my_username:my_password@my_host:my_port/my_service_name')
# 創建 Session
Session = sessionmaker(bind=engine)
session = Session()
# 定義模型
Base = declarative_base()
class MyTable(Base):
__tablename__ = 'my_table'
id = Column(Integer, primary_key=True)
name = Column(String(50))
age = Column(Integer)
# 創建表
Base.metadata.create_all(engine)
# 插入數據
my_data = MyTable(id=1, name='John', age=30)
session.add(my_data)
session.commit()
# 查詢數據
rows = session.query(MyTable).filter_by(name='John').all()
for row in rows:
print(row.id, row.name, row.age)
# 關閉 Session
session.close()
在上面的代碼中，將 my_username、my_password、my_host、my_port 和 my_service_name 替換爲要連接的用戶名、密碼、主機名、端口號和服務名。
接下來，使用 create_engine() 方法建立連接，該方法需要指定連接字符串。在連接字符串中，使用 Oracle 數據庫的用戶名、密碼、主機名、端口號和服務名。
然後，使用 sessionmaker() 方法創建 Session，使用 Session() 方法創建一個 Session 對象。這裏使用 SQLAlchemy 的 ORM 功能，定義一個模型 MyTable，該模型對應一個名爲 my_table 的表。
使用 Base.metadata.create_all() 方法創建表。在上面的示例中，使用 add() 方法插入數據，使用 query() 方法查詢數據。
最後，使用 session.close() 方法關閉 Session。
Python 中連接 RabbitMQ
要在 Python 中連接 RabbitMQ，可以使用 pika 模塊。以下是一個簡單的示例：首先，需要安裝 pika 模塊。可以使用 pip 命令進行安裝：
pip install pika
然後，可以使用以下代碼連接到 RabbitMQ：
import pika
# 建立連接
credentials = pika.PlainCredentials('my_username', 'my_password')
connection = pika.BlockingConnection(pika.ConnectionParameters('my_host', 5672, '/', credentials))
channel = connection.channel()
# 聲明隊列
channel.queue_declare(queue='my_queue')
# 發送消息
channel.basic_publish(exchange='', routing_key='my_queue', body='Hello, RabbitMQ!')
# 接收消息
def callback(ch, method, properties, body):
print("Received message:", body)
channel.basic_consume(queue='my_queue', on_message_callback=callback, auto_ack=True)
channel.start_consuming()
# 關閉連接
channel.close()
connection.close()
在上面的代碼中，將 my_username、my_password、my_host 替換爲要連接的用戶名、密碼和主機名。
接下來，使用 pika.BlockingConnection() 方法建立連接，該方法需要指定連接參數。在連接參數中，使用 RabbitMQ 的主機名、端口號、虛擬主機名和憑證。
然後，使用 channel.queue_declare() 方法聲明隊列，使用 channel.basic_publish() 方法發送消息。
使用 channel.basic_consume() 方法接收消息，需要定義一個回調函數 callback()，接收消息時會調用該函數。在上面的示例中，定義的回調函數將收到的消息打印出來。
最後，使用 channel.close() 和 connection.close() 方法關閉連接。
除了以上的連接方法外，還可以使用 kombu 模塊來連接 RabbitMQ。kombu 是一個 Python 的消息傳遞庫，支持多種消息傳遞協議，包括 RabbitMQ。以下是一個使用 kombu 的示例：
from kombu import Connection, Exchange, Queue
# 建立連接
conn = Connection('amqp://my_username:my_password@my_host:5672//')
channel = conn.channel()
# 定義 Exchange 和 Queue
exchange = Exchange('my_exchange', type='direct')
queue = Queue('my_queue', exchange, routing_key='my_queue')
# 發送消息
producer = conn.Producer(serializer='json')
producer.publish({'message': 'Hello, RabbitMQ!'}, exchange=exchange, routing_key='my_queue')
# 接收消息
def callback(body, message):
print("Received message:", body)
message.ack()
with conn.Consumer(queue, callbacks=[callback]) as consumer:
while True:
conn.drain_events()
# 關閉連接
channel.close()
conn.close()
在上面的代碼中，將 my_username、my_password、my_host 替換爲要連接的用戶名、密碼和主機名。
接下來，使用 Connection() 方法建立連接，該方法需要指定連接字符串。在連接字符串中，使用 RabbitMQ 的用戶名、密碼、主機名和端口號。
然後，使用 Exchange() 和 Queue() 方法定義 Exchange 和 Queue，使用 Producer() 方法發送消息。
使用 Consumer() 方法接收消息，需要定義一個回調函數 callback()，接收到消息時會調用該函數。在上面的示例中，定義的回調函數將收到的消息打印出來，並使用 ack() 方法確認消息已接收。
最後，使用 channel.close() 和 conn.close() 方法關閉連接。
來源：Python 中連接 MSSQL/MySQL/SQLite/Redis/ElasticSearch/Mongodb/PostgreSQL/Oracle/RabbitMQhttps://www.iwmyx.cn/pythonconndb.html