පයිතන්ගේ සැඟවුණු ලක්ෂණ [වසා ඇත]

පයිතන් ක්‍රමලේඛන භාෂාවේ එතරම් ප්‍රසිද්ධ නැති නමුත් ප්‍රයෝජනවත් අංග මොනවාද?

• පයිතන් හරයට පිළිතුරු සීමා කිරීමට උත්සාහ කරන්න.
• පිළිතුරකට එක් අංගයක්.
• ප්‍රලේඛනයට සබැඳියක් පමණක් නොව, විශේෂාංගය පිළිබඳ උදාහරණයක් සහ කෙටි විස්තරයක් දෙන්න.
• පළමු පේළිය ලෙස මාතෘකාවක් භාවිතා කරමින් විශේෂාංගය ලේබල් කරන්න.

පිළිතුරු සඳහා ඉක්මන් සබැඳි:

• තර්කය ඉවත් කිරීම
• වරහන්
• දම්වැල් සංසන්දනාත්මක ක්‍රියාකරුවන්
• සැරසිලි කරන්නන්
• පෙරනිමි තර්කය ගොචාස් / විකෘති පෙරනිමි තර්ක වල අන්තරායන්
• විස්තර කරන්නන්
• ශබ්ද කෝෂයේ පෙරනිමි .getඅගය
• ඩොක්ස්ට්‍රිං ටෙස්ට්
• එලිප්සිස් ස්ලයිසින් සින්ටැක්ස්
• ගණන් බැලීම
• / වෙනත් සඳහා
• Iter () තර්කය ලෙස ක්‍රියා කිරීම
• උත්පාදක ප්‍රකාශන
• import this
• ස්ථාන අගය හුවමාරු කිරීමේදී
• ලැයිස්තු පියවර
• __missing__ අයිතම
• බහු රේඛා රීජෙක්ස්
• නූල් හැඩතල ගැන්වීම
• කැදැලි ලැයිස්තුව / උත්පාදක අවබෝධය
• ධාවන වේලාවේදී නව වර්ග
• .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, නමුත් අඩු ටයිප් කිරීම සහ එක් එක් පදය තක්සේරු කරනු ලබන්නේ එක් වරක් පමණි.

ඔබේ රීජෙක්ස් නිදොස් කිරීම සඳහා පයිතන් රීජෙක්ස් විග්‍රහ කිරීමේ ගස ලබා ගන්න.

නිත්‍ය ප්‍රකාශන පයිතන්හි විශිෂ්ට ලක්ෂණයකි, නමුත් ඒවා නිදොස් කිරීම වේදනාවක් විය හැකි අතර, රීජෙක්ස් වැරදියට ලබා ගැනීම පහසුය.

වාසනාවකට මෙන්, ලේඛනගත නොකළ, පර්යේෂණාත්මක, සැඟවුණු ධජය 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
>>>

යොමුව:

• පයිතන් නිබන්ධනය - ලූප ක්‍රම
• පයිතන් ඩොක්ස් - සාදන ලද කාර්යයන් -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

විෂය පථයන් දැක්වීමට සුදු අවකාශය භාවිතා කිරීමට ඔබ අකමැති නම්, ඔබට නිකුත් කිරීමෙන් සී-ස්ටයිල් {use භාවිතා කළ හැකිය:

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]

සැරසිලි කරන්නන්

ක්‍රියාකාරිත්වය එකතු කිරීම, තර්ක හෝ ප්‍රති results ල වෙනස් කිරීම වැනි වෙනත් ශ්‍රිතයක් තුළ සැරසිලි කරුවන්ට සැරසිලි කිරීමට ඉඩ සලසයි. ඔබ සැරසිලි කරුවන් ශ්‍රිත අර්ථ දැක්වීමට ඉහළින් එක් පේළියක් ලියයි, එය “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

සඳහා ... වෙනත් වාක්‍ය ඛණ්ඩය ( http://docs.python.org/ref/for.html බලන්න )

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

විවේකය ලෙස හැඳින්වුවහොත් මිස, "වෙනත්" කොටස සාමාන්‍යයෙන් for for loop අවසානයේ ක්‍රියාත්මක වේ.

ඉහත කේතය පහත පරිදි අනුකරණය කළ හැකිය:

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

දී dict උපපංතිය ද ඇත 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]නව අයිතමයක් එකතු කරන අයිතමයක් තිබේදැයි පරීක්ෂා කිරීමට බොහෝ කේත භාවිතා කරයි .

ස්ථානීය අගය හුවමාරුව

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

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

පැවරුමේ දකුණු පස නව ටුපල් එකක් නිර්මාණය කරන ප්‍රකාශනයකි. පැවරුමේ වම් පස වහාම (යොමු නොකල) නම් වලට ඇලවීම aසහ b.

පැවරුම පසු, නව tuple සහිතවූ හා කැළි කසළ සඳහා සලකුණු වන අතර, එම අගයන් බැඳී aහා bජින් කර ඇත.

දත්ත ව්‍යුහයන් පිළිබඳ පයිතන් නිබන්ධනයේ සඳහන් පරිදි ,

බහුවිධ පැවරුම් සැබවින්ම ටුපල් ඇසුරුම් සහ අනුක්‍රමික ඇසුරුම්වල එකතුවක් බව සලකන්න.

කියවිය හැකි නිත්‍ය ප්‍රකාශන

පයිතන්හිදී ඔබට නිත්‍ය ප්‍රකාශනයක් බහුවිධ රේඛා හරහා බෙදිය හැකිය, ඔබේ ගැලපීම් නම් කරන්න සහ අදහස් ඇතුළත් කරන්න.

උදාහරණ වාචික වාක්‍ය ඛණ්ඩය ( කිමිදුම් සිට පයිතන් දක්වා ):

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

වචනාර්ථයෙන් සම්මුතියට 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 හි හඳුන්වා දී ඇති , සන්දර්භය කළමණාකරු යනු ප්‍රකාශන කට්ටලයක් සඳහා ධාවන කාල සන්දර්භයක් ලෙස ක්‍රියා කරන වස්තුවකි.

විශේෂාංගය නව වචන භාවිතා කරන බැවින්, එය ක්‍රමයෙන් හඳුන්වා දෙනු ලැබේ: එය __future__නියමයෙන් පයිතන් 2.5 හි ලබා ගත හැකිය . පයිතන් 2.6 සහ ඊට වැඩි (පයිතන් 3 ද ඇතුළුව) එය පෙරනිමියෙන් ලබා ගත හැකිය.

මම "සමග" ප්‍රකාශය බොහෝ දුරට භාවිතා කර ඇති බැවින් එය ඉතා ප්‍රයෝජනවත් ඉදිකිරීමක් යැයි මම සිතමි, මෙන්න ඉක්මන් නිරූපණයක්:

from __future__ import with_statement

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

තිරය ​​පිටුපස මෙහි සිදුවෙමින් පවතින්නේ, “with” ප්‍රකාශය ගොනු වස්තුවෙහි විශේෂ __enter__සහ __exit__ක්‍රම හඳුන්වයි . ව්‍යතිරේක තොරතුරු __exit__ප්‍රකාශන ආයතනයෙන් කිසියම් ව්‍යතිරේකයක් මතු කර ඇත්නම්, එහි ව්‍යතිරේකය හැසිරවීමට ඉඩ සලසයි.

මෙම විශේෂිත අවස්ථාවෙහිදී ඔබ වෙනුවෙන් මෙය කරන්නේ, එය withසාමාන්‍යයෙන් සිදුවන්නේ නම් හෝ ව්‍යතිරේකයක් විසි කර ඇත්ද යන්න නොසලකා, ක්‍රියාත්මක කිරීම කට්ටලයේ විෂය පථයෙන් බැහැර වන විට ගොනුව වසා ඇති බවට සහතික වීමයි. එය මූලික වශයෙන් පොදු ව්‍යතිරේක-හැසිරවීමේ කේතය වියුක්ත කිරීමේ ක්‍රමයකි.

මේ සඳහා භාවිතා වන වෙනත් පොදු අවස්ථා අතරට නූල් සමඟ අගුළු දැමීම සහ දත්ත සමුදා ගනුදෙනු ඇතුළත් වේ.

ශබ්දකෝෂවලට ලබා ගැනීමේ () ක්‍රමයක් ඇත

ශබ්ද කෝෂවලට 'get ()' ක්‍රමයක් ඇත. ඔබ යතුර [යතුර] කර යතුර නොමැති නම්, ඔබට ව්‍යතිරේකයක් ලැබේ. ඔබ d.get ('key') කරන්නේ නම්, 'යතුර' නොමැති නම් ඔබට කිසිවක් ආපසු නොලැබේ. කිසිවක් වෙනුවට එම අයිතමය නැවත ලබා ගැනීම සඳහා ඔබට දෙවන තර්කයක් එක් කළ හැකිය, උදා: d.get ('key', 0).

අංක එකතු කිරීම වැනි දේ සඳහා එය විශිෂ්ටයි:

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

විස්තර කරන්නන්

මූලික පයිතන් විශේෂාංග රාශියක් පිටුපස ඇති මැජික් ඒවාය.

සාමාජිකයෙකු බැලීමට ඔබ තිත් ප්‍රවේශය භාවිතා කරන විට (උදා: xy), පයිතන් පළමුව නිදර්ශන ශබ්ද කෝෂයේ සාමාජිකයා සොයයි. එය සොයාගත නොහැකි නම්, එය පන්ති ශබ්ද කෝෂයේ එය සොයයි. එය පන්ති ශබ්ද කෝෂයේ සොයාගත හොත්, වස්තුව විස්තර කිරීමේ ප්‍රොටෝකෝලය ක්‍රියාත්මක කරන්නේ නම්, එය ආපසු ලබා දෙනවා වෙනුවට, පයිතන් එය ක්‍රියාත්මක කරයි. ඒ descriptor කියාත්මක කරන ඕනෑම පන්තිය යි __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!"

ගුණාංග, බැඳී ඇති ක්‍රම, ස්ථිතික ක්‍රම, පන්ති ක්‍රම සහ තව් ආදිය ක්‍රියාත්මක කිරීම සඳහා විස්තර පයිතන් හි භාවිතා වේ. ඒවා අවබෝධ කර ගැනීමෙන් පෙර පයිතන් 'විචක්ෂණ' ලෙස පෙනෙන බොහෝ දේ ඒවා වන්නේ මන්දැයි බැලීමට පහසු වේ.

රේමන්ඩ් හෙට්ටිංගර්ට විශිෂ්ට නිබන්ධනයක් ඇත, එය මට වඩා විස්තර කිරීමට වඩා හොඳ කාර්යයක් කරයි.

කොන්දේසිගත පැවරුම

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

එය හරියටම පෙනෙන ආකාරයටම කරයි: "y 1 නම් 3 සිට x දක්වාද, එසේ නොමැතිනම් 2 සිට x දක්වාද යොදන්න". පාරෙන්ස් අවශ්‍ය නොවන බව මතක තබා ගන්න, නමුත් කියවීමට ඔවුන් කැමතියි. ඔබට වඩා සංකීර්ණ යමක් ඇත්නම් ඔබට එය දම්වැල් කළ හැකිය:

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

එක්තරා අවස්ථාවක දී එය ටිකක් දුර යයි.

ඔබට ඕනෑම ප්‍රකාශනයක නම් ... වෙනත් ආකාරයකින් භාවිතා කළ හැකි බව සලකන්න. උදාහරණයක් වශයෙන්:

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

Y 1 නම් සහ func2 නම් මෙහි func1 අමතනු ඇත. මෙම අවස්ථා දෙකෙහිම අනුරූප ශ්‍රිතය arg1 සහ arg2 තර්ක සමඟ කැඳවනු ලැබේ.

ප්‍රතිසම වශයෙන්, පහත සඳහන් දෑ ද වලංගු වේ:

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

පන්ති 1 සහ පන්ති 2 පන්ති දෙකකි.

ආචාර්ය : එකවර ප්‍රලේඛනය සහ ඒකක පරීක්ෂා කිරීම.

පයිතන් ප්‍රලේඛනයෙන් උපුටා ගත් උදාහරණය:

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.

ප්‍රදේශවාසීන් () ද ශබ්ද කෝෂයක් බැවින් ඔබට එය ආ ict ාවක් ලෙස සම්මත කර ඔබේ දේශීය විචල්‍යයන්ගෙන්% -ප්‍රතිස්ථාපන ලබා ගත හැකිය. මම හිතන්නේ මෙය කෝපයට පත් වී ඇති නමුත් දේවල් සරල කරයි ..

නව විලාසිතාවේ හැඩතල ගැන්වීම

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

තවත් පයිතන් මොඩියුල එකතු කිරීම සඳහා (විශේෂයෙන් තෙවන පාර්ශවීය ඒවා), බොහෝ අය පයිතන්පාත් පරිසර විචල්‍යයන් භාවිතා කරන බවක් පෙනේ, නැතහොත් ඔවුන් ඔවුන්ගේ අඩවි පැකේජ නාමාවලිවල සමමුහුර්ත හෝ නාමාවලි එක් කරයි. තවත් ක්‍රමයක් නම්, * .pth ගොනු භාවිතා කිරීමයි. නිල පයිතන් ලේඛනයේ පැහැදිලි කිරීම මෙන්න:

"[පයිතන්ගේ සෙවුම් මාර්ගය වෙනස් කිරීමට] වඩාත්ම පහසු ක්‍රමය වන්නේ දැනටමත් ... / අඩවි පැකේජ / නාමාවලියට දැනටමත් පයිතන්ගේ මාවතේ ඇති නාමාවලියකට මාර්ග වින්‍යාස ගොනුවක් එක් කිරීමයි. මාර්ග වින්‍යාස ගොනු වල .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()

උත්සාහය වගන්තියට අතිරේක කේත එකතු කිරීමට වඩා වෙනත් වගන්තිය භාවිතා කිරීම වඩා හොඳය, මන්ද එය උත්සාහයෙන් ආරක්‍ෂා කර ඇති කේතය මගින් මතු නොකළ ව්‍යතිරේකයක් අහම්බෙන් අල්ලා ගැනීම වළක්වයි ... ප්‍රකාශය හැර.

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)

දෝෂ හසුරුවන්නෙකු තුළ කිසිදු තර්කයක් නොමැති 'නැගිටීම' ප්‍රකාශය පයිතන්ට පවසන්නේ මුල් ලුහුබැඳීම සමඟ ව්‍යතිරේකය නැවත ඉහළ නංවන ලෙසයි . එවිට ඔබට "ඔහ්, සමාවෙන්න, සමාවෙන්න, මම එය අල්ලා ගැනීමට අදහස් නොකළෙමි, සමාවෙන්න, සමාවෙන්න. "

මුල් ලුහුබැඳීම සමඟ මුද්‍රණය කිරීමට, ගබඩා කිරීමට හෝ ෆෙඩල් කිරීමට ඔබට අවශ්‍ය නම්, ඔබට එය sys.exc_info () සමඟ ලබා ගත හැකි අතර, පයිතන් මෙන් මුද්‍රණය කිරීම 'ට්‍රේස්බැක්' මොඩියුලය සමඟ සිදු කෙරේ.

ප්‍රධාන පණිවිඩ :)

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

ඩී-සයිෆර්ඩ් :

ටිම් පීටර්ස් විසින් රචිත සෙන් ඔෆ් පයිතන්

ලස්සන කැතට වඩා හොඳයි.
ව්‍යංගයට වඩා පැහැදිලිය.
සරල දේට වඩා සංකීර්ණයි.
සංකීර්ණය සංකීර්ණ වීමට වඩා හොඳයි.
පැතලි කැදැල්ලට වඩා හොඳයි.
විරල ense නත්වයට වඩා හොඳයි.
කියවීමේ හැකියාව ගණන් කරයි.
විශේෂ අවස්ථා නීති කඩ කිරීමට තරම් විශේෂ නොවේ.
ප්‍රායෝගිකත්වය පාරිශුද්ධත්වයට පහර දුන්නද.
දෝෂ කිසි විටෙක නිහ .ව සම්මත නොවිය යුතුය.
පැහැදිලිව නිහ ced නොකළහොත්.
අපැහැදිලි තත්වයන් හමුවේ, අනුමාන කිරීමට ඇති පෙළඹවීම ප්‍රතික්ෂේප කරන්න. එකක් තිබිය යුතුය - වඩාත් සුදුසු වන්නේ එය කිරීමට එක් - පැහැදිලි ක්‍රමයක් පමණි.
ඔබ ලන්දේසි ජාතිකයෙකු නොවේ නම් මුලදී එය පැහැදිලිව පෙනෙන්නට නැත.
දැන් වෙන කවරදාටත් වඩා හොඳයි.
කිසි විටෙකත් වඩා හොඳ නැතඅයිතිය දැන්.
ක්‍රියාත්මක කිරීම පැහැදිලි කිරීමට අපහසු නම් එය නරක අදහසකි.
ක්‍රියාත්මක කිරීම පැහැදිලි කිරීමට පහසු නම්, එය හොඳ අදහසක් විය හැකිය.
නාම අවකාශයන් යනු ඉතා හොඳ අදහසකි - අපි ඒවායින් වැඩි ප්‍රමාණයක් කරමු!

අන්තර් ක්‍රියාකාරී පරිවර්තක පටිත්ත සම්පූර්ණ කිරීම

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}

සම්මත පුස්තකාල යොමුවෙන් වැඩි විස්තර: වර්ග සකසන්න