Curso intensivo de Python para Programadores que no usan Python: Como iniciar rápidamente

print("Hola Mundo")

# Esto es un comentario en Python
msg_desde_computador = "Hola" # String
otro_msg ='Hola en una sola comilla' # Esto además es un string

print(msg_desde_computador + " Mundo..!")

# Type retornara el tipo de data.
print(type(msg_desde_computador)) # <type 'str'>. Nosotros miraremos la explicación más tarde.

2
2 * 3
2 ** 7
(2 + 3) * 4

contador = 5

print("Yo necesito" + contador + "chocolates") # Esta línea levantará un error. Como contador es un entero, tú tienes que castear esto.

print("Yo necesito" + str(contador) + "chocolates") # Esto trabajara

True # La primera letra esta en mayúscula

False

bool("Algún valor") # Retorna True

bool("") # Retorna False

bool(1) # Retorna True

numeros = ["uno", "dos", "tres"]

numeros[0] # uno

numeros[-1] # tres. Esto es impresionante. Si, nosotros pasamos valores negativos Python iniciara desde el final.

numeros[-2] # dos

len(numeros) # 3. Esto solo retorna la longitud

numeros.append("cuatro") # Añadirá el elemento a la última posición. ["uno", "dos", "tres", "cuatro"]

numeros.insert(1, "nuevo_uno") # Insert, inserta el valor en la posición adecuada. ["uno", "nuevo_uno", "dos", "tres", "cuatro"]
-------

# Borrar un valor es poco común
del numeros[1] # Nosotros borraremos la posición apropiad la cual es uno "nuevo_uno". ["uno", "dos", "tres", "cuatro"]

# Pop le ayudará a eliminar el último elemento de una lista
item_eliminado = numeros.pop()

print(item_eliminado) # Cuatro
print(numeros) # ["uno", "dos", "tres"]

# Remover elementos por el valor
numeros.remove("dos") # ["uno", "tres"]. Esto removera la primera ocurrencia de la lista

# Ordenando
alfa = ["z", "c", "a"]
alfa.sort()
print(alfa) # ["a", "c", "z"] Ordenamiento es permanente. Ahora `alfa` esta ordenado permanente

alfa.sort(reverse=True)
print(alfa) #["z", "c" , "a"] Ordenamiento de reverso.

alfa = ["z", "c", "a"]
print(sorted(alfa)) # ["a", "c", "z"] Esto retornara una lista ordenada. Esto no guardara el ordenmiento en la misma variable.

print(alfa) # ["z", "c", "a"] Como tu puedes ver, esto no esta ordenado

# Reversando una lista
nums = [10, 1, 5]
nums.reverse()
print(nums) # [5, 1, 10] Esto solo reversa una lista. Significa que lee desde el último. Esto no lo esta ordenando. Solo cambia el orden cronológico.

# Cortando elementos
alfa = ['a', 'b', 'c', 'd', 'e']
alfa[1:3] # ['b', 'c']. El primer elemento es el indice de partida: 1. Python para antes del segundo índice en este caso 3.
alfa[2:5] # ['c', 'd', 'e']

alfa[:4] # [ 'a', 'b', 'c', 'd'] En este caso el primer índice no existe, así que por default inicia desde el índice 0.

alfa[:3] # ['a', 'b', 'c']

alfa[3:] # ['d', 'e'] En este caso el último índice no esta presente. Asi que viaja hasta el final de la lista

alfa[:] # ['a', 'b', 'c', 'd', 'e'] No hay un índice de inicio o final. Así que ya sabes lo que pasa. Esto te ayudara a copiar todo la lista. Creo que no tengo que explicar que si copias la lista, cualquier cambio en la lista original no afectará a la lista copiada.

otro_alfa = alfa # Esto no es copiar una lista. Cualquier cambio en el otro_alfa afectará a otro alfa también.

nums = (1, 2, 3)

print(nums) # (1, 2, 3)

print(nums[0]) # 1

print(len(nums)) # 3

tupla_vacia = () # Tupla vacia. Longitud es cero.

num = (1, ) # Nota fíjese en la coma. Al definir un solo elemento en la tupla, considera agregar una coma final.

num = (1)
print(type(num)) # <type 'int'> No retorna una tupla. Porque no hay ninguna coma final.

# Crear una tupla desde una existente tupla
nums = (1, 2, 3)
char = ('a', )
nueva_tupla = nums + char
print(nueva_tupla) # (1, 2, 3, 'a')

alfa = {'a', 'b', 'c', 'a'}

print(alfa) # set(['a', 'c', 'b']) Como tú puedes ver, los duplicados se eliminan en los conjuntos. Además no se ordena el salida.

# Acceso a elementos en el conjunto
# Tú no puedes acceder por índice porque los conjuntos no están ordenados. Tú puedes acceder por bucle. No te preocupes por el bucle de for, lo veremos con más detalle en la siguiente sección.
for item in alfa:
  print(item)

# add puede ser usado para insertar sólo un elemento. Si deseas varios elementos, entonces la update será útil
alfa.add('s')


alfa.update(['a', 'x', 'z']) # set(['a', 'c', 'b', 'x', 'z']) Recuerda los duplicados son removidos

# Longitud del alfa
len(alfa) # 5

# Remover el elemento desde el conjunto
alfa.remove('a')
alfa.discard('a') # Es más seguro usar discard que remove. Discard nunca arrojará un error, incluso si el elemento no está presente en el conjunto, pero la eliminación lo hará. 

usuario = {'id': 1, 'nombre': 'John wick', 'email': 'john@gmail.com'}

usuario['id'] # 1
usuario['nombre'] # John wick

# Longitud del diccionario
len(usuario) # 3

# Añadir un nuevo par clave-valor
usuario['edad'] = 35

# Obtener todas las claves
claves = usuario.keys() # ['id', 'nombre', 'email', 'edad']. Esto retorna una lista

# Obtener todos los valores
valores = usuario.values() # [1, 'John Wick', 'john@gmail.com']

# Borrar clave
del usuario['edad']

# Ejemplo de dict anidado
user = {
  'id': 1,
  'nombre': 'John Wick',
  'carros': ['audi', 'bmw', 'tesla'],
  'proyectos': [
    {
      'id': 10,
      'nombre': 'Proyecto 1'
    },
    {
      'id': 11,
      'nombre': 'Proyecto 2'
    }
  ]
}

# Nosotros miraremos, cómo hacer un bucle a través del diccionario en la sección de bucle.

a = 5
b = 10

# Mira la indentación, ya que es muy importante en Python. Python arrojará error, si la indentación no es apropiada
if a == 5:
  print('Impresionante')

# "Y" es equivalente a && 
if a == 5 and b == 10:
  print('A es 5 y b es diez')

# Declaración if-else. Esto es lo mismo que la mayoría de lenguajes.
if a == 5:
  print('A es cinco')
elif a == 6:
  print('A es seis')
elif a == 7:
  print('A es siete')
else:
  print('A es algún número')

# "O" es equivalente ||
if a < 6 or a == 10:
  print('A debería ser menor que 6 o debería ser igual a diez')

# "No" es equivalente !
if not a == 10:
  print('A no es igual a 10')

# Esto es una abreviación de la declaración if.
if a == 5: print('A es cinco')

# Abreviación para la declaración if-else
print('A es cinco') if a == 5 else print('A no es cinco')

# El siguiente while imprime hasta 5. Recuerda tener presente la indentación. 
i = 0
while i <= 5:
  print(i)
  i += 1

# Uso de break or continue en el búcle while
i = 0
while i <= 5:
  print(i)
  i += 1
  if i == 2:
    break # Tú puedes usar continue aquí

# Aquí viene la parte interesante. búcle while tiene un "else"; "else" se ejecuta una vez cuando el búcle es completado.
i = 10
while i <= 15:
  print(i)
  i += 1
else:
  print('Completado')

# Salida
10
11
12
13
14
15
Completado

# Pero si estás usando break en el búcle, entonces Python saldrá del búcle entero y no ejecutará el "else".
i = 10
while i <= 15:
  print(i)
  i += 1
  if i == 13:
    break
else:
  print('Completado')

# Salida
10
11
12

# Búcle for parecido a for(i=0; i<5; i++) no son usuales en Python. En cambio, Python insiste en iterar sobre los items. 

lista = ['a', 'b', 'c', 'd', 'e']
for item in lista: # Imprime un elemento iterando la lista
  print(item)

palabra = "python"
for caracter in palabra: # Imprime un caracter de la variable palabra
  print(caracter)

# Tú puedes usar el break, continue y else, en el búcle for.

# Al hablar de los bucles, me di cuenta de que la mayoría de los recursos mencionan la función range(). (Trataremos el tema sobre las funciones más adelante de este artículo).

# range() función genera a secuencia de numeros.

# range(inicio, fin, pasos)
# inicio - Opcional, el número de donde inicia. Por defecto es 0. Este número esta incluido en la secuencia
# fin - Obligatorio, el número donde termina. Este número excluye la secuencia.
# pasos - Opcional, Incremento del número de la iteración de inicio hasta el final. Por defecto es 1.

range(3) # Este código genera la secuencia desde 0 a 2.
range(1, 4) # Este código genera la secuencia desde 1 a 3.
range(1, 8, 2) # Este código genera la secuencia con 1, 3, 5, 7

for item in range(3): # Imprime de 0 a 2. 
  print(item)

# En el siguiente ejemplo, tú puedes ver que yo he utilizado el rango para iterar una lista a través de un índice. 
for indice in range(0, len(lista)):
  print(lista[indice])

dict = {'nombre': 'John wick'}

# Tú puedes iterar a través de un diccionario. items() retorna tanto las llaves como los valores. También puedes usar keys() y values() si es necesario.
for llave, valor in dict.items():
  print(llave + " es " + valor)

# Tú puedes utilizar una función incorporada llamada enumerate(). enumurate() retorna una tupla con índice. Se usa principalmente para añadir un contador a los objetos iterables en Python.
for indice, valor in enumerate(arreglo):
  print(valor + " est ubicado en: " + str(indice))

def imprime_hola_mundo():
  print('Hola mundo desde Python')

>>> imprime_hola_mundo()
>>> 'Hola mundo desde Python'

# Declaración return
def imprime_algunacosa(algunacosa):
  return algunacosa + ' desde Python'

>>> print(imprime_algunacosa('Hola Mundo'))
>>> 'Hola Mundo desde Python'

# Si pasas un número equivocado de argumentos como dos o tres argumentos a esta función, entonces Python arrojará un error.
print(imprime_algunacosa())

# Paramétro por defecto. Yo creo que es muy común en la mayoría de lenguajes.
def imprime_algunacosa(something = 'Hola mundo'):
  print(algunacosa + ' desde Python')

# Tú puedes usar cualquier argumento. De esta manera, tú no tienes que usar los argumentos en el mismo orden explicito de los paramétros de la función.
def info_pelicula(titulo, nombre_director, calificación):
  print(titulo + " - " + nombre_director + " - " + calificación)

info_pelicula(calificacion='9/10', nombre_director='David Fincher', titulo='Fight Club')


# Arbitrario número de argumentos
# Algunas veces, tú no conoces el número de argumentos pasados. En ese caso, tú tienes que pedir a Python que acepte todos los posibles argumentso

def lenguajes(*nombre):
  print(nombre) # ('Python', 'Ruby', 'JavaScript', 'Go'). Esta es una tupla.
  return 'Mencionaste ' + str(len(nombre)) + ' lenguaje'

print(languajes('Python', 'Ruby', 'JavaScript', 'Go')) # Mencionaste 4 languages

def languajes(fav_languaje, *nombre):
  print(nombre) # ('Ruby', 'JavaScript', 'Go')
  return 'Mi lenguaje favorito es ' + fav_languaje + '. Estoy planeando aprender ' + str(len(names)) + ' lenguajes más.'

print(languages('Python', 'Ruby', 'JavaScript', 'Go')) # Mi lenguaje favorito es Python. Estoy planeando aprender 3 languajes más.


# Arbitrarios argumentos de llave-valor
# Este tipo de argumentos son útiles cuando no se sabe qué tipo de parámetros se pasan. En el caso anterior, es útil cuando no se sabe cuántos parámetros son obtenidos, pero en este caso, no se sabe qué tipo de información se pasará.

def info_usuario(**info):
  print(info) # {'id': 1, 'nombre': 'Srebalaji', 'fav_languaje': ['Python', 'Ruby']} Esto es un diccionario

# Arbitrarios llave-valor o kwargs en Python, siempre son esperados mencionarlos explicitamente
info_usuario(id=1, nombre='Srebalaji', fav_languaje=['Python', 'Ruby'])

# El código de abajo conduce a un error. No se estan pasando kwargs como argumentos
info_usuario(1, 'Srebalaji')

def info_usuario(id, nombre, **info):
  print(info) # {'fav_languaje': ['Python', 'Ruby'], 'twitter': '@srebalaji'}

info_usuario(1, 'Srebalaji', fav_languaje=['Python', 'Ruby'], twitter='@srebalaji')

# Python es de propósito general y orientado a objetos

# Es una convención que el nombre de la clase comience con mayúsculas. Pero Python no arroja ningún error si no lo haces.
class Animal():
  # Esto es un constructor.
  # Como tú puedes ver en todos los métodos de la clase he pasado el "self" como primer parámetro. Siempre se espera que el primer parámetro sea la instancia actual de la clase y es obligatorio pasar la instancia en el primer parámetro de un método de clase. Tú puedes nombrar esa variable como quieras.
  def __init__(self, nombre): 
    self.nombre = nombre

  def comer(self):
    print(self.nombre +' come')

  def dormir(self):
    print(self.nombre +' duerme')

# Inicializar clase
>>> perro = Animal('harry')
>>> perro.comer()

>>> print(dog.nombre) #  Mira el atributo de "nombre" también está disponible en público.

# Incluso puede ser modificado.
perro.nombre = 'Rosie'
print(perro.nombre) # 'Rosie'

# Técnicamente no hay forma de crear atributos privados en Python. Pero hay algunas técnicas que los programadores de Python están usando. Trataré de listar algunas.

# Atributos protected
# Estos atributos sólo pueden ser accedidos dentro de la clase y también por la subclase.

class Persona():
  # Tú puedes ver que he usado un nombre diferente para el primer parámetro.
  def __init__(mi_instancia, nombre):
    # 'nombre' Atributo es protegido.
    mi_instancia._nombre = nombre

  def lee(mi_instancia):
    print(mi_instancia._nombre + ' lee')

  def escribe(mi_objeto):
    print(mi_objeto._name + ' escribe')


>>> persona1 = Persona('Ram')
>>> persona1.lee()

# Pero la peor parte es que la instancia de la clase todavía puede acceder y cambiarla :P

print(persona1._nombre) # 'Ram'

persona1._nombre = 'Yo puedo cambiar esto todavia'
print(persona1._nombre) # Yo puedo cambiar esto todavia

# Protected puede ser útil a veces. Veamos cómo funcionan los atributos privados. Eso puede ser un salvavidas a veces.

class Persona():
  def __init__(self, nombre):
    # 'nombre' atributo es privado.
    self.__nombre = nombre

  def lee(self):
    print(self.__nombre + ' lee')

  def escribe(self):
    print(self.__nombre + ' escribe')
  
  # Este es un método privado. No se puede acceder a esto fuera de la clase.
  def __algun_metodo_ayuda():
      print('Algún método de ayuda')


persona1 = Persona('Ram')
persona1.lee() # Ram lee

print(persona1.nombre) # Arrojará un error. 
>>> 'Persona' object has no attribute 'nombre'

print(persona1.__nombre) # Arrojará un error. 'Person' object has no attribute '__name'

# Private sólo puede ser accedido dentro de la clase. Así que es seguro. Pero aún así hay una trampa :P

print(persona1._Persona__nombre) # Ram.

# Incluso puedes cambiar el valor
persona1._Persona__nombre = 'Hari'

print(persona1._Persona__nombre) # Hari.

# Pero todos los desarrolladores saben que acceder y modificar los atributos privados es una mala práctica. Python no tiene realmente una clara restricción para evitarlo. Así que tienes que confiar en tus compañeros en esto.

# Herencia

class Animal():
  def __init__(self, nombre):
    self.nombre = nombre

  def come(self):
    print('Animal come')

  def duerme(self):
    print('Animal duerme')

# Perro es una sub clase de Animal
class Perro(Animal):
  def __init__(self, nombre):
    self.nombre = nombre

  def come(self):
    print('Perro come')


perro1 = Perro('harry')
perro1.come() # Perro come
perro1.duerme() # Animal duerme

# Los módulos nos ayudan a organizar el código en Python. Puedes dividir el código en diferentes archivos y carpetas y puedes acceder a ellos cuando quieras.

# Considera el siguiente archivo. Tiene dos funciones.
# calculos.py

def sumar(a, b):
  return a + b

def restr(a, b):
  return a - b

# Considera otro archivo que consideramos como un archivo principal.
# main.py
import calculos

calculos.sumar(5, 10) # 15
calculos.restar(10, 3) # 7

# En el ejemplo anterior, ha importado el archivo y ha accedido a las funciones del mismo.

# Hay otras formas de importación.

# Tú puedes cambiar el nombre del método si quieres
import calculos as calc
calc.add(5, 10) # 15

# Tú puedes importar las funciones específicas que necesites.
# Tú puedes acceder a la función directamente sin necesidad de mencionar el módulo
from calculations import sumar
sumar(5, 10) # 15

# Tú también puedes importar múltiples funciones
from calculos import sumar, multiplicar, dividir

# Tú puedes importar todas las funciones
from calculos import *
sumar(10, 15)
multiplicar(4, 5)
dividir(10, 3)

# Esto funcionará para las clases y las variables también.

# Según la documentación oficial de Python, cualquier objeto puede ser probado como verdadero o falso.

# Los siguientes valores son verdaderos
True
2 # Cualquier valor número mayor que 0
[1] # list no vacio
{'a': 1} # dict no vacio
'a' # String no vacío
{'a'} # Set no vacío

# Los siguientes valores son falsos
False
None
0 
0.0
[] # list vacia
{} # dict vacio
() # tuple vacia
"" # string vacio
range(0) # set vacio

# Se puede evaluar cualquier objeto a bool usando
bool(cualquier_objeto) # retorna True o False

# El código puede levantar excepciones, pero pueden ser atrapadas con la declaración 'try'. 'except' Manejará la excepción.
try:
  algun_error_levantado
except:
  print('Excepción manejada')

# Cada excepción es heredada de la clase 'Exception'. 

# En el siguiente ejemplo, tú puedes mirar el 'NameError' es la excepción derivada de la clase principal  'Exception'
try:
  algun_error_levantado
except Exception as e:
  print('Excepción levantada')
  print(e.__class__) # <class 'NameError'>

# La declaración "else" se ejecutará si el código en el bloque "try" no levanta ninguna excepción. Esto será útil en muchas situaciones.

try:
  algun_error_levantado
except:
  print('Excepción levantada')
else:
  print('Error no levantado') # Este código se ejecutará si no se produce ningún error en el bloque de 'try'.

# Bloque final
# El bloque "finally" se ejecutará sin importar si la excepción se levanta o no.
try:
  algun_error_levantado
except Exception as e:
  print('Excepción levantada')
else:
  print('Esto se ejecutará si no se produce ningún error en el intento')
finally:
  print('Este código se ejecutará tanto si el código tiene un error como si no.')


# Crear tus propias excepciones. También puedes crear tú propia clase de excepción heredada de la clase de Exception.
try:
  raise ZeroDivisionError # Excepción incorporada de Python
except Exception as e:
  print(e.__class__) # <class 'ZeroDivisionError'>

# Captura una excepción específica
try:
  raise ZeroDivisionError # Excepción incorporada de Python
except TypeError as e:
  print('Solamente Type Error excepción es capturada')
except ZeroDivisionError as e:
  print('Solamente Zero Division excepción es capturada')
except Exception as e:
  print('Otras excepciones')