Linux python运维
Python 是一种高级编程语言，它具有简单易学、可移植性强、丰富的第三方库等特点，因此成为了广泛应用于各个领域的编程语言之一。而在 Linux 系统中，Python 的使用也十分普遍。本文将介绍如何在 Linux 系统中执行 Python 脚本并传入参数，以及如何在 Python 中获取这些参数。
1. 在 Linux 中执行 Python 脚本
在 Linux 系统中执行 Python 脚本非常简单，只需在终端中输入以下命令：
“`bash
python script.py
“`其中，script.py 是你要执行的 Python 脚本的文件名。如果 Python 脚本位于当前目录下，则可以省略路径，直接输入文件名即可。
2. 在 Linux 中给 Python 脚本传入参数
如果你要给 Python 脚本传入参数，则可以在执行 Python 脚本的命令中添加参数。例如：
“`bash
python script.py arg1 arg2
“`上述命令中，arg1 和 arg2 就是传入的参数。在 Python 脚本中，可以使用 sys 模块获取这些参数。具体操作如下：
“`python
import sys
if __name__ == ‘__mn__’:
args = sys.argv[1:]
print(args)
“`上述代码中，sys.argv 是一个列表，其中之一个元素是 Python 脚本的文件名，而从第二个元素开始，便是传入的参数。因此，我们可以使用 sys.argv[1:] 将传入的参数提取出来，并打印出来。
3. 在 Python 中获取参数
上述方法虽然可以获取参数，但是获取到的参数都是以字符串的形式呈现，如果需要将参数转换为其他的数据类型，则需要进行特殊的处理。下面是几个示例：
比如：将参数转换为整数型
“`python
import sys
if __name__ == ‘__mn__’:
arg1 = int(sys.argv[1])
arg2 = int(sys.argv[2])
print(arg1 + arg2)
“`4、Python脚本在Linux上怎么运行
有两种方式：
1、直接使用python xxxx.py执行。其中python可以写成python的绝对路径。使用which python进行查询。
2、在文件的头部写上#!/usr/bin/python2.7，这个地方使用python的绝对路径，就是上面用which python查询来的结果。然后在外面就可以使用./xxx.py执行了。
因为在linux中，python是普通的文本格式，都需要一种程序取解释执行它。要么调用的时候指定，要么在文件头指定。
5、Python调用Shell命令
用Python调用Shell命令有如下几种方式：
1. os.system
os.system("The command you want"). |
|
os.system("lscpu"). |
|
os.system("ls -al"). |
这个调用相当直接，且是同步进行的，程序需要阻塞并等待返回。返回值是依赖于系统的，直接返回系统的调用返回值，所以windows和linux是不一样的。
2. os.popen
os.popen(command[,mode[,bufsize]]) |
可以看出，popen方法通过p.read()获取终端输出，而且popen需要关闭close().当执行成功时，close()不返回任何值，失败时，close()返回系统返回值. 可见它获取返回值的方式和os.system不同。
3. subprocess《Python文档中目前全力推荐》
subprocess使用起来同样简单：
直接调用命令，返回值即是系统返回。shell=True表示命令最终在shell中运行。Python文档中出于安全考虑，不建议使用shell=True。
二、使用步骤
python源码示例：
# -*- coding:utf-8 -*-
import os, subprocess, time
#该文件测试python嗲用shell的四种方法
current_workspace = os.path.join(os.path.dirname(os.path.abspath(__file__)))
workspace='/mnt/e/00.WORKSPACE/00.Python_Develop/ToolsLibrarByPython'
'''
os.system() 调用的C库
def system(command: StrOrBytesPath) -> int: ... 返回整数，返回0则表示执行成功
# os.system(str) 方法：
# 1.可以执行linux命令，可以加参数
# 2.可以执行shell脚本，也可以加参数
# 3.特别的，重定向可以直接通过linux重定向进行，
# 但是这样重定向输出局限于当前linux执行的服务器，无法重定向到当前程序执行的目录
'''
def excute_shell_by_os_system():
# cmd -> str
status = os.system('ls')
print(status)
#cmd命令，+参数（python str 语法加参数）
status = os.system('find %s -name "*.py"|sort' %workspace) #python str 占位符号
print(status)
status = os.system('find {} -type f'.format(workspace)) #python str.format()
print(status)
status = os.system(f"find {workspace} -type f") #python str f表达式
print(status)
#cmd 执行shell脚本
status = os.system('./shell_demo.sh')
print(status)
#cmd 执行带有参数的shell脚本
status = os.system('./shell_demo_with_param.sh %s' %workspace)
print(status)
#cmd 执行shell脚本, 重定向到某个文件
status = os.system('./shell_demo.sh > %s' %(os.path.join(current_workspace, 'log.txt')))
print(status)
#cmd 执行shell脚本, 终端输出同时写入
status = os.system('./shell_demo.sh|tee %s' %(os.path.join(current_workspace, 'log1.txt')))
print(status)
'''
os.popen(cmd)
return ：返回值是连接管道的文件对象
该方法返回linux命令执行的结果
read()方法返回,linux执行命令输出；
readline()方法返回第一行；
readlines()方法返回：
['total 28\n', '-rwxrwxrwx 1 root root 9000 Oct 19 23:04 log.txt\n',]
'''
def excute_shell_by_os_popen():
return_content = os.popen('ls -l')
#print(type(return_content.read())) # 注意：每次读取之后，就会释放，第二次就读取不到
print(return_content.read())
return_content = os.popen('ls -l')
print(return_content.readline())
print('-------------------------------------')
return_content = os.popen('ls -l')
print(return_content.readlines())
return_content = os.popen('./shell_demo.sh')
print(return_content.readline())
return_content = os.popen('./shell_demo.sh', 'r')
print(type(return_content))
return_content = os.popen('find {} -type f'.format(workspace))
print(return_content.readline())
'''
python 3已经用subprocess代替commands模块
Deprecated since version 2.6: The commands module has been removed in Python 3.
Use the subprocess module instead.'''
def excute_shell_by_commands():
pass
'''
return
'''
def excute_shell_by_subprocess():
result = subprocess.run('ls -l', shell=True)#默认打印linux执行结果
print("-------------------------------------")
print(result) #CompletedProcess(args='ls -l', returncode=0)
print(result.args) #ls -l
print(result.returncode) #0 表示执行成功
print(result.stdout) #默认传入None
print(result.stderr)#默认传入None
'''
文件重定向
'''
#使用linux自带的重定向输出将打印结果保存到文件中
result = subprocess.run('ls -l > %s'%(os.path.join(current_workspace, 'stdout_o.log')), shell=True)#保存到文件
result = subprocess.run('ls -l |tee %s'%(os.path.join(current_workspace, 'stdout_o.log')), shell=True)#打印并保存到文件
if result.returncode != 0:
print("excute '%s' failed!" % result.args)
else:
print("excute '%s' successful!!" % result.args)
#将终端打印的信息保存到文件中【输出内容和错误信息分别保存到对应的文件】
#stderr file对象
#stdout file对象
with open(os.path.join(current_workspace, 'stdout.log'), 'w') as f_o:
with open(os.path.join(current_workspace, 'stderr.log'), 'w') as f_e:
result = subprocess.run('ls -l', shell=True, stderr=f_e, stdout=f_o)
if result.returncode != 0:
print("excute '%s' failed!" % result.args)
else:
print("excute '%s' successful!!" % result.args)
print("--------------------------------------*****---------------------------------------------")
result1 = subprocess.run(['find', workspace,'-type','f'], shell=False) #特别注意这个位置 shell设置为False，否则不生效
print(result1)
result = subprocess.run('ls -l', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)# 返回变量
print(result)#return tuple(stdout, stderr)///tuple(bytes, bytes)
def excute_shell_by_subprocess_Popen():
#Popen
print("--------------------------------------**&&**---------------------------------------------")
# 实例化Popen对象，打印执行结果，但是进程未结束，一直处于等待中...
# result = subprocess.Popen(['ls', '-l'])# 若没指定stdout和stderr，会打印结果, communicate会返回None
result = subprocess.Popen(['ls', '-l'], shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE)# return
#简单说communicate() 和wait()的区别，使用 subprocess 模块的 Popen 调用外部程序，
#如果 stdout 或 stderr 参数是 pipe，并且程序输出超过操作系统的 pipe size时，
#如果使用 Popen.wait() 方式等待程序结束获取返回值，会导致死锁，程序卡在 wait() 调用上
#那死锁问题如何避免呢？官方文档里推荐使用 Popen.communicate()。这个方法会把输出放在内存，
#而不是管道里，所以这时候上限就和内存大小有关了，一般不会有问题。而且如果要获得程序返回值，
#可以在调用 Popen.communicate() 之后取 Popen.returncode 的值。
# Attributes:【stdin, stdout, stderr, pid, returncode】
print("-------------------------------@@@@@@@@-----------------------------------------------")
print(result.stdin)
print(result.stdout.read()) #<_io.BufferedReader name=3>
print(result.stderr.read()) #return error
print(result.pid) # return pid:224
print(result.returncode) # return int
print("-------------------------------@@@@@@@@-----------------------------------------------")
#function：【communicate(), wait(), terminate(), poll()】
result_communicate = result.communicate()# return
print(result_communicate)# return (bytes, bytes)
## 设置等待时间，终止进程
time.sleep(5) #设置一个等待时间，确保结果被打印
result.terminate() #终止进程
#该方法可以代替如上语句
result_wait = result.wait(time.sleep(2)) #等待 time.sleep(10)进程结束，在结束当前linux进程
print(result_wait) # return int
print(result.poll()) #return int; 检查当前进程是够结束，若结束则返回 0
# """Check if child process has terminated. Set and return returncode attribute."""
#subprocess another api
def excute_shell_by_subprocess_old_api():
result = subprocess.call(['ls', '-l']) #return , 0 success; 同时打印结果
print(result)# return 0
print("-------------------------------------------------------------------------------------")
result = subprocess.check_call(['ls', '-l'])#return , 0 success; 同时打印结果, same call()
print(result)
print("-------------------------------------------------------------------------------------")
result = subprocess.check_output(['ls', '-l'])#return ; 返回查询结果bytes
print(result)
print("-------------------------------------------------------------------------------------")
result = subprocess.getoutput(['ls', '-l'])#return ; 返回查询结果 str
##特别注意：当前返回结果，不包含 total:36(linux中显示当前所有文件的大小总和)
print(result)
print("-------------------------------------------------------------------------------------")
result = subprocess.getstatusoutput(['ls', '-l'])#return /(status, output) tuple
print(result)#status:int ; output: str
if __name__ == '__main__':
# demo
excute_shell_by_os_system()
excute_shell_by_os_popen()
excute_shell_by_subprocess()
excute_shell_by_subprocess_old_api()
excute_shell_by_subprocess_Popen()
几个关键注意点：
输入
字符串形式：cmd通过字符串格式输入，os、subprocess皆支持；特别注意参数传入，按照python的字符串要求传入即可（%s，str.format()，python3 f表达式）。
命令以列表形式传入：当前只有subprocess模块支持
执行linux结果
打印执行结果 ：os模块默认打印；subprocess.Popen()实例不指定stdout，stderr时候。
返回执行结果状态 ：os.system()；subprocess.run(cmd).returncode，subprocess.call(cmd)，subprocess.check_call(cmd)，subprocess.getstatusoutput()[0]
返回执行结果，可以将结果赋值给变量 :os.popen().raeds()；subprocess.Popen(cmd,stdout=subprocess.PIPE, stderr=subprocess.PIPE).run()，subprocess.check_output()，subprocess.getoutput()，subprocess.getstatusoutput()[1]
将执行结果打印到文件中：两种思路，一种是通过linux本身自带的重定向写入文件，另一种是使用subprocess指定stdout为本地文件即可
两个模块的对比：
返回结果：
os.system(cmd)，打印结果，返回执行结果状态（0执行成功）；
os.popen(cmd)，打印结果，同时返回执行结果（一个打开的文件对象）；
subprocess模块可以根据实际需求返回对应的结果。
使用场景：
os模块，常常用于简单的linux命令操作
subprocess模块，长用于shell等大型交付场景使用（个人建议直接使用该模块）
参考：
1、https://www.dbs724.com/340499.html
2、python3调用linux/shell—【标准库：os模块&subprocess模块】_subprocess.run_半斗烟草的博客-CSDN博客