it-swarm-tr.com

Python'un gizli özellikleri

1420
jelovirt

Bir list ile sum() ile) düzleştirme.

sum() built-in işlevi, __add__list s) birlikte kullanmak için kullanılabilir, bir list of list s:) düzleştirmek için kullanışlı bir yol sağlar

Python 2.7.1 (r271:86832, May 27 2011, 21:41:45) 
[GCC 4.2.1 (Apple Inc. build 5664)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> l = [[1, 2, 3], [4, 5], [6], [7, 8, 9]]
>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]
9
Johnsyweb

Borg Deseni

Bu Alex Martelli 'den bir katil. Borg öğesinin tüm örnekleri durumu paylaşır. Bu, singleton düzenini kullanma ihtiyacını ortadan kaldırır (durumlar paylaşıldığı zaman önemli değildir) ve oldukça zarif (ancak yeni sınıflarla daha karmaşıktır).

foo'ın değeri herhangi bir durumda yeniden atanabilir ve hepsi güncellenir, hatta tüm şeridi yeniden atayabilirsiniz. Borg mükemmel bir isim, devamını oku here .

class Borg:
    __shared_state = {'foo': 'bar'}
    def __init__(self):
        self.__dict__ = self.__shared_state
    # rest of your class here

Bu, bir eventlet'i paylaşmak için mükemmeldir. Eşzamanlılığı kontrol etmek için GreenPool.

9
cerberos

En İyi Gizli Nitelikler

>>> class A(object): pass
>>> a = A()
>>> setattr(a, "can't touch this", 123)
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', "can't touch this"]
>>> a.can't touch this # duh
  File "<stdin>", line 1
    a.can't touch this
                     ^
SyntaxError: EOL while scanning string literal
>>> getattr(a, "can't touch this")
123
>>> setattr(a, "__class__.__name__", ":O")
>>> a.__class__.__name__
'A'
>>> getattr(a, "__class__.__name__")
':O'

Dinamik olarak eklenen özellikler

Sınıflarınıza yalnızca bazı özellikleri ekleyerek bazı özellikler eklemeyi düşünüyorsanız, bu yararlı olabilir. Bu, nokta operand kullanıldığında çağrılan __getattribute__ üye işlevini geçersiz kılarak yapılabilir. Öyleyse, örneğin kukla bir sınıf görelim:

class Dummy(object):
    def __getattribute__(self, name):
        f = lambda: 'Hello with %s'%name
        return f

Bir Dummy nesnesini başlattığınızda ve bir yöntem çağrısı yaparken, aşağıdakileri alırsınız:

>>> d = Dummy()
>>> d.b()
'Hello with b'

Son olarak, niteliği sınıfınıza bile ayarlayabilirsiniz, böylece dinamik olarak tanımlanabilir. Python web çerçeveleriyle çalışıyorsanız ve özniteliğin adını ayrıştırıp sorgular yapmak istiyorsanız bu yararlı olabilir.

Bu basit kodla github'da ve bir arkadaşı tarafından Ruby'de eşdeğer bir Gist var.

Kendine iyi bak!

9
FernandoEscher

namedtuple bir Tuple

>>> node = namedtuple('node', "a b")
>>> node(1,2) + node(5,6)
(1, 2, 5, 6)
>>> (node(1,2), node(5,6))
(node(a=1, b=2), node(a=5, b=6))
>>> 

Yorumlara cevap vermek için bazı deneyler:

>>> from collections import namedtuple
>>> from operator import *
>>> mytuple = namedtuple('A', "a b")
>>> yourtuple = namedtuple('Z', "x y")
>>> mytuple(1,2) + yourtuple(5,6)
(1, 2, 5, 6)
>>> q = [mytuple(1,2), yourtuple(5,6)]
>>> q
[A(a=1, b=2), Z(x=5, y=6)]
>>> reduce(operator.__add__, q)
(1, 2, 5, 6)

Bu yüzden, namedtuple, Tuple dosyasının bir ilginç alt türüdür.

9
Apalala

İlgili verilere sahip iki dizinin sözlüğünü oluşturma

In [15]: t1 = (1, 2, 3)

In [16]: t2 = (4, 5, 6)

In [17]: dict (Zip(t1,t2))
Out[17]: {1: 4, 2: 5, 3: 6}
9
Lakshman Prasad

threading.enumerate (), sistemdeki tüm Thread nesnelerine erişim sağlar ve sys._current_frames (), sistemdeki tüm iş parçacıklarının geçerli yığın çerçevelerini döndürür, bu yüzden bu ikisini birleştirir ve Java stili yığın dökümlerini alırsınız:

def dumpstacks(signal, frame):
    id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
    code = []
    for threadId, stack in sys._current_frames().items():
        code.append("\n# Thread: %s(%d)" % (id2name[threadId], threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    print "\n".join(code)

import signal
signal.signal(signal.SIGQUIT, dumpstacks)

Bunu çok iş parçacıklı bir python programının başında yapın ve herhangi bir zamanda bir SIGQUIT göndererek mevcut iş parçacığı durumuna erişebilirsiniz. Ayrıca, sinyal.SIGUSR1 veya sinyal.SIGUSR2'yi de seçebilirsiniz.

Görmek

8
haridsv

pdb - Python Hata Ayıklayıcı

Bir programcı olarak, ciddi program geliştirme için ihtiyacınız olan ilk şeylerden biri hata ayıklayıcıdır. Python, pdb adında bir modül olarak kullanılabilen bir yerleşik yapıya sahiptir (doğal olarak "Python DeBugger" için!).

http://docs.python.org/library/pdb.html

8
Tom Viner

teftiş modülü de harika bir özellik.

7
Pratik Deoghare

Modülleri yeniden yüklemek bir "canlı kodlama" tarzını mümkün kılar. Ancak sınıf örnekleri güncellenmez. İşte nedeni ve nasıl aşılacağı. Unutma, her şey, evet, her şey bir nesnedir.

>>> from a_package import a_module
>>> cls = a_module.SomeClass
>>> obj = cls()
>>> obj.method()
(old method output)

Şimdi yöntemi a_module.py dosyasında değiştirdiniz ve nesneyi güncellemek istiyorsunuz.

>>> reload(a_module)
>>> a_module.SomeClass is cls
False # Because it just got freshly created by reload.
>>> obj.method()
(old method output)

Bunu güncellemenin bir yolu var (ancak makasla çalıştığını düşünün):

>>> obj.__class__ is cls
True # it's the old class object
>>> obj.__class__ = a_module.SomeClass # pick up the new class
>>> obj.method()
(new method output)

Bu "makasla koşmaktır" çünkü nesnenin iç durumu yeni sınıfın beklediğinden farklı olabilir. Bu gerçekten basit durumlar için işe yarar, ancak bunun ötesinde, pickle senin arkadaşın. Yine de, bunun neden işe yaradığını anlamak hala yararlı.

7
Ken Arnold

Operatörler fonksiyon olarak adlandırılabilir:

from operator import add
print reduce(add, [1,2,3,4,5,6])
7
Brendon Crawford

listede sonsuz özyineleme

>>> a = [1,2]
>>> a.append(a)
>>> a
[1, 2, [...]]
>>> a[2]
[1, 2, [...]]
>>> a[2][2][2][2][2][2][2][2][2] == a
True
7
Elisha

... dict.get() öğesinde default değeri / Yoktur, böylece KeyErrors'dan kaçınır:

In [1]: test = { 1 : 'a' }

In [2]: test[2]
---------------------------------------------------------------------------
<type 'exceptions.KeyError'>              Traceback (most recent call last)

&lt;ipython console&gt; in <module>()

<type 'exceptions.KeyError'>: 2

In [3]: test.get( 2 )

In [4]: test.get( 1 )
Out[4]: 'a'

In [5]: test.get( 2 ) == None
Out[5]: True

ve hatta bunu 'olay yerinde' belirtmek için:

In [6]: test.get( 2, 'Some' ) == 'Some'
Out[6]: True

Ve eğer ayarlanmış ve varsa geri döndürülmüş bir değer elde etmek için setdefault() kullanabilirsiniz:

>>> a = {}
>>> b = a.setdefault('foo', 'bar')
>>> a
{'foo': 'bar'}
>>> b
'bar
7
Steen

Ham dizgilerin içindeki ters eğik çizgiler, tırnaklardan hala kaçabilir. Bunu gör:

>>> print repr(r"aaa\"bbb")
'aaa\\"bbb'

Son satırda hem ters eğik çizginin hem de çift teklifin bulunduğunu unutmayın.

Sonuç olarak, ham bir dizgiyi ters eğik çizgiyle bitiremezsiniz:

>>> print repr(r"C:\")
SyntaxError: EOL while scanning string literal
>>> print repr(r"C:\"")
'C:\\"'

Bunun nedeni ham dizelerin düzenli ifadeler yazmaya ve Windows yollarını yazmamalarına yardımcı olmak için uygulanmasıdır. Bununla ilgili uzun bir tartışmayı Gotcha - Windows dosya isimlerinde .

7
Denilson Sá Maia

Küçük intgerlerin nesneleri (-5 .. 256) asla iki kere yaratılmadı:


>>> a1 = -5; b1 = 256
>>> a2 = -5; b2 = 256
>>> id(a1) == id(a2), id(b1) == id(b2)
(True, True)
>>>
>>> c1 = -6; d1 = 257
>>> c2 = -6; d2 = 257
>>> id(c1) == id(c2), id(d1) == id(d2)
(False, False)
>>>

Düzenleme: Nesneleri hiç bir zaman yok etmeyecek şekilde listele Python'un içinde 80'e kadar boş listeyi tuttuğu bir dizi vardır. List nesnesini yok ettiğinizde - python bu diziye koyar ve yeni liste oluşturduğunuzda - python bu diziden en son alınan listeye girer:


>>> a = [1,2,3]; a_id = id(a)
>>> b = [1,2,3]; b_id = id(b)
>>> del a; del b
>>> c = [1,2,3]; id(c) == b_id
True
>>> d = [1,2,3]; id(d) == a_id
True
>>>
6
Mykola Kharechko

Dilimler olarak değer. Bu Eratosthenes Elek, asal sayıya ya da 0'a sahip olan bir liste oluşturur.

def eras(n):
    last = n + 1
    sieve = [0,0] + list(range(2, last))
    sqn = int(round(n ** 0.5))
    it = (i for i in xrange(2, sqn + 1) if sieve[i])
    for i in it:
        sieve[i*i:last:i] = [0] * (n//i - i + 1)
    return filter(None, sieve)

Çalışmak için, soldaki dilime aynı uzunlukta sağdaki bir liste atanmalıdır.

6
hughdbrown

Yuvarlama Tamamlayıcıları: Python, double türündeki sayıları döndüren round işlevine sahiptir:

 >>> print round(1123.456789, 4)
1123.4568
 >>> print round(1123.456789, 2)
1123.46
 >>> print round(1123.456789, 0)
1123.0

Bu fonksiyon harika bir büyü özelliğine sahiptir:

 >>> print round(1123.456789, -1)
1120.0
 >>> print round(1123.456789, -2)
1100.0

Sonuç olarak bir tamsayıya ihtiyacınız varsa, type dönüştürmek için int kullanın:

 >>> print int(round(1123.456789, -2))
1100
 >>> print int(round(8359980, -2))
8360000

Teşekkür ederim Gregor .

6
yoav.aviram

Özyineleme Sınırını Yönetme

Sys.getrecursionlimit () & sys.setrecursionlimit () ile maksimum özyineleme derinliğini alma veya ayarlama.

Sonsuz özyinelemeden kaynaklanan yığın taşmasını önlemek için sınırlayabiliriz.

6
grayger

Bir sınıfın mro'yu bir metaclass ile geçersiz kılabilirsiniz.

>>> class A(object):
...     def a_method(self):
...         print("A")
... 
>>> class B(object):
...     def b_method(self):
...         print("B")
... 
>>> class MROMagicMeta(type):
...     def mro(cls):
...         return (cls, B, object)
... 
>>> class C(A, metaclass=MROMagicMeta):
...     def c_method(self):
...         print("C")
... 
>>> cls = C()
>>> cls.c_method()
C
>>> cls.a_method()
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute 'a_method'
>>> cls.b_method()
B
>>> type(cls).__bases__
(<class '__main__.A'>,)
>>> type(cls).__mro__
(<class '__main__.C'>, <class '__main__.B'>, <class 'object'>)

Muhtemelen iyi bir sebepten dolayı gizlidir. :)

6

Dil silme, doğrudan dosya değiştirme, dosya silme, dosya açma gibi şeyleri bile değiştirebilme. Bu, testi yaparken çok büyük bir avantajdır. Her şeyi karmaşık kaplara sarmanız gerekmez. Sadece bir işlev/yöntem kullanın ve gidin. Buna aynı zamanda maymun yamalama denir.

6
Paweł Hajdan

Dilimler ve Değişebilirlik

Listeleri kopyalama

>>> x = [1,2,3]
>>> y = x[:]
>>> y.pop()
3
>>> y
[1, 2]
>>> x
[1, 2, 3]

Listeleri değiştirme

>>> x = [1,2,3]
>>> y = x
>>> y[:] = [4,5,6]
>>> x
[4, 5, 6]
6
Daniel Hepper

Yuvalanmış İşlev Parametresi Yeniden bağlama

def create_printers(n):
    for i in xrange(n):
        def printer(i=i): # Doesn't work without the i=i
            print i
        yield printer
6
ironfroggy

Python 2.x, dizinin son elemanından sonra bulunursa virgülleri yoksayar:

>>> a_Tuple_for_instance = (0,1,2,3,)
>>> another_Tuple = (0,1,2,3)
>>> a_Tuple_for_instance == another_Tuple
True

İzleyen virgül, tek bir parantez içindeki öğenin bir dizi olarak ele alınmasına neden olur:

>>> a_Tuple_with_one_element = (8,)
6
Martin

Yerleşik yöntemler veya işlevler, böyle şeyleri yapmayı imkansız kılan tanımlayıcı protokolü uygulamaz:

>>> class C(object):
...  id = id
... 
>>> C().id()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: id() takes exactly one argument (0 given)

Ancak bunu mümkün kılan küçük bir cilt tanımlayıcı oluşturabilirsiniz:

>>> from types import MethodType
>>> class bind(object):
...  def __init__(self, callable):
...   self.callable = callable
...  def __get__(self, obj, type=None):
...   if obj is None:
...    return self
...   return MethodType(self.callable, obj, type)
... 
>>> class C(object):
...  id = bind(id)
... 
>>> C().id()
7414064
6
Armin Ronacher

İşlevleri sınıflarla dekore edebilirsiniz - işlevi bir sınıf örneğiyle değiştirme:

class countCalls(object):
    """ decorator replaces a function with a "countCalls" instance
    which behaves like the original function, but keeps track of calls

    >>> @countCalls
    ... def doNothing():
    ...     pass
    >>> doNothing()
    >>> doNothing()
    >>> print doNothing.timesCalled
    2
    """
    def __init__ (self, functionToTrack):
        self.functionToTrack = functionToTrack
        self.timesCalled = 0
    def __call__ (self, *args, **kwargs):
        self.timesCalled += 1
        return self.functionToTrack(*args, **kwargs)
6
Markus

Bunun Python belgelerinde nerede (veya olup olmadığından) emin değilim, ancak python 2.x için (az önce denediğim en az 2.5 ve 2.6), print ifadesi parantez içinde çağrılabilir. Bazı Python 2.x kodlarını Python 3.x'e kolayca yerleştirmek istiyorsanız bu özellik faydalı olabilir.

Örnek: print('We want Moshiach Now'), python 2.5, 2.6 ve 3.x'te We want Moshiach Now eserini yazdırmalıdır.

Ayrıca, not operatörü Python 2 ve 3'teki parantezlerle çağrılabilir: not False ve not(False), her ikisi de True değerini döndürmelidir.

Parenthenses ayrıca diğer ifadelerle ve operatörlerle de çalışabilir.

EDIT: Parantezleri not operatörlerinin (ve muhtemelen diğer operatörlerin) çevresine koymak iyi bir fikir DEĞİLDİR, çünkü böyle durumları şaşırtıcı durumlar için yapabilir (çünkü parantezler gerçekten 1 etrafındadır):

>>> (not 1) == 9
False

>>> not(1) == 9
True

Bu da işe yarayabilir, bazı değerler için (bunun geçerli bir tanımlayıcı adı olmadığını düşünüyorum), bunun gibi: not'val'False döndürmeli ve print'We want Moshiach Now'We want Moshiach Now döndürmelidir. (ancak not552, geçerli bir tanımlayıcı adı olduğu için bir NameError değerini yükseltir).

5
Abbafei

Dict Anlayışları

>>> {i: i**2 for i in range(5)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python belgeleri

Wikipedia Girişi

5
Justin

Bir sözlükteki her alanı başlatmak için çok tembel misiniz? Sorun değil:

Python'da> 2.3:

from collections import defaultdict

Python'da <= 2.3:

def defaultdict(type_):
    class Dict(dict):
        def __getitem__(self, key):
            return self.setdefault(key, type_())
    return Dict()

Herhangi bir sürümde:

d = defaultdict(list)
for stuff in lots_of_stuff:
     d[stuff.name].append(stuff)

GÜNCELLEME:

Teşekkürler Ken Arnold . Defaultdict'in daha sofistike bir versiyonunu yeniden uygulamaya koydum. Tam olarak standart kütüphanedeki gibi davranmalıdır.

def defaultdict(default_factory, *args, **kw):                              

    class defaultdict(dict):

        def __missing__(self, key):
            if default_factory is None:
                raise KeyError(key)
            return self.setdefault(key, default_factory())

        def __getitem__(self, key):
            try:
                return dict.__getitem__(self, key)
            except KeyError:
                return self.__missing__(key)

    return defaultdict(*args, **kw)
5
pi.

Maymun yakalama nesneleri

Python'daki her nesne, nesnenin özniteliklerini saklayan bir __dict__ üyesine sahiptir. Yani, böyle bir şey yapabilirsiniz:

class Foo(object):
    def __init__(self, arg1, arg2, **kwargs):
        #do stuff with arg1 and arg2
        self.__dict__.update(kwargs)

f = Foo('arg1', 'arg2', bar=20, baz=10)
#now f is a Foo object with two extra attributes

Bu, nesnelere keyfi olarak hem nitelikler hem de işlevler eklemek için kullanılabilir. Bu, hızlı ve kirli bir struct tipi oluşturmak için de kullanılabilir.

class struct(object):
    def __init__(**kwargs):
       self.__dict__.update(kwargs)

s = struct(foo=10, bar=11, baz="i'm a string!')
5
Chinmay Kanchi

Basit yerleşik kıyaslama aracı

Python Standart Kütüphanesi "timeit" adı verilen kullanımı kolay bir kıyaslama modülü ile birlikte gelir. Birkaç dil yapısından hangisinin en hızlı olduğunu görmek için komut satırından bile kullanabilirsiniz.

Örneğin.,

% python -m timeit 'r = range(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 48.4 usec per loop

% python -m timeit 'r = xrange(0, 1000)' 'for i in r: pass'
10000 loops, best of 3: 37.4 usec per loop
5
Douglas

Kavramaları Ayarla

>>> {i**2 for i in range(5)}                                                       
set([0, 1, 4, 16, 9])

Python belgeleri

Wikipedia Girişi

5
Justin

Buna ek olarak haridsv ile daha önce belirtilenlere:

>>> foo = bar = baz = 1
>>> foo, bar, baz
(1, 1, 1)

bunu yapmak da mümkündür:

>>> foo, bar, baz = 1, 2, 3
>>> foo, bar, baz
(1, 2, 3)
5
armandino

Liste anlama

liste kavramaları

Daha geleneksel olanı karşılaştırın (liste kavrama olmadan):

foo = []
for x in xrange(10):
  if x % 2 == 0:
     foo.append(x)

için:

foo = [x for x in xrange(10) if x % 2 == 0]
5
Oko

İşte 2 paskalya yumurtası:


Python'da bir tane:

>>> import __hello__
Hello world...

Ve ortaya çıkarmak için biraz karmaşık olan Werkzeugmodülünde bir tane daha, işte burada:

Werkzeugname __ 'in kaynak koduna bakarak, werkzeug/__init__.py' da dikkatinizi çekmesi gereken bir satır var:

'werkzeug._internal':   ['_easteregg']

Biraz merak ediyorsanız, bu size werkzeug/_internal.py 'a bir göz atmanızı sağlar, burada, argüman içinde bir wsgi uygulaması alan bir _easteregg() işlevi göreceksiniz, ayrıca bazı base64 kodlanmış verileri ve 2 iç içe geçmiş işlevi de içerir. Sorgu dizesinde macgybarchakkuadlı bir argüman bulunursa özel bir şey yapmış gibi görünüyor.

Bu paskalya yumurtasını ortaya çıkarmak için, _easteregg() işlevine bir uygulama koymanız gerekecek gibi görünüyor:

from werkzeug import Request, Response, run_simple
from werkzeug import _easteregg

@Request.application
def application(request):
    return Response('Hello World!')

run_simple('localhost', 8080, _easteregg(application))

Şimdi, uygulamayı çalıştırıp http: // localhost: 8080 /? Macgybarchakku adresini ziyaret ederseniz paskalya Yumurtası'nı görmelisiniz.

5
mdeous

Sınıflarınızda tanımlayıcılar kullanıyorsanız, Python, bu anahtar için __dict__ işlevini tamamen atlar;

>>> class User(object):
...  def _get_username(self):
...   return self.__dict__['username']
...  def _set_username(self, value):
...   print 'username set'
...   self.__dict__['username'] = value
...  username = property(_get_username, _set_username)
...  del _get_username, _set_username
... 
>>> u = User()
>>> u.username = "foo"
username set
>>> u.__dict__
{'username': 'foo'}

Bu dir()_ temiz tutmanıza yardımcı olur.

5
Armin Ronacher

Pythonic deyim x = ... if ... else ...x = ... and ... or ... 'dan çok daha üstündür ve işte nedeni:

İfadesine rağmen

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

Eşittir

x = y == 1 and 3 or 2

x = ... and ... or ... deyimini kullanırsanız, bir gün bu zor durumdan ısırılabilirsiniz:

x = 0 if True else 1    # sets x equal to 0

ve bu nedenle eşdeğer değildir

x = True and 0 or 1   # sets x equal to 1

Bunu yapmanın doğru yolu hakkında daha fazla bilgi için, bkz. Python Gizli özellikleri.

5
Amol
5
Gurch

Değişken Tamponları Gösterme

Python Buffer Protocol to değişken byte odaklı arabellekleri göster kullanarak Python'da (2.5/2.6).

(Üzgünüz, burada kod yok. Düşük seviye C API veya mevcut adaptör modülünün kullanılması gerekiyor).

5
user166390

getattr üçüncü bir parametre alır

getattr(obj, attribute_name, default) gibidir:

try:
    return obj.attribute
except AttributeError:
    return default

bunun dışında attribute_name herhangi bir dize olabilir.

Bu duck yazarak için gerçekten yararlı olabilir. Belkide şöyle bir şey vardır:

class MyThing:
    pass
class MyOtherThing:
    pass
if isinstance(obj, (MyThing, MyOtherThing)):
    process(obj)

(btw, isinstance(obj, (a,b)), isinstance(obj, a) or isinstance(obj, b) anlamına gelir.)

Yeni bir şey yaptığınızda, gerçekleştiği her yerde bu Bağlantıya eklemeniz gerekir. (Bu yapı aynı zamanda modülleri yeniden yüklerken veya aynı dosyayı iki isim altında alırken de sorunlara neden olur. İnsanların kabul etmek istediğinden daha fazlası olur.) Ancak bunun yerine şunu söyleyebilirsiniz:

class MyThing:
    processable = True
class MyOtherThing:
    processable = True
if getattr(obj, 'processable', False):
    process(obj)

Kalıtım ekleyin ve daha da iyi olur: işlenebilir nesne örneklerinin tümü miras alabilir

class Processable:
    processable = True

ancak herkesi temel sınıfınızdan miras almaya, sadece bir özellik belirlemeye ikna etmek zorunda değilsiniz.

5
Ken Arnold

__getattr __ ()

getattr, genel bir sınıf oluşturmanın gerçekten güzel bir yoludur, bu özellikle bir API yazıyorsanız kullanışlıdır. Örneğin, FogBugz Python API'sinde , getattr, yöntem çağrılarını web hizmetine sorunsuz bir şekilde iletmek için kullanılır:

class FogBugz:
    ...

    def __getattr__(self, name):
        # Let's leave the private stuff to Python
        if name.startswith("__"):
            raise AttributeError("No such attribute '%s'" % name)

        if not self.__handlerCache.has_key(name):
            def handler(**kwargs):
                return self.__makerequest(name, **kwargs)
            self.__handlerCache[name] = handler
        return self.__handlerCache[name]
    ...

Birisi FogBugz.search(q='bug') işlevini çağırdığında, aslında search yöntemini çağırmazlar. Bunun yerine, getattr çağrıyı, web API'sine uygun HTTP isteğini işleyen makerequest yöntemini saran yeni bir işlev oluşturarak işler. Herhangi bir hata web servisi tarafından gönderilir ve kullanıcıya geri gönderilir.

5
tghw

Her şeyin birinci sınıflığı ('her şey bir nesnedir') ve bunun neden olabileceği kargaşa.

>>> x = 5
>>> y = 10
>>> 
>>> def sq(x):
...   return x * x
... 
>>> def plus(x):
...   return x + x
... 
>>> (sq,plus)[y>x](y)
20

Son satır, iki işlevi içeren bir Tuple oluşturur, daha sonra y> x (True) olarak değerlendirir ve bunu Tuple'a bir indeks olarak kullanır (bir int, 1'e çevirerek) ve bu işlevi y parametresi ile çağırır ve sonuç.

Daha fazla suistimal için, indeksli bir nesne (örneğin bir liste) döndürüyorsanız, sonuna köşeli parantezler ekleyebilirsiniz; içeriği çağrılabilir ise, daha fazla parantez vb. Fazladan sapma için, böyle bir kodun sonucunu başka bir örnekte ifade olarak kullanın (yani y> x'i bu kodla değiştirin):

(sq,plus)[y>x](y)[4](x)

Bu, Python'un iki yüzünü gösterir - uç noktaya götürülen 'her şey bir nesnedir' felsefesi ve dilin sözdiziminin uygunsuz veya kötü düşünülmüş bir şekilde kullanılmasının, tek bir ifadeye uyan tamamen okunamayan, anlaşılmaz bir spagetti koduna yol açabileceği yöntemler .

4
Dan Udey

Döngüler için paket açma, liste anlama ve üretici ifadelerini listeleme:

>>> l=[(1,2),(3,4)]
>>> [a+b for a,b in l ] 
[3,7]

Bu deyimde, sözlüklerdeki (anahtar, veri) çiftleri yineleme için kullanışlıdır:

d = { 'x':'y', 'f':'e'}
for name, value in d.items():  # one can also use iteritems()
   print "name:%s, value:%s" % (name,value)

baskılar:

name:x, value:y
name:f, value:e
4
Rafał Dowgird

Bir dakikalık çalışma ile diş açma modülünün kullanımı inanılmaz derecede kolaydır. Bu dekoratör bir işlevi değiştirir, böylece kendi iş parçacığında çalışır ve normal sonucu yerine bir yer tutucu sınıfı örneği döndürür. Placeolder.result dosyasını kontrol ederek cevabı sorgulayabilir veya placeholder.awaitResult () adlı telefonu arayarak bekleyebilirsiniz.

def threadify(function):
    """
    exceptionally simple threading decorator. Just:
    >>> @threadify
    ... def longOperation(result):
    ...     time.sleep(3)
    ...     return result
    >>> A= longOperation("A has finished")
    >>> B= longOperation("B has finished")

    A doesn't have a result yet:
    >>> print A.result
    None

    until we wait for it:
    >>> print A.awaitResult()
    A has finished

    we could also wait manually - half a second more should be enough for B:
    >>> time.sleep(0.5); print B.result
    B has finished
    """
    class thr (threading.Thread,object):
        def __init__(self, *args, **kwargs):
            threading.Thread.__init__ ( self )  
            self.args, self.kwargs = args, kwargs
            self.result = None
            self.start()
        def awaitResult(self):
            self.join()
            return self.result        
        def run(self):
            self.result=function(*self.args, **self.kwargs)
    return thr
4
Markus

Python'un beklenmedik şeyler için istisnaları var:

İthalat

Bu, eğer bir lib eksikse, bir alternatif almanıza izin verir

try:
    import json
except ImportError:
    import simplejson as json

Yineleme

Döngüler için bunu dahili olarak yapın ve StopIteration'ı yakalayın:

iter([]).next()
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    iter(a).next()
StopIteration

Hakaret

>>> try:
...     assert []
... except AssertionError:
...     print "This list should not be empty"
This list should not be empty

Bu bir çek için daha ayrıntılı olsa da, istisnaları ve aynı hata mesajına sahip boole operatörlerini karıştıran çoklu çekler bu şekilde kısaltılabilir.

4
e-satis

Python'da sır yoktur;)

4
Juanjo Conti

Paket açma işlemini yazdırma işleviyle birleştirin:

# in 2.6 <= python < 3.0, 3.0 + the print function is native
from __future__ import print_function 

mylist = ['foo', 'bar', 'some other value', 1,2,3,4]  
print(*mylist)
4
Wayne Werner

Nesne örneği için yöntem değiştirme

Önceden oluşturulmuş nesne örneklerinin yöntemlerini değiştirebilirsiniz. Farklı (istisnai) işlevselliğe sahip nesne örneği oluşturmanıza olanak sağlar:

>>> class C(object):
...     def fun(self):
...         print "C.a", self
...
>>> inst = C()
>>> inst.fun()  # C.a method is executed
C.a <__main__.C object at 0x00AE74D0>
>>> instancemethod = type(C.fun)
>>>
>>> def fun2(self):
...     print "fun2", self
...
>>> inst.fun = instancemethod(fun2, inst, C)  # Now we are replace C.a by fun2
>>> inst.fun()  # ... and fun2 is executed
fun2 <__main__.C object at 0x00AE74D0>

Yapabildiğimiz gibi C.ainst örneğinde fun2() ile değiştirildi (self değişmedi).

Alternatif olarak, new modülünü kullanabiliriz, ancak Python 2.6'dan bu yana değer kaybetti:

>>> def fun3(self):
...     print "fun3", self
...
>>> import new
>>> inst.fun = new.instancemethod(fun3, inst, C)
>>> inst.fun()
fun3 <__main__.C object at 0x00AE74D0>

Düğüm: Bu çözüm miras mekanizmasının genel yerine kullanılmamalıdır! Ancak bazı durumlarda (hata ayıklama, alay etme) çok kullanışlı olabilir.

Uyarı: Bu çözüm, yerleşik türler için ve yuvaları kullanan yeni stil sınıfları için çalışmaz.

4
Tupteq

Python'un dinamik yapısından yararlanarak python sözdiziminde bir config config dosyaları var. Örneğin, bir config dosyasında aşağıdakilere sahipseniz:

{
  "name1": "value1",
  "name2": "value2"
}

Sonra önemsizce şöyle okuyabilirsin:

config = eval(open("filename").read())
4
pixelbeat

Sözlük öğelerine nitelik (özellik) olarak erişin. bir a1 = AttrDict (), a1 ['name'] yerine 'name' -> anahtarına sahipse, -> a1.name kullanarak a1'in name özniteliğine kolayca erişebiliriz


class AttrDict(dict):

    def __getattr__(self, name):
        if name in self:
            return self[name]
        raise AttributeError('%s not found' % name)

    def __setattr__(self, name, value):
        self[name] = value

    def __delattr__(self, name):
        del self[name]

person = AttrDict({'name': 'John Doe', 'age': 66})
print person['name']
print person.name

person.name = 'Frodo G'
print person.name

del person.age

print person
4
amix

Özel yöntemler

Mutlak güç!

4
cleg

Python'da Unicode tanımlayıcısı:

>>> 'Unicode字符_تكوين_Variable'.isidentifier()
True
>>> Unicode字符_تكوين_Variable='Python3 rules!'
>>> Unicode字符_تكوين_Variable
'Python3 rules!'
4
Kabie

Bir modülHER ŞEYI KENDI AD ALANINDAverir

Diğer modüllerden ithal edilen isimler dahil!

# this is "answer42.py"
from operator import *
from inspect  import *

Şimdi modülden neyin ithal edilebileceğini test edin.

>>> import answer42
>>> answer42.__dict__.keys()
['gt', 'imul', 'ge', 'setslice', 'ArgInfo', 'getfile', 'isCallable', 'getsourcelines', 'CO_OPTIMIZED', 'le', 're', 'isgenerator', 'ArgSpec', 'imp', 'lt', 'delslice', 'BlockFinder', 'getargspec', 'currentframe', 'CO_NOFREE', 'namedtuple', 'rshift', 'string', 'getframeinfo', '__file__', 'strseq', 'iconcat', 'getmro', 'mod', 'getcallargs', 'isub', 'getouterframes', 'isdatadescriptor', 'modulesbyfile', 'setitem', 'truth', 'Attribute', 'div', 'CO_NESTED', 'ixor', 'getargvalues', 'ismemberdescriptor', 'getsource', 'isMappingType', 'eq', 'index', 'xor', 'sub', 'getcomments', 'neg', 'getslice', 'isframe', '__builtins__', 'abs', 'getmembers', 'mul', 'getclasstree', 'irepeat', 'is_', 'getitem', 'indexOf', 'Traceback', 'findsource', 'ModuleInfo', 'ipow', 'TPFLAGS_IS_ABSTRACT', 'or_', 'joinseq', 'is_not', 'itruediv', 'getsourcefile', 'dis', 'os', 'iand', 'countOf', 'getinnerframes', 'pow', 'pos', 'and_', 'lshift', '__name__', 'sequenceIncludes', 'isabstract', 'isbuiltin', 'invert', 'contains', 'add', 'isSequenceType', 'irshift', 'types', 'tokenize', 'isfunction', 'not_', 'istraceback', 'getmoduleinfo', 'isgeneratorfunction', 'getargs', 'CO_GENERATOR', 'cleandoc', 'classify_class_attrs', 'EndOfBlock', 'walktree', '__doc__', 'getmodule', 'isNumberType', 'ilshift', 'ismethod', 'ifloordiv', 'formatargvalues', 'indentsize', 'getmodulename', 'inv', 'Arguments', 'iscode', 'CO_NEWLOCALS', 'formatargspec', 'iadd', 'getlineno', 'imod', 'CO_VARKEYWORDS', 'ne', 'idiv', '__package__', 'CO_VARARGS', 'attrgetter', 'methodcaller', 'truediv', 'repeat', 'trace', 'isclass', 'ior', 'ismethoddescriptor', 'sys', 'isroutine', 'delitem', 'stack', 'concat', 'getdoc', 'getabsfile', 'ismodule', 'linecache', 'floordiv', 'isgetsetdescriptor', 'itemgetter', 'getblock']
>>> from answer42 import getmembers
>>> getmembers
<function getmembers at 0xb74b2924>
>>> 

from x import * yapmamak ve __all__ = tanımlamak için iyi bir neden.

4
Apalala

ekleme vs ekle

bir özellik değil, ama ilginç olabilir

bir listeye bazı veriler eklemek istediğinizi varsayalım ve ardından geri alın. en kolay şey

count = 10 ** 5
nums = []
for x in range(count):
    nums.append(x)
nums.reverse()

o zaman düşünün: peki ya rakamları en baştan eklemek yerine? yani:

count = 10 ** 5 
nums = [] 
for x in range(count):
    nums.insert(0, x)

ama 100 kat daha yavaş olacak! Eğer sayımı = 10 ** 6 olarak ayarlarsak, 1000 kat daha yavaş olacaktır; Bunun nedeni insert'in O (n ^ 2) iken, ekleme işleminin O (n) olmasıdır.

bu farkın nedeni, ekin her çağrıldığında listedeki her bir öğeyi taşımak zorunda olmasıdır; sadece listenin sonunda bulunan öğeleri ekleyin (bazen her şeyi yeniden tahsis etmesi gerekir, ama yine de daha hızlıdır)

4
Ant

Aynı değere birkaç değişken atayabilirsiniz.

>>> foo = bar = baz = 1
>>> foo, bar, baz
(1, 1, 1)

Birkaç değişkeni, Yok olarak kompakt bir şekilde başlatmak için kullanışlıdır.

4
haridsv

Tersiyer operatörünü ve veya kullanarak taklit etmek.

ve ve veya python'daki operatörler, Booleanlardan ziyade nesneleri döndürür. Böylece:

In [18]: a = True

In [19]: a and 3 or 4
Out[19]: 3

In [20]: a = False

In [21]: a and 3 or 4
Out[21]: 4

Bununla birlikte, Py 2.5 açık bir üçüncü derece operatör ekledi gibi görünüyor

    In [22]: a = 5 if True else '6'

    In [23]: a
    Out[23]: 5

Peki, bu sizin gerçek cümlecik değerinizin False olarak değerlendirilmediğinden eminseniz işe yarar. örnek:

>>> def foo(): 
...     print "foo"
...     return 0
...
>>> def bar(): 
...     print "bar"
...     return 1
...
>>> 1 and foo() or bar()
foo
bar
1

Doğru yapmak için biraz daha fazlasını yapmalısınız:

>>> (1 and [foo()] or [bar()])[0]
foo
0

Ancak, bu kadar güzel değil. python sürümünüz destekliyorsa, koşullu operatörü kullanın.

>>> foo() if True or bar()
foo
0
3
Lakshman Prasad

Çok satırlı dizileri tek tek ekran olarak yazdır

license nesnesinin bir örneği olan site._Printer sınıfında gizlenen gerçekten kullanışlı olmayan bir özellik. İkincisi, çağrıldığında, Python lisansını yazdırır. Biri aynı türden başka bir nesne yaratabilir, örneğin bir dize geçirerek Bir dosyanın içeriği - ikinci argüman olarak ve onu çağırmak:

type(license)(0,open('textfile.txt').read(),0)()

Bu, bir kerede belirli bir sayıda satıra bölünmüş dosya içeriğini yazdırır:

...
file row 21
file row 22
file row 23

Hit Return for more, or q (and Return) to quit:
3
etuardu

Her şey dinamik

"Derleme zamanı yok". Python'daki her şey çalışma zamanıdır. Bir modül, bir script gibi, modülün kaynağını yukarıdan aşağıya çalıştırarak 'tanımlanır' ve elde edilen ad alanı, modülün öznitelik alanıdır. Benzer şekilde, sınıf gövdesi yukarıdan aşağıya çalıştırılarak bir sınıf 'tanımlanır' ve sonuçta elde edilen ad alanı sınıfın nitelik-alanıdır. Bir sınıf gövdesi, import ifadeleri, döngüler ve diğer sınıf ifadeleri dahil olmak üzere tamamen rasgele kod içerebilir. Bazen istendiği gibi 'dinamik' bir sınıf, işlev veya hatta modül oluşturmak zor değildir; Aslında, kaçınılması imkansız, çünkü her şey 'dinamik'.

3
Thomas Wouters

Python "özel" değişkenlere sahiptir

Çift alt çizgi ile başlayan, ancak bitmeyen değişkenler yalnızca kongre ile değil, özel hale gelir. Aslında __var _Classname__var'a döner, burada Classname değişkenin yaratıldığı sınıftır. Miras alınmaz ve geçersiz kılınamazlar.


>>> class A:
...     def __init__(self):
...             self.__var = 5
...     def getvar(self):
...             return self.__var
... 
>>> a = A()
>>> a.__var
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: A instance has no attribute '__var'
>>> a.getvar()
5
>>> dir(a)
['_A__var', '__doc__', '__init__', '__module__', 'getvar']
>>>
3
Ivan P

HER ŞEYİN bir nesne olduğu ve bu şekilde genişletilebilir olduğu gerçeği. Tanımladığım bir işleve üye değişkenleri meta veri olarak ekleyebilirim:

>>> def addInts(x,y): 
...    return x + y
>>> addInts.params = ['integer','integer']
>>> addInts.returnType = 'integer'

Bu, örneğin dinamik ünite testleri yazmak için çok faydalı olabilir.

3
Greg

çok Pythonic olmasa da print kullanarak bir dosyaya yazabilirsiniz.

print>>outFile, 'I am Being Written'

Açıklama :

Bu forma bazen "print chevron" denir. Bu formda, >>'den sonraki ilk ifade, özellikle yukarıda açıklandığı gibi bir write() yöntemine sahip bir nesne olan "dosya benzeri" bir nesneye değerlendirmelidir. Bu genişletilmiş formla, sonraki ifadeler bu dosya nesnesine yazdırılır. İlk ifade None olarak değerlendirirse, çıktı için dosya olarak sys.stdout kullanılır.

3
matchew

Boole bağlamındaki nesneler

Boş kümeler, listeler, işaretler, dizeler ve diğer birçok nesne, boolean bağlamında False'ye eşittir (boş olmayanlar True değerine eşittir).

empty_Tuple = ()
empty_list = []
empty_dict = {}
empty_string = ''
empty_set = set()
if empty_Tuple or empty_list or empty_dict or empty_string or empty_set:
  print 'Never happens!'

Bu, mantıksal işlemlerin bazı durumlarda yararlı olan True/False yerine işlenenlerinden birini döndürmesini sağlar:

s = t or "Default value" # s will be assigned "Default value"
                         # if t is false/empty/none
3
Constantin

Uygulamanızın Pickle üzerinden kullanıcı tarafından kaydedilmiş dosyaları yüklediğiniz bir sınıfı yeniden adlandırdıysanız ve yeniden adlandırılmış sınıflardan biri kullanıcının eski kaydında saklanırsa, o turşu dosyayı yükleyemezsiniz.

Bununla birlikte, sadece sınıf tanımınıza ve her şeyin yoluna bir referans ekleyin:

örneğin, önceden:

class Bleh:
    pass

şimdi,

class Blah:
    pass

bu nedenle, kullanıcının turşu kayıtlı dosyası, yeniden adlandırma nedeniyle var olmayan Bleh referansını içerir. Çözüm?

Bleh = Blah

basit!

3
Steven Sproat

İşlevsel destek.

Jeneratörler ve jeneratör ifadeleri, özellikle.

Ruby bu genel kullanıma tekrar başladı, ancak Python da bunu yapabilir. Kütüphanelerde her yerde olduğu gibi çok da kötü değil, Ruby'de olduğu gibi, ama sözdizimini daha çok seviyorum, daha basit.

Her yerde bulunmadıkları için neden yararlı olduklarına dair pek fazla örnek göremiyorum, ancak daha temiz ve daha verimli kod yazmam için bana izin verdiler.

3
Karl Anderson

Özel yöntemler ve veri gizleme (kapsülleme)

Python'da, alt çizgi ile başlayan isimler vererek, sınıfın dış API'sinin bir parçası olması amaçlanmayan diğer sınıf üyelerini ve ifade eden metotların ortak bir deyimi vardır. Bu pratiktir ve pratikte çok iyi çalışır, ancak Python'un özel kod ve/veya verilerin doğru şekilde kapsüllenmesini desteklemediği yanlış bir izlenim bırakıyor. Aslında, Python otomatik olarak size sözcüksel kapanışlar verir; bu durum, durumu gerçekten garanti ettiğinde verileri daha fazla kurşun geçirmez bir şekilde kaplamayı çok kolaylaştırır. İşte bu tekniği kullanan bir sınıfın tartışmalı bir örneği:

class MyClass(object):
  def __init__(self):

    privateData = {}

    self.publicData = 123

    def privateMethod(k):
      print privateData[k] + self.publicData

    def privilegedMethod():
      privateData['foo'] = "hello "
      privateMethod('foo')

    self.privilegedMethod = privilegedMethod

  def publicMethod(self):
    print self.publicData

Ve işte kullanımının tartışmalı bir örneği:

>>> obj = MyClass()
>>> obj.publicMethod()
123
>>> obj.publicData = 'World'
>>> obj.publicMethod()
World
>>> obj.privilegedMethod()
hello World
>>> obj.privateMethod()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateMethod'
>>> obj.privateData
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateData'

Bunun anahtarı, privateMethod ve privateData öğelerinin gerçekten hiçbir şekilde obj özniteliği olmadığı, bu nedenle dışarıdan erişilemedikleri ve dir() veya benzerleriyle görünmedikleri. Bunlar yapıcıdaki yerel değişkenlerdir, __init__ dışında tamamen erişilemez. Bununla birlikte, kapanışların büyüsü nedeniyle, bunlar aslında bağlı oldukları nesneyle aynı ömre sahip olan örnek başına değişkenlerdir, bunlara privilegedMethod'yi çağırmak dışında dışarıdan erişmenin bir yolu olmamasına rağmen. Genellikle bu tür çok katı bir kapsülleme aşırı yüklenir, ancak bazen bir API veya bir ad alanını temiz tutmak için gerçekten çok kullanışlı olabilir.

Python 2.x'te değişebilir özel duruma sahip olmanın tek yolu değiştirilebilir bir nesneyledir (bu örnekteki dikt gibi). Birçok insan bunun ne kadar sinir bozucu olabileceğini belirtti. Python 3.x, PEP 3104 içinde açıklanan nonlocal anahtar sözcüğünü getirerek bu kısıtlamayı ortadan kaldırır.

3
zaphod

Bir anahtarın dikte olup olmadığını test etmenin basit yolu:

>>> 'key' in { 'key' : 1 }
True

>>> d = dict(key=1, key2=2)
>>> if 'key' in d:
...     print 'Yup'
... 
Yup
3
six8
** Using sets to reference contents in sets of frozensets**

Muhtemelen bildiğiniz gibi, kümeler değişkendir ve bu nedenle de kullanılamazlar, bu nedenle bir küme yapmak istiyorsanız frozensetleri kullanmak (veya kümeleri sözlük anahtarı olarak kullanmak gerekir):

>>> fabc = frozenset('abc')
>>> fxyz = frozenset('xyz')
>>> mset = set((fabc, fxyz))
>>> mset
{frozenset({'a', 'c', 'b'}), frozenset({'y', 'x', 'z'})}

Bununla birlikte, üyeliği test etmek ve sadece sıradan setleri kullanarak üyeleri kaldırmak/silmek mümkündür:

>>> abc = set('abc')
>>> abc in mset
True
>>> mset.remove(abc)
>>> mset
{frozenset({'y', 'x', 'z'})}

Python Standart Kütüphanesi dokümanlarından alıntı yapmak için:

Not, __contains__(), remove() ve discard() yöntemlerinin elem argümanı bir küme olabilir. Eşdeğer bir frozenset aramayı desteklemek için, elem kümesi arama sırasında geçici olarak mutasyona uğratılır ve ardından geri yüklenir. Arama sırasında, elem kümesi anlamlı bir değere sahip olmadığından okunmamalı veya değiştirilmemelidir.

Ne yazık ki ve belki de şaşırtıcı bir şekilde, bu sözlükler için doğru değildir:

>>> mdict = {fabc:1, fxyz:2}
>>> fabc in mdict
True
>>> abc in mdict
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
TypeError: unhashable type: 'set'
3
Don O'Donnell

Getattr yerleşik işlevi:

>>> class C():
    def getMontys(self):
        self.montys = ['Cleese','Palin','Idle','Gilliam','Jones','Chapman']
        return self.montys


>>> c = C()
>>> getattr(c,'getMontys')()
['Cleese', 'Palin', 'Idle', 'Gilliam', 'Jones', 'Chapman']
>>> 

Bağlama bağlı olarak fonksiyonu göndermek istiyorsanız Faydalı. Python'a Dalış Örneklerine bakınız ( Here )

2
Busted Keaton

Nick Johnson'ın bir Mülkiyet sınıfının uygulanmasına ilişkin olarak (yalnızca tanımlayıcıların bir gösterimi, elbette, yerleşik bir yerine geçmez), bir AttributeError'ı yükselten bir belirleyici içerir:

 sınıf Özellik (nesne): 
 def __init __ (öz, fget): 
 self.fget = fget 
 
 def __get __ (öz, obj , type): 
 obj ise Hiçbiri: 
 öz [geri dön 
 öz. kendini döndür. (obj) 
 
 def __set __ (öz, obj, değer): 
 yetiştirme AttributeError, 'Salt okunur öznitelik' 

Belirleyicinin dahil edilmesi, bunu bir yöntem/veri tanımlayıcısı yerine veri tanımlayıcısı yapar. Bir veri tanımlayıcısı, örnek sözlükler üzerinde önceliğe sahiptir. Artık bir örnek, özellik adına atanmış farklı bir nesneye sahip olamaz ve özelliğe atanmaya çalışmak bir özellik hatası oluşturacaktır.

2
eryksun
2

Gerçekten gizli bir özellik değil, kullanışlı olabilecek bir şey.

listedeki öğelerin arasında ikili olarak dolaşmak için

for x, y in Zip(s, s[1:]):
2
Primal Pappachan

Standart Python'da spam modülü

Test amaçlı kullanılır.

Onu ctypes tutorial 'dan seçtim. Kendin dene:

>>> import __hello__
Hello world...
>>> type(__hello__)
<type 'module'>
>>> from __phello__ import spam
Hello world...
Hello world...
>>> type(spam)
<type 'module'>
>>> help(spam)
Help on module __phello__.spam in __phello__:

NAME
    __phello__.spam

FILE
    c:\python26\<frozen>
2
jfs

Bir işlevde exec kullanıyorsanız, değişken arama kuralları önemli ölçüde değişir. Kapaklar artık mümkün değil ancak Python, fonksiyondaki keyfi tanımlayıcılara izin veriyor. Bu size "değiştirilebilir yereller ()" verir ve yıldız tanımlayıcıları içe aktarmak için kullanılabilir. Dezavantajı, her aramayı yavaşlatır çünkü değişkenler çerçevedeki yuvalardan ziyade bir dikme ile sonuçlanır:

>>> def f():
...  exec "a = 42"
...  return a
... 
>>> def g():
...  a = 42
...  return a
... 
>>> import dis
>>> dis.dis(f)
  2           0 LOAD_CONST               1 ('a = 42')
              3 LOAD_CONST               0 (None)
              6 DUP_TOP             
              7 EXEC_STMT           

  3           8 LOAD_NAME                0 (a)
             11 RETURN_VALUE        
>>> dis.dis(g)
  2           0 LOAD_CONST               1 (42)
              3 STORE_FAST               0 (a)

  3           6 LOAD_FAST                0 (a)
              9 RETURN_VALUE        
2
Armin Ronacher

Bellek yönetimi

Python, belleği dinamik olarak ayırır ve kullanılmayan alanı kurtarmak için çöp toplama alanını kullanır. Bir nesne kapsam dışı kaldığında ve başka hiçbir değişken referans göstermediğinde, kurtarılır. Arabellek taşması ve yavaş büyüyen sunucu işlemleri hakkında endişelenmeme gerek yok. Bellek yönetimi ayrıca diğer dinamik dillerin bir özelliğidir ancak Python bunu çok iyi yapar.

Elbette, dairesel referanslara dikkat etmeli ve artık ihtiyaç duyulmayan nesnelere referansları tutmalıyız, ancak zayıf referanslar burada çok yardımcı olur.

2
Mike

Birinci sınıf nesne olarak sınıflar (dinamik bir sınıf tanımında gösterilir)

Kapatma kullanımına da dikkat edin. Bu özel örnek bir soruna "doğru" bir yaklaşım gibi görünüyorsa, birkaç kez dikkatlice yeniden düşünün ... :)

def makeMeANewClass(parent, value):
  class IAmAnObjectToo(parent):
    def theValue(self):
      return value
  return IAmAnObjectToo

Klass = makeMeANewClass(str, "fred")
o = Klass()
print isinstance(o, str)  # => True
print o.theValue()        # => fred
2
user166390

Hiç aralık yerine xrange (INT) kullandı (INT) .... Daha az bellek kullanımı var ve tamsayının boyutuna bağlı değil. Yey !! Bu iyi değil mi?

2
Mojo_Jojo

Hiç gizli bir özellik değil ama yine de Güzel:

import os.path as op

root_dir = op.abspath(op.join(op.dirname(__file__), ".."))

Yolları işlerken çok sayıda karakter kaydeder!

2
Luper Rouch

haritayı kullanarak mapreduce ve azaltma işlevleri

bu şekilde basit bir ürün oluşturun:

def sumprod(x,y):
    return reduce(lambda a,b:a+b, map(lambda a, b: a*b,x,y))

örnek:

In [2]: sumprod([1,2,3],[4,5,6])
Out[2]: 32
1
locojay
>>> x=[1,1,2,'a','a',3]
>>> y = [ _x for _x in x if not _x in locals()['_[1]'] ]
>>> y
[1, 2, 'a', 3]


"locals () ['_ [1]']", oluşturulan listenin "gizli adı" dır. Listenin oluşturulma durumu müteakip yapım kararlarını etkilediğinde çok faydalıdır.

1
Kevin Little

Bir programlama özelliği değil ama Python'u bash veya Shell scripts ile kullanırken kullanışlıdır.

python -c"import os; print(os.getcwd());"

Burada python belgelerine bakınız. daha uzun yazarken dikkat edilmesi gerekenler Python scriptleri bu tartışma içinde görülebilir.

1
sransara

Python'un konumlandırma ve anahtar kelime genişletmeleri yalnızca depolanan bir listeden değil, anında da kullanılabilir.

l=lambda x,y,z:x+y+z
a=1,2,3
print l(*a)
print l(*[a[0],2,3])

Bu gibi şeylerle genellikle daha yararlıdır:

a=[2,3]
l(*(a+[3]))
1
Perkins

Senaryoların Etkileşimli Hata Ayıklaması (ve doctest dizeleri)

Bunun olabildiğince yaygın olduğunu sanmıyorum, ancak bu satırı herhangi bir python betiğine ekleyin:

import pdb; pdb.set_trace()

pDB hata ayıklayıcısının kodun bu noktasında çalışma imleci ile açılmasına neden olacaktır. Daha az bilinen şey ise, bence aynı çizgiyi doktesten kullanabiliyorsunuz:

"""
>>> 1 in (1,2,3)   
Becomes
>>> import pdb; pdb.set_trace(); 1 in (1,2,3)
"""

Daha sonra doctest ortamını kontrol etmek için hata ayıklayıcısını kullanabilirsiniz. Bir doktesten gerçekten geçemezsiniz çünkü satırların her biri özerk bir şekilde yürütülür, ancak bu doktrin dünyasını ve çevresini hata ayıklamak için harika bir araçtır.

0
shadowland

commands.getoutput

os.system 'da olduğu gibi doğrudan stdout veya stderr işlevine çıktı veren bir işlevin çıktısını almak istiyorsanız, commands.getoutput kurtarmaya gelir. Tüm modül sadece harika yapılmış.

>>> print commands.getoutput('ls')
myFile1.txt    myFile2.txt    myFile3.txt    myFile4.txt    myFile5.txt
myFile6.txt    myFile7.txt    myFile8.txt    myFile9.txt    myFile10.txt
myFile11.txt   myFile12.txt   myFile13.txt   myFile14.txt   module.py
0
inspectorG4dget

Python 2'de bir ifadenin dize temsilini backticks ile ekleyerek oluşturabilirsiniz:

 >>> `sorted`
'<built-in function sorted>'

Bu python 3.X de gitti.

0

Talep üzerine kwargs işlevlerini oluşturabilirsiniz:

kwargs = {}
kwargs[str("%s__icontains" % field)] = some_value
some_function(**kwargs)

Str () çağrısı bir şekilde gereklidir, çünkü python aksi halde dize olmadığından şikayet eder. Nedenini bilmiyorum;) Bunu Djangos nesne modelindeki dinamik filtreler için kullanıyorum:

result = model_class.objects.filter(**kwargs)
0
Martin Thurau

azaltma ve operatör ile bazı harika özellikler.

>>> from operator import add,mul
>>> reduce(add,[1,2,3,4])
10
>>> reduce(mul,[1,2,3,4])
24
>>> reduce(add,[[1,2,3,4],[1,2,3,4]])
[1, 2, 3, 4, 1, 2, 3, 4]
>>> reduce(add,(1,2,3,4))
10
>>> reduce(mul,(1,2,3,4))
24

İşte tür hataları ayıklarken kullandığım yararlı bir işlev

def typePrint(object):
    print(str(object) + " - (" + str(type(object)) + ")")

Basitçe girişi izleyen yazıyı basar, örneğin

>>> a = 101
>>> typePrint(a)
    101 - (<type 'int'>)
0
giodamelio

Tekrarlamak için bir dize çarpın

print "SO"*5 

verir

SOSOSOSOSO
0
Rabarberski