1. Intro a Python

1.1 Introduciendo Python

El objetivo de este capítulo es introducir las bases de Python. Iniciaremos desde cero y aprenderemos a editar, ejecutar, y depurar programas. Además, escribiremos una secuencia de comandos que lee data en un archivo CSV y ejecuta un cálculo.

1.1.1: Qué es Python?

Python es un lenguaje interpretado de programación de alto nivel. A menudo se le clasifica como un lenguaje de secuencias de comandos y también se le considera similar a lenguajes como Perl, Tcl o Ruby. La sintaxis de Python está vagamente inspirada en elementos de la programación C. Python fue creado por Guido van Rossum alrededor de 1990, quien lo nombró en honor a la comedia de origen británico Monty Python.

1.1.2: Donde consigo Python?

Puedes obtener una versión de Python en Python.org. Para los propósitos de este curso, solo necesitas una instalación básica. Recomiendo instalar Python 3.6 o una versión más reciente. Python 3.6 es el que se usa en las notas y en las soluciones, sin embargo puedes utilizar cualquier versión.

1.1.3: Porqué fue creado?

En palabras del creador de Python:

Mi motivación original para crear Python fue la necesidad percibida de un lenguaje de alto nivel en el proyecto Amoeba [Sistemas Operativos]. Me di cuenta de que el desarrollo de las utilidades de administración del sistema en C estaban tardando demasiado. Además, hacer estas cosas en el shell Bourne no iba a funcionar por una variedad de razones. ... Entonces, era necesario un lenguaje que cerrara la brecha entre C y el shell.

Guido van Rossum

1.1.4: Dónde está Python en mi Maquina?

Aunque hay muchos entornos en los que puede ejecutar Python, Python normalmente se instala en su máquina como un programa que se ejecuta desde la terminal o el shell de comandos. Desde la terminal, debería poder escribir python así:

$ python
Python 3.8.1 (default, Feb 20 2020, 09:29:22)
[Clang 10.0.0 (clang-1000.10.44.4)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> print("hello world")
hello world
>>>

Aunque hay muchos entornos en donde puede programar en Python, será un programador más fuerte si puede ejecutar, depurar e interactuar con Python en la terminal. Este es el entorno nativo de Python. Si puede usar Python aquí, podrá usarlo en cualquier otro lugar.

1.1.5: Ejercicios

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

Ejercicio 1.1: Utilizando Python como Calculadora

En su máquina, inicie Python y utilícelo como calculador para resolver el siguiente problema.

El suertudo de Juan compró 75 acciones de Google a un precio de $235.14 USD por acción. Hoy, las acciones de Google tienen un precio de $711.25 USD. Usando el modo interactivo de Python como una calculadora, averigüe cuántas ganancias obtendría Juan si vendiera todas sus acciones.

>>> (711.25 - 235.14) * 75
35708.25
>>>

Consejo profesional: use la variable de subrayado (_) para usar el resultado del último cálculo. Por ejemplo, ¿cuántas ganancias obtiene Juan después de que su malvado corredor se lleva su parte del 20%?

>>> _ * 0.80
28566.600000000002
>>>

Ejercicio 1.2: Consiguiendo ayuda

Utilice el comando help() para obtener ayuda sobre la función abs(). Luego use help() para obtener ayuda sobre la función round(). Escriba help(), asi sin valor alguno, para ingresar al visor de ayuda interactiva.

Una advertencia con help() es que no funciona para declaraciones básicas de Python como for, if, while, etc. (es decir, si escribe help(for) obtendrá un error de sintaxis). En su lugar, puede intentar poner el tema de la ayuda entre comillas: help('for'). Si eso no funciona, tendrá que recurrir a una búsqueda en Internet.

Seguimiento: vaya a http://docs.python.org y busque la documentación de la función abs() (pista: se encuentra en la referencia de la biblioteca relacionada con las funciones integradas).

Ejercicio 1.3: Copiar y pegar

Este curso está estructurado como una serie de páginas en las que se le anima a probar ejemplos interactivos de código Python escribiéndolos a mano. Si está aprendiendo Python por primera vez, se recomienda este "enfoque lento". Obtendrá una mejor idea del idioma al reducir la velocidad, escribir cosas y pensar en lo que está haciendo.

Si debe "cortar y pegar" ejemplos de código, seleccione el código comenzando después del indicador >>> y subiendo hasta, pero no más allá de la primera línea en blanco o el siguiente mensaje >>> (lo que aparezca primero). Seleccione "copiar" en el navegador, vaya a la ventana de Python y seleccione "pegar" para copiarlo en el shell de Python. Para que el código se ejecute, es posible que deba presionar "Retorno" una vez después de haberlo pegado.

Corte y pegue las siguientes declaraciones de Python:

>>> 12 + 20
32
>>> (3 + 4
         + 5 + 6)
18
>>> for i in range(5):
        print(i)

0
1
2
3
4
>>>

Advertencia: No es posible pegar más de un comando de Python (declaraciones que aparecen después de >>>) en el shell básico de Python a la vez. Tienes que pegar cada comando de uno en uno.

Ahora que ha hecho esto, recuerde que sacará más provecho de la clase escribiendo el código lentamente y pensando en ello, no cortando y pegando.

Ejercicio 1.4: Donde esta mi bus?

Pruebe algo más avanzado y escriba estas declaraciones para averiguar cuánto tiempo tendrán que esperar las personas que esperan en la esquina de la calle Clark y Balmoral en Chicago al próximo autobús CTA n. ° 22 en dirección norte:

>>> import urllib.request
>>> u = urllib.request.urlopen('http://ctabustracker.com/bustime/map/getStopPredictions.jsp?stop=14791&route=22')
>>> from xml.etree.ElementTree import parse
>>> doc = parse(u)
>>> for pt in doc.findall('.//pt'):
        print(pt.text)

6 MIN
18 MIN
28 MIN
>>>

Sí, acaba de descargar una página web, analizar un documento XML y extraer información útil en aproximadamente 6 líneas de código. Los datos a los que accedió en realidad alimentan el sitio web http://ctabustracker.com/bustime/home.jsp. Inténtelo nuevamente y observe cómo cambian las predicciones.

Si falla la primera declaración de importación import urllib.request, probablemente esté usando Python 2. Para este curso, debe asegurarse de que está usando Python 3.6 o más reciente. Vaya a https://www.python.org para descargarlo si lo necesita.

Si su entorno de trabajo requiere el uso de un servidor proxy HTTP, es posible que deba configurar la variable de entorno HTTP_PROXY para que esta parte del ejercicio funcione.

Por ejemplo:

>>> import os
>>> os.environ['HTTP_PROXY'] = 'http://suproxy.server.com'
>>>

Si no puede hacer que esto funcione, no se preocupe. El resto de este curso no tiene nada que ver con analizar XML.

1.2 Un primer programa

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.2.1: Ejecutando Python

Los programas de Python siempre se ejecutan dentro de un intérprete.

El intérprete es una aplicación "basada en consola" que normalmente se ejecuta desde un shell de comandos.

python3
Python 3.6.1 (v3.6.1:69c0db5050, Mar 21 2017, 01:21:04)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Los programadores expertos generalmente no tienen problemas para usar el intérprete de esta manera, pero no es tan fácil de usar para los principiantes. Es posible que esté utilizando un entorno que proporciona una interfaz diferente a Python. Eso está bien, pero aprender a ejecutar la terminal de Python sigue siendo una habilidad útil.

1.2.2: Modo interactivo

Cuando inicias Python, obtienes un modo interactivo donde puedes experimentar.

Si comienza a escribir declaraciones, se ejecutarán de inmediato. No hay ciclo de edición / compilación / ejecución / depuración.

>>> print('hello world')
hello world
>>> 37*42
1554
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>>

Este llamado ciclo de lectura-evaluación-impresión (o REPL, por sus siglas en inglés) es muy útil para depurar y explorar.

DETENTE: si no puedes descubrir cómo interactuar con Python, detengase y descubra cómo hacerlo. Si está utilizando un IDE, es posible que esté oculto detrás de una opción de menú u otra ventana. Muchas partes de este curso asumen que puede interactuar con el intérprete.

Let's take a closer look at the elements of the REPL:

>>> es el indicador del intérprete para iniciar una nueva declaración.
... es la indicación del intérprete para continuar una declaración. Ingrese una línea en blanco para terminar de escribir y ejecutar lo que ingresó.

El mensaje ... puede aparecer o no según el entorno. Para este curso, se muestra como espacios en blanco para que sea más fácil cortar / pegar muestras de código.

El guión bajo _ contiene el último resultado.

>>> 37 * 42
1554
>>> _ * 2
3108
>>> _ + 50
3158
>>>

Esto solo es cierto en el modo interactivo. Nunca uses _ en un programa.

1.2.3: Creando programas

Los programas se colocan en archivos .py.

# hola.py
print('hola mundo')

Puede crear estos archivos con su editor de texto favorito.

1.2.4: Ejecutando programas

Para ejecutar un programa, ejecútelo en la terminal con el comando python. Por ejemplo, en la línea de comandos Unix:

$ python hola.py
hola mundo
$

O desde el shell de Windows:

C:\AlgunDirectorio>hola.py
hello world

C:\AlgunDirectorio>c:\python36\python hola.py
hello world

Nota: en Windows, es posible que deba especificar una ruta completa al intérprete de Python, como c:\python36\python. Sin embargo, si Python se instala de la forma habitual, es posible que pueda simplemente escribir el nombre del programa, como hola.py.

1.2.5: Un ejemplo

Resolvamos el siguiente problema:

Una mañana, sales y colocas un billete de un dólar en la acera de la torre Sears en Chicago. Cada día a partir de entonces, sales y colocas el doble de billetes. ¿Cuánto tiempo tarda la pila de billetes en superar la altura de la torre?

Una posible solución:

# sears.py
billete_grosor = 0.11 * 0.001 # Metros (0.11 mm)
sears_altura = 442 # Altura (metros)
num_billetes = 1
dia = 1

while num_billetes * billete_grosor < sears_altura:
    print(dia, num_billetes, num_billetes * billete_grosor)
    dia = dia + 1
    num_billetes = num_billetes * 2

print('Número de días', dia)
print('Número de facturas', num_billetes)
print('Altura final', num_billetes * billete_grosor)

Cuando lo ejecuta, obtiene el siguiente resultado:

$ python3 sears.py
1 1 0.00011
2 2 0.00022
3 4 0.00044
4 8 0.00088
5 16 0.00176
6 32 0.00352
7 64 0.00704
8 128 0.01408
9 256 0.02816
10 512 0.05632
11 1024 0.11264
12 2048 0.22528
13 4096 0.45056
14 8192 0.90112
15 16384 1.80224
16 32768 3.60448
17 65536 7.20896
18 131072 14.41792
19 262144 28.83584
20 524288 57.67168
21 1048576 115.34336
22 2097152 230.68672
Número de días 23
Número de facturas 4194304
Altura final 461.37344

Usando este programa como guía, puede aprender una serie de conceptos básicos importantes sobre Python.

1.2.6: Declaraciones

Un programa de Python es una secuencia de declaraciones:

a = 3 + 4
b = a * 2
print(b)

Cada declaración termina con una nueva línea. Las sentencias se ejecutan una tras otra hasta que el control llega al final del archivo.

1.2.7: Comentarios

Los comentarios son texto que no se ejecutará.

a = 3 + 4
# Esto es un comentario
b = a * 2
print(b)

Los comentarios se indican con # y se extienden hasta el final de la línea.

1.2.8: Variables

Una variable es el nombre de un valor. Puede utilizar letras (minúsculas y mayúsculas) de la a a la z, además del carácter subrayado _. Los números también pueden formar parte del nombre de una variable, excepto como primer carácter.

altura = 442  # válido
_height = 442 # válido
altura2 = 442 # válido
2height = 442 # inválido

1.2.9: Tipos

Las variables no necesitan declararse con el tipo de valor. El tipo está asociado con el valor del lado derecho, no con el nombre de la variable.

altura = 442            # Un número entero
altura = 442.0          # Punto flotante
height = 'Muy alto'     # Una cadena

Python se escribe dinámicamente. El "tipo" percibido de una variable puede cambiar a medida que se ejecuta un programa en función del valor actual que se le asigna.

1.2.10: Casos Sensitivos

Python distingue entre mayúsculas y minúsculas. Las letras mayúsculas y minúsculas se consideran letras diferentes. Todas estas son variables diferentes:

nombre = 'Jake'
Nombre = 'Elwood'
NOMBRE = 'Guido'

Las declaraciones de idioma son siempre en minúsculas.

while x < 0: # OK
WHILE x < 0: # ERROR

1.2.11: Ciclar

La instrucción while ejecuta un ciclo.

while num_billetes * billete_grosor < sears_altura:
    print(dia, num_billetes, num_billetes * billete_grosor)
    dia = dia + 1
    num_billetes = num_billetes * 2

print('Numero de dias', dia)

Las declaraciones con sangría debajo del while se ejecutarán siempre que la expresión posterior al while sea verdadera / cierta.

1.2.12: Sangrías (las de texto)

La sangría se usa para denotar grupos de declaraciones que van juntas. Considere el ejemplo anterior:

while num_billetes * billete_grosor < sears_altura:
    print(dia, num_billetes, num_billetes * billete_grosor)
    dia = dia + 1
    num_billetes = num_billetes * 2

print('Numero de dias', dia)

La sangría agrupa las siguientes declaraciones juntas como las operaciones que se repiten:

    print(dia, num_billetes, num_billetes * billete_grosor)
    dia = dia + 1
    num_billetes = num_billetes * 2

Debido a que la instrucción print() al final no tiene sangría, no pertenece al ciclo. La línea vacía es solo para facilitar la lectura. No afecta la ejecución.

Sangrías - Mejores prácticas

Utilice espacios en lugar de tabulaciones.
Utilice 4 espacios por nivel.
Utilice un editor compatible con Python.

El único requisito de Python es que la sangría dentro del mismo bloque sea consistente. Por ejemplo, esto es un error:

while num_billetes * billete_grosor < sears_altura:
    print(dia, num_billetes, num_billetes * billete_grosor)
        dia = dia + 1  # error
    num_billetes = num_billetes * 2

1.2.13: Condicionales

La instrucción if se usa para ejecutar un condicional:

if a > b:
    print('Computadora dice no')
else:
    print('Computadora dice si')

Puede verificar múltiples condiciones agregando verificaciones adicionales usando elif.

if a > b:
    print('Computadora dice no')
elif a == b:
    print('Computadora dice si')
else:
    print('Computadora dice quizas')

1.2.14: Imprimiendo

La función de impresión produce una sola línea de texto con los valores pasados.

print('¡Hola mundo!') # Imprime el texto '¡Hola mundo!'

Puede utilizar variables. El texto impreso será el valor de la variable, no el nombre.

x = 100
print(x) # Imprime el texto '100'

Si pasa más de un valor para imprimir, están separados por espacios.

nombre = 'Jake'
print('Mi nombre es', nombre) # Imprime el texto 'Mi nombre es Jake'

print() siempre pone una nueva línea al final.

print('Hola')
print('Mi nombre es', 'Jake')

Esto imprime:

shell
Hola
Mi nombre es Jake

La nueva línea adicional se puede suprimir:

print('Hola', end = '')
print('Mi nombre es', 'Jake')

Este código ahora se imprimirá:

Hola mi nombre es Jake

1.2.15: Input (dato de entrada) de usuario

Para leer una línea de entrada de usuario escrita, use la función input():

nombre = input('Ingrese su nombre:')
print('Tu nombre es', nombre)

input imprime un mensaje al usuario y devuelve su respuesta. Esto es útil para programas pequeños, ejercicios de aprendizaje o depuración simple. No se usa mucho para programas reales.

1.2.16: La declaración "pass"

Sometimes you need to specify an empty code block. The keyword pass is used for it.

if a > b:
    pass
else:
    print('Computer says false')

This is also called a "no-op" statement. It does nothing. It serves as a placeholder for statements, possibly to be added later.

1.2.17: Ejercicios

Este es el primer conjunto de ejercicios en los que necesita crear archivos Python y ejecutarlos. A partir de este punto, se asume que está editando archivos en el directorio ./Work/. Para ayudarle a localizar el lugar adecuado, se han creado varios archivos de inicio vacíos con los nombres de archivo adecuados. Busque el archivo ./Work/rebote.py que se utilizó en el primer ejercicio.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

Ejercicio 1.5: El rebote

Una pelota de goma se deja caer desde una altura de 100 metros y cada vez que golpea el suelo, rebota hasta 3/5 de la altura a la que cayó. Escriba un programa bounce.py que imprima una tabla que muestre la altura de los primeros 10 rebotes.

Su programa debería crear una tabla que se parezca a esto:

1 60,0
2 36,0
3 21.599999999999998
4 12.959999999999999
5 7.775999999999999
6 4.6655999999999995
7 2.7993599999999996
8 1,6796159999999998
9 1,0077695999999998
10 0.6046617599999998

Nota: Puede limpiar un poco la salida si usa la función round(). Intente usarlo para redondear la salida a 4 dígitos.

Ejercicio 1.6: Depuración

El siguiente fragmento de código contiene código del problema de la torre Sears. También tiene un error.

billete_grosor = 0.11 * 0.001 # Metros (0.11 mm)
sears_altura = 442 # Altura (metros)
num_billetes = 1
dia = 1

while num_billetes * billete_grosor < sears_altura:
    print(dia, num_billetes, num_billetes * billete_grosor)
    dia = dias + 1
    num_billetes = num_billetes * 2

print ('Número de días', dia)
print ('Número de facturas', num_billetes)
print ('Altura final', num_billetes * billete_grosor)

Copie y pegue el código que aparece arriba en un nuevo programa llamado sears.py. Cuando ejecute el código, obtendrá un mensaje de error que hace que el programa se bloquee de esta manera:

Traceback (most recent call last):
  File "sears.py", line 10, in <module>
    day = dias + 1
NameError: name 'dias' is not defined

Leer los mensajes de error es una parte importante del código Python. Si su programa falla, la última línea del mensaje de rastreo es la razón real por la cual el programa falla. Por encima de eso, debería ver un fragmento de código fuente y luego un nombre de archivo de identificación y un número de línea.

¿Qué línea es el error?
Cual es el error?
Arreglar el error
Ejecute el programa con éxito

1.3 Números

Esta sección discute sobre cálculos matemáticos.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.3.1: Tipos de numeros

Python tiene 4 tipos de números:

Booleanos
Enteros
Punto flotante
Complejo (números imaginarios)

1.3.2: Booleanos (bool)

Los booleanos tienen dos valores: True,False.

a = True
b = False

Numéricamente, se evalúan como números enteros con valor "1", "0".

c = 4 + True # 5
d = False
if d == 0:
    print('d is False')

Pero no escriba código como ese. Sería extraño. *

1.3.3: Enteros (int)

Valores firmados de tamaño y base arbitraria:

a = 37
b = -299392993727716627377128481812241231
c = 0x7fa8      # Hexadecimal
d = 0o253       # Octal
e = 0b10001111  # Binario

Operaciones comunes:

x + y      Suma
x - y      Resta
x * y      Multiplicacion
x / y      División (produce un flotante)
x // y     División entera (produce un entero)
x % y      Modulo (devuelve el resto de la división)
x ** y     Potencia
x << n     Bit desplazamiento izquierda
x >> n     Bit desplazamiento derecha
x & y      Bit-wise AND
x | y      Bit-wise OR
x ^ y      Bit-wise XOR
~x         Bit-wise NOT
abs(x)     Valor absoluto

1.3.4: Punto flotante (float)

Utilice una notación decimal o exponencial para especificar un valor de coma flotante:

a = 37.45
b = 4e5 # 4 x 10**5 or 400,000
c = -1.345e-10

Los flotantes se representan con precisión doble utilizando la representación de CPU nativa IEEE 754. Es lo mismo que el tipo "doble" en el lenguaje de programación C.

17 dígitos de precisión
Exponente de -308 a 308

Tenga en cuenta que los números de punto flotante son inexactos cuando representan decimales.

>>> a = 2.1 + 4.2
>>> a == 6.3
False
>>> a
6.300000000000001
>>>

Esto no es un problema de Python, sino el hardware de punto flotante subyacente en la CPU.

Operaciones comunes:

x + y      Suma
x - y      Resta
x * y      Multiplicacion
x / y      Division
x // y     Division entera
x % y      Modulo
x ** y     Potencia
abs(x)     Valor absoluto

Estos son los mismos operadores que los enteros, excepto los operadores bit a bit. Las funciones matemáticas adicionales se encuentran en el módulo math.

import math
a = math.sqrt(x)
b = math.sin(x)
c = math.cos(x)
d = math.tan(x)
e = math.log(x)

1.3.5: Comparaciones

Los siguientes operadores de comparación / relacionales funcionan con números:

x < y      Menor
x <= y     Menor o igual
x > y      Mayor
x >= y     Mayor o igual
x == y     Igual
x != y     No es igual

Puede formar expresiones booleanas más complejas usando

and, or, not

Aquí están algunos ejemplos:

if b >= a and b <= c:
    print('b está entre a y c')

if not (b < a or b > c):
    print('b todavía está entre a y c')

1.3.6: Convirtiendo numeros

El nombre del tipo se puede utilizar para convertir valores:

a = int(x)    # Convierte x a entero
b = float(x)  # Convierte x a coma flotante

Try it out.

>>> a = 3.14159
>>> int(a)
3
>>> b = '3.14159' # También funciona con cadenas de numeros
>>> float(b)
3.14159
>>>

1.3.7: Ejercicios

Recordatorio: Estos ejercicios asumen que está trabajando en el directorio /Work. Busque el archivo hipoteca.py.

Ejercicio 1.7: La hipoteca de Dave

Dave ha decidido sacar una hipoteca de tasa fija a 30 años de $500,000 con el comercio de hipotecas, inversiones en acciones y Bitcoin de Guido corporación. La tasa de interés es del 5% y el pago mensual es $2684,11.

Aquí hay un programa que calcula la cantidad total que Dave tendrá para pagar durante la vida de la hipoteca:

# mortgage.py

capital = 500000.0
tasa = 0.05
pago = 2684.11
total_pagado = 0.0

while capital > 0:
    capital = capital * (1 + tasa / 12) - pago
    total_pagado = total_pagado + pago

print('Total pagado', total_pagado)

Ingrese a este programa y ejecútelo. Debería obtener una respuesta de "966,279.6".

Ejercicio 1.8: Pagos adicionales

Suponga que Dave paga $1000 adicionales al mes durante los primeros 12 meses de la hipoteca.

Modifique el programa para incorporar este pago adicional y haga que imprima el monto total pagado junto con la cantidad de meses requeridos.

Cuando ejecute el nuevo programa, debería informar un pago total de 929,965.62 durante 342 meses.

Ejercicio 1.9: Hacer una calculadora de pago adicional

Modifique el programa para que la información de pago adicional pueda manejarse de manera más general.

Hágalo de modo que el usuario pueda configurar estas variables:

extra_pago_inicio_mes = 61
extra_pago_fin_mes = 108
extra_pago = 1000

Haga que el programa mire estas variables y calcule el total pagado adecuadamente.

¿Cuánto pagará Dave si paga $1000 adicionales al mes durante 4 años a partir de la primera ya se han pagado cinco años?

Ejercicio 1.10: Crear una tabla

Modifique el programa para imprimir una tabla que muestre el mes, el total pagado hasta el momento y el capital restante.

La salida debería verse así:

1 2684.11 499399.22
2 5368.22 498795.94
3 8052.33 498190.15
4 10736.44 497581.83
5 13420.55 496970.98
...
308 874705.88 3478.83
309 877389,99 809,21
310 880074.1 -1871.53
Total pagado 880074,1
Meses 310

Ejercicio 1.11: Bono

Mientras lo hace, corrija el programa para corregir el pago en exceso que se produjo en el último mes.

Ejercicio 1.12: Un misterio

int() y float() se pueden usar para convertir números.

Por ejemplo:

>>> int("123")
123
>>> float("1.23")
1.23
>>>

Con eso en mente, ¿puede explicar este comportamiento?

>>> bool("False")
True
>>>

1.4 Cadenas

Esta sección presenta formas de trabajar con texto.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.4.1: Representando texto literal

Los literales de cadena se escriben en programas con comillas.

# Comillas simples
a = 'Sí, pero no, pero sí, pero ...'

# Comillas dobles
b = "la computadora dice que no"

# Comillas triples
c = '''
Mírame a los ojos, mírame a los ojos, los ojos, los ojos, los ojos, no alrededor de los ojos, no mires alrededor de los ojos, mírame a los ojos, estás debajo.
'''

Normalmente, las cadenas solo pueden abarcar una sola línea. Las comillas triples capturan todo el texto incluido en varias líneas incluido todo el formato.

No hay diferencia entre usar simple (') versus doble (") citas. Sin embargo, se debe utilizar el mismo tipo de cita que se utiliza para iniciar una cadena como para terminarla.

1.4.2: Código de escape de cadenas

Los códigos de escape se utilizan para representar caracteres de control y caracteres que no se pueden escribir fácilmente directamente en el teclado. A continuación, se muestran algunos códigos de escape comunes:

'\n' salto de línea
'\r' Retorno de carro
'\t' Pestaña
'\'' Literal comilla simple
'\'  Literal comillas dobles
'\\' Barra invertida literal

1.4.3: Representación de cadenas

Cada carácter de una cadena se almacena internamente como un denominado "punto de código" Unicode, que es un entero. Puede especificar un valor de punto de código exacto mediante las siguientes secuencias de escape:

a = '\xf1'          # a = 'ñ'
b = '\u2200'        # b = '∀'
c = '\U0001D122'    # c = '𝄢'
d = '\N{FOR ALL}'   # d = '∀'

La [Base de datos de caracteres Unicode] (https://unicode.org/charts) es una referencia para todos los códigos de caracteres disponibles.

1.4.4: Indexación de cadenas

Las cadenas funcionan como una matriz para acceder a caracteres individuales. Utiliza un índice entero, comenzando en 0. Los índices negativos especifican una posición relativa al final de la cadena.

a = 'Hello world'
b = a[0]          # 'H'
c = a[4]          # 'o'
d = a[-1]         # 'd' (final de la cadena)

También puede dividir o seleccionar subcadenas especificando un rango de índices con :.

d = a[:5]     # 'Hello'
e = a[6:]     # 'world'
f = a[3:8]    # 'lo wo'
g = a[-5:]    # 'world'

El carácter del índice final no está incluido. Los índices que faltan asumen el principio o el final de la cadena.

1.4.5: Operaciones de cadena

Concatenación, tamaño, pertenencia y replicación.

# concatenación (+)
a = 'Hello' + 'World'   # 'HelloWorld'
b = 'Say ' + a          # 'Say HelloWorld'

# tamaño (len)
s = 'Hello'
len(s)                  # 5

# prueba de pertenencia (`in`, `not in`)
t = 'e' in s            # True
f = 'x' in s            # False
g = 'hi' not in s       # True

# replicación (s * n)
rep = s * 5             # 'HelloHelloHelloHelloHello'

1.4.6: Metodos de cadena

Las cadenas tienen métodos que realizan varias operaciones con los datos de la cadena.

Ejemplo: eliminar cualquier espacio en blanco inicial / final.

s = '  Hello '
t = s.strip()     # 'Hello'

Ejemplo: conversión de casos.

s = 'Hello'
l = s.lower()     # 'hello'
u = s.upper()     # 'HELLO'

Ejemplo: Reemplazo de texto.

s = 'Hello world'
t = s.replace('Hello' , 'Hallo')   # 'Hallo world'

Otros metodos de cadena

Las cadenas tienen una amplia variedad de otros métodos para probar y manipular los datos de texto.

Esta es una pequeña muestra de métodos:

s.endswith(sufijo)   # Compruebe si la cadena termina con sufijo
s.find(t)            # Primera aparición de t en s
s.index(t)           # Primera aparición de t en s
s.isalpha()          # Comprueba si los caracteres son alfabéticos
s.isdigit()          # Comprueba si los caracteres son numéricos
s.islower()          # Comprueba si los caracteres son minúsculas
s.isupper()          # Comprueba si los caracteres están en mayúsculas
s.join(slist)        # Únase a una lista de cadenas usando s como delimitador
s.lower()            # Convertir a minúsculas
s.replace(antiguo, nuevo) # Reemplazar texto
s.rfind(t)           # Busca t desde el final de la cadena
s.rindex(t)          # Busca t desde el final de la cadena
s.split([delim])     # Dividir cadena en lista de subcadenas
s.startswith(prefix) # Compruebe si la cadena comienza con prefijo
s.strip()            # Franja el espacio inicial / final
s.upper()            # Convertir a mayúsculas

1.4.7: Mutabilidad de cadenas

Las cadenas son "inmutables" o de solo lectura. Una vez creado, el valor no se puede cambiar.

>>> s = 'Hello World'
>>> s[1] = 'a'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>

Todas las operaciones y métodos que manipulan datos de cadenas, siempre crean cadenas nuevas.

1.4.8: Conversiones de cadena

Utilice str () para convertir cualquier valor en una cadena. El resultado es una cadena que sostiene el mismo texto que habría sido producido por la declaración print ().

>>> x = 42
>>> str(x)
'42'
>>>

1.4.9: Cadenas byte

Una cadena de bytes de 8 bits, que se encuentra comúnmente con I/O de bajo nivel, se escribe de la siguiente manera:

data = b'Hola Mundo\r\n'

Al poner una b pequeña antes de la primera cita, especificas que es una cadena de bytes en lugar de una cadena de texto.

La mayoría de las operaciones habituales con cadenas funcionan.

len(data)                         # 13
data[0:5]                         # b'Hola'
data.replace(b'Hello', b'Cruel')  # b'Cruel Mundo\r\n'

La indexación es un poco diferente porque devuelve valores de bytes como números enteros.

data[0]   # 72 (ASCII code for 'H')

Conversion to/from text strings.

text = data.decode('utf-8') # bytes -> texto
data = text.encode('utf-8') # texto -> bytes

El argumento 'utf-8' especifica una codificación de caracteres. Otros comunes los valores incluyen 'ascii' y' latin1'.

1.4.10: Cadenas crudas

Las cadenas sin formato son literales de cadena con una barra invertida no interpretada. Se especifican anteponiendo la cita inicial con una "r" minúscula.

>>> rs = r'c:\newdata\test' # Sin formato (barra invertida no interpretada)
>>> rs
'c:\\newdata\\test'

La cadena es el texto literal incluido adentro, exactamente como se escribe. Esto es útil en situaciones en las que la barra invertida tiene significado. Ejemplo: nombre de archivo, expresiones regulares, etc.

1.4.11: Cadenas `f`

Una cadena con sustitución de expresión formateada.

>>> nombre = 'IBM'
>>> acciones = 100
>>> precio = 91.1
>>> a = f'{nombre:>10s} {acciones:10d} {precio:10.2f}'
>>> a
'       IBM        100      91.10'
>>> b = f'Costo = ${acciones * precio:0.2f}'
>>> b
'Costo = $9110.00'
>>>

Nota: Esto requiere Python 3.6 o más reciente. El significado de los códigos de formato se explica más adelante.

1.4.12: Ejercicios

En estos ejercicios, experimentará con operaciones en Python tipo de cadena. Debe hacer esto en el indicador interactivo de Python donde puede ver fácilmente los resultados.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

Nota IMPORTANTE:

En los ejercicios en los que se supone que debe interactuar con el intérprete, >>> es el indicador del intérprete que obtienes cuando Python quiere que escriba una nueva declaración. Algunas declaraciones en el período de ejercicios varias líneas: para que se ejecuten estas declaraciones, es posible que deba presionar 'volver' unas cuantas veces. Solo un recordatorio de que * NO * escribe el >>> al trabajar con estos ejemplos.

Empiece por definir una cadena que contenga una serie de símbolos de cotización bursátil como este:

>>> symbols = 'AAPL,IBM,MSFT,YHOO,SCO'
>>>

Ejercicio 1.13: Extracción de caracteres individuales y subcadenas

Las cadenas son matrices de caracteres. Intente extraer algunos caracteres:

>>> symbols[0]
?
>>> symbols[1]
?
>>> symbols[2]
?
>>> symbols[-1]        # Ultimo caracter
?
>>> symbols[-2]        # Indices negativos son desde el final
?
>>>

En Python, las cadenas son de solo lectura. Verifique esto intentando cambiar el primer carácter de symbols a una minúscula 'a'.

>>> symbols[0] = 'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>>

Ejercicio 1.14: Concatenación de caracteres

Although string data is read-only, you can always reassign a variable to a newly created string.

Try the following statement which concatenates a new symbol "GOOG" to the end of symbols:

>>> symbols = symbols + 'GOOG'
>>> symbols
'AAPL,IBM,MSFT,YHOO,SCOGOOG'
>>>

¡Ups! Eso no es lo que querías. Corríjelo para que la variable symbols contenga el valor'AAPL, IBM, MSFT, YHOO, SCO, GOOG'.

>>> symbols = ?
>>> symbols
'AAPL,IBM,MSFT,YHOO,SCO,GOOG'
>>>

Agregue 'HPQ' al frente de la cuerda

>>> symbols = ?
>>> symbols
'HPQ,AAPL,IBM,MSFT,YHOO,SCO,GOOG'
>>>

En estos ejemplos, puede parecer que la cadena original está siendo modificado, en una aparente violación de que las cadenas sean de solo lectura. No entonces. Las operaciones en cadenas crean una cadena completamente nueva cada una hora. Cuando se reasigna el nombre de la variable símbolos, apunta al cadena recién creada. Posteriormente, la cuerda vieja se destruye ya que ya no se usa.

Ejercicio 1.15: Pruebas de membresía

Experimente con el operador "in" para buscar subcadenas. En el mensaje interactivo, pruebe estas operaciones:

>>> 'IBM' in symbols
?
>>> 'AA' in symbols
True
>>> 'CAT' in symbols
?
>>>

¿Por qué la comprobación de 'AA' devolvió True?

Ejercicio 1.16: Métodos de cadenas

En el indicador interactivo de Python, intente experimentar con algunos de los métodos de cadena.

>>> symbols.lower()
?
>>> symbols
?
>>>

Recuerde, las cadenas siempre son de solo lectura. Si desea guardar el resultado de una operación, debe colocarlo en una variable:

>>> lowersyms = symbols.lower()
>>>

Pruebe algunas operaciones más:

>>> symbols.find('MSFT')
?
>>> symbols[13:17]
?
>>> symbols = symbols.replace('SCO','DOA')
>>> symbols
?
>>> name = '   IBM   \n'
>>> name = name.strip()    # Remove surrounding whitespace
>>> name
?
>>>

Ejercicio 1.17: f-strings

A veces desea crear una cadena e incrustar los valores de variables en él.

Para hacer eso, use una f-string. Por ejemplo:

>>> nombre = 'IBM'
>>> acciones = 100
>>> precio = 91.1
>>> f'{acciones} acciones de {nombre} a ${precio:0.2f}'
'100 acciones de IBM a $91.10'
>>>

Modifique el programa de hipoteca Dave mortgage.py del Ejercicio 1.10 para crear su salida usando f-strings. Intente hacer que la salida esté bien alineada.

Ejercicio 1.18: Expresiones regulares

Una limitación de las operaciones básicas con cadenas es que no admite cualquier tipo de coincidencia de patrones avanzada. Por eso tu Necesito recurrir al módulo re y las expresiones regulares de Python. El manejo de expresiones regulares es un gran tema, pero aquí hay un breve ejemplo:

>>> text = 'Today is 3/27/2018. Tomorrow is 3/28/2018.'
>>> # Find all occurrences of a date
>>> import re
>>> re.findall(r'\d+/\d+/\d+', text)
['3/27/2018', '3/28/2018']
>>> # Replace all occurrences of a date with replacement text
>>> re.sub(r'(\d+)/(\d+)/(\d+)', r'\3-\1-\2', text)
'Today is 2018-3-27. Tomorrow is 2018-3-28.'
>>>

Para obtener más información sobre el módulo re, consulte la documentación oficial en https://docs.python.org/library/re.html.

Algunos comentarios

A medida que comienza a experimentar con el intérprete, a menudo desea conocer más sobre las operaciones soportadas por diferentes objetos. Por ejemplo, ¿cómo averigua qué operaciones están disponibles en un cadena?

Dependiendo de su entorno de Python, es posible que pueda ver una lista de los métodos disponibles mediante el completado con tabulación. Por ejemplo, intente escribir esta:

>>> s = 'hello world'
>>> s.<tab key>
>>>

Si presionar tab no hace nada, puede volver al función incorporada dir(). Por ejemplo:

>>> s = 'hello'
>>> dir(s)
['__add__', '__class__', '__contains__', ..., 'find', 'format',
'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit',
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
'title', 'translate', 'upper', 'zfill']
>>>

dir() produce una lista de todas las operaciones que pueden aparecer después de (.). Utilice el comando help() para obtener más información sobre una operación específica:

>>> help(s.upper)
Help on built-in function upper:

upper(...)
    S.upper() -> string

    Return a copy of the string S converted to uppercase.
>>>

1.5 Listas

Esta sección presenta listas, el tipo principal de Python para contener una colección ordenada de valores.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.5.1: Creando una lista

Utilice corchetes para definir un literal de lista:

nombres = [ 'Elwood', 'Jake', 'Curtis' ]
numeros = [39, 38, 42, 65, 111]

En ocasiones las listas son creadas por otros metodos. Por ejemplo, una cadena puede ser dividida haciendo uso del método split().

>>> linea = 'GOOG,100,490.10'
>>> fila = line.split(',')
>>> fila
['GOOG', '100', '490.10']
>>>

1.5.2: Operaciones de lista

Las listas pueden contener elementos de cualquier tipo. Agregue un nuevo elemento usando append():

nombres.append('Murphy')    # Agrega al final
nombres.insert(2, 'Aretha') # Inserta en el medio

Use + para concatenar listas:

s = [1, 2, 3]
t = ['a', 'b']
s + t           # [1, 2, 3, 'a', 'b']

Las listas están indexadas por números enteros. A partir de 0.

nombres = [ 'Elwood', 'Jake', 'Curtis' ]

nombres[0]  # 'Elwood'
nombres[1]  # 'Jake'
nombres[2]  # 'Curtis'

Los índices negativos cuentan desde el final.

nombres[-1] # 'Curtis'

Puede cambiar cualquier elemento de una lista.

nombres[1] = 'Joliet Jake'
nombres  # [ 'Elwood', 'Joliet Jake', 'Curtis' ]

Length of the list.

nombres = ['Elwood','Jake','Curtis']
len(nombres)  # 3

Prueba de pertenencia (in, not in)

'Elwood' in nombres       # True
'Britney' not in nombres  # True

Replicación (s * n).

s = [1, 2, 3]
s * 3   # [1, 2, 3, 1, 2, 3, 1, 2, 3]

1.5.3: Iteracion de lista y búsqueda

Utilice for para iterar sobre el contenido de la lista.

for nombre in nombres:
    # use nombre
    # e.g. print(nombre)
    ...

Esto es similar a una declaración foreach de otros lenguajes de programación.

Para encontrar la posición de algo rápidamente, use index().

nombres = ['Elwood','Jake','Curtis']
nombres.index('Curtis')   # 2

Si el elemento está presente más de una vez, index() devolverá el índice de la primera aparición.

Si el elemento no se encuentra, generará una excepción "ValueError".

1.5.4: Remoción en lista

Puede eliminar elementos por valor de elemento o por índice:

# Using the value
nombres.remove('Curtis')

# Using the index
del nombres[1]

Eliminar un artículo no crea un agujero. Otros elementos se moverán hacia abajo para llenar el espacio desocupado. Si hay más de una aparición del elemento, remove() eliminará solo la primera aparición.

1.5.5: Ordenar una lista

Las listas se pueden ordenar "in situ".

s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']

Utilice sorted() si desea crear una nueva lista en su lugar:

t = sorted(s)  # s sin cambios, t tiene los valores ordenados

1.5.6: Listas y matemáticas

Caution: Lists were not designed for math operations.

>>> nombres = [1, 2, 3, 4, 5]
>>> nombres * 2
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
>>> nombres + [10, 11, 12, 13, 14]
[1, 2, 3, 4, 5, 10, 11, 12, 13, 14]

Específicamente, las listas no representan vectores/matrices como en MATLAB, Octave, R, etc. Sin embargo, existen algunos módulos/paquetes/librerías que le ayudan con eso (e.g. numpy)

1.5.7: Ejercicios

En este ejercicio, experimentaremos con listas. En la ultima sección trabajamos con cadenas conteniendo símbolos de acciones de bolsa valores.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

>>> symbols = 'HPQ,AAPL,IBM,MSFT,YHOO,DOA,GOOG'

Divida la cadena en una lista de nombres haciendo uso de la operacion split() de cadenas:

>>> symlist = symbols.split(',')

Ejercicio 1.19: Extracción y reasignación de elementos

Pruebe algunas busquedas:

>>> symlist[0]
'HPQ'
>>> symlist[1]
'AAPL'
>>> symlist[-1]
'GOOG'
>>> symlist[-2]
'DOA'
>>>

Intente reasignar un valor:

>>> symlist[2] = 'AIG'
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'DOA', 'GOOG']
>>>

Agarre unos pedazos:

>>> symlist[0:3]
['HPQ', 'AAPL', 'AIG']
>>> symlist[-2:]
['DOA', 'GOOG']

Crea una lista vacía y agregue un elemento.

>>> mysyms = []
>>> mysyms.append('GOOG')
>>> mysyms
['GOOG']

Puede reasignar una porción de la lista a otra lista. Por ejemplo:

>>> symlist[-2:] = mysyms
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG']
>>>

Cuando hace esto, la lista en el lado izquierdo (symlist) será reajustada apropiadamente para que el lado derecho (mysyms) ocupe un puesto en ella.

Ejercicio 1.20: Ciclando sobre una lista

El ciclo/bucle for funciona ciclando sobre data en una secuencia la lista. Pruebe lo siguiente:

>>> for s in symlist:
...     print('s =', s)

Ejercicio 1.21: Pruebas de pertenencia

Utilice el operador in o not in para comprobar si 'AIG','AA' y 'CAT' están en la lista de símbolos.

>>> # Está 'AIG' en `symlist`?
True
>>> # Está 'AA' en `symlist`?
False
>>> # 'CAT' no esta en `symlist`?
True
>>>

Ejercicio 1.22: Añadiendo, insertando y borrando elementos

Utilice el método append() para agregar el símbolo 'RHT' al final desymlist.

>>> # agregue 'RHT'
>>> symlist
['HPQ', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']
>>>

Utilice el método insert() para insertar el símbolo 'AA' como el segundo elemento de la lista.

>>> # Agregue 'AA' como segundo item en la lista
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'MSFT', 'YHOO', 'GOOG', 'RHT']
>>>

Utilice el método remove() para eliminar 'MSFT' de la lista.

>>> # Remueva 'MSFT'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT']
>>>

Añada una entrada duplicada para 'YHOO' al final de la lista.

Nota: está perfectamente bien si una lista tenga valores duplicados.

>>> # Append 'YHOO'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'YHOO', 'GOOG', 'RHT', 'YHOO']
>>>

Utilice el método index() para encontrar la primera posición de 'YHOO' en la lista.

>>> # Encuentre el primer índice de 'YHOO'
4
>>> symlist[4]
'YHOO'
>>>

Cuente cuántas veces 'YHOO' está en la lista:

>>> symlist.count('YHOO')
2
>>>

Remueva la primera ocurrencia de 'YHOO'.

>>> # Remueva primera ocurrencia de 'YHOO'
>>> symlist
['HPQ', 'AA', 'AAPL', 'AIG', 'GOOG', 'RHT', 'YHOO']
>>>

Para su información, no existe ningún método para buscar o eliminar todas las apariciones de un elemento Sin embargo, veremos una forma elegante de hacer esto en la sección 2.

Ejercicio 1.23: Ordernando

¿Quieres ordenar una lista? Utilice el método sort(). Pruébalo:

>>> symlist.sort()
>>> symlist
['AA', 'AAPL', 'AIG', 'GOOG', 'HPQ', 'RHT', 'YHOO']
>>>

¿Quiere ordenar al revés? Prueba esto:

>>> symlist.sort(reverse=True)
>>> symlist
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']
>>>

Nota: ordenar una lista modifica su contenido "en el lugar". Es decir, los elementos de la lista se mezclan, pero no se crea una nueva lista como resultado.

Ejercicio 1.24: Ajuntando todo nuevamente

¿Quiere tomar una lista de cadenas y unirlas en una sola cadena? Utilice el método join () de cadenas como esta (nota: esto se ve gracioso al principio).

>>> a = ','.join(symlist)
>>> a
'YHOO,RHT,HPQ,GOOG,AIG,AAPL,AA'
>>> b = ':'.join(symlist)
>>> b
'YHOO:RHT:HPQ:GOOG:AIG:AAPL:AA'
>>> c = ''.join(symlist)
>>> c
'YHOORHTHPQGOOGAIGAAPLAA'
>>>

Ejercicio 1.25: Listas de cualquier cosa

Las listas pueden contener cualquier tipo de objeto, incluidas otras listas (por ejemplo, listas anidadas). Probar esto:

>>> nums = [101, 102, 103]
>>> items = ['spam', symlist, nums]
>>> items
['spam', ['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA'], [101, 102, 103]]

Preste mucha atención a la salida anterior. items es una lista con tres elementos. El primer elemento es una cadena, pero los otros dos elementos son listas.

Puede acceder a los elementos de las listas anidadas mediante varias operaciones de indexación.

>>> items[0]
'spam'
>>> items[0][0]
's'
>>> items[1]
['YHOO', 'RHT', 'HPQ', 'GOOG', 'AIG', 'AAPL', 'AA']
>>> items[1][1]
'RHT'
>>> items[1][1][2]
'T'
>>> items[2]
[101, 102, 103]
>>> items[2][1]
102
>>>

Aunque técnicamente es posible hacer estructuras muy complicadas compuestas por listas, como regla general, es preferible mantener las cosas simples.

Por lo general, las listas contienen elementos que tienen el mismo tipo de valor. Por ejemplo, una lista que consta completamente de números o una lista de texto de cadena. Mezclar diferentes tipos de datos en la misma lista es a menudo un buen dolor de cabeza, por lo que es mejor evitarlo.

1.6 Archivos

La mayoría de los programas necesitan leer la entrada de algún lugar. Esta sección discute sobre el acceso a archivos.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.6.1: Entrada y Salida de un Archivo

Abre un archivo.

f = open('foo.txt', 'rt')     # Open for reading (text)
g = open('bar.txt', 'wt')     # Open for writing (text)

Lee toda la data.

data = f.read()
data = f.read([maxbytes])  # Read only up to 'maxbytes' bytes

Escribe algo de texto.

g.write('some text')

Cierra cuando terminas.

f.close()
g.close()

Files should be properly closed and it's an easy step to forget. Thus, the preferred approach is to use the with statement like this.

with open(filename, 'rt') as file:
    # Haz uso del archivo "file"
    ...
    # No hay necesidad de cerrar explícitamente
...statements

Esto cierra automáticamente el archivo cuando el control abandona el bloque de código con sangría.

1.6.2: Patrones comunes de lectura de archivos

Leer un archivo completo de una vez como una cadena.

with open('foo.txt', 'rt') as file:
    data = file.read()
    # `data` is a string with all the text in `foo.txt`

Leer un archivo línea por línea iterando.

with open(filename, 'rt') as file:
    for line in file:
        # Process the line

1.6.3: Patrones comunes de escritura de archivos

Escribe data en cadena.

with open('outfile', 'wt') as out:
    out.write('Hello World\n')
    ...

Redireccionando la función de impresión.

with open('outfile', 'wt') as out:
    print('Hola Mundo', file=out)
    ...

1.6.4: Ejercicios

Estos ejercicios dependen de un archivo Data/portfolio.csv. El archivo contiene una lista de líneas con información sobre una cartera de acciones. Se supone que está trabajando en el archivo ./Work/ directorio.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.26: Prerequisitos

Primero, intente leer todo el archivo a la vez en una cadena grande:

>>> with open('Data/portfolio.csv', 'rt') as f:
        data = f.read()

>>> data
'name,shares,price\n"AA",100,32.20\n"IBM",50,91.10\n"CAT",150,83.44\n"MSFT",200,51.23\n"GE",95,40.37\n"MSFT",50,65.10\n"IBM",100,70.44\n'
>>> print(data)
name,shares,price
"AA",100,32.20
"IBM",50,91.10
"CAT",150,83.44
"MSFT",200,51.23
"GE",95,40.37
"MSFT",50,65.10
"IBM",100,70.44
>>>

En el ejemplo anterior, cabe señalar que Python tiene dos modos de salida. En el primer modo, donde aparece ">>> data" en el indicador, Python muestra la representación de la cadena sin procesar, incluidas las comillas y códigos de escape. Cuando escribe print(data), obtiene el formato real de salida de la cadena.

Para leer un archivo línea por línea, use un bucle for como éste:

>>> with open('Data/portfolio.csv', 'rt') as f:
        for line in f:
            print(line, end='')

name,shares,price
"AA",100,32.20
"IBM",50,91.10
...
>>>

En determinadas ocasiones, es posible que desee leer u omitir manualmente una única línea de texto (por ejemplo, tal vez desee omitir la primera línea de los encabezados de columna).

>>> f = open('Data/portfolio.csv', 'rt')
>>> headers = next(f)
>>> headers
'name,shares,price\n'
>>> for line in f:
    print(line, end='')

"AA",100,32.20
"IBM",50,91.10
...
>>> f.close()
>>>

next() devuelve la siguiente línea de texto en el archivo. Si lo llamara repetidamente, obtendría líneas sucesivas. Sin embargo, para que lo sepa, el ciclo for hace uso denext() para obtener sus datos. Por lo tanto, normalmente no lo llamaría directamente a menos que esté tratando de omitir o leer explícitamente una sola línea como se muestra.

Una vez que esté leyendo las líneas de un archivo, puede comenzar a realizar más procesamiento, como dividir.

Por ejemplo, intente esto:

>>> f = open('Data/portfolio.csv', 'rt')
>>> headers = next(f).split(',')
>>> headers
['name', 'shares', 'price\n']
>>> for line in f:
    row = line.split(',')
    print(row)

['"AA"', '100', '32.20\n']
['"IBM"', '50', '91.10\n']
...
>>> f.close()

Nota: En estos ejemplos, f.close() se llama explícitamente porque no se utiliza la instrucción with.

Ejercicio 1.27: Leyendo de un archivo

Ahora que sabe cómo leer un archivo, escribamos un programa para realizar un cálculo.

Las columnas de portfolio.csv corresponden al nombre de la acción, número de acciones, y precio de compra de una sola participación accionaria. Escribe un programa llamado pcost.py que abre este archivo, lee todas las líneas y calcula cuánto costó comprar todas las acciones en la cartera (portfolio).

Sugerencia: para convertir una cadena en un entero, use int(s). Para convertir una cadena en punto flotante, use float(s).

Su programa debería imprimir un resultado como el siguiente:

Costo total 44671.15

Ejercicio 1.28: Otro tipo de "archivos"

¿Y si quisiera leer un archivo que no es de texto, como un archivo comprimido gzip? La función integrada open() no le ayudará aquí, pero Python tiene un módulo gzip que puede leer archivos comprimidos gzip.

>>> import gzip
>>> with gzip.open('Data/portfolio.csv.gz', 'rt') as f:
    for line in f:
        print(line, end='')

... mira la salida ...
>>>

Nota: Incluir el modo de archivo de 'rt' es fundamental aquí. Si olvidas eso obtendrá cadenas de bytes en lugar de cadenas de texto normales.

Algunos comentarios

Los científicos de datos se apresuran a señalar que librerias como Pandas ya tienen una función para leer archivos CSV. Esto es cierto y funciona bastante bien. Sin embargo, este no es un curso sobre cómo aprender pandas. Leer archivos es un problema más general que las específicaciones de archivos CSV.

La razón principal por la que trabajamos con un archivo CSV es porque es un formato conocido para la mayoría de los programadores y es relativamente fácil trabajarlo directamente - ilustrando muchas características de Python en el proceso. Entonces, por supuesto, use Pandas cuando regrese al trabajo. Para el resto de este curso, sin embargo, vamos a seguir con la funcionalidad estándar de Python.

1.7 Funciones

A medida que sus programas comiencen a crecer, va a querer organizarse. Esta sección presenta brevemente las funciones y los módulos de la biblioteca estándar. También se introduce el manejo de errores con excepciones.

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

1.7.1: Funciones personalizadas

Utilice funciones para el código que desea reutilizar. Aquí hay una definición de función:

def sumcount(n):
    '''
    Retorna la suma de los primeros n enteros
    '''
    total = 0
    while n > 0:
        total += n
        n -= 1
    return total

Para llamar una función.

a = sumcount(100)

Una función es una serie de declaraciones que realizan alguna tarea y devuelven un resultado. La palabra clave return es necesaria para especificar explícitamente el valor de retorno de la función.

1.7.2: Funciones de biblioteca

Python viene con una gran biblioteca estándar. Se accede a los módulos de la biblioteca usando import. Por ejemplo:

import math
x = math.sqrt(10)

import urllib.request
u = urllib.request.urlopen('http://www.python.org/')
data = u.read()

Cubriremos bibliotecas y módulos con más detalle más adelante.

1.7.3: Errores y excepciones

Las funciones informan sobre errores como las excepciones. Una excepción provoca la interrupción de una función y puede hacer que todo el programa se detenga si no se maneja.

Prueba esto en tu REPL (read/lee, evaluate/evalua, print/imprime, cicla/loop) de Python.

>>> int('N/A')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'N/A'
>>>

Para fines de depuración, el mensaje describe lo que sucedió, dónde ocurrió el error, y un rastreo que muestra las otras llamadas a funciones que provocaron la falla.

1.7.4: Atrapando y gestionando excepciones

Las excepciones de pueden atrapar y gestionar.

Para atrapar, use la declaración try - except.

for linea in f:
    campos = linea.split()
    try:
        acciones = int(campos[1])
    except ValueError:
        print("No se pudo analizar", linea)
    ...

El nombre "ValueError" debe coincidir con el tipo de error que está intentando detectar.

A menudo es difícil saber exactamente qué tipo de errores pueden ocurrir de antemano dependiendo de la operación que se esté realizando. Para mejor o para peor, el manejo de excepciones a menudo se agrega después de que un programa falló inesperadamente (es decir, "oh, nos olvidamos de detectar ese error, debería gestionar eso! ").

1.7.5: Generando excepciones

Para generar una excepción, use la instrucción raise.

raise RuntimeError('Que desorden')

Esto hará que el programa se anule con un rastreo de excepción. A menos que sea atrapado por un bloque "try-except".

$ python3 foo.py
Traceback (most recent call last):
  File "foo.py", line 21, in <module>
    raise RuntimeError("Que desorden")
RuntimeError: What a kerfuffle

1.7.6: Ejercicios

Nota: si desea hacer esta sección online, hemos puesto a disposición un editor, consola Python y terminal Linux en repl.it. De lo contrario, tendrá que ejecutar instrucciones en su ordenador

Ejercicio 1.29: Definiendo una función

Intente definir una función simple:

>>> def saludo(nombre):
        'Genera un saludo'
        print('Hola', nombre)

>>> saludo('Guido')
Hola Guido
>>> saludo('Paula')
Hola Paula
>>>

Si la primera declaración de una función es una cadena, sirve como documentación.

Intente escribir un comando como help(saludo) para que se muestre.

Ejercicio 1.30: Convirtiendo una secuencia de comandos en una función

Tome el código que escribió para el programa pcost.py en el Ejercicio 1.27 y conviértalo en una función cartera_costo(nombre_de_archivo). La función toma un nombre de archivo como entrada, lee los datos de la cartera en ese archivo y devuelve el costo total de la cartera como flotante.

Para usar su función, cambie su programa para que se vea algo así:

def cartera_costo(nombre_de_archivo):
    ...
    # Su código aquí
    ...

costo = cartera_costo('Data/portfolio.csv')
print('Total cost:', costo)

Cuando ejecute su programa, debería ver el mismo resultado que antes.

Después de ejecutar su programa, también puede llamar a su función interactivamente escribiendo esto:

$ python3 -i pcost.py

Esto le permitirá llamar a su función desde el modo interactivo.

>>> cartera_costo('Data/portfolio.csv')
44671.15
>>>

Being able to experiment with your code interactively is useful for testing and debugging.

Ejercicio 1.31: Administración de errores

¿Qué sucede si prueba su función en un archivo al que le faltan algunos campos?

>>> cartera_costo('Data/missing.csv')
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "pcost.py", line 11, in cartera_costo
    nshares    = int(fields[1])
ValueError: invalid literal for int() with base 10: ''
>>>

En este momento, tiene que tomar una decisión. Para que el programa funcione puede depurar el archivo de entrada eliminando las líneas o puede modificar su código para manejar las líneas defectuosas de alguna forma.

Modifique el programa pcost.py para detectar la excepción, imprima una advertencia mensaje y continúe procesando el resto del archivo.

Ejercicio 1.32: Usando una función de biblioteca local

Python viene con una biblioteca estándar de funciones útiles.

Una biblioteca que podría ser útil aquí es el módulo csv. Debe usarlo siempre que tenga que trabajar con archivos de datos CSV.

A continuación, se muestra un ejemplo de cómo funciona:

>>> import csv
>>> f = open('Data/portfolio.csv')
>>> rows = csv.reader(f)
>>> headers = next(rows)
>>> headers
['name', 'shares', 'price']
>>> for row in rows:
        print(row)

['AA', '100', '32.20']
['IBM', '50', '91.10']
['CAT', '150', '83.44']
['MSFT', '200', '51.23']
['GE', '95', '40.37']
['MSFT', '50', '65.10']
['IBM', '100', '70.44']
>>> f.close()
>>>

Una cosa buena sobre el módulo csv es que se ocupa de una variedad de detalles de bajo nivel como las comillas y la división adecuada por comas. En la salida anterior, notará que ha eliminado las comillas dobles lejos de los nombres en la primera columna.

Modifique su programa pcost.py para que use el módulocsv para analizar e intentar ejecutar ejemplos anteriores.

Ejercicio 1.33: Leyendo desde la línea de comando

En el programa pcost.py, el nombre del archivo de entrada se ha integrado en el código:

# pcost.py

def cartera_costo(filename):
    ...
    # Su código aquí
    ...

costo = cartera_costo('Data/portfolio.csv')
print('Total costo:', costo)

Está bien para aprender y probar, pero en un programa real probablemente no haría eso. En su lugar, pudiera pasar el nombre del archivo como argumento a un archivo con una secuencia de comandos.

Intente cambiar la parte inferior del programa de la siguiente manera:

# pcost.py
import sys

def cartera_costo(filename):
    ...
    # Su código aquí
    ...

if len(sys.argv) == 2:
    filename = sys.argv[1]
else:
    filename = 'Data/portfolio.csv'

costo = cartera_costo(filename)
print('Total costo:', costo)

sys.argv es una lista que contiene argumentos pasados en la línea de comando (si los hay).

Para ejecutar su programa, deberá ejecutar Python desde la terminal.

Por ejemplo, desde bash en Unix:

bash % python3 pcost.py Data/portfolio.csv
Total cost: 44671.15
bash %

1. Intro a Python

1.1 Introduciendo Python

1.1.1: Qué es Python?

1.1.2: Donde consigo Python?

1.1.3: Porqué fue creado?

1.1.4: Dónde está Python en mi Maquina?

1.1.5: Ejercicios

Ejercicio 1.1: Utilizando Python como Calculadora

Ejercicio 1.2: Consiguiendo ayuda

Ejercicio 1.3: Copiar y pegar

Ejercicio 1.4: Donde esta mi bus?

1.2 Un primer programa

1.2.1: Ejecutando Python

1.2.2: Modo interactivo

1.2.3: Creando programas

1.2.4: Ejecutando programas

1.2.5: Un ejemplo

1.2.6: Declaraciones

1.2.7: Comentarios

1.2.8: Variables

1.2.9: Tipos

1.2.10: Casos Sensitivos

1.2.11: Ciclar

1.2.12: Sangrías (las de texto)

Sangrías - Mejores prácticas

1.2.13: Condicionales

1.2.14: Imprimiendo

1.2.15: Input (dato de entrada) de usuario

1.2.16: La declaración "pass"

1.2.17: Ejercicios

Ejercicio 1.5: El rebote

Ejercicio 1.6: Depuración

1.3 Números

1.3.1: Tipos de numeros

1.3.2: Booleanos (bool)

1.3.3: Enteros (int)

1.3.4: Punto flotante (float)

1.3.5: Comparaciones

1.3.6: Convirtiendo numeros

1.3.7: Ejercicios

Ejercicio 1.7: La hipoteca de Dave

Ejercicio 1.8: Pagos adicionales

Ejercicio 1.9: Hacer una calculadora de pago adicional

Ejercicio 1.10: Crear una tabla

Ejercicio 1.11: Bono

Ejercicio 1.12: Un misterio

1.4 Cadenas

1.4.1: Representando texto literal

1.4.2: Código de escape de cadenas

1.4.3: Representación de cadenas

1.4.4: Indexación de cadenas

1.4.5: Operaciones de cadena

1.4.6: Metodos de cadena

Otros metodos de cadena

1.4.7: Mutabilidad de cadenas

1.4.8: Conversiones de cadena

1.4.9: Cadenas byte

1.4.10: Cadenas crudas

1.4.11: Cadenas f

1.4.12: Ejercicios

Ejercicio 1.13: Extracción de caracteres individuales y subcadenas

Ejercicio 1.14: Concatenación de caracteres

Ejercicio 1.15: Pruebas de membresía

Ejercicio 1.16: Métodos de cadenas

Ejercicio 1.17: f-strings

Ejercicio 1.18: Expresiones regulares

Algunos comentarios

1.5 Listas

1.5.1: Creando una lista

1.5.2: Operaciones de lista

1.5.3: Iteracion de lista y búsqueda

1.5.4: Remoción en lista

1.5.5: Ordenar una lista

1.5.6: Listas y matemáticas

1.5.7: Ejercicios

Ejercicio 1.19: Extracción y reasignación de elementos

Ejercicio 1.20: Ciclando sobre una lista

Ejercicio 1.21: Pruebas de pertenencia

Ejercicio 1.22: Añadiendo, insertando y borrando elementos

Ejercicio 1.23: Ordernando

1.4.11: Cadenas `f`