Jakie są ważne cechy językowe (idiomy) Pythona do nauki na wczesnym etapie [duplicate]

Ta strona obejmuje wszystkie główne idiomy Pythona: http://python.net / ~goodger/projects/pycon/2007/idiomatic/handout.html

Ważnym idiomem w Pythonie jest docstrings.

Każdy obiekt ma atrybut _ _ doc__, który może być użyty do uzyskania pomocy na tym obiekcie. Możesz ustawić atrybut __doc_ _ na modułach, klasach, metodach i funkcjach w następujący sposób:

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

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

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

Teraz, kiedy wpisujesz help(m), help(m.f) itd. wydrukuje docstring jako wiadomość pomocy.

Ponieważ jest to tylko część normalnej introspekcji obiektu, może to być używane przez systemy generujące dokumenty, takie jak epydoc lub używane do celów testowych przez unittest.

Jeszcze bardziej interesujące jest to, że chociaż doc jest atrybutem tylko do odczytu na większości obiektów, możesz ich używać wszędzie w ten sposób:

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

I narzędzia dokumentacji, takie jak epydoc , mogą je podnieść i odpowiednio sformatować (w przeciwieństwie do normalnego komentarza, który pozostaje wewnątrz formatowania kodu.

Dekoratorzy dostają mój głos. Gdzie jeszcze można napisać coś w stylu:

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)

I get output like:

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

Wszystko co związane z użytkowaniem listy.
Agregaty, Generatory itp.

Z bardziej zaawansowanego punktu widzenia, zrozumienie, w jaki sposób słowniki są używane wewnętrznie przez Pythona. Klasy, funkcje, Moduły, referencje to tylko właściwości w słowniku. Gdy to zrozumiemy, łatwo będzie zrozumieć, jak wykonać łatkę i użyć potężnych metod _ _ gettattr__, _ _ setattr _ _ I _ _ call__.

Oto jeden, który może pomóc. Jaka jest różnica między:

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

I

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

Odpowiedź: w drugim przykładzie foo jest wywoływane tylko raz. Może to być ważne, jeśli foo ma efekt uboczny lub jeśli iterable używany do konstruowania listy jest duży.

Osobiście bardzo lubię Definiowanie bloków kodu w Pythonie za pomocą wcięcia, a nie za pomocą słów "BEGIN" I "END" (jak w Basic i Visual Basic Microsoftu - nie lubię tych) lub za pomocą lewego i prawego klamry (jak w C, C++, Java, Perl - lubię te).

To naprawdę mnie zaskoczyło, bo chociaż wcięcia zawsze były dla mnie bardzo ważne, nie robiłam na to zbyt wiele "hałasu" - żyłam z tym, a umiejętność czytania innych jest uważana za umiejętność ludzie, kod "spaghetti". Co więcej, nigdy nie słyszałem, aby inny programista sugerował, aby wcięcia stały się częścią języka. Aż Do Pytona! Żałuję tylko, że nie zrealizowałem tego pomysłu jako pierwszy.

Dla mnie to tak, jakby składnia Pythona zmuszała do pisania dobrego, czytelnego kodu.

Dobra, zejdę z mydelniczki. ;-)

Dwie rzeczy, które uderzyły mnie jako szczególnie Pythoniczne, to dynamiczne pisanie i różne smaki list używanych w Pythonie, szczególnie krotki.

Obsesja listy Pythona można powiedzieć, że jest LISP-y, ale ma swój własny, unikalny smak. Wiersz jak:

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

Lub nawet

return False, False, False

Using string substitutions:

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

Kiedy nie programuję w Pythonie, tego prostego użycia najbardziej mi brakuje.

Kolejną rzeczą, której nie możesz zacząć wystarczająco wcześnie, jest prawdopodobnie testowanie. Tutaj szczególnie doctesty są świetnym sposobem na przetestowanie kodu, wyjaśniając go jednocześnie.

Doctesty to prosty plik tekstowy zawierający interaktywną sesję interpretera oraz tekst taki jak ten:

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

Jeśli np. a. text zwróci coś innego, test się nie powiedzie.

Doctesty mogą być wewnątrz docstrings lub samodzielnych plików tekstowych i są wykonywane za pomocą modułu doctests . Oczywiście dostępne są również bardziej znane testy jednostkowe.

Myślę, że poradniki online i książki mówią tylko o robieniu rzeczy, a nie robieniu rzeczy w najlepszy sposób. Wraz ze składnią Pythona uważam, że szybkość w niektórych przypadkach jest ważna.

Python zapewnia sposób na testowanie funkcji, właściwie dwóch!!

Jednym ze sposobów jest użycie modułu profile w następujący sposób:

import profile

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

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

Innym sposobem jest użycie modułu timeit, Tak:

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)