2024-09-05



import sqlite3
import threading
 
# 创建数据库连接和锁
conn = sqlite3.connect('example.db', timeout=10)
lock = threading.Lock()
 
def query_data(query, params=()):
    with lock:
        cursor = conn.cursor()
        cursor.execute(query, params)
        return cursor.fetchall()
 
def insert_data(query, params=()):
    with lock:
        cursor = conn.cursor()
        cursor.execute(query, params)
        conn.commit()
 
# 使用示例
query = "SELECT * FROM some_table WHERE condition = ?"
params = ('value',)
data = query_data(query, params)
 
insert = "INSERT INTO some_table (column1, column2) VALUES (?, ?)"
insert_params = ('data1', 'data2')
insert_data(insert, insert_params)

这个代码示例展示了如何在Python中使用sqlite3和threading库来创建一个线程安全的数据库查询和插入函数。通过使用锁(lock),确保同时只有一个线程可以进行数据库操作,避免了并发时可能出现的数据不一致或锁冲突问题。这是一个简单的解决方案,适用于需要线程安全数据库交互的应用场景。

2024-09-05

为了将日志信息写入数据库表,你可以使用Python的logging模块配合数据库接口库如sqlite3pymysql等。以下是一个简单的例子,演示如何将日志信息写入SQLite数据库中。

首先,确保你的环境中已安装sqlite3




import logging
import sqlite3
 
# 创建或连接到数据库
db_path = 'logs.db'
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
 
# 创建日志表
create_table_query = '''
CREATE TABLE IF NOT EXISTS log_records (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    log_level TEXT,
    log_message TEXT,
    timestamp TEXT
);
'''
cursor.execute(create_table_query)
conn.commit()
 
# 定义记录日志的处理函数
def log_record(cursor, log_level, message):
    timestamp = logging.Formatter.formatTime(
        logging.Formatter(datefmt='%Y-%m-%d %H:%M:%S'),
        logging.LogRecord(None, logging.NOTSET, None, None, message, None, None)
    )
    insert_query = '''
    INSERT INTO log_records (log_level, log_message, timestamp)
    VALUES (?, ?, ?);
    '''
    cursor.execute(insert_query, (log_level, message, timestamp))
    conn.commit()
 
# 配置日志记录
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger()
 
# 添加日志监听器,使用自定义的处理函数
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
logger.addHandler(handler)
 
# 测试日志记录
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')
 
# 关闭数据库连接
conn.close()

在这个例子中,我们首先创建了一个SQLite数据库和日志表。然后定义了一个函数log_record,它负责将日志信息插入到数据库表中。接着配置了logging模块,并为其添加了一个自定义的处理器,该处理器使用log_record函数来记录日志。最后,我们模拟了一些日志记录,并在结束时关闭了数据库连接。

如果你使用的是MySQL或其他数据库,你需要安装对应的数据库接口库(如pymysql),并修改数据库连接和查询语句以适配你的数据库系统。

2024-09-05



from django.contrib.auth import authenticate, login
from django.http import HttpResponse
from django.shortcuts import render
 
def login_view(request):
    # 如果是通过POST请求进行登录
    if request.method == 'POST':
        # 获取用户名和密码
        username = request.POST.get('username')
        password = request.POST.get('password')
 
        # 使用Django的authenticate方法验证用户名和密码
        user = authenticate(request, username=username, password=password)
 
        # 如果用户验证成功
        if user is not None:
            # 使用Django的login方法登录用户
            login(request, user)
            # 重定向到首页或其他页面
            return HttpResponse("登录成功!")
        else:
            # 如果用户名或密码不正确,返回错误信息
            return HttpResponse("用户名或密码错误。")
 
    # 如果是GET请求,则渲染登录页面
    return render(request, 'login.html')

这段代码实现了用户登录的功能,首先检查请求方法是否为POST,如果是则获取用户名和密码,并使用Django的authenticate方法进行验证。验证成功后,使用Django的login方法将用户登录,并可以通过HttpResponse进行重定向或返回登录成功的信息。如果用户名或密码不正确,则返回错误信息。如果请求方法为GET,则渲染登录页面供用户输入。

2024-09-05

imaplib是Python的内置库,用于处理IMAP(Internet Mail Access Protocol)协议。这个库可以用于访问、检索和处理电子邮件。

以下是一些使用imaplib库的常见方法:

  1. 打开到IMAP服务器的连接



import imaplib
 
M = imaplib.IMAP4_SSL('imap.gmail.com')
  1. 登录到邮箱



M.login('your_email@gmail.com', 'your_password')
  1. 选择邮件的文件夹



M.select('inbox')
  1. 搜索邮件



typ, data = M.search(None, 'ALL')
  1. 获取邮件的信息



typ, msg_data = M.fetch(data[0], '(RFC822)')
  1. 解析邮件



from email import parser
 
msg = parser.BytesParser().parsebytes(msg_data[0][1])
  1. 关闭连接



M.close()
M.logout()
  1. 获取邮件的UID



typ, uids = M.uid('search', None, "ALL")
  1. 根据UID获取邮件



typ, msg_data = M.uid('fetch', uids[0].split()[0], '(RFC822)')
  1. 设置邮件的标记



M.store(uids[0].split()[0], '+FLAGS', '\\Deleted')
  1. 删除邮件



M.expunge()

注意:在使用这些方法时,需要替换'your\_email@gmail.com'和'your\_password'为你自己的邮箱和密码,'imap.gmail.com'是Gmail的IMAP服务器地址,如果你使用的是其他邮件服务,需要替换为相应的IMAP服务器地址。

以上就是imaplib库的一些基本用法,实际使用时可以根据需要选择合适的方法。

2024-09-05



from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
 
# 示例函数:移除停用词并进行词干提取
def preprocess_text(text):
    stop_words = set(stopwords.words('english'))
    words = [word for sentence in text for word in sentence]
    words = [stemmer.stem(word) for word in words if word not in stop_words and word.isalpha()]
    return words
 
# 示例函数:计算词频
def calculate_term_frequency(words):
    word_frequencies = {}
    for word in words:
        word_frequencies[word] = word_frequencies.get(word, 0) + 1
    return word_frequencies
 
# 示例函数:计算逆文档频率
def calculate_inverse_document_frequency(words, documents):
    word_doc_counts = {}
    num_docs = len(documents)
    for word in words:
        word_doc_counts[word] = word_doc_counts.get(word, 0) + 1
    
    idf_values = {}
    for word, doc_count in word_doc_counts.items():
        idf_values[word] = np.log(num_docs / (1 + doc_count))
    return idf_values
 
# 示例函数:计算TF-IDF值
def calculate_tf_idf(words, documents, word_frequencies, idf_values):
    tf_idf_values = {}
    for word, word_freq in word_frequencies.items():
        tf_idf_values[word] = word_freq * idf_values[word]
    return tf_idf_values
 
# 示例文本和文档集合
text = [['machine', 'learning', 'is', 'fun'], ['deep', 'learning', 'is', 'even', 'more', 'fun']]
documents = [[text[0]], [text[1]]]
 
# 预处理文本
stemmer = PorterStemmer()
preprocessed_text = preprocess_text(text)
 
# 计算词频
term_frequencies = calculate_term_frequency(preprocessed_text)
 
# 计算逆文档频率
idf_values = calculate_inverse_document_frequency(preprocessed_text, documents)
 
# 计算TF-IDF值
tf_idf_values = calculate_tf_idf(preprocessed_text, documents, term_frequencies, idf_values)
 
# 打印结果
print(tf_idf_values)

这个代码示例展示了如何使用NLTK库进行文本预处理,包括移除停用词和进行词干提取,计算词频,计算逆文档频率,以及计算TF-IDF值。这是自然语言处理中一个常见的工作流程,对于理解文本分析的原理很有帮助。

2024-09-05

Python 的 time 模块提供了几个函数来处理时间相关的操作。以下是一些常用的函数和相关的使用示例:

  1. time.sleep(secs): 暂停执行给定的秒数。



import time
 
print("Before sleep")
time.sleep(5)  # 暂停5秒
print("After sleep")
  1. time.time(): 返回当前时间的时间戳。



import time
 
current_time = time.time()
print(current_time)  # 输出类似于1585157600.201845
  1. time.ctime(): 返回当前时间的字符串形式。



import time
 
current_time = time.ctime()
print(current_time)  # 输出类似于'Sun Mar 29 10:06:40 2021'
  1. time.gmtime(): 返回当前时间的UTC时间的struct_time形式。



import time
 
current_time = time.gmtime()
print(current_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=18, tm_sec=39, tm_wday=6, tm_yday=90, tm_isdst=0)
  1. time.localtime(): 返回当前时间的本地时间的struct_time形式。



import time
 
current_time = time.localtime()
print(current_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=22, tm_sec=12, tm_wday=6, tm_yday=90, tm_isdst=0)
  1. time.mktime(t): 将struct_time形式的时间转换为时间戳。



import time
 
current_time = time.localtime()
time_stamp = time.mktime(current_time)
print(time_stamp)  # 输出类似于1585158532.0
  1. time.strftime(format, t): 将struct_time形式的时间转换为字符串形式。



import time
 
current_time = time.localtime()
time_string = time.strftime("%Y-%m-%d %H:%M:%S", current_time)
print(time_string)  # 输出类似于'2021-03-29 10:30:37'
  1. time.strptime(string, format): 将字符串形式的时间转换为struct_time形式。



import time
 
time_string = "2021-03-29 10:30:37"
struct_time = time.strptime(time_string, "%Y-%m-%d %H:%M:%S")
print(struct_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=30, tm_sec=37, tm_wday=6, tm_yday=90, tm_isdst=-1)

以上是一些基本的 time 模块操作。实际使用时,可以根据需要选择合适的函数。

2024-09-05

在Django中,SQLite是默认数据库,SQLAlchemy是一个Python的数据库工具,Django的ORM(Object-Relational Mapping)提供了数据库的抽象层。以下是一个简单的例子,展示如何在Django项目中使用SQLite数据库和SQLAlchemy。

首先,确保你已经安装了Django和SQLAlchemy。




pip install django sqlalchemy

然后,在Django项目的settings.py文件中配置SQLAlchemy:




# settings.py
 
# ...
 
# 引入SQLAlchemy
import sqlalchemy
 
# 创建SQLAlchemy配置对象
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',  # 使用SQLite数据库
        'NAME': 'mydatabase',  # 数据库文件名
    }
}
 
# 配置SQLAlchemy连接
SQLALCHEMY_DATABASE_URI = sqlalchemy.engine.url.URL(
    drivername='sqlite',
    database=str(DATABASES['default']['NAME']),
)

接下来,定义模型并使用SQLAlchemy的Session对象来操作数据库:




# models.py
 
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
 
# 创建SQLAlchemy引擎
engine = create_engine(SQLALCHEMY_DATABASE_URI)
Session = sessionmaker(bind=engine)
session = Session()
 
# 定义模型
Base = declarative_base()
 
class User(Base):
    __tablename__ = 'users'
    
    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
    name = sqlalchemy.Column(sqlalchemy.String)
    email = sqlalchemy.Column(sqlalchemy.String)
 
# 创建数据库表
Base.metadata.create_all(engine)
 
# 使用SQLAlchemy Session 对象操作数据库
def add_user(name, email):
    user = User(name=name, email=email)
    session.add(user)
    session.commit()
 
def get_users():
    return session.query(User).all()

在Django的视图中使用这些模型操作数据:




# views.py
 
from .models import add_user, get_users
 
def add_user_view(request):
    add_user('Alice', 'alice@example.com')
    return HttpResponse('User added')
 
def list_users_view(request):
    users = get_users()
    return render(request, 'users.html', {'users': users})

以上代码展示了如何在Django项目中结合使用SQLite、SQLAlchemy和ORM。这样的结合使得你可以同时使用Django的便利性和SQLAlchemy的灵活性。

2024-09-05



import pandas as pd
 
# 创建一个简单的DataFrame
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 23, 34, 29]}
df = pd.DataFrame(data)
 
# 打印DataFrame
print(df)
 
# 将DataFrame导出到CSV文件
df.to_csv('output.csv', index=False)
 
# 从CSV文件读取数据到新的DataFrame
df_from_csv = pd.read_csv('output.csv')
 
# 打印新的DataFrame
print(df_from_csv)

这段代码展示了如何使用Pandas库创建一个简单的DataFrame,并将其导出为CSV文件,然后再从CSV文件读取数据到新的DataFrame。这个过程是数据处理和分析的常见步骤,对于学习Pandas库的用户来说,这是一个很好的入门示例。

2024-09-05

创建一个简单的Django学生管理系统可以包括以下步骤:

  1. 创建一个新的Django项目和应用。
  2. 定义模型来表示学生信息。
  3. 创建管理员用户。
  4. 创建视图和模板来显示学生信息和允许管理。
  5. 配置URLs以便可以通过网页访问应用。

以下是一个简化的例子:

首先,确保安装了Django:




pip install django

然后,创建项目和应用:




django-admin startproject student_management
cd student_management
python manage.py startapp students

students/models.py中定义学生模型:




from django.db import models
 
class Student(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    email = models.EmailField(max_length=100)
 
    def __str__(self):
        return self.name

student_management/settings.py中添加应用:




INSTALLED_APPS = [
    # ...
    'students',
    # ...
]

students/views.py中创建视图:




from django.shortcuts import render
from .models import Student
 
def student_list(request):
    students = Student.objects.all()
    return render(request, 'students/student_list.html', {'students': students})
 
def student_create(request):
    # 处理POST请求以创建新学生
    # ...
    pass

students/urls.py中定义路由:




from django.urls import path
from .views import student_list, student_create
 
urlpatterns = [
    path('', student_list, name='student_list'),
    path('create/', student_create, name='student_create'),
]

student_management/urls.py中包含学生应用的URLs:




from django.urls import include, path
 
urlpatterns = [
    # ...
    path('students/', include('students.urls')),
    # ...
]

创建学生列表的HTML模板students/templates/students/student_list.html




<!DOCTYPE html>
<html>
<head>
    <title>Student List</title>
</head>
<body>
    <h1>Student List</h1>
    <a href="{% url 'student_create' %}">Add New Student</a>
    <ul>
        {% for student in students %}
        <li>{{ student.name }} - {{ student.age }} - {{ student.email }}</li>
        {% empty %}
        <li>No students available.</li>
        {% endfor %}
    </ul>
</body>
</html>

最后,通过以下命令创建和查看数据库:




python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py runserver

访问 http://127.0.0.1:8000/students/ 可以看到学生列表,使用管理员账号登录后可以添加学生信息。

这个例子提供了一个简单的学生管理系统的骨架,实际的系统可能需要更多的功能,如用户认证、权限管理、表单处理、分页等。

2024-09-05



import psycopg2
 
# 连接PostgreSQL数据库
def connect_to_db(dbname, host, port, user, password):
    """
    连接到PostgreSQL数据库
    :param dbname: 数据库名
    :param host: 数据库主机地址
    :param port: 端口号
    :param user: 用户名
    :param password: 密码
    :return: 数据库连接对象和游标对象
    """
    # 使用psycopg2连接数据库
    conn = psycopg2.connect(
        dbname=dbname,
        host=host,
        port=port,
        user=user,
        password=password
    )
    # 创建游标对象
    cur = conn.cursor()
    return conn, cur
 
# 查询操作
def query_data(cur):
    """
    执行查询操作
    :param cur: 游标对象
    :return: 查询结果
    """
    # 编写SQL查询语句
    sql_query = "SELECT * FROM your_table_name"
    # 使用游标执行查询
    cur.execute(sql_query)
    # 获取所有查询结果
    rows = cur.fetchall()
    return rows
 
# 插入操作
def insert_data(cur, data):
    """
    执行插入操作
    :param cur: 游标对象
    :param data: 要插入的数据
    :return: 插入结果
    """
    # 编写SQL插入语句
    sql_insert = "INSERT INTO your_table_name (column1, column2) VALUES (%s, %s)"
    # 使用游标执行插入
    cur.execute(sql_insert, data)
    # 提交事务
    return cur.rowcount
 
# 更新操作
def update_data(cur, data, condition):
    """
    执行更新操作
    :param cur: 游标对象
    :param data: 要更新的数据
    :param condition: 更新条件
    :return: 更新结果
    """
    # 编写SQL更新语句
    sql_update = "UPDATE your_table_name SET column1 = %s WHERE column2 = %s"
    # 使用游标执行更新
    cur.execute(sql_update, data, condition)
    # 提交事务
    return cur.rowcount
 
# 删除操作
def delete_data(cur, condition):
    """
    执行删除操作
    :param cur: 游标对象
    :param condition: 删除条件
    :return: 删除结果
    """
    # 编写SQL删除语句
    sql_delete = "DELETE FROM your_table_name WHERE column_name = %s"
    # 使用游标执行删除
    cur.execute(sql_delete, condition)
    # 提交事务
    return cur.rowcount
 
# 关闭数据库连接
def close_db_connection(conn, cur):
    """
    关闭数据库连接和游标
    :param conn: 数据库连接对象
    :param cur: 游标对象
    :return: None
    """
    # 关闭游标
    cur.close()
    # 关闭连接
    conn.close()
 
# 示例使用
if __name__ == "__main__":
    # 数据库连接参数
    dbname = "your_dbname"
    host = "your_host"
    port = "your_port"
    user = "your_user"
    password = "your_password"
    
    # 连接数据库
    conn, cur = connect_to_db(dbname, host, port, user, password)
    
    # 查询数据
    rows = query_data(cur)
    print(rows)
    
    #