使用 Python 来 Ping 服务器-IT科技

摘要：问题描述：在 Python 中，有没有办法通过 ICMP ping 服务器，如果服务器响应则返回 TRUE，如果没有响应则返回 FALSE？解决方案 1：如果您不需要支持 Windows，这里有一个非常简洁的方法：import os param = '-n' if os.sys.platform().lowe...

问题描述：

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

解决方案 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 超时（以秒为单位）。请注意，这会将文本输出到控制台。

解决方案 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 上的@ikraseTrue ，如果出现错误，此函数仍将返回Destination Host Unreachable。

解释

此命令适用ping于 Windows 和类 Unix 系统。

选项-n(Windows) 或-c(Unix) 控制数据包数量，在本例中设置为 1。

platform.system()返回平台名称。例如'Darwin'在 macOS 上。

subprocess.call()执行系统调用。例如subprocess.call(['ls','-l'])。

解决方案 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))

解决方案 4：

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

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

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

解决方案 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

解决方案 6：

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

解决方案 7：

由于发送原始 ICMP 数据包需要提升权限，因此编程式 ICMP ping 非常复杂，而且调用二进制文件也非常丑陋。对于服务器监控，您可以使用名为TCP ping 的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 连接并立即断开连接，测量经过的时间。此特定实现有一点限制，因为它不处理关闭的端口，但对于您自己的服务器来说，它工作得很好。

解决方案 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"))

解决方案 9：

我的 ping 功能版本：

适用于 Windows 和 Linux 上的 Python 3.5 及更高版本。
在 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

请随意使用它。

解决方案 10：

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

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

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

解决方案 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()

解决方案 12：

如果您的服务器不支持 ICMP（防火墙可能会阻止它），它很可能仍在 TCP 端口上提供服务。在这种情况下，您可以执行TCP ping 1（独立于平台且无需安装其他 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()

代码取自这里，仅做了少许修改。

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

解决方案 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 是否正确的方法。Saludos

解决方案 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")

解决方案 15：

CAP_NET_RAW在 Linux 上，无需 root（或 setuid 或）即可创建 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

虽然其他答案建议的许多软件包也可以使用

解决方案 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 !")

解决方案 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)

解决方案 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

解决方案 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”可以忽略！

希望有帮助！

解决方案 20：

看起来很简单，但却让我很头疼。我一直收到“icmp open socket operation not allowed”的提示，否则如果服务器离线，解决方案就会挂起。但是，如果您想知道服务器是否处于活动状态，并且您正在该服务器上运行 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

解决方案 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

解决方案 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("
")
    else:
        Stdout = []
    if Error:
        Stderr = Error.split("
")
    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% 丢失）”中提取信息来进行额外验证。

解决方案 23：

我最终找到了有关类似情况的这个问题。我尝试了 pyping，但 Naveen 给出的示例在 Windows 下的 Python 2.7 中对我不起作用。

对我有用的一个示例是：

import pyping

response = pyping.send('Your IP')

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

解决方案 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:
'
print x


#print out the whole returned object
# only x[0] element has values in it
print '
Print Whole Object - can directly reference the field names:
'
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:    ', i.ResponseTime, 'ms'
    print 'TTL:    ', i.TimeToLive


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

示例输出

解决方案 25：

这是一个使用 Pythonsubprocess模块和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

解决方案 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 会首先打印。

解决方案 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 的评论，忽略大小写。

解决方案 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
') #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

解决方案 29：

我想到的唯一还算满意的解决方案是：

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

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

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

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

解决方案 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 = \n        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))