Sección 1.

3: Sangría de bloque

Python usa sangría para definir construcciones de control y bucle. Esto contribuye a la legibilidad
de Python; sin embargo, requiere que el programador preste mucha atención al uso de espacios en
blanco. Por lo tanto, una mala calibración del editor podría provocar que el código se comporte de
forma inesperada.

Python usa el símbolo de dos puntos (:) y la sangría para mostrar dónde comienzan y terminan los
bloques de código (si viene de otro idioma, no confunda esto con estar relacionado de alguna
manera con el operador ternario). Es decir, los bloques en Python, como funciones, bucles,

cláusulas if y otras construcciones, no tienen identificadores finales. Todos los bloques comienzan
con dos puntos y luego contienen las líneas sangradas debajo.

Por ejemplo:

def mi_función(): a = 2

devolver un

# Esta es una definición de función. Tenga en cuenta los dos puntos (:)

# Esta línea pertenece a la función porque tiene sangría # Esta línea también pertenece a la misma
función

print(my_function()) # Esta línea está FUERA del bloque de funciones

si a > b:

imprimir(a)

demás:

imprimir(b)

# Si el bloque comienza aquí

# Esto es parte del bloque if # else debe estar en el mismo nivel que if

# Esta línea es parte del bloque else

Los bloques que contienen exactamente una declaración de una sola línea se pueden colocar en la
misma línea, aunque esta forma generalmente no se considera un buen estilo:

si a > b: imprimir(a) en caso contrario: imprimir(b)

Intentar hacer esto con más de una declaración no funcionará:

si x > y: y = x print(y) #

IndentationError: sangría inesperada

si x > y: while y != z: y = 1 # SyntaxError: sintaxis no válida

Un bloque vacío provoca un error de sangría. Utilice pasar (un comando que no hace nada) cuando
tenga un bloque con sin contenido:

def will_be_implemented_later(): pasar

Espacios versus pestañas

En resumen: utilice siempre 4 espacios para la sangría.

Usar pestañas exclusivamente es posible pero PEP 8, la guía de estilo para el código Python,
establece que se prefieren los espacios.

Python 3.x Versión 3.0

Python 3 no permite mezclar el uso de tabulaciones y espacios para sangría. En tal caso, se genera
un error en tiempo de compilación: uso inconsistente de tabulaciones y espacios en sangría y el
programa no se ejecutará.

Python 2.x Versión 2.7

Python 2 permite mezclar tabulaciones y espacios en sangría; Esto se desaconseja

encarecidamente. El carácter de tabulación completa la sangría anterior para ser un múltiplo de 8
espacios. Dado que es común que los editores estén configurados para mostrar pestañas con
múltiplos de 4 espacios, esto puede causar errores sutiles.

Citando a PEP 8:

Al invocar el intérprete de línea de comandos de Python 2 con la opción t , emite advertencias

sobre código que mezcla ilegalmente tabulaciones y espacios. Cuando se usa tt estas advertencias
se convierten en errores. ¡Estas opciones son muy recomendables!

Muchos editores tienen una configuración de "tabulación a espacios". Al configurar el editor, se

debe diferenciar entre el carácter de tabulación ('\t') y la tecla Tab.

El carácter de tabulación debe configurarse para mostrar 8 espacios, para que coincida con la
semántica del idioma, al menos en los casos en que es posible una sangría mixta (accidental). Los
editores también pueden convertir automáticamente el carácter de tabulación a

espacios.

Sin embargo, puede resultar útil configurar el editor para que al presionar la tecla Tab se inserten 4
espacios, en lugar de insertar un carácter de tabulación.

El código fuente de Python escrito con una combinación de tabulaciones y espacios, o con un
número no estándar de espacios de sangría, se puede hacer compatible con pep8 usando
autopep8. (Una alternativa menos poderosa viene con la mayoría de las instalaciones de Python:
reindent.py)
Sección 1.4: Tipos de datos

Tipos incorporados booleanos

bool: un valor booleano de Verdadero o Falso. Las operaciones lógicas como y o no se pueden
realizar en valores booleanos.

# si x es # si x es Falso entonces y en caso contrario x x o yx e y

Falso entonces x en caso contrario y # si x es Verdadero entonces Falso,

no x

en caso contrario Verdadero

En Python 2.x y Python 3.x, un booleano también es un int. El tipo bool es una subclase del tipo int
y Verdadero y Falso son sus únicas instancias:

issubclass(bool, int) # Verdadero

isinstance(Verdadero, bool) # Verdadero isinstance(False, bool) # Verdadero

Si se utilizan valores booleanos en operaciones aritméticas, sus valores enteros (1 y 0 para

Verdadero y Falso) se utilizarán para devolver un resultado entero:

Verdadero + Falso == 1 # 1 + 0 == 1

Verdadero * Verdadero == 1 # 1 * 1 == 1

Números

int: número entero

a=2

b = 100

c = 123456789 d

= 38563846326424324

Los números enteros en Python son de tamaños arbitrarios.

Nota: en versiones anteriores de Python, estaba disponible un tipo largo y era distinto de int. Los
dos se han unificado.

float: número de coma flotante; la precisión depende de la implementación y la arquitectura del

sistema; para CPython, el tipo de datos flotante corresponde a un doble de C.

a = 2.0 b

= 100.e0
c = 123456789.e1

complejo: números complejos

a = 2 + 1j b

= 100 + 10j

Los operadores <, <=, > y >= generarán una excepción TypeError cuando cualquier operando sea un
número complejo.

Cadenas

Python 3.x Versión 3.0

str: una cadena Unicode. El tipo de bytes de 'hola' : una cadena de bytes. El tipo de b'hola'

Python 2.x Versión 2.7

str: una cadena de bytes. El tipo de bytes 'hola' : sinónimo de cadena

Unicode: una cadena Unicode. El tipo de "hola"

Secuencias y colecciones.

Python diferencia entre secuencias ordenadas y colecciones desordenadas (como set y dict).

cadenas (cadena, bytes, unicode) son secuencias

invertido: un orden inverso de str con función invertida

a = invertido('hola')

tupla: una colección ordenada de n valores de cualquier tipo (n >= 0).

a = (1, 2, 3) b =

('a', 1, 'python', (1, 2)) b[2] = 'algo más' # devuelve un TypeError

Admite indexación; inmutable; hashable si todos sus miembros son hashables

lista: una colección ordenada de n valores (n >= 0)

a = [1, 2, 3] b =

['a', 1, 'python', (1, 2), [1, 2]] b[2] = 'algo más' # permitido

No hashable; mudable.

conjunto: una colección desordenada de valores únicos. Los elementos deben ser hash.

un = {1, 2, 'un'}
dict: una colección desordenada de pares clavevalor únicos; las claves deben ser hash.

a = {1: 'uno', 2:

'dos'}

b = {'a': [1, 2, 3], 'b': 'una

cadena'}

Un objeto es hash si tiene un valor hash que nunca cambia durante su vida (necesita un método
hash () ) y se puede comparar con otros objetos (necesita un método eq () ). Los objetos hash que
comparan igualdad deben tener el mismo valor hash.

Constantes incorporadas

Junto con los tipos de datos integrados, hay una pequeña cantidad de constantes integradas en el
espacio de nombres integrado:

Verdadero: el valor verdadero del tipo incorporado bool. Falso: el valor falso del tipo incorporado
bool.

Ninguno: un objeto singleton utilizado para señalar que un valor está ausente.

Elipsis o ...: utilizado en el núcleo de Python3+ en cualquier lugar y uso limitado en Python2.7+
como parte de la notación de matriz. Los paquetes numpy y relacionados usan esto como una
referencia para "incluir todo" en las matrices.

NotImplemented: un singleton usado para indicarle a Python que un método especial no admite
los argumentos específicos, y Python probará alternativas si están disponibles.

a = Ninguno # No se asignará ningún valor. Cualquier tipo de datos válido se puede asignar más
tarde

Python 3.x Versión 3.0

Ninguno no tiene ningún orden natural. El uso de operadores de comparación de pedidos (<, <=,
>=, >) ya no se admite y generará un TypeError.

Python 2.x Versión 2.7

Ninguno es siempre menor que cualquier número (Ninguno < 32 se evalúa como Verdadero).

Probando el tipo de variables.

En Python, podemos verificar el tipo de datos de un objeto usando el tipo de función incorporada.
a = '123'

imprimir (tipo (a))

# Salida: <clase 'str'> b = 123

imprimir(tipo(b))

# Salida: <clase 'int'>

En declaraciones condicionales es posible probar el tipo de datos con isinstance. Sin embargo,
normalmente no se recomienda confiar en el tipo de variable.

yo = 7

i es instancia(i, int): yo += 1

elif esinstancia(i, str): i = int(i) i += 1

Para obtener información sobre las diferencias entre type() e isinstance() lea: Diferencias entre
isinstance y type en Python

Para probar si algo es de Ninguno Tipo:

x = Ninguno

si x es Ninguno:

print('No es una sorpresa, acabo de definir x como Ninguno.')

Convertir entre tipos de datos

Puede realizar una conversión de tipo de datos explícita.

Por ejemplo, '123' es de tipo str y se puede convertir a un número entero usando la función int .

a = '123' b =

int(a)

La conversión desde una cadena flotante como '123.456' se puede realizar utilizando la función
flotante .

a = '123.456' b =

float(a) c = int(a) #

ValueError: literal no válido para int() con base 10: '123.456' d = int(b) # 123

También puedes convertir tipos de secuencia o colección.

a = 'hola' lista(a)
# ['h', 'e', 'l', 'l', 'o'] set(a) # {'o', 'e', 'l', ' h'} tupla(a) # ('h', 'e', 'l', 'l', 'o')

Tipo de cadena explícita en la definición de literales

Con etiquetas de una letra justo delante de las comillas, puede saber qué tipo de cadena desea
definir.

b'foo bar': resultados bytes en Python 3, str en Python 2 u'foo bar': resultados str en Python 3,
unicode en Python 2 'foo bar': resultados str

r'foo bar': resultados de la llamada cadena sin formato, donde no es necesario escapar de
caracteres especiales, todo se toma palabra por palabra a medida que escribe

normal = 'foo\nbar' # foo

# bar

escapó = 'foo\\nbar' # foo\nbar = r'foo\nbar' # foo\nbar

crudo

Tipos de datos mutables e inmutables

Un objeto se llama mutable si se puede cambiar. Por ejemplo, cuando pasa una lista a alguna
función, la lista se puede cambiar:

def f(m):

m.append(3) # agrega un número a la lista. Esta es una mutación.

x = [1, 2] f(x) x

== [1,

2] # Falso ahora, ya que se agregó un elemento a la lista

Un objeto se llama inmutable si no se puede cambiar de ninguna manera. Por ejemplo, los
números enteros son inmutables, ya que no hay forma de cambiarlos:

def bar(): x = (1,

2) g(x) x == (1,

2) #

Siempre será Verdadero, ya que ninguna función puede cambiar el objeto (1, 2)
Tenga en cuenta que las variables en sí son mutables, por lo que podemos reasignar la variable x,
pero esto no cambia el objeto al que x había apuntado previamente. Solo hizo que x apuntara a un
nuevo objeto.

Los tipos de datos cuyas instancias son mutables se denominan tipos de datos mutables, y lo
mismo ocurre con los objetos y tipos de datos inmutables.

Ejemplos de tipos de datos inmutables:

int, largo, flotante, complejo

cadena

tupla de bytes

conjunto congelado

Ejemplos de tipos de datos mutables:

matriz de bytes lista

colocar

dictar

Sección 1.5: Tipos de colección

Hay varios tipos de colecciones en Python. Mientras que tipos como int y str contienen un único
valor, los tipos de colección contienen varios valores.

Lista

El tipo de lista es probablemente el tipo de colección más utilizado en Python. A pesar de su

nombre, una lista se parece más a una matriz en otros lenguajes, principalmente JavaScript. En
Python, una lista es simplemente una colección ordenada de valores válidos de Python. Se puede
crear una lista encerrando valores, separados por comas, entre corchetes:

lista_int = [1, 2, 3] lista_cadena = ['abc', 'defghi']

Una lista puede estar vacía:

lista_vacia = []

Los elementos de una lista no están restringidos a un único tipo de datos, lo cual tiene sentido
dado que Python es un lenguaje dinámico:

lista_mixta = [1, 'abc', Verdadero, 2.34, Ninguno]

Una lista puede contener otra lista como elemento:

lista_anidada = [['a', 'b', 'c'], [1, 2, 3]]

Se puede acceder a los elementos de una lista mediante un índice o representación numérica de
su posición. Las listas en Python tienen un índice cero, lo que significa que el primer elemento de la
lista está en el índice 0, el segundo elemento está en el índice 1 y así sucesivamente:

nombres = ['Alicia', 'Bob', 'Craig', 'Diana', 'Eric'] imprimir(nombres[0]) # Alicia imprimir(nombres[2])

# Craig

Los índices también pueden ser negativos, lo que significa contar desde el final de la lista (siendo 1
el índice del último elemento). Entonces, usando la lista del ejemplo anterior:

imprimir(nombres[1]) # Eric imprimir(nombres[4]) # Bob

Las listas son mutables, por lo que puedes cambiar los valores en una lista:

nombres[0] = 'Ann' imprimir(nombres)

# Salidas ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Además, es posible agregar y/o eliminar elementos de una lista:

Agregar objeto al final de la lista con L.append(objeto), devuelve Ninguno.

nombres = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric'] nombres.append("Sia")

print(nombres)

# Salidas ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Agregue un nuevo elemento a la lista en un índice específico. L.insertar(índice, objeto)

nombres.insert(1, "Nikki") imprimir(nombres)

# Salidas ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Elimina la primera aparición de un valor con L.remove(valor), devuelve Ninguno

nombres.remove("Bob")

print(nombres) # Salidas ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

dieciséis

Obtenga el índice en la lista del primer elemento cuyo valor es x. Mostrará un error si no existe
dicho elemento.

nombre.index("Alicia") 0

Contar la longitud de la lista

len(nombres) 6

contar la aparición de cualquier elemento en la lista

a = [1, 1, 1, 2, 3, 4] a.cuenta(1) 3
invertir la lista

a.reverse() [4, 3,

2, 1, 1, 1] # o a[::1] [4, 3, 2, 1,

1, 1]

Eliminar y devolver el artículo en el índice (el valor predeterminado es el último artículo) con
L.pop([índice]), devuelve el artículo

nombres.pop() # Salidas 'Sia'

Puede iterar sobre los elementos de la lista como se muestra a continuación:

para elemento en my_list: imprimir (elemento)

Tuplas

Una tupla es similar a una lista excepto que tiene una longitud fija y es inmutable. Por lo tanto, los
valores de la tupla no se pueden cambiar ni agregar o eliminar valores de la tupla. Las tuplas se
utilizan comúnmente para pequeñas colecciones de valores que no será necesario cambiar, como
una dirección IP y un puerto. Las tuplas se representan entre paréntesis en lugar de corchetes:

dirección_ip = ('10.20.30.40', 8080)

Las mismas reglas de indexación para listas también se aplican a las tuplas. Las tuplas también se
pueden anidar y los valores pueden ser cualquier Python válido.

Una tupla con un solo miembro debe definirse (tenga en cuenta la coma) de esta manera:

one_member_tuple = ('Único miembro',)

one_member_tuple = 'Único miembro', # Sin corchetes

o simplemente usando la sintaxis de tupla

one_member_tuple = tupla(['Único miembro'])

Diccionarios

Un diccionario en Python es una colección de pares clavevalor. El diccionario está rodeado de

llaves. Cada par está separado por una coma y la clave y el valor están separados por dos puntos.
Aquí hay un ejemplo:

capitales_estado = {

'Arkansas': 'Pequeña Roca', 'Colorado': 'Denver', 'California': 'Sacramento', 'Georgia': 'Atlanta'

}
Para obtener un valor, consúltelo por su clave:

ca_capital = capitales_estado['California']

También puedes obtener todas las claves en un diccionario y luego iterar sobre ellas:

para k en state_capitals.keys():

print('{} es la capital de {}'.format(state_capitals[k], k))

Los diccionarios se parecen mucho a la sintaxis JSON. El módulo json nativo de la biblioteca
estándar de Python se puede utilizar para convertir entre JSON y diccionarios.

colocar

Un conjunto es una colección de elementos sin repeticiones y sin orden de inserción pero sí
ordenados. Se utilizan en situaciones en las que sólo es importante que algunas cosas estén
agrupadas y no el orden en que se incluyeron. Para grandes grupos de datos, es mucho más rápido
comprobar si un elemento está o no en un conjunto que hacer lo mismo con una lista.

Definir un conjunto es muy similar a definir un diccionario: primeros_nombres = {'Adán', 'Beth',

'Charlie'}

O puede crear un conjunto utilizando una lista existente :

mi_lista = [1,2,3]

mi_conjunto = conjunto(mi_lista)

Verifique la membresía del conjunto usando en:

si el nombre está en first_names:

imprimir (nombre)

Puede iterar sobre un conjunto exactamente como una lista, pero recuerde: los valores estarán en
un orden arbitrario definido por la implementación.

dictamen predeterminado

Un defaultdict es un diccionario con un valor predeterminado para las claves, de modo que se
pueda acceder sin errores a las claves para las que no se ha definido explícitamente ningún valor.
defaultdict es especialmente útil cuando los valores en el diccionario son colecciones (listas,
dictados, etc.) en el sentido de que no es necesario inicializarlo cada vez que se usa una nueva
clave.

Un defaultdict nunca generará un KeyError. Cualquier clave que no exista obtiene el valor
predeterminado.

Por ejemplo, considere el siguiente diccionario

>>> capitales_estado = { 'Arkansas': 'Pequeña Roca', 'Colorado': 'Denver', 'California': 'Sacramento',

'Georgia': 'Atlanta'
}

Si intentamos acceder a una clave inexistente, Python nos devuelve un error de la siguiente
manera