在 Python 中 Ping 服务器

Question

在Python中，有没有办法通过ICMP ping服务器并在服务器响应时返回TRUE，如果没有响应则返回FALSE？

Answer 1

如果您不需要支持 Windows，这里有一个非常简洁的方法：

import os
param = '-n' if os.sys.platform().lower()=='win32' else '-c'
hostname = "google.com" #example
response = os.system(f"ping {param} 1 {hostname}")

#and then check the response...
if response == 0:
  print(f"{hostname} is up!")
else:
  print(f"{hostname} is down!")

此方法有效，因为如果连接失败，ping 将返回非零值。 （返回值实际上根据网络错误而有所不同。）您还可以使用“-t”选项更改 ping 超时（以秒为单位）。请注意，这会将文本输出到控制台。

Answer 2

此功能适用于任何操作系统（Unix、Linux、macOS 和 Windows）
Python 2 和 Python 3

编辑：
由 @radato os.system 替换为 subprocess.call 。这可以避免在主机名字符串可能无法验证的情况下出现 shell 注入漏洞。

import platform    # For getting the operating system name
import subprocess  # For executing a shell command

def ping(host):
    """
    Returns True if host (str) responds to a ping request.
    Remember that a host may not respond to a ping (ICMP) request even if the host name is valid.
    """

    # Option for the number of packets as a function of
    param = '-n' if platform.system().lower()=='windows' else '-c'

    # Building the command. Ex: "ping -c 1 google.com"
    command = ['ping', param, '1', host]

    return subprocess.call(command) == 0

请注意，根据 Windows 上的 @ikrase，此函数仍将返回 True 如果您收到目标主机无法访问 错误。

说明

该命令在 Windows 和类 Unix 系统中都是 ping。
选项 -n (Windows) 或 -c (Unix) 控制数据包数量，在本例中设置为 1。

platform.system() 返回平台名称。前任。 macOS 上的“达尔文”。
subprocess.call() 执行系统调用。前任。 subprocess.call(['ls','-l'])。

Answer 3

有一个名为 pyping 的模块可以做到这一点。它可以使用 pip 安装，

pip install pyping

使用起来非常简单，但是，在使用此模块时，您需要 root 访问权限，因为它是在幕后制作原始数据包。

import pyping

r = pyping.ping('google.com')

if r.ret_code == 0:
    print("Success")
else:
    print("Failed with {}".format(r.ret_code))

Answer 4

对于python3，有一个非常简单方便的python模块ping3：(pip install ping3 ，需要root权限）。

from ping3 import ping, verbose_ping
ping('example.com')  # Returns delay in seconds.
>>> 0.215697261510079666

该模块还允许自定义一些参数。

Answer 5

在python3中使用socket包：

import socket

def ping_server(server: str, port: int, timeout=3):
    """ping server"""
    try:
        socket.setdefaulttimeout(timeout)
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((server, port))
    except OSError as error:
        return False
    else:
        s.close()
        return True

Answer 6

import subprocess
ping_response = subprocess.Popen(["/bin/ping", "-c1", "-w100", "192.168.0.1"], stdout=subprocess.PIPE).stdout.read()

Answer 7

由于发送原始 ICMP 数据包需要提升权限，因此编程 ICMP ping 很复杂，而且调用 ping 二进制文件也很难看。对于服务器监控，您可以使用称为 TCP ping 的技术来实现相同的结果：

# pip3 install tcping
>>> from tcping import Ping
# Ping(host, port, timeout)
>>> ping = Ping('212.69.63.54', 22, 60)
>>> ping.ping(3)
Connected to 212.69.63.54[:22]: seq=1 time=23.71 ms
Connected to 212.69.63.54[:22]: seq=2 time=24.38 ms
Connected to 212.69.63.54[:22]: seq=3 time=24.00 ms

在内部，这只是建立到目标服务器的 TCP 连接并立即断开连接，测量所用的时间。这个特定的实现有一点限制，因为它不处理关闭的端口，但对于您自己的服务器来说，它工作得很好。

Answer 8

因为我想让我的 Python 程序在 2.7 和 3.x 版本以及 Linux、Mac OS 和 Windows 平台上通用，所以我必须修改现有的示例。

# shebang does not work over all platforms
# ping.py  2016-02-25 Rudolf
# subprocess.call() is preferred to os.system()
# works under Python 2.7 and 3.4
# works under Linux, Mac OS, Windows

def ping(host):
    """
    Returns True if host responds to a ping request
    """
    import subprocess, platform

    # Ping parameters as function of OS
    ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1"
    args = "ping " + " " + ping_str + " " + host
    need_sh = False if  platform.system().lower()=="windows" else True

    # Ping
    return subprocess.call(args, shell=need_sh) == 0

# test call
print(ping("192.168.17.142"))

Answer 9

我的 ping 函数版本：

• 适用于 Python 3.5 及更高版本、Windows 和 Linux。
• 在 Windows 上，如果 ping 命令失败并显示“目标主机无法访问”，则返回 False。
• 并且不显示任何输出，无论是作为弹出窗口还是在命令行中。

import platform, subprocess

def ping(host_or_ip, packets=1, timeout=1000):
    ''' Calls system "ping" command, returns True if ping succeeds.
    Required parameter: host_or_ip (str, address of host to ping)
    Optional parameters: packets (int, number of retries), timeout (int, ms to wait for response)
    Does not show any output, either as popup window or in command line.
    Python 3.5+, Windows and Linux compatible
    '''
    # The ping command is the same for Windows and Linux, except for the "number of packets" flag.
    if platform.system().lower() == 'windows':
        command = ['ping', '-n', str(packets), '-w', str(timeout), host_or_ip]
        # run parameters: capture output, discard error messages, do not show window
        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, creationflags=0x08000000)
        # 0x0800000 is a windows-only Popen flag to specify that a new process will not create a window.
        # On Python 3.7+, you can use a subprocess constant:
        #   result = subprocess.run(command, capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
        # On windows 7+, ping returns 0 (ok) when host is not reachable; to be sure host is responding,
        # we search the text "TTL=" on the command output. If it's there, the ping really had a response.
        return result.returncode == 0 and b'TTL=' in result.stdout
    else:
        command = ['ping', '-c', str(packets), '-w', str(timeout), host_or_ip]
        # run parameters: discard output and error messages
        result = subprocess.run(command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        return result.returncode == 0

请随意使用它。

Answer 10

环顾四周后，我最终编写了自己的 ping 模块，该模块旨在监视大量地址，是异步的，并且不使用大量系统资源。您可以在这里找到它：https://github.com/romana/multi-ping/它已获得 Apache 许可，因此您可以按照您认为合适的任何方式在项目中使用它。

实现我自己的方法的主要原因是其他方法的限制：

• 这里提到的许多解决方案都需要执行命令行实用程序。如果您需要监控大量 IP 地址，那么这是非常低效且占用资源的。
• 其他人提到了一些较旧的 python ping 模块。我查看了这些，最后发现它们都存在一些问题（例如未正确设置数据包 ID），并且无法处理大量地址的 ping 操作。

Answer 11

#!/usr/bin/python3

import subprocess as sp

def ipcheck():
    status,result = sp.getstatusoutput("ping -c1 -w2 " + str(pop))
    if status == 0:
        print("System " + str(pop) + " is UP !")
    else:
        print("System " + str(pop) + " is DOWN !")


pop = input("Enter the ip address: ")
ipcheck()

Answer 12

如果您的服务器不支持 ICMP（防火墙可能会阻止它），它很可能仍然在 TCP 端口上提供服务。在这种情况下，您可以执行TCP ping¹（独立于平台，无需安装额外的Python模块），如下所示：

import socket

def isReachable(ipOrName, port, timeout=2):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(timeout)
    try:
        s.connect((ipOrName, int(port)))
        s.shutdown(socket.SHUT_RDWR)
        return True
    except:
        return False
    finally:
        s.close()

代码取自此处。

---

¹ TCP ping 并不真正存在，因为 ping 是在 ISO/OSI 第 3 层上使用 ICMP 执行的。TCP ping 是在 ISO/OSI 第 4 层上执行的。它只是尝试以最基本的方式连接到 TCP 端口，即不传输任何数据，而是在连接后立即关闭连接。

Answer 13

我用以下方法解决了这个问题：

def ping(self, host):
    res = False

    ping_param = "-n 1" if system_name().lower() == "windows" else "-c 1"

    resultado = os.popen("ping " + ping_param + " " + host).read()

    if "TTL=" in resultado:
        res = True
    return res

“TTL” 是了解 ping 是否正确的方法。
萨卢多斯

Answer 14

确保 pyping 已安装或安装它 pip install pyping

#!/usr/bin/python
import pyping

response = pyping.ping('Your IP')

if response.ret_code == 0:
    print("reachable")
else:
    print("unreachable")

Answer 15

在 Linux 上，无需 root（或 setuid 或 CAP_NET_RAW）即可创建 ICMP 数据报（非原始）套接字：https://unix.stackexchange.com/a/592914。我最终得到了

$ id
uid=1000(raylu) gid=1000(raylu) [...]
$ sudo sysctl net.ipv4.ping_group_range='1000 1000'

import socket
import struct
import time

def main():
    ping('192.168.1.10')

def ping(destination):
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.getprotobyname('icmp'))
    sock.settimeout(10.0)
    start_time = time.time_ns() # python 3.7+ only

    payload = struct.pack('L', start_time)
    sock.sendto(encode(payload), (destination, 0))
    while (time.time_ns() - start_time) // 1_000_000_000 < 10:
        try:
            data, source = sock.recvfrom(256)
        except socket.timeout:
            print('timed out')
            return
        message_type, message_code, check, identifier, sequence_number = struct.unpack('bbHHh', data[:8])
        if source == (destination, 0) and message_type == ICMP.ECHO_REPLY and data[8:] == payload:
            print((time.time_ns() - start_time) // 1_000_000, 'ms')
            break
        else:
            print('got unexpected packet from %s:' % source[0], message_type, data[8:])
    else:
        print('timed out')

def encode(payload: bytes):
    # calculate checksum with check set to 0
    checksum = calc_checksum(icmp_header(ICMP.ECHO_REQUEST, 0, 0, 1, 1) + payload)
    # craft the packet again with the checksum set
    return icmp_header(ICMP.ECHO_REQUEST, 0, checksum, 1, 1) + payload

def icmp_header(message_type, message_code, check, identifier, sequence_number) -> bytes:
    return struct.pack('bbHHh', message_type, message_code, check, identifier, sequence_number)

def calc_checksum(data: bytes) -> int:
    '''RFC 1071'''
    # code stolen from https://github.com/alessandromaggio/pythonping/blob/a59ce65a/pythonping/icmp.py#L8
    '''
    MIT License

    Copyright (c) 2018 Alessandro Maggio

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
    '''
    subtotal = 0
    for i in range(0, len(data)-1, 2):
        subtotal += (data[i] << 8) + data[i+1]
    if len(data) % 2:
        subtotal += (data[len(data)-1] << 8)
    while subtotal >> 16:
        subtotal = (subtotal & 0xFFFF) + (subtotal >> 16)
    check = ~subtotal
    return ((check << 8) & 0xFF00) | ((check >> 8) & 0x00FF)

class ICMP:
    ECHO_REPLY = 0
    ECHO_REQUEST = 8

虽然其他答案在这里建议的许多软件包也可以工作

Answer 16

#!/usr/bin/python3

import subprocess as sp

ip = "192.168.122.60"
status,result = sp.getstatusoutput("ping -c1 -w2 " + ip)

if status == 0: 
    print("System " + ip + " is UP !")
else:
    print("System " + ip + " is DOWN !")

Answer 17

我使用这篇文章中答案的想法进行减少，但仅使用较新推荐的子进程模块和 python3：

import subprocess
import platform

operating_sys = platform.system()
nas = '192.168.0.10'

def ping(ip):
    # ping_command = ['ping', ip, '-n', '1'] instead of ping_command = ['ping', ip, '-n 1'] for Windows
    ping_command = ['ping', ip, '-n', '1'] if operating_sys == 'Windows' else ['ping', ip, '-c 1']
    shell_needed = True if operating_sys == 'Windows' else False

    ping_output = subprocess.run(ping_command,shell=shell_needed,stdout=subprocess.PIPE)
    success = ping_output.returncode
    return True if success == 0 else False

out = ping(nas)
print(out)

Answer 18

该脚本适用于 Windows，并且应该适用于其他操作系统：
它可以在 Windows、Debian 和 Macosx 上运行，需要在Solaris 上进行测试。

import os
import platform


def isUp(hostname):

    giveFeedback = False

    if platform.system() == "Windows":
        response = os.system("ping "+hostname+" -n 1")
    else:
        response = os.system("ping -c 1 " + hostname)

    isUpBool = False
    if response == 0:
        if giveFeedback:
            print hostname, 'is up!'
        isUpBool = True
    else:
        if giveFeedback:
            print hostname, 'is down!'

    return isUpBool

print(isUp("example.com")) #Example domain
print(isUp("localhost")) #Your computer
print(isUp("invalid.example.com")) #Unresolvable hostname: https://tools.ietf.org/html/rfc6761
print(isUp("192.168.1.1")) #Pings local router
print(isUp("192.168.1.135")) #Pings a local computer - will differ for your network

Answer 19

使用Multi-ping（pip install multiPing）我编写了这个简单的代码（如果您愿意，只需复制并粘贴即可！）：

from multiping import MultiPing

def ping(host,n = 0):
    if(n>0):
        avg = 0
        for i in range (n):
            avg += ping(host)
        avg = avg/n
    # Create a MultiPing object to test hosts / addresses
    mp = MultiPing([host])

    # Send the pings to those addresses
    mp.send()

    # With a 1 second timout, wait for responses (may return sooner if all
    # results are received).
    responses, no_responses = mp.receive(1)


    for addr, rtt in responses.items():
        RTT = rtt


    if no_responses:
        # Sending pings once more, but just to those addresses that have not
        # responded, yet.
        mp.send()
        responses, no_responses = mp.receive(1)
        RTT = -1

    return RTT

用法：

#Getting the latency average (in seconds) of host '192.168.0.123' using 10 samples
ping('192.168.0.123',10)

如果你想要单个样本，第二个参数“10”可以忽略！

希望有帮助！

Answer 20

看起来很简单，但让我很不舒服。我不断收到“不允许 icmp 打开套接字操作”的消息，否则如果服务器离线，解决方案将挂起。但是，如果您想知道服务器是否处于活动状态并且您正在该服务器上运行 Web 服务器，那么curl 将完成这项工作。如果您有 ssh 和证书，那么 ssh 和一个简单的命令就足够了。这是代码：

from easyprocess import EasyProcess # as root: pip install EasyProcess
def ping(ip):
    ping="ssh %s date;exit"%(ip) # test ssh alive or
    ping="curl -IL %s"%(ip)      # test if http alive
    response=len(EasyProcess(ping).call(timeout=2).stdout)
    return response #integer 0 if no response in 2 seconds

Answer 21

使用它，它在 python 2.7 上进行了测试，工作正常，如果成功则返回 ping 时间（以毫秒为单位），如果失败则返回 False。

import platform,subproccess,re
def Ping(hostname,timeout):
    if platform.system() == "Windows":
        command="ping "+hostname+" -n 1 -w "+str(timeout*1000)
    else:
        command="ping -i "+str(timeout)+" -c 1 " + hostname
    proccess = subprocess.Popen(command, stdout=subprocess.PIPE)
    matches=re.match('.*time=([0-9]+)ms.*', proccess.stdout.read(),re.DOTALL)
    if matches:
        return matches.group(1)
    else: 
        return False

Answer 22

我有类似的要求，所以我实现了它，如下所示。它在 Windows 64 位和 Linux 上进行了测试。

import subprocess
def systemCommand(Command):
    Output = ""
    Error = ""     
    try:
        Output = subprocess.check_output(Command,stderr = subprocess.STDOUT,shell='True')
    except subprocess.CalledProcessError as e:
        #Invalid command raises this exception
        Error =  e.output 

    if Output:
        Stdout = Output.split("\n")
    else:
        Stdout = []
    if Error:
        Stderr = Error.split("\n")
    else:
        Stderr = []

    return (Stdout,Stderr)

#in main
Host = "ip to ping"
NoOfPackets = 2
Timeout = 5000 #in milliseconds
#Command for windows
Command = 'ping -n {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
#Command for linux 
#Command = 'ping -c {0} -w {1} {2}'.format(NoOfPackets,Timeout,Host)
Stdout,Stderr = systemCommand(Command)
if Stdout:
   print("Host [{}] is reachable.".format(Host))
else:
   print("Host [{}] is unreachable.".format(Host))

当 IP 不可访问时， subprocess.check_output() 会引发异常。可以通过从输出行“数据包：已发送 = 2，已接收 = 2，丢失 = 0（0% 丢失）”中提取信息来完成额外验证。

Answer 23

我最终发现了关于类似场景的这个问题。我尝试了 pyping，但 Naveen 给出的示例在 Python 2.7 下的 Windows 中对我不起作用。

对我有用的一个例子是：

import pyping

response = pyping.send('Your IP')

if response['ret_code'] == 0:
    print("reachable")
else:
    print("unreachable")

Answer 24

仅限 WINDOWS - 不敢相信没有人破解 Win32_PingStatus
使用简单的 WMI 查询，我们免费返回一个包含真正详细信息的对象

import wmi


# new WMI object
c = wmi.WMI()

# here is where the ping actually is triggered
x = c.Win32_PingStatus(Address='google.com')

# how big is this thing? - 1 element
print 'length x: ' ,len(x)


#lets look at the object 'WMI Object:\n'
print x


#print out the whole returned object
# only x[0] element has values in it
print '\nPrint Whole Object - can directly reference the field names:\n'
for i in x:
    print i



#just a single field in the object - Method 1
print 'Method 1 ( i is actually x[0] ) :'
for i in x:
    print 'Response:\t', i.ResponseTime, 'ms'
    print 'TTL:\t', i.TimeToLive


#or better yet directly access the field you want
print '\npinged ', x[0].ProtocolAddress, ' and got reply in ', x[0].ResponseTime, 'ms'

示例输出

Answer 25

以下是使用 Python 的 subprocess 模块和底层操作系统提供的 ping CLI 工具的解决方案。在 Windows 和 Linux 上进行了测试。支持设置网络超时。不需要 root 权限（至少在 Windows 和 Linux 上）。

import platform
import subprocess

def ping(host, network_timeout=3):
    """Send a ping packet to the specified host, using the system "ping" command."""
    args = [
        'ping'
    ]

    platform_os = platform.system().lower()

    if platform_os == 'windows':
        args.extend(['-n', '1'])
        args.extend(['-w', str(network_timeout * 1000)])
    elif platform_os in ('linux', 'darwin'):
        args.extend(['-c', '1'])
        args.extend(['-W', str(network_timeout)])
    else:
        raise NotImplemented('Unsupported OS: {}'.format(platform_os))

    args.append(host)

    try:
        if platform_os == 'windows':
            output = subprocess.run(args, check=True, universal_newlines=True).stdout

            if output and 'TTL' not in output:
                return False
        else:
            subprocess.run(args, check=True)

        return True
    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
        return False

Answer 26

我需要更快的 ping 扫描，并且不想使用任何外部库，因此我决定使用内置 asyncio 来使用并发。

此代码需要 python 3.7+，并且仅在 Linux 上制作和测试。它无法在 Windows 上运行，但我相信您可以轻松地将其更改为在 Windows 上运行。

我不是asyncio方面的专家，但我使用了这篇很棒的文章加速你的Python并发编程，我想出了这些代码行。我试图使其尽可能简单，因此您很可能需要向其中添加更多代码以满足您的需求。

它不返回 true 或 false，我认为让它打印响应 ping 请求的 IP 会更方便。我认为它相当快，在近 10 秒内 ping 255 ips。

#!/usr/bin/python3

import asyncio

async def ping(host):
    """
    Prints the hosts that respond to ping request
    """
    ping_process = await asyncio.create_subprocess_shell("ping -c 1 " + host + " > /dev/null 2>&1")
    await ping_process.wait()

    if ping_process.returncode == 0:
        print(host)
    return 


async def ping_all():
    tasks = []

    for i in range(1,255):
        ip = "192.168.1.{}".format(i)
        task = asyncio.ensure_future(ping(ip))
        tasks.append(task)

    await asyncio.gather(*tasks, return_exceptions = True)

asyncio.run(ping_all())

示例输出：

192.168.1.1
192.168.1.3
192.168.1.102
192.168.1.106
192.168.1.6

请注意，IP 不按顺序排列，因为 IP 在回复后立即打印，因此首先响应的 IP 将首先打印。

Answer 27

我借用了其他答案。尝试简化和最小化查询。

import platform, os

def ping(host):
    result = os.popen(' '.join(("ping", ping.param, host))).read()
    return 'ttl=' in result.lower()

ping.param = "-n 1" if platform.system().lower() == "windows" else "-c 1"

编辑：根据 Olivier B. 的评论，忽略大小写。

Answer 28

import os #to get clear screen
import subprocess as sp #to get system ping
os.system("clear") #clear screen
print('Wait or Press Ctrl+Z to Terminate\n') #notice to terminate or wait
for i in range(255): #0 to 255 loop
    ip='192.168.1.'+str(i) #concatenating str and int
    s,r=sp.getstatusoutput("ping -c1 -w2 " + ip) #ping and store status in s
    if s==0: #if status is 0 equal to pass
        print(ip+" is UP ✓ ") #output
    else: #if status is not 0 equal to fail
        pass #skip and try next ip from loop

Answer 29

我想出的唯一一个半途而废的解决方案是：

from tcppinglib import tcpping
tcpping('example.com', 443, 1, 1).is_alive

通过简单的套接字使用非特权帐户在 Windows 和 Linux 下工作。

显然还支持异步/多“ping”。

https://pypi.org/project/tcppinglib/

Answer 30

在 Windows 或 Linux 中对它们进行 ping 操作，返回排序后的列表。这是@Ahmed Essam 和@Arno 回复的混合/修复。

import asyncio
import re

import platform
isWindows = platform.system()


async def ping(host):
    cmd = 'ping {} {} 1'.format(host, '-n' if isWindows else '-c')
    ping_proc = \
        await asyncio.create_subprocess_shell(cmd, stdout=asyncio.subprocess.PIPE,
                                                      stderr=asyncio.subprocess.PIPE)
    stdout, stderr = await ping_proc.communicate()
    outstr = stdout.decode()

    if ping_proc.returncode == 0:
        delay = int(re.search(r'(?:time=)([\d]*)', outstr).group(1)) if 'time=' in outstr else -1
        if delay >= 0:
            # print('{} {}ms'.format(host, delay))
            return [host, delay]

    return [host, None]


async def ping_all():
    tasks = []

    for i in range(1, 256):
        ip = "192.168.1.{}".format(i)
        task = asyncio.ensure_future(ping(ip))
        tasks.append(task)

    retList = await asyncio.gather(*tasks, return_exceptions=True)
    retList = [x for x in retList if x[1] is not None]
    retList.sort(key=lambda x: int(x[0].split('.')[-1]))

    return retList


loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
pingRet = loop.run_until_complete(ping_all())

for ip, d in pingRet:
    print('{:<16s} {}ms'.format(ip, d))