高级过滤方法

    先从初始化 nornir 对象开始，查看现在的主机清单和组：

    1. from nornir import InitNornir
    2. from nornir.core.filter import F
    4. nr = InitNornir(config_file="advanced_filtering/config.yaml")
    1. [15]:
    1. # %load advanced_filtering/inventory/hosts.yaml
    2. ---
    3. cat:
    4.     groups:
    5.         - terrestrial
    6.         - mammal
    7.     data:
    8.         domestic: true
    9.         diet: omnivore
    10.         additional_data:
    11.             lifespan: 17
    12.             famous_members:
    13.                 - garfield
    14.                 - felix
    15.                 - grumpy
    17. bat:
    18.     groups:
    19.         - terrestrial
    20.         - mammal
    21.     data:
    22.         domestic: false
    23.         fly: true
    24.         diet: carnivore
    25.         additional_data:
    26.             lifespan: 15
    27.             famous_members:
    28.                 - batman
    29.                 - count chocula
    30.                 - nosferatu
    32. eagle:
    33.     groups:
    34.         - terrestrial
    35.         - bird
    36.     data:
    37.         domestic: false
    38.         diet: carnivore
    39.         additional_data:
    40.             lifespan: 50
    41.             famous_members:
    42.                 - thorondor
    43.                 - sam
    45. canary:
    46.         - terrestrial
    47.         - bird
    48.     data:
    50.         diet: herbivore
    51.         additional_data:
    52.             lifespan: 15
    53.             famous_members:
    54.                 - tweetie
    56. caterpillaer:
    57.     groups:
    58.         - terrestrial
    59.         - invertebrate
    60.     data:
    61.         domestic: false
    62.         diet: herbivore
    63.         additional_data:
    64.             lifespan: 1
    65.             famous_members:
    66.                 - Hookah-Smoking
    68. octopus:
    69.     groups:
    70.         - marine
    71.         - invertebrate
    72.     data:
    73.         domestic: false
    74.         diet: carnivore
    75.         additional_data:
    76.             lifespan: 1
    77.             famous_members:
    78.                 - sharktopus
    1. [4]:
    1. # %load advanced_filtering/inventory/groups.yaml
    2. ---
    3. mammal:
    4.     data:
    5.         reproduction: birth
    6.         fly: false
    8. bird:
    9.     data:
    10.         reproduction: eggs
    11.         fly: true
    13. invertebrate:
    14.     data:
    15.         reproduction: mitosis
    16.         fly: false
    17. terrestrial: {}
    18. marine: {}

    在上面的主机及主机组文件中，建立了具有不同属性的动物分类。F 对象可以只需在前面加上两个下划线和魔术方法的名称即可访问每种类型的魔术方法。例如，如果想检查一个列表是否包含一个特定的元素，你可以在前面加上 __contains。现在来查找属于鸟类（bird）的所有动物：

    1. [2]:
    1. birds = nr.filter(F(groups__contains="bird"))
    2. print(birds.inventory.hosts.keys())
    3. # dict_keys(['鹰', '金丝雀'])
    1. dict_keys(['eagle', 'canary'])
    1. [3]:
    1. not_birds = nr.filter(~F(groups__contains="bird"))
    2. print(not_birds.inventory.hosts.keys())
    3. # dict_keys(['猫', '蝙蝠', '毛毛虫', '章鱼'])

    还可以组合 F 对象并使用符号 & 和 | 执行 AND 和 OR 运算：

    1. [4]:
    1. # 筛选鸟类（bird）或者家养动物（domestic）
    2. domestic_or_bird = nr.filter(F(groups__contains="bird") | F(domestic=True))
    3. print(domestic_or_bird.inventory.hosts.keys())
    4. # dict_keys(['猫', '鹰', '金丝雀'])
    1. dict_keys(['cat', 'eagle', 'canary'])
    1. [5]:
    1. # 筛选哺乳动物（mammal）并且是家养动物（domestic）
    2. domestic_mammals = nr.filter(F(groups__contains="mammal") & F(domestic=True))
    3. print(domestic_mammals.inventory.hosts.keys())
    4. # dict_keys(['猫'])
    1. dict_keys(['cat'])

    也可以将所有符号进行组合：

    1. [6]:
    1. # 筛选会飞的动物（fly）并且不是食肉动物（cannivore）
    2. flying_not_carnivore = nr.filter(F(fly=True) & ~F(diet="carnivore"))
    3. print(flying_not_carnivore.inventory.hosts.keys())
    4. # dict_keys(['金丝雀'])
    1. dict_keys(['canary'])
    1. [7]:
    1. dict_keys(['cat', 'bat', 'eagle', 'canary'])
    1. [8]:
    1. # 结合这个例子，增加对上一个代码框的理解
    2. # 使用整数的魔术方法进行比较大小
    3. # 定义 a = 1，b = 2
    4. a = 1
    5. b = 2
    6. # 调用 a 的 魔术方法，将 b 作为参数传入，等价于 a >= b
    7. a.__ge__(b)
    1. [8]:
    1. False

    除了 __contains 外，还有两个选项可以对列表进行处理：any 和 all。 any 代表列表中的元素是 OR 的关系，满足一个条件就可以；all 代表列表中的元素是 AND 的关系，必须满足所有的条件才行：

    1. [9]:
    1. # 筛选鸟类（bird）或者无脊椎动物（invertebrates）
    2. bird_or_invertebrates = nr.filter(F(groups__any=["bird", "invertebrate"]))
    3. print(bird_or_invertebrates.inventory.hosts.keys())
    4. # dict_keys(['鹰', '金丝雀', '毛毛虫', '章鱼'])
    1. dict_keys(['eagle', 'canary', 'caterpillaer', 'octopus'])
    1. [10]:
    1. # 筛选海生动物（marine）并且是无脊椎动物（invertebrates）
    2. marine_and_invertebrates = nr.filter(F(groups__all=["marine", "invertebrate"]))
    3. # dict_keys(['章鱼'])

    从示例中可以看出，如果需要对多个组进行过滤操作的话，某些情况下使用 any 和 all 比使用 __contains 和多级运算 &、~、 更为方便。

    上一节 | | 返回首页