Der vierte Teil einer Reihe von Artikeln über Analoga in Python und JavaScript.
In diesem Teil: Funktionsargumente, Erstellen und Arbeiten mit Klassen, Vererbung, Setter-Getter und Klasseneigenschaften.
Zusammenfassung der vorherigen Teile:
- Erster Teil : Typkonvertierung, ternärer Operator, Zugriff auf eine Eigenschaft nach Eigenschaftsname, Wörterbücher, Listen, Zeichenfolgen, Zeichenfolgenverkettung.
- Teil zwei : JSON, Stammgäste, Ausnahmefehler
- Dritter Teil : Modernes Python und JS: String-Muster (F-Strings), Listenentpacken, Lambda-Funktionen, Listeniterationen, Generatoren, Mengen.
Funktionsargumente
Python verfügt über ein umfangreiches Toolkit für die Arbeit mit Funktionsargumenten - es gibt Standardwerte, eine variable Anzahl von Positions- und benannten Argumenten ( *args und **kwargs ).
Wenn Sie einen Wert an eine Funktion übergeben, können Sie den Namen des Arguments angeben, an das dieser Wert übergeben wird. JS hat auch diese Funktion.
Die Standardwerte für Funktionsargumente können in Python definiert werden:
from pprint import pprint def report(post_id, reason='not-relevant'): pprint({'post_id': post_id, 'reason': reason}) report(42) report(post_id=24, reason='spam')
In JS ähnlich:
function report(post_id, reason='not-relevant') { console.log({post_id: post_id, reason: reason}); } report(42); report(post_id=24, reason='spam');
Positionsargumente in Python können mit dem Operator * verarbeitet werden:
from pprint import pprint def add_tags(post_id, *tags): pprint({'post_id': post_id, 'tags': tags}) add_tags(42, 'python', 'javascript', 'django')
In JS werden Positionsargumente mit dem Operator ... verarbeitet:
function add_tags(post_id, ...tags) { console.log({post_id: post_id, tags: tags}); } add_tags(42, 'python', 'javascript', 'django');
In Python werden häufig benannte Argumente verwendet, wenn Sie eine variable Anzahl von Argumenten übergeben müssen:
from pprint import pprint def create_post(**options): pprint(options) create_post( title='Hello, World!', content='This is our first post.', is_published=True, ) create_post( title='Hello again!', content='This is our second post.', )
Das Übergeben einer Reihe benannter Argumente an JS wird mithilfe eines Wörterbuchs implementiert ( options in diesem Beispiel):
function create_post(options) { console.log(options); } create_post({ 'title': 'Hello, World!', 'content': 'This is our first post.', 'is_published': true }); create_post({ 'title': 'Hello again!', 'content': 'This is our second post.' });
Klassen und Vererbung
Python ist eine objektorientierte Sprache. Ab ECMAScript 6 können Sie mit JS auch objektorientierten Code ohne Tricks und Syntax schreiben.
Python Wir erstellen eine Klasse, einen Konstruktor und eine Methode für die Textdarstellung des Objekts:
class Post(object): def __init__(self, id, title): self.id = id self.title = title def __str__(self): return self.title post = Post(42, 'Hello, World!') isinstance(post, Post) == True print(post)
Ähnliche Aktionen auf JS:
class Post { constructor (id, title) { this.id = id; this.title = title; } toString() { return this.title; } } post = new Post(42, 'Hello, World!'); post instanceof Post === true; console.log(post.toString());
Erstellen Sie in Python zwei Article und Linkklassen, die von der Post Klasse erben. Möglicherweise stellen Sie fest, dass wir die super verwenden, um auf die Methoden der Post Basisklasse zuzugreifen:
class Article(Post): def __init__(self, id, title, content): super(Article, self).__init__(id, title) self.content = content class Link(Post): def __init__(self, id, title, url): super(Link, self).__init__(id, title) self.url = url def __str__(self): return '{} ({})'.format( super(Link, self).__str__(), self.url, ) article = Article(1, 'Hello, World!', 'This is my first article.') link = Link(2, 'DjangoTricks', 'https://djangotricks.blogspot.com') isinstance(article, Post) == True isinstance(link, Post) == True print(link)
Gleiches in JS:
class Article extends Post { constructor (id, title, content) { super(id, title); this.content = content; } } class Link extends Post { constructor (id, title, url) { super(id, title); this.url = url; } toString() { return super.toString() + ' (' + this.url + ')'; } } article = new Article(1, 'Hello, World!', 'This is my first article.'); link = new Link(2, 'DjangoTricks', 'https://djangotricks.blogspot.com'); article instanceof Post === true; link instanceof Post === true; console.log(link.toString());
Klasseneigenschaften: Getter und Setter.
In der objektorientierten Programmierung haben Klassen Attribute, Methoden und Eigenschaften. Eigenschaften sind eine Mischung aus Attributen und Methoden. Sie können Eigenschaften als Attribute behandeln, aber irgendwo im Inneren rufen sie spezielle Methoden auf, die als Getter / Setter für bestimmte Datenverarbeitungen bezeichnet werden.
In diesem Beispiel zeigt Python die grundlegende Möglichkeit, den Getter und Setter für die slug Eigenschaft mithilfe von Dekoratoren zu beschreiben:
class Post(object): def __init__(self, id, title): self.id = id self.title = title self._slug = '' @property def slug(self): return self._slug @slug.setter def slug(self, value): self._slug = value post = Post(1, 'Hello, World!') post.slug = 'hello-world' print(post.slug)
In JS können Getter und Setter für die slug Eigenschaft wie slug beschrieben werden:
class Post { constructor (id, title) { this.id = id; this.title = title; this._slug = ''; } set slug(value) { this._slug = value; } get slug() { return this._slug; } } post = new Post(1, 'Hello, World!'); post.slug = 'hello-world'; console.log(post.slug);
Schlussfolgerungen
- In beiden Sprachen können Sie die Standardwerte von Funktionsargumenten beschreiben.
- In beiden Sprachen können Sie einer Funktion eine beliebige Anzahl benannter oder positioneller Argumente übergeben.
- Beide Sprachen unterstützen ein objektorientiertes Programmierparadigma.
Nun, am Ende schlägt der Autor des ursprünglichen Beitrags vor, bei ihm ein PDF mit farbigen Spickzettel für Python und Javascript für fünfzehn Dollar zu kaufen .
Drucken und an die Wand hängen oder ein Papierflugzeug bauen - Sie entscheiden!