Python 3

# Métodos

title() --- Mayúsculas iniciales en cada palabra de la cadena

upper() --- Todas las letras de la cadena en minúsculas
lower() --- Todas las letras de la cadena en mayúsculas
rstrip() --- Elimina espacios en blanco a la derecha
lstrip() --- Elimina espacios en blanco a la izquierda
strip() --- Elimina espacios en blanco a ambos lados
sort() --- Ordena una lista

# Funciones
print() --- Imprime texto en pantalla
str() --- Representa el argumento non-string como un string

# Variables

nombre_de_la_variable = valor

Ejemplos:
mensaje = "Hola mundo!"
entero = 3
decimal = 3.7

# Concatenación de cadenas de texto

nombre = "ada"
apellido = "lovelace"
nombre_completo = nombre + " " + apellido

# Espacios en blanco
\t --- Añade un tab
\n --- Añade una nueva línea

# Números

# Suma (+), resta(-), multiplicación(*) y división(/). Exponentes(**)

# Una línea que inicia con # es una línea comentada (el intérprete ignora)

# Lista: Colección de objetos en un orden particular

bicycles = ['trek','cannondale','redline', 'specialized']

# Acceder a un elemento de una lista

bicycles[0] # Imprime el primer elemento de la lista

# Acceder al último elemento de la lista

bicycles[-1]

# Modificar elementos de una lista

pares = ['2','3','6','8','10']
pares[1] = 4

# Añadir elemento a la lista (al final)

pares.append(12)

# Insertar elementos en una posición particular

pares.insert(0, 0) # (posición, valor)

# Eliminar un elemento de la lista si se conoce su índice

del pares[0]

# Eliminar el último elemento de una lista pero mantenerlo en memoria

popped_par = pares.pop()

# Usar pop() para índices distintos al último

popped_par_primero = pares.pop(0)

# Remover elementos por valor

motos = ['akt', 'honda','susuki']

motos.remove('akt')

# Ordenando una lista permanentemente con el método sort()

# Usar sort(reverse=True) para ordenarlos de forma inversa
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()

# Se puede presentar la lista ordenada sin alterar la original con la función

sorted()

cars = ['bmw', 'audi', 'toyota', 'subaru']

print(sorted(cars))
print(sorted(cars,reverse=True))

# Para invertir el orden de la lista:

cars.reverse()

# Para obtener la longitud (número de elementos de una lista):

len(cars)

# Búcle en una lista

for valor in lista:

print(valor)

# Búcle en un rango

for valor in range(1,6);

print(valor)

# Generar una lista con la función range()

numeros = list(range(1,11)) # Números del 1 al 10

# Saltar números en un rango

pares = list(range(2,11,2))

# Estadísticas simples con una lista de números

digitos = [1,2,3,4,5,6,7,8,9,0]
min(digitos) # Número menor de la lista
max(digitos) # Número mayor de la lista
sum(digitos) # Suma de todos los números de la lista

# Comprensión de listas

squares = [value**2 for value in range(1,11)]

# Porciones de una lista

digitos[2:5] # Elementos desde la posición 2, hasta la posición 5

digitos[:6] # Elementos desde la posición inicial hasta la 6
digitos[4:] # Elementos desde la posición 4 hasta la última
digitos[-3:] # Los 3 últimos elementos

# Copiar una lista

digitos_copia = digitos[:]

# Tuplas

# Una tupla es una lista inmutable, se define como una lista pero en lugar de
usar corchetes [] se usan paréntesis (). Se accede a un elemento de la tupla, de
igual manera a como se accedería a un elemento de una lista.

# Si bien una lista es inmutable (no se pueden cambiar, eliminar, agregar valores),
es posible redefinir la tupla con nuevos valores.

# Condicionales

# Operador | Símbolo
-----------------------------------------------
# Igualdad | ==
# Desigualdad | !=
# Menor | <
# Menor o igual | <=
# Mayor | >
# Mayor o igual | >=

# Comprobar múltiples condiciones usando 'and'

(condicion1 == 1) and (condicion2 == 2) # Los paréntesis no son obligatorios

# Comprobar múltiples condiciones usando 'or'

(condicion1 == 1) or (condicion2 == 2) # Los paréntesis no son necesarios

# Comprobar si un elemento existe en una lista usando la palabra 'in'

if 'word' in list:
...

# Comprobar si un elemento no existe en una lista 'not in'

if 'word' not in list:
...

# Expresiones booleanas (True, False)

# Sentencia if simple

if conditional_test:
do something

# Sentencia if-else

if conditional_test:
do something
else:
do something

# Sentencia if-elif-else. (Se pueden agregar tantos elif como sea necesario

if conditional_test:
do something
elif conditional_test:
do something
else:
do something

# No es necesario tener un else en la sentencia if-elif

# Comprobar que una lista no esté vacía

lista = []
if lista:
do something

# Diccionarios

# Declarar un diccionario
diccionario = {'color': 'green', 'puntos': 5}

# Acceder a valores del diccionario

diccionario['color']

# Añadir nuevos pares clave/valor a un diccionario

diccionario['x_position'] = 0

# Para crear un diccionario vacío

diccionario = {}

# Modificar valores de un diccionario

diccionario['color'] = 'yellow'

# Remover pares clave/valor del diccionario

del diccionario['points']

# Búcle a través de un diccionario

for key, value in diccionario.items():

do something

# Búcle a través de únicamente las claves de un diccionario

for name in languages.keys():

do something

# ...o de forma equivalente

for name in languages:

do something

# Se puede ordenar los valores de un búcle a un diccionario

for name in sorted(languages.keys()):

do something

# Búcle a través de todos los valores de un diccionario

for name in languages.values():

do something

# El anterior búcle mostrará resultados sin importar si estos se repiten.

# Se puede evitar este comportamiento usando la función set()

for name in set(languages.values()):

do something

# Anidar:

# Los elementos de una lista pueden ser diccionarios

# Los valores en un par clave/valor de un diccionario pueden ser listas
# Los elementos de un diccionario pueden ser otros diccionarios

# Entrada de usuario

# La función input() pausa el programa y espera a que el usuario introduzca algún

texto. Una vez Python recibe la información la almacena en una variable

user_input = input("Mensaje para el usuario: ")

# Usar int() para aceptar valores numéricos

numero = input("Escriba un número: ")

numero = int(numero)

# El operador módulo % divide un número entre otro y devuelve el residuo

# Búcle while: Ejecuta un código mientras cierta condición se cumpla

while number < 5:

do something
number += 1
# Para salir de un búcle while inmediatamente sin correr el código restante, sin
importar los resultados de algún test condicional, se usa la sentencia 'break'.

# La sentencia 'continue' ignora el resto del loop y retorna al inicio de este.

# El búcle 'while' es efectivo para modificar listas y diccionarios. No tanto el

búcle 'for'.

# Funciones

# Definir una función

def nombre_funcion():
"""Esto es un docstring"""
do something

# Llamar a una función

nombre_funcion()

# Pasar información a una función

def saludar(nombre): # nombre ---> parámetro

""" Saludar """
print("Hola, " + nombre.title())

saludar('parcerito') # parcerito ---> argumento

# Argumento posicional: Cuando se pasan argumentos a una función de este modo, el

orden importa.

def mascota(nombre, raza):

"""Mascota"""
do something

mascota('Rocke', 'Cruce')

# Argumento par clave/valor (no importa el orden)

def mascota(nombre, raza):

"""Mascota"""
do something

mascota(raza = 'cruce', nombre = 'Rocke')

# Valores por defecto: Al declarar una función se puede especificar un valor por
defecto para un parámetro. Si al invocar la función se envía un argumento,
Python hace uso de ese argumento, sino, Python usará el valor por defecto.

def mascota(nombre, raza = 'indefinida'):

""" """
do something

# Retornar valores: Una función no tiene que mostrar su salida directamente. En

lugar de ello, puede procesar algunos datos y retornar uno o más valores.

def funcion(par1,par2):
"""docstring"""
var = par1 + par2
 return var

# Un argumento puede ser opcional: Declaramos el parámetro que queremos ser

opcional con un valor vacío por defecto.

def funcion(par1, par2, par3 = '')

# Una función puede retornar valores más complejos, como un diccionario por
ejemplo.

# A una función se le pueden pasar valores complejos, como una lista.

# Pasando una cantidad arbitraria de argumentos

def funcion(*argumentos):
"""docstring"""
do something

# Se pueden mezclar argumentos posicionales y argumentos arbitrarios

def funcion(arg1, *args):

"""docstring"""
do something

# Usando argumentos clave arbitrarios

def funcion(par1,par2,**pars):
"""docstring"""
for value, key in pars.items:
do something

funcion('arg1', 'arg2', key1: 'val1', key2 = 'val2')

# Almacenar funciones en módulos

# Un módulo es un archivo externo que contiene código que se puede importar al

código actual.

# Importar un módulo completamente

import nombre_modulo # el módulo es un archivo .py

# Para usar una función que se encuentra dentro del módulo

nombre_modulo.nombre_funcion()

# Importar funciones específicas

from nombre_modulo import nombre_funcion

# Se pueden importar varias funciones del mismo módulo

from nombre_modulo import funcion1, funcion2, funcion3

# Usar 'as' para dar un alias a la función

from modulo import funcion as alias_deseado

# Usar 'as' para dar un alias a un módulo

import modulo as alias_deseado

# Importar todas las funciones de un módulo. De esta manera se pueden usar las
funciones sin tener que usar el nombre del módulo, esto puede generar problemas si
hay funciones en el módulo que se llamen igual a funciones dentro del código
actual.

from modulo import *

# Clases

# En la programación orientada a objetos uno programa clases que representan

situaciones y cosas del mundo real y crea objetos basados en esas clases. Cuando
escribes una clase defines el comportamiento general que una categoría completa de
objetos puede tener. Cuando creas un objeto a partir de una clase, dicho objeto es
automáticamente equipado con el comportamiento general, puedes entonces agregarle a
ese objeto las características únicas que desees. Crear un objeto a partir de una
clase se llama 'instanciamiento', y trabajas con 'instancias' de esa clase.

# Crear una clase

class Dog(): # Se usa la primera letra del nombre de la clase en mayúscula por
convención
"""Docstring"""

def __init__(self, name, age):

# Una función que es parte de una clase es un método
# El parámetro self es obligatorio cuando se construye el método y debe ir
primero
#
"""Docstring"""
self.name = name
self.age = age

def sit(self):
"""Simulate sit"""
print(self.name.title() + " está sentado")

def roll_over(self):
"""Roll over"""
print(self.name.title() + " roll over")

# Crear una instancia de una clase

my_dog = Dog('Will', 6)

# Acceder a atributos

my_dog.name # Accede al atributo 'name' propia de la instancia

# Llamar métodos

my_dog.sit() # Accede al método 'sit()' propia de la instancia

# Se pueden crear tantas instancias como se desee

# Herencia
No siempre tienes que empezar desde cero cuando vas a escribir una clase. Si la
clase que estás escribiendo es una versión especializada de otra clase, puedes usar
la 'herencia'. Cuando una clase hereda de otra, automáticamente toma todos los
atributos y métodos de la clase madre.

class Car(): # Súper clase

"""docstring"""
def __init__(self, make, model, year):
self.make = make
...

class ElectricCar(Car): # Clase hija (pasamos como argumento el nombre de la súper

clase)
"""docstring"""
def __init__(self, make, model, year):
"""dosctring"""
super().__init__(make, model, year) # Darle atributos a la instancia de
ElectricCar de la función madre

# Importar clases

# Importar una sola clase

from car import Car

# Importar múltiples clases

from car import Car, ElectricCar

# Importar el módulo enter

import car

# Importar todas las clases de un módulo

from module name import *

# La librería estándar de Python: Conjunto de módulos incluídos con cada

instalación de Python.

# Los diccionarios permiten conectar piezas de información, pero no tienen un

rastreo
del orden en el cual se agregaron pares clave/valor. Si se desea mantener el rastro
de
este orden se puede usar la clase OrderedDict del módulo collections. Las
instancias de esta clase se comportan igual que los diccionarios.

from collections import OrderedDict

# Archivos y excepciones

# Leer un archivo completo

with open('pi_digits.txt') as file_object:

contents = file_object.read()
print(contents)

# Para realizar cualquier trabajo con un archivo, primero hay que abrirlo.
# Leer un archivo línea por línea

filename = 'pi_digits.txt'

with open(filename) as file_object:

for line in file_object:
print(line)

# Hacer una lista de líneas de un archivo: Cuando abres un archivo con with/open,
ese archivo solo está disponible en ese bloque de código. Si desea trabajar con el
contenido de dicho archivo puede copiarlo a una lista con el método readlines(),
que toma cada una de las líneas del archivo y las almacena en una lista.

with open(filename) as file_object:

lines = file_object.readlines()

# Escribir a un archivo

# Escribir a archivo vacío

filename = 'programming.txt'

with open(filename, 'w') as file_object:

file_object.write("i love cc")

# modo lectura: r, modo escritura: w, modo adjuntar: a, leer y escribir: r+

# Excepciones

# Usando el bloque try-except

try:
print(5/0)
except ZeroDivisionError:
print('No está definida la divisón por cero.')

# Se puede evitar informar un error al usuario:

...
except error:
pass
---

# Almacenar data

# JSON (javascript object notation)

# La función json.dump() toma dos argumentos: una porción de datos para almacenar,
y un archivo objeto que puede usar para almacenar la data.

import json

numbers = [2,3,5,7,11,13]

filename = 'numbers.json'
with open(filename, 'w') as f_obj:
json.dump(numbers, f_obj)

# Podemos cargar un archivo JSON de esta forma:

import json

filename = 'numbers.json'
with open(filename) as f_obj:
numbers = json.load(f_obj)

print(numbers)