Приховані особливості Python [закрито]

Які маловідомі, але корисні функції мови програмування Python?

• Спробуйте обмежити відповіді ядром Python.
• Одна особливість на відповідь.
• Наведіть приклад та короткий опис функції, а не лише посилання на документацію.
• Позначте функцію, використовуючи заголовок у якості першого рядка.

Швидкі посилання на відповіді:

• Розпакування аргументу
• Брекети
• Оператори ланцюга порівняння
• Декоратори
• Аргумент за замовчуванням Gotchas / Небезпека змінних аргументів за замовчуванням
• Дескриптори
• .getЗначення за замовчуванням у словнику
• Докстринг-тести
• Синтаксис нарізки еліпсису
• Перерахування
• Для / інакше
• Функція як аргумент iter ()
• Генераторні вирази
• import this
• В заміні вартості місця
• Список крокових
• __missing__ предметів
• Багаторядковий Regex
• Форматування іменних рядків
• Вкладені розуміння списку / генератора
• Нові типи під час виконання
• .pth файли
• ROT13 Кодування
• Налагодження Regex
• Надсилання генераторам
• Завершення вкладки в інтерактивному перекладачі
• Потрійний вираз
• try/except/else
• Розпакування + print()функція
• with заява

Оператори ланцюга порівняння:

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20 
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True

У разі , якщо ви думаєте , що він робить 1 < x, який виходить як True, а потім порівняння True < 10, який також True, то немає, це на самому справі не те , що відбувається (див останній приклад.) Це дійсно переклад в 1 < x and x < 10і x < 10 and 10 < x * 10 and x*10 < 100, але з меншим кількістю введення і кожен Термін оцінюється лише один раз.

Отримайте дерево аналізу синтаксису python, щоб налагодити свій регулярний вираз.

Регулярні вирази - відмінна риса python, але налагодження їх може бути болем, і неправильно підвести регулярний вираз.

На щастя, python може надрукувати дерево розбору регулярних виразів, передавши недокументований, експериментальний, прихований прапор re.DEBUG(насправді, 128) re.compile.

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

Як тільки ви зрозумієте синтаксис, ви можете помітити свої помилки. Там ми можемо бачити , що я забув , щоб уникнути []ін [/font].

Звичайно, ви можете комбінувати його з будь-якими прапорами, як, наприклад, з коментованими регулярними виразами:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

перерахувати

Оберніть ітерабельний номер із перерахуванням, і він отримає елемент разом із його індексом.

Наприклад:

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>>

Список літератури:

• Підручник Python - методи циклічного циклу
• Документи Python - вбудовані функції -enumerate
• PEP 279

Створення об’єктів генераторів

Якщо ти пишеш

x=(n for n in foo if bar(n))

ви можете дістати генератор і призначити його x. Тепер це означає, що ви можете зробити

for n in x:

Перевагою цього є те, що вам не потрібно проміжне зберігання, яке вам знадобиться, якби ви це зробили

x = [n for n in foo if bar(n)]

У деяких випадках це може призвести до значного прискорення.

Ви можете додати багато, якщо заяви до кінця генератора, в основному реплікуючи вкладені для циклів:

>>> n = ((a,b) for a in range(0,2) for b in range(4,6))
>>> for i in n:
...   print i 

(0, 4)
(0, 5)
(1, 4)
(1, 5)

iter () може приймати аргумент, що викликається

Наприклад:

def seek_next_line(f):
    for c in iter(lambda: f.read(1),'\n'):
        pass

iter(callable, until_value)Функція багаторазово викликає callableі дає свій результат , поки until_valueне буде повернений.

Будьте обережні з змінними аргументами за замовчуванням

>>> def foo(x=[]):
...     x.append(1)
...     print x
... 
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

Натомість слід використовувати дозорне значення, що позначає "не дано", та замінити його на мутант, який ви хотіли б за замовчуванням:

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
>>> foo()
[1]
>>> foo()
[1]

Надсилання значень у функції генератора . Наприклад, що має цю функцію:

def mygen():
    """Yield 5 until something else is passed back via send()"""
    a = 5
    while True:
        f = (yield a) #yield a and possibly get f in return
        if f is not None: 
            a = f  #store the new value

Ти можеш:

>>> g = mygen()
>>> g.next()
5
>>> g.next()
5
>>> g.send(7)  #we send this back to the generator
7
>>> g.next() #now it will yield 7 until we send something else
7

Якщо вам не подобається використовувати пробіл для позначення областей, ви можете використовувати стиль C {}, видавши:

from __future__ import braces

Аргумент кроків в операторах фрагментів Наприклад:

a = [1,2,3,4,5]
>>> a[::2]  # iterate over the whole list in 2-increments
[1,3,5]

Окремий випадок x[::-1]є корисною фразою для "x reversed".

>>> a[::-1]
[5,4,3,2,1]

Декоратори

Декоратори дозволяють перенести функцію або метод в іншу функцію, яка може додавати функціональність, змінювати аргументи або результати і т. Д. Ви пишете декораторів на один рядок над визначенням функції, починаючи зі знака "at" (@).

Приклад показує print_argsдекоратор, який друкує аргументи оформленої функції перед тим, як викликати її:

>>> def print_args(function):
>>>     def wrapper(*args, **kwargs):
>>>         print 'Arguments:', args, kwargs
>>>         return function(*args, **kwargs)
>>>     return wrapper

>>> @print_args
>>> def write(text):
>>>     print text

>>> write('foo')
Arguments: ('foo',) {}
foo

Синтаксис для ... else (див. Http://docs.python.org/ref/for.html )

for i in foo:
    if i == 0:
        break
else:
    print("i was never 0")

Блок "else", як правило, виконується в кінці циклу for, якщо тільки не викликається перерва.

Вищевказаний код можна імітувати так:

found = False
for i in foo:
    if i == 0:
        found = True
        break
if not found: 
    print("i was never 0")

Починаючи з 2.5 і далі дикти мають спеціальний метод, __missing__який викликається для відсутніх елементів:

>>> class MyDict(dict):
...  def __missing__(self, key):
...   self[key] = rv = []
...   return rv
... 
>>> m = MyDict()
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Існує також диктує підклас collectionsназивається , defaultdictщо робить майже те ж саме , але викликає функцію без аргументів для не існують пунктів:

>>> from collections import defaultdict
>>> m = defaultdict(list)
>>> m["foo"].append(1)
>>> m["foo"].append(2)
>>> dict(m)
{'foo': [1, 2]}

Я рекомендую перетворити такі дикти в звичайні, перш ніж передати їх у функції, які не очікують таких підкласів. Багато коду використовує d[a_key]та ловить KeyErrors, щоб перевірити, чи існує елемент, який додав би новий елемент до диктату.

Поміняння вартості на місці

>>> a = 10
>>> b = 5
>>> a, b
(10, 5)

>>> a, b = b, a
>>> a, b
(5, 10)

Права частина завдання - вираз, що створює новий кортеж. Ліва частина завдання негайно розпаковує, що (невідредаговане) вкладається в імена aта b.

Після присвоєння новий кортеж залишається невизначеним і позначений для вивезення сміття, а значення, пов'язані з aта bбули замінені.

Як зазначено в розділі підручника Python про структури даних ,

Зауважте, що багаторазове призначення - це лише комбінація упаковки кортежу та розпакування послідовностей.

Зрозумілі регулярні вирази

У Python ви можете розділити регулярний вираз на кілька рядків, назвати відповідність і вставити коментарі.

Приклад багатослівного синтаксису (від занурення в Python ):

>>> pattern = """
... ^                   # beginning of string
... M{0,4}              # thousands - 0 to 4 M's
... (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                     #            or 500-800 (D, followed by 0 to 3 C's)
... (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                     #        or 50-80 (L, followed by 0 to 3 X's)
... (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                     #        or 5-8 (V, followed by 0 to 3 I's)
... $                   # end of string
... """
>>> re.search(pattern, 'M', re.VERBOSE)

Приклад узгодження імен (з Regular Expression HOWTO )

>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'

Ви також можете докладно написати регулярний вираз без використання re.VERBOSEзавдяки рядковому буквеному конкатенації.

>>> pattern = (
...     "^"                 # beginning of string
...     "M{0,4}"            # thousands - 0 to 4 M's
...     "(CM|CD|D?C{0,3})"  # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
...                         #            or 500-800 (D, followed by 0 to 3 C's)
...     "(XC|XL|L?X{0,3})"  # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
...                         #        or 50-80 (L, followed by 0 to 3 X's)
...     "(IX|IV|V?I{0,3})"  # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
...                         #        or 5-8 (V, followed by 0 to 3 I's)
...     "$"                 # end of string
... )
>>> print pattern
"^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$"

Розпакування аргументу функції

Ви можете розпакувати список або словник як аргументи функції за допомогою *і **.

Наприклад:

def draw_point(x, y):
    # do some magic

point_foo = (3, 4)
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)
draw_point(**point_bar)

Дуже корисний ярлик, оскільки списки, кортежі та дикти широко використовуються як контейнери.

ROT13 є дійсним кодуванням вихідного коду, коли ви використовуєте правильну заяву кодування у верхній частині файлу коду:

#!/usr/bin/env python
# -*- coding: rot13 -*-

cevag "Uryyb fgnpxbiresybj!".rapbqr("rot13")

Створення нових типів повністю динамічним чином

>>> NewType = type("NewType", (object,), {"x": "hello"})
>>> n = NewType()
>>> n.x
"hello"

що точно так само, як

>>> class NewType(object):
>>>     x = "hello"
>>> n = NewType()
>>> n.x
"hello"

Напевно, не найкорисніше, але приємно знати.

Редагувати : Виправлена ​​назва нового типу має бути NewTypeточно такою ж, як і у classоператорі.

Редагувати : відрегульовано заголовок для більш точного опису функції.

Контекстні менеджери та " with" Заява

Введений у PEP 343 , менеджер контексту - це об'єкт, який виконує роль контексту виконання для набору висловлювань.

Оскільки функція використовує нові ключові слова, вона вводиться поступово: вона доступна в Python 2.5 через __future__директиву. У Python 2.6 і вище (включаючи Python 3) доступні за замовчуванням.

Я багато використовував оператор "з", тому що думаю, що це дуже корисна конструкція, ось швидка демонстрація:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

Що відбувається тут за лаштунками, це те, що оператор «з» викликає особливості __enter__та __exit__методи на файловому об’єкті. Деталі про винятки також передаються, __exit__якщо будь-який виняток був порушений з органом оператора з оператором, що дозволяє обробці виключень там відбуватися.

У цьому конкретному випадку це для вас - це те, що він гарантує закриття файлу, коли виконання виходить за межі withнабору, незалежно від того , чи це нормально відбувається або викинуто виняток. Це в основному спосіб абстрагування загального коду обробки обставин.

Інші поширені випадки використання для цього включають блокування потоками та транзакції бази даних.

Словники мають метод get ()

Словники мають метод "get ()". Якщо ви робите d ['key'], а ключ немає, ви отримуєте виняток. Якщо ви робите d.get ("ключ"), ви отримуєте "None", якщо "ключ" немає. Ви можете додати другий аргумент, щоб повернути цей елемент замість None, наприклад: d.get ('key', 0).

Це чудово підходить для таких речей, як додавання чисел:

sum[value] = sum.get(value, 0) + 1

Дескриптори

Вони - магія за цілою купою основних функцій Python.

Коли ви використовуєте пунктирний доступ для пошуку члена (наприклад, xy), Python спочатку шукає члена в словнику екземпляра. Якщо його не знайдено, він шукає його у словнику класів. Якщо він знайде його в словнику класів, а об'єкт реалізує протокол дескриптора, замість того, щоб просто повернути його, Python виконує його. Дескриптор є будь-який клас , який реалізує __get__, __set__або __delete__методи.

Ось як ви реалізували власну (лише для читання) версію властивості за допомогою дескрипторів:

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

і ви використовуєте його так само, як і вбудовану властивість ():

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

Дескриптори використовуються в Python для реалізації властивостей, зв'язаних методів, статичних методів, методів класів та слотів, серед іншого. Розуміючи їх, можна легко зрозуміти, чому багато речей, які раніше були схожими на "хитрощі" Python, є такими, якими вони є.

Реймонд Хеттінгер має чудовий підручник, який робить набагато кращу роботу щодо їх опису, ніж я.

Умовне призначення

x = 3 if (y == 1) else 2

Це робиться саме так, як це звучить: "призначте 3 х x, якщо y дорівнює 1, інакше призначте 2 до х". Зауважте, що паролі не потрібні, але я люблю їх за читабельність. Ви також можете ланцюжок, якщо у вас є щось складніше:

x = 3 if (y == 1) else 2 if (y == -1) else 1

Хоча в певний момент це заходить занадто далеко.

Зауважте, що ви можете використовувати if ... else у будь-якому виразі. Наприклад:

(func1 if y == 1 else func2)(arg1, arg2) 

Тут func1 буде називатися, якщо y дорівнює 1, а func2, інакше. В обох випадках відповідна функція буде викликана аргументами arg1 та arg2.

Аналогічно, діє також таке:

x = (class1 if y == 1 else class2)(arg1, arg2)

де class1 та class2 - два класи.

Doctest : документація та тестування одиниць одночасно.

Приклад, витягнутий з документації Python:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()

Іменоване форматування

% -форматування бере словник (також застосовується перевірка% i /% s тощо).

>>> print "The %(foo)s is %(bar)i." % {'foo': 'answer', 'bar':42}
The answer is 42.

>>> foo, bar = 'question', 123

>>> print "The %(foo)s is %(bar)i." % locals()
The question is 123.

А оскільки locals () також є словником, ви можете просто передати це як диктант і мати% -заміни з ваших локальних змінних. Я думаю, це нахмуриться, але спрощує речі.

Форматування нового стилю

>>> print("The {foo} is {bar}".format(foo='answer', bar=42))

Щоб додати більше модулів python (особливо сторонніх), більшість людей, схоже, використовують змінні середовища PYTHONPATH або вони додають символьні посилання або каталоги у своїх каталогах пакунків сайтів. Інший спосіб - використовувати * .pth файли. Ось офіційне пояснення доктора python:

"Найзручніший спосіб [змінити шлях пошуку python] - це додавання файлу конфігурації шляху до каталогу, який вже знаходиться на шляху Python, як правило, до ... / site-пакети / каталог. Файли конфігурації контуру мають розширення .pth , і кожен рядок повинен містити єдиний шлях, який буде доданий до sys.path. (Оскільки нові шляхи додаються до sys.path, модулі в доданих каталогах не замінять стандартні модулі. Це означає, що ви не можете використовувати цей механізм для встановлення фіксованих версій стандартних модулів.) "

Виняток ще стаття:

try:
  put_4000000000_volts_through_it(parrot)
except Voom:
  print "'E's pining!"
else:
  print "This parrot is no more!"
finally:
  end_sketch()

Використовувати застереження else краще, ніж додавати додатковий код до пункту спробу, оскільки це дозволяє уникнути випадкового лову винятку, який не був порушений кодом, захищеним спробувати try ... крім оператора.

Див. Http://docs.python.org/tut/node10.html

Повторне виняток :

# Python 2 syntax
try:
    some_operation()
except SomeError, e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

# Python 3 syntax
try:
    some_operation()
except SomeError as e:
    if is_fatal(e):
        raise
    handle_nonfatal(e)

Заява "підняти" без аргументів всередині обробника помилок повідомляє Python повторно підняти виняток з первинним простеженням недоторканим , що дозволяє вам сказати "о, вибачте, вибачте, я не хотів це зрозуміти, вибачте, вибачте. "

Якщо ви хочете надрукувати, зберегти або поспілкуватися з оригінальним прослідковуванням, ви можете отримати його за допомогою sys.exc_info (), а друк, як у Python, виконується за допомогою модуля 'traceback'.

Основні повідомлення :)

import this
# btw look at this module's source :)

Дефіфіковано :

Дзен Пітона, Тім Петерс

Красиве краще, ніж потворне.
Явне краще, ніж неявне.
Просте - краще, ніж складне.
Комплекс краще, ніж складний.
Квартира краще, ніж вкладена.
Розріджений краще, ніж щільний.
Читання рахується.
Особливі випадки недостатньо спеціальні для порушення правил.
Хоча практичність перемагає чистоту.
Помилки ніколи не повинні проходити мовчки.
Якщо явно мовчати.
В умовах неоднозначності відмовтеся від спокуси здогадатися. Повинно бути один - і бажано лише один - очевидний спосіб це зробити.
Хоча спочатку цей спосіб може бути не очевидним, якщо ви не голландці.
Зараз краще, ніж ніколи.
Хоча ніколи не буває краще, ніжпрямо зараз.
Якщо реалізацію важко пояснити, це погана ідея.
Якщо реалізацію легко пояснити, це може бути хорошою ідеєю.
Простори імен - це чудова ідея - давайте зробимо більше таких!

Завершення вкладки інтерактивного перекладача

try:
    import readline
except ImportError:
    print "Unable to load readline module."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")


>>> class myclass:
...    def function(self):
...       print "my function"
... 
>>> class_instance = myclass()
>>> class_instance.<TAB>
class_instance.__class__   class_instance.__module__
class_instance.__doc__     class_instance.function
>>> class_instance.f<TAB>unction()

Вам також доведеться встановити змінну середовища PYTHONSTARTUP.

Вкладені розуміння списку та вирази генератора:

[(i,j) for i in range(3) for j in range(i) ]    
((i,j) for i in range(4) for j in range(i) )

Вони можуть замінити величезні фрагменти коду вкладеного циклу.

Перевантаження оператора для setвбудованого:

>>> a = set([1,2,3,4])
>>> b = set([3,4,5,6])
>>> a | b # Union
{1, 2, 3, 4, 5, 6}
>>> a & b # Intersection
{3, 4}
>>> a < b # Subset
False
>>> a - b # Difference
{1, 2}
>>> a ^ b # Symmetric Difference
{1, 2, 5, 6}

Більш детально зі стандартної посилання на бібліотеку: Встановити типи