Variables y funciones básicas#

Important

¿Cómo vamos?

Hasta el momento debemos tener claro lo siguiente:

Hemos recorrido un largo camino para empezar a programar en Python. Sin embargo, fue necesario para reconocer conceptos, herramientas y hábitos que nos llevarán a un buen puerto con nuestras piezas de código. Empezaremos hablando de algunas instrucciones elementales de Python, crearemos nuestros primeros programas, también llamdos scripts que posteriormente serán interpretados. Mencionaremos algunos tipos elementales de datos y los guardaremos en un espacio de memoría mediante variables para transformarlos y generar nueva información.

¡Hola mundo!#

Un ejercicio tradicional de cualquier lenguaje es verificar que funciona, para verlo usaremos una celda de código y escrbiremos print('¡Hola Mundo!') oprimimos [Shift]+[Enter] (ejecuta y generará una nueva celda) o [Alt]+[Enter] (ejecuta sin crear una nueva celda) o el ícono run en la parte superior del cuaderno y debe aparecer lo siguiente:

print('¡Hola Mundo!')

¡Hola Mundo!

Puede parecer insignificante pero en este ejercicio estamos haciendo varias cosas:

  1. Diferenciamos la celda de texto con la celda de código.

  2. Identificamos un comando para ejecutar, comentamos que Python es un lenguaje interpretado y que permite correr código sin necesidad de compilar, aún así debemos indicarle a la máquina que corra.

  3. Identificamos la entrada y salida de una celda de código, en gris estará el código que diseñamos y justo abajo el resultado de la ejecución del código. Hay un par de valores que indican la identificación de la salida y la entrada del cuaderno.

Otro ejercicio interesante es hacer una sencilla operación matemática, en principio Python soporta las operaciones aritméticas básicas y sin ningun problema podemos hacer lo siguiente:

Operador

Descripción

+

Suma

-

Resta

*

Multiplicación

/

División

**

Potencia

Usemos a Python como calculadora simple y hagamos algunas cuentas:

Una suma:

2+2

4

Una resta:

1000003-65

999938

Una multiplicación:

526563255*454544411121

239346384661931958855

Una resta de un número muy grande, solo para demostrar que Python puede usar una gran cantidad de memoria:

3999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999+1

4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Una potencia:

2**6

64

Como se puede apreciar en sus cuadernos, cada operación está debidamente identificada y se distingue claramente la salida y la entrada de la celda.

Ejercicio

Calcule lo siguiente e interprete el resultado:

In[2]

Variables#

Una variable en Python sirve para guardar un valor específico, ya sea numérico, texto u otro Tipo de Dato con un nombre que nosotros escojamos. Debemos escribir una expresión de la forma:

[Nombre de variable]=[Valor para guardar]

Por ejemplo, si queremos guardar el valor 1 en la variable x, debemos escribir:

x=1

Si queremos guardar el texto 'Python es asombroso' en la variable y, debemos escribir:

y='Python es asombroso'

Hay variables previamente asignadas en Python, como la que acabamos de ejecutar, esta hace referencia a la variable preasignada en Jupyter In, cada vez que se ejecuta, Python llama alguna entrada que está guardada en la memoría de nuestra máquina. Esto lo logramos en Jupyter Notebook a través del núcleo, un motor computacional de Jupyter que utiliza los recursos del computador (CPU y RAM) para guardar los cálculos. Cada vez que se reinicia el núcleo se pierden todos los datos guardados. Así mismo Out guarda todas las salidas posibles.

Note

Variables predefinidas en Python

A parte de las variables preasignadas, en Python hay palabras reservadas, que no pueden ser usadas para definir variables. Una forma de verlas es utilizando la librería keywords, en la siguiente celda importamos esa librería y le pedimos a Python que nos muestre una lista con las palabras que no se pueden usar.

Después entramos en más detalle con los conceptos resaltados en esta nota:

  • Librería

  • Importar

  • Lista

import keyword
print(f'Hay un total de {len(keyword.kwlist)} palabras reservadas: ')
keyword.kwlist

Hay un total de 36 palabras reservadas: 

['False',
 'None',
 'True',
 '__peg_parser__',
 'and',
 'as',
 'assert',
 'async',
 'await',
 'break',
 'class',
 'continue',
 'def',
 'del',
 'elif',
 'else',
 'except',
 'finally',
 'for',
 'from',
 'global',
 'if',
 'import',
 'in',
 'is',
 'lambda',
 'nonlocal',
 'not',
 'or',
 'pass',
 'raise',
 'return',
 'try',
 'while',
 'with',
 'yield']

Important

Reglas de Creación de Variables:

Para crear variables se den seguir algunas reglas elementales y tener en cuenta unas distinciones, basta con seguir las siguientes reglas:

  • El nombre de una variable debe comenzar con una letra ó con _ .

  • El nombre de una variable no puede comenzar con un número.

  • El nombre de una variable sólo puede contener carácteres alfa-numéricos.

  • El nombre de una variable tiene sensibilidad a mayúsculas y minúsculas (x es diferente de X).

Ejemplo

Hagamos un código que le diga al computador que imprima los textos Tengo my_age años, donde my_age es una variable que tenga asignada una edad.

my_age=25
print("Tengo",my_age, "años")

Tengo 25 años

Efectivamente, al ejecutar el script se remplaza my_age por el número 25. Veamos un eujemplo un poco más complicado:

Ejemplo

El siguiente código calcula la longitud del nombre y la presenta en un texto. Observe que en el comando print() , sep= es un parámetro que separa los valores ingresados dentro de la función print. Como se puede apreciar, usamos una nueva función len() ¿Puedes deducir qué hace?

Nombre='Su_nombre'# cambiar 'Su_nombre' por su verdadero nombre
longitud=len(Nombre)
print(Nombre," tiene una longitud de ",longitud, "caractéres", sep=" ")

Su_nombre  tiene una longitud de  9 caractéres

Múltiples Asignaciones:#

Es posible asignar valores a diferentes variables en una línea de código:

# Asignación múltiple

w, x, y, z = "Manzana", "Sandía", "Uva", 28;

print(w);
print(x);
print(y);
print(z);
print(w,x,y,z,sep=", ");

Manzana
Sandía
Uva
28
Manzana, Sandía, Uva, 28

También es posible asignar un mismo valor a diferentes variables:

# Asignación múltiple del mismo valor

x1 = x2 = x3 = 0.5;
print('x1 =',x1);
print('x2 =',x2);
print('x3 =',x3);

x1 = 0.5
x2 = 0.5
x3 = 0.5

Cuidado con las variables no asignadas. Generan error:

n # Variable sin asignar

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Input In [12], in <cell line: 1>()
----> 1 n

NameError: name 'n' is not defined

Important

Errores en Python

Python resulta ser un programa bastante amable con el programador, es muy específico con los problemas que tiene y permite resolver errores de manera muy sencilla. El mensaje de error hace referencia a una excepción, pues tenemos una sintáxis correcta, pero para Python es imposible ejecutar.

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/tmp/ipykernel_4603/2966927032.py in <module>
----> 1 n # Variable sin asignar

NameError: name 'n' is not defined

El intérprete reproduce la línea responsable del error y muestra una pequeña “flecha” que apunta al lugar donde se detectó el error. El error ha sido provocado (o al menos detectado) en el elemento que precede a la flecha: en el ejemplo, el error se detecta en la línea 1 puesto que se llama a n, una variable sin asignar. También se muestran: el número de línea para que sepas dónde corregir y en la última línea se indica el tipo de error cometido. En este caso, como se comentó anteriormente, es una excepción provocada porque no hay una asignación previa a la variable n.

Ejemplo

Vamos a empezar a hacer operaciones con variables, en este caso usaremos el operador +. Es claro que Python es tan sencillo e intutivo, que sumar diferentes variables indicará una suma, sin embargo, aquí dependemos del tipo de dato que se guarda en la variable; cuando las variables son numéricas, se suman matemáticamente y cuando es texto se concatenan.

# Sumar dos textos

x = "Python is ";
y = "awesome";
z =  x + y;
print(z);

# Sumar dos números

n1 = 1;
n2 = 5;
suma = n1 +n2;
print(suma);

# Escribir texto y números

print(x+"the number",n1);

Python is awesome
6
Python is the number 1

Tipos de datos#

Los ejemplos anteriores permitieron que interactuara por primera vez con Python, no obstante, las operaciones aritméticas difieren del programa hola_mundo que inicio nuestra travesía programática. Uno de los primeros aspectos son el tipo de dato que se usó, por el lado de hola mundo es una cadena de caractéres, que nosotros conocemos como texto y por el lado de las operaciones números enteros y textos también, antes de iniciar un enredo en la cabeza hablemos de los tipós de datos que admite Python y evitemos aumentar nuestra confusión.

Note

En ocasiones se definen objetos a partir de paquetes y/o módulos que se entenderan como datos en Python. Evidentemente hoy trabajaremos con los que se tienen por defecto, sin embargo, cada vez que se importa una librería habran nuevos tipos de datos.

Enteros#

Hace referencia a los valores numéricos, positivos o negativos, que no tienen coma decimal. Como cuando estabamos en secundaria, trabajamos aquí con valores que no admiten partes y que se utilizan en un sin fin de operaciones matemáticas. En la siguiente línea definimos un par de variables enteras, usamos la función type()para identificar el tipo de dato con el que lidiamos y calculamos una suma, una resta, una multiplicación y una división:

n1=5
n2=3

print(n1, 'es',type(n1))
print(n2, 'es',type(n2))

5 es <class 'int'>
3 es <class 'int'>

suma=n1+n2
print(suma, 'es',type(suma))

8 es <class 'int'>

resta=n2-n1
print(resta, 'es',type(resta))

-2 es <class 'int'>

mult=n1*n2
print(mult, 'es',type(mult))

15 es <class 'int'>

Otros operadores aritméticos

Antes de empezar a dividir, vale la pena hacer mención a un par de operaciones aritméticas que no se han mencionado: la división entera // y el cálculo de residuo %. Corresponde a la división que usamos en nuestra infancia en el que cada número entero se descomponía en un cociente por un divisor más un residuo.

Por ejemplo, si dividimos de forma entera a 20 entre 6, el cociente es 3 y su residuo es 2:

\[ 20=6\times 3+2 \]

La forma de calcular ese cociente es utilizando la división entera (//) y la forma de calcular el residuo es utilizando el operador módulo (%)

20//6

3

20%6

2

De forma, más general:

n=20
d=6

print(n,'=',n//d,'*',d,'+',n%d)
print(n//d, 'es',type(n//d))
print(n%d, 'es',type(n%d))

20 = 3 * 6 + 2
3 es <class 'int'>
2 es <class 'int'>

Coma flotante#

Hasta ahora se puede ver que todos nuestros cálculos generan enteros, eso es porque al calcular el tipo de dato aparece <class 'int'>, int proviene de integer que es entero en inglés. Sin embargo, es bien sabido por la comunidad de estudiantes que al momento de dividir es posible que aparezcan decimales, ese tipo de dato debe cambiar:

divi=n1/n2
print(divi, 'es',type(divi))

1.6666666666666667 es <class 'float'>

El anterior ejemplo hace referencia a la notación de coma flotante usada en los computadores para representar los números reales. Utiliza la idea detras de la notación científica guardando las cifras significativas del número y el exponente que indica la posición de la coma decimal. Los números en Python que contengan una parte decimal se convierten en número representados en coma flotante, en ingles float.

n1=5.3
n2=8.0
print(n1, 'es',type(n1))
print(n2, 'es',type(n2))

5.3 es <class 'float'>
8.0 es <class 'float'>

Conceptualmente 8.0 es un número entero, pero incluir el punto exige que python ubique la como, por eso se convierte en un número flotante.

Boleanos#

Otro tipo de datos utilizado ampliamente en Python, y muchas veces sin que el programador se entere, es el dato booleano. Simplemente indica dos valores True (Verdadero) o False(Falso). Este tipo de información será bastante útil en algunas estructuras de programación elemental, además se puede entender como la presencia/ausencia de una característica medida en el programa. Su definición es simple, pero se puede ayudar por preguntas que le podemos hacer a python a partir de operadores de comparación o operadores lógicos, similares a los operadores aritméticos pero cuya respuesta es Trueo False.

x=True
print(x,'es',type(x))

True es <class 'bool'>

y=False
print(y,'es',type(y))

False es <class 'bool'>

Operadores de comparación:

Python es capaz de comparar información, utiliza los operadores habituales que me permiten hacer comparaciones aritméticas: la igualdad (==), la diferencia (!=), mayor que (>), menor que (<), mayor o igual que (>=) y ,enor o igual que (<=).

4==3 # Preguntamos si 4 es igual a 3

False

Podemos guardarlo en una variable, se recomienda usar paréntesis:

x=(4==3)
print(x,'es',type(x))

False es <class 'bool'>

3!=5 #Preguntamos si 3 es diferente de 5

True

3<5  #Preguntamos si 3 es menor que 5

True

Operadores lógicos

Así como pudimos comparar datos, podemos armar expresiones lógicas complejas formandolas con operadores booleanos. Entre los más conocidos tenemos:

Conjunción (AND)

Verdadera si ambas sentencias lógicas son verdaderas, en otro caso falsa:

(4!=3) and (5==5) 

True

(4!=4) and (5==5) 

False

Disyunción (OR)

Falsa si ambas sentencias lógicas son falsas, en otro caso verdadero:

(4!=4) or (5==5) 

True

(4!=4) or (5!=5) 

False

Negación (NOT)

Cambia el valor de la variable booleana:

not (4==4)

False

not (4!=4)

True

Textos (Strings)#

Los textos son expresiones que representan una cadena de caracteres, utiles para escribir mensajes y combinarlos con valores que generemos en nuestros procesamientos. Para guardar un texto en Python usamos comillas simples: '...' o comillas dobles: "...". Es posible utilizar dos tipos de comillas, puesto que en algunas ocasiones la comilla es necesaria para el texto:

Usemos los diferentes tipos de comillas para generar texto:

a='Texto simple escrito entre comillas simples'
print(a)
a

b='Texto simple escrito entre comillas dobles'
print(b)
b

c='Texto simple escrito entre comillas simples que necesita "adentrico" comillas dobles'
print(c)
c

Texto simple escrito entre comillas simples que necesita "adentrico" comillas dobles

'Texto simple escrito entre comillas simples que necesita "adentrico" comillas dobles'

d="Texto simple escrito entre comillas dobles que necesita 'adentrico' comillas simples"
print(d)
d

Texto simple escrito entre comillas dobles que necesita 'adentrico' comillas simples

"Texto simple escrito entre comillas dobles que necesita 'adentrico' comillas simples"

Note

No hay diferencia en guardar un texto en comillas simples o dobles. No obstante, para Python un texto que contenga comillas simples es diferente a un texto que contenga comillas dobles.

text1="Primer texto"
text2= 'Primer texto'
print(text1==text2)

True

text1="'Primer' texto"
text2= '"Primer" texto'
print(text1==text2)

False

Como vimos, la función print es la que nos permite imprimir estos mensajes. El texto \n indica una nueva linea en el texto:

print("Una línea\notra línea")

No obstante, a veces necesitamos escribir \n en un mensaje:

print('La ruta del archivo es C:\nombres\archivo.ipynb')

En este caso la aparición de \ daño el mensaje, para resolver el problema escribimos r antes:

print(r'La ruta del archivo es C:\nombres\archivo.ipynb')

Podemos recorrer los caractéres de la cadena de texto de la siguiente forma:

En el ejemplo utilizamos el texto 'Hola mundo' y el número arriba indica la posición o índice de cada caracter:

texto='Hola mundo'
print(texto)

Hola mundo

Cada número arriba indica la posición, accedemos a esa posición llamando a la variable y con paréntesis cuadrados indicamos el acceso al valor indicado:

texto[0]

'H'

texto[4]

' '

texto[9]

'o'

Podemos tomar un subtexto, en Python los rangos se simbolizan con dos puntos y toman desde el índice indicado en el inicio hasta el índice anterior al final.

texto[0:5]

'Hola '

Note que el anterior mostro el subtexto que contiene los valores con indice [0], [1], [2], [3] y [4]. El carcater [5] no apareció.

texto[5:9]

'mund'

claramente el tipo de dato cambia, en python hace referencia a str que indica que es una cade de caractéres, String.

print(texto,'es',type(texto))

Hola mundo es <class 'str'>

Repaso#

Como vimos anteriormente, en Python la asignación de valores a variables se hace con el operador =, a la variable de la izquierda le asignamos el valor de la derecha.

Tip

En pro de hacer amena la lectura del código, es recomendable asignar nombres relacionados con el problema que se está programando. En el ejemplo siguiente se calcula el área de un triángulo. Esplique las diferencias entre los dos códigos.

Código 1

base = 1
altura = 2
area = base*altura

Código 2

a = 1
b = 2
c = a*b

Note

Los dos códigos anteriores para Python son iguales, pero para el lector es más fácil identificar el error en el primero que en el segundo, por ello, es mejor utilizar el primer código que el segundo.

Recordemos …

Las variables no pueden tener algunos nombres, que son palabras reservadas por Python, estas palabras son: and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, nonlocal, None, not, or, pass, raise, return, True, try, while, with y yield.

Tip

Si deseamos hacer mucho más fácil la lectura del código, podemos agregar comentarios, los cuales van antecedidos de #, es decir,

base = 1 #Base del triángulo
altura = 2 #Altura del triángulo
area = base*altura/2 #Cálculo del área de un triángulo

Si deseamos definir múltiples variables, aprovechamos las ventajas de Python para este hecho, por ejemplo:

base, altura= 1,2 #Base y altura del triángulo
area = base*altura/2 #Cálculo del área de un triángulo

Recordemos …

Condiciones que deben cumplir los nombres de las variables:

  • El nombre de una variable debe comenzar con una letra ó con _ .

  • El nombre de una variable no puede comenzar con un número.

  • El nombre de una variable sólo puede contener carácteres alfa-numéricos.

  • El nombre de una variable tiene sensibilidad a mayúsculas y minúsculas (x es diferente de X).

Textos

Recordemos que un tipo de variables muy utilizadas son las que contienen texto en ellas, como por ejemplo:

z = "Hola mundo" #El texto también puede ir entre comillas sencillas, así: z = 'Hola mundo'

Para imprimir los valores de diferentes variables, utilizamos el comando print

print(z)

Hola mundo

print(a,z)

1 Hola mundo

print(a,z,area)

1 Hola mundo 1.0

print('El valor de a es:',a) #Nota que la separación entre los elementos es un espacio

El valor de a es: 1

print(a,z,area,sep='\n') #Con esta opción podemos nodificar la separación

1
Hola mundo
1.0

Sobre las variables tipo str, podemos aplicar la función len para medir la cantidad de caracteres que hay en la variable:

len(z) #El espacio cuenta como un caracter

10

w = 'hoy es un gran día'

Las variables tipo str se pueden operar:

print(z+w)

Hola mundohoy es un gran día

print(z+' '+w)

Hola mundo hoy es un gran día

print(3*z)

Hola mundoHola mundoHola mundo

Si deseamos escribir comillas en una variable tipo str, debemos definir la variable con comillas dobles y las comillas que deseamos deben ser sencillas, o viceversa. De manera más general, podemos definir la variable con comillas triples:

z1 = "Así ponemos comillas 'sencillas'"
z2 = 'Así ponemos comillas "dobles"'
z3 = ''' Y así 'podemos' usar cualquier tipo de "comillas"'''
print(z1,z2,z3)

Así ponemos comillas 'sencillas' Así ponemos comillas "dobles"  Y así 'podemos' usar cualquier tipo de "comillas"

Tip

Si tenemos una variable tipo str la cual queremos volver una variable de tipo numérico, en caso que su contenido lo permita, tenemos las siguientes funciones:

n = '2'

print('El tipo de n es:',type(n),
      'Si lo queremos volver entero:',int(n),type(int(n)),
      'Si lo queremos volver float:',float(n),type(float(n)),sep='\n')
#Nota que podemos separar las entradas de la función con un salto de línea, para hacer más fácil la lectura o para no perder valores de vista como pasa con este comentario

El tipo de n es:
<class 'str'>
Si lo queremos volver entero:
2
<class 'int'>
Si lo queremos volver float:
2.0
<class 'float'>

Entrada de texto a la máquina:

En muchas oportunidades es de gran utilidad establecer líneas de interacción entre el usuario y la máquina, de tal forma, que el usuario pueda ingresar información a medida que se ejecuta cierto código, para ello tenemos a nuestra disposición la función input:

input('texto que aparece, aclarando la entrada que se pretende modificar: ')

texto que aparece, aclarando la entrada que se pretende modificar:  54542

'54542'

Como podemos ver, el retorno de la función input, es una cadena de caracteres, por lo tanto, si deseamos transformar tales valores debemos utilizar las funciones que mencionamos anteriormente int y/o float.

Ejercicio#

Ingresar el salario desado:

salario = float(input(
    'Ingresa el valor del salario que te gustaría ganar cuando termines el pregrado (en pesos sin puntos ni comas): '))

Ingresa el valor del salario que te gustaría ganar cuando termines el pregrado (en pesos sin puntos ni comas):  1223

Muchas veces, a la hora de mostrar los valores que hemos guardado, debemos darles formato, para ello podemos tener en cuenta las siguientes opciones de la función print:

print("El salario al que aspiras es:", salario)
print("Pero se vería mejor con la separación en miles: ${0:8,f}".format(salario))

El salario al que aspiras es: 1223.0
Pero se vería mejor con la separación en miles: $1,223.000000

{0:8,f} En el código anterior0 indica la posición del elemento que imprimiremos, el 8 la cantidad de espacios para reservar e imprimir el número pero no afectará ya que no tenemos ningún tipo de alineación la , indica la separación por miles y por último f indica que se imprimirá un float.

Cambia {0:8,f} por ${0:,2f}y comenta los resultados.

Podemos prescindir del punto decimal:

print("Si no queremos el punto decimal: {0:7,d}".format(int(salario)))

Si no queremos el punto decimal:   1,223

d indica que lo que se imprime es un entero (int).

También podemos usar notación científica, en este caso usamos e. La e indica que se usará notación científica para el resultado, 1 es la cantidad de números antes de la coma y 2 la cantidad de números después de la coma.

print("O tal vez, sea mejor la notación científica: {0:1.2e}".format(int(salario)))

O tal vez, sea mejor la notación científica: 1.22e+03

Si tenemos diferentes salidas a las cuales darles formato, podemos hacer algo como lo que viene a continuación

print('Salario mensual: {0:1,d} Salario anual {1:2.2e} '.format(int(salario),salario*12))
#Nota que el 0 es para el salario y el 1 para el salario multiplicado por 12

Salario mensual: 1,223 Salario anual 1.47e+04

Cierre#

Hemos empezado a trabajar con Python guardando variables en diferentes tipos de datos. Aunque aún no estamos aplicando procesos muy complicados ya vemos como poco a poco aplicamos una secuencia estructurada de pasos para resolver algunos problemas. Por ejemplo, aunque no fue mencionado, se espera que como estudiante de Python se de cuenta de uqe las variables deben ser asignadas antes de usarse y que para asignarse debe ser ejecutada una celda donde se defina la variables. Así mismo, se espera que reconozca el orden de ejecución, la jerarquía de las operaciones y la importancia de usar paréntesis.

En el próximo módulo se empezará a trabajar con estructuras de programación, se estudiaran algunos métodos útiles para la manipulación de texto y se representarán como debe ser algunos algoritmos.