คุณสมบัติที่ซ่อนของ Python [ปิด]

ฟีเจอร์ที่เป็นที่รู้จักน้อย แต่มีประโยชน์ของภาษาการเขียนโปรแกรม Python คืออะไร

• พยายาม จำกัด คำตอบสำหรับ Python core
• หนึ่งคุณลักษณะต่อคำตอบ
• ยกตัวอย่างและคำอธิบายโดยย่อของคุณสมบัติไม่ใช่แค่ลิงก์ไปยังเอกสารประกอบ
• ติดป้ายกำกับสถานที่โดยใช้หัวเรื่องเป็นบรรทัดแรก

ลิงก์ด่วนไปยังคำตอบ:

• อาร์กิวเมนต์เปิดออก
• วงเล็บปีกกา
• ตัวดำเนินการเปรียบเทียบการโยง
• ตกแต่ง
• อาร์กิวเมนต์เริ่มต้น Gotchas / อันตรายจากอาร์กิวเมนต์เริ่มต้นที่ไม่แน่นอน
• อธิบาย
• เริ่มต้นพจนานุกรม.getคุ้มค่า
• การทดสอบ Docstring
• ไวยากรณ์ของการแบ่งไข่ปลา
• การนับ
• สำหรับ / อื่น
• ทำหน้าที่เป็นอาร์กิวเมนต์ 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 regex tree tree เพื่อดีบัก regex ของคุณ

นิพจน์ทั่วไปเป็นคุณลักษณะที่ยอดเยี่ยมของงูหลาม แต่การดีบั๊กมันอาจเป็นความเจ็บปวดและมันง่ายเกินไปที่จะทำผิด regex

โชคดีที่หลามสามารถพิมพ์ต้นไม้แยก regex โดยไม่มีเอกสารที่ผ่านการทดลองธงที่ซ่อนอยู่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]

แน่นอนคุณสามารถรวมเข้ากับธงใด ๆ ที่คุณต้องการเช่นความคิดเห็น regexes:

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

การระบุ

ล้อมรอบ iterable ด้วย enumerate และมันจะให้ไอเท็มพร้อมกับดัชนี

ตัวอย่างเช่น:

>>> 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 tutorial— เทคนิคการวนซ้ำ
• Python docs— ฟังก์ชั่นในตัว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]

คุณควรใช้ค่า Sentinel แทน "ไม่ได้รับ" และแทนที่ด้วยค่าที่ไม่แน่นอนที่คุณต้องการเป็นค่าเริ่มต้น:

>>> 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-style {} โดยการออก:

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 กลับด้าน'

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

ตกแต่ง

Decoratorsอนุญาตให้ห่อฟังก์ชั่นหรือวิธีการในฟังก์ชั่นอื่นที่สามารถเพิ่มฟังก์ชั่นการแก้ไขข้อโต้แย้งหรือผลลัพธ์ ฯลฯ คุณเขียนมัณฑนากรหนึ่งบรรทัดด้านบนนิยามฟังก์ชั่นเริ่มต้นด้วยเครื่องหมาย "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 loop ยกเว้นว่ามีการแบ่ง

โค้ดด้านบนสามารถจำลองได้ดังต่อไปนี้:

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

จาก 2.5 เป็นต้นไป dicts มีวิธีพิเศษ__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]}

นอกจากนี้ยังมีคลาสย่อย dict ที่collectionsเรียกdefaultdictว่าคล้ายกันมาก แต่เรียกใช้ฟังก์ชันที่ไม่มีอาร์กิวเมนต์สำหรับรายการที่ไม่มีอยู่:

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

ฉันขอแนะนำให้แปลง dicts ดังกล่าวเป็น dicts ปกติก่อนที่จะส่งผ่านไปยังฟังก์ชันที่ไม่ต้องการคลาสย่อยดังกล่าว รหัสจำนวนมากใช้d[a_key]และจับ KeyErrors เพื่อตรวจสอบว่ามีรายการอยู่หรือไม่ซึ่งจะเพิ่มรายการใหม่ให้กับ dict

การแลกเปลี่ยนค่าในสถานที่

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

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

ทางด้านขวาของการมอบหมายคือนิพจน์ที่สร้าง tuple ใหม่ ด้านซ้ายมือของงานทันทีที่ unpacks (unreferenced) tuple จะชื่อและab

หลังจากการมอบหมาย tuple ใหม่จะไม่ถูกอ้างถึงและทำเครื่องหมายสำหรับการรวบรวมขยะและค่าที่ผูกไว้กับaและbถูกสลับเป็น

ตามที่ระบุไว้ในส่วนการกวดวิชาหลามบนโครงสร้างข้อมูล ,

โปรดทราบว่าการมอบหมายหลายรายการเป็นเพียงการรวมกันของการบรรจุสิ่งอันดับและลำดับการเปิดออก

นิพจน์ทั่วไปที่อ่านได้

ใน Python คุณสามารถแยกนิพจน์ปกติผ่านหลายบรรทัดตั้งชื่อการจับคู่และแทรกความคิดเห็น

ตัวอย่างไวยากรณ์ verbose (จากDive สู่ 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)

ตัวอย่างการตั้งชื่อการจับคู่ (จากปกตินิพจน์ HOWTO )

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

นอกจากนี้คุณยังสามารถเขียน regex อย่างละเอียดโดยไม่ต้อง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)

ทางลัดที่มีประโยชน์มากตั้งแต่รายการ tuples และ dicts ถูกใช้อย่างกว้างขวางเป็นคอนเทนเนอร์

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

พจนานุกรมมีวิธี 'รับ ()' หากคุณทำ d ['key'] และรหัสไม่อยู่ที่นั่นคุณจะได้รับการยกเว้น หากคุณใช้ d.get ('key') คุณจะไม่ได้รับอะไรเลยหาก 'key' ไม่อยู่ที่นั่น คุณสามารถเพิ่มอาร์กิวเมนต์ที่สองเพื่อรับรายการนั้นกลับมาแทน None เช่น: d.get ('key', 0)

มันยอดเยี่ยมสำหรับสิ่งต่าง ๆ เช่นการเพิ่มตัวเลข:

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

อธิบาย

พวกมันคือความมหัศจรรย์ที่อยู่เบื้องหลังฟีเจอร์หลักของ Python

เมื่อคุณใช้การเข้าถึงแบบจุดเพื่อค้นหาสมาชิก (เช่น xy) Python จะค้นหาสมาชิกในพจนานุกรมอินสแตนซ์ก่อน หากไม่พบมันจะค้นหาในพจนานุกรมคลาส หากพบว่ามันอยู่ในพจนานุกรมคลาสและวัตถุใช้โพรโทคอล descriptor แทนที่จะส่งคืน Python จะเรียกใช้มัน อธิบายเป็นชั้นใด ๆ ที่ดำเนินการ__get__, __set__หรือ__delete__วิธีการ

นี่คือวิธีที่คุณจะใช้คุณสมบัติของเวอร์ชัน (อ่านอย่างเดียว) ของคุณเองโดยใช้ descriptors:

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

Descriptors ถูกใช้ใน Python เพื่อใช้คุณสมบัติ, เมธอดที่ถูกผูก, วิธีสแตติก, เมธอดคลาสและสล็อต, ระหว่างสิ่งอื่น ๆ การทำความเข้าใจพวกมันทำให้ง่ายต่อการดูว่าทำไมหลาย ๆ อย่างที่ก่อนหน้านี้ดูเหมือนว่า 'นิสัยใจคอ' ของ Python นั้นเป็นอย่างที่มันเป็น

Raymond Hettinger มีบทช่วยสอนที่ยอดเยี่ยมซึ่งทำหน้าที่อธิบายได้ดีกว่าฉันมาก

การมอบหมายแบบมีเงื่อนไข

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

มันทำสิ่งที่ดูเหมือนว่า: "กำหนด 3 ถึง x ถ้า y เป็น 1 มิฉะนั้นกำหนด 2 ถึง x" โปรดทราบว่าไม่จำเป็นต้อง parens แต่ฉันชอบพวกเขาสำหรับการอ่าน คุณสามารถโยงมันได้หากคุณมีบางอย่างที่ซับซ้อนมากขึ้น:

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

แม้ว่าจะถึงจุดหนึ่งมันก็ไกลไปหน่อย

โปรดทราบว่าคุณสามารถใช้ถ้า ... 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.

และเนื่องจาก localals () เป็นพจนานุกรมคุณก็สามารถส่งมันเป็น dict และมี% -substitions จากตัวแปรโลคอลของคุณ ฉันคิดว่านี่เป็นเรื่องที่ขมวดคิ้ว แต่ทำให้สิ่งต่าง ๆ ง่ายขึ้น ..

การจัดรูปแบบสไตล์ใหม่

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

เพื่อเพิ่มโมดูลหลามเพิ่มเติม (โดยเฉพาะบุคคลที่สาม) คนส่วนใหญ่ดูเหมือนจะใช้ตัวแปรสภาพแวดล้อม PYTHONPATH หรือเพิ่ม symlink หรือไดเรกทอรีในไดเรกทอรีแพ็คเกจไซต์ อีกวิธีคือใช้ไฟล์ * .pth นี่คือคำอธิบายของ python doc อย่างเป็นทางการ:

"วิธีที่สะดวกที่สุด [เพื่อแก้ไขเส้นทางการค้นหาของ python] คือการเพิ่มไฟล์การกำหนดค่าพา ธ ไปยังไดเรกทอรีที่มีอยู่แล้วในเส้นทางของ Python โดยปกติไปที่ ... / site-packages / directory ไฟล์การกำหนดค่าพา ธ มีนามสกุล. 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()

การใช้อนุประโยคอื่นดีกว่าการเพิ่มโค้ดเพิ่มเติมลงใน try clause เนื่องจากจะหลีกเลี่ยงการจับข้อยกเว้นที่ไม่ได้เกิดจากโค้ดที่ได้รับการปกป้องโดยคำสั่ง 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 :)

ยกเลิกการเชื่อมโยง :

The Zen of Python โดย Tim Peters

สวยดีกว่าน่าเกลียด
ชัดเจนดีกว่าโดยปริยาย
เรียบง่ายดีกว่าซับซ้อน
คอมเพล็กซ์ดีกว่าซับซ้อน
แบนดีกว่าซ้อนกัน
เบาบางดีกว่าหนาแน่น
จำนวนการอ่าน
กรณีพิเศษไม่พิเศษพอที่จะทำลายกฎ
แม้ว่าการปฏิบัติจริงชนะความบริสุทธิ์
ข้อผิดพลาดไม่ควรผ่านไปอย่างเงียบ ๆ
เว้นแต่จะปิดเสียงอย่างชัดเจน
ในการเผชิญกับความกำกวมปฏิเสธสิ่งล่อใจที่จะคาดเดา ควรมีอย่างน้อยหนึ่งวิธีที่ชัดเจนกว่าที่จะทำ
แม้ว่าวิธีนี้อาจไม่ชัดเจนในตอนแรกเว้นแต่ว่าคุณเป็นชาวดัตช์
ตอนนี้ดีกว่าไม่เคย
แม้ว่าจะไม่เคยดีกว่าที่เหมาะสมในขณะนี้
หากการนำไปปฏิบัตินั้นยากที่จะอธิบายเป็นความคิดที่ไม่ดี
หากการนำไปปฏิบัตินั้นง่ายต่อการอธิบายอาจเป็นความคิดที่ดี
Namespaces เป็นหนึ่งในแนวคิดที่ยอดเยี่ยม - ลองทำสิ่งเหล่านี้ให้มากขึ้น!

การแปลแท็บ Interactive Interpreter

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

สิ่งเหล่านี้สามารถแทนที่โค้ดที่ซ้อนกันจำนวนมาก

ผู้ประกอบการมากไปสำหรับ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}

รายละเอียดเพิ่มเติมจากการอ้างอิงไลบรารีมาตรฐาน: Set Types