Autor: Luis Fernando Apáez Álvarez
-Curso PyM-
Clase 1: Primeros pasos
Fecha: 08 de Agosto del 2022
Como hemos dicho anteriormente, un lenguaje de programación funge el papel, tal vez no directo, de ser un intermediario entre el programador y la "computadora". Dentro del lenguaje Python podemos declarar variables de distintos tipos. Las variables, como su nombre lo indican, son elementos que Python va almacenando de acuerdo al valor que le asignemos; éstas las ocupamos de acuerdo al fin u objetivo que tengamos y fungen un papel similar al concepto de variables que conocemos en el ámbito matemático.
Comenzamos por el tipo más natural de variable, es decir, el tipo numérico:
# Esto es un comentario, esto no es procesado por Python y sirve para
# describir el codigo que vamos escribiendo para brindar legibilidad
# a nuestro proyectos
# --------------------------------------------
# Declaramos variables de tipo int, las cuales serán almacenadas
# en una dirección de memoria
x = 3
y = 5
Comenzamos por declarar variables enteras; este tipo se denomina int (integer). Luego, podemos utilizar una función que viene por defecto en Python: print(). Como su nombre lo indica, la funcionalidad es imprimir, así que, si queremos ver el valor de las variables que hemos declarado podemos utilizar esta función. Como tal, las funciones en Python son como funciones matemáticas, las cuales reciben uno o más parámetros y devuelven un resultado. Veamos:
# Imprimimos el valor de la variable x
print(x)
# dejamos una línea en blanco
print()
# Imprimimos el valor de la variable y
print(y)
3 5
Cabe resaltar que la ejecución que realiza Python es de arriba abajo. Por ejemplo, del código anterior podemos ver que se imprimió primero el valor de x pues en la celda de código aparece primero print(x); al final se mostró el valor de y pues print(y) es el último código en nuestra celda.
Luego, con la función type() podemos obtener el tipo de dato de una variable:
# tipo de dato de la variable x
print(type(x))
<class 'int'>
Tenemos otros tipos de datos que debemos conocer:
float: Tipo de dato flotante o decimal.string: Tipo de dato de las cadenas de texto; corresponden a texto que las personas manejan usualmente. Las cadenas de texto van entre comillas dobles o simples.Por ejemplo
# Declaramos una variable de tipo string con comillas dobles
mensaje = "Hola Mundo"
# Declaramos una variable de tipo string con comillas simples
mensaje2 = 'Hola Mundo!'
# Imprimimos nuestros mensajes
print(mensaje)
# Imprimimos varios guiones medios
print("------------------------")
# Imprimimos el segundo mensaje
print(mensaje2)
# Imprimimos 20 guiones medios
print("-" * 20)
# Imprimos el tipo de dato de los mensajes
# Podemos colocar varios parámetros separados por una coma,
# por ejemplo imprimimos el tipo de dato del primer mensaje
# despues imprimimos una coma (",") y depues el tipo de dato
# del segundo mensaje
print(type(mensaje), ",", type(mensaje2))
Hola Mundo ------------------------ Hola Mundo! -------------------- <class 'str'> , <class 'str'>
Tenemos otro tipo de datos importante:
boolean: Corresponde a variables que toman el valor de True (verdadero) o False (falso)# declaramos nuestra primer variable de tipo booleana
es_verdad = True
es_mentira = False
# Podemos combinar cadenas de texto o mensaje con los valores de las variables
# como parámetro de la funcion print(), lo que se conoce como concatenacion
# La concatenacion se realiza colocando comas como separadores entre cada texto o variable
# "\n" representa un salto de linea
print("El valor de verdad de la variable es_verdad es: ", es_verdad,
"\nEl valor de verdad de la variable es_mentira es: ", es_mentira )
El valor de verdad de la variable es_verdad es: True El valor de verdad de la variable es_mentira es: False
Podemos jugar con el valor de verdad de las variables booleanas y podemos combinarlas con operadores booleanos. Los operadores booleanos son:
not: este operador cambia el valor de verdad de una variable booleana# Sabemos que la variable es_mentira es falsa, pero su negacion es verdader
print(not es_mentira)
True
and: si tenemos dos variables verdaderas, el operador and de dichas variables será verdadero, caso contrario el operador de dichas variables será falso.# operador and de dos variables verdaderas
# los parentesis nos sirve de separacion
print( (es_verdad) and (not es_mentira))
# operador and de una variable verdadera y una falsa
print( (es_verdad) and (es_mentira))
True False
or: el operador or será verdadera siempre y cuando una de las variables boolenas involucradas sea verdadera# operador or, una variable es verdadera y la otra falsa
print((es_verdad) or (es_mentira))
# operador or; ambas variables son verdaderas
print((es_verdad) or ( not es_mentira))
# operador or, ambas variables son falsas
print((not es_verdad) or (es_mentira))
True True False
El último operador es el de igualdad. Como vimos antes, hemos estado ocupando el símbolo = para asignar variables, así que, si queremos utilizar tal cual como concemos el concepto de igualdad utilizaremos ==. Por ejemplo, nos podemos preguntar si el 1 es igual al 0:
print(1 == 0)
False
Podemos efectuar operaciones entre variables. Como vimos antes, existen operadores booleanos para operar entre variables booleanas. Asimismo, y más naturalmente, tenemos operadores numéricos:
# x es una variables que tenia el valor de 3 (x=3), pero como su nombre lo indica
# es una variable, asi que podemos cambiar su valor
x = 7
y = 3
# imprimimos su suma
print("Suma x+y=", x + y)
Suma x+y= 10
# alternativamente:
# declaramos una variable que almacene la suma de dichas variables,
# a continuacion veremos en accion como utilizar variables para otras variables
suma = x + y
print("Suma x+y=", suma)
Suma x+y= 10
La ventaja de declarar la variable suma es que podremos utilizarla después en nuestro código si así lo queremos
# operador de multiplicacion *:
# utilizaremos la variable suma
print("Multiplicación de", suma, "por 5: ", suma * 5)
Multiplicación de 10 por 5: 50
El operador de multiplicación nos sirve también para carácteres y cadenas de texto, no sólo para números:
print("Luis" * 5)
print("-" * 50)
print("*" * 50)
print("Esto es genial, " * 5)
LuisLuisLuisLuisLuis -------------------------------------------------- ************************************************** Esto es genial, Esto es genial, Esto es genial, Esto es genial, Esto es genial,
Pero, ¿qué pasa si intentamos sumar cadenas?
cadena1 = "Hola "
cadena2 = "mundo"
print(cadena1 + cadena2)
Hola mundo
Genial! Lo que ocurre cuando sumamos cadenas de texto se conoce como cancatenación de cadenas, es decir, unimos dos cadenas de texto en una sola. Un detalle importante es que el operador de suma + sirve para valores de datos del mismo tipo, no podemos sumar un string con un int
print("Luis" + 0)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-24-b16049b447e0> in <module> ----> 1 print("Luis" + 0) TypeError: can only concatenate str (not "int") to str
Python nos marca error al intentar sumar tipos de datos distintos. Continuando, tenemos los operadores
# division /
print("La división de 1 entre 2 es ", 1 / 2)
print("-" * 50)
# exponentes **
print("2 elevada a la 3 es: ", 2 ** 3)
La división de 1 entre 2 es 0.5 -------------------------------------------------- 2 elevada a la 3 es: 8
En la función print() podemos utilizar cadenas de texto y valores fijos o de variables como
z = 0
print("Cadena de texto, ", z)
De forma alternativa, podemos combinar cadenas de texto y variables o valores fijos en la función print()
utilizando lo que se conoce como f string. El f string funge como un conector entre cadenas de texto y variables (o valores fijos); por ejemplo, el código anterior se puede escribir como:
# f string: f""
z = 0
print(f"Cadena de texto, {z}")
donde dentro de la comillas del f string hemos colocado cadena de texto como sabemos hacer y hemos colocado una variable, pero la variable fue colocada entre llaves. Otros ejemplos:
# Ejemplos utilizando f string
# declaramos algunas variables
edad = 24
nombre = "Luis Fernado"
mensaje_saludo = f"Nombre: {nombre} \nEdad: {edad}"
# imprimimos el mensaje
print(mensaje_saludo)
Nombre: Luis Fernado Edad: 24
Lo anterior es de gran utilidad pues, podemos cambiar el valor de la variable nombre a cualquier otro, así como el valor de la variable edad, e imprimir un mensaje diferente dependiendo el valor de dichas variables.
input() ¶La función input() es otra función que viene por defecto en Python (las funciones que vienen por defecto se denominan funciones predefinidas). Ésta sirve para que el usuario ingrese información. Por ejemplo, podemos mostrar un saludo personalizado dependiendo del nombre del usuario:
# declaramos algunas variables
# la variable nombre tomara el valor que el usuario ingrese
nombre = input()
# Declaramos una variable para tener el mensaje personalizado
mensaje_saludo = f"Hola {nombre}, ¡bienvenido!"
# imprimimos el mensaje
print(mensaje_saludo)
Naruto Uzumaki Hola Naruto Uzumaki, ¡bienvenido!
# podemos ver el valor de la variable nombre:
print(nombre)
Naruto Uzumaki
que representa el nombre que el usuario ingresó.
Para ciertos tipos de datos podemos realizar una conversión de tipos. Por ejemplo, podemos cambiar el tipo de dato de un número entero al tipo flotante:
# variable de tipo entera
x = 4
print(type(x))
print("-" * 50)
# Realizamos la conversion de x al tipo flotante
x = float(x)
print(type(x))
print("-" * 50)
print(x)
<class 'int'> -------------------------------------------------- <class 'float'> -------------------------------------------------- 4.0
Nota que x = float(x) estamos asignado a la variable x, equis misma pero ahora del tipo flotante; en otras palabras, a la variable x le hemos asignado el valor de 4.0
También podemos convertir variables de tipo flotante a tipo entero:
# Variable del tipo flotante
y = 5.0
# Conversion al tipo entero
y = int(y)
print(y)
5
# Variable del tipo flotante
# en caso de tener decimales, estos seran truncados
z = 5.7
# Conversion al tipo entero
z = int(z)
print(z)
5
¿Podremos convertir datos del tipo entero a cadenas de texto?
# Variable entera
x = 3
# para convertir a dato string utilizamos str()
x = str(x)
# tipo de dato de x
print(type(x))
<class 'str'>
La realidad es que sí podemos convertir datos del tipo numérico a cadenas de texto, más aún, podemos convertir ciertas cadenas de texto a tipo numérico
# Variable flotante
x = 3.1416
# para convertir a dato string utilizamos str()
x = str(x)
# tipo de dato de x
print(type(x))
print("-" * 50)
print(x)
<class 'str'> -------------------------------------------------- 3.1416
# Convertimos una cadena a entero
numero1 = "1"
numero1 = int(numero1)
print(type(numero1))
print("-" * 50)
print(numero1)
<class 'int'> -------------------------------------------------- 1
# Convertimos una cadena a flotante
numero2 = "2.0"
numero2 = float(numero2)
print(type(numero2))
print("-" * 50)
print(numero2)
<class 'float'> -------------------------------------------------- 2.0
# Y, en realidad, no cualquier cadena puede ser convertida al tipo numérico
cad = "numero 1"
cad = int(cad)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-43-d1b17c75d974> in <module> 1 # Y, en realidad, no cualquier cadena puede ser convertida al tipo numérico 2 cad = "numero 1" ----> 3 cad = int(cad) ValueError: invalid literal for int() with base 10: 'numero 1'
# Y, en realidad, no cualquier cadena puede ser convertida al tipo numérico
cad = "numero 1"
cad = float(cad)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-45-7f644a9bb6f5> in <module> 1 # Y, en realidad, no cualquier cadena puede ser convertida al tipo numérico 2 cad = "numero 1" ----> 3 cad = float(cad) ValueError: could not convert string to float: 'numero 1'
Sólo podemos convertir cadenas de texto que contenga únicamente números enteros o flotantes, cualquier otra cadena de texto no podrá ser convertida al tipo numérico. Con lo anterior, podemos escribir, por ejemplo:
# variable para almacenar el nombre del usuario
nombre = input()
# variable para almacenar la edad del usuario
edad = input()
# veamos el tipo de dato cuando el usuario ingresa informacion
print(type(nombre))
print("-" * 50)
print(type(edad))
Luis 24 <class 'str'> -------------------------------------------------- <class 'str'>
En ambos casos la entrada es de tipo string. En general, la entrada del usuario siempre es del tipo string, entonces
# Podemos hacer algo como:
# variable para almacenar el nombre del usuario
nombre = input()
# variable para almacenar la edad del usuario
edad = int(input())
# veamos el tipo de dato cuando el usuario ingresa informacion
print(type(nombre))
print("-" * 50)
print(type(edad))
Luis 24 <class 'str'> -------------------------------------------------- <class 'int'>
Anteriormente vimos que el operador == nos permite comparar la igualdad entre dos variables, por ejemplo
x = "Hola"
y = "Mundo"
# Primera comparacion
print(x == y)
# Segunda comparacion
print(x == x)
False True
Asimismo, podemos comparar variables numéricas para ver cuál es mayor, menor o si éstas son menores iguales o mayores iguales, o también si dichas variables son distintas:
# Es claro que las variables de tipo string que definimos arriba son diferentes
# Operador "distinto"
# ¿x es distinto de y?
print(x != y)
True
# operador menor que
print(1 < 2)
# operador menor o igual que
print(2 <= 2)
# operador mayor que
print(0 >- 1)
# operador mayor o igual que
print(2 >= 4)
True True True False
Ahora bien, notemos el siguiente comportamiento
n = 0
print(n)
print("-" * 50)
# asignamos a n, n misma mas 1
n = n + 1
print(n)
0 -------------------------------------------------- 1
Lo anterior podría pensarse como:
Donde al inicio el valor de n es cero, pero después cambiaremos el valor de n. Dicho cambio será al valor de n+1, pero en esos momentos n vale cero, por lo cual n+1 tendrá el valor de 1 y así, el nuevo valor de n es 1. Si tenemos ahora
n = n + 3
ahora n tendrá el valor de 4 pues, en primera instancia n tiene el valor de 1, luego le estamos sumando 3, esto es n + 3, y finalemente dicho resultado se lo reasignamos a la variable n.
Dentro de la programación es muy común realizar reasignaciones, por ello podemos simplificar el código de una reasignación como
n += 3
que significa exactamente lo mismo que n = n + 3. Otro ejemplos
k = 2
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
k = k + 1
print(k)
2 -------------------------------------------------- 3
# O alternativamente
k = 2
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
k += 1
print(k)
2 -------------------------------------------------- 3
Tambibién podemos realizar la reasignación para el operador de resta, multiplicación y exponenciación:
k = 2
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
k *= 3
print(k)
2 -------------------------------------------------- 6
que significa en otras palabras:
k = 2
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
k = k * 3
print(k)
Continuando
# Resta
k = 5
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
k -= 2
print(k)
5 -------------------------------------------------- 3
# Exponentes
k = 2
print(k)
print("--" * 25)
# Realizamos la reasignacion aumentando en uno el valor de k
# k = k ** 4
k **= 4
print(k)
2 -------------------------------------------------- 16
print(f'{"esto, " * 3}es todo amigos {"." * 20}')
esto, esto, esto, es todo amigos....................