name - ¿Cuáles son las características importantes del idioma(modismos) de Python para aprender temprano en

python package name

Question

Esta pregunta ya tiene una respuesta aquí:

• The Zen of Python [cerrado] 22 respuestas
• Python: ¿Me estoy perdiendo algo? [cerrado] 16 respuestas

Me interesaría saber qué piensa la comunidad de StackOverflow sobre las características importantes del lenguaje (modismos) de Python. Características que definirían a un programador como Pythonic.

Idioma de Python (pythonic) - "expresión de código" que es natural o característica del lenguaje Python.

Además, ¿qué modismos deberían aprender todos los programadores de Python desde el principio?

Gracias por adelantado

Relacionado:

• Código como un Pythonista: Python Idiomático
• Python: ¿Me estoy perdiendo algo?

Answer 1

Desde un punto de vista más avanzado, entender cómo Python usa internamente los diccionarios. Las clases, funciones, módulos y referencias son solo propiedades en un diccionario. Una vez que se comprende esto, es fácil entender cómo usar el parche de mono y usar los potentes métodos __gettattr__, __setattr__ y __call__.

Answer 2

Dos cosas que me impresionaron especialmente como Pythonic fueron el tipado dinámico y los diversos sabores de las listas usadas en Python, particularmente las tuplas.

La obsesión de la lista de Python podría decirse que es LISP-y, pero tiene su propio sabor único. Una línea como:

return HandEvaluator.StraightFlush, (PokerCard.longFaces[index + 4], 
  PokerCard.longSuits[flushSuit]), []

o incluso

return False, False, False

solo se parece a Python y nada más. (Técnicamente, también verías lo último en Lua, pero Lua es bastante pitonica en general).

Answer 3

Esta página cubre todos los principales modismos de Python: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html

Answer 4

Los decoradores obtienen mi voto. ¿Dónde más puedes escribir algo como:

def trace(num_args=0):
  def wrapper(func):
    def new_f(*a,**k):
      print_args = ''''
      if num_args > 0:
        print_args = str.join('','', [str(x) for x in a[0:num_args]])
      print(''entering %s(%s)'' %(f.__name__,print_args))
      rc = f(*a,**k)
      if rc is not None:
        print(''exiting %s(%s)=%s'' %(f.__name__,str(rc)))
      else:
        print(''exiting %s(%s)'' %(f.__name__))
      return rc
    return new_f
  return wrapper

@trace(1)
def factorial(n):
  if n < 2:
    return 1
  return n * factorial(n-1)
factorial(5)

y obtener resultados como:

entering factorial(5)
entering factorial(4)
entering factorial(3)
entering factorial(2)
entering factorial(1)
entering factorial(0)
exiting factorial(0)=1
exiting factorial(1)=1
exiting factorial(2)=2
exiting factorial(3)=6
exiting factorial(4)=24
exiting factorial(5)=120

Answer 5

Otra cosa que no puedes comenzar lo suficientemente temprano es probablemente la prueba. Aquí especialmente los doctests son una excelente forma de probar tu código explicándolo al mismo tiempo.

doctests son archivos de texto simples que contienen una sesión de intérprete interactivo más un texto como este:

Let''s instantiate our class::

>>> a=Something(text="yes")
>>> a.text
yes

Now call this method and check the results::

>>> a.canify()
>>> a.text
yes, I can

Si egatext arroja algo diferente, la prueba fallará.

Los doctests pueden estar dentro de docstrings o archivos de texto independientes y se ejecutan utilizando el módulo doctests . Por supuesto, las pruebas unitarias más conocidas también están disponibles.

Answer 6

Python es un lenguaje que se puede describir como:

"reglas que pueden caber en la palma de su mano con una enorme bolsa de ganchos".

Casi todo en Python sigue los mismos estándares simples. Todo es accesible, modificable y modificable. Hay muy pocos elementos de nivel de lenguaje.

Tomemos, por ejemplo, la función integrada len (datos). len(data) funciona simplemente buscando un método de data.__len__() , y luego lo llama y devuelve el valor. De esa forma, len() puede funcionar en cualquier objeto que implemente un __len__() .

Comience por aprender sobre los tipos y la sintaxis básica:

1. Idiomas dinámicos fuertemente formulados
2. bool, int, float, cadena, lista, tupla, dict, conjunto
3. declaraciones, sangría, "todo es un objeto"
4. definiciones de funciones básicas

Luego continúe aprendiendo sobre cómo funciona Python:

1. importaciones y módulos (realmente simples)
2. el camino de python (sys.path)
3. la función dir()
4. __builtins__

Una vez que haya comprendido cómo encajar las piezas, vuelva atrás y cubra algunas de las características más avanzadas del lenguaje:

1. iteradores
2. anula como __len__ (hay toneladas de estos)
3. lista comprensiones y generadores
4. clases y objetos (de nuevo, muy simple una vez que conoces un par de reglas)
5. reglas de herencia python

Y una vez que tenga un nivel de comodidad con estos elementos (con un enfoque en lo que los hace pitónicos), consulte los ítems más específicos:

1. Enhebrado en python (tenga en cuenta el bloqueo de intérprete global)
2. administradores de contexto
3. acceso a la base
4. archivo IO
5. tomas de corriente
6. etc ...

Y nunca olvides El Zen de Python (por Tim Peters)

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren''t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you''re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it''s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let''s do more of those!

Answer 7

Todo conectado para mostrar el uso.
Comprensiones, generadores, etc.

Answer 8

Una expresión importante en Python es docstrings.

Cada objeto tiene un atributo __doc__ que se puede utilizar para obtener ayuda sobre ese objeto. Puede establecer el atributo __doc__ en módulos, clases, métodos y funciones como este:

# this is m.py
""" module docstring """

class c:
    """class docstring"""
    def m(self):
        """method docstring"""
        pass

def f(a):
    """function f docstring"""
    return

Ahora, cuando escriba help(m) , help(mf) etc. imprimirá la docstring como mensaje de ayuda.

Debido a que es solo parte de la introspección normal de objetos, esto puede ser utilizado por sistemas de generación de documentación como epydoc o utilizado para fines de prueba por unittest.

También se puede aplicar a usos más no convencionales (es decir, no idiomáticos) como las gramáticas en Dparser .

Lo que me resulta aún más interesante es que, aunque el doc es un atributo de solo lectura en la mayoría de los objetos, puedes usarlos en cualquier lugar como este:

x = 5
""" pseudo docstring for x """

y las herramientas de documentación como epydoc pueden recogerlas y formatearlas correctamente (a diferencia de un comentario normal que permanece dentro del formato del código).

Answer 9

Aquí hay uno que puede ayudar. Cuál es la diferencia entre:

[ foo(x) for x in range(0, 5) ][0]

y

( foo(x) for x in range(0, 5) ).next()

respuesta: en el segundo ejemplo, foo se llama solo una vez. Esto puede ser importante si foo tiene un efecto secundario, o si el iterable que se usa para construir la lista es grande.

Answer 10

Usando sustituciones de cadenas:

name = "Joe"
age = 12
print "My name is %s, I am %s" % (name, age)

Cuando no estoy programando en Python, ese uso simple es lo que más extraño.

Answer 11

Personalmente, me gusta mucho la sintaxis de Python al definir bloques de código mediante el uso de sangrías , y no con las palabras "BEGIN" y "END" (como en Basic y Visual Basic de Microsoft, no me gustan) o usando left- and right- llaves (como en C, C ++, Java, Perl - Me gustan).

Esto realmente me sorprendió porque, aunque la sangría siempre ha sido muy importante para mí, no hice mucho "ruido" al respecto. Viví con eso, y se considera una habilidad para poder leer a otras personas ", spaghetti "código". Además, nunca escuché a otro programador sugerir que la sangría fuera parte de un idioma. Hasta Python! Ojalá me hubiera dado cuenta de esta idea primero.

Para mí, es como si la sintaxis de Python te obligara a escribir un código bueno y legible.

De acuerdo, me bajaré de mi caja de jabón. ;-)

Answer 12

Creo que los tutoriales en línea y los libros solo hablan de hacer cosas, no de hacer las cosas de la mejor manera. Junto con la sintaxis de Python, creo que la velocidad en algunos casos es importante.

Python proporciona una forma de comparar funciones, en realidad dos!

Una forma es usar el módulo de profile , así:

import profile

def foo(x, y, z):
    return x**y % z # Just an example.

profile.run(''foo(5, 6, 3)'')

Otra forma de hacerlo es usar el módulo timeit , así:

import timeit

def foo(x, y, z):
    return x**y % z # Can also be ''pow(x, y, z)'' which is way faster.

timeit.timeit(''foo(5, 6, 3)'', ''from __main__ import *'', number = 100) 
# timeit.timeit(testcode, setupcode, number = number_of_iterations)