python 命令行执行分享

引言

在Python编程中，命令行工具是一种强大且高效的交互方式。通过命令行，我们可以直接运行Python脚本，处理数据，执行系统任务等。

步骤一：编写Python脚本

首先，我们需要创建一个Python文件。在任意文本编辑器（如Notepad、Visual Studio Code或PyCharm）中，新建一个文件，并将其命名为hello.py（扩展名为.py表明这是一个Python文件）。在文件中输入以下简单代码：

# hello.py 文件内容 
print("Hello, World!")

步骤二：理解Python解释器

Python解释器是执行Python代码的程序。在大多数安装了Python的系统中，都默认安装了Python解释器。

步骤三：在命令行中执行Python脚本

1. 打开命令行终端（Windows用户可按Win+R键，输入cmd后回车；Mac和Linux用户可以在Terminal应用中操作）。

2. 使用cd命令切换到你的Python脚本所在的目录。例如，如果hello.py位于桌面上，则可以输入：

   1. 对于Windows用户：cd C:\Users\YourUsername\Desktop

   2. 对于Mac/Linux用户：cd /Users/YourUsername/Desktop

3. 确认当前路径下有你的Python脚本文件，可以通过ls命令（Mac/Linux）或dir命令（Windows）查看。

4. 运行Python脚本，输入以下命令并回车：

python hello.py

如果一切正常，你应该能在命令行界面看到输出的"Hello, World!"。

进阶技巧

# hello.py 文件内容 
def main(): 
    print("Hello, World!") 

if __name__ == "__main__": 
    main()

在命令行中依然执行 python hello.py，由于if条件判断，main()函数会被自动执行。

import sys
def main(name):
    print(f"Hello, {name}!")
if 
name
 == "
__main__
":
    if len(sys.argv) > 1:
        main(sys.argv[1])
    else:
        print("Please provide a name.")

在命令行中执行 python hello.py Alice，将会输出 "Hello, Alice!"。

以上就是Python命令行执行文件的基本操作和一些进阶技巧。

多参数传递与处理

在实际开发中，我们常常需要向Python脚本传递多个命令行参数。Python的sys.argv列表提供了这样的功能，其中sys.argv[0]是脚本名本身，从sys.argv[1:]开始则是传入的参数。

下面是一个处理多参数的示例：

import sys
def main(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")
if 
name
 == "
__main__
":
    if len(sys.argv) > 2:
        # 提取命令行参数
        first_name = sys.argv[1]
        last_name = sys.argv[2]
        main(first_name, last_name)
    else:
        print("Please provide both first name and last name.")

保存上述代码为hello.py，然后在命令行中执行如下命令：

python hello.py Alice Smith

运行后，输出将是 "Hello, Alice Smith!"。

为了更优雅地处理命令行参数，Python还提供了一个强大的第三方库 argparse，可以用来创建用户友好的命令行接口：

import argparse
def main(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")
if 
name
 == "
__main__
":
    # 创建解析器
    parser = argparse.ArgumentParser(description="Say hello to someone.")
    parser.add_argument('first_name', help='The person\'s first name')
    parser.add_argument('last_name', help='The person\'s last name')
    # 解析参数
    args = parser.parse_args()
    # 使用解析后的参数调用主函数
    main(args.first_name, args.last_name)

安装argparse命令

pip install argparse

同样，在命令行中执行 python hello.py Alice Smith，效果和前面的例子一样，但通过argparse库，你可以添加更复杂、更灵活的参数选项和验证逻辑。

接下来我们展示如何使用argparse处理更多复杂场景，例如添加可选参数和参数组：

import argparse
def main(first_name, last_name, greeting='Hello', age=None):
    if age:
        print(f"{greeting}, {first_name} {last_name}, you are {age} years old!")
    else:
        print(f"{greeting}, {first_name} {last_name}!")
if 
name
 == "
__main__
":
    # 创建解析器
    parser = argparse.ArgumentParser(description="Say hello to someone.")

    # 添加必需的参数
    parser.add_argument('first_name', help='The person\'s first name')
    parser.add_argument('last_name', help='The person\'s last name')
    # 添加一个可选的问候语参数，默认为"Hello"
    parser.add_argument('-g', '--greeting', default='Hello', help='The greeting message')
    # 添加一个可选的年龄参数，并设置类型为整数
    parser.add_argument('-a', '--age', type=int, help='The person\'s age')
    # 解析命令行参数
    args = parser.parse_args()
    # 使用解析后的参数调用主函数
    main(args.first_name, args.last_name, args.greeting, args.age)

现在在命令行中执行脚本时，你可以提供更多的选项：

通过这种方式，你的Python脚本可以更加灵活地处理多种输入参数，提高其可用性和扩展性。 当然，我们可以进一步扩展argparse的使用，包括添加标志参数、设置参数默认值、以及定义参数组以更好地组织和解释命令行选项：

import argparse
def main(first_name, last_name, greeting='Hello', verbose=False, age=None):
    if verbose:
        print(f"Executing with the following parameters: first_name={first_name}, last_name={last_name}, greeting={greeting}, age={age}")

    if age:
        message = f"{greeting}, {first_name} {last_name}, you are {age} years old!"
    else:
        message = f"{greeting}, {first_name} {last_name}!"
    print(message)
if 
name
 == "
__main__
":
    # 创建解析器
    parser = argparse.ArgumentParser(description="Say hello to someone.")

    # 添加必需的参数
    parser.add_argument('first_name', help='The person\'s first name')
    parser.add_argument('last_name', help='The person\'s last name')
    # 添加一个可选的问候语参数，默认为"Hello"
    parser.add_argument('-g', '--greeting', default='Hello', help='The greeting message')
    # 添加一个布尔型标志参数，用于控制详细输出
    parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output for debugging purposes')
    # 添加一个名为'optional'的参数组，并在其中定义年龄参数
    group_optional = parser.add_argument_group('Optional arguments')
    group_optional.add_argument('-a', '--age', type=int, help='The person\'s age')
    # 解析命令行参数
    args = parser.parse_args()
    # 使用解析后的参数调用主函数
    main(args.first_name, args.last_name, args.greeting, args.verbose, args.age)

现在，你可以通过-v或--verbose来开启详细的调试信息输出：

python hello.py Alice Smith -v -a 30

这样运行脚本将会显示详细的参数信息，然后再执行正常的问候逻辑。这个例子展示了如何利用argparse提供的强大功能来设计和实现复杂的命令行接口。

我们还可以进一步扩展argparse的功能，包括处理列表类型的参数。以下是一个示例，该脚本接受一个或多个兴趣爱好作为参数：

import argparse
def main(first_name, last_name, greeting='Hello', verbose=False, age=None, hobbies=[]):
    if verbose:
        print(f"使用以下参数执行: first_name={first_name}, last_name={last_name}, greeting={greeting}, age={age}, hobbies={hobbies}")
    if age:
        message = f"{greeting}, {first_name} {last_name}, you are {age} years old and enjoy {', '.join(hobbies)}."
    else:
        message = f"{greeting}, {first_name} {last_name}. You enjoy {', '.join(hobbies)}."
    print(message)
if 
name
 == "
__main__
":
    # 创建解析器
    parser = argparse.ArgumentParser(description="Say hello to someone.")

    # 添加必需的参数
    parser.add_argument('first_name', help='The person\'s first name')
    parser.add_argument('last_name', help='The person\'s last name')
    # 添加可选的问候语参数，默认为"Hello"
    parser.add_argument('-g', '--greeting', default='Hello', help='The greeting message')
    # 添加布尔型标志参数用于详细输出
    parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output for debugging purposes')
    # 添加年龄参数
    parser.add_argument('-a', '--age', type=int, help='The person\'s age')
    # 添加一个名为'hobbies'的列表类型参数，可以多次指定
    parser.add_argument('-H', '--hobby', action='append', help='A hobby of the person')
    # 解析命令行参数
    args = parser.parse_args()
    # 使用解析后的参数调用主函数
    main(args.first_name, args.last_name, args.greeting, args.verbose, args.age, args.hobby)

现在，你可以通过多次指定--hobby来传递多个兴趣爱好：

python hello.py Alice Smith -v -a 30 --hobby reading --hobby painting --hobby hiking

我们还可以进一步丰富命令行参数的处理，比如添加子命令功能和文件输入输出的支持。下面是一个包含子命令和从文件读取参数的例子：

import argparse
import json
def greet(first_name, last_name, greeting='Hello', hobbies=None):
    if hobbies:
        hobby_message = f" and enjoy {', '.join(hobbies)}"
    else:
        hobby_message = ""
    print(f"{greeting}, {first_name} {last_name}{hobby_message}.")
def load_params_from_file(filename):
    try:
        with open(filename) as file:
            params = json.load(file)
            return params
    except FileNotFoundError:
        print(f"Error: The file '{filename}' does not exist.")
        sys.exit(1)
    except json.JSONDecodeError:
        print("Error: Unable to parse the provided file. Please ensure it contains valid JSON.")
        sys.exit(1)
def main():
    parser = argparse.ArgumentParser(description="Say hello to someone.")

    # 添加子命令功能
    subparsers = parser.add_subparsers(title="subcommands", dest="command")
    # 创建'greet'子命令解析器
    greet_parser = subparsers.add_parser('greet', help="Greet a person")
    greet_parser.add_argument('first_name', help='The person\'s first name')
    greet_parser.add_argument('last_name', help='The person\'s last name')
    greet_parser.add_argument('-g', '--greeting', default='Hello', help='The greeting message')
    greet_parser.add_argument('-H', '--hobby', action='append', help='A hobby of the person')
    # 创建'from-file'子命令解析器
    from_file_parser = subparsers.add_parser('from-file', help="Read parameters from a JSON file")
    from_file_parser.add_argument('filename', help='Path to the JSON file containing parameters')
    args = parser.parse_args()
    if args.command == 'greet':
        greet(args.first_name, args.last_name, args.greeting, args.hobby)
    elif args.command == 'from-file':
        params = load_params_from_file(args.filename)
        greet(params['first_name'], params['last_name'], params.get('greeting', 'Hello'), params.get('hobbies', []))
if 
name
 == "
__main__
":
    main()

现在，你可以通过greet子命令直接提供参数，或者通过from-file子命令从JSON文件中读取参数：

# 使用'greet'子命令
python hello.py greet Alice Smith -g "Hi" --hobby reading --hobby writing

# 从JSON文件加载参数
python hello.py from-file parameters.json

其中，parameters.json的内容可以是：

{
  "first_name": "Alice",
  "last_name": "Smith",
  "greeting": "Greetings!",
  "hobbies": ["reading", "writing"]
}

这样，我们的Python脚本在命令行中的功能就变得更加丰富和灵活了。

我们还可以进一步增强命令行工具的功能，例如添加环境变量的支持以及处理不同类型的输入输出格式。以下是一个读取环境变量和接受CSV文件作为输入的示例：

import argparse
import csv
def process_data(data, greeting='Hello'):
    for first_name, last_name in data:
        print(f"{greeting}, {first_name} {last_name}!")
def main():
    parser = argparse.ArgumentParser(description="Say hello to a list of people from input.")

    # 添加从变量获取默认问候语
    default_greeting = 'Hello'
    parser.add_argument('-g', '--greeting', default=default_greeting, help='The greeting message (default: $default_greeting)')
    # 添加读取CSV文件作为输入参数
    parser.add_argument('input_file', type=argparse.FileType('r'), help='A CSV file containing names separated by commas')
    args = parser.parse_args()
    reader = csv.reader(args.input_file)
    data = [row for row in reader if len(row) == 2]  # 假设每行包含两个字段：first_name 和 last_name
    process_data([tuple(row) for row in data], args.greeting)
if 
name
 == "
__main__
":
    main()

现在，这个脚本可以读取环境变量DEFAULT_GREETING设置默认的问候语，并通过命令行接收一个CSV文件路径作为参数。CSV文件中的每一行应包含两个人名（用逗号分隔）。运行脚本时，它会依次对每一个人发出问候。

创建一个名为names.csv的文件，内容如下：

Alice,Smith

Bob,Doe

Charlie,Wong

最后执行脚本：

python hello.py names.csv

输出结果将会是：

Hello, Alice Smith! 
Hello, Bob Doe! 
Hello, Charlie Wong!

这展示了如何在Python命令行工具中整合多种功能，包括环境变量、文件输入以及数据处理等。

作者：HAMYHF