Of course! Since "python commands for" is a very broad topic, I'll break this down into the most common categories you might be looking for.
（图片来源网络，侵删）
Running Python Code
These are the fundamental commands you use to execute Python scripts or code snippets.
| Command | Purpose | Example |
|---|---|---|
python |
Starts the interactive Python interpreter (REPL). You can type code line by line and see the results immediately. | python (then type print("Hello") and press Enter) |
python script.py |
Executes the code in a file named script.py. |
python hello.py |
python -c "..." |
Executes a single string of Python code from the command line. | python -c "import math; print(math.sqrt(16))" |
python -m module |
Runs a module as a script. This is the standard way to run command-line tools that are part of a package. | python -m pip install requests |
Managing Packages and Environments (with pip and venv)
These are essential for modern Python development.
| Command | Purpose | Example |
|---|---|---|
pip install <package> |
Installs a package from the Python Package Index (PyPI). | pip install requests |
pip uninstall <package> |
Uninstalls a package. | pip uninstall requests |
pip list |
Lists all installed packages and their versions. | pip list |
pip show <package> |
Shows detailed information about a specific package. | pip show numpy |
pip freeze > requirements.txt |
Creates a requirements.txt file with a list of all installed packages and their versions. |
pip freeze > requirements.txt |
pip install -r requirements.txt |
Installs all the packages listed in a requirements.txt file. |
pip install -r requirements.txt |
python -m venv <env_name> |
Creates a new virtual environment (e.g., my_project_env). |
python -m venv my_project_env |
source <env_name>/bin/activate |
(Linux/macOS) Activates the virtual environment. | source my_project_env/bin/activate |
.\env_name\Scripts\activate |
(Windows) Activates the virtual environment. | .\my_project_env\Scripts\activate |
deactivate |
Deactivates the currently active virtual environment. | deactivate |
Running Scripts as Modules
This is a crucial concept for organizing larger projects.
| Command | Purpose | Example |
|---|---|---|
python -m <module_path> |
Executes a module or package. This is how you run command-line tools. | python -m pytest |
if __name__ == "__main__": |
A standard Python construct that allows a script to be run directly or imported as a module without executing its main code. | See "Project Structure" example below. |
Command-Line Arguments
These commands allow your Python script to accept input from the command line.
（图片来源网络，侵删）
| Command/Concept | Purpose | Example |
|---|---|---|
import sys |
The sys module provides access to command-line arguments. |
sys.argv is a list containing the script name and arguments. |
sys.argv |
A list of command-line arguments. The first element (sys.argv[0]) is the script name. |
python script.py arg1 arg2 -> sys.argv is ['script.py', 'arg1', 'arg2'] |
argparse |
The standard, powerful library for creating user-friendly command-line interfaces. | See "Project Structure" example below. |
Built-in Python Functions (Core Language)
These are functions you can use directly in your code without importing anything.
| Function | Purpose | Example |
|---|---|---|
print() |
Outputs messages to the console. | print("Hello, world!") |
len() |
Returns the length (number of items) of an object. | len("hello") returns 5 |
type() |
Returns the type of an object. | type(123) returns <class 'int'> |
range() |
Generates a sequence of numbers. | list(range(5)) returns [0, 1, 2, 3, 4] |
input() |
Reads a line from the console. | name = input("Enter your name: ") |
open() |
Opens a file and returns a file object. | f = open("file.txt", "r") |
int(), str(), float() |
Converts a value to an integer, string, or float. | int("10") returns 10 |
list(), dict(), tuple() |
Creates new lists, dictionaries, or tuples. | list("abc") returns ['a', 'b', 'c'] |
Common Python Modules (Useful Libraries)
These are standard libraries that come with Python.
| Module | Purpose | Example |
|---|---|---|
os |
Interacting with the operating system (file paths, directories, environment variables). | os.getcwd() (get current directory), os.listdir() |
sys |
Accessing system-specific parameters and functions (command-line arguments, exit). | sys.argv, sys.exit() |
json |
Encoding and decoding JSON data. | json.loads('{"name": "John"}') |
datetime |
Manipulating dates and times. | datetime.datetime.now() |
re |
Regular expressions for pattern matching in strings. | re.search("hello", "hello world") |
math |
Mathematical functions. | math.sqrt(16), math.pi |
random |
Generating random numbers. | random.randint(1, 10) |
argparse |
Parsing command-line arguments. | See project structure example below. |
Putting It All Together: A Project Structure Example
Let's imagine you have a project to greet a user. You want to run it from the command line.
File Structure:
（图片来源网络，侵删）
my_project/
├── greet.py
└── requirements.txtrequirements.txt
This file lists your project's dependencies.
colorama==0.4.6greet.py (using sys.argv)
This is a simple way to get arguments.
import sys
# sys.argv[0] is the script name
if len(sys.argv) > 1:
name = sys.argv[1]
print(f"Hello, {name}!")
else:
print("Hello, stranger!")
How to run it:
# Navigate to the project directory cd my_project # Run the script with an argument python greet.py Alice # Output: Hello, Alice! # Run it without an argument python greet.py # Output: Hello, stranger!
greet.py (using argparse - more robust)
This is the professional way to handle command-line arguments.
import argparse
def main():
"""Main function to parse arguments and print a greeting."""
parser = argparse.ArgumentParser(description="A friendly greeter script.")
parser.add_argument(
"name",
type=str,
help="The name of the person to greet."
)
parser.add_argument(
"--shout",
action="store_true", # Makes --shout a flag, no value needed
help="Greet in ALL CAPS."
)
args = parser.parse_args() # Parse the arguments
if args.shout:
print(f"HELLO, {args.name.upper()}!")
else:
print(f"Hello, {args.name}!")
if __name__ == "__main__":
main()
How to run it:
# Navigate to the project directory cd my_project # Install the requirement pip install -r requirements.txt # Run with a name python greet.py Bob # Output: Hello, Bob! # Run with a name and the --shout flag python greet.py Bob --shout # Output: HELLO, BOB! # Get help python greet.py --help # Output: # usage: greet.py [-h] [--shout] name # # A friendly greeter script. # # positional arguments: # name The name of the person to greet. # # options: # -h, --help show this help message and exit # --shout Greet in ALL CAPS.
This comprehensive list should cover the most common "python commands for" various tasks. If you have a more specific question (e.g., "python commands for data science"), feel free to ask
