La cuarta parte de una serie de artículos sobre análogos en Python y JavaScript.
En esta parte: argumentos de función, creación y trabajo con clases, herencia, captadores de setter y propiedades de clase.
Resumen de partes anteriores:
- Primera parte : conversión de tipo, operador ternario, acceso a una propiedad por nombre de propiedad, diccionarios, listas, cadenas, concatenación de cadenas.
- Segunda parte : JSON, clientes habituales, errores de excepción
- Tercera parte : Python y JS modernos: patrones de cadena (líneas f), desempaque de listas, funciones lambda, iteraciones de listas, generadores, conjuntos.
Argumentos de funciones
Python tiene un extenso kit de herramientas para trabajar con argumentos de función: hay valores predeterminados, un número variable de argumentos posicionales y con nombre ( *args y **kwargs ).
Cuando pasa un valor a una función, puede especificar el nombre del argumento al que se pasará ese valor. JS también tiene esta característica.
Los valores predeterminados para los argumentos de la función se pueden definir en Python:
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')
En JS, de manera similar:
function report(post_id, reason='not-relevant') { console.log({post_id: post_id, reason: reason}); } report(42); report(post_id=24, reason='spam');
Los argumentos posicionales en Python se pueden procesar con el operador * :
from pprint import pprint def add_tags(post_id, *tags): pprint({'post_id': post_id, 'tags': tags}) add_tags(42, 'python', 'javascript', 'django')
En JS, los argumentos posicionales se procesan utilizando el operador ... :
function add_tags(post_id, ...tags) { console.log({post_id: post_id, tags: tags}); } add_tags(42, 'python', 'javascript', 'django');
Los argumentos con nombre a menudo se usan en Python cuando necesita pasar un número variable de argumentos:
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.', )
Pasar un conjunto de argumentos con nombre a JS se implementa mediante un diccionario ( options en este ejemplo):
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.' });
Clases y herencia
Python es un lenguaje orientado a objetos. Comenzando con ECMAScript 6, JS también le permite escribir código orientado a objetos sin trucos ni sintaxis.
Pitón Creamos una clase, un constructor y un método para la representación textual del objeto:
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)
Acciones similares en 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());
Cree dos clases de Article y Link en Python que heredarán de la clase Post . Puede notar que utilizamos la super función para acceder a los métodos de la clase base Post :
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)
Lo mismo en 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());
Propiedades de clase: captadores y establecedores.
En la programación orientada a objetos, las clases tienen atributos, métodos y propiedades. Las propiedades son una mezcla de atributos y métodos. Puede tratar las propiedades como atributos, pero en algún lugar dentro de ellas se llaman métodos especiales llamados getters / setters para el procesamiento de datos específicos.
En este ejemplo, Python muestra la forma básica de describir el getter y setter para la propiedad slug usando decoradores:
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)
En JS, el getter y setter para la propiedad slug se pueden describir como:
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);
Conclusiones
- En ambos idiomas, puede describir los valores predeterminados de los argumentos de la función.
- En ambos idiomas, puede pasar un número arbitrario de argumentos con nombre o posicionales a una función.
- Ambos lenguajes admiten un paradigma de programación orientado a objetos.
Bueno, y finalmente, el autor de la publicación original ofrece comprarle pdfku con hojas de colores para python y javascript por quince dólares .
Imprime y cuelga en la pared o haz un avión de papel: ¡tú decides!