Introduccion A La Programacion en Python 3

INTRODUCCIÓN A LA PROGRAMACIÓN EN PYTHON 3
Python es un lenguaje de programación relativamente fácil de aprender, interpretado, de alto nivel, orientado
a objetos, con tipado dinámico, ampliable con biblioteca de módulos... y que permite un desarrollo rápido de
aplicaciones en diversas áreas y sobre la mayoría de las plataformas.
Está orientado hacia la computación numérica, aunque hay módulos para cálculo simbólico, tratamiento de
datos...
INSTALACIÓN
Online
Plataforma repl.it: Uno de los editores y consola en línea, a través del navegador de internet (por tanto
accesible en cualquier dispositivo), se tiene en la plataforma web https://repl.it/languages, seleccionando el
lenguaje de programación Python (a continuación se muestra la interface con sesión iniciada en repl.it):
En la ventana de la derecha (fondo negro) está la consola (introducir órdenes y ejecutarlas y mostrar
resultados, como en una calculadora) y en la central el editor de programas, que se ejecutan pulsando en run
(icono verde) y mostrando el resultado en la consola. En la figura anterior se muestra el resultado de la
ejecución del programa.
Registrándose (es gratuito) se pueden guardar proyectos a los que se les asigna una url para ejecutar /
modificar o compartir en cualquier momento.
plrp 2019-20 v.7 Página 1

Ordenador
Instalar Python desde el sitio oficial https://www.python.org/ descargando Python 3 para el sistema operativo
correspondiente.
Así en Windows tenemos:
en donde es preferible añadir las rutas al PATH de Windows y realizar una instalación personalizada para
seleccionar la carpeta de instalación, entre otras opciones.
Al finalizar habilitar que el PATH pueda tener más de 260 caracteres:
Se instala un IDLE (Integrated Development and Learning Environment), un entorno interactivo de edición,
que actúa de consola en la que se pueden introducir instrucciones, y pulsar RETURN para obtener
resultados, como en una calculadora:

Si vamos a File, New File se abre un editor de programas en el que teclearemos las instrucciones de un
programa, como en el ejemplo (que calcula el promedio de tres valores, por ejemplo tres calificaciones):
que, después de guardarlo, al ir a Run, Run Module se ejecuta el programa mostrando el resultado en la
consola:

Hay multitud de IDEs. Uno bastante completo es PyScripter (https://sourceforge.net/projects/pyscripter/):
Android
Entre otras aplicaciones podemos instalar QPython3 desde Play Store.
Al abrir la aplicación se muestra la pantalla de la izquierda en la que se puede

escoger la Consola para introducir instrucciones y ejecutarlas una a una (pantalla
central) o escoger Editor para escribir un programa, que se ejecuta pulsando en el triángulo inferior y
mostrando el resultado en la consola.

COMENTARIOS
Cada línea de comentario tiene que comenzar con el carácter almohadilla # (es un delimitador):
#esto es un comentario
VARIABLES
Las variables son una especie de "cajas" de memoria a las que asignamos nombres, que almacenarán
cualquier tipo de dato y que puede ir variando su contenido a lo largo del programa. (Propiamente en Python,
por ser un lenguaje orientado a objetos, las variables son nombres -etiquetas- que se utilizan para referirse a
los objetos que son las “cajas” de memoria en la que están almacenados los datos concretos).
Los nombres de las variables deben empezar por letra o guion bajo y puede seguir con más letras, números o
guiones bajos, o letras mayúsculas (tener en cuenta que Python distingue minúscula de mayúscula). No se
permiten espacios y no se pueden utilizar palabras reservadas del sistema.
En la siguiente línea se almacena el número 5 en la variable a1 (el texto previo a este paréntesis está
redactado utilizando economía del lenguaje, pero deberíamos decir crear el objeto 5 guardándolo en una caja
de memoria a la que asignamos la etiqueta a1, pues será más fácil recordar ese objeto por su etiqueta que por
sus coordenadas en la memoria del ordenador. En resumen, en Python cuando se dice "guardar un valor en
una variable" se debe entender "guardar el valor en un objeto y asociar una variable al objeto"):
a1 = 5
En la siguiente orden se suma 7 al contenido de a1 y se guarda en a1, pasando a1 a contener el valor 12 (se
asigna el valor de la expresión de la derecha a la variable que aparece a la izquierda):
a1 = a1 + 7
Si después de la operación anterior escribimos a1 en la consola y pulsamos RETURN obtendremos el

contenido de a1, es decir 12. Sin embargo, dentro de un programa (o también en la consola) tendremos que
utilizar la función print() para obtener el contenido de a1:
print(a1)
Palabras reservadas
No se pueden utilizar para nombrar variables:
and def from nonlocal while

as del global not with
assert elif if or yield
async else import pass
await except in raise
break false is return
class finally lambda true
continue for none try

OPERADORES MATEMÁTICOS
Los básicos son:
+ (suma) - (resta)
* (multiplicación, que hay que indicar explícitamente), / (división)
** (potencia)
TIPOS DE DATOS BÁSICOS
Valores booleanos
True (cierto) False (falso)
Números
Enteros
Números positivos o negativos que no tienen decimales. Pueden ser de tipo
int (entero, integer)
Máquinas de 32 bits: de -231 a 231-1 (de -2 147 483 648 a 2 147 483 647)
Máquinas de 64 bits: -9 223 372 036 854 775 808 hasta 9 223 372 036 854 775 807
long (largo)
Pueden ser de cualquier precisión, limitada por la memoria de la máquina.
Además también hay octal y hexadecimal.
Reales
Tienen decimales. Se expresan mediante el tipo float, utilizando 64 bits, de doble precisión. Van de
±2,2250738585072020x10-308 hasta ±1,7976931348623157×10308.
La potencia de 10 se representa con la letra e. Así, el número de Avogadro se escribe 6.023e23 (que
es lo mismo que 6,023·1023).
Cadenas de caracteres
Son secuencias de caracteres (palabras o frases) que siempre van encerradas entre comillas, simples o
dobles (son otros delimitadores):
‘Martes’ "es un día de la semana"
aunque es conveniente utilizar el mismo tipo de comillas en un programa.
Las cadenas se pueden concatenar:

‘Martes’ + " " + "es un día de la semana"

se obtendría como resultado:
Martes es un día de la semana
Un valor numérico se convierte a cadena mediante la función str()

a = 6.75
numero = str(a)
Una cadena se convierte en número (siempre que la cadena tenga caracteres numéricos, de lo contrario dará
error) a tipo entero con la función int() (para lo cual no puede haber punto decimal, de lo contrario
tendríamos error), o real con la función float(). Por ejemplo:
valor = "6"
numero_entero = int(valor)
valor = "6.75"
numero_real = float(valor)
Listas
Las listas son un tipo de colección de datos ordenados (otros son las tuplas y los diccionarios). Son como los
arrays o vectores en otros lenguajes, pero con gran flexibilidad. Pueden contener cualquier tipo de dato
(número, cadena, listas dentro de listas... incluso distintos tipos de datos). Se indican entre corchetes y sus
elementos se separan con comas. El primer elemento de la lista es el 0, no el 1.
Dos ejemplos basados en calificaciones (una lista para tres calificaciones numéricas de un alumno, y la otra
para las cualitativas) pueden ser:
cali_numericas = [6.7, 8.25, 9.0]
cali_cualitativas = ["Insuficiente", "Suficiente", "Aprobado", "Notable",
"Sobresaliente"]
Para referirse, por ejemplo, al segundo elemento de la primera lista haremos

cali_numericas[1]
obteniendo el valor 8.25 (recordar que el primer elemento tiene el índice 0).
Para cambiar dicho elemento por el valor 7.75 haremos:

cali_numericas[1] = 7.75
y para imprimir la lista:

print(cali_numericas)
obteniendo [6.7, 7.75, 9.0].
El número de elementos de una lista se obtiene con la función len(), que también se aplica a cadenas. Así,
para la segunda lista
len(cali_cualitativas)
dará como resultado 5.
Para añadir una cuarta calificación, por ejemplo 6.75 a la primea lista, se utiliza el método append:
cali_numericas.append(6.75)

Con range() creamos una lista de elementos sucesivos:
a = range(4)
siendo ahora a = [0, 1, 2, 3].
Asignación de tipos
Las asignación se produce en el momento de crear la variable:

fecha = 2020 #tipo número entero
fecha = 2020.0 #tipo número decimal
fecha = "2020" #tipo fecha
fecha = [19, "enero", 2020] #tipo lista
Definir y asignar valores a varias variables a la vez

a = b = 23 #asigna el valor 23 a la variable a y a la variable b
a, b = 5, 12 #asigna el valor 5 a "a", y el valor 12 a "b"
FUNCIONES INPUT() Y PRINT()
Son las dos funciones básicas de entrada y salida de datos, respectivamente.
Input()
Para introducir por pantalla el nombre Juan y almacenarlo en la variable nombre:

nombre = input()
o bien, de un forma más completa:

nombre = input("Introducir el nombre: ")
Se debe tener en cuenta que todas las entradas por pantalla son de tipo cadena, así si hacemos valor =
input() y tecleamos 5.6 no podremos realizar operaciones con valor tal como valor+5 porque daría
error, pues 5.6 fue almacenado como la cadena "5.6". Para ello deberemos utilizar las funciones int() o
float().
Print()
Escribe en la pantalla el contenido que está entre paréntesis, que puede ser cadena, contenido de una
variable, resultado de expresiones, etc:
nombre = "Juan"
edad = 5 #en años
print(nombre) #salida: Juan
print("Esta persona es ", nombre) #salida: Esta persona es Juan
print("Es ", nombre, " y tiene ", 5*12, " meses") #salida: Es Juan y tiene 60 meses

Las cadenas "f" simplifican la inserción de variables y expresiones en las cadenas. Una cadena "f" contiene
variables y expresiones entre llaves ({}) que se sustituyen directamente por su valor. Las cadenas "f" se
reconocen porque comienzan por una letra f antes de las comillas de apertura:
nombre = "Juan"
edad = 5
print(f"Me llamo {nombre} y tengo {edad} años.")
siendo la salida Me llamo Juan y tengo 5 años.
Otro ejemplo:
valor1 = 5
valor2 = 6
print(f"la suma de {valor1} y {valor2} es {valor1+valor2}.")
obteniendo como resultado la suma de 5 y 6 es 11.
Las cadenas “f” también se pueden emplear en las funciones input():
valor1 = int(input("Introducir un número: "))
valor2 = int(input(f"Introducir un número mayor que {valor1}: "))
CONTROL DE FLUJO DE UN PROGRAMA. ALGUNAS ESTRUCTURAS BÁSICAS
if
Es una estructura de control que permite que un programa ejecute unas instrucciones cuando se cumpla una
condición.
La estructura es:
if condicion:
aquí va el bloque de órdenes que se ejecutan si la condición es cierta
(true), que pueden ocupar varias líneas.
La condición siempre se evalúa. En caso de que sea verdadera se ejecuta el bloque de órdenes que está
formado por las líneas identadas. Notar que después de la condición hay que escribir el símbolo de dos
puntos. Al pulsar RETURN las siguientes líneas se identan automáticamente. Si no están correctamente
identadas esas líneas no se reconocen como bloque a ejecutar en el caso de que la condición sea verdadera.
El bloque termina con la última línea identada. Si la condición es falsa no se ejecuta dicho bloque y el
programa continúa en la primera línea no identada a partir del if.
Algunos operadores lógicos son ==, >, >=, <, <=, ¡= (distinto).
Ejemplo que evalúa si una calificación es suspenso (<5) o aprobado (>=5):

cali_numerica = 6.7
if cali_numerica >= 5:
print(“Aprobado”)

if...else
Tiene dos bloques, el primero se ejecuta cuando la condición es verdadera, el segundo cuando es falsa.
cali_numerica = 6.7
if cali_numerica >=5:
print("Aprobado")
else:
print("Suspenso")
while
Es una estructura de bucle: ejecuta un bloque de código mientras se cumpla la condición.
Un ejemplo muy sencillo que imprime los números pares hasta el 10:
a = 0
while a <= 8:
a = a + 2
print(a)
print("Fin")
Comprueba el valor de a. Si la condición a <= 10 es verdadera entonces imprime el valor de a. Notar que
cuando a alcanza el valor 8 todavía en inferior a 10 e imprimirá el valor de a + 2. Después a pasa a valer 10
y sale del bloque porque ya no se cumple la condición.
Si en el ejemplo anterior queremos que no se imprima el 6 podemos utilizar la instrucción continue, que
hace que no se ejecuten las restantes líneas del bloque while y se continúe con la siguiente iteracción:
a = 0
while a <= 8:
a = a + 2
if a == 6:
continue
else:
print(a)
print("Fin")
Si en este ejemplo nos olvidamos de escribir la instrucción que aumenta el valor de a, el bucle continuará
ejecutándose indefinidamente (bucle infinito), por lo que es necesario tener cuidado.
A veces un bucle infinito es útil; por ejemplo uno en el que el programa repite todo lo que el usuario
introduzca hasta que se escriba, por ejemplo, salir, haciendo que break salga del bucle while:
print("para salir del bucle teclear salir")
while True:
entrada = input("teclear algo: ")
if entrada == "salir":
break
else:
print("se ha tecleado: ", entrada)
print("ha salido del programa")

for ... in
Repite un bloque de código un número determinado de veces.
Ejemplo en el que se imprimen los números del 15 al 18:

for i in range(15, 19):
print(i)
El índice, en este caso la variable i recorre el rango entre el límite inferior (15 en este caso) y el superior (19)
adquiriendo sus valores, pero teniendo en cuenta que no se ejecuta el bloque cuando el índice toma el valor
del límite superior. Como índice se suele utilizar la variable i, pero puede ser cualquier otra.
El código siguiente imprime los valores enteros del 0 al 9:

for i in range(10):
print(i)
En el siguiente se imprimen los números 15, 14 y 13:

for i in range(15, 12, -1):
print(i)
pues el formato de rango es range(inicio, fin, paso). En el caso anterior se comienza en 15 y se

termina con 13 porque resta una unidad cada vez.
Sin embargo el código

for i in range(15, 12):
print(i)
dará error porque presupone (si no se indica) que el paso es +1 y el valor final es inferior al inicial.
En el siguiente ejemplo se imprimen los elementos de una lista:

cali_cualitativas = ["Insuficiente", "Suficiente", "Aprobado", "Notable",
"Sobresaliente"]
for i in cali_cualitativas:
print(i)
En el siguiente se imprimen las letras de la palabra Invierno:

for i in "Invierno":
print(i)
En las estructuras for también se pueden utilizar las instrucciones break y continue.
FUNCIONES
Una función es un bloque de código, al que se le asocia un nombre, que realiza una serie de tareas y devuelve
un valor (nulo -None- cuando no se emplea return -es como un procedimiento en otros lenguajes-, o no
nulo cuando se emplea return). Utilizar funciones ayuda a programar y depurar el programa al hacerlo más
legible, y permite reutilizar código, es decir, las funciones evitan la repetición de código.
La estructura de una función en Python es la siguiente:

def nombre_funcion(param1, param2, ...):
Línea 1
Línea 2
..........
Return #optativo
Las funciones se escribirán al principio del programa para que ya se encuentren definidas en el momento en
que se llamen. Se suele dejar una línea en blanco al final de la definición de cada función por claridad de
lectura del código. Si una función llama a otra, la que llama tiene que declararse después de la llamada. Una
vez terminada la declaración de funciones comienza el cuerpo del programa.
Un ejemplo muy elemental: se define una función que recoge una cadena (en el argumento texto) y la
imprime. El nombre de la función comienza, por manía propia, con f_ para indicar que es una función (no es
necesario, evidentemente). El cuerpo del programa comienza asignando una cadena a la variable valor para
a continuación llamar a la función pasándole el contenido de valor que es asignado a texto:
def f_imprime_algo(texto):
print(texto)
valor = "hola"
f_imprime_algo(valor)
El contenido de la variable del bloque programa, en este caso valor, es visible para la función porque es una
variable global. Así
print(valor)
print(texto)
valor = "hola"
imprime dos veces hola.
Sin embargo, el contenido del o de los argumentos declarados en la función o variables dentro del cuerpo de
la función no son visibles fuera de ella, es decir, son locales. Así
valor2 = "ejemplo"
print(texto)
valor = "hola"
print(valor2)
imprimirá hola pero dará un error en el momento de ejecutar la última instrucción del programa porque la
variable valor2 no está definida (no tiene contenido, no hace referencia a ningún objeto) fuera del cuerpo de
la función.
A continuación una función que tiene varios parámetros de entrada y devuelve un valor: calcula la media de
tres valores:
def f_media(p1, p2, p3):
valor_medio = (p1 + p2 + p3)/3
return valor_medio

c1 = 5.7
c2 = 8.5
c3 = 6.75
media = f_media(c1, c2, c3)
print(media)
función muy limitada porque solo sirve para un caso muy concreto, pero muestra como return devuelve la
media calculada. Además el cálculo de la media en este caso se podría escribir dentro del cuerpo del
programa y no crear una función, pues ese cálculo consta de una sola instrucción. Sin embargo la función
mejora la legilibilidad del programa.
Mejoramos el programa para que la función que calcula la media admita un número indeterminado de
parámetros (se hace anteponiendo el asterisco al parámetro):
def f_media(*valores):
total = 0
for i in valores:
total = total + i
valor_medio = total/len(valores)
return valor_medio
c1, c2, c3 = 5.7, 8.5, 6.75

media = f_media(c1, c2, c3)
print(media)
y un ejemplo completamente general utilizando una lista, datos, en la que se introducen los n datos:
def f_media(valores):
total = 0
for i in valores:
total = total + i
return valor_medio
datos = [5.7, 8.5, 6.75, 6] #escribir los datos en esta línea

media = f_media(datos)
print(media)
Un ejemplo en el que la función devuelve varios valores: una función que determina la media y la varianza s2
∑(𝑥𝑖 −𝑥̅ )2
= y devuelve los dos valores con una sola llamada a la función:
𝑛
def f_media_varianza(valores):
total = 0
for i in valores:
total = total + i
total = 0
for i in valores:
total = (i - valor_medio)**2
s2 = total/len(valores)
return valor_medio, s2

media, varianza = f_media_varianza(datos)
print("media = ", media)
print("varianza = ", varianza)

Las funciones pueden no tener parámetros, como la siguiente cuyo resultado es imprimir ejemplo:
def f_imprime():
print("ejemplo")
f_imprime()
Funciones integradas en Python
Python incluye las siguientes funciones de forma predeterminada (es decir, estas funciones siempre están
disponibles):
_import_() delattr() hash() memoryview() set()
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed()
complex() hasattr() max() round()
Los nombres de las funciones integradas se pueden utilizar para nombrar variables, pero entonces las
funciones ya no estarán disponibles en el programa. Si se eliminan las variables, las funciones vuelven a
estar disponibles.
MÓDULOS
Módulos creados por el usuario
Los programas largos se suelen dividir en fragmentos, almacenando cada uno de ellos en un archivo con la
extensión .py. Cada archivo, con su nombre correspondiente, es un módulo de Python, que suele contener
definiciones de funciones y/o declaraciones de constantes. Estos archivos, que deberán estar en la misma
carpeta que el archivo del programa principal, serán cargados con la instrucción import desde el programa
principal.
Supongamos que creamos un módulo llamado impresion (guardado con el nombre de archivo
impresion.py) que contiene dos funciones, la primera que imprime un texto que le pasamos y la segunda el
cuadrado de un valor numérico que también le pasamos:

#módulo que contiene funciones que imprimen
def f_imprime_texto(valor):
print(valor)
def f_imprime_numero_cuadrado(valor):
print(valor**2)
y ahora creamos el programa principal, que guardaremos en la misma carpeta que el módulo anterior con la
extensión también .py:
#programa principal que llama a un módulo
import impresion
cadena = "imprimiendo"
impresion.f_imprime_texto(cadena)
numero = 3.4
impresion.f_imprime_numero_cuadrado(numero)
La instrucción import carga el módulo impresion (las instrucciones contenidas en el archivo

impresion.py). Las funciones contenidas en este módulo son llamadas desde el programa principal como
impresion.f_imprime_texto(cadena)
y
impresion.f_imprime_numero_cuadrado(numero)
porque f_imprime_texto() y f_imprime_numero_cuadrado() son métodos del módulo impresion.
Si el nombre del módulo es largo tendríamos que teclear bastante texto para llamar a sus funciones y se
convertiría además en ilegible. Tenemos la alternativa de llamar con, por ejemplo, import impresion as Im, y
la llamada a la función que imprime texto quedaría:
Im.f_imprime_texto(cadena)
Otra forma de importar es cargar la o las funciones que nos interesan del módulo. Para ello se utiliza la
instrucción
from modulo import nombre_funcion # o funciones, separadas por comas
que evita hacer referencia al objeto (módulo) en el que está contenida dicha función, es decir, se elimina el
nombre del objeto y el punto que le sigue. Este método también carga menos instrucciones en memoria, y
por ello es más rápido.
En nuestro caso para imprimir solo la cadena quedaría:

from impresion import f_imprime_texto
cadena = "imprimiendo"
f_imprime_texto(cadena)
Y en el caso de desear cargar todas las funciones del módulo se podría utilizar la instrucción
from modulo import *
cuyas funciones serían llamadas sin hacer referencia al objeto, como en el caso anterior.

En todo caso, la mejor forma es la primera o la segunda (con as), referenciando la función del módulo a
través del objeto, evitando ambigüedades en el caso de utilizar el mismo nombre para una función en dos o
más módulos.
Módulos de la librería estándar de Python
Python instala numerosos módulos que se cargan como se ha descrito anteriormente con la instrucción
import. Por ejemplo, por defecto Python no contiene en su núcleo muchas funciones matemáticas, tal como
la raíz cuadrada, funciones trigonométricas, etc., o constantes como el número pi. Para trabajar con estas
funciones antes hay que cargar el módulo math, que es un módulo del sistema, de la librería estándar (aunque
no del núcleo) de Python y que se instala con el.
Si del módulo math necesitamos solo la función raíz cuadrada haríamos

from math import sqrt
∑(𝑥𝑖 −𝑥̅ )2
Así, el cálculo de la media y de la desviación típica de una muestra, s = √ 𝑛−1
, podría ser:

def f_media_desviactipica(valores):
total = 0
for i in valores:
total = total + i
total = 0
for i in valores:
total = (i - valor_medio)**2
s = sqrt(total/(len(valores)-1))
return valor_medio, s

media, desviaciontipica = f_media_desviactipica(datos)
print("media = ", media)
print("desviac. típica = ", desviaciontipica)
Cuando Python importa un módulo, primero comprueba si existe integrado en el sistema, si no existe
comprueba si existe un archivo con ese nombre, bien creado por el usuario o bien un módulo externo.
A continuación tenemos un código que calcula el tiempo, en segundos, que tarda en contar desde 0 hasta
999, utilizando el módulo integrado time. La instrucción for necesita ejecutar algo, y si no lo encuentra
produce un error, por ello se añade la sentencia pass para que continúe con el siguiente valor del índice:
import time
TiempoInicial = time.time()
for i in range(1000):
pass
TiempoFinal = time.time()
TotalTiempo = TiempoFinal - TiempoInicial
print("El tiempo empleado en segundo es= ", TotalTiempo)

CÁLCULO SIMBÓLICO CON PYTHON
Python también permite realizar cálculo simbólico: derivadas e integrales simbólicas, límites, resolución de
ecuaciones, etc. Para ello se necesita el módulo externo (de terceros, que no está en la librería estándar de
Python, que no se instala cuando se instala Python), SymPy, que puede ser llamado directamente por los
Python online (tal como repl.it –NOTA: en este servicio hay que iniciar sesión para que cargue módulos de
terceras partes-) o QPython de Android, pero necesita instalación previa cuando se trabaja con Python en un
ordenador.
Así, para instalar SymPy en Windows se puede hacer lo siguiente:
• Abrir el cuadro de ejecutar comandos con las teclas Win+R

• Escribir cmd y ejecutar. Se muestra la consola de Windows.
• Escribir pip install sympy y esperar. Se instala el módulo Sympy. (pip es un programa que se
instala con Python).
[Para saber que módulos están instalados se puede ejecutar la orden pip list]
Nota: al ejecutar la orden pip nos puede aparecer el aviso de actualización del programa pip. Para actualizar
se ejecuta python -m pip install --upgrade pip.
Veamos un sencillo ejemplo en el que deseamos obtener las raíces de una ecuación (es de segundo grado
aunque no está escrita en forma polinómica) procedente de un equilibrio químico ácido-base: un ácido débil
de concentración 0,5 M y constante de disociación 1,8·10-5 del que queremos calcular la concentración de
𝑥2
iones hidrógeno en el equilibrio, es decir, x. La condición de equilibrio es entonces 1.8 · 10−5 = 0.5−𝑥, y el
código:
import sympy #importar el módulo SymPy
x = sympy.symbols("x") #hacer que x sea símbolo aplicando el método symbols
exp = x**2/(0.5 - x) - 1.8e-5 #construír la expresión igualada a 0
raices = sympy.solvers.solve(exp, x) #obtener las raíces aplicando el método solvers.solve
print(raices) #imprimir las soluciones
obteniendo como resultado [-0.00300901349996963, 0.00299101349996962] , del que podemos extraer

la solución válida, la segunda, con raices[1].
Aunque se recomienda utilizar el método solveset en lugar de solve:

import sympy
x = sympy.symbols("x")
exp = x**2/(0.5 - x) - 1.8e-5
raices = sympy.solveset(exp, x)
print(raices)
con la diferencia de que el resultado ahora es de tipo conjunto o set (un tipo de datos de Python que no está
ordenado, por tanto no se puede indexar), con sus elementos encerrados entre llaves en vez de corchetes
como en las listas, {-0.00300901349996963, 0.00299101349996962} . Una forma de extraer los
elementos del conjunto consiste en recorrer el conjunto con un bucle for y añadir el elemento a una lista
creada previamente y vacía, por lo que se añadiría el siguiente código:
lista=[] #crea una lista vacía
for i in raices: #recorre los elementos del conjunto raices
lista.append(i) #añade el elemento a la lista

y ya tendríamos las soluciones en forma de lista.
Un ejemplo con dos ecuaciones: calcular el pH de una disolución acuosa de ácido cianhídrico de
concentración c0 = 1,2·10-5 M a 25 ºC, sabiendo que Ka = 6,2·10-10.
Se trata de un ácido muy débil y a muy baja concentración por lo que en los equilibrios hay que tener en
cuenta la autoionización del agua. Si x es la concentración de los iones oxonio procedentes del ácido e y la
procedente del agua, las ecuaciones son:
(𝑥 + 𝑦) · 𝑥
Ka =
c0 − 𝑥
Kw = (𝑦 + 𝑥) · 𝑦
y el código:
import sympy
x, y = sympy.symbols("x, y")
c0 = 1.2e-5
Ka = 6.2e-10
Kw = 1e-14
exp1 = (x + y)*x/(c0 - x) - Ka
exp2 = (y + x)*y - Kw
sol = sympy.solvers.solve([exp1, exp2], [x, y])
print(sol)
obteniendo una matriz (ya redondeados los valores a efectos de presentar aquí) [(-5.6546e-8 + 0.e-28*I,
-7.5647e-8 + 0.e-28*I), (5.6130e-8 - 0.e-28*I, 7.5798e-8 - 0.e-28*I), (2.81289e-5 -
0.e-30*I,-2.8129e-5 + 0.e-28*I)] observando que los términos imaginarios son nulos (10-28 ≈ 0) y que
las soluciones válidas son las del segundo conjunto –o segunda fila en términos de matriz- (hay tres
conjuntos, encerrados en paréntesis cada uno de ellos). Para extraer el valor de x haremos
sol[1][0] obteniendo 5.6130e-8
(que extrae el elemento de índice 0 –recordemos que el índice comienza en 0- del conjunto 1)
y para obtener el valor de y
sol[1][1] obteniendo 7.5798e-8
La concentración de iones oxonio será [H3O+] = x + y = 5.613010-8 + 7.579810-8 = 1,3193·10-7 M, de donde

pH = -log [H3O+] = 6,88.
El código anterior permite modificar los valores de la concentración inicial y/o de la constante de equilibrio y
obtener rápidamente la solución.

GRÁFICOS
En el siguiente ejemplo se representan tres gráficas utilizando las funciones gráficas del módulo Sympy:
import sympy
x,t=sympy.symbols("x t")
#grafica1 de p1
p1=x**3
sympy.plot(p1)
#grafica2 de p1 con el color por defecto y p2 en rojo
p2=sympy.diff(p1)
p=sympy.plot(p1,p2,(x,-15,15), show=False)
p[1].line_color="r"
p.show()
#grafica3 de una parametrica
ejex=2*t
ejey=-t**2+6*t+10
sympy.plotting.plot_parametric(ejex, ejey, (t,0,10))
que hay que teclear en un IDE que permita ventanas gráficas, tal como el IDE propio de Python, o el de
PyScripter... Cada vez que se invoca la instrucción plot o show se abre una ventana gráfica representando la
gráfica. Para continuar con la siguiente hay que cerrar la que está abierta.
El resultado es:
LIBRO DE ESTILO DE PYTHON
Un libro de estilo de un lenguaje de programación contiene un conjunto de recomendaciones sobre el

formato de un programa, con la finalidad de facilitar la lectura del código, reutilizar el mismo y detectar
errores. En cuanto a Python se dan a continuación algunas recomendaciones.
• Sangrado o identado: con espacios (4 espacios) en lugar de tabuladores. Recuérdese que el identado
es obligatorio para que Python reconozca el bloque a ejecutar.
• Escribir una instrucción por línea (Python permite escribir varias instrucciones por líneas
separándolas con dos puntos).
• Evitar espacios después de un paréntesis, llave o corchete de apertura o antes de uno de cierre, o
antes de un paréntesis de apertura de función.
• Evitar espacios antes de comas, punto y coma y dos puntos, pero poner espacio después de los
mismos.

• Los signos de igualdad llevarán espacio antes y después.
• Poner espacios antes y después de los signos de suma y resta.
• Poner comentario descriptivo en la cabecera del programa: objeto del programa, autor, fecha...
RECURSOS
Sitio oficial de Python

https://www.python.org/
Sitio oficial del módulo Sympy

https://www.sympy.org/es/
Tutoriales de Python
Introducción a la programación con Python:

http://www.mclibre.org/consultar/python/
Tutorial de Python:
http://docs.python.org.ar/tutorial/3/index.html#
Programación en Python - Nivel básico:

https://entrenamiento-python-basico.readthedocs.io/es/latest/index.html
Guías oficiales de estilo de Python:
Style Guide for Python Code:

https://www.python.org/dev/peps/pep-0008/
Libro de estilo de Python:

http://www.mclibre.org/consultar/python/otros/libro-de-estilo.html
Guía de estilo del código Python:

http://mundogeek.net/traducciones/guia-estilo-python.htm

Introduccion A La Programacion en Python 3

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introduccion A La Programacion en Python 3

Cargado por

Copyright:

Formatos disponibles

INTRODUCCIÓN A LA PROGRAMACIÓN EN PYTHON 3

plrp 2019-20 v.7 Página 1

Así en Windows tenemos:

Al finalizar habilitar que el PATH pueda tener más de 260 caracteres:

plrp 2019-20 v.7 Página 2

plrp 2019-20 v.7 Página 3

Entre otras aplicaciones podemos instalar QPython3 desde Play Store.

Al abrir la aplicación se muestra la pantalla de la izquierda en la que se puede

plrp 2019-20 v.7 Página 4

Si después de la operación anterior escribimos a1 en la consola y pulsamos RETURN obtendremos el

No se pueden utilizar para nombrar variables:

and def from nonlocal while

plrp 2019-20 v.7 Página 5

Los básicos son:

* (multiplicación, que hay que indicar explícitamente), / (división)

TIPOS DE DATOS BÁSICOS

True (cierto) False (falso)

Números positivos o negativos que no tienen decimales. Pueden ser de tipo

int (entero, integer)

Pueden ser de cualquier precisión, limitada por la memoria de la máquina.

Además también hay octal y hexadecimal.

aunque es conveniente utilizar el mismo tipo de comillas en un programa.

Las cadenas se pueden concatenar:

plrp 2019-20 v.7 Página 6

Un valor numérico se convierte a cadena mediante la función str()

Para referirse, por ejemplo, al segundo elemento de la primera lista haremos

Para cambiar dicho elemento por el valor 7.75 haremos:

y para imprimir la lista:

obteniendo [6.7, 7.75, 9.0].

dará como resultado 5.

plrp 2019-20 v.7 Página 7

siendo ahora a = [0, 1, 2, 3].

Las asignación se produce en el momento de crear la variable:

Definir y asignar valores a varias variables a la vez

FUNCIONES INPUT() Y PRINT()

Son las dos funciones básicas de entrada y salida de datos, respectivamente.

Para introducir por pantalla el nombre Juan y almacenarlo en la variable nombre:

o bien, de un forma más completa:

plrp 2019-20 v.7 Página 8

print(f"Me llamo {nombre} y tengo {edad} años.")

siendo la salida Me llamo Juan y tengo 5 años.

print(f"la suma de {valor1} y {valor2} es {valor1+valor2}.")

obteniendo como resultado la suma de 5 y 6 es 11.

Las cadenas “f” también se pueden emplear en las funciones input():

valor1 = int(input("Introducir un número: "))

valor2 = int(input(f"Introducir un número mayor que {valor1}: "))

CONTROL DE FLUJO DE UN PROGRAMA. ALGUNAS ESTRUCTURAS BÁSICAS

Ejemplo que evalúa si una calificación es suspenso (<5) o aprobado (>=5):

plrp 2019-20 v.7 Página 9

Es una estructura de bucle: ejecuta un bloque de código mientras se cumpla la condición.

plrp 2019-20 v.7 Página 10

Repite un bloque de código un número determinado de veces.

Ejemplo en el que se imprimen los números del 15 al 18:

El código siguiente imprime los valores enteros del 0 al 9:

En el siguiente se imprimen los números 15, 14 y 13:

pues el formato de rango es range(inicio, fin, paso). En el caso anterior se comienza en 15 y se

Sin embargo el código

En el siguiente ejemplo se imprimen los elementos de una lista:

En el siguiente se imprimen las letras de la palabra Invierno:

La estructura de una función en Python es la siguiente:

plrp 2019-20 v.7 Página 11

imprime dos veces hola.