python - precio - piton bola tamaño maximo

Corto(y útil) fragmentos de pitón

Question

Según el espíritu del "fragmento de C / C ++ más útil" existente: tema:

¿Ustedes tienen fragmentos cortos y monofuncionales de Python que usen (a menudo) y quieran compartir con la comunidad de StackOverlow? Por favor, mantenga las entradas pequeñas (¿quizás menos de 25 líneas?) Y dé solo un ejemplo por publicación.

Comenzaré con un pequeño fragmento que uso de vez en cuando para contar sloc (líneas fuente de código) en proyectos Python:

# prints recursive count of lines of python source code from current directory
# includes an ignore_list. also prints total sloc

import os
cur_path = os.getcwd()
ignore_set = set(["__init__.py", "count_sourcelines.py"])

loclist = []

for pydir, _, pyfiles in os.walk(cur_path):
    for pyfile in pyfiles:
        if pyfile.endswith(".py") and pyfile not in ignore_set:
            totalpath = os.path.join(pydir, pyfile)
            loclist.append( ( len(open(totalpath, "r").read().splitlines()),
                               totalpath.split(cur_path)[1]) )

for linenumbercount, filename in loclist: 
    print "%05d lines in %s" % (linenumbercount, filename)

print "/nTotal: %s lines (%s)" %(sum([x[0] for x in loclist]), cur_path)

Answer 1

Al depurar, a veces desea ver una cadena con un editor básico. Para mostrar una cadena con bloc de notas:

import os, tempfile, subprocess

def get_rand_filename(dir_=os.getcwd()):
    "Function returns a non-existent random filename."
    return tempfile.mkstemp(''.tmp'', '''', dir_)[1]

def open_with_notepad(s):
    "Function gets a string and shows it on notepad"
    with open(get_rand_filename(), ''w'') as f:
        f.write(s)
        subprocess.Popen([''notepad'', f.name])

Answer 2

Aquí hay algunos que creo que valen la pena conocer pero que pueden no ser útiles a diario. La mayoría de ellos son de una sola línea.

Eliminar duplicados de una lista

L = list(set(L))

Obtener enteros de una cadena (espacio separado)

ints = [int(x) for x in S.split()]

Encontrar Factorial

fac=lambda(n):reduce(int.__mul__,range(1,n+1),1)

Encontrar el mayor divisor común

>>> def gcd(a,b):
...     while(b):a,b=b,a%b
...     return a

Answer 3

Arranca un servidor web simple para los archivos en el directorio actual:

python -m SimpleHTTPServer

Útil para compartir archivos.

Answer 4

De hecho, acabo de crear esto, pero creo que va a ser una herramienta de depuración muy útil.

def dirValues(instance, all=False):
    retVal = {}
    for prop in dir(instance):
        if not all and prop[1] == "_":
            continue
        retVal[prop] = getattr(instance, prop)
    return retVal

Normalmente uso dir () en un contexto pdb, pero creo que esto será mucho más útil:

(pdb) from pprint import pprint as pp
(pdb) from myUtils import dirValues
(pdb) pp(dirValues(someInstance))

Answer 5

El único ''truco'' que conozco que realmente me cautivó cuando supe que es enumerar. Le permite tener acceso a los índices de los elementos dentro de un ciclo for.

>>> l = [''a'',''b'',''c'',''d'',''e'',''f'']
>>> for (index,value) in enumerate(l):
...     print index, value
... 
0 a
1 b
2 c
3 d
4 e
5 f

Answer 6

Emulando una declaración de cambio. Por ejemplo switch (x) {..}:

def a():
  print "a"

def b():
  print "b"

def default():
   print "default"

apply({1:a, 2:b}.get(x, default))

Answer 7

Enorme aceleración para la lista anidada y diccionarios con:

deepcopy = lambda x: cPickle.loads(cPickle.dumps(x))

Answer 8

Hardlink archivos idénticos en el directorio actual (en Unix, esto significa que tienen compartir el almacenamiento físico, lo que significa mucho menos espacio):

import os
import hashlib

dupes = {}

for path, dirs, files in os.walk(os.getcwd()):
    for file in files:
        filename = os.path.join(path, file)
        hash = hashlib.sha1(open(filename).read()).hexdigest()
        if hash in dupes:
            print ''linking "%s" -> "%s"'' % (dupes[hash], filename)
            os.rename(filename, filename + ''.bak'')
            try:
                os.link(dupes[hash], filename)
                os.unlink(filename + ''.bak'')
            except:
                os.rename(filename + ''.bak'', filename)
            finally:
        else:
            dupes[hash] = filename

Answer 9

Inicializando una lista 2D

Si bien esto se puede hacer de manera segura para inicializar una lista:

lst = [0] * 3

El mismo truco no funcionará para una lista 2D (lista de listas):

>>> lst_2d = [[0] * 3] * 3
>>> lst_2d
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> lst_2d[0][0] = 5
>>> lst_2d
[[5, 0, 0], [5, 0, 0], [5, 0, 0]]

El operador * duplica sus operandos y las listas duplicadas construidas con [] apuntan a la misma lista. La forma correcta de hacer esto es:

>>> lst_2d = [[0] * 3 for i in xrange(3)]
>>> lst_2d
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> lst_2d[0][0] = 5
>>> lst_2d
[[5, 0, 0], [0, 0, 0], [0, 0, 0]]

Answer 10

Iterar sobre cualquier iterable (lista, conjunto, archivo, secuencia, cadenas, lo que sea), de CUALQUIER tamaño (incluido el tamaño desconocido), por fragmentos de x elementos:

from itertools import chain, islice

def chunks(iterable, size, format=iter):
    it = iter(iterable)
    while True:
        yield format(chain((it.next(),), islice(it, size - 1)))

>>> l = ["a", "b", "c", "d", "e", "f", "g"]
>>> for chunk in chunks(l, 3, tuple):
...         print chunk
...     
("a", "b", "c")
("d", "e", "f")
("g",)

Answer 11

Me gusta este para comprimir todo en un directorio. ¡Tecla de acceso rápido para instabackups!

import zipfile

z = zipfile.ZipFile(''my-archive.zip'', ''w'', zipfile.ZIP_DEFLATED)
startdir = "/home/johnf"
for dirpath, dirnames, filenames in os.walk(startdir):
  for filename in filenames:
    z.write(os.path.join(dirpath, filename))
z.close()

Answer 12

Me gusta usar any y un generador:

if any(pred(x.item) for x in sequence):
    ...

en lugar de un código escrito así:

found = False
for x in sequence:
    if pred(x.n):
        found = True
if found:
    ...

Primero me enteré de esta técnica en un article Peter Norvig.

Answer 13

Para Python 2.4+ o anterior:

for x,y in someIterator:
  listDict.setdefault(x,[]).append(y)

En Python 2.5+ hay una alternativa usando defaultdict .

Answer 14

Para aplanar una lista de listas, como

[[''a'', ''b''], [''c''], [''d'', ''e'', ''f'']]

dentro

[''a'', ''b'', ''c'', ''d'', ''e'', ''f'']

utilizar

[inner
    for outer in the_list
        for inner in outer]

Answer 15

Para averiguar si la línea está vacía (es decir, ya sea tamaño 0 o contiene solo espacio en blanco), use la tira de método de cadena en una condición, como se muestra a continuación:

if not line.strip():    # if line is empty
    continue            # skip it

Answer 16

Para listas de comprensiones que necesitan actual, siguiente:

[fun(curr,next) 
 for curr,next 
 in zip(list,list[1:].append(None)) 
 if condition(curr,next)] 

Para la lista circular zip(list,list[1:].append(list[0])) .

Para anterior, actual: zip([None].extend(list[:-1]),list) circular: zip([list[-1]].extend(list[:-1]),list)

Answer 17

Supongamos que tiene una lista de elementos y desea un diccionario con estos elementos como claves. Utilizar fromkeys:

>>> items = [''a'', ''b'', ''c'', ''d'']
>>> idict = dict().fromkeys(items, 0)
>>> idict
{''a'': 0, ''c'': 0, ''b'': 0, ''d'': 0}
>>>

El segundo argumento de fromkeys es el valor que se otorgará a todas las claves recién creadas.

Answer 18

Una "barra de progreso" que se ve así:

|#############################---------------------|
59 percent done

Código:

class ProgressBar():
    def __init__(self, width=50):
        self.pointer = 0
        self.width = width

    def __call__(self,x):
         # x in percent
         self.pointer = int(self.width*(x/100.0))
         return "|" + "#"*self.pointer + "-"*(self.width-self.pointer)+/
                "|/n %d percent done" % int(x) 

Función de prueba (para el sistema de Windows, cambie "clear" en "CLS"):

if __name__ == ''__main__'':
    import time, os
    pb = ProgressBar()
    for i in range(101):
        os.system(''clear'')
        print pb(i)
        time.sleep(0.1)

Answer 19

Una lista personalizada que cuando se multiplica por otra lista devuelve un producto cartesiano ... lo bueno es que el producto cartesiano es indexable, no como el de itertools.product (pero los multiplicandos deben ser secuencias, no iteradores).

import operator

class mylist(list):
    def __getitem__(self, args):
        if type(args) is tuple:
            return [list.__getitem__(self, i) for i in args]
        else:
            return list.__getitem__(self, args)
    def __mul__(self, args):
        seqattrs = ("__getitem__", "__iter__", "__len__")
        if all(hasattr(args, i) for i in seqattrs):
            return cartesian_product(self, args)
        else:
            return list.__mul__(self, args)
    def __imul__(self, args):
        return __mul__(self, args)
    def __rmul__(self, args):
        return __mul__(args, self)
    def __pow__(self, n):
        return cartesian_product(*((self,)*n))
    def __rpow__(self, n):
        return cartesian_product(*((self,)*n))

class cartesian_product:
    def __init__(self, *args):
        self.elements = args
    def __len__(self):
        return reduce(operator.mul, map(len, self.elements))
    def __getitem__(self, n):
        return [e[i] for e, i  in zip(self.elements,self.get_indices(n))]
    def get_indices(self, n):
        sizes = map(len, self.elements)
        tmp = [0]*len(sizes)
        i = -1
        for w in reversed(sizes):
            tmp[i] = n % w
            n /= w
            i -= 1
        return tmp
    def __add__(self, arg):
        return mylist(map(None, self)+mylist(map(None, arg)))
    def __imul__(self, args):
        return mylist(self)*mylist(args)
    def __rmul__(self, args):
        return mylist(args)*mylist(self)
    def __mul__(self, args):
        if isinstance(args, cartesian_product):
            return cartesian_product(*(self.elements+args.elements))
        else:
            return cartesian_product(*(self.elements+(args,)))
    def __iter__(self):
        for i in xrange(len(self)):
            yield self[i]
    def __str__(self):
        return "[" + ",".join(str(i) for i in self) +"]"
    def __repr__(self):
        return "*".join(map(repr, self.elements))

Answer 20

zip(*iterable) transpone un iterable.

>>> a=[[1,2,3],[4,5,6]]
>>> zip(*a)
    [(1, 4), (2, 5), (3, 6)]

También es útil con dicts.

>>> d={"a":1,"b":2,"c":3}
>>> zip(*d.iteritems())
[(''a'', ''c'', ''b''), (1, 3, 2)]

Answer 21

import tempfile
import cPickle

class DiskFifo:
    """A disk based FIFO which can be iterated, appended and extended in an interleaved way"""
    def __init__(self):
        self.fd = tempfile.TemporaryFile()
        self.wpos = 0
        self.rpos = 0
        self.pickler = cPickle.Pickler(self.fd)
        self.unpickler = cPickle.Unpickler(self.fd)
        self.size = 0

    def __len__(self):
        return self.size

    def extend(self, sequence):
        map(self.append, sequence)

    def append(self, x):
        self.fd.seek(self.wpos)
        self.pickler.clear_memo()
        self.pickler.dump(x)
        self.wpos = self.fd.tell()
        self.size = self.size + 1

    def next(self):
        try:
            self.fd.seek(self.rpos)
            x = self.unpickler.load()
            self.rpos = self.fd.tell()
            return x

        except EOFError:
            raise StopIteration

    def __iter__(self):
        self.rpos = 0
        return self

Answer 22

• como otra persona de arriba, dije ''¡Wooww!'' cuando descubrí enumerate ()

• Hice una alabanza a Python cuando descubrí repr () que me dio la posibilidad de ver precisamente el contenido de las cadenas que quería analizar con una expresión regular

• Estuve muy satisfecho de descubrir que la print ''/n''.join(list_of_strings) se muestra mucho más rápidamente con '' / n''.join (...) que for ch in list_of_strings: print ch

• Splitlines (1) con un argumento mantiene las líneas nuevas

Estos cuatro "trucos" combinados en un fragmento son muy útiles para mostrar rápidamente el código fuente de una página web, línea tras línea, cada línea está numerada, todos los caracteres especiales como ''/ t'' o las líneas nuevas no se interpretan, y con las líneas nuevas presente:

import urllib
from time import clock,sleep

sock = urllib.urlopen(''http://docs.python.org/'')
ch = sock.read()
sock.close()


te = clock()
for i,line in enumerate(ch.splitlines(1)):
    print str(i) + '' '' + repr(line)
t1 = clock() - te


print "/n/nIn 3 seconds, I will print the same content, using ''//n''.join(....)/n" 

sleep(3)

te = clock()
# here''s the point of interest:
print ''/n''.join(str(i) + '' '' + repr(line)
                for i,line in enumerate(ch.splitlines(1)) )
t2 = clock() - te

print ''/n''
print ''first  display took'',t1,''seconds''
print ''second display took'',t2,''seconds''

Con mi computadora no muy rápida, obtuve:

first  display took 4.94626048841 seconds
second display took 0.109297410704 seconds