Notas de la formación por parte de la Consellería de Promoción do Emprego e Igualdade y el Clúster TIC Galicia impartida en 2023.

• Introducir los distintos entornos de desarrollo. El entorno interactivo Jupyter para ejecutar y crear programas.
• Conocer los elementos básicos del lenguaje, las estructuras de control, estructuras de datos, y elementos sintácticos específicos de Python.
• Introducir algunas de las bibliotecas más habituales del lenguaje.
• Realizar prácticas y ejercicios sencillos de programación con Python.

• Bloque I: Introducción a Python y E/S básica
  • Mostrar mensajes por pantalla -print()
  • Cadenas de texto -strings
  • Introducción de datos –input()
  • Ejercicios prácticos
• Bloque II: Variables y tipos de datos
  • Variables
  • Tipos de datos
    • Integers
    • Floats
  • Conversiones entre tipos de datos
  • Formatear cadenas
  • Operadores matemáticos
  • Redondeo
  • Ejercicios prácticos
• Bloque III: Cadenas de caracteres y tipos de datos abstractos
  • Método index
  • Extraer substrings
  • Métodos de string
  • Propiedades de string
  • Tipos de datos
    • Listas
    • Diccionarios
    • Tuplas
    • Sets
    • Booleanos
  • Ejercicios prácticos
• Bloque IV: Sentencias de control
  • Operadores de comparación
  • Operadores lógicos
  • Control de flujo
  • Loops
    • for
    • while
  • Rango
  • Enumerador
  • Zip
  • Min y Max
  • Random
  • Comprensión de listas
  • Match
  • Ejercicios prácticos
• Bloque V: Funciones
  • Métodos ayuda y documentación
  • Crear funciones
  • Return
  • Funciones dinámicas
  • Interacción entre funciones
  • Argumentos indefinidos -* args
  • Argumentos indefinidos -* kwargs
  • Ejercicios prácticos
• Bloque VI: Ficheros
  • Abrir y manipular archivos
  • Crear y escribir archivos
  • Directorios
  • Pathlib
  • Path
  • Limpiar la consola
  • Archivos y funciones
  • Ejercicios prácticos
• Bloque VII: Programación Orientada a Objetos
  • Programación orientada a objetos
  • Atributos
  • Métodos
  • Tipos de métodos
  • Herencia
  • Polimorfismo
  • Métodos especiales
  • Ejercicios prácticos

nombre_de_la_variable = valor

Python es un lenguaje de tipado “débil” y dinámico. No es necesario definir el tipo de dato que va a contener una variable. Python lo infiere.

a = 1
type(a) # int
 
a = "hola"
 
type(a) # str

Definición de una variable como resultado de una operación:

b = 5 * 3
 
b # 15
 
c = (b + 1) / 2
 
c # 8.0
 
type(c) # float

Como la división podría dar lugar a un número con decimales, Python lo transforma en un tipo de dato flotante. El operador de división / tiene que servir tanto para enteros como para flotantes. Si queremos hacer explícitamente una división entera, existe el operador //. Con el operador % podríamos obtener el resto de la división:

r = 7 % 2
 
r # 1

• Suma: a + b
• Resta: a - b
• Cambio de signo: -a
• Multiplicación: a * b
• División: a / b, a // b
• Potencia: a ** b
• Módulo / resto división entera: a % b

f = 1 + c * 5 - (b + 1) / 3

Primero se evalúa lo que hay entre paréntesis y luego operaciones de potencia, multiplicación, división y finalmente suma y resta:

1. (b + 1)
2. / 3
3. c * 5
4. 1 +

Afectan a valores lógicos o booleanos

• ==: igualdad
• >: mayor que
• <: menor que
• >=: mayor o igual que
• ⇐: menor o igual que
• !=: distinto
• and
• or
• not

Tabla de verdad del operador and:

Tabla de verdad del operador or:

Tabla de verdad del operador not:

p = True
q = False
s = True
 
p, q, s # (True, False, True)
 
w = p or q # True
y = p and s # True
z = not q # True

Aunque no existe la operación XOR (or exclusivo), se puede emular como:

x = (p and not q) or (not p and q)

Orden de precedencia de operaciones lógicas:

1. Se evalúa lo que haya entre paréntesis
2. not
3. and
4. or

En Python se utiliza la lógica de cortocircuito, que quiere decir que si una expresión lógica compleja sabemos que va a dar un determinado resultado sin necesidad de evaluar todos sus componentes, ya no sigue procesando. Por ejemplo, en una operación a and b, si a es falso, ya no es necesario evaluar b para conocer el resultado.

• Concatenación de las cadenas a y b: a + b
• Repetición de la cadena a n veces (n debe ser un número entero): a * n
• Longitud o número de caracteres de una cadena: len(a)
• Conversión de cualquier valor a cadena: str(x)

s = "Hola"
t = "Mundo"
 
s, t # ('Hola', 'Mundo')
 
s + t # 'HolaMundo'
 
s * 3 # 'HolaHolaHola'
 
len(s) # 4
 
q = 4
 
str(q) # '4'

Si quisiéramos unir cadenas con algún caracter, podemos usar el método join:

s = "Hola"
t = "mundo"
 
"_".join # 'Hola_mundo'

Sirven para comparar dos valores de varias formas diferentes, dando como resultado un valor booleano:

• Igualdad: a == b
• Diferente o no es igual: a != b
• Mayor que: a > b
• Menor que: a < b
• Mayor o igual que: a >= b
• Menor o igual que: a ⇐ b

Los tipos de datos que se pueden comparar deben tener definido un orden, como ocurre con los números enteros, los números de coma flotante o las cadenas de caracteres, entre otros.

a = 3
b = 4
c = 3
 
a == b # False
 
a !=b # True
 
a > c # False
 
a >= c # True
 
b < c # False
 
a = "Alpha"
b = "Bravo"
 
a < b # True (por el orden lexicográfico)

mi_variable #34.6666666666666664

Queremos imprimir la variable mi_variable con cierto formato, podemos emplear varias técnicas.

Usando f antes de la cadena.

print(f"La variable a vale {mi_variable:5.3f}") # La variable a vale 34.677

En el ejemplo anterior también estamos indicando el número de posiciones (al menos) y número de decimales. En ese caso, el número de posiciones (5) no parece muy útil salvo que se quiera dejar espacios delante del número. Si solo queremos trabajar con los decimales, omitimos la parte de las posiciones:

print(f"La variable a vale {mi_variable:.3f}") # La variable a vale 34.677

Otra variante utilizando el método format:

print("La variable a vale {mi_variable:.3f}".format(mi_variable)) # La variable a vale 34.677

Podríamos truncar (quitar) la parte decimal de un número convirtiéndolo a entero:

a = 34.6666666666666664
 
int(a) # 34

Si queremos redondear decimales, es decir, el entero más próximo, podemos usar la función round:

round(a, 2) # 34.67
 
round(a) # 35

# Cálculo del área y perímetro de un rectángulo
 
# Primer paso: toma de datos
base = float(input("Base del rectángulo: "))
altura = float(input("Altura del rectángulo: "))
 
# Segundo paso: procesamiento
area = base * altura
perimetro = 2 * (base + altura)
 
# Tercer paso: mostrar resultados
print(f"Área del rectángulo: {area:g}")
print(f"Perímetro del rectángulo: {perimetro:.2f})

# Cálculo de una ecuación de segundo grado
from math import sqrt # Cargamos el módulo 'math', pero nos quedamos con su función 'sqrt'
# import math # importaríamos todo el módulo
 
# Primer paso: toma de datos; coeficientes a, b y c
print("ax^2 + bx + c = 0")
a = float(input("Coeficiente a: "))
b = float(input("Coeficiente b: "))
c = float(input("Coeficiente c: "))
 
# Segundo paso: cálculo de las raíces/soluciones
x1 = (-b + sqrt(b**2 - 4 * a * c)) / 2 * a
 
x2 = (-b - sqrt(b**2 - 4 * a * c)) / 2 * a
 
# Tercer paso: mostrar resultados
print(f"Soluciones: {x1} y {x2}")