python命令行执行方法及技巧分享

目录

• 引言
• 步骤一：编写python脚本
• 步骤二：理解Python解释器
• 步骤三：在命令行中执行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脚本

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

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

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

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

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

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

python hello.py

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

进阶技巧

• 指定Python版本执行：如果你的电脑上安装了多个Python版本，可以通过指定完整路径来选择使用哪个版本的Python解释器执行脚本，如 C:\Python37\python.exe hello.py。

• 模块化执行：如果你的Python脚本定义了一个主函数（如main()），可以在命令行中直接调用该函数，这通常在大型项目中更为常见：

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

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

• 命令行参数传递：Python还允许我们在命令行中向脚本传递参数，这些参数可以通过sys.argv访问。例如：

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_phpname}!")
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 hello.py Alice Smith

• 自定义问候语：python hello.py Alice Smith -g "Hi there"

• 提供年龄信息：python hello.py Alice Smith -a 30

• 同时指定问候语和年龄：python hello.py Alice Smith -g "Hey" -a 25

通过这种方式，你的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 djsebugging 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)}."
    e编程lse:
        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} {lasjavascriptt_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命令行工具中整合多种功能，包括环境变量、文件输入以及数据处理等。

总结

到此这篇关于python命令行执行方法及技巧分享的文章就介绍到这了,更多相关python命令行执行内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！