principales problemas para alguien que se mueve desde un idioma estático (java/C#) a un lenguaje dinámico como python

Question

¿Cuáles son los mejores inconvenientes para alguien que se mueve de un idioma estático (java/C#) a un lenguaje dinámico como Python?

Parece genial cómo se pueden hacer las cosas, pero renombrar un método o agregar/eliminar parámetros parece ser tan arriesgado.

¿Es la única solución para escribir pruebas para cada método?

Answer 1

Yo diría que el número uno está tratando de escribir código estáticamente tipado en un lenguaje dinámico.

no dude en utilizar un identificador para apuntar a una cadena y luego una lista de secciones independientes de código

keys = 'foo bar foobar' # Imagine this coming in as an argument 
keys = keys.split() # Now the semantically chose name for the argument can be 
        # reused As the semantically chosen name for a local variable 

no dude en tratar funciones como valores normales: son. Toma el siguiente analizador Supongamos que queremos tratar todas las etiquetas de encabezado por igual y las etiquetas ul como las etiquetas ol.

class Parser(HTMLParser): 
    def __init__(self, html): 
     self.feed(html) 

    def handle_starttag(self, tag, attrs): 
     parse_method = 'parse_' + tag  
     if hasattr(self, parse_method): 
      getattr(self, parse_method)(attrs) 


    def parse_list(self, attrs): 
     # generic code 

    def parse_header(self, attrs): 
     # more generic code 

    parse_h1 = parse_h2 = parse_h3 = parse_h4 = parse_h5 = parse_h6 = parse_header 
    parse_ol = parse_ul = parse_list 

Esto podría hacerse mediante el uso de código de menos genérico en el método handle_starttag en un lenguaje como Java llevando un registro de qué etiquetas mapa para el mismo método pero si luego decide que desea manejar etiquetas div, se tiene que agregar eso en la lógica de despacho. Aquí solo agrega el método parse_div y listo.

No tipear! ¡Tipo de pato!

def funtion(arg): 
    if hasattr(arg, 'attr1') and hasattr(arg, 'attr2'): 
     foo(arg): 
    else: 
     raise TypeError("arg must have 'attr1' and 'attr2'") 

a diferencia del isinstance(arg, Foo). Esto le permite pasar cualquier objeto con attr1 y attr2. Esto le permite, por ejemplo, pasar una clase de seguimiento envuelta alrededor de un objeto para fines de depuración. Tendría que modificar la clase para hacer eso en Java AFAIK.

Como lo señala THC4k, otra forma (más pitonica) de hacer esto es la expresión EAPF. No me gusta esto porque me gusta detectar errores tan pronto como sea posible. Sin embargo, es más eficiente si esperas que el código rara vez falle. No le digas a nadie que no me gusta, aunque nuestros dejarán de pensar que sé cómo escribir Python. Aquí hay un ejemplo cortesía de THC4k.

try: 
    foo(arg): 
except (AttributeError, TypeError): 
    raise InvalidArgumentError(foo, arg) 

Es un volado que si debemos coger el AttributeError y TypeError o simplemente dejar que se propagan a alguna parte que sabe cómo manejar ellos, pero esto es sólo un ejemplo así que vamos a dejarlo volar.

Answer 2

"Is the only solution to write tests for each method?"

¿Está usted diciendo no pruebas de escritura para cada método en Java?

Si escribió pruebas para cada método en Java, entonces, bueno, nada cambia, ¿verdad?

renaming a method, seems so risky!

Correcto. No lo hagas

adding/removing parameters seems so risky!

¿Qué? ¿Estás hablando de parámetros opcionales? Si es así, tener varios nombres sobrecargados en Java parece arriesgado y confuso. Tener parámetros opcionales parece más simple.

---

Si busca en SO las preguntas más comunes de Python, encontrará que algunas cosas son crónicas.

• Cómo actualizar el PYTHONPATH.

• Por qué un cálculo aleatorio de coma flotante no es lo mismo que una abstracción matemática puede indicar.

• Usando Python 3 y escribiendo el código de un tutorial de Python 2.

• Por qué Python no tiene declaraciones supercomplejas protected, private y public.

• Por qué Python no tiene un tipo de enumeración.

El problema crónico # 1 parece estar utilizando objetos mutables como valores predeterminados para una función. Simplemente evita esto.

Answer 3

Algunas cosas que me llamaron la atención cuando se trata de la primera salida de Python (que viene de un fondo principalmente de Java):

1. Escribir Pythonic código. Utilice las expresiones idiomáticas recomendadas para Python, en lugar de hacerlo de la manera anterior de Java/C. Esto es más que solo un problema cosmético o dogmático. El código pitónico es realmente mucho más rápido en la práctica que el código tipo C prácticamente todo el tiempo. De hecho, en mi humilde opinión, gran parte de la noción de "Python es lento" se debe al hecho de que codificadores inexpertos intentaron codificar Java/C en Python y terminaron teniendo un gran impacto de rendimiento y se les ocurrió la idea de que Python es terriblemente lento Utilice las listas de comprensión y mapa/filtro/reducir siempre que sea posible.

2. Póngase cómodo con la idea de que las funciones son realmente objetos. Páselos como devoluciones de llamada, haga que las funciones devuelvan funciones, conozca los cierres, etc.

3. Hay muchas cosas geniales y casi mágicas que puedes hacer en Python como renombrar métodos como mencionas. Estas cosas son geniales para mostrar las características de Python, pero realmente no son necesarias si no las necesitas. De hecho, como señaló S. Lott, es mejor evitar cosas que parecen riesgosas.