python装飾器学習ノート

24302 ワード
python
参考:http://stackoverflow.com/questions/739654/how-to-make-a-chain-of-function-decorators#answer-1594484
装飾器は高級なPython文法です。関数、方法、またはクラスの加工ができます。Pythonでは、関数とクラスを加工するための様々な方法があります。他の方法に比べて、装飾器の文法は簡単で、コードの読み取り可能性が高いです。したがって、装飾器はPythonプロジェクトで広く使われています。修飾器は常に切面需要があるシーンに用いられ、比較的古典的なのは日誌、性能試験、事務処理、Web権限検査、Cacheなどがある。有名な例はコーヒー、砂糖入りのコーヒー、ミルク入りのコーヒーです。本質的には、やはりコーヒーで、もともとあったものに「装飾」を施すだけで、機能や特性を付加させます。
装飾器の利点は、関数機能自体に関係のない大量の関数から同じコードを抜き出して再利用することができるということです。すなわち、関数「修飾」を全く異なる挙動にすることができ、トラフィック論理を効果的に直交分解することができる。概括的に言えば、装飾器の役割はすでに存在しているオブジェクトに追加の機能を付加することです。例えばログを記録するには、いくつかの関数を記録する必要があります。愚かな方法で、関数ごとにコードを入れます。コードが変わったら、悲しいです。装飾器の方法は、専用ログ記録の装飾器を定義し、必要な関数を装飾します。
PythonのDecoratorはJava/C〓のAnnotationと似ています。この方法のためにいくつかのものを装飾します。しかし、Java/C葃のAnnotationもとても人を見ていて、それを使う前にアンノテーションのクラス文書の山を知る必要があります。他の言語を勉強していると感じられます。PythonはDecortor PatternとAnnotationに対して非常に優雅な方法を使用しています。この方法は複雑なOOモデルやAnnotationの様々な種類のライブラリ規定を把握する必要がありません。完全に言語レベルの遊び方です。関数式プログラミングのテクニックです。
Pythonでは、装飾器の実現が非常に便利です。関数は捨てられます。
pythonの関数はオブジェクトです。
装飾器を理解するには、pythonで関数も対象であることをまず知っておく必要があります。この点を知ることはとても重要です。例を通して、なぜかを見てみましょう。
def shout(word="yes"):
    return word.capitalize()+"!"

print(shout())
# outputs : 'Yes!'

# As an object, you can assign the function to a variable like any other object 
scream = shout

# Notice we don't use parentheses: we are not calling the function,
# we are putting the function "shout" into the variable "scream".
# It means you can then call "shout" from "scream":

print(scream())
# outputs : 'Yes!'

# More than that, it means you can remove the old name 'shout',
# and the function will still be accessible from 'scream'

del shout
try:
    print(shout())
except NameError, e:
    print(e)
    #outputs: "name 'shout' is not defined"

print(scream())
# outputs: 'Yes!'
python関数のもう一つの興味深い特性は，それらが他の関数の中で定義できることである。
def talk():

    # You can define a function on the fly in "talk" ...
    def whisper(word="yes"):
        return word.lower()+"..."

    # ... and use it right away!
    print(whisper())

# You call "talk", that defines "whisper" EVERY TIME you call it, then
# "whisper" is called in "talk". 
talk()
# outputs: 
# "yes..."

# But "whisper" DOES NOT EXIST outside "talk":

try:
    print(whisper())
except NameError, e:
    print(e)
    #outputs : "name 'whisper' is not defined"*
    #Python's functions are objects
関数参照(Funtions references)
先ほど分かりました。pythonの関数も対象です。
  • は変数
    • に値を与えられます。
  • は、他の関数内で
    • を定義することができる。
    このようにして、関数が別の関数に戻ることができるということです。例を見てください。
    def getTalk(kind="shout"):

    # We define functions on the fly
    def shout(word="yes"):
        return word.capitalize()+"!"

    def whisper(word="yes") :
        return word.lower()+"...";

    # Then we return one of them
    if kind == "shout":
        # We don't use "()", we are not calling the function,
        # we are returning the function object
        return shout  
    else:
        return whisper

# How do you use this strange beast?

# Get the function and assign it to a variable
talk = getTalk()      

# You can see that "talk" is here a function object:
print(talk)
#outputs : 

# The object is the one returned by the function:
print(talk())
#outputs : Yes!

# And you can even use it directly if you feel wild:
print(getTalk("whisper")())
#outputs : yes...
    関数を返すことができるなら、パラメータのように伝えることができます。
    def doSomethingBefore(func): 
    print("I do something before then I call the function you gave me")
    print(func())

doSomethingBefore(scream)
#outputs: 
#I do something before then I call the function you gave me
#Yes!
    装飾器を理解するための基礎知識はすでに整っています。装飾器とは、装飾された関数を実行する前または後に他のコードを実行し、関数自体を変更する必要がないようにする包装材料のことです。
    ハンドメイド装飾器（Handcraftd decorators）
    このようにカスタマイズできます。
    # A decorator is a function that expects ANOTHER function as parameter
def my_shiny_new_decorator(a_function_to_decorate):

    # Inside, the decorator defines a function on the fly         : the wrapper.
    # This function is going to be wrapped around the original function
    # so it can execute code before and after it.
    def the_wrapper_around_the_original_function():

        # Put here the code you want to be executed BEFORE the original function is called
        print("Before the function runs")

        # Call the function here (using parentheses)
        a_function_to_decorate()

        # Put here the code you want to be executed AFTER the original function is called
        print("After the function runs")

    # At this point, "a_function_to_decorate" HAS NEVER BEEN EXECUTED.
    # We return the wrapper function we have just created.
    # The wrapper contains the function and the code to execute before and after. It’s ready to use!
    return the_wrapper_around_the_original_function

# Now imagine you create a function you don't want to ever touch again.
def a_stand_alone_function():
    print("I am a stand alone function, don't you dare modify me")

a_stand_alone_function() 
#outputs: I am a stand alone function, don't you dare modify me

# Well, you can decorate it to extend its behavior.
# Just pass it to the decorator, it will wrap it dynamically in 
# any code you want and return you a new function ready to be used:

a_stand_alone_function_decorated = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function_decorated()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs
    今は大体希望しています。毎回a_を呼んでください。stand_alone_functionの場合、実際に呼び出したのはa_です。stand_alone_function_decoratedこれは簡単です。myを入れさえすればいいです。シャニーnew_decoratorの戻りの関数はa_をカバーします。stand_alone_機能だけでいいです。
    a_stand_alone_function = my_shiny_new_decorator(a_stand_alone_function)
a_stand_alone_function()
#outputs:
#Before the function runs
#I am a stand alone function, don't you dare modify me
#After the function runs

# That’s EXACTLY what decorators do!
    掲秘装飾器（Decorators demystified）
    私たちは飾り器の文法を使って前の例を書き直します。
    @my_shiny_new_decorator
def another_stand_alone_function():
    print("Leave me alone")

another_stand_alone_function()  
#outputs:  
#Before the function runs
#Leave me alone
#After the function runs
    はい、これで終わりです。こんなに簡単です。decoratorは以下の文の略記にすぎません。
    another_stand_alone_function = my_shiny_new_decorator(another_stand_alone_function)
    飾り器とは、飾り器のパターンの一つであるpython化の変体です。開発を容易にするために、pythonはすでにいくつかの古典的なデザインモードを内蔵しています。例えば、ディズエター。もちろん、装飾器を使うこともできます。
    def bread(func):
    def wrapper():
        print("''''''\>")
        func()
        print("")
    return wrapper

def ingredients(func):
    def wrapper():
        print("#tomatoes#")
        func()
        print("~salad~")
    return wrapper

def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs: --ham--
sandwich = bread(ingredients(sandwich))
sandwich()
#outputs:
#''''''\>
# #tomatoes#
# --ham--
# ~salad~
#
    pythonの装飾器文法で表します。
    @bread
@ingredients
def sandwich(food="--ham--"):
    print(food)

sandwich()
#outputs:
#''''''\>
# #tomatoes#
# --ham--
# ~salad~
#
    装飾器の置く順序は重要です。
    @ingredients
@bread
def strange_sandwich(food="--ham--"):
    print(food)

strange_sandwich()
#outputs:
##tomatoes#
#''''''\>
# --ham--
#
# ~salad~
    装飾器関数への参照(Passing argments to the decorated function)
    # It’s not black magic, you just have to let the wrapper 
# pass the argument:

def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print("I got args! Look: {0}, {1}".format(arg1, arg2))
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

# Since when you are calling the function returned by the decorator, you are
# calling the wrapper, passing arguments to the wrapper will let it pass them to 
# the decorated function

@a_decorator_passing_arguments
def print_full_name(first_name, last_name):
    print("My name is {0} {1}".format(first_name, last_name))

print_full_name("Peter", "Venkman")
# outputs:
#I got args! Look: Peter Venkman
#My name is Peter Venkman
    Pythonの偉大なところは、方法と関数はほぼ同じであり、方法の最初のパラメータ以外は現在のオブジェクトの参照であるべきである。これはselfを考慮して覚えていれば、同じ方法で装飾器を作ることができるということです。
    def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
        lie = lie - 3 # very friendly, decrease age even more :-)
        return method_to_decorate(self, lie)
    return wrapper


class Lucy(object):

    def __init__(self):
        self.age = 32

    @method_friendly_decorator
    def sayYourAge(self, lie):
        print("I am {0}, what did you think?".format(self.age + lie))

l = Lucy()
l.sayYourAge(-3)
#outputs: I am 26, what did you think?
    もしあなたが汎用の装飾器を作っているなら、彼はどんな関数や種類の方法にも応用できます。パラメータは何でも使えます。*args, **kwargs:
    def a_decorator_passing_arbitrary_arguments(function_to_decorate):
    # The wrapper accepts any arguments
    def a_wrapper_accepting_arbitrary_arguments(*args, **kwargs):
        print("Do I have args?:")
        print(args)
        print(kwargs)
        # Then you unpack the arguments, here *args, **kwargs
        # If you are not familiar with unpacking, check:
        # http://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/
        function_to_decorate(*args, **kwargs)
    return a_wrapper_accepting_arbitrary_arguments

@a_decorator_passing_arbitrary_arguments
def function_with_no_argument():
    print("Python is cool, no argument here.")

function_with_no_argument()
#outputs
#Do I have args?:
#()
#{}
#Python is cool, no argument here.

@a_decorator_passing_arbitrary_arguments
def function_with_arguments(a, b, c):
    print(a, b, c)

function_with_arguments(1,2,3)
#outputs
#Do I have args?:
#(1, 2, 3)
#{}
#1 2 3 

@a_decorator_passing_arbitrary_arguments
def function_with_named_arguments(a, b, c, platypus="Why not ?"):
    print("Do {0}, {1} and {2} like platypus? {3}".format(a, b, c, platypus))

function_with_named_arguments("Bill", "Linus", "Steve", platypus="Indeed!")
#outputs
#Do I have args ? :
#('Bill', 'Linus', 'Steve')
#{'platypus': 'Indeed!'}
#Do Bill, Linus and Steve like platypus? Indeed!

class Mary(object):

    def __init__(self):
        self.age = 31

    @a_decorator_passing_arbitrary_arguments
    def sayYourAge(self, lie=-3): # You can now add a default value
        print("I am {0}, what did you think?".format(self.age + lie))

m = Mary()
m.sayYourAge()
#outputs
# Do I have args?:
#(<__main__.mary object="" at="">,)
#{}
#I am 28, what did you think?
    装飾器への参列（Passing argments to the decorator）
    現在、飾り器自体にパラメータを伝えるには、どう思いますか？はい、このようにちょっと遠回りです。装飾器は一つの関数をパラメータとして受け取らなければならないので、装飾された関数のパラメータを直接装飾器に伝えることができません。
    まっすぐに答えを出す前に、まず小さなヒントを書きます。
    # Decorators are ORDINARY functions
def my_decorator(func):
    print("I am an ordinary function")
    def wrapper():
        print("I am function returned by the decorator")
        func()
    return wrapper

# Therefore, you can call it without any "@"

def lazy_function():
    print("zzzzzzzz")

decorated_function = my_decorator(lazy_function)
#outputs: I am an ordinary function

# It outputs "I am an ordinary function", because that’s just what you do:
# calling a function. Nothing magic.

@my_decorator
def lazy_function():
    print("zzzzzzzz")

#outputs: I am an ordinary function
    これは全く同じで、全部myです。decoratorが呼び出されます。だからあなたが使う時は@my_decoratorでは、pythonに「変数mycloratorによってマークされた」関数を呼び出してください。これはとても重要です。あなたがくれたこのラベルは直接装飾器や他のものを指すことができます。
    def decorator_maker():

    print("I make decorators! I am executed only once: "
          "when you make me create a decorator.")

    def my_decorator(func):

        print("I am a decorator! I am executed only when you decorate a function.")

        def wrapped():
            print("I am the wrapper around the decorated function. "
                  "I am called when you call the decorated function. "
                  "As the wrapper, I return the RESULT of the decorated function.")
            return func()

        print("As the decorator, I return the wrapped function.")

        return wrapped

    print("As a decorator maker, I return a decorator")
    return my_decorator

# Let’s create a decorator. It’s just a new function after all.
new_decorator = decorator_maker()       
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator

# Then we decorate the function

def decorated_function():
    print("I am the decorated function.")

decorated_function = new_decorator(decorated_function)
#outputs:
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function

# Let’s call the function:
decorated_function()
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
    驚きを感じないでください。全く同じことをさせてください。中間変数をスキップしただけです。
    def decorated_function():
    print("I am the decorated function.")
decorated_function = decorator_maker()(decorated_function)
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

# Finally:
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
    もう一度作ってください。コードはさらに短いです。
    @decorator_maker()
def decorated_function():
    print("I am the decorated function.")
#outputs:
#I make decorators! I am executed only once: when you make me create a decorator.
#As a decorator maker, I return a decorator
#I am a decorator! I am executed only when you decorate a function.
#As the decorator, I return the wrapped function.

#Eventually: 
decorated_function()    
#outputs:
#I am the wrapper around the decorated function. I am called when you call the decorated function.
#As the wrapper, I return the RESULT of the decorated function.
#I am the decorated function.
    私たちは@文法で関数を呼び出して、パラメータ付きの装飾器に戻ります。関数動的（オンザフライ）の生成装飾器を使えば、パラメータをその関数に渡すことができますか？
    def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):

    print("I make decorators! And I accept arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))

    def my_decorator(func):
        # The ability to pass arguments here is a gift from closures.
        # If you are not comfortable with closures, you can assume it’s ok,
        # or read: http://stackoverflow.com/questions/13857/can-you-explain-closures-as-they-relate-to-python
        print("I am the decorator. Somehow you passed me arguments: {0}, {1}".format(decorator_arg1, decorator_arg2))

        # Don't confuse decorator arguments and function arguments!
        def wrapped(function_arg1, function_arg2) :
            print("I am the wrapper around the decorated function.
    "
                  "I can access all the variables
    "
                  "\t- from the decorator: {0} {1}
    "
                  "\t- from the function call: {2} {3}
    "
                  "Then I can pass them to the decorated function"
                  .format(decorator_arg1, decorator_arg2,
                          function_arg1, function_arg2))
            return func(function_arg1, function_arg2)

        return wrapped

    return my_decorator

@decorator_maker_with_arguments("Leonard", "Sheldon")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments: {0}"
           " {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments("Rajesh", "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Sheldon
#I am the decorator. Somehow you passed me arguments: Leonard Sheldon
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Sheldon 
#   - from the function call: Rajesh Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Rajesh Howard
    これはパラメータ付きの装飾器です。パラメータは変数にも設定できます。
    c1 = "Penny"
c2 = "Leslie"

@decorator_maker_with_arguments("Leonard", c1)
def decorated_function_with_arguments(function_arg1, function_arg2):
    print("I am the decorated function and only knows about my arguments:"
           " {0} {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments(c2, "Howard")
#outputs:
#I make decorators! And I accept arguments: Leonard Penny
#I am the decorator. Somehow you passed me arguments: Leonard Penny
#I am the wrapper around the decorated function. 
#I can access all the variables 
#   - from the decorator: Leonard Penny 
#   - from the function call: Leslie Howard 
#Then I can pass them to the decorated function
#I am the decorated function and only knows about my arguments: Leslie Howard
    あなたが見ているように、装飾器にパラメータを伝えることができます。他のいずれかにこのようなトリックの関数が使われているようです。（。望みがあれば、＊args、＊kwargsを使ってもいいです。ただし、デバイスは一回しか呼び出さないことを覚えてください。pythonがこのスクリプトを導入した時だけです。パラメータはその後動的に設定できません。import xを実行すると、この関数は既に装飾されていますので、何も変更できません。
    実践：装飾器は装飾器を飾ります。（Let’s practice：a decorator to decorate a decorator）
    私たちは共通の任意のパラメータを受け入れられる飾り器を作るためのコードを示します。結局、パラメータを受け取るために、もう一つの関数を使って私たちの飾り器を作りました。飾り器を包装しました。私たちが見たばかりのものに、関数を包むものがありますか？はい、飾り器です。飾り器に飾り器を書いて遊びに来ます。:
    def decorator_with_args(decorator_to_enhance):
    """ 
    This function is supposed to be used as a decorator.
    It must decorate an other function, that is intended to be used as a decorator.
    Take a cup of coffee.
    It will allow any decorator to accept an arbitrary number of arguments,
    saving you the headache to remember how to do that every time.
    """

    # We use the same trick we did to pass arguments
    def decorator_maker(*args, **kwargs):

        # We create on the fly a decorator that accepts only a function
        # but keeps the passed arguments from the maker.
        def decorator_wrapper(func):

            # We return the result of the original decorator, which, after all, 
            # IS JUST AN ORDINARY FUNCTION (which returns a function).
            # Only pitfall: the decorator must have this specific signature or it won't work:
            return decorator_to_enhance(func, *args, **kwargs)

        return decorator_wrapper

    return decorator_maker
    このように使えます。
    # You create the function you will use as a decorator. And stick a decorator on it :-)
# Don't forget, the signature is "decorator(func, *args, **kwargs)"
@decorator_with_args 
def decorated_decorator(func, *args, **kwargs): 
    def wrapper(function_arg1, function_arg2):
        print("Decorated with {0} {1}".format(args, kwargs))
        return func(function_arg1, function_arg2)
    return wrapper

# Then you decorate the functions you wish with your brand new decorated decorator.

@decorated_decorator(42, 404, 1024)
def decorated_function(function_arg1, function_arg2):
    print("Hello {0} {1}".format(function_arg1, function_arg2))

decorated_function("Universe and", "everything")
#outputs:
#Decorated with (42, 404, 1024) {}
#Hello Universe and everything

# Whoooot!
    前回あなたが感じたのは、「再帰を理解する前に、再帰を理解しなければならない」という人の話を聞いた後です。しかし、今は把握してから、気持ちがいいと思いませんか？
    装飾器はどうやって使えますか？
    今問題がありました。装飾器を使って何ができますか？かっこよくて強いように見えますが、実際の例を作ったほうがいいです。典型的な用途は外部から導入された関数を拡張するための行為です。または調整のために（この関数を一時的に変更したくないです。）いくつかの関数に拡張するために同じコードだけで装飾器を使ってもいいです。また、毎回このコードを書き換える必要はありません。これはよく使うDRYです。
    def benchmark(func):
    """
    A decorator that prints the time a function takes
    to execute.
    """
    import time
    def wrapper(*args, **kwargs):
        t = time.clock()
        res = func(*args, **kwargs)
        print("{0} {1}".format(func.__name__, time.clock()-t))
        return res
    return wrapper


def logging(func):
    """
    A decorator that logs the activity of the script.
    (it actually just prints it, but it could be logging!)
    """
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        print("{0} {1} {2}".format(func.__name__, args, kwargs))
        return res
    return wrapper


def counter(func):
    """
    A decorator that counts and prints the number of times a function has been executed
    """
    def wrapper(*args, **kwargs):
        wrapper.count = wrapper.count + 1
        res = func(*args, **kwargs)
        print("{0} has been used: {1}x".format(func.__name__, wrapper.count))
        return res
    wrapper.count = 0
    return wrapper

@counter
@benchmark
@logging
def reverse_string(string):
    return str(reversed(string))

print(reverse_string("Able was I ere I saw Elba"))
print(reverse_string("A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!"))

#outputs:
#reverse_string ('Able was I ere I saw Elba',) {}
#wrapper 0.0
#wrapper has been used: 1x 
#ablE was I ere I saw elbA
#reverse_string ('A man, a plan, a canoe, pasta, heros, rajahs, a coloratura, maps, snipe, percale, macaroni, a gag, a banana bag, a tan, a tag, a banana bag again (or a camel), a crepe, pins, Spam, a rut, a Rolo, cash, a jar, sore hats, a peon, a canal: Panama!',) {}
#wrapper 0.0
#wrapper has been used: 2x
#!amanaP :lanac a ,noep a ,stah eros ,raj a ,hsac ,oloR a ,tur a ,mapS ,snip ,eperc a ,)lemac a ro( niaga gab ananab a ,gat a ,nat a ,gab ananab a ,gag a ,inoracam ,elacrep ,epins ,spam ,arutaroloc a ,shajar ,soreh ,atsap ,eonac a ,nalp a ,nam A
    もちろん、飾り器のいいところは、ほとんどのものを飾り、書き換えないことです。つまり、私が言っているDRYです。
    @counter
@benchmark
@logging
def get_random_futurama_quote():
    from urllib import urlopen
    result = urlopen("http://subfusion.net/cgi-bin/quote.pl?quote=futurama").read()
    try:
        value = result.split("

    ")[1].split("

    ")[0]
        return value.strip()
    except:
        return "No, I'm ... doesn't!"


print(get_random_futurama_quote())
print(get_random_futurama_quote())

#outputs:
#get_random_futurama_quote () {}
#wrapper 0.02
#wrapper has been used: 1x
#The laws of science be a harsh mistress.
#get_random_futurama_quote () {}
#wrapper 0.01
#wrapper has been used: 2x
#Curse you, merciful Poseidon!
    Python言語自体もいくつかの装飾器を提供しています。プロperty、staticmethodなど。Djangoは装飾器で和図権限を管理しています。Twistedはインライン非同期関数を偽装して呼び出します。
    締め括りをつける
    装飾器の核心的な役割はname bindingです。この文法はPython多プログラミングの範式のもう一つの表現です。ほとんどのPythonユーザーは装飾器を定義する必要がないですが、装飾器を使う可能性があります。Pythonプロジェクトでの装飾器の広範な使用にかんがみて、この言語法を知るのは非常に有益です。
    HU 1302-The Snail