it-swarm-eu.dev

Skryté vlastnosti Pythonu

1420
jelovirt

Vyrovnání a list with sum() .

sum() vestavěná funkce může být použita k __add__list s dohromady, což poskytuje praktický způsob, jak zploštit list of list s:

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ův vzor

To je vrah z Alex Martelli . Všechny instance stavu Borg sdílení. To odstraňuje potřebu používat vzor singleton (instance nejsou důležité, když je stav sdílen) a je spíše elegantní (ale je komplikovanější s novými třídami).

Hodnota foo může být opětovně přiřazena v libovolné instanci a vše bude aktualizováno, můžete dokonce znovu přiřadit celý diktát. Borg je perfektní jméno, přečtěte si více zde .

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

To je ideální pro sdílení eventlet.GreenPool pro řízení souběžnosti.

9
cerberos

Top tajné atributy

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

Dynamicky přidané atributy

To by mohlo být užitečné, pokud si myslíte, že přidáte některé atributy do svých tříd, stačí je zavolat. To lze provést přepsáním funkce __getattribute__ member, která se nazývá, když se použije bodový operand. Podívejme se například na fiktivní třídu:

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

Když vytvoříte instanci falešného objektu a provedete volání metodou, získáte následující informace:

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

Nakonec můžete atribut nastavit i do své třídy, aby mohl být dynamicky definován. To by mohlo být užitečné, pokud pracujete s webovými strukturami Pythonu a chcete provádět dotazy pomocí analýzy názvu atributu.

Mám Gist u githubu s tímto jednoduchým kódem a jeho ekvivalentem na Ruby, který vytvořil přítel.

Opatruj se!

9
FernandoEscher

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

Některé další experimenty reagují na komentáře:

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

namedtuple je tedy zajímavý podtyp Tuple.

9
Apalala

Vytvoření slovníku dvou sekvencí, které mají související data

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 () poskytuje přístup ke všem objektům Thread v systému a sys._current_frames () vrací aktuální rámce zásob všech vláken v systému, takže tyto dva stavy kombinujte a dostanete výpisy stylů ve stylu Java:

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)

Udělejte to na začátku vícevláknového programu python a kdykoli získáte přístup k aktuálnímu stavu podprocesů odesláním SIGQUIT. Můžete také zvolit signál.SIGUSR1 nebo signál.SIGUSR2.

Viz

8
haridsv

pdb - Debugger Pythonu

Jako programátor je jednou z prvních věcí, které potřebujete pro seriózní vývoj programu, debugger. Python má jeden vestavěný modul, který je k dispozici jako modul nazvaný pdb (přirozeně pro Python DeBugger!).

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

8
Tom Viner

kontrolovat modul je také skvělá funkce.

7
Pratik Deoghare

Reloading moduly umožňují "live-encoding" styl. Instance třídy se však neaktualizují. Zde je důvod, proč a jak se kolem něj dostat. Pamatujte, všechno, ano, všechno je objekt.

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

Nyní změňte metodu v a_module.py a chcete aktualizovat svůj objekt.

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

Zde je jeden způsob, jak ji aktualizovat (ale považovat ji za běžící s nůžkami):

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

Toto je "běh s nůžkami", protože vnitřní stav objektu může být odlišný od toho, co nová třída očekává. To funguje pro opravdu jednoduché případy, ale kromě toho je pickle váš přítel. Je však stále užitečné pochopit, proč to funguje.

7
Ken Arnold

Operátory mohou být volány jako funkce:

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

nekonečná rekurze v seznamu

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

... že dict.get()výchozí hodnota of None, čímž se vyhnete KeyErrors:

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

a dokonce specifikovat toto 'u scény':

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

A můžete použít setdefault() pro nastavení hodnoty a vrácení, pokud neexistuje:

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

Zpětná lomítka uvnitř surových řetězců mohou stále unikat uvozovkám. Viz toto:

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

Všimněte si, že zpětné lomítko a dvojité uvozovky jsou obsaženy v posledním řetězci.

V důsledku toho nelze ukončit nezpracovaný řetězec se zpětným lomítkem:

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

K tomu dochází, protože byly implementovány syrové řetězce, které pomáhají psát regulární výrazy, a nikoli zapisovat cesty systému Windows. Přečtěte si o tom dlouhou diskusi na Gotcha - zpětná lomítka v názvech souborů systému Windows .

7

Objekty malých intgers (-5 .. 256) nikdy vytvořené dvakrát:


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

Upravit: Seznam objektů, které nebyly nikdy zničeny (pouze objekty v seznamech). Python má pole, ve kterém uchovává až 80 prázdných seznamů. Když zničíte objekt seznamu - python ho vloží do tohoto pole a při vytvoření nového seznamu dostane python z tohoto pole poslední vložený seznam:


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

Řezy jako hodnoty. Toto síto Eratosthenes produkuje seznam, který má buď prvočíslo, nebo 0. Prvky jsou 0'd ven s přiřazením řezu ve smyčce.

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)

Pro práci musí být řez vlevo přiřazen seznam vpravo od stejné délky.

6
hughdbrown

Zaokrouhlování Celá čísla: Python má funkci, která vrací čísla typu double:

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

Tato funkce má nádhernou magickou vlastnost:

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

Pokud potřebujete výsledek, použijte příkaz int k převedení typu:

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

Děkuji Gregor .

6
yoav.aviram

Manipulační limit rekurze

Získání nebo nastavení maximální hloubky rekurze pomocí sys.getrecursionlimit () & sys.setrecursionlimit ().

Můžeme jej omezit, aby se zabránilo přetečení zásobníku způsobenému nekonečnou rekurzí.

6
grayger

Mro třídy můžete přepsat metaclassem

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

Je to pravděpodobně ukrytý z dobrého důvodu. :)

6

Schopnost nahradit i věci jako mazání souborů, otevírání souborů atd. - přímá manipulace s jazykovou knihovnou. To je obrovská výhoda, když testování. Nemusíte všechno zabalit do složitých kontejnerů. Stačí nahradit funkci/metodu a jít. Toto je také nazýváno opice-záplatování.

6
Paweł Hajdan

Řezy a mutability

Kopírování seznamů

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

Výměna seznamů

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

Vnořená funkce Parametr Re-vazba

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 ignoruje čárky, pokud je nalezen za posledním prvkem sekvence:

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

Koncová čárka způsobí, že se s jedním prvkem v závorkách zachází jako s posloupností:

>>> a_Tuple_with_one_element = (8,)
6
Martin

Vestavěné metody nebo funkce neimplementují protokol deskriptoru, který znemožňuje podobné věci:

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

Můžete však vytvořit malý popisovač vazeb, který to umožní:

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

Funkci můžete zdobit třídami - nahrazením funkce třídou instance:

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

Nejsem si jistý, kde (nebo zda) je to v Pythonových dokumentech, ale pro python 2.x (alespoň 2,5 a 2,6, které jsem právě zkoušel) lze příkaz print vyvolat pomocí parenthenses. To může být užitečné, pokud chcete snadno přenést Python 2.x do Pythonu 3.x.

Příklad: print('We want Moshiach Now') by měl tisknout We want Moshiach Now práci v pythonu 2.5, 2.6 a 3.x.

Operátor not může být také volán s rodičovskými čočkami v Pythonu 2 a 3: not False a not(False) by měly oba vrátit True.

Parenthenses mohou také pracovat s jinými prohlášeními a operátory.

EDITOVAT: NENÍ dobrý nápad umístit parenthenses kolem not operátorů (a pravděpodobně i jiných operátorů), protože to může udělat pro překvapivé situace, jako je tomu tak (to se děje proto, že parenthenses jsou opravdu kolem 1):

>>> (not 1) == 9
False

>>> not(1) == 9
True

To může také fungovat, pro některé hodnoty (myslím, že tam není platný název identifikátoru), jako je tento: not'val' by měl vrátit False a print'We want Moshiach Now' by měl vrátit We want Moshiach Now. (ale not552 by zvýšil hodnotu NameError, protože se jedná o platný název identifikátoru).

5
Abbafei

Dict Komplikace

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

Dokumentace Pythonu

Vstup Wikipedie

5
Justin

Příliš líný na inicializaci každého pole ve slovníku? Žádný problém:

V jazyce Python> 2.3:

from collections import defaultdict

V Pythonu <= 2.3:

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

V jakékoli verzi:

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

UPDATE:

Díky Ken Arnold . Přepracoval jsem sofistikovanější verzi defaultdictu. Mělo by se chovat přesně jako ten ve standardní knihovně .

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.

Monkeypatching objekty

Každý objekt v Pythonu má člena __dict__, který ukládá atributy objektu. Tak můžete udělat něco takového:

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

To lze využít k přidání jak atributů, tak funkcí libovolně do objektů. To může být také využito k vytvoření rychlého a špinavého typu struct.

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

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

Jednoduchý vestavěný srovnávací nástroj

Knihovna standardů Python je dodávána s velmi snadno použitelným modulem benchmarkingu nazvaným "timeit". Můžete ji dokonce použít z příkazového řádku, abyste zjistili, která z několika jazykových konstrukcí je nejrychlejší.

Např.,

% 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

Nastavit omezení

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

Dokumentace Pythonu

Vstup Wikipedie

5
Justin

Kromě výše zmíněných haridsv :

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

je to také možné:

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

Seznam porozumění

seznam porozumění

Porovnejte tradičnější (bez porozumění seznamu):

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

na:

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

Zde jsou 2 velikonoční vajíčka:


Jeden v samotném pythonu:

>>> import __hello__
Hello world...

A další v modulu Werkzeug, který je trochu složitější odhalit, zde je:

Při pohledu na zdrojový kód Werkzeug ve werkzeug/__init__.py je řádek, který by měl upozornit na vaši pozornost:

'werkzeug._internal':   ['_easteregg']

Pokud jste trochu zvědaví, mělo by to vést k tomu, abyste se podívali na werkzeug/_internal.py, kde najdete funkci _easteregg(), která v aplikaci používá aplikaci wsgi, obsahuje také některá data zakódovaná kódem base64 a 2 vnořené funkce, Zdá se, že dělá něco zvláštního, pokud je v řetězci dotazu nalezen argument s názvem macgybarchakku.

Takže, abych odhalil toto velikonoční vajíčko, zdá se, že potřebujete zabalit aplikaci do funkce _easteregg(), pojďme:

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

Nyní, pokud spustíte aplikaci a navštivte http: // localhost: 8080 /? Macgybarchakku , měli byste vidět velikonoční vajíčko.

5
mdeous

Pokud používáte deskriptory na svých třídách, Python zcela obejde __dict__ pro tento klíč, což z něj dělá pěkné místo pro ukládání těchto hodnot:

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

To pomáhá udržet dir() čisté.

5
Armin Ronacher

Pythonic idiom x = ... if ... else ... je mnohem lepší než x = ... and ... or ... a zde je důvod, proč:

Ačkoli prohlášení

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

Je ekvivalentní

x = y == 1 and 3 or 2

pokud použijete idiom x = ... and ... or ..., jednoho dne vás může tato složitá situace pokořit:

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

a proto není ekvivalentní

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

Pro více informací o správném způsobu, jak to udělat, viz Skryté vlastnosti Pythonu .

5
Amol
5
Gurch

Vystavení proměnných vyrovnávacích pamětí

Použití Python Buffer Protocol k exponovat mutovatelné byte-orientované buffery v Pythonu (2.5/2.6).

(Omlouváme se, zde není žádný kód. Vyžaduje použití nízkoúrovňového rozhraní C API nebo existujícího modulu adaptéru).

5
user166390

getattr má třetí parametr

getattr(obj, attribute_name, default) je jako:

try:
    return obj.attribute
except AttributeError:
    return default

kromě toho attribute_name může být libovolný řetězec.

To může být velmi užitečné pro kachní psaní . Možná máte něco jako:

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

(btw, isinstance(obj, (a,b)) znamená isinstance(obj, a) or isinstance(obj, b).)

Když uděláte nový druh věci, budete ji muset přidat do toho Tuple všude, kde k ní dojde. (Tato konstrukce také způsobuje problémy při opětovném načítání modulů nebo importu stejného souboru pod dvěma jmény. Stává se to více, než lidé rádi přiznávají.) Místo toho byste mohli říci:

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

Přidat dědičnost a to je ještě lepší: všechny vaše příklady zpracovatelných objektů mohou zdědit

class Processable:
    processable = True

ale nemusíte přesvědčit každého, aby zdědil od vaší základní třídy, jen aby nastavil atribut.

5
Ken Arnold

__getattr __ ()

getattr je opravdu pěkný způsob, jak vytvořit obecné třídy, což je zvláště užitečné, pokud píšete API. Například v FogBugz Python API , getattr se používá k předávání volání metod na webové služby bez problémů:

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

Když někdo volá FogBugz.search(q='bug'), nedostane vlastně volání metody search. Namísto toho getattr zpracovává volání vytvořením nové funkce, která zabalí metodu makerequest, která řemeslným požadavkům HTTP na webové rozhraní API. Jakékoliv chyby budou odeslány webovou službou a předány uživateli.

5
tghw

První prvotina všeho („všechno je objekt“) a chaos, který to může způsobit.

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

Poslední řádek vytvoří Tuple obsahující dvě funkce, pak vyhodnotí y> x (True) a použije jej jako index k Tuple (tím, že se převede na int, 1), a pak zavolá tuto funkci s parametrem y a zobrazí výsledek.

Pro další zneužití, pokud jste vraceli objekt s indexem (např. Seznamem), můžete na konci přidat další hranaté závorky; pokud obsah byl vypověditelný, více závorek a tak dále. Pro extra perverzi použijte výsledek tohoto kódu jako výraz v jiném příkladu (tj. Nahradit y> x tímto kódem):

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

Toto přehlídky dva aspekty Python - 'všechno je filozofie objektu' zaujatý k extrému, a metody kterým nesprávný nebo špatně-koncipovaný použití syntaxe jazyka může vést k úplně nečitelný, unmaintainable spaghetti kód, který se vejde do jediného výrazu\t .

4
Dan Udey

Tuple rozbalení pro smyčky, seznam porozumění a výrazy generátoru:

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

Užitečné v tomto idiomu pro iteraci (klíčových, datových) párů ve slovnících:

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

výtisky:

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

S nepatrným množstvím práce se modul navlékání závitů stává neuvěřitelně snadno použitelným. Tento dekoratér změní funkci tak, aby byla spuštěna ve vlastním vlákně a vrátila instanci třídy zástupných symbolů namísto pravidelného výsledku. Odpověď můžete prozkoumat kontrolou placeolder.result nebo počkejte na to voláním placeholder.awaitResult ()

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 má výjimky pro velmi neočekávané věci:

Dovoz

To vám umožní importovat alternativu, pokud chybí lib

try:
    import json
except ImportError:
    import simplejson as json

Iterace

Pro smyčky to proveďte interně a chytte StopIteration:

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

Tvrzení

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

I když je to více podrobnější pro jednu kontrolu, více kontrol směšování výjimek a booleovské operátory se stejnou chybovou zprávu lze zkrátit tímto způsobem.

4
e-satis

V Pythonu nejsou žádná tajemství;)

4
Juanjo Conti

Kombinace rozbalení s funkcí tisku:

# 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

Výměna metody pro instanci objektu

Metody již vytvořených instancí objektů můžete nahradit. Umožňuje vytvořit instanci objektu s různými (výjimečnými) funkcemi:

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

C.a bylo nahrazeno fun2() v instanci inst (self se nezměnilo).

Alternativně můžeme použít modul new, ale od Pythonu 2.6 je odepisován:

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

Uzel: Toto řešení by nemělo být používáno jako obecná náhrada dědičného mechanismu! Ale může to být velmi užitečné v některých specifických situacích (ladění, zesměšňování).

Varování: Toto řešení nebude fungovat pro vestavěné typy a pro nové třídy stylů pomocí slotů.

4
Tupteq

Využití dynamické povahy pythonu pro konfiguraci konfiguračních souborů aplikací v syntaxi python. Pokud jste například v konfiguračním souboru měli následující:

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

Pak byste si to mohli prostudovat jako:

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

Přístup k prvkům slovníku jako atributům (vlastnostem). takže pokud a1 = AttrDict () má klíč 'name' -> namísto a1 ['name'], můžeme snadno přistupovat ke jménu atributu a1 pomocí -> a1.name


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

Speciální metody

Absolutní moc!

4
cleg

Identifikátor Unicode v Pythonu3:

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

Export moduluV&SCARON;Eve svém oboru názvů

Včetně názvů importovaných z jiných modulů!

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

Nyní otestujte, co je z modulu importovatelné.

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

To je dobrý důvod, proč from x import * a definovat __all__ =.

4
Apalala

vložení vs příloha

není funkce, ale může být zajímavá

předpokládejme, že chcete vložit některá data do seznamu a pak je vrátit zpět. nejjednodušší věc je

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

pak si myslíte: co místo vkládání čísel od začátku? tak:

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

ale to se stává 100 krát pomalejší! pokud nastavíme počet = 10 ** 6, bude to 1000krát pomalejší; toto je, protože vložka je O (n ^ 2), zatímco append je O (n).

důvodem tohoto rozdílu je to, že vložka musí přesunout každý prvek v seznamu pokaždé, když se nazývá; přidejte na konec seznamu jen to, že prvky (někdy musí vše znovu alokovat, ale stále je to mnohem rychlejší)

4
Ant

Na stejnou hodnotu můžete přiřadit několik proměnných

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

Užitečné je inicializovat několik proměnných na None, kompaktním způsobem.

4
haridsv

Simulace terciárního operátora pomocí a a nebo.

a a nebo operátory v pythonu vrátí objekty samy místo Booleovců. Tím pádem:

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

Zdá se však, že Py 2.5 přidal explicitního terciárního operátora

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

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

No, to funguje, pokud jste si jisti, že vaše pravdivá klauzule nevyhodnocuje False. příklad:

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

Chcete-li to správně, musíte se jen trochu více:

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

To však není tak hezké. Pokud ji vaše verze pythonu podporuje, použijte podmíněný operátor.

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

Tisk víceřádkových řetězců najednou

Není opravdu užitečná funkce skrytá ve třídě site._Printer, jejíž objekt license je instancí. Ten, když je volán, vytiskne licenci Pythonu. Lze vytvořit další objekt stejného typu, který předává řetězec - např. obsah souboru - jako druhý argument a volejte jej:

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

To by vytisklo obsah souboru rozdělený podle určitého počtu řádků najednou:

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

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

Vše je dynamické

"Není doba kompilace". Vše v Pythonu je runtime. Modul je „definován“ spuštěním zdroje modulu shora dolů, stejně jako skript, a výsledný jmenný prostor je atributem prostoru modulu. Stejně tak třída je definována provedením těla třídy shora dolů a výsledný jmenný prostor je atributem třídy třídy. Tělo třídy může obsahovat zcela libovolný kód - včetně příkazů importu, smyček a dalších výpisů tříd. Vytvoření třídy, funkce nebo dokonce modulu „dynamicky“, jak je někdy požadováno, není těžké; ve skutečnosti je nemožné se vyhnout, protože vše je „dynamické“.

3
Thomas Wouters

Python má "soukromé" proměnné

Proměnné, které začínají, ale ne končí, s dvojitým podtržítkem se stávají soukromými, a nikoli pouze podle konvence. Vlastně __var se změní na _Classname__var, kde Classname je třída, ve které byla proměnná vytvořena. Nejsou zděděny a nemohou být překonány.


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

Skutečnost, že VŠE je objekt a jako taková je rozšiřitelná. Můžu přidat členské proměnné jako metadata do funkce, kterou definuji:

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

To může být velmi užitečné pro psaní testů dynamických jednotek, např.

3
Greg

zatímco ne příliš Pythonic můžete zapisovat do souboru pomocí print

print>>outFile, 'I am Being Written'

Vysvětlení :

Tato forma je někdy označována jako „print chevron.“ V tomto formuláři musí první výraz po >> vyhodnotit jako „souborový“ objekt, konkrétně objekt, který má metodu write() popsanou výše. S tímto rozšířeným formulářem jsou následující výrazy vytištěny do tohoto objektu souboru. Pokud je první výraz vyhodnocen jako None, použije se jako soubor pro výstup sys.stdout.

3
matchew

Objekty v logickém kontextu

Prázdné n-tice, seznamy, diktáty, řetězce a mnoho dalších objektů jsou ekvivalentní False v boolean kontextu (a non-prázdné jsou ekvivalentní True).

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

To umožňuje logickým operacím vrátit jeden z operandů namísto True/False, což je užitečné v některých situacích:

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

Pokud jste přejmenovali třídu ve své aplikaci, kde načítáte soubory uložené uživatelem prostřednictvím nástroje Pickle, a jedna z přejmenovaných tříd je uložena ve starém uložení uživatele, nebudete moci tento soubor načíst.

Stačí však jednoduše přidat odkaz na definici vaší třídy a vše dobré:

např. před:

class Bleh:
    pass

nyní,

class Blah:
    pass

takže uložený uložený soubor uživatele obsahuje odkaz na Bleh, který v důsledku přejmenování neexistuje. Oprava?

Bleh = Blah

jednoduchý!

3
Steven Sproat

Funkční podpora.

Výrazy generátorů a generátorů.

Ruby znovu udělal tento mainstream, ale Python to dokáže stejně dobře. Není to tak všudypřítomné v knihovnách jako v Ruby, což je příliš špatné, ale líbí se mi syntaxe lépe, je to jednodušší.

Protože nejsou tak všudypřítomní, nevidím tolik příkladů, proč jsou užitečné, ale dovolili mi napsat čistejší a účinnější kód.

3
Karl Anderson

Soukromé metody a skrytí dat (zapouzdření)

Tam je obyčejný idiom v Python označovat metody a jiné členy třídy, které nejsou zamýšlel být díl třídy je externí API tím, že dá jim jména, která začínají podtržítky. To je praktické a v praxi velmi dobře funguje, ale dává falešný dojem, že Python nepodporuje skutečné zapouzdření soukromého kódu a/nebo dat. Ve skutečnosti vám Python automaticky dává lexikální uzávěry , což velmi usnadňuje zapouzdření dat mnohem více neprůstřelným způsobem, když to situace opravdu zaručuje. Zde je příklad třídy, která tuto techniku ​​využívá:

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

A zde je vynalézavý příklad jeho použití:

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

Klíčem je, že privateMethod a privateData nejsou ve skutečnosti atributy obj vůbec, takže nemohou být přístupné zvenčí, ani se nezobrazují v dir() nebo podobně. Jsou to lokální proměnné v konstruktoru, zcela nepřístupné mimo __init__. Kvůli kouzlu uzávěrů jsou však skutečně proměnnými na instanci se stejnou životností jako objekt, se kterým jsou spojeny, i když k nim není možné přistupovat zvenčí, s výjimkou (v tomto příkladu) vyvoláním privilegedMethod. Tento druh velmi přísného zapouzdření je často přehnaný, ale někdy to může být velmi užitečné pro udržení čistého rozhraní API nebo jmenného prostoru.

V Pythonu 2.x je jediným způsobem, jak mít mutovatelný soukromý stav, mutovatelný objekt (například dict v tomto příkladu). Mnoho lidí poznamenalo, jak to může být nepříjemné. Python 3.x toto omezení odstraní zavedením klíčového slova nonlocal popsaného v PEP 3104 .

3
zaphod

Jednoduchý způsob, jak otestovat, zda je klíč v diktátu:

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

Jak pravděpodobně víte, sady jsou mutovatelné, a proto nejsou hašovatelné, takže je nutné použít frozensets, pokud chcete vytvořit sadu sad (nebo použít sady jako klíče slovníků):

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

Je však možné otestovat členství a odebrat/odstranit členy pomocí běžných sad:

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

Citace z dokumentu Knihovna standardů Python:

Poznámka: argument elem pro metody __contains__(), remove() a discard() může být množina. Pro podporu hledání ekvivalentního frozensetu je soubor elem dočasně zmutován během vyhledávání a poté obnoven. Během hledání by soubor elem neměl být čten ani mutován, protože nemá významnou hodnotu.

Bohužel, a možná i překvapivě, totéž neplatí pro slovníky:

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

Vestavěná funkce getattr:

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

Užitečné, pokud chcete odesílat funkce v závislosti na kontextu. Podívejte se na příklady v Dive Into Python ( Zde )

2
Busted Keaton

Co se týče implementace třídy Property Nicka Johnsona (jen ukázka popisovačů, samozřejmě, ne náhrada za vestavěný), zahrnula bych setter, který vyvolá AttributeError:

 třída Vlastnost (objekt): 
 def __init __ (self, fget): 
 self.fget = fget 
 
 def __get __ (self, obj , type): 
 pokud obj je None: 
 return self 
 return self.fget (obj) 
 
 def __set __ (self, obj, value): 
 raise AttributeError, 'Atribut jen pro čtení' 

Zahrnutí setteru činí tento datový deskriptor na rozdíl od metody/datového deskriptoru. Deskriptor dat má přednost před slovníky instancí. Nyní instance nemůže mít jiný objekt přiřazený k názvu vlastnosti a pokusy o přiřazení vlastnosti zvýší chybu atributu.

2
eryksun
2

Není to opravdu skrytá vlastnost, ale něco, co by se mohlo hodit.

pro opakované procházení položek v seznamu

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

Modul spam ve standardním Pythonu

Používá se pro testovací účely.

Vybral jsem to z ctypes tutorial . Zkus to sám:

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

Pokud používáte exec ve funkci, proměnná pravidla pro vyhledávání se drasticky změní. Uzávěry již nejsou možné, ale Python ve funkci umožňuje libovolné identifikátory. To vám dává "modifikovatelné locals ()" a může být použito pro identifikaci hvězdičkových importů. Nevýhodou je, že každé vyhledávání je pomalejší, protože proměnné skončí spíše v diktech než v slotech:

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

Správa paměti

Python dynamicky přiděluje paměť a používá k odstranění nepoužitého místa sběr odpadu. Jakmile je objekt mimo rozsah a nebudou na něj odkazovat žádné jiné proměnné, bude obnoven. Nemusím se starat o překročení bufferů a pomalu rostoucí serverové procesy. Správa paměti je také funkcí jiných dynamických jazyků, ale Python to dělá tak dobře.

Samozřejmě musíme dávat pozor na kruhové odkazy a udržování odkazů na objekty, které již nepotřebujeme, ale slabé odkazy zde hodně pomáhají.

2
Mike

Třídy jako objekty první třídy (zobrazeny pomocí definice dynamické třídy)

Všimněte si také použití uzávěru. Pokud tento konkrétní příklad vypadá jako "správný" přístup k problému, pečlivě přehodnotit ... několikrát :)

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

Někdy používal xrange (INT) namísto rozsahu (INT) .... Má menší využití paměti a ve skutečnosti nezávisí na velikosti celého čísla. Yey! Není to dobré?

2
Mojo_Jojo

Vůbec se nejedná o skrytý rys, ale pořád pěkný:

import os.path as op

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

Šetří spoustu postav při manipulaci s cestami!

2
Luper Rouch

mapreduce pomocí map a redukce funkcí

vytvořte jednoduchý souhrnný produkt takto:

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

příklad:

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]']" je "tajné jméno" vytvořeného seznamu. Velmi užitečné, když stav sestavovaného seznamu ovlivňuje následná rozhodnutí o sestavení.

1
Kevin Little

Není to programovací funkce, ale je užitečná při použití Pythonu s bash nebo Shell scripts.

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

Viz python dokumentace zde . Další věci, které je třeba poznamenat při psaní delších skriptů Pythonu lze vidět v tato diskuse .

1
sransara

Rozmístění pozic a klíčových slov Pythonu lze použít za běhu, nikoli pouze z uloženého seznamu.

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

Obvykle je užitečnější u podobných věcí:

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

Interaktivní ladění skriptů (a řetězců doctest)

Nemyslím si, že je to tak známé, jak by to mohlo být, ale přidejte tento řádek do jakéhokoli skriptu python:

import pdb; pdb.set_trace()

způsobí ladicí program PDB vyskočit s kurzorem spuštění v tomto bodě v kódu. Co je ještě méně známé, myslím, že můžete použít stejnou linku v doctestu:

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

Potom můžete použít ladicí program k pokladně prostředí doctest. Nemůžete opravdu projít doctest, protože linky jsou spuštěny samostatně, ale je to skvělý nástroj pro ladění doctest globs a prostředí.

0
shadowland

commands.getoutput

Pokud chcete získat výstup funkce, která je přímo na stdout nebo stderr, jako je tomu v případě os.system, commands.getoutput přijde na záchranu. Celý modul je vyroben z úžasné.

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

V Pythonu 2 můžete vytvořit řetězcovou reprezentaci výrazu tak, že ji uzavřete pomocí zpětných kopií:

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

Toto je pryč v python 3.X.

0

Můžete postavit funkce kwargs na vyžádání:

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

Volání str () je nějak nutné, protože python si stěžuje, že to není žádný řetězec. Nevím proč;) Používám to pro dynamické filtry v modelu objektu Djangos:

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

některé skvělé funkce s omezením a obsluhou.

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

Zde je užitečná funkce, kterou používám při ladění chyb typu

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

Například jednoduše vytiskne vstup následovaný typem

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

Vynásobte řetězec, abyste ho zopakovali

print "SO"*5 

dává

SOSOSOSOSO
0
Rabarberski