mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2025-09-02 19:22:49 +02:00
Merge pull request #3856 from sshine/make-python3-default
[Python] Make Python 3 default
This commit is contained in:
Adam Bard
GitHub
@@ -1,26 +1,25 @@
|
||||
---
|
||||
language: python
|
||||
language: Python
|
||||
contributors:
|
||||
- ["Louie Dinh", "http://ldinh.ca"]
|
||||
- ["Louie Dinh", "http://pythonpracticeprojects.com"]
|
||||
translators:
|
||||
- ["Camilo Garrido", "http://www.twitter.com/hirohope"]
|
||||
- ["Fabio Souto", "http://fabiosouto.me"]
|
||||
- ["Camilo Garrido", "http://twitter.com/hirohope"]
|
||||
lang: es-es
|
||||
filename: learnpython-es.py
|
||||
---
|
||||
|
||||
Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
|
||||
de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
|
||||
Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
|
||||
de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
|
||||
Es básicamente pseudocódigo ejecutable.
|
||||
|
||||
¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
|
||||
|
||||
Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
|
||||
|
||||
```python
|
||||
|
||||
# Comentarios de una línea comienzan con una almohadilla (o signo gato)
|
||||
""" Strings multilínea pueden escribirse
|
||||
usando tres "'s, y comúnmente son usados
|
||||
|
||||
""" Strings multilinea pueden escribirse
|
||||
usando tres "'s, y comunmente son usados
|
||||
como comentarios.
|
||||
"""
|
||||
|
||||
@@ -31,69 +30,49 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
|
||||
# Tienes números
|
||||
3 #=> 3
|
||||
|
||||
# Evidentemente puedes realizar operaciones matemáticas
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
# Matemática es lo que esperarías
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
|
||||
# La división es un poco complicada. Es división entera y toma la parte entera
|
||||
# de los resultados automáticamente.
|
||||
5 / 2 #=> 2
|
||||
# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
|
||||
35 / 5 # => 7.0
|
||||
# Sin embargo también tienes disponible división entera
|
||||
34 // 5 # => 6
|
||||
|
||||
# Para arreglar la división necesitamos aprender sobre 'floats'
|
||||
# (números de coma flotante).
|
||||
2.0 # Esto es un 'float'
|
||||
11.0 / 4.0 #=> 2.75 ahhh...mucho mejor
|
||||
|
||||
# Resultado de la división de enteros truncada para positivos y negativos
|
||||
5 // 3 # => 1
|
||||
5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
|
||||
-5 // 3 # => -2
|
||||
-5.0 // 3.0 # => -2.0
|
||||
|
||||
# El operador módulo devuelve el resto de una división entre enteros
|
||||
7 % 3 # => 1
|
||||
|
||||
# Exponenciación (x elevado a y)
|
||||
2**4 # => 16
|
||||
# Cuando usas un float, los resultados son floats
|
||||
3 * 2.0 # => 6.0
|
||||
|
||||
# Refuerza la precedencia con paréntesis
|
||||
(1 + 3) * 2 #=> 8
|
||||
(1 + 3) * 2 # => 8
|
||||
|
||||
# Operadores booleanos
|
||||
# Nota: "and" y "or" son sensibles a mayúsculas
|
||||
True and False #=> False
|
||||
False or True #=> True
|
||||
|
||||
# Podemos usar operadores booleanos con números enteros
|
||||
0 and 2 #=> 0
|
||||
-5 or 0 #=> -5
|
||||
0 == False #=> True
|
||||
2 == True #=> False
|
||||
1 == True #=> True
|
||||
# Valores 'boolean' (booleanos) son primitivos
|
||||
True
|
||||
False
|
||||
|
||||
# Niega con 'not'
|
||||
not True #=> False
|
||||
not False #=> True
|
||||
not True # => False
|
||||
not False # => True
|
||||
|
||||
|
||||
# Igualdad es ==
|
||||
1 == 1 #=> True
|
||||
2 == 1 #=> False
|
||||
1 == 1 # => True
|
||||
2 == 1 # => False
|
||||
|
||||
# Desigualdad es !=
|
||||
1 != 1 #=> False
|
||||
2 != 1 #=> True
|
||||
1 != 1 # => False
|
||||
2 != 1 # => True
|
||||
|
||||
# Más comparaciones
|
||||
1 < 10 #=> True
|
||||
1 > 10 #=> False
|
||||
2 <= 2 #=> True
|
||||
2 >= 2 #=> True
|
||||
1 < 10 # => True
|
||||
1 > 10 # => False
|
||||
2 <= 2 # => True
|
||||
2 >= 2 # => True
|
||||
|
||||
# ¡Las comparaciones pueden ser concatenadas!
|
||||
1 < 2 < 3 #=> True
|
||||
2 < 3 < 2 #=> False
|
||||
1 < 2 < 3 # => True
|
||||
2 < 3 < 2 # => False
|
||||
|
||||
# Strings se crean con " o '
|
||||
"Esto es un string."
|
||||
@@ -105,40 +84,41 @@ not False #=> True
|
||||
# Un string puede ser tratado como una lista de caracteres
|
||||
"Esto es un string"[0] #=> 'E'
|
||||
|
||||
# % pueden ser usados para formatear strings, como esto:
|
||||
"%s pueden ser %s" % ("strings", "interpolados")
|
||||
# .format puede ser usaro para darle formato a los strings, así:
|
||||
"{} pueden ser {}".format("strings", "interpolados")
|
||||
|
||||
# Una forma más reciente de formatear strings es el método 'format'.
|
||||
# Este método es la forma preferida
|
||||
"{0} pueden ser {1}".format("strings", "formateados")
|
||||
# Puedes usar palabras clave si no quieres contar.
|
||||
"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña")
|
||||
# Puedes reutilizar los argumentos de formato si estos se repiten.
|
||||
"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
|
||||
# Puedes usar palabras claves si no quieres contar.
|
||||
"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
|
||||
# También puedes interpolar cadenas usando variables en el contexto
|
||||
nombre = 'Bob'
|
||||
comida = 'Lasaña'
|
||||
f'{nombre} quiere comer {comida}' #=> "Bob quiere comer lasaña"
|
||||
|
||||
# None es un objeto
|
||||
None #=> None
|
||||
None # => None
|
||||
|
||||
# No uses el símbolo de igualdad `==` para comparar objetos con None
|
||||
# Usa `is` en lugar de
|
||||
# Usa `is` en su lugar
|
||||
"etc" is None #=> False
|
||||
None is None #=> True
|
||||
|
||||
# El operador 'is' prueba la identidad del objeto. Esto no es
|
||||
# muy útil cuando se trata de datos primitivos, pero es
|
||||
# muy útil cuando se trata de objetos.
|
||||
|
||||
# None, 0, y strings/listas vacíos(as) todas se evalúan como False.
|
||||
# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
|
||||
# Todos los otros valores son True
|
||||
bool(0) #=> False
|
||||
bool("") #=> False
|
||||
bool(0) # => False
|
||||
bool("") # => False
|
||||
bool([]) #=> False
|
||||
bool({}) #=> False
|
||||
bool(set()) #=> False
|
||||
|
||||
|
||||
####################################################
|
||||
## 2. Variables y Colecciones
|
||||
####################################################
|
||||
|
||||
# Imprimir es muy fácil
|
||||
print "Soy Python. ¡Encantado de conocerte!"
|
||||
|
||||
# Python tiene una función para imprimir
|
||||
print("Soy Python. Encantado de conocerte")
|
||||
|
||||
# No hay necesidad de declarar las variables antes de asignarlas.
|
||||
una_variable = 5 # La convención es usar guiones_bajos_con_minúsculas
|
||||
@@ -148,19 +128,16 @@ una_variable #=> 5
|
||||
# Ve Control de Flujo para aprender más sobre el manejo de excepciones.
|
||||
otra_variable # Levanta un error de nombre
|
||||
|
||||
# 'if' puede ser usado como una expresión
|
||||
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
|
||||
|
||||
# Las listas almacenan secuencias
|
||||
# Listas almacena secuencias
|
||||
lista = []
|
||||
# Puedes empezar con una lista prellenada
|
||||
otra_lista = [4, 5, 6]
|
||||
|
||||
# Añadir cosas al final de una lista con 'append'
|
||||
lista.append(1) # lista ahora es [1]
|
||||
lista.append(2) # lista ahora es [1, 2]
|
||||
lista.append(4) # lista ahora es [1, 2, 4]
|
||||
lista.append(3) # lista ahora es [1, 2, 4, 3]
|
||||
lista.append(1) #lista ahora es [1]
|
||||
lista.append(2) #lista ahora es [1, 2]
|
||||
lista.append(4) #lista ahora es [1, 2, 4]
|
||||
lista.append(3) #lista ahora es [1, 2, 4, 3]
|
||||
# Remueve del final de la lista con 'pop'
|
||||
lista.pop() #=> 3 y lista ahora es [1, 2, 4]
|
||||
# Pongámoslo de vuelta
|
||||
@@ -181,6 +158,12 @@ lista[1:3] #=> [2, 4]
|
||||
lista[2:] #=> [4, 3]
|
||||
# Omite el final
|
||||
lista[:3] #=> [1, 2, 4]
|
||||
# Selecciona cada dos elementos
|
||||
lista[::2] # =>[1, 4]
|
||||
# Invierte la lista
|
||||
lista[::-1] # => [3, 4, 2, 1]
|
||||
# Usa cualquier combinación de estos para crear trozos avanzados
|
||||
# lista[inicio:final:pasos]
|
||||
|
||||
# Remueve elementos arbitrarios de una lista con 'del'
|
||||
del lista[2] # lista ahora es [1, 2, 3]
|
||||
@@ -191,14 +174,14 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
|
||||
# Concatenar listas con 'extend'
|
||||
lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Chequea la existencia en una lista con
|
||||
# Verifica la existencia en una lista con 'in'
|
||||
1 in lista #=> True
|
||||
|
||||
# Examina el tamaño de una lista con 'len'
|
||||
# Examina el largo de una lista con 'len'
|
||||
len(lista) #=> 6
|
||||
|
||||
|
||||
# Las tuplas son como las listas, pero son inmutables.
|
||||
# Tuplas son como listas pero son inmutables.
|
||||
tupla = (1, 2, 3)
|
||||
tupla[0] #=> 1
|
||||
tupla[0] = 3 # Levanta un error TypeError
|
||||
@@ -217,7 +200,7 @@ d, e, f = 4, 5, 6
|
||||
e, d = d, e # d ahora es 5 y e ahora es 4
|
||||
|
||||
|
||||
# Diccionarios almacenan mapeos
|
||||
# Diccionarios relacionan llaves y valores
|
||||
dicc_vacio = {}
|
||||
# Aquí está un diccionario prellenado
|
||||
dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
@@ -225,16 +208,16 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
# Busca valores con []
|
||||
dicc_lleno["uno"] #=> 1
|
||||
|
||||
# Obtén todas las llaves como una lista
|
||||
dicc_lleno.keys() #=> ["tres", "dos", "uno"]
|
||||
# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego.
|
||||
list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
|
||||
# Nota - El orden de las llaves del diccionario no está garantizada.
|
||||
# Tus resultados podrían no ser los mismos del ejemplo.
|
||||
|
||||
# Obtén todos los valores como una lista
|
||||
dicc_lleno.values() #=> [3, 2, 1]
|
||||
# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable.
|
||||
list(dicc_lleno.values()) #=> [3, 2, 1]
|
||||
# Nota - Lo mismo que con las llaves, no se garantiza el orden.
|
||||
|
||||
# Chequea la existencia de una llave en el diccionario con 'in'
|
||||
# Verifica la existencia de una llave en el diccionario con 'in'
|
||||
"uno" in dicc_lleno #=> True
|
||||
1 in dicc_lleno #=> False
|
||||
|
||||
@@ -248,19 +231,18 @@ dicc_lleno.get("cuatro") #=> None
|
||||
dicc_lleno.get("uno", 4) #=> 1
|
||||
dicc_lleno.get("cuatro", 4) #=> 4
|
||||
|
||||
# El método 'setdefault' es una manera segura de añadir nuevos pares
|
||||
# llave-valor en un diccionario
|
||||
# El método 'setdefault' inserta en un diccionario solo si la llave no está presente
|
||||
dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5
|
||||
dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5
|
||||
|
||||
|
||||
# Remueve llaves de un diccionario con 'del'
|
||||
del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno
|
||||
|
||||
# Sets (conjuntos) almacenan ... bueno, conjuntos
|
||||
conjunto_vacio = set()
|
||||
# Inicializar un conjunto con montón de valores
|
||||
un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4])
|
||||
|
||||
# Desde Python 2.7, {} puede ser usado para declarar un conjunto
|
||||
conjunto_lleno = {1, 2, 2, 3, 4} # => {1 2 3 4}
|
||||
# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento.
|
||||
un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4}
|
||||
|
||||
# Añade más valores a un conjunto
|
||||
conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5}
|
||||
@@ -275,7 +257,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
|
||||
# Haz diferencia de conjuntos con -
|
||||
{1,2,3,4} - {2,3,5} #=> {1, 4}
|
||||
|
||||
# Chequea la existencia en un conjunto con 'in'
|
||||
# Verifica la existencia en un conjunto con 'in'
|
||||
2 in conjunto_lleno #=> True
|
||||
10 in conjunto_lleno #=> False
|
||||
|
||||
@@ -284,32 +266,30 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
|
||||
## 3. Control de Flujo
|
||||
####################################################
|
||||
|
||||
# Hagamos sólo una variable
|
||||
una_variable = 5
|
||||
# Creemos una variable para experimentar
|
||||
some_var = 5
|
||||
|
||||
# Aquí está una declaración de un 'if'. ¡La indentación es importante en Python!
|
||||
# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
|
||||
# imprime "una_variable es menor que 10"
|
||||
if una_variable > 10:
|
||||
print "una_variable es completamente mas grande que 10."
|
||||
print("una_variable es completamente mas grande que 10.")
|
||||
elif una_variable < 10: # Este condición 'elif' es opcional.
|
||||
print "una_variable es mas chica que 10."
|
||||
print("una_variable es mas chica que 10.")
|
||||
else: # Esto también es opcional.
|
||||
print "una_variable es de hecho 10."
|
||||
|
||||
print("una_variable es de hecho 10.")
|
||||
|
||||
"""
|
||||
For itera sobre listas
|
||||
For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
|
||||
imprime:
|
||||
perro es un mamifero
|
||||
gato es un mamifero
|
||||
raton es un mamifero
|
||||
"""
|
||||
for animal in ["perro", "gato", "raton"]:
|
||||
# Puedes usar % para interpolar strings formateados
|
||||
print "%s es un mamifero" % animal
|
||||
print("{} es un mamifero".format(animal))
|
||||
|
||||
"""
|
||||
`range(número)` retorna una lista de números
|
||||
`range(número)` retorna un generador de números
|
||||
desde cero hasta el número dado
|
||||
imprime:
|
||||
0
|
||||
@@ -318,7 +298,7 @@ imprime:
|
||||
3
|
||||
"""
|
||||
for i in range(4):
|
||||
print i
|
||||
print(i)
|
||||
|
||||
"""
|
||||
While itera hasta que una condición no se cumple.
|
||||
@@ -330,18 +310,49 @@ imprime:
|
||||
"""
|
||||
x = 0
|
||||
while x < 4:
|
||||
print x
|
||||
print(x)
|
||||
x += 1 # versión corta de x = x + 1
|
||||
|
||||
# Maneja excepciones con un bloque try/except
|
||||
|
||||
# Funciona desde Python 2.6 en adelante:
|
||||
try:
|
||||
# Usa raise para levantar un error
|
||||
raise IndexError("Este es un error de indice")
|
||||
except IndexError as e:
|
||||
pass # Pass no hace nada. Usualmente harias alguna recuperacion aqui.
|
||||
|
||||
# Python oferce una abstracción fundamental llamada Iterable.
|
||||
# Un iterable es un objeto que puede ser tratado como una sequencia.
|
||||
# El objeto es retornado por la función 'range' es un iterable.
|
||||
|
||||
dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
nuestro_iterable = dicc_lleno.keys()
|
||||
print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
|
||||
|
||||
Podemos recorrerla.
|
||||
for i in nuestro_iterable:
|
||||
print(i) # Imprime uno, dos, tres
|
||||
|
||||
# Aunque no podemos selecionar un elemento por su índice.
|
||||
nuestro_iterable[1] # Genera un TypeError
|
||||
|
||||
# Un iterable es un objeto que sabe como crear un iterador.
|
||||
nuestro_iterator = iter(nuestro_iterable)
|
||||
|
||||
# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos.
|
||||
# Obtenemos el siguiente objeto llamando la función __next__.
|
||||
nuestro_iterator.__next__() #=> "uno"
|
||||
|
||||
# Mantiene el estado mientras llamamos __next__.
|
||||
nuestro_iterator.__next__() #=> "dos"
|
||||
nuestro_iterator.__next__() #=> "tres"
|
||||
|
||||
# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator.
|
||||
nuestro_iterator.__next__() # Genera StopIteration
|
||||
|
||||
# Puedes obtener todos los elementos de un iterador llamando a list() en el.
|
||||
list(dicc_lleno.keys()) #=> Retorna ["uno", "dos", "tres"]
|
||||
|
||||
|
||||
|
||||
####################################################
|
||||
## 4. Funciones
|
||||
@@ -349,7 +360,7 @@ except IndexError as e:
|
||||
|
||||
# Usa 'def' para crear nuevas funciones
|
||||
def add(x, y):
|
||||
print "x es %s y y es %s" % (x, y)
|
||||
print("x es {} y y es {}".format(x, y))
|
||||
return x + y # Retorna valores con una la declaración return
|
||||
|
||||
# Llamando funciones con parámetros
|
||||
@@ -358,6 +369,7 @@ add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11
|
||||
# Otra forma de llamar funciones es con argumentos de palabras claves
|
||||
add(y=6, x=5) # Argumentos de palabra clave pueden ir en cualquier orden.
|
||||
|
||||
|
||||
# Puedes definir funciones que tomen un número variable de argumentos
|
||||
def varargs(*args):
|
||||
return args
|
||||
@@ -373,6 +385,7 @@ def keyword_args(**kwargs):
|
||||
# Llamémosla para ver que sucede
|
||||
keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
|
||||
|
||||
|
||||
# Puedes hacer ambas a la vez si quieres
|
||||
def todos_los_argumentos(*args, **kwargs):
|
||||
print args
|
||||
@@ -410,23 +423,28 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
|
||||
# Podemos usar listas por comprensión para mapeos y filtros agradables
|
||||
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
|
||||
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
|
||||
# también hay diccionarios
|
||||
{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
|
||||
# y conjuntos por comprensión
|
||||
{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
|
||||
|
||||
####################################################
|
||||
## 5. Clases
|
||||
## 5. Classes
|
||||
####################################################
|
||||
|
||||
|
||||
# Heredamos de object para obtener una clase.
|
||||
class Humano(object):
|
||||
|
||||
# Un atributo de clase es compartido por todas las instancias de esta clase
|
||||
especie = "H. sapiens"
|
||||
|
||||
# Constructor básico, se llama al instanciar la clase.
|
||||
# Constructor basico
|
||||
def __init__(self, nombre):
|
||||
# Asigna el argumento al atributo nombre de la instancia
|
||||
self.nombre = nombre
|
||||
|
||||
# Un método de instancia. Todos los metodos toman self como primer argumento
|
||||
# Un metodo de instancia. Todos los metodos toman self como primer argumento
|
||||
def decir(self, msg):
|
||||
return "%s: %s" % (self.nombre, msg)
|
||||
|
||||
@@ -436,7 +454,7 @@ class Humano(object):
|
||||
def get_especie(cls):
|
||||
return cls.especie
|
||||
|
||||
# Un metodo estático es llamado sin la clase o instancia como referencia
|
||||
# Un metodo estatico es llamado sin la clase o instancia como referencia
|
||||
@staticmethod
|
||||
def roncar():
|
||||
return "*roncar*"
|
||||
@@ -467,12 +485,12 @@ Humano.roncar() #=> "*roncar*"
|
||||
|
||||
# Puedes importar módulos
|
||||
import math
|
||||
print math.sqrt(16) #=> 4.0
|
||||
print(math.sqrt(16)) #=> 4.0
|
||||
|
||||
# Puedes obtener funciones específicas desde un módulo
|
||||
from math import ceil, floor
|
||||
print ceil(3.7) #=> 4.0
|
||||
print floor(3.7) #=> 3.0
|
||||
print(ceil(3.7)) #=> 4.0
|
||||
print(floor(3.7))#=> 3.0
|
||||
|
||||
# Puedes importar todas las funciones de un módulo
|
||||
# Precaución: Esto no es recomendable
|
||||
@@ -495,52 +513,48 @@ dir(math)
|
||||
## 7. Avanzado
|
||||
####################################################
|
||||
|
||||
# Los generadores permiten evaluación perezosa
|
||||
# Los generadores te ayudan a hacer un código perezoso (lazy)
|
||||
def duplicar_numeros(iterable):
|
||||
for i in iterable:
|
||||
yield i + i
|
||||
|
||||
# Un generador crea valores sobre la marcha
|
||||
# En vez de generar y devolver todos los valores de una vez, crea un valor
|
||||
# en cada iteración. En este ejemplo los valores mayores que 15 no serán
|
||||
# procesados en duplicar_numeros.
|
||||
# Nota: xrange es un generador que hace lo mismo que range.
|
||||
# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
|
||||
# xrange crea un generador, mientras que range crea toda la lista.
|
||||
# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
|
||||
# reservadas de python.
|
||||
xrange_ = xrange(1, 900000000)
|
||||
|
||||
# duplica todos los números hasta que encuentra un resultado >= 30
|
||||
for i in duplicar_numeros(xrange_):
|
||||
print i
|
||||
# Un generador crea valores sobre la marcha.
|
||||
# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
|
||||
# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
|
||||
# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.
|
||||
_rango = range(1, 900000000)
|
||||
# Duplicará todos los números hasta que un resultado >= se encuentre.
|
||||
for i in duplicar_numeros(_rango):
|
||||
print(i)
|
||||
if i >= 30:
|
||||
break
|
||||
|
||||
|
||||
# Decoradores
|
||||
# en este ejemplo pedir rodea a hablar
|
||||
# Si por_favor es True se cambiará el mensaje.
|
||||
# en este ejemplo 'pedir' envuelve a 'decir'
|
||||
# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar
|
||||
from functools import wraps
|
||||
|
||||
|
||||
def pedir(target_function):
|
||||
@wraps(target_function)
|
||||
def pedir(_decir):
|
||||
@wraps(_decir)
|
||||
def wrapper(*args, **kwargs):
|
||||
msg, por_favor = target_function(*args, **kwargs)
|
||||
if por_favor:
|
||||
return "{} {}".format(msg, "¡Por favor! Soy pobre :(")
|
||||
return msg
|
||||
mensaje, decir_por_favor = _decir(*args, **kwargs)
|
||||
if decir_por_favor:
|
||||
return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(")
|
||||
return mensaje
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
@pedir
|
||||
def hablar(por_favor=False):
|
||||
msg = "¿Me puedes comprar una cerveza?"
|
||||
return msg, por_favor
|
||||
def say(decir_por_favor=False):
|
||||
mensaje = "¿Puedes comprarme una cerveza?"
|
||||
return mensaje, decir_por_favor
|
||||
|
||||
print hablar() # ¿Me puedes comprar una cerveza?
|
||||
print hablar(por_favor=True) # ¿Me puedes comprar una cerveza? ¡Por favor! Soy pobre :(
|
||||
|
||||
print(decir()) # ¿Puedes comprarme una cerveza?
|
||||
print(decir(decir_por_favor=True)) # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :()
|
||||
```
|
||||
|
||||
## ¿Listo para más?
|
||||
@@ -549,9 +563,10 @@ print hablar(por_favor=True) # ¿Me puedes comprar una cerveza? ¡Por favor! So
|
||||
|
||||
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
|
||||
* [Dive Into Python](http://www.diveintopython.net/)
|
||||
* [The Official Docs](http://docs.python.org/2.6/)
|
||||
* [Ideas for Python Projects](http://pythonpracticeprojects.com)
|
||||
* [The Official Docs](http://docs.python.org/3/)
|
||||
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
|
||||
* [Python Module of the Week](http://pymotw.com/2/)
|
||||
* [Python Module of the Week](http://pymotw.com/3/)
|
||||
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
|
||||
|
||||
### Encuadernados
|
||||
|
||||
@@ -1,25 +1,26 @@
|
||||
---
|
||||
language: python3
|
||||
language: Python 2 (legacy)
|
||||
contributors:
|
||||
- ["Louie Dinh", "http://pythonpracticeprojects.com"]
|
||||
- ["Louie Dinh", "http://ldinh.ca"]
|
||||
translators:
|
||||
- ["Camilo Garrido", "http://twitter.com/hirohope"]
|
||||
- ["Camilo Garrido", "http://www.twitter.com/hirohope"]
|
||||
- ["Fabio Souto", "http://fabiosouto.me"]
|
||||
lang: es-es
|
||||
filename: learnpython3-es.py
|
||||
filename: learnpythonlegacy-es.py
|
||||
---
|
||||
|
||||
Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
|
||||
de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
|
||||
Python fue creado por Guido Van Rossum en el principio de los 90. Ahora es uno
|
||||
de los lenguajes más populares que existen. Me enamoré de Python por su claridad sintáctica.
|
||||
Es básicamente pseudocódigo ejecutable.
|
||||
|
||||
¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
|
||||
|
||||
Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
|
||||
|
||||
```python
|
||||
|
||||
# Comentarios de una línea comienzan con una almohadilla (o signo gato)
|
||||
|
||||
""" Strings multilinea pueden escribirse
|
||||
usando tres "'s, y comunmente son usados
|
||||
""" Strings multilínea pueden escribirse
|
||||
usando tres "'s, y comúnmente son usados
|
||||
como comentarios.
|
||||
"""
|
||||
|
||||
@@ -30,49 +31,69 @@ Es básicamente pseudocódigo ejecutable.
|
||||
# Tienes números
|
||||
3 #=> 3
|
||||
|
||||
# Matemática es lo que esperarías
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
# Evidentemente puedes realizar operaciones matemáticas
|
||||
1 + 1 #=> 2
|
||||
8 - 1 #=> 7
|
||||
10 * 2 #=> 20
|
||||
35 / 5 #=> 7
|
||||
|
||||
# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
|
||||
35 / 5 # => 7.0
|
||||
# Sin embargo también tienes disponible división entera
|
||||
34 // 5 # => 6
|
||||
# La división es un poco complicada. Es división entera y toma la parte entera
|
||||
# de los resultados automáticamente.
|
||||
5 / 2 #=> 2
|
||||
|
||||
# Cuando usas un float, los resultados son floats
|
||||
3 * 2.0 # => 6.0
|
||||
# Para arreglar la división necesitamos aprender sobre 'floats'
|
||||
# (números de coma flotante).
|
||||
2.0 # Esto es un 'float'
|
||||
11.0 / 4.0 #=> 2.75 ahhh...mucho mejor
|
||||
|
||||
# Resultado de la división de enteros truncada para positivos y negativos
|
||||
5 // 3 # => 1
|
||||
5.0 // 3.0 # => 1.0 # funciona con números de coma flotante
|
||||
-5 // 3 # => -2
|
||||
-5.0 // 3.0 # => -2.0
|
||||
|
||||
# El operador módulo devuelve el resto de una división entre enteros
|
||||
7 % 3 # => 1
|
||||
|
||||
# Exponenciación (x elevado a y)
|
||||
2**4 # => 16
|
||||
|
||||
# Refuerza la precedencia con paréntesis
|
||||
(1 + 3) * 2 # => 8
|
||||
(1 + 3) * 2 #=> 8
|
||||
|
||||
# Operadores booleanos
|
||||
# Nota: "and" y "or" son sensibles a mayúsculas
|
||||
True and False #=> False
|
||||
False or True #=> True
|
||||
|
||||
# Valores 'boolean' (booleanos) son primitivos
|
||||
True
|
||||
False
|
||||
# Podemos usar operadores booleanos con números enteros
|
||||
0 and 2 #=> 0
|
||||
-5 or 0 #=> -5
|
||||
0 == False #=> True
|
||||
2 == True #=> False
|
||||
1 == True #=> True
|
||||
|
||||
# Niega con 'not'
|
||||
not True # => False
|
||||
not False # => True
|
||||
|
||||
not True #=> False
|
||||
not False #=> True
|
||||
|
||||
# Igualdad es ==
|
||||
1 == 1 # => True
|
||||
2 == 1 # => False
|
||||
1 == 1 #=> True
|
||||
2 == 1 #=> False
|
||||
|
||||
# Desigualdad es !=
|
||||
1 != 1 # => False
|
||||
2 != 1 # => True
|
||||
1 != 1 #=> False
|
||||
2 != 1 #=> True
|
||||
|
||||
# Más comparaciones
|
||||
1 < 10 # => True
|
||||
1 > 10 # => False
|
||||
2 <= 2 # => True
|
||||
2 >= 2 # => True
|
||||
1 < 10 #=> True
|
||||
1 > 10 #=> False
|
||||
2 <= 2 #=> True
|
||||
2 >= 2 #=> True
|
||||
|
||||
# ¡Las comparaciones pueden ser concatenadas!
|
||||
1 < 2 < 3 # => True
|
||||
2 < 3 < 2 # => False
|
||||
1 < 2 < 3 #=> True
|
||||
2 < 3 < 2 #=> False
|
||||
|
||||
# Strings se crean con " o '
|
||||
"Esto es un string."
|
||||
@@ -84,41 +105,40 @@ not False # => True
|
||||
# Un string puede ser tratado como una lista de caracteres
|
||||
"Esto es un string"[0] #=> 'E'
|
||||
|
||||
# .format puede ser usaro para darle formato a los strings, así:
|
||||
"{} pueden ser {}".format("strings", "interpolados")
|
||||
# % pueden ser usados para formatear strings, como esto:
|
||||
"%s pueden ser %s" % ("strings", "interpolados")
|
||||
|
||||
# Puedes reutilizar los argumentos de formato si estos se repiten.
|
||||
"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
|
||||
# Puedes usar palabras claves si no quieres contar.
|
||||
"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
|
||||
# También puedes interpolar cadenas usando variables en el contexto
|
||||
nombre = 'Bob'
|
||||
comida = 'Lasaña'
|
||||
f'{nombre} quiere comer {comida}' #=> "Bob quiere comer lasaña"
|
||||
# Una forma más reciente de formatear strings es el método 'format'.
|
||||
# Este método es la forma preferida
|
||||
"{0} pueden ser {1}".format("strings", "formateados")
|
||||
# Puedes usar palabras clave si no quieres contar.
|
||||
"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña")
|
||||
|
||||
# None es un objeto
|
||||
None # => None
|
||||
None #=> None
|
||||
|
||||
# No uses el símbolo de igualdad `==` para comparar objetos con None
|
||||
# Usa `is` en su lugar
|
||||
# Usa `is` en lugar de
|
||||
"etc" is None #=> False
|
||||
None is None #=> True
|
||||
|
||||
# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
|
||||
# El operador 'is' prueba la identidad del objeto. Esto no es
|
||||
# muy útil cuando se trata de datos primitivos, pero es
|
||||
# muy útil cuando se trata de objetos.
|
||||
|
||||
# None, 0, y strings/listas vacíos(as) todas se evalúan como False.
|
||||
# Todos los otros valores son True
|
||||
bool(0) # => False
|
||||
bool("") # => False
|
||||
bool([]) #=> False
|
||||
bool({}) #=> False
|
||||
bool(set()) #=> False
|
||||
bool(0) #=> False
|
||||
bool("") #=> False
|
||||
|
||||
|
||||
####################################################
|
||||
## 2. Variables y Colecciones
|
||||
####################################################
|
||||
|
||||
# Python tiene una función para imprimir
|
||||
print("Soy Python. Encantado de conocerte")
|
||||
# Imprimir es muy fácil
|
||||
print "Soy Python. ¡Encantado de conocerte!"
|
||||
|
||||
|
||||
# No hay necesidad de declarar las variables antes de asignarlas.
|
||||
una_variable = 5 # La convención es usar guiones_bajos_con_minúsculas
|
||||
@@ -128,16 +148,19 @@ una_variable #=> 5
|
||||
# Ve Control de Flujo para aprender más sobre el manejo de excepciones.
|
||||
otra_variable # Levanta un error de nombre
|
||||
|
||||
# Listas almacena secuencias
|
||||
# 'if' puede ser usado como una expresión
|
||||
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
|
||||
|
||||
# Las listas almacenan secuencias
|
||||
lista = []
|
||||
# Puedes empezar con una lista prellenada
|
||||
otra_lista = [4, 5, 6]
|
||||
|
||||
# Añadir cosas al final de una lista con 'append'
|
||||
lista.append(1) #lista ahora es [1]
|
||||
lista.append(2) #lista ahora es [1, 2]
|
||||
lista.append(4) #lista ahora es [1, 2, 4]
|
||||
lista.append(3) #lista ahora es [1, 2, 4, 3]
|
||||
lista.append(1) # lista ahora es [1]
|
||||
lista.append(2) # lista ahora es [1, 2]
|
||||
lista.append(4) # lista ahora es [1, 2, 4]
|
||||
lista.append(3) # lista ahora es [1, 2, 4, 3]
|
||||
# Remueve del final de la lista con 'pop'
|
||||
lista.pop() #=> 3 y lista ahora es [1, 2, 4]
|
||||
# Pongámoslo de vuelta
|
||||
@@ -158,12 +181,6 @@ lista[1:3] #=> [2, 4]
|
||||
lista[2:] #=> [4, 3]
|
||||
# Omite el final
|
||||
lista[:3] #=> [1, 2, 4]
|
||||
# Selecciona cada dos elementos
|
||||
lista[::2] # =>[1, 4]
|
||||
# Invierte la lista
|
||||
lista[::-1] # => [3, 4, 2, 1]
|
||||
# Usa cualquier combinación de estos para crear trozos avanzados
|
||||
# lista[inicio:final:pasos]
|
||||
|
||||
# Remueve elementos arbitrarios de una lista con 'del'
|
||||
del lista[2] # lista ahora es [1, 2, 3]
|
||||
@@ -174,14 +191,14 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
|
||||
# Concatenar listas con 'extend'
|
||||
lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
|
||||
|
||||
# Verifica la existencia en una lista con 'in'
|
||||
# Chequea la existencia en una lista con
|
||||
1 in lista #=> True
|
||||
|
||||
# Examina el largo de una lista con 'len'
|
||||
# Examina el tamaño de una lista con 'len'
|
||||
len(lista) #=> 6
|
||||
|
||||
|
||||
# Tuplas son como listas pero son inmutables.
|
||||
# Las tuplas son como las listas, pero son inmutables.
|
||||
tupla = (1, 2, 3)
|
||||
tupla[0] #=> 1
|
||||
tupla[0] = 3 # Levanta un error TypeError
|
||||
@@ -200,7 +217,7 @@ d, e, f = 4, 5, 6
|
||||
e, d = d, e # d ahora es 5 y e ahora es 4
|
||||
|
||||
|
||||
# Diccionarios relacionan llaves y valores
|
||||
# Diccionarios almacenan mapeos
|
||||
dicc_vacio = {}
|
||||
# Aquí está un diccionario prellenado
|
||||
dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
@@ -208,16 +225,16 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
# Busca valores con []
|
||||
dicc_lleno["uno"] #=> 1
|
||||
|
||||
# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego.
|
||||
list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
|
||||
# Obtén todas las llaves como una lista
|
||||
dicc_lleno.keys() #=> ["tres", "dos", "uno"]
|
||||
# Nota - El orden de las llaves del diccionario no está garantizada.
|
||||
# Tus resultados podrían no ser los mismos del ejemplo.
|
||||
|
||||
# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable.
|
||||
list(dicc_lleno.values()) #=> [3, 2, 1]
|
||||
# Obtén todos los valores como una lista
|
||||
dicc_lleno.values() #=> [3, 2, 1]
|
||||
# Nota - Lo mismo que con las llaves, no se garantiza el orden.
|
||||
|
||||
# Verifica la existencia de una llave en el diccionario con 'in'
|
||||
# Chequea la existencia de una llave en el diccionario con 'in'
|
||||
"uno" in dicc_lleno #=> True
|
||||
1 in dicc_lleno #=> False
|
||||
|
||||
@@ -231,18 +248,19 @@ dicc_lleno.get("cuatro") #=> None
|
||||
dicc_lleno.get("uno", 4) #=> 1
|
||||
dicc_lleno.get("cuatro", 4) #=> 4
|
||||
|
||||
# El método 'setdefault' inserta en un diccionario solo si la llave no está presente
|
||||
# El método 'setdefault' es una manera segura de añadir nuevos pares
|
||||
# llave-valor en un diccionario
|
||||
dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5
|
||||
dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5
|
||||
|
||||
|
||||
# Remueve llaves de un diccionario con 'del'
|
||||
del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno
|
||||
|
||||
# Sets (conjuntos) almacenan ... bueno, conjuntos
|
||||
conjunto_vacio = set()
|
||||
# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento.
|
||||
un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4}
|
||||
# Inicializar un conjunto con montón de valores
|
||||
un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4])
|
||||
|
||||
# Desde Python 2.7, {} puede ser usado para declarar un conjunto
|
||||
conjunto_lleno = {1, 2, 2, 3, 4} # => {1 2 3 4}
|
||||
|
||||
# Añade más valores a un conjunto
|
||||
conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5}
|
||||
@@ -257,7 +275,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
|
||||
# Haz diferencia de conjuntos con -
|
||||
{1,2,3,4} - {2,3,5} #=> {1, 4}
|
||||
|
||||
# Verifica la existencia en un conjunto con 'in'
|
||||
# Chequea la existencia en un conjunto con 'in'
|
||||
2 in conjunto_lleno #=> True
|
||||
10 in conjunto_lleno #=> False
|
||||
|
||||
@@ -266,30 +284,32 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
|
||||
## 3. Control de Flujo
|
||||
####################################################
|
||||
|
||||
# Creemos una variable para experimentar
|
||||
some_var = 5
|
||||
# Hagamos sólo una variable
|
||||
una_variable = 5
|
||||
|
||||
# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
|
||||
# Aquí está una declaración de un 'if'. ¡La indentación es importante en Python!
|
||||
# imprime "una_variable es menor que 10"
|
||||
if una_variable > 10:
|
||||
print("una_variable es completamente mas grande que 10.")
|
||||
print "una_variable es completamente mas grande que 10."
|
||||
elif una_variable < 10: # Este condición 'elif' es opcional.
|
||||
print("una_variable es mas chica que 10.")
|
||||
print "una_variable es mas chica que 10."
|
||||
else: # Esto también es opcional.
|
||||
print("una_variable es de hecho 10.")
|
||||
print "una_variable es de hecho 10."
|
||||
|
||||
|
||||
"""
|
||||
For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
|
||||
For itera sobre listas
|
||||
imprime:
|
||||
perro es un mamifero
|
||||
gato es un mamifero
|
||||
raton es un mamifero
|
||||
"""
|
||||
for animal in ["perro", "gato", "raton"]:
|
||||
print("{} es un mamifero".format(animal))
|
||||
# Puedes usar % para interpolar strings formateados
|
||||
print "%s es un mamifero" % animal
|
||||
|
||||
"""
|
||||
`range(número)` retorna un generador de números
|
||||
`range(número)` retorna una lista de números
|
||||
desde cero hasta el número dado
|
||||
imprime:
|
||||
0
|
||||
@@ -298,7 +318,7 @@ imprime:
|
||||
3
|
||||
"""
|
||||
for i in range(4):
|
||||
print(i)
|
||||
print i
|
||||
|
||||
"""
|
||||
While itera hasta que una condición no se cumple.
|
||||
@@ -310,49 +330,18 @@ imprime:
|
||||
"""
|
||||
x = 0
|
||||
while x < 4:
|
||||
print(x)
|
||||
print x
|
||||
x += 1 # versión corta de x = x + 1
|
||||
|
||||
# Maneja excepciones con un bloque try/except
|
||||
|
||||
# Funciona desde Python 2.6 en adelante:
|
||||
try:
|
||||
# Usa raise para levantar un error
|
||||
raise IndexError("Este es un error de indice")
|
||||
except IndexError as e:
|
||||
pass # Pass no hace nada. Usualmente harias alguna recuperacion aqui.
|
||||
|
||||
# Python oferce una abstracción fundamental llamada Iterable.
|
||||
# Un iterable es un objeto que puede ser tratado como una sequencia.
|
||||
# El objeto es retornado por la función 'range' es un iterable.
|
||||
|
||||
dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
|
||||
nuestro_iterable = dicc_lleno.keys()
|
||||
print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
|
||||
|
||||
Podemos recorrerla.
|
||||
for i in nuestro_iterable:
|
||||
print(i) # Imprime uno, dos, tres
|
||||
|
||||
# Aunque no podemos selecionar un elemento por su índice.
|
||||
nuestro_iterable[1] # Genera un TypeError
|
||||
|
||||
# Un iterable es un objeto que sabe como crear un iterador.
|
||||
nuestro_iterator = iter(nuestro_iterable)
|
||||
|
||||
# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos.
|
||||
# Obtenemos el siguiente objeto llamando la función __next__.
|
||||
nuestro_iterator.__next__() #=> "uno"
|
||||
|
||||
# Mantiene el estado mientras llamamos __next__.
|
||||
nuestro_iterator.__next__() #=> "dos"
|
||||
nuestro_iterator.__next__() #=> "tres"
|
||||
|
||||
# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator.
|
||||
nuestro_iterator.__next__() # Genera StopIteration
|
||||
|
||||
# Puedes obtener todos los elementos de un iterador llamando a list() en el.
|
||||
list(dicc_lleno.keys()) #=> Retorna ["uno", "dos", "tres"]
|
||||
|
||||
|
||||
|
||||
####################################################
|
||||
## 4. Funciones
|
||||
@@ -360,7 +349,7 @@ list(dicc_lleno.keys()) #=> Retorna ["uno", "dos", "tres"]
|
||||
|
||||
# Usa 'def' para crear nuevas funciones
|
||||
def add(x, y):
|
||||
print("x es {} y y es {}".format(x, y))
|
||||
print "x es %s y y es %s" % (x, y)
|
||||
return x + y # Retorna valores con una la declaración return
|
||||
|
||||
# Llamando funciones con parámetros
|
||||
@@ -369,7 +358,6 @@ add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11
|
||||
# Otra forma de llamar funciones es con argumentos de palabras claves
|
||||
add(y=6, x=5) # Argumentos de palabra clave pueden ir en cualquier orden.
|
||||
|
||||
|
||||
# Puedes definir funciones que tomen un número variable de argumentos
|
||||
def varargs(*args):
|
||||
return args
|
||||
@@ -385,7 +373,6 @@ def keyword_args(**kwargs):
|
||||
# Llamémosla para ver que sucede
|
||||
keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
|
||||
|
||||
|
||||
# Puedes hacer ambas a la vez si quieres
|
||||
def todos_los_argumentos(*args, **kwargs):
|
||||
print args
|
||||
@@ -423,28 +410,23 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
|
||||
# Podemos usar listas por comprensión para mapeos y filtros agradables
|
||||
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
|
||||
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
|
||||
# también hay diccionarios
|
||||
{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
|
||||
# y conjuntos por comprensión
|
||||
{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
|
||||
|
||||
####################################################
|
||||
## 5. Classes
|
||||
## 5. Clases
|
||||
####################################################
|
||||
|
||||
|
||||
# Heredamos de object para obtener una clase.
|
||||
class Humano(object):
|
||||
|
||||
# Un atributo de clase es compartido por todas las instancias de esta clase
|
||||
especie = "H. sapiens"
|
||||
|
||||
# Constructor basico
|
||||
# Constructor básico, se llama al instanciar la clase.
|
||||
def __init__(self, nombre):
|
||||
# Asigna el argumento al atributo nombre de la instancia
|
||||
self.nombre = nombre
|
||||
|
||||
# Un metodo de instancia. Todos los metodos toman self como primer argumento
|
||||
# Un método de instancia. Todos los metodos toman self como primer argumento
|
||||
def decir(self, msg):
|
||||
return "%s: %s" % (self.nombre, msg)
|
||||
|
||||
@@ -454,7 +436,7 @@ class Humano(object):
|
||||
def get_especie(cls):
|
||||
return cls.especie
|
||||
|
||||
# Un metodo estatico es llamado sin la clase o instancia como referencia
|
||||
# Un metodo estático es llamado sin la clase o instancia como referencia
|
||||
@staticmethod
|
||||
def roncar():
|
||||
return "*roncar*"
|
||||
@@ -485,12 +467,12 @@ Humano.roncar() #=> "*roncar*"
|
||||
|
||||
# Puedes importar módulos
|
||||
import math
|
||||
print(math.sqrt(16)) #=> 4.0
|
||||
print math.sqrt(16) #=> 4.0
|
||||
|
||||
# Puedes obtener funciones específicas desde un módulo
|
||||
from math import ceil, floor
|
||||
print(ceil(3.7)) #=> 4.0
|
||||
print(floor(3.7))#=> 3.0
|
||||
print ceil(3.7) #=> 4.0
|
||||
print floor(3.7) #=> 3.0
|
||||
|
||||
# Puedes importar todas las funciones de un módulo
|
||||
# Precaución: Esto no es recomendable
|
||||
@@ -513,48 +495,52 @@ dir(math)
|
||||
## 7. Avanzado
|
||||
####################################################
|
||||
|
||||
# Los generadores te ayudan a hacer un código perezoso (lazy)
|
||||
# Los generadores permiten evaluación perezosa
|
||||
def duplicar_numeros(iterable):
|
||||
for i in iterable:
|
||||
yield i + i
|
||||
|
||||
# Un generador crea valores sobre la marcha.
|
||||
# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
|
||||
# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
|
||||
# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.
|
||||
_rango = range(1, 900000000)
|
||||
# Duplicará todos los números hasta que un resultado >= se encuentre.
|
||||
for i in duplicar_numeros(_rango):
|
||||
print(i)
|
||||
# Un generador crea valores sobre la marcha
|
||||
# En vez de generar y devolver todos los valores de una vez, crea un valor
|
||||
# en cada iteración. En este ejemplo los valores mayores que 15 no serán
|
||||
# procesados en duplicar_numeros.
|
||||
# Nota: xrange es un generador que hace lo mismo que range.
|
||||
# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
|
||||
# xrange crea un generador, mientras que range crea toda la lista.
|
||||
# Añadimos un guión bajo a los nombres de variable que coinciden con palabras
|
||||
# reservadas de python.
|
||||
xrange_ = xrange(1, 900000000)
|
||||
|
||||
# duplica todos los números hasta que encuentra un resultado >= 30
|
||||
for i in duplicar_numeros(xrange_):
|
||||
print i
|
||||
if i >= 30:
|
||||
break
|
||||
|
||||
|
||||
# Decoradores
|
||||
# en este ejemplo 'pedir' envuelve a 'decir'
|
||||
# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar
|
||||
# en este ejemplo pedir rodea a hablar
|
||||
# Si por_favor es True se cambiará el mensaje.
|
||||
from functools import wraps
|
||||
|
||||
|
||||
def pedir(_decir):
|
||||
@wraps(_decir)
|
||||
def pedir(target_function):
|
||||
@wraps(target_function)
|
||||
def wrapper(*args, **kwargs):
|
||||
mensaje, decir_por_favor = _decir(*args, **kwargs)
|
||||
if decir_por_favor:
|
||||
return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(")
|
||||
return mensaje
|
||||
msg, por_favor = target_function(*args, **kwargs)
|
||||
if por_favor:
|
||||
return "{} {}".format(msg, "¡Por favor! Soy pobre :(")
|
||||
return msg
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
@pedir
|
||||
def say(decir_por_favor=False):
|
||||
mensaje = "¿Puedes comprarme una cerveza?"
|
||||
return mensaje, decir_por_favor
|
||||
def hablar(por_favor=False):
|
||||
msg = "¿Me puedes comprar una cerveza?"
|
||||
return msg, por_favor
|
||||
|
||||
|
||||
print(decir()) # ¿Puedes comprarme una cerveza?
|
||||
print(decir(decir_por_favor=True)) # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :()
|
||||
print hablar() # ¿Me puedes comprar una cerveza?
|
||||
print hablar(por_favor=True) # ¿Me puedes comprar una cerveza? ¡Por favor! Soy pobre :(
|
||||
```
|
||||
|
||||
## ¿Listo para más?
|
||||
@@ -563,10 +549,9 @@ print(decir(decir_por_favor=True)) # ¿Puedes comprarme una cerveza? ¡Por favo
|
||||
|
||||
* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
|
||||
* [Dive Into Python](http://www.diveintopython.net/)
|
||||
* [Ideas for Python Projects](http://pythonpracticeprojects.com)
|
||||
* [The Official Docs](http://docs.python.org/3/)
|
||||
* [The Official Docs](http://docs.python.org/2.6/)
|
||||
* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
|
||||
* [Python Module of the Week](http://pymotw.com/3/)
|
||||
* [Python Module of the Week](http://pymotw.com/2/)
|
||||
* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
|
||||
|
||||
### Encuadernados
|
||||
Reference in New Issue
Block a user