python netaddr

最新推荐文章于 2024-05-18 09:34:08 发布
最新推荐文章于 2024-05-18 09:34:08 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： 开发 文章标签： 杂碎 netaddr python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Neil_001/article/details/104586078
版权

参考:http://pydoc.net/netaddr/0.7.10/netaddr.strategy/

from netaddr.strategy.ipv4 import int_to_words, bin_to_int

1. IPAddress


In [79]: ip = IPAddress('127.0.0.1')                                                                               

In [80]: ip                                                                                                        
Out[80]: IPAddress('127.0.0.1')

In [81]: ip.bin                                                                                                    
Out[81]: '0b1111111000000000000000000000001'

In [82]: ip.value                                                                                                  
Out[82]: 2130706433

In [83]: int(ip)                                                                                                   
Out[83]: 2130706433

In [84]: ip.info                                                                                                   
Out[84]: 
{'IPv4': [{'date': '1981-09',
 'designation': 'IANA - Loopback',
 'prefix': '127/8',
 'status': 'Reserved',
 'whois': ''}]}

In [85]: ip..format                                                                                                
  File "<ipython-input-85-14e9e84bea11>", line 1
    ip..format
       ^
SyntaxError: invalid syntax


In [86]: ip.format                                                                                                 
Out[86]: <bound method IPAddress.format of IPAddress('127.0.0.1')>

In [87]: ip.format()                                                                                               
Out[87]: '127.0.0.1'

In [88]: ip.ipv4                                                                                                   
Out[88]: <bound method IPAddress.ipv4 of IPAddress('127.0.0.1')>

In [89]: ip.ipv4()                                                                                                 
Out[89]: IPAddress('127.0.0.1')

In [90]: ip.ipv6()                                                                                                 
Out[90]: IPAddress('::ffff:127.0.0.1')

In [91]: ip.is_private()                                                                                           
Out[91]: False

 

2. IPNetwork

In [42]: from netaddr import *                                                                                     

In [43]: ip = IPNetwork('192.168.0.1/29')                                                                          

In [44]: ip_list = IPNetwork('192.168.0.1/29')                                                                     

In [45]: len(ip_list)                                                                                              
Out[45]: 8

In [46]: ip_list                                                                                                   
Out[46]: IPNetwork('192.168.0.1/29')

In [47]: list(ip_list)                                                                                             
Out[47]: 
[IPAddress('192.168.0.0'),
 IPAddress('192.168.0.1'),
 IPAddress('192.168.0.2'),
 IPAddress('192.168.0.3'),
 IPAddress('192.168.0.4'),
 IPAddress('192.168.0.5'),
 IPAddress('192.168.0.6'),
 IPAddress('192.168.0.7')]



In [96]: ipn = IPNetwork('127.0.0.1/24')                                                                           

In [97]: ipn                                                                                                       
Out[97]: IPNetwork('127.0.0.1/24')

In [98]: ipn.cidr                                                                                                  
Out[98]: IPNetwork('127.0.0.0/24')

In [99]: ipn.first                                                                                                 
Out[99]: 2130706432

In [100]: ipn.last                                                                                                 
Out[100]: 2130706687

In [101]: ipn.is_private                                                                                           
Out[101]: <bound method BaseIP.is_private of IPNetwork('127.0.0.1/24')>

In [102]: ipn.is_private()                                                                                         
Out[102]: False

In [103]: ipn.next                                                                                                 
Out[103]: <bound method IPNetwork.next of IPNetwork('127.0.0.1/24')>

In [104]: ipn.next()                                                                                               
Out[104]: IPNetwork('127.0.1.0/24')

In [105]: ipn.previous()                                                                                           
Out[105]: IPNetwork('126.255.255.0/24')

In [106]: ipn.is_loopback()                                                                                        
Out[106]: True

In [107]: ipn.ipv4                                                                                                 
Out[107]: <bound method IPNetwork.ipv4 of IPNetwork('127.0.0.1/24')>

In [108]: ipn.ipv4()                                                                                               
Out[108]: IPNetwork('127.0.0.1/24')

In [109]: ipn.ipv6()                                                                                               
Out[109]: IPNetwork('::ffff:127.0.0.1/120')

In [110]: ipn.size()                                                                                               
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-110-21878477cf57> in <module>
----> 1 ipn.size()

TypeError: 'int' object is not callable

In [111]: ipn.size                                                                                                 
Out[111]: 256

In [112]: ipn.sort_key                                                                                             
Out[112]: <bound method IPNetwork.sort_key of IPNetwork('127.0.0.1/24')>

In [113]: ipn.sort_key()                                                                                           
Out[113]: (4, 2130706432, 23, 1)

In [114]: ipn.value                                                                                                
Out[114]: 2130706433

In [115]: ipn.version                                                                                              
Out[115]: 4

In [116]: ipn.subnet                                                                                               
Out[116]: <bound method IPNetwork.subnet of IPNetwork('127.0.0.1/24')>


In [118]: ipn.network                                                                                              
Out[118]: IPAddress('127.0.0.0')

In [119]: ipn.broadcast                                                                                            
Out[119]: IPAddress('127.0.0.255')

In [120]: ipn.ip                                                                                                   
Out[120]: IPAddress('127.0.0.1')


In [122]: ipn.hostmask                                                                                             
Out[122]: IPAddress('0.0.0.255')



In [124]: ipn.prefixlen                                                                                            
Out[124]: 24

In [125]: ipn.previous                                                                                             
Out[125]: <bound method IPNetwork.previous of IPNetwork('127.0.0.1/24')>

In [126]: ipn                                                                                                      
Out[126]: IPNetwork('127.0.0.1/24')

In [127]: ipn.next                                                                                                 
Out[127]: <bound method IPNetwork.next of IPNetwork('127.0.0.1/24')>

3. cidrs

In [49]: import netaddr                                                                                            

In [50]: cidrs = netaddr.iprange_to_cidrs('192.168.0.1', '192.168.0.9')                                            

In [51]: cidrs                                                                                                     
Out[51]: 
[IPNetwork('192.168.0.1/32'),
 IPNetwork('192.168.0.2/31'),
 IPNetwork('192.168.0.4/30'),
 IPNetwork('192.168.0.8/31')]

In [52]: cidrs[0]                                                                                                  
Out[52]: IPNetwork('192.168.0.1/32')

4. 相关计算

In [197]: ip_test = '192.168.0.1'                                                                                  

In [199]: IPAddress(ip_test)                                                                                       
Out[199]: IPAddress('192.168.0.1')

In [200]: ipa = IPAddress(ip_test)                                                                                 

In [201]: ipa                                                                                                      
Out[201]: IPAddress('192.168.0.1')


In [203]: ipa.value                                                                                                
Out[203]: 3232235521

In [204]: int_to_words(ipa.value)                                                                                  
Out[204]: (192, 168, 0, 1)

In [205]: IPNetwork(ipa)                                                                                           
Out[205]: IPNetwork('192.168.0.1/32')

In [206]: ipn = IPNetwork(ipa)                                                                                     

In [207]: ipn.last                                                                                                 
Out[207]: 3232235521

In [208]: ipn.first                                                                                                
Out[208]: 3232235521

In [209]: int_to_words(ipn.first)                                                                                  
Out[209]: (192, 168, 0, 1)

In [215]: ipn[-1]                                                                                                  
Out[215]: IPAddress('192.168.0.1')

In [216]: ipn[0]                                                                                                   
Out[216]: IPAddress('192.168.0.1')

In [217]: ipn[0].bin                                                                                               
Out[217]: '0b11000000101010000000000000000001'

In [218]: ipn[0].value                                                                                             
Out[218]: 3232235521

 

Neil_001
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两个处理IP好用的Python库ipaddr和netaddr
zongyue_wang的博客
06-15 4303
Python中关于IP处理的两个模块 这里介绍的两个处理IP好用的Python库名为：ipaddr和netaddr 顺便提一个不好用的：IPy。上面两个能完全胜任这个库的功能，但这个库容错性不好，常报错。 1.ipaddr简单介绍： Google开发的IP处理模块，地址：http://pythonhosted.org/ipaddr/ 可用pip安装：pip install ipaddr 所有包含的类和方法使用help命令查看： help(ipaddr) Class总共分为：BaseIP、IPv4、IPv6
python ipaddr_python 3:ipaddr/netaddr模块
weixin_39710462的博客
11-30 625
我一定是做错了什么。。。我目前正在尝试使用内置模块验证ip是否在特定子网中。我正在使用activepython：ActivePython 3.1.2.3 (ActiveState Software Inc.) based onPython 3.1.2 (r312:79147, Mar 22 2010, 12:20:29) [MSC v.1500 32 bit (Intel)] on win32在变...
netaddr:适用于Python的网络地址处理库
04-29
netaddr 适用于Python 2.7和3.5+的独立于系统的网络地址操作库。 （不建议使用Python 2.7和3.5）。 提供以下支持： 第3层地址 IPv4和IPv6地址，子网，掩码，前缀 迭代，切片，分类，汇总和分类IP网络 处理各种范围格式（CIDR，任意范围和glob，nmap） 设置基于IP地址和子网的操作（联合，交叉点等） 解析各种不同的格式和符号 查找IANA IP阻止信息 生成DNS反向查询 超级网络和子网划分 第2层地址 表示和操作MAC地址和EUI-64标识符 查找IEEE组织信息（OUI，IAB） 生成派生的IPv6地址 从Python 3.3开始，Python标准库中提供了一个模块，该模块提供了与netaddr重叠的第3层地址处理功能。 文献资料 最新文档 分享并享受！
python ipaddr_Python IP netaddr module
weixin_39770821的博客
11-30 99
[IPNetwork('172.24.0.0/23'), IPNetwork('172.24.2.0/23'), IPNetwork('172.24.4.0/23'), IPNetwork('172.24.6.0/23'), IPNetwork('172.24.8.0/23'), IPNetwork('172.24.10.0/23'), IPNetwork('172.24.12.0/23'), I...
推荐开源项目：netaddr - 优化的Go语言IP地址库
最新发布
gitblog_00024的博客
05-18 376
推荐开源项目：netaddr - 优化的Go语言IP地址库 项目地址:https://gitcode.com/inetaf/netaddr 项目介绍 netaddr 是一个用于Go语言的高性能、成熟的IP地址处理包。虽然现在已被官方标记为已弃用，并推荐使用go4.org/netipx和标准库中的net/netip，但netaddr在过去的生产环境中表现出色，特别适合那些对性能有高要求的项目。 项目...
Python自动化运维实战：使用Python管理网络设备
m0_59235699的博客
05-27 4044
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取哈）
Python库 | netaddr-0.6.1-py2.4.egg
04-29
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：netaddr-0.6.1-py2.4.egg 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
python3-netaddr-0.7.19-8.el8.noarch.rpm
12-10
官方离线安装包，亲测可用
网工Python库.pdf
07-19
- `netaddr`：处理IP、子网、MAC地址等网络地址，提供强大的地址操作和验证功能。 - `ipaddress`：Python标准库，提供对IPv4和IPv6地址及子网的高级操作。 4. **数据分析与处理**： - `numpy`：提供高效的数据...
python中netaddr库用法详解
IT之一小佬的博客
08-07 4540
python中netaddr库用法详解
netaddr: Python 库 for IP networking
gitblog_00005的博客
03-12 421
netaddr: Python 库 for IP networking netaddr 是一个用于处理 IP 网络地址、子网、路由等的 Python 库。 功能特性 支持 IPv4 和 IPv6 地址和子网。 提供了方便的数据结构和方法来进行 IP 网络计算和操作。 支持 CIDR（无类别域间路由）表示法。 可以与常见的 IP 工具进行交互，如 ping、traceroute 等。 内置了 IP...
netaddr:网络地址类型
03-20
netaddr 什么 这是一个软件包，其中包含Go的新IP地址类型。 查看其文档： : 动机 请参阅以获得有关为什么我们制作新IP地址包的长篇博客文章。 其他连结： （“网络：重新考虑IP的表示形式”） （“网络：ParseIP应该返回错误，就像其他Parse函数一样”） （“网络：无法可靠地将IPv4映射的IPv6地址与常规IPv4地址区分开”） 合并net.IPAddr和net.IP（由于遗留原因，Go net软件包之间有些破译） ... 待办事项：完成此列表 到期 该软件包已成熟，经过优化，并且已在生产中。但是，尚不能保证API的稳定性。 测验 除了常规的Go测试之外，netaddr还使用模糊测试。语料库单独存储在子模块中，以最大程度地减少对其他所有人的影响。 使用方法： $ git submodule update --init $ go get -u gi
netaddress 给出域名写出IP地址
11-24
inetaddress 给出域名写出IP地址 for循环
netaddr网络地址工具python
weixin_30609287的博客
08-06 1049
print("==========1==========") from netaddr import IPNetwork # IPNetwork('192.168.7.80/30'), IPNetwork('192.168.7.84/30'), IPNetwork('192.168.7.88/30'), IPNetwork('192.168.7.92/30') ip_str...
netaddr模块的一些用法
qq1438438的博客
05-07 1647
1.将数值型IP转化为字符型IP def int_ip2str_ip(ip): u""" 将数值型ip转化为字符型ip :param ip: 需要转化的数值型ip """ return str(netaddr.IPAddress(ip)) 将ipv6_addr结构体转化为字符型ipv6 def ipv6_addr2ipv6_str(ipv6_addr...
网络编程－Python的netaddr库
weixin_30267691的博客
12-01 553
In[1]:fromnetaddrimport* In[2]:ip=IPAddress('172.16.100.39') ip.format()ip地址的格式化 '172.16.100.39' repr(ip) "IPAddress('172.16.100.39')" ip=IPNetwork('172.16.100.39/24') ip.ne...
Python获取ip地址
Y2701310012的专栏
12-25 6550
1. 获取ip/MAC地址等 获取本地ip地址首先想到的命令是ifconfig，然后从结果中提取出ip地址，Python代码如下： def get_ip(): cmd = "/sbin/ifconfig | grep 'inet addr' | grep -v 127.0.0.1 | awk '{print $2}' | awk -F ':' '{print $2}'" pi
python netaddr库常用方法
02-21
python netaddr库的常用方法包括：IPv4Network类用于构建IPv4网络对象；IPv6Network类用于构建IPv6网络对象；IPRange类用于构建IPv4或IPv6的范围对象；IPGlob类用于构建IPv4或IPv6的通配符对象；IPv4Interface类用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值