Fitur tersembunyi dari Python [ditutup]

Apa saja fitur yang kurang diketahui tetapi berguna dari bahasa pemrograman Python?

• Cobalah untuk membatasi jawaban ke inti Python.
• Satu fitur per jawaban.
• Berikan contoh dan deskripsi singkat tentang fitur ini, bukan hanya tautan ke dokumentasi.
• Beri label fitur menggunakan judul sebagai baris pertama.

Tautan cepat ke jawaban:

• Argumen Membongkar
• Kawat gigi
• Operator Perbandingan Chaining
• Dekorator
• Argumen Default Gotchas / Bahaya Mutable, Argumen Default
• Penjelas
• .getNilai default kamus
• Tes Dokumentasi
• Ellipsis Slicing Syntax
• Pencacahan
• Untuk / lainnya
• Berfungsi sebagai argumen iter ()
• Ekspresi generator
• import this
• Swapping Nilai Di Tempat
• Daftar loncatan
• __missing__ barang
• Multi-line Regex
• Memformat string bernama
• Pemahaman daftar / generator bersarang
• Jenis baru saat runtime
• .pth file
• Pengodean ROT13
• Regex Debugging
• Mengirim ke Generator
• Penyelesaian Tab dalam Interpreter Interaktif
• Ekspresi Ternary
• try/except/else
• Membongkar print()fungsi +
• with pernyataan

Operator perbandingan operator:

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

Jika Anda berpikir sedang melakukan 1 < x, yang keluar sebagai True, dan kemudian membandingkan True < 10, yang juga True, maka tidak, itu benar-benar bukan yang terjadi (lihat contoh terakhir.) Ini benar-benar diterjemahkan ke dalam 1 < x and x < 10, dan x < 10 and 10 < x * 10 and x*10 < 100, tetapi dengan kurang mengetik dan masing-masing Istilah ini hanya dievaluasi sekali.

Dapatkan pohon parse regex python untuk men-debug regex Anda.

Ekspresi reguler adalah fitur hebat dari python, tetapi men-debug-nya bisa sangat menyebalkan, dan terlalu mudah untuk membuat kesalahan regex.

Untungnya, python dapat mencetak pohon parse regex, dengan melewatkan flag yang tidak didokumentasikan, eksperimental, dan disembunyikan re.DEBUG(sebenarnya, 128) ke 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

Setelah Anda memahami sintaks, Anda dapat menemukan kesalahan Anda. Di sana kita bisa melihat bahwa saya lupa untuk melarikan diri []di [/font].

Tentu saja Anda dapat menggabungkannya dengan bendera apa pun yang Anda inginkan, seperti regex yang dikomentari:

>>> 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)

menghitung

Bungkus iterable dengan enumerate dan itu akan menghasilkan item beserta indeksnya.

Sebagai contoh:

>>> 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
>>>

Referensi:

• Tutorial Python — teknik pengulangan
• Python docs — fungsi bawaan—enumerate
• PEP 279

Membuat objek generator

Jika kamu menulis

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

Anda bisa mengeluarkan generator dan menugaskannya ke x. Sekarang berarti Anda bisa melakukannya

for n in x:

Keuntungan dari hal ini adalah Anda tidak perlu penyimpanan perantara, yang akan Anda perlukan jika memang perlu

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

Dalam beberapa kasus, ini dapat mempercepat secara signifikan.

Anda dapat menambahkan banyak pernyataan if ke akhir generator, yang pada dasarnya mereplikasi nested for loop:

>>> 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 () dapat mengambil argumen yang bisa dipanggil

Contohnya:

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

The iter(callable, until_value)fungsi berulang kali memanggil callabledan menghasilkan hasilnya sampai until_valuedikembalikan.

Hati-hati dengan argumen default yang bisa berubah

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

Alih-alih, Anda harus menggunakan nilai sentinel yang menunjukkan "tidak diberikan" dan ganti dengan yang dapat diubah yang Anda inginkan sebagai default:

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

Mengirim nilai ke fungsi generator . Misalnya memiliki fungsi ini:

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

Kamu bisa:

>>> 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

Jika Anda tidak suka menggunakan spasi untuk menunjukkan cakupan, Anda dapat menggunakan gaya-C {} dengan mengeluarkan:

from __future__ import braces

Argumen langkah dalam operator slice. Sebagai contoh:

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

Kasus khusus x[::-1]adalah ungkapan yang berguna untuk 'x terbalik'.

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

Dekorator

Dekorator memungkinkan untuk membungkus fungsi atau metode dalam fungsi lain yang dapat menambah fungsionalitas, memodifikasi argumen atau hasil, dll. Anda menulis dekorator satu baris di atas definisi fungsi, dimulai dengan tanda "at" (@).

Contoh menunjukkan print_argsdekorator yang mencetak argumen fungsi yang didekorasi sebelum memanggilnya:

>>> 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

Sintaks untuk ... else (lihat http://docs.python.org/ref/for.html )

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

Blok "lain" biasanya akan dieksekusi pada akhir dari for loop, kecuali jika break disebut.

Kode di atas dapat ditiru sebagai berikut:

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

Dari 2,5 dan seterusnya dikte memiliki metode khusus __missing__yang dipanggil untuk item yang hilang:

>>> 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]}

Ada juga subkelas dict yang collectionsdisebutnya defaultdictyang melakukan hampir sama tetapi memanggil fungsi tanpa argumen untuk item yang tidak ada:

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

Saya sarankan untuk mengubah dikte tersebut menjadi dikte biasa sebelum meneruskannya ke fungsi yang tidak diharapkan subkelas tersebut. Banyak kode menggunakan d[a_key]dan menangkap KeyErrors untuk memeriksa apakah ada item yang akan menambahkan item baru ke dikt.

Penukaran nilai di tempat

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

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

Sisi kanan penugasan adalah ekspresi yang membuat tuple baru. Sisi kiri penugasan segera membongkar bahwa (tidak direferensikan) tuple ke nama adan b.

Setelah penugasan, tuple baru tidak direferensikan dan ditandai untuk pengumpulan sampah, dan nilai-nilai terikat adan btelah ditukar.

Seperti yang disebutkan di bagian tutorial Python tentang struktur data ,

Perhatikan bahwa banyak tugas benar-benar hanya kombinasi dari pengemasan tuple dan urutan pembongkaran.

Ekspresi reguler yang dapat dibaca

Dengan Python Anda dapat membagi ekspresi reguler menjadi beberapa baris, beri nama kecocokan Anda dan masukkan komentar.

Contoh sintaksis verbose (dari Menyelam ke 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)

Contoh penamaan yang cocok (dari Regular Expression HOWTO )

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

Anda juga dapat secara tertulis menulis regex tanpa menggunakan re.VERBOSEterima kasih kepada string literal.

>>> 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})$"

Argumen fungsi membongkar

Anda dapat membongkar daftar atau kamus sebagai argumen fungsi menggunakan *dan **.

Sebagai contoh:

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)

Jalan pintas yang sangat berguna karena daftar, tupel dan dikte banyak digunakan sebagai wadah.

ROT13 adalah pengodean yang valid untuk kode sumber, ketika Anda menggunakan deklarasi pengkodean yang tepat di bagian atas file kode:

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

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

Membuat tipe baru dengan cara yang sepenuhnya dinamis

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

yang persis sama dengan

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

Mungkin bukan hal yang paling berguna, tapi menyenangkan untuk diketahui.

Sunting : Nama tetap tipe baru, harus NewTypesama persis dengan classpernyataan.

Sunting : Menyesuaikan judul untuk menjelaskan fitur dengan lebih akurat.

Manajer konteks dan pernyataan " with"

Diperkenalkan dalam PEP 343 , manajer konteks adalah objek yang bertindak sebagai konteks run-time untuk serangkaian pernyataan.

Karena fitur ini menggunakan kata kunci baru, diperkenalkan secara bertahap: ini tersedia dalam Python 2.5 melalui __future__arahan. Python 2.6 dan di atasnya (termasuk Python 3) telah tersedia secara default.

Saya sering menggunakan pernyataan "with" karena saya pikir ini adalah konstruk yang sangat berguna, berikut adalah demo singkatnya:

from __future__ import with_statement

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

Apa yang terjadi di sini di belakang layar, adalah bahwa pernyataan "with" memanggil spesial__enter__ dan __exit__pada objek file. Detail pengecualian juga diteruskan ke __exit__jika ada pengecualian yang diajukan dari badan pernyataan with, yang memungkinkan penanganan pengecualian terjadi di sana.

Apa yang ini lakukan untuk Anda dalam kasus khusus ini adalah bahwa ia menjamin bahwa file ditutup ketika eksekusi keluar dari ruang lingkup with suite, terlepas dari apakah itu terjadi secara normal atau apakah pengecualian dilemparkan. Ini pada dasarnya adalah cara untuk mengabstraksi kode penanganan pengecualian yang umum.

Kasing penggunaan umum lainnya untuk ini termasuk penguncian dengan utas dan transaksi basis data.

Kamus memiliki metode get ()

Kamus memiliki metode 'get ()'. Jika Anda melakukan d ['kunci'] dan kunci tidak ada di sana, Anda akan mendapatkan pengecualian. Jika Anda melakukannya d.get ('kunci'), Anda mendapatkan kembali Tidak ada jika 'kunci' tidak ada. Anda dapat menambahkan argumen kedua untuk mendapatkan item itu kembali sebagai ganti None, mis .: d.get ('key', 0).

Ini bagus untuk hal-hal seperti menambahkan angka:

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

Penjelas

Mereka adalah keajaiban di balik sejumlah fitur inti Python.

Ketika Anda menggunakan akses bertitik untuk mencari anggota (misalnya, xy), Python pertama mencari anggota dalam kamus contoh. Jika tidak ditemukan, akan dicari di kamus kelas. Jika menemukannya di kamus kelas, dan objek mengimplementasikan protokol deskriptor, alih-alih mengembalikannya, Python menjalankannya. Sebuah descriptor adalah setiap kelas yang mengimplementasikan __get__, __set__atau __delete__metode.

Inilah cara Anda akan menerapkan versi properti Anda (hanya baca) menggunakan deskriptor:

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)

dan Anda akan menggunakannya seperti properti bawaan ():

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

Penjelas digunakan dalam Python untuk mengimplementasikan properti, metode terikat, metode statis, metode kelas, dan slot, di antara hal-hal lainnya. Memahami mereka membuatnya mudah untuk melihat mengapa banyak hal yang sebelumnya tampak seperti 'quirks' Python adalah cara mereka.

Raymond Hettinger memiliki tutorial yang sangat baik yang melakukan pekerjaan yang jauh lebih baik dalam menggambarkan mereka daripada saya.

Tugas Bersyarat

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

Itu tidak persis seperti apa terdengar: "tetapkan 3 ke x jika y adalah 1, jika tidak tetapkan 2 ke x". Perhatikan bahwa parens tidak diperlukan, tetapi saya suka agar mudah dibaca. Anda juga dapat mengaitkannya jika memiliki sesuatu yang lebih rumit:

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

Meskipun pada titik tertentu, itu agak terlalu jauh.

Perhatikan bahwa Anda dapat menggunakan if ... else dalam ekspresi apa pun. Sebagai contoh:

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

Di sini func1 akan dipanggil jika y adalah 1 dan func2, jika tidak. Dalam kedua kasus fungsi yang sesuai akan dipanggil dengan argumen arg1 dan arg2.

Secara analog, yang berikut ini juga valid:

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

dimana class1 dan class2 adalah dua kelas.

Doctest : dokumentasi dan pengujian unit pada saat bersamaan.

Contoh diekstrak dari dokumentasi 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()

Pemformatan yang diberi nama

% -formatting mengambil kamus (juga berlaku validasi% i /% s dll.)

>>> 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.

Dan karena penduduk lokal () juga merupakan kamus, Anda dapat dengan mudah menyampaikannya sebagai dict dan memiliki% -substitions dari variabel lokal Anda. Saya pikir ini disukai, tetapi menyederhanakan hal-hal ..

Pemformatan Gaya Baru

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

Untuk menambahkan lebih banyak modul python (terutama yang pihak ke-3), kebanyakan orang tampaknya menggunakan variabel lingkungan PYTHONPATH atau mereka menambahkan symlink atau direktori di direktori paket-situs mereka. Cara lain, adalah dengan menggunakan file * .pth. Berikut penjelasan resmi python doc:

"Cara paling mudah [untuk memodifikasi jalur pencarian python] adalah dengan menambahkan file konfigurasi path ke direktori yang sudah ada di path Python, biasanya ke ... / situs-paket / direktori. File konfigurasi path memiliki ekstensi .pth , dan setiap baris harus berisi jalur tunggal yang akan ditambahkan ke sys.path. (Karena jalur baru ditambahkan ke sys.path, modul di direktori yang ditambahkan tidak akan menimpa modul standar. Ini berarti Anda tidak dapat menggunakan mekanisme ini untuk menginstal versi tetap dari modul standar.) "

Klausa pengecualian lain :

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

Penggunaan klausa lain lebih baik daripada menambahkan kode tambahan ke klausa coba karena menghindari secara tidak sengaja menangkap pengecualian yang tidak dimunculkan oleh kode yang dilindungi oleh percobaan ... kecuali pernyataan.

Lihat http://docs.python.org/tut/node10.html

Memunculkan kembali pengecualian :

# 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)

Pernyataan 'naikkan' tanpa argumen di dalam penangan kesalahan memberitahu Python untuk menaikkan kembali pengecualian dengan traceback asli yang utuh , memungkinkan Anda untuk mengatakan "oh, maaf, maaf, saya tidak bermaksud menangkap itu, maaf, maaf. "

Jika Anda ingin mencetak, menyimpan, atau mengutak-atik traceback asli, Anda bisa mendapatkannya dengan sys.exc_info (), dan mencetaknya seperti yang dilakukan Python dilakukan dengan modul 'traceback'.

Pesan utama :)

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

Di-cyphered :

Zen Python, oleh Tim Peters

Cantik lebih baik dari yang jelek.
Eksplisit lebih baik daripada implisit.
Sederhana lebih baik daripada kompleks.
Kompleks lebih baik daripada rumit.
Flat lebih baik daripada bersarang.
Jarang lebih baik daripada padat.
Jumlah keterbacaan diperhitungkan.
Kasus khusus tidak cukup istimewa untuk melanggar aturan.
Meskipun kepraktisan mengalahkan kemurnian.
Kesalahan tidak boleh terjadi secara diam-diam.
Kecuali secara eksplisit dibungkam.
Dalam menghadapi ambiguitas, tolak godaan untuk menebak. Harus ada satu - dan lebih disukai hanya satu - cara yang jelas untuk melakukannya.
Meskipun demikian mungkin tidak jelas pada awalnya kecuali Anda orang Belanda.
Sekarang lebih baik daripada tidak sama sekali.
Meskipun tidak pernah sering lebih baik daripadatepat sekarang.
Jika implementasinya sulit dijelaskan, itu ide yang buruk.
Jika implementasinya mudah dijelaskan, mungkin itu ide yang bagus.
Namespaces adalah salah satu ide bagus - mari kita lakukan lebih banyak lagi!

Penyelesaian Tab Interpreter Interaktif

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()

Anda juga harus menetapkan variabel lingkungan PYTHONSTARTUP.

Pemahaman daftar bersarang dan ekspresi generator:

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

Ini dapat menggantikan potongan besar kode nested-loop.

Overloading operator untuk setbuiltin:

>>> 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}

Lebih detail dari referensi pustaka standar: Set Type