Of course! Let's break down python mysqladmin. This is a common point of confusion, so it's important to clarify the difference between the built-in Python tool and the more modern, recommended approach.

The Core Difference: mysqladmin vs. mysql.connector

There are two main ways to interact with MySQL from Python:

1. mysqladmin (The Built-in Tool): This is a command-line utility that comes pre-packaged with Python. It's designed for administrative tasks, not for writing applications. You use it in your terminal, not within a Python script.
2. mysql.connector (The Modern Library): This is a third-party Python library that you install. It's the standard, recommended way to write Python applications that connect to, query, and manage MySQL databases.

The Built-in mysqladmin Utility

This tool is part of the Python Standard Library's sqlite3 module, but it provides a command-line interface to manage a MySQL server. It's very basic and not commonly used for development today.

How to Use It

You run it from your terminal, not from a Python script.

Basic Syntax:

python -m mysqladmin [options] command command_args

Common Commands:

• create_db: Create a new database.

  # Create a database named 'my_new_db'
  python -m mysqladmin -u root -p create my_new_db

  • -u root: Specifies the MySQL user.
  • -p: Prompts you for the password.

• drop_db: Delete a database. (Use with caution!)

  # Delete the database 'my_new_db'
  python -m mysqladmin -u root -p drop my_new_db

• status: Get a quick status report of the MySQL server.

  
  （图片来源网络，侵删）

  python -m mysqladmin -u root -p status

• version: Check the server version.

  python -m mysqladmin -u root -p version

Limitations:

• No Data Manipulation: You cannot run SELECT, INSERT, UPDATE, or DELETE statements.
• No Table Management: You cannot create, alter, or drop tables.
• Very Basic: It's limited to a handful of administrative commands.
• Not for Applications: It's impossible to use this tool's logic inside a Python script (e.g., "if the database exists, create it").

The Modern Approach: Using mysql.connector Library

This is the correct and powerful way to work with MySQL in Python. It allows you to connect, execute any SQL query, and manage your database programmatically.

Step 1: Install the Library

First, you need to install the official MySQL driver for Python.

pip install mysql-connector-python

Step 2: Connect and Perform Operations

Now you can write Python scripts to interact with your database.

Example 1: Creating a Database and a Table

This script connects to the server, creates a database (if it doesn't exist), creates a table, and inserts some data.

import mysql.connector
from mysql.connector import Error
def create_connection(host_name, user_name, user_password):
    """Establishes a connection to the MySQL server."""
    connection = None
    try:
        connection = mysql.connector.connect(
            host=host_name,
            user=user_name,
            passwd=user_password
        )
        print("Connection to MySQL successful")
        return connection
    except Error as e:
        print(f"The error '{e}' occurred")
        return None
def create_database(connection, query):
    """Creates a new database."""
    cursor = connection.cursor()
    try:
        cursor.execute(query)
        print("Database created successfully")
    except Error as e:
        print(f"The error '{e}' occurred")
def execute_query(connection, query, data=None):
    """Executes a single query (CREATE, INSERT, UPDATE, DELETE)."""
    cursor = connection.cursor()
    try:
        if data:
            cursor.execute(query, data)
        else:
            cursor.execute(query)
        connection.commit()
        print("Query executed successfully")
    except Error as e:
        print(f"The error '{e}' occurred")
# --- Main Execution ---
if __name__ == "__main__":
    # Connection details for the MySQL server
    db_host = "localhost"
    db_user = "root"
    db_password = "your_password" # Replace with your actual password
    # 1. Connect to the MySQL server
    conn = create_connection(db_host, db_user, db_password)
    if conn is not None:
        # 2. Create a database if it doesn't exist
        create_database_query = "CREATE DATABASE IF NOT EXISTS python_db"
        create_database(conn, create_database_query)
        # 3. Switch to the new database
        conn.database = "python_db"
        # 4. Create a table
        create_users_table_query = """
        CREATE TABLE IF NOT EXISTS users (
            id INT AUTO_INCREMENT PRIMARY KEY,
            name VARCHAR(255) NOT NULL,
            email VARCHAR(255) NOT NULL UNIQUE,
            age INT
        )
        """
        execute_query(conn, create_users_table_query)
        # 5. Insert data into the table
        insert_user_query = "INSERT INTO users (name, email, age) VALUES (%s, %s, %s)"
        user_data = ("Alice", "alice@example.com", 30)
        execute_query(conn, insert_user_query, user_data)
        user_data_2 = ("Bob", "bob@example.com", 25)
        execute_query(conn, insert_user_query, user_data_2)
        # 6. Fetch and display data (SELECT)
        select_users_query = "SELECT * FROM users"
        cursor = conn.cursor()
        try:
            cursor.execute(select_users_query)
            results = cursor.fetchall()
            print("\n--- Users in the database ---")
            for row in results:
                print(row)
        except Error as e:
            print(f"The error '{e}' occurred")
        # 7. Close the connection
        if conn.is_connected():
            cursor.close()
            conn.close()
            print("\nMySQL connection is closed")

Summary: mysqladmin vs. mysql.connector

Conclusion:

For any serious Python application that needs to interact with a MySQL database, you should use the mysql.connector library. The built-in mysqladmin utility is a legacy tool best suited for simple, one-off administrative commands from your operating system's command line.