Quali sono alcune caratteristiche di Python che lo rendono unico come lingua propria? [chiuso]

Avrai difficoltà a trovare funzionalità assolutamente uniche . La maggior parte delle caratteristiche linguistiche esistenti sono state adottate in più di una lingua sin dal loro inizio. Alcuni possono essere più rari, soprattutto perché sono nuovi e ancora nell'oscurità, o si estinguono per una buona ragione. Tuttavia, anche in questo caso starai meglio a guardare le combinazioni di funzionalità.

Detto questo, diverse funzionalità di Python dovrebbero creare una combinazione relativamente unica. Almeno non sono a conoscenza di alcuna lingua remota come popolare (e pratica) con un set di funzionalità per lo più sovrapposte. Come notato nei commenti, Ruby è piuttosto vicino, ma ci sono comunque numerose differenze.

• Metaprogramming basato su Metaclass . In pratica, eseguendo il codice arbitario sulla creazione della classe. Rende per molto una buona personalizzazione della classe con un piccolo lavoro molto sulla parte che riceve - ad es. per un Object-relational Mapping (ORM), le classi client possono essere scritte come al solito con alcune linee extra come attr = SomeDataType() e una tonnellata di codice viene generata automaticamente. Un esempio di questo è "Modelli" di Django .
• Sei incoraggiato a utilizzare iteratori per tutto . Ciò è particolarmente evidente in 3.x, dove la maggior parte delle alternative basate su elenchi con un equivalente basato su iteratore è stata abolita a favore di quest'ultima. Gli iteratori fungono anche da interfaccia universale per le collezioni (sia quelle che hai effettivamente in memoria sia quelle che ti servono solo una volta e quindi create con le funzionalità seguenti). Raccolta-agnostica, spazio-efficiente ( O(1) spazio per risultati intermedi spesso segue naturalmente, pochissime attività richiedono effettivamente tutti gli elementi nella memoria contemporaneamente), il crunching dei dati componibili non è mai stato più facile.
• Espressioni del generatore, correlate a quanto sopra. Molti avranno sentito parlare di list comprehensions (creando un elenco da un altro iterabile, filtraggio e mappatura nel processo, con una sintassi molto comoda). Dimenticati di loro, sono zucchero sintattico, un caso speciale. Le espressioni dei generatori sono molto vicine sintatticamente e alla fine producono la stessa sequenza di elementi, ma producono risultati pigramente (e quindi richiedono O(1) di spazio a meno che non si mantengano esplicitamente i risultati).
• yield , che rendono principalmente più simpatici gli iteratori di scrittura (chiamati generatori qui). Sono il fratello maggiore di quanto sopra, supportando tutti i tipi di flusso di controllo. C # ha qualcosa di simile, con la stessa parola chiave. Ma yield è anche sovraccarico per supportare un tipo limitato di coroutine (Lua ad esempio ha un supporto più elaborato) che è stato tuttavia utilizzato a buon mercato da persone intelligenti che lavorano su problemi difficili. Due esempi in cima alla mia testa: L'analisi della discesa ricorsiva con backtracing e nessun limite di stack e I / O asincrono (con comoda sintassi).
• Assegnazione di più target e disimballaggio iterabile. Assegnazione di steroidi. Non solo è possibile assegnare a più valori contemporaneamente (anche per lo scambio di valori e quando si itera - for key, value in mapping.items() ), è possibile decomprimere qualsiasi iterable di lunghezza nota (onestamente, principalmente tuple) in più variabili. Dal 3.x è persino pratico per insiemi di lunghezza sconosciuta in quanto è possibile specificare alcune variabili che assumono singoli elementi e uno che prende ciò che rimane: first, *everything_in_between, last = values .
• Descrittori , probabilmente il più potente tra i vari modi di personalizzare l'accesso agli attributi. Ci sono proprietà (come in C #, ma senza supporto linguistico speciale), metodi statici, metodi di classe, ecc. Tutti implementati come descrittori. Sono anche oggetti di prima classe. Solo una settimana fa, mi sono trovato di fronte a codice ripetitivo e complicato nelle proprietà, quindi ho scritto una piccola funzione che genera la parte ripetitiva e la racchiude in un oggetto propery .
• Regola del fuorigioco (indentaion per la delimitazione dei blocchi). L'ho messo intenzionalmente. Mentre distingue Python, non si distingue nella programmazione di tutti i giorni una volta che ci si abitua (o almeno è la mia esperienza).

Immagino che l'unica cosa che rende Python unico sia la particolare combinazione di caratteristiche che espone. Questo sarebbe vero per la maggior parte dei linguaggi di programmazione.

Oppure potrebbe esserci una piccola cosa: non ho visto il modo in cui Python supera esplicitamente self come parametro formale per le funzioni membro oggetto eseguite in qualsiasi altra lingua. È una cosa piccola, e non vedo come questo cambi veramente qualcosa.

Ma non sono molto fluente in Python, quindi potrebbero esserci cose che mi mancano di sicuro!

L'elaborazione automatica di docstrings per diventare proprietà del proprietario. In generale, tutte le fantastiche funzioni di introspezione di Python ne fanno un linguaggio davvero unico, dalla possibilità di usare help () alla possibilità di usare __doc__ come proprietà di prima classe di un oggetto. Ad esempio:

>>> class DocStringException(Exception):
...     """Error message is the same as docstring"""
...     def __str__(self):
...         return repr(self.__doc__)
... 
>>> class ExampleException(DocStringException):
...     """An example happened"""
... 
>>> raise ExampleException
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
__main__.ExampleException: 'An example happened'

Altre utili funzioni di introspezione:

• help / help () - aiuto con l'interprete / aiuto con un oggetto
• parole chiave - parole chiave python
• locals () - ottiene i nomi locali
• globals () - ottieni i nomi globali
• dir () - ottiene le proprietà e i metodi di un oggetto
• il metodo .mro. , issubclass - Comprensione dell'ereditarietà
• id () - ottiene l'indirizzo di memoria di un oggetto

1. Generator Expressions
2. input() Lasciatemi spiegare, non ho visto un linguaggio (finora), in cui è possibile assegnare un valore a un'istruzione che stampa qualcosa, è come print/gets di ruby, ma con un valore assegnato alla stampa, invece di : %codice%
3. print "Foo" bar = gets
4. Molti tipi di set di dati: yield

Il fatto è che Python è tra pochissime lingue con un sovraccarico sintattico estremamente basso che gli conferisce enormi poteri espressivi: comprensione list / set / dict, rendimento, decoratori, eval, programmazione di meta class, introspezione, strutture di dati integrate ottimizzate (liste, dict, set), tutte queste cose cospirano in un modo molto carino per dare a te (lo sviluppatore) il potere di esprimere i tuoi pensieri in un codice conciso ed elegante quasi alla velocità che puoi pensare. Non riesco davvero a pensare a nessun'altra lingua con questo insieme di funzioni killer combinate insieme.

Direi che è l'uso del rientro per includere istruzioni e cicli. Non l'ho visto in nessuna altra lingua.

Penso che sia molto utile perché rende molto più difficile offuscare il codice Python!

Sembra anche eseguirsi in modo lineare riga per riga con l'eccezione delle funzioni, e può essere interpretato anche come tale, che è bello.