Was die wichtigen Sprachfunktionen (Idiome) von Python sind frühzeitig zu lernen [Duplicate]

Question

    

Diese Frage bereits eine Antwort hier:

    

        
•              Der Zen of Python [geschlossen]                                      22 Antworten                          
        
•              Python: Bin ich etwas fehlt? [Geschlossen]                                      16 Antworten                          
    

    

würde mich interessieren, zu wissen, was die Gemeinschaft denkt Stackoverflow die wichtigen Sprachfunktionen (Idiome) von Python sind. Features, die ein Programmierer als Pythonic definieren würde.

Python (pythonic) Idiom - "code Ausdruck", der auf die Sprache Python natürliche oder charakteristisch ist.

Plus, die Idiome sollten alle Python-Programmierer lernen früh?

Vielen Dank im Voraus

Siehe auch:

• -Code wie ein Pythonista: Idiomatic Python
• Python: Bin ich etwas fehlt

Answer 1

Python ist eine Sprache, die wie folgt beschrieben werden kann:

  

"Regeln, die Sie in die passen   Handfläche mit einer riesigen Tüte   Haken“.

Fast alles, was in Python folgt die gleichen einfachen Standards. Alles ist zugänglich, veränderbar und modifizierbar. Es gibt sehr wenige Sprachniveau Elemente.

Nehmen Sie zum Beispiel die len (Daten) eingebaute Funktion. len(data) funktioniert, indem einfach eine data.__len__() Methode überprüft, und nennt es dann und gibt den Wert. Auf diese Weise len() kann auf jedem Objekt arbeiten, die eine __len__() Methode implementiert.

---

Beginnen Sie mit über die Typen und grundlegende Syntax lernen:

1. Dynamische stark typisierten Sprachen
2. bool, int, float, string, Liste, Tupel, dict, Set
3. Aussagen, Einrückungen, "alles ist ein Objekt"
4. Grundfunktionsdefinitionen

Dann gehen Sie zu lernen, wie Python funktioniert:

1. Importe und Module (wirklich einfach)
2. der Python-Pfad (sys.path)
3. die dir() Funktion
4. __builtins__

Sobald Sie ein Verständnis davon, wie Teile zusammen zu passen, gehen Sie zurück und decken einige der erweiterten Sprachfunktionen:

1. Iteratoren
2. Überschreibungen wie __len__ (es gibt Tonnen von diesen)
3. Listenkomprehensionen und Generatoren
4. Klassen und Objekte (auch hier wirklich einfach, wenn Sie ein paar Regeln kennen)
5. Python Vererbungsregeln

Und wenn Sie ein Komfortniveau mit diesen Produkten haben (mit einem Fokus auf das, was sie pythonic macht), Blick auf speziellere Produkte:

1. Threading in Python (man beachte den Global Interpreter Lock)
2. Kontext-Manager
3. Zugriff auf die Datenbank
4. Datei IO
5. Steckdosen
6. etc ...

---

Und nie vergessen, Der Zen von Python (von 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 2

Diese Seite deckt alle wichtigen Python Idiome: http: // python.net/~goodger/projects/pycon/2007/idiomatic/handout.html

Answer 3

Ein wichtiges Idiom in Python ist Docstrings.

Jedes Objekt hat ein __doc__ Attribut, das verwendet werden kann, Hilfe für das Objekt zu erhalten. Sie können die __doc__ Attribut auf Module festgelegt, Klassen, Methoden und Funktionen wie folgt aus:

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

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

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

Wenn Sie jetzt geben help(m), help(m.f) usw. es wird die docstring als Hilfemeldung drucken.

Weil es nur ein Teil der normalen Objekt Innerlichkeit ist das von Dokumention verwendet werden können Systeme wie epydoc oder verwendet zu Testzwecken durch Unittest zu erzeugen.

Es kann auch unkonventionelle gestellt werden (dh nicht-idiomatische) verwendet wie Grammatiken in Dparser .

Wo es noch interessanter für mich bekommt, ist, dass, obwohl doc ist eine schreibgeschützte auf den meisten Objekten zuschreiben, können Sie sie wie folgt überall verwenden:

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

und Dokumentations-Tools wie epydoc können sie abholen und formatiert sie richtig (im Gegensatz zu einem normalen Kommentar, der innerhalb der Code-Formatierung bleibt.

Answer 4

Dekorateure bekommen meine Stimme. Wo sonst kann man schreiben so etwas wie:

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)

und erhält eine Ausgabe wie:

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

Alles verbunden Verwendung.
Comprehensions, Generatoren, etc.

Answer 6

Von einer fortgeschritteneren Sicht zu verstehen, wie Wörterbücher werden intern von Python verwendet. Klassen, Funktionen, Module, Referenzen sind alle nur Eigenschaften auf ein Wörterbuch. Sobald dies verstanden wird, ist es einfach, wie man Affen-Patch und nutzt die mächtigen __gettattr__, __setattr__ und __call__ Methoden zu verstehen.

Answer 7

Hier ist eine, die helfen können. Was ist der Unterschied zwischen:

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

und

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

Antwort: im zweiten Beispiel wird foo nur einmal aufgerufen. Dies ist wichtig sein kann, wenn foo eine Nebenwirkung hat, oder wenn die iterable Wesen verwendet, um die Liste zu konstruieren, ist groß.

Answer 8

Ich persönlich wie Python wirklich Syntax definiert Codeblocks durch Verwendung von Vertiefung , und nicht durch die Worte „BEGIN“ und „END“ (wie in Microsoft Basic und Visual Basic - Ich mag es nicht diese) oder unter Verwendung von linken und rechten Klammern (wie in C, C ++, Java, Perl - Ich mag diese)

.

Das hat mir wirklich überrascht, weil, obwohl Vertiefung mir schon immer sehr wichtig, ich nicht zu viel „Lärm“ machen habe - ich mit ihm gelebt, und es ist eine Fähigkeit, in Betracht gezogen werden können andere Völker lesen "Spaghetti" Code. Außerdem habe ich noch nie gehört, empfiehlt ein anderer Programmierer Vertiefung machen, ein Teil einer Sprache. Bis Python! Ich wünschte nur, ich zum ersten Mal diese Idee realisiert hatte.

Für mich ist es, als ob Python Syntax zwingt Sie gut lesbaren Code zu schreiben.

Okay, ich werde meine Seife-Box aus. ; -)

Answer 9

Zwei Dinge, die mir auffiel, als besonders Pythonic waren dynamische Typisierung und die verschiedenen Aromen von Listen in Python verwendet, insbesondere Tupel.

Pythons Liste Besessenheit könnte sagen, LISP-y sein, aber es ist seinen eigenen einzigartigen Geschmack bekommt. Eine Zeile wie:

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

oder auch

return False, False, False

sieht genauso aus wie Python und nichts anderes. (Technisch gesehen, würden Sie diese in Lua auch sehen, aber Lua ist ziemlich Pythonic im Allgemeinen.)

Answer 10

string Ersetzungen verwenden:

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

Wenn ich nicht in Python programmiert, dass einfache Bedienung ist das, was ich am meisten vermisse.

Answer 11

Eine andere Sache, die Sie nicht früh genug beginnen kann, ist wahrscheinlich zu testen. Hier besonders Doctests sind eine gute Möglichkeit, Ihren Code zu testen, indem sie zugleich zu erklären.

Doctests sind einfache Textdatei eine interaktive Interpreter-Sitzung und Text wie folgt enthalten:

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

Wenn z.B. a.text gibt etwas anderes den Test fehl.

Doctests kann innerhalb Docstrings oder Standalone-Text-Dateien sein und ausgeführt werden durch die Verwendung von Doctests Modul . Natürlich sind die bekannteren Unit-Tests sind ebenfalls erhältlich.

Answer 12

Ich denke, dass Online-Tutorials und Bücher nur über Dinge zu tun, reden, die Dinge nicht auf die beste Art und Weise zu tun. Zusammen mit der Python-Syntax denke ich, dass die Geschwindigkeit in einigen Fällen wichtig ist.

Python bietet eine Möglichkeit zur Benchmark-Funktionen, eigentlich zwei !!

Eine Möglichkeit ist es, das profile Modul zu verwenden, etwa so:

import profile

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

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

Eine andere Möglichkeit, dies zu tun, ist das timeit Modul zu verwenden, wie folgt aus:

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)