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]