精华内容
下载资源
问答
  • 今天小编就为大家分享一篇python 判断linux进程,并杀死进程的实现方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 主要介绍了使用Python获取Linux系统的各种信息,例如系统类型、CPU信息、内存信息、块设备等,需要的朋友可以参考下
  • 如下所示: ''' @author: Jacobpc ''' import os ...else: sys.exit(1) 以上这篇python 判断linux进程,并杀死进程的实现方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持聚米学院。

    如下所示:

    '''

    @author: Jacobpc

    '''

    import os

    import sys

    import subprocess

    def get_process_id(name):

    child = subprocess.Popen(["pgrep","-f",name],stdout=subprocess.PIPE,shell=False)

    response = child.communicate()[0]

    return response

    pid = get_process_id("python socialbanklog.py")

    print pid

    if not pid:

    print "no target pid to kill,please check"

    sys.exit(1)

    result=os.system("kill -9 "+pid)

    if result==0:

    print "execute kill success"

    else:

    sys.exit(1)

    以上这篇python 判断linux进程,并杀死进程的实现方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持聚米学院。

    展开全文
  • python代码获取linux进程pid

    千次阅读 2018-12-20 20:47:42
    python代码获取linux进程pid 在某些需求中,我们需要根据某些条件动态的执行或者停止某程序(linux环境下),对于动态执行,一般没有什么难度。 开始某程序:需要知道程序的路径,以及对应的.py文件 os.system(‘cd ...

    python代码获取linux进程pid

    在某些需求中,我们需要根据某些条件动态的执行或者停止某程序(linux环境下),对于动态执行,一般没有什么难度。

    开始某程序:需要知道程序的路径,以及对应的.py文件

    os.system(‘cd {} && python {}’.format(file_path,a.py))

    上面就是表明执行a.py文件

    动态停止某程序。

    上网搜索好久,一般推荐的方法都是安装 psutil,

    import  psutil;
    for proc in psutil.process_iter():
        print("pid-%d,name:%s" % (proc.pid,proc.name()))
    
    #执行结果
    pid-1,name:systemd
    pid-2,name:kthreadd
    pid-3,name:ksoftirqd/0
    pid-5,name:kworker/0:0H
    pid-6,name:kworker/u12:0
    pid-7,name:rcu_sched
    pid-8,name:rcu_bh
    pid-9,name:migration/0
    pid-10,name:watchdog/0
    pid-11,name:watchdog/1
    pid-12,name:migration/1
    pid-13,name:ksoftirqd/1
    pid-15,name:kworker/1:0H
    pid-16,name:watchdog/2
    pid-17,name:migration/2
    pid-18,name:ksoftirqd/2
    pid-20,name:kworker/2:0H
    pid-21,name:watchdog/3
    pid-22,name:migration/3
    pid-23,name:ksoftirqd/3
    pid-25,name:kworker/3:0H
    pid-26,name:watchdog/4
    pid-27,name:migration/4
    

    但在实际操作中发现,此种方法并不能解决想要获取pid的问题。因为其后面显示的信息并不精确。比如我们python执行两个.py文件,则结果中的name:python,会出现两个,这样我们如何能获得pid?

    实际:

    import os
    pid=os.popen('ps -ef | grep  main.py ').readlines()[0].split()[1]
    #此处的popen会把命令的输出作为返回值,我们再采用读文件的形式再根据实际情况进行分割,取其下标即可
    #此处补充os.system(cmd) 返回值只会有0(成功),1,2
    print(pid)
    
    #执行结果
    19212
    
    展开全文
  • pythonLinux下使用top命令获取进程信息进行分析做可视化展示 版本 版本 作者 日期 备注 v1.0 ZY 2020.11.10 初版完成 文章目录pythonLinux下使用top命令获取进程信息进行分析做可视化展示版本一、...

    python将Linux下使用top命令获取的进程信息进行分析做可视化展示

    版本

    版本作者日期备注
    v1.0ZY2020.11.10初版完成

    一、目标

    Linux下我们通常使用top命令过滤某个进程获取该进程的内存以及CPU占用等信息,而进行长时间拷机时更可以将该信息重定向到文件中,拷机完成后我们直接分析该文件查看内存是否稳定,cpu占用是否存在飙升等,目前大数据分析火热的情况,我们想到将该文件数据做下简单的大数据分析,将常用数据利用python做下分析后以图表的形式展现出来并写入excel形成一次拷机的分析文档,这样将中间分析过程以及结果的归档过程代码化、自动化了,后续回溯也变得很方便了。

    二、源码

    (1)、top命令简单说明:

    top ? 或者top -h之后:
    Usage: top [ -m max_procs ] [ -n iterations ] [ -d delay ] [ -s sort_column ] [ -t ] [ -h ]
        -m num  Maximum number of processes to display.
        -n num  Updates to show before exiting.
        -d num  Seconds to wait between updates.
        -s col  Column to sort by (cpu,vss,rss,thr).
        -t      Show threads instead of processes.
        -h      Display this help screen.
    

    (2)、常用的top获取信息并存储文件

    将process进程的信息获取并存储到top文件:
    top | grep process > ./top
    

    (3)、python处理思路

    • 读取top文件获取原始数据
    • 简单清洗原始数据,获取需要进行分析的cpu等字段信息并转换成int/float等便于进行数据计算的数据类习惯
    • 关键字段进行数学运算,比如计算最大值、最小值、平均值等
    • 将内存等信息变化过程利用图表展示出来
    • 将分析结果写入excel
    • 将python脚本打包,比如Windows下的exe,使得不用安装python环境即可运行

    (4)、小技巧

    • 传入top文件时使用外部传参的方式获取任意名称的top文件,这样打包成exe后拖入任意名称的top文件即可
    • pandas的excel处理会覆盖sheet,因此需要结合openpyxl进一步处理excel

    (5)、源码

    思路清晰之后,结合python丰富的包,代码只有100+行,很方便,这里没有做过多的函数封装,后续可以优化一下(试用了pandas、openpyxl、matplotlib等):

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    # @Time    : 2020/11/6 0006 9:24
    # @Author  : ZY
    
    import time
    import sys
    import openpyxl
    import pandas as pd
    from openpyxl import load_workbook
    import matplotlib.pyplot as plt
    from openpyxl.drawing.image import Image
    
    
    def add_sheet(data, excel_writer, sheet_name):
        """
        不改变原有Excel的数据,新增sheet。
        注:
            使用openpyxl操作Excel时Excel必需存在,因此要新建空sheet
            无论如何sheet页都会被新建,只是当sheet_name已经存在时会新建一个以1结尾的sheet,如:test已经存在时,新建sheet为test1,以此类推
        :param data: DataFrame数据
        :param excel_writer: 文件路径
        :param sheet_name: 新增的sheet名称
        :return:
        """
        book = load_workbook(excel_writer.path)
        excel_writer.book = book
        data.to_excel(excel_writer=excel_writer, sheet_name=sheet_name, index=None, header=True)
    
        excel_writer.close()
    
    
    # pandas读取top文件
    if len(sys.argv) == 2:
        original_data = pd.read_csv(sys.argv[1], sep='\\s+', encoding='utf-8')
    else:
        print("参数个数错误,请指定解析文件")
        sys.exit(-1)
    
    # 以当前时间创建文件名
    path = './' + 'top数据分析结果_' + time.strftime("%Y%m%d%H%M%S") + '.xlsx'
    print(path)
    
    # 创建空excel,添加sheet的接口必须文件存在
    excel_write = pd.ExcelWriter(path, engine='openpyxl')
    pd.DataFrame().to_excel(path, sheet_name='Sheet1')
    
    # 可能存储的top文件没有线程调度策略这一项
    if original_data.shape[1] == 10:
        original_data.columns = ['进程id(PID)', '进程优先级(PR)', 'CPU占用率(CPU%)', '进程状态(S)', '线程数(#THR)',
                                 '虚拟内存(VSS)', '实际使用的物理内存(RSS)', '线程调度策略(PCY)', '进程所有者的ID(UID)', '进程名字(Name)']
    elif original_data.shape[1] == 9:
        original_data.columns = ['进程id(PID)', '进程优先级(PR)', 'CPU占用率(CPU%)', '进程状态(S)', '线程数(#THR)',
                                 '虚拟内存(VSS)', '实际使用的物理内存(RSS)', '进程所有者的ID(UID)', '进程名字(Name)']
    print(original_data)
    
    # 删除有空值的一行,即取出最后一列进程名字不为空的数据
    topdata = original_data[original_data['进程名字(Name)'].notna()].copy()
    print(topdata)
    
    # 去除CPU占用中的%和内存中的K
    topdata['CPU占用率(CPU%)'].replace(regex=True, inplace=True, to_replace='%', value='')
    topdata['实际使用的物理内存(RSS)'].replace(regex=True, inplace=True, to_replace='K', value='')
    # 转换类型为int/float
    topdata['CPU占用率(CPU%)'] = topdata['CPU占用率(CPU%)'].astype('float64')
    topdata['实际使用的物理内存(RSS)'] = topdata['实际使用的物理内存(RSS)'].astype('float64')
    
    # 计算统计结果
    min_mem = topdata['实际使用的物理内存(RSS)'].min()
    max_mem = topdata['实际使用的物理内存(RSS)'].max()
    avg_mem = round(topdata['实际使用的物理内存(RSS)'].mean(), 2)
    statistical_res = {'统计结果': ['总行数:' + str(len(topdata)),
                                'ky_stb PID:' + str(topdata.iat[0, 0]),
                                '运行时长:' + str(round(len(topdata) * 3 / 60 / 60, 2)) + 'h',
                                'ky_stb重启次数:' + str(topdata['进程id(PID)'].value_counts().count() - 1),
                                '最小CPU:' + str(topdata['CPU占用率(CPU%)'].min()) + '%',
                                '最大CPU:' + str(topdata['CPU占用率(CPU%)'].max()) + '%',
                                '平均CPU:' + str(round(topdata['CPU占用率(CPU%)'].mean(), 2)) + '%',
                                '最小内存:' + str(min_mem) + 'KB' + '(' + str(round(min_mem / 1024, 2)) + 'M)',
                                '最大内存:' + str(max_mem) + 'KB' + '(' + str(round(max_mem / 1024, 2)) + 'M)',
                                '平均内存:' + str(avg_mem) + 'KB' + '(' + str(round(avg_mem / 1024, 2)) + 'M)']}
    
    # 将内存数据转换为折线图并存储为图片
    mem_show = pd.DataFrame(topdata['实际使用的物理内存(RSS)'], index=topdata.index)
    fig = plt.figure()
    # 设置字体,防止默认字体不存在告警以及显示方块
    plt.rcParams['font.sans-serif'] = ['SimHei']
    ax = fig.add_subplot(1, 1, 1)
    mem_show.plot(ax=ax)
    fig.savefig('mem.png')
    
    # 将统计结果放入新sheet中
    add_sheet(pd.DataFrame(statistical_res), excel_write, sheet_name='统计结果')
    # 添加清洗后的未分析数据到excel的新sheet中
    add_sheet(pd.DataFrame(topdata), excel_write, sheet_name='原始top数据清洗结果')
    # 添加最原始的数据
    add_sheet(pd.DataFrame(original_data), excel_write, sheet_name='原始top数据')
    # 保存之前的修改
    excel_write.save()
    
    # 删除创建时的空sheet
    excel_file = path
    wb = openpyxl.load_workbook(excel_file)
    ws = wb['Sheet1']
    wb.remove(ws)
    # 设置统计结果列的列宽
    ws = wb[wb.sheetnames[0]]
    ws.column_dimensions['A'].width = 50
    # 插入内存处理后的图片到D3位置
    img = Image('mem.png')
    ws.add_image(img, 'D3')
    
    wb.save(excel_file)
    

    (6)、打包

    使用pyinstaller打包:
    (这个是其官网,可以总体了解一下:http://www.pyinstaller.org)

    pip install pyinstaller
    pyinstaller -F xxx.py
    

    打包后的exe在生成的dist目录下。

    期间打包后运行报错:could not find the matplotlib data files,最后发现是matplotlib版本和pyinsteller版本不匹配导致的,我这里重新安装3.1.1即可:

    pip uninstall matplotlib
    pip install matplotlib==3.1.1
    

    三、最后

    python流行自有其原因,丰富的包确实让开发应用快捷很多,但是其执行效率和打包后的大小确实也比较大。总体来说,python及数据处理是值得下功夫琢磨的。

    展开全文
  • usr/bin/env python # -*- coding: utf-8 -*- import socket import psutil class NodeResource(object): def get_host_info(self): host_name = socket.gethostname() return {'host_name':host_name} def get_...
  • 使用 Python 获取 Linux 系统信息

    千次阅读 2013-11-10 16:56:52
    使用 Python 获取 Linux 系统信息 2013/08/02 | 分类: 程序员 | 0 条评论 | 标签: LINUXPYTHON 分享到:30 原文出处: Linux System Mining with Python 译文出处: oschina 在...

    使用 Python 获取 Linux 系统信息

    原文出处:  Linux System Mining with Python   译文出处:  oschina

    在本文中,我们将会探索使用Python编程语言工具来检索Linux系统各种信息。走你。

    探索platform模块

    platform模块在标准库中,它有很多运行我们获得众多系统信息的函数。让我们运行Python解释器来探索它们中的一些函数,那就从platform.uname()函数开始吧:

    1
    2
    3
    >>> import platform
    >>> platform.uname()
    ( 'Linux' , 'fedora.echorand' , '3.7.4-204.fc18.x86_64' , '#1 SMP Wed Jan 23 16:44:29 UTC 2013' , 'x86_64' )

    如果你已知道linux上的uname命令,那么你就会认出来这个函数就是这个命令的一个接口。在Python 2上,它会返回一个包含系统类型(或者内核版本),主机名,版本,发布版本,机器的硬件以及处理器信息元组(tuple)。你可以使用下标访问个别属性,像这样:

    1
    2
    >>> platform.uname()[ 0 ]
    'Linux'

    在Python 3上,这个函数返回的是一个命名元组:

    1
    2
    3
    4
    5
    >>> platform.uname()
     
    uname_result(system = 'Linux' , node = 'fedora.echorand' ,
    release = '3.7.4-204.fc18.x86_64' , version = ' #1 SMP Wed Jan 23 16:44:29
    UTC 2013 ', machine=' x86_64 ', processor=' x86_64')

    因为返回结果是一个命名元组,这就可以简单地通过名字来指定特定的属性,而不是必须记住下标,像这样:

    1
    2
    >>> platform.uname().system
    'Linux'

    platform模块还有一些上面属性的直接接口,像这样:

    1
    2
    3
    4
    5
    >>> platform.system()
    'Linux'
     
    >>> platform.release()
    '3.7.4-204.fc18.x86_64'

    linux_distribution()函数返回的有关你所在的linux发布版本的详细信息。例如,在Fedora 18系统上,这个命令会返回如下信息:

    1
    2
    >>> platform.linux_distribution()
    ( 'Fedora' , '18' , 'Spherical Cow' )

    这个返回结果中包含了版本发布名,版本以及代号元组。特定的Python版本支持的发布版本上可以通过_supported_dists显示的值获得。

    1
    2
    3
    4
    >>> platform._supported_dists
    ( 'SuSE' , 'debian' , 'fedora' , 'redhat' , 'centos' , 'mandrake' ,
    'mandriva' , 'rocks' , 'slackware' , 'yellowdog' , 'gentoo' ,
    'UnitedLinux' , 'turbolinux' )

    如果你的linux发布版本不在其中(或者其中之一的衍生发行版)。那么你很可能调用了上面这个函数而看不到任何有用的信息。

    platform模块的最后一个函数,我们将会看看architecture()函数。当你无参的调用这个函数,它会返回包含架构位数以及python可执行的格式的元组,像这样:

    1
    2
    >>> platform.architecture()
    ( '64bit' , 'ELF' )

    在32位的系统上,你将会看到:

    1
    2
    >>> platform.architecture()
    ( '32bit' , 'ELF' )

    如果你指定了系统上其他任何可执行的,你都将会获得相似的结果,如同这样:

    1
    2
    >>> platform.architecture(executable = '/usr/bin/ls' )
    ( '64bit' , 'ELF' )

    鼓励探索platform模块的除了这些的其它函数,找出你现在运行的Python版本。如果你想知道这个模块是如何获取这些信息的,你可以深入查看PYthon源码目录下的Lib/platform.py文件。

    os和sys模块也可以获得一些系统属性,例如原生的字节序。接下来,我们超越Python标准库模块,去探索一些在linux系统通过proc和sysfs文件系统使之访问信息成为可能。注意的是通过文件系统来访问信息将会在不同的硬件架构有所不同。所以在读本文或是写脚本时要时刻记住可以试图从这些文件获取信息。

    CPU信息

    /proc/cpuinfo文件包含了你的系统处理器单元的信息。例如,这里就是python版的linux命令cat /proc/cpuinfo所做的事:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #! /usr/bin/env python
    """ print out the /proc/cpuinfo
         file
    """
     
    from __future__ import print_function
     
    with open ( '/proc/cpuinfo' ) as f:
         for line in f:
             print (line.rstrip( '\n' ))

    当你使用Python 2 或者 Python 3执行这个程序时,你会在屏幕上看到所有/proc/cpuinfo的内容(在上面的程序里,rstrip()方法用来删除每行末尾的换行符)
    在下面的代码里列举了使用startwith()字符串方法来显示你的处理器单元的模式。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #! /usr/bin/env python
     
    """ Print the model of your
         processing units
     
    """
     
    from __future__ import print_function
     
    with open ( '/proc/cpuinfo' ) as f:
         for line in f:
             # Ignore the blank line separating the information between
             # details about two processing units
             if line.strip():
                 if line.rstrip( '\n' ).startswith( 'model name' ):
                     model_name = line.rstrip( '\n' ).split( ':' )[ 1 ]
                     print (model_name)

    当你运行这个程序后,你应该会看到你的每个处理器单元的模式名。例如,这里就是在我电脑上所看到的。

    1
    2
    3
    4
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz

    迄今为止,我们已有两种方式来找出我们所使用的系统的架构。从技术上讲是正确的,两个方 式实际上报告了你系统运行的内核架构,所以,如果你的电脑是64位的,但是运行的是32位的内核,然后上面的方法还是将会显示为32位的架构。你可以通过从/proc/cpuinfo所列举的标志中查找lm标志,来找到你的电 脑的真实的架构。lm标志代表了长模式,只有64位架构的才会显示它。下面的程序将会指导你怎样做:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    #! /usr/bin/env python
     
    """ Find the real bit architecture
    """
     
    from __future__ import print_function
     
    with open ( '/proc/cpuinfo' ) as f:
         for line in f:
             # Ignore the blank line separating the information between
             # details about two processing units
             if line.strip():
                 if line.rstrip( '\n' ).startswith( 'flags' ) \
                         or line.rstrip( '\n' ).startswith( 'Features' ):
                     if 'lm' in line.rstrip( '\n' ).split():
                         print ( '64-bit' )
                     else :
                         print ( '32-bit' )

    如我们所看到那样,读取/proc/cpuinfo文件以及使用简单文本处理技术就可以获得我们要查找的数据是可能的。为了给其他程序更好的使用这些数据,一个更好的主意就是使/proc/cpuinfo的内容成为标准的数据结构,譬如字典(dictionary)。这个注意很简单:如果你查看这个文件的内容,你就会发现对于每个处理器单元,都有好些键值对(在先前的例子中,我们打印了每个处理器的模型名,即模型名就是关键字)。不同的处理器单元的信息可以使用空白行隔开。构造一个字典数据结构包含每个处理器单元的关键字是很简单的。对于每个关键字,对于处理器单元的值都在/proc/cpuinfo文件中。下面的代码将会指导你怎么做。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    #!/usr/bin/env/ python
     
    """
    /proc/cpuinfo as a Python dict
    """
    from __future__ import print_function
    from collections import OrderedDict
    import pprint
     
    def cpuinfo():
         ''' Return the information in /proc/cpuinfo
         as a dictionary in the following format:
         cpu_info['proc0']={...}
         cpu_info['proc1']={...}
     
         '''
     
         cpuinfo = OrderedDict()
         procinfo = OrderedDict()
     
         nprocs = 0
         with open ( '/proc/cpuinfo' ) as f:
             for line in f:
                 if not line.strip():
                     # end of one processor
                     cpuinfo[ 'proc%s' % nprocs] = procinfo
                     nprocs = nprocs + 1
                     # Reset
                     procinfo = OrderedDict()
                 else :
                     if len (line.split( ':' )) = = 2 :
                         procinfo[line.split( ':' )[ 0 ].strip()] = line.split( ':' )[ 1 ].strip()
                     else :
                         procinfo[line.split( ':' )[ 0 ].strip()] = ''
     
         return cpuinfo
     
    if __name__ = = '__main__' :
         cpuinfo = cpuinfo()
         for processor in cpuinfo.keys():
             print (cpuinfo[processor][ 'model name' ])

    这段代码中使用了OrderedDict(有序字典)而不是常规的字典,能够使用键值有序的存储在文件里。所以,第一个处理器单元的数据之后就是第二个处理器单元的数据,以此类推。你可以使用过滤器来过滤你所查找的信息(如同在if __name__ == ‘__main__’块中演示的那样)。上面的程序每次执行后都会打印每个处理器单元的模型名(如通过cpuinfo[processor]['model name']语句表明的那样)

    1
    2
    3
    4
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz
    Intel(R) Core(TM) i7-3520M CPU @ 2 .90GHz

    内存信息

    和/proc/cpuinfo相似,文件/proc/meminfo包含了你电脑的主存的信息。下面的这个程序创建了一个使用这个文件的内容填充的字典。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #!/usr/bin/env python
     
    from __future__ import print_function
    from collections import OrderedDict
     
    def meminfo():
         ''' Return the information in /proc/meminfo
         as a dictionary '''
         meminfo = OrderedDict()
     
         with open ( '/proc/meminfo' ) as f:
             for line in f:
                 meminfo[line.split(