Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com

Table of Contents
EJE I: CARACTERISTICAS DEL LENGUAJE .................................................................................................. 3
QUE ES PYTHON .................................................................................................................................. 4
CARACTERISTICAS DE PYTHON ............................................................................................................ 4
VARIABLES .......................................................................................................................................... 6
TIPOS DE DATOS BASICOS ................................................................................................................... 7
OPERADORES .................................................................................................................................... 12
ENTRADAS......................................................................................................................................... 16
SALIDAS Y FORMATOS ....................................................................................................................... 18
EJE II: CONTROL DE FLUJO ..................................................................................................................... 23
SENTENCIAS CONDICIONALES ........................................................................................................... 24
SETENCIAS ITERATIVAS ...................................................................................................................... 28
EXPRESIONES ANIDADAS .................................................................................................................. 31
COLECCIONES DE DATOS ................................................................................................................... 32
FUNSIONES ....................................................................................................................................... 42
ARGUMENTOS .................................................................................................................................. 48
ARGUMENTOS IDETERMINADOS ...................................................................................................... 50
EJE III: PERSISTENCIA DE DATOS. ........................................................................................................... 53
DICCIONARIOS. ................................................................................................................................. 54
FICHEROS. ......................................................................................................................................... 57
FICHEROS CSV ................................................................................................................................... 63
FICHEROS JSON ................................................................................................................................. 66
BASES DE DATOS EN PYTHON. ........................................................................................................... 68
EJE IV: PARADIGMA ORIENTADO A OBJETO. ......................................................................................... 72
PROGRAMACION ESTRUCTURADA VS POO ....................................................................................... 73
CLASE, OBJETO, Y ATRIBUTOS............................................................................................................ 73
MÉTODOS. ........................................................................................................................................ 75
HERENCIA.......................................................................................................................................... 78
Bibliografía............................................................................................................................................ 80

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
 EJE I: CARACTERISTICAS DEL LENGUAJE

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
QUE ES PYTHON

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis
que favorezca un código legible. Y define este como un lenguaje multiparadigma, debido a que
soporta orientación a objetos, programación imperativa y en menor medida programación
funcional. Es interpretado de tipado dinámico y multiplataforma. Vamos a tratar de explicar cada
característica del lenguaje de la manera más simple posible.

CARACTERISTICAS DE PYTHON

Interpretado
Normalmente los lenguajes de programación se pueden agrupar en Interpretados y Compilados
según la forma en la que son traducidos. Los lenguajes se inventaron para facilitar al programador
el desarrollo aplicaciones, imagina que nuestro computador trabaja en código binario y sería muy
difícil programar todo en unos y ceros, además del tiempo que eso llevaría. Por eso al escribir un
código en realidad lo que estamos haciendo es hablar un lenguaje más fácil de comprender para
nosotros y que luego será traducido a lenguaje de máquina que es lo que puede entender el
procesador. Entonces, cómo se realiza esta “traducción” es lo que los agrupa en Interpretados o
Compilados:

Los lenguajes Compilados son aquellos en los que el código del programador es traducido por
completo de una sola vez mediante un proceso llamado “Compilado” para ser ejecutado por un
sistema predeterminado. Entre los más comunes encontramos “C”, “C++”, Java, etc.
Y los lenguajes Interpretados son aquellos en los que el código del programador es traducido
mediante un intérprete a medida que es necesario. Entre los más comunes encontramos
“Python“, “Ruby”, “Javascript”, etc.
El que Python sea interpretado nos presenta ventajas:

 No necesitamos compilar ahorrándonos mucho tiempo en el desarrollo y prueba de una

aplicación.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
  Nuestro código fuente puede ser ejecutado en cualquier software siempre y cuando este
disponga del intérprete (Windows, Linux, Mac, Android, Web).
Multiparadigma
Esto nos dice que Python es un lenguaje que soporta más de un paradigma, suponiendo
paradigma como modelo de desarrollo (y cada lenguaje tiene el suyo). El paradigma más
sobresaliente en la programación en Python es el Orientado a Objetos.
La orientación a objetos es un paradigma de programación en el que los conceptos del mundo
real relevantes para nuestro problema se trasladan a clases y objetos en nuestro programa. La
ejecución del programa consiste en una serie de interacciones entre los objetos. Python también
permite la programación imperativa, programación funcional y programación orientada a
aspectos.
De Tipado Dinámico
Es de tipado dinámico cuando una variable puede tomar diferentes valores de distintos tipos en
diferentes momentos. En Python las variables son declaradas por su contenido y no por su
contenedor, lo que nos va a permitir cambiar el valor y tipo de una variable durante la ejecución
sin necesidad de volver a declarar. Por ejemplo supongamos que X es una variable, y en este
caso X = 1. Si bien X está almacenando un número, igualmente podemos almacenar una letra
durante la ejecución del programa en la misma variable X mediante una instrucción, por ejemplo
X = “a”.
Veamos una variable como un bloque de memoria donde podemos “almacenar” un dato. O como
una cajita donde guardar cosas..
En python:

 Si dentro de la variable colocamos números, la variable será de tipo numérica.

 Ahora, si colocamos letras, la variable será de tipo texto.
 Y si en ella colocamos un booleano (Verdadero o Falso), será de tipo booleano.
Es decir, vamos a guardar en ella lo que queremos y python automáticamente detectara su tipo,
no hace falta que se lo indiquemos.
Resumiendo
Python es un lenguaje que todo el mundo debería conocer. Su sintaxis simple, clara y sencilla;
el tipado dinámico, el gestor de memoria, la gran cantidad de librerías disponibles y la potencia
del lenguaje, entre otros, hacen que desarrollar una aplicación en Python sea sencillo, muy rápido
y, lo que es más importante, divertido.
La sintaxis de Python es tan sencilla y cercana al lenguaje natural que los programas elaborados
en Python parecen pseudocódigo. Por este motivo se trata además de uno de los mejores
lenguajes para comenzar a programar.
Python no es adecuado sin embargo para la programación de bajo nivel o para aplicaciones en
las que el rendimiento sea crítico.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Algunos casos de éxito en el uso de Python son Google, Yahoo, la NASA, Industrias Light &
Magic, y todas las distribuciones Linux, en las que Python cada vez representa un tanto por ciento
mayor de los programas disponibles.

VARIABLES

Las variables son uno de los componentes básicos de cualquier programa. En su esencia, un
programa está compuesto por datos e instrucciones que manipulan esos datos. Normalmente,
los datos se almacenan en memoria (RAM) para que podamos acceder a ellos.
Una variable es una forma de identificar, de forma sencilla, un dato que se encuentra almacenado
en la memoria del ordenador. Es un contenedor en el que se almacena un dato, el cuál, puede
cambiar durante el flujo del programa. Una variable nos permite acceder fácilmente a dicho dato
para ser manipulado y transformado.
Por ejemplo, si queremos mostrar el resultado de sumar 1 + 2 debemos indicarle al programa
dónde se encuentra dicho dato en memoria y, para ello, hacemos uso de una
variable:

Como vimos en el ejemplo anterior, para asignar un valor (un dato) a una variable se utiliza el
operador de asignación =.
En la operación de asignación se ven involucradas tres partes:

 El operador de asignación =
 Un identificador o nombre de variable, a la izquierda del operador
 Un literal, una expresión, una llamada a una función o una combinación de todos ellos a
la derecha del operador de asignación

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Cuando asignamos un valor a una variable por primera vez, se dice que en ese lugar se define
e inicializa la variable. En un script o programa escrito en Python, podemos definir variables en
cualquier lugar del mismo. Sin embargo, es una buena práctica definir las variables que vayamos
a utilizar al principio.
Si intentamos usar una variable que no ha sido definida/inicializada previamente, el intérprete
nos mostrará un error:

Para modificar el valor de una variable en Python, basta con asignarle un nuevo valor en cualquier
momento y lugar después de la definición.

TIPOS DE DATOS BASICOS

En Python los tipos básicos se dividen en:

 Números, como pueden ser 3 (entero), 15.57 (de coma flotante) o 7 + 5j (complejos)
 Cadenas de texto, como “Hola Mundo”
 Valores booleanos: True (cierto) y False (falso).
Vamos a crear un par de variables a modo de ejemplo. Una de tipo cadena y una de tipo
entero:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En Python, a diferencia de muchos otros lenguajes, no se declara el tipo de la variable al crearla.
En Java, por ejemplo, escribiríamos:
String c = “Hola Mundo”;
int e = 23;
Números
Como decíamos, en Python se pueden representar números enteros, reales y complejos.
Enteros
El tipo de los números enteros es int. Este tipo de dato comprende el conjunto de todos los
números enteros, pero como dicho conjunto es infinito, en Python el conjunto está limitado
realmente por la capacidad de la memoria disponible. No hay un límite de representación
impuesto por el lenguaje.
Un número de tipo int se crea a partir de un literal que represente un número entero o bien como
resultado de una expresión o una llamada a una función. Ejemplos:

También podemos representar los números enteros en formato binario, octal o hexadecimal.
Los números octales se crean anteponiendo el valor 0o a una secuencia de dígitos octales (del
0 al 7). Para crear un número entero en hexadecimal, hay que anteponer 0x a una secuencia de
dígitos en hexadecimal (del 0 al 9 y de la A la F). En cuanto a los números en binario, se antepone
0b a una secuencia de dígitos en binario (0 y 1).
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Números de punto flotante
Los números de punto flotante representan al conjunto de los números reales. Hay que tener en
cuenta algunos detalles. Veamos un ejemplo:

Al igual que ocurre con los números enteros, los números reales son infinitos y, por tanto, es
imposible representar todo el conjunto de números reales con un ordenador.
Para representar el mayor número posible de los números reales con las limitaciones de memoria
(tamaños de palabra de 32 y 64 bits), se adaptó la notación científica de representación de
números reales al sistema binario (que es el sistema que se utiliza en programación para
representar los datos e instrucciones).
El caso es que la suma de la representación en punto flotante en binario del número 1,1 y de la
representación en punto flotante en binario del número 2,2, dan como resultado
3,3000000000000003
Pero hay más casos, como por ejemplo la representación del número 1/3. En algún momento, el
ordenador tiene que truncar el número periódico resultante.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
La explicación final es que los números de punto flotante se representan en el hardware del
ordenador como fracciones de base 2 (binarias). Y el problema está en que la mayoría de las
fracciones decimales no se pueden representar de forma exacta como fracciones binarias porque
tienen infinitos números decimales. Una consecuencia es que, en general, los números
decimales de punto flotante que usamos en nuestras aplicaciones son una aproximación de los
números binarios de punto flotante realmente almacenados en la máquina.
Este tipo de datos en Python es float. Que puede ser usado para representar cualquier número
real (siempre teniendo en cuenta que es una aproximación lo más precisa posible). Por tanto
para longitudes, pesos, frecuencias, etc, en los que prácticamente es lo mismo 3,3 que
3,3000000000000003. Además es posible darle formato al número de la siguiente manera:

Números Complejos
El último tipo de dato numérico básico que tiene Python es el de los números complejos, complex.
Los números complejos tienen una parte real y otra imaginaria y cada una de ellas se representa
como un float. Para crear un número complejo, se sigue la siguiente estructura
<parte_real>+<parte_imaginaria>j. Y se puede acceder a la parte real e imaginaria a través de
los atributos real e imag:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Aritmética de los tipos numéricos
Con todos los tipos numéricos se pueden aplicar las operaciones de la aritmética: suma, resta,
producto, división.
En Python está permitido realizar una operación aritmética con números de distinto tipo. En este
caso, el tipo numérico «más pequeño» se convierte al del tipo «más grande», de manera que el
tipo del resultado siempre es el del tipo mayor. Entendemos que el tipo int es menor que el tipo
float que a su vez es menor que el tipo complex. Por tanto, es posible, por ejemplo, sumar un int
y un float:

Tipo booleano
En Python la clase que representa los valores booleanos es bool. Esta clase solo se puede
instanciar con dos valores/objetos: True para representar verdadero y False para representar
falso.
Una particularidad del lenguaje es que cualquier objeto puede ser usado en un contexto donde
se requiera comprobar si algo es verdadero o falso. Por tanto, cualquier objeto se puede usar en
la condición de un if o un while (son estructuras de control que veremos en tutoriales posteriores)
o como operando de una operación booleana.
Por defecto, cualquier objeto es considerado como verdadero con dos excepciones:

 Que implemente el método __bool__() y este devuelva False.

 Que implemente el método __len__() y este devuelva 0.
Además, los siguientes objetos/instancias también son consideradas falsas:

 None
 False
 El valor cero de cualquier tipo numérico: 0, 0.0, 0j, …
 Secuencias y colecciones vacías : '', (), [], {}, set(), range(0)
Más adelante desarrollaremos el significado de métodos y de otros tipos de datos.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Tipo cadena de caracteres
Otro tipo básico de Python, e imprescindible, son las secuencias o cadenas de caracteres. Este
tipo es conocido como string aunque su clase verdadera es str. Formalmente, un string es una
secuencia inmutable de caracteres en formato Unicode.
Para crear un string, simplemente hay que encerrar entre comillas simples '' o dobles "" una
secuencia de caracteres.
Se puede usar indistintamente comillas simples o dobles, con una particularidad. Si en la cadena
de caracteres se necesita usar una comilla simple, tienes dos opciones: usar comillas dobles
para encerrar el string, o bien, usar comillas simples pero anteponer el carácter \ a la comilla
simple del interior de la cadena. El caso contrario es similar.
Veamos todo esto con un ejemplo:

A diferencia de otros lenguajes, en Python no existe el tipo «carácter». No obstante, se puede

simular con un string de un solo carácter.

OPERADORES

Los operadores son símbolos reservados por el lenguaje que se utilizan para llevar a cabo
operaciones sobre uno o más operandos. Los operandos pueden ser variables, literales, el valor
devuelto por una expresión o el valor devuelto por una función.
Operadores Aritméticos
Los operadores aritméticos permiten realizar las diferentes operaciones aritméticas del álgebra.
Estos operadores Python son de los más utilizados:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Operadores de Pertenencia
Los operadores de pertenencia se utilizan para comprobar si un valor o variable se encuentran
en una secuencia (list, tuple, dict, set o str).

Operadores de Asignación
El operador de asignación se utiliza para asignar un valor a una variable. Existe el operador
simple “=” y otros de asignación compuestos que realizan una operación básica sobre la variable
a la que se le asigna el valor.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Operadores de Comparación
Los operadores de comparación se utilizan, como su nombre indica, para comparar dos o más
valores. El resultado de estos operadores siempre es True o False.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Operador de concatenación de cadenas de caracteres
Una de las operaciones más básicas cuando se trabaja con cadenas de caracteres es la
concatenación. Esto consiste en unir dos cadenas en una sola, siendo el resultado un nuevo
string.
La forma más simple de concatenar dos cadenas en Python es utilizando el operador de
concatenación +:

Operadores lógicos o booleanos

A la hora de operar con valores booleanos podemos utilizar and, or y not.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Prioridad de los operadores en Python
Al igual que ocurre en las matemáticas, los operadores en Python tienen un orden de prioridad.
De mayor a menor prioridad el orden es el siguiente:
1. aritméticos (con el mismo orden de prioridad que en las matemáticas).
2. operadores de comparación y pertenencia
3. operadores lógicos
4. asignación
Este orden se puede alterar con el uso de los paréntesis ().

ENTRADAS

Los programas serían de muy poca utilidad si no fueran capaces de interactuar con el usuario,
incluso podrían no cumplir con el objetivo de encontrar la solución a un problema.
La entrada de datos en Python es bastante simple por medio de la función input(). En este módulo
conoceremos una de las funciones para leer datos por teclado y asignar ese valor recibido a una
variable. Además algunas consideraciones a tener en cuenta al momento de usarla.
La forma general de mostrar información por pantalla es mediante una consola de comando,
generalmente podemos mostrar texto y variables separándolos con comas, para esto se usa la
sentencia print().
Entrada de datos por consola
Para pedir al usuario que introduzca algún dato a través del teclado, usaremos el método input().
Este método, recibe como parámetro un str con el mensaje a mostrar al usuario:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En este momento, la consola queda a la espera de la entrada de datos por parte del usuario. Al
introducir cualquier texto, será asignado a la variable edad.
La entrada es convertida siempre a un objeto de tipo str UTF-8. Por tanto, si lo que necesitamos
es cualquier otro tipo, por ejemplo, un int, habrá que hacer la conversión correspondiente.
En el siguiente ejemplo, se pide un número al usuario y se desea mostrar su consecutivo.

Como el dato ingresado se almacena como cadena de texto, no es posible encontrar su

consecutivo. Veamos cómo se consigue una solución al problema:

En el código anterior se usó la función predefinida int() para convertir el dato ingresado de cadena
de texto a valor numérico, por lo tanto la operación para obtener su consecutivo está permitida.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Entrada de datos por Script
Hasta aquí lo que hemos escrito código en el intérprete, y/o escribir pequeños programas Python,
pero los programas informáticos más complejos no funcionan así. Se basan en escribir todas las
instrucciones en archivos llamados scripts, que no son más que guiones de instrucciones. Luego
se envía este archivo al intérprete como parámetro desde la terminal y éste ejecutará todas las
instrucciones en bloque.
Aparte de ser la base del funcionamiento de los programas, la característica de los scripts es que
pueden recibir datos desde la propia terminal de comando en el momento de la ejecución, algo
muy útil para agregar dinamismo a los scripts a través de parámetros personalizables.
A continuación, un ejemplo el cual simula una sala de chat, validando datos de entradas
numéricas y tipo cadena de caracteres e interactúa con el usuario.

Además de la entrada por consola, es posible obtener datos desde un archivo de texto de
diversas extensiones o desde una página web. El primero de los ítems lo desarrollaremos más
adelante estudiando el uso de ficheros JSON y CSV, el segundo tema conocido como Web
Scraping lo dejaremos para un curso más avanzado y como objeto de investigación de los
estudiantes.

SALIDAS Y FORMATOS

Mostrar datos por pantalla no solo es sencillo sino además flexible. En general, es cuestión de
una sola línea de código con una sola función llamada print().
La función print() de Python, recibe entre los paréntesis lo que sea que quieras mostrar y además
permite indicar algunos detalles adicionales.
Mostrar mensajes de texto
Se realiza colocando como argumento un texto encerrado entre comillas (ya sean dobles "" o
simples '')

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
No hay un límite en la cantidad de caracteres a imprimir, pero si el texto es muy largo
puede ensuciar el código.

Tratemos de dividirlo en varias llamadas a print para que el código sea más legible:

Sin embargo el resultado obtenido es completamente diferente al esperado, pues, Python puso
cada mensaje en una línea diferente en la pantalla. Esto sucede, debido a que, por defecto,
Python crea saltos de línea al final de cada llamado a print().
Esto puede resolverse usando parámetros especiales de print(), indicando que queremos poner
un espacio en blanco, en lugar de un salto de línea, de modo que todo quede en una sola línea
en pantalla y con sus debidos espacios. Lo que haremos es cambiar el final de línea de print() en
Python indicándolo en un parámetro llamado end:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Mostrar variables o expresiones
Además de texto puro es posible mostrar valores asignados a unas variable o directamente
expresiones algebraicas sin ser asignadas previamente.

Por supuesto que una salida es más clara o explícita cuando se combinan los valores que se
desean mostrar con mensajes de texto que describen esos valores.
Otro ejemplo:

Por defecto el separador de print es un espacio en blanco, es decir, separa fin de cadena de texto
o valor de variable. Es posible modificarlo usando el parámetro sep.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Muestra Avanzada
Hasta aquí hemos visto salidas en pantalla usando sentencias básicas, esta última forma que te
explicaremos abarca las ya vistas y ayuda a una mejor legibilidad de una salida dentro de un
programa Python.
Se propone una nueva forma de interpolar o intercalar expresiones en cadenas y aplicar formatos
con conversiones implícitas, llamada cadenas f conocida como f-strings. Un nuevo instrumento
disponible desde Python 3.6 que simplifica y unifica las posibilidades anteriores.

Tenemos una línea más corta, más legible ofreciendo la oportunidad de invocar funciones, por
ejemplo si quisiéramos colocar el valor de materia en mayúsculas.

Ya que las f-strings son evaluadas al momento de la ejecución tenemos la posibilidad de colocar
cualquier expresión válida.

Si necesitamos dividir nuestro mensaje en múltiple líneas podemos hacerlo de esta forma.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Es muy importante colocar la f al inicio de cada línea de lo contrario Python imprimirá la línea
como texto, con llaves y variables inclusive.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
 EJE II: CONTROL DE FLUJO

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
SENTENCIAS CONDICIONALES

SENTENCIA IF
La sentencia if se utiliza para ejecutar un bloque de código si, y sólo si, se cumple una
determinada condición. La estructura básica es la siguiente:

Es decir, solo si condición se evalúa a True, se ejecutarán las sentencias que forman parte de
bloque de código. En caso de que se evalúe a False no se ejecutará ninguna sentencia
perteneciente a bloque de código.
Condición puede ser un literal, el valor de una variable, el resultado de una expresión o el valor
devuelto por una función.
En las expresiones es muy común usar los operadores booleanos y de comparación.
IMPORTANTE: El cuerpo del bloque está indicado con una sangría o identación mayor. Dicho
bloque termina cuando se encuentre la primera línea con un sangrado menor.
Sangría, identación y sangrado se usan como sinónimos y representa el espacio en blanco
que dejamos desde el margen izquierdo al comenzar una sentencia.
Por ejemplo:

En el código anterior la variable x toma el valor 17. En la línea 2, la condición de la sentencia if

evalúa si x es menor que 20. Como el valor devuelto es True, se ejecuta el bloque del if,
mostrando por pantalla la cadena x es menor que 20.
Veamos otros ejemplos:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En ambos casos se define una lista de valores y comprobamos si en ella está un número
determinado. En el primer caso el if comprueba si el número 5 se encuentra entre estos valores.
Como la expresión devuelve como resultado False, porque 5 no está entre los valores
simplemente mostrará por pantalla la cadena fin. En el segundo caso, comprobando si 3 se
encuentra entre los valores observamos que se muestra ambas cadenas de texto.
SENTENCIA IF-ELSE
Hay ocasiones en que la sentencia if básica no es suficiente y es necesario ejecutar un conjunto
de instrucciones o sentencias cuando la condición se evalúa a False.
Para ello se utiliza la estructura if...else... Esta estructura es la siguiente:

Imagina un programa en el que necesitas realizar la división de dos números. Si divides un

número entre 0, el programa lanzará un error y terminará. Para evitar esto, podemos añadir una
sentencia if ... else... como en el ejemplo siguiente:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Si ejecutamos el caso que quisimos salvar, se vería:

SENTENCIA IF-ELIF-ELSE
También es posible que haya situaciones en que una decisión dependa de más de una condición.
En estos casos se usa una sentencia if compuesta, cuya estructura es como se indica a
continuación:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Es decir, en esta ocasión, se comprueba la condición cond1. Si se evalúa a True, se ejecuta el
bloque cond1 y luego el flujo continúa después del bloque if.
Luego, si cond1 se evalúa a False, se comprueba la condición cond2. Si ésta se evalúa a True,
se ejecuta el bloque de sentencias bloque cond2. En caso contrario, pasaría a comprobar la
condición del siguiente elif y así sucesivamente hasta que llegue al else, que se ejecuta si
ninguna de las condiciones anteriores se evaluó a True.
Veamos un ejemplo. Imagina que queremos comprobar si un número es menor que 0, igual a 0
o mayor que 0 y en cada situación debemos ejecutar un grupo de sentencias diferente. Por
ejemplo:

En el ejemplo anterior x toma el valor 28. La primera condición de la sentencia if se evalúa a

False y pasa a la siguiente (a la del bloque elif). En esta ocasión, la expresión se evalúa a True,
mostrándose por pantalla la cadena “28 es mayor que 0”.
SENTENCIA IF ANIDADAS
A cualquiera de los bloques de sentencias anteriores se le puede volver a incluir una sentencia
if, o if … else … o if … elif … else …
Podemos reescribir el último ejemplo de la siguiente manera:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
SETENCIAS ITERATIVAS

Un bucle o ciclo en programación es la ejecución continua de un determinado bloque de código

mientras una condición asignada se cumple.
SENTENCIA FOR
El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista, tupla, conjunto,
diccionario) y ejecutar un bloque de código. En cada paso de la iteración se tiene en cuenta a un
único elemento del objeto iterable, sobre el cuál se pueden aplicar una serie de operaciones.
Su sintaxis es la siguiente:

Aquí, elem es la variable que toma el valor del elemento dentro del iterador en cada paso del
bucle. Este finaliza su ejecución cuando se recorren todos los elementos.
La clase range
Una de las iteraciones más comunes que se realizan, es la de iterar un número, por ejemplo,
entre 0 y N. Supongamos que queremos iterar una variable i de 0 a 3.
La clase range se usa para implementar y/o simular el ciclo for basado en una secuencia
numérica. El constructor de esta clase, range(max), devuelve un iterable cuyos valores van desde
0 hasta max - 1.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
El tipo de datos range se puede invocar con uno, dos e incluso tres parámetros:
range(max): Un iterable de números enteros consecutivos que empieza en 0 y acaba en max - 1
range(min, max): Un iterable de números enteros consecutivos que empieza en min y acaba en
max - 1
range(min, max, step): Un iterable de números enteros consecutivos que empieza en min acaba
en max - 1 y los valores se van incrementando de step en step. Este último caso simula el bucle
for con variable de control.
SENTENCIA WHILE
La sentencia o bucle while es una sentencia de control de flujo que se utiliza para ejecutar un
bloque de instrucciones de forma continuada mientras se cumpla una condición determinada.
El cuerpo del ciclo se ejecutará mientras una condición determinada sea verdadera. Es decir, si
la condición se cumple se ejecutará el cuerpo de dicho ciclo y al finalizar se volverá a comprobar
la condición, si continúa siendo verdadera pues se ejecutara nuevamente. Cuando se deje de
cumplir, se saldrá del ciclo y se continuará la ejecución normal. Llamaremos iteración a una
ejecución completa del bloque de código.
La estructura de esta sentencia es la siguiente:

Mientras condición se evalúe a True, se ejecutarán las instrucciones y sentencias de bloque de

código. Aquí, condición puede ser un literal, el valor de una variable, el resultado de una expresión
o el valor devuelto por una función.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Veamos cómo crear un menú de opciones muy sencillo:

En la primera parte del código se puede ver que creamos el ciclo debajo, en el cuerpo del mismo
colocamos un input para mostrarle al usuario las opciones y permitirle elegir una para
almacenarla en la variable “opcion”.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Dentro del cuerpo del ciclo, de acuerdo al ingreso de usuario se ejecuta una u otra tarea, en este
caso simplemente mostrar un mensaje.
También dentro del cuerpo del ciclo, pero hacia el final, usamos otro input para darle la posibilidad
al usuario de detener la ejecución o no del ciclo.

EXPRESIONES ANIDADAS

Las estructuras o flujos de control pueden anidarse, es decir, la ejecución de alguna de ellas se
encuentra dentro del bloque o cuerpo de código de otra y por lo tanto su ejecución dependerá de
la ejecución de esa otra.
Desarrollaremos el siguiente ejemplo: “Determinar cuáles son los 5 primeros números primos de
2 cifras”

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
COLECCIONES DE DATOS

Además de los tipos básicos, otros tipos fundamentales de Python son los tipos compuestos y
se utilizan para agrupar juntos varios valores. Entre ellos tenemos:
 Listas: son secuencias mutables de valores.
 Tuplas: son secuencias inmutables de valores.
 Conjuntos: se utilizan para representar conjuntos donde no pueden existir dos objetos
iguales dentro de él.
 Diccionarios: son tipos especiales de contenedores en los que se puede acceder a sus
elementos a partir de una clave única.
LISTAS
Las listas en Python son un tipo contenedor, compuesto, que se usan para almacenar conjuntos
de elementos relacionados del mismo tipo o de tipos distintos.Tienen la particularidad de ser
mutables, es decir, que su contenido se puede modificar después de haber sido creada.
Para crear una lista en Python, simplemente hay que encerrar una secuencia de elementos
separados por comas entre corchetes [].
Ejemplos de creación de listas:

Las listas también se pueden crear usando el constructor de la clase, list(iterable). En este caso,
el constructor crea una lista cuyos elementos son los mismos y están en el mismo orden que los
ítems del iterable. El objeto iterable puede ser o una secuencia, un contenedor que soporte la
iteración o un objeto iterador (más adelante explicaremos los conceptos de clase y de objeto
iterador).
Por ejemplo, el tipo str también es un tipo secuencia. Si pasamos un string al constructor list()
creará una lista cuyos elementos son cada uno de los caracteres de la cadena:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
También podemos crear listas sin especificar los elementos que contienen, porque al ser
mutables los podemos agregar después. A continuación, se muestran dos alternativas de crear
una lista vacía:

INDICES Y SLICING
Para acceder a un elemento de una lista se utilizan los índices. Un índice es un número entero
que indica la posición de un elemento en una lista. El primer elemento se encuentra en el índice
0. Por ejemplo, en una lista con 4 elementos, los índices de cada uno de los ítems serían 0, 1, 2
y 3.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Si se intenta acceder a un índice que está fuera del rango de la lista, el intérprete lanzará la
excepción IndexError.

Si se utiliza un índice que no es un número entero, se lanzará la excepción TypeError:

Como hemos visto, las listas pueden contener otros elementos de tipo secuencia de forma
anidada. Por ejemplo, una lista donde uno de sus ítems es otra lista. Del mismo modo, se puede
acceder a los elementos de estos tipos usando índices compuestos o anidados:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ACCESO A UN SUBCONJUNTO DE ELEMENTOS
También es posible acceder a un subconjunto de elementos de una lista utilizando rangos en los
índices. Esto es usando el operador [:]:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Otras tareas que pueden realizarse sobre una lista son:
 Recorrer una lista
 Añadir/Modificar/Eliminar elementos
 Determinar la longitud de la lista
 Determinar si un elemento pertenece a una lista
TUPLAS
La clase tuple en Python es un tipo contenedor, compuesto, que en un principio se pensó para
almacenar grupos de elementos heterogéneos, aunque también puede contener elementos
homogéneos. Tiene la particularidad de ser inmutables, es decir, que su contenido NO se puede
modificar después de haber sido creada.
En general, para crear una tupla en Python simplemente hay que definir una secuencia de
elementos separados por comas. Por ejemplo:

Otras formas de crear una tupla en Python:

 Tupla vacía: usa paréntesis () o el constructor tuple() sin parámetros.
 Tupla con un único elemento: elem, o (elem, ). Siempre se añade una coma.
 Usando el constructor tuple(iterable), donde el constructor crea una tupla cuyos
elementos son los mismos y en el mismo orden que los del iterable.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
INDICES Y SLICING
Para acceder a un elemento de una tupla se utilizan los índices. Un índice es un número entero
que indica la posición de un elemento en una tupla. El primer elemento de una tupla siempre
comienza en el índice 0.
Por ejemplo, en una tupla con 3 elementos, los índices de cada uno de los ítems serían 0, 1 y 2.

Al igual que con Listas, si se intenta acceder a un índice que está fuera del rango de la tupla, el
intérprete lanzará la excepción IndexError. Sii se utiliza un índice que no es un número entero,
se lanzará la excepción TypeError:
También es posible acceder a un subconjunto de elementos de una tupla utilizando el operador
[:].
Los ejemplos de estas tareas son idénticos a los mostrados en la sección de listas, usando tuple
en vez de list.
MODIFICAR UNA TUPLA
Como ya se indicó, las tuplas son objetos inmutables. No obstante, las tuplas pueden contener
objetos u otros elementos de tipo secuencia, por ejemplo, una lista. Estos objetos, si son
mutables, sí se pueden modificar:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Otras tareas que pueden realizarse sobre una tupla son:

 Recorrer la tupla
 Determinar la longitud de la tupla
 Determinar si un elemento pertenece a una tupla
Recuerda que las tuplas son un tipo secuencial que no se puede modificar. Se usan cuando no
quieres que los elementos de una lista se deban modificar o para almacenar las claves de un
diccionario.

CONJUNTOS
El tipo set en Python es utilizado para trabajar con conjuntos de elementos. La principal
característica de este tipo de datos es que es una colección cuyos elementos no guardan ningún
orden y que además son únicos.
Estas características hacen que los principales usos de esta clase sean conocer si un elemento
pertenece o no a una colección y eliminar duplicados de un tipo secuencial (list, tuple o str).
Además, esta clase también implementa las típicas operaciones matemáticas sobre conjuntos:
unión, intersección, diferencia, etc.
Para crear un conjunto, basta con encerrar una serie de elementos entre llaves {}, o bien usar el
constructor de la clase set() y pasarle como argumento un objeto iterable (como una lista, una
tupla, una cadena).

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Para crear un conjunto vacío, simplemente llama al constructor set() sin parámetros.

ACCESO A LOS ELEMENTOS DE UN CONJUNTO

Dado que los conjuntos son colecciones desordenadas, en ellos no se guarda la posición en la
que son insertados los elementos como ocurre en los tipos list o tuple.
Es por ello que no se puede acceder a los elementos a través de un índice. Sin embargo, sí se
puede acceder y/o recorrer todos los elementos de un conjunto usando un bucle for:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Además de las tareas mencionadas para otros tipos de datos:

 Añadir/Eliminar un elemento
 Determinar el número de elementos
 Comprobar si un elemento está en un conjunto
En particular podemos agregar las operaciones del álgebra de conjuntos:
 Unión
 Intersección
 Diferencia
 Diferencia Simétrica
 Inclusión de conjuntos
 Conjuntos disjuntos
 Igualdad
RECORRER LOS ELEMENTOS DE UN OBJETO ITERABLE
El bucle for se utiliza para recorrer los elementos de un objeto iterable (lista, tupla, conjunto,
diccionario) y ejecutar un bloque de código. En cada paso de la iteración se tiene en cuenta a un
único elemento del objeto iterable, sobre el cuál se pueden aplicar una serie de operaciones.
Su sintaxis es la siguiente:

Aquí, elem es la variable que toma el valor del elemento dentro del iterador en cada paso del
bucle. Este finaliza su ejecución cuando se recorren todos los elementos.
Si tenemos una lista de números y queremos mostrarlos por consola podríamos hacer:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Ahora, si tenemos una lista de números y queremos mostrar por consola solo aquellos que son
pares, podríamos hacer:

ITERACIÓN EN LISTAS
En el siguiente ejemplo definiremos una lista de palabras y un ciclo para iterarla, luego a cada
ítem le calculamos su longitud, es decir la cantidad de caracteres de cada palabra, usando la
función len, además mostramos esta información.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ITERACIÓN EN CADENAS DE TEXTO
Veremos su uso desarrollando el siguiente ejemplo, donde definimos una cadena determinada y
contamos cuántas letras ‘a’ posee la misma.

FUNSIONES

Las funciones en Python, y en cualquier lenguaje de programación, son estructuras esenciales

de código.
Una función es un grupo de instrucciones que constituyen una unidad lógica del programa
y resuelven un problema muy concreto.
Como unidades lógicas de un programa tienen un doble objetivo:

 Dividir y organizar el código en partes más sencillas.

 Encapsular el código que se repite a lo largo de un programa para ser reutilizado.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Python define un conjunto de funciones que podemos utilizar directamente en nuestras
aplicaciones, se denominan nativas o predefinidas o integradas. Ya hemos utilizado algunas de
ellas, como la función len(), que obtiene el número de elementos de un objeto contenedor como
una lista, una tupla, un diccionario o un conjunto. También hemos visto la función print(), que
muestra por consola un texto.
Sin embargo, como programadores, podemos definir nuestras propias funciones para estructurar
el código de manera que sea más legible y para reutilizar aquellas partes que se repiten a lo
largo de una aplicación. Esto es una tarea fundamental a medida que va creciendo el número de
líneas de un programa.
El diseño de funciones parte de los siguientes principios:
 El principio de reusabilidad, si tenemos un fragmento de código usado en muchos sitios,
la mejor solución sería pasarlo a una función. Nos evitaría tener código repetido y
modificarlo sería más fácil, ya que bastaría con cambiar la función una vez.
 Y el principio de modularidad, en vez de escribir largos trozos de código, es mejor crear
módulos o funciones que agrupen fragmentos en funcionalidades específicas, haciendo
que el código resultante sea más fácil de leer.
FUNCIONES PREDEFINIDAS EN PYTHON
Vamos a describir algunas funciones internas más utilizadas y conocidas. Indicaremos su nombre
y los argumentos necesarios para invocarlas acompañadas de un ejemplo de uso.
Funciones Numéricas

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Funciones de Cadena

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Otras funciones útiles

DEFINICIÓN DE UNA FUNCIÓN

La siguiente imagen muestra el esquema de una función en Python:

Para definir una función se utiliza la palabra reservada def. A continuación el nombre o
identificador de la función que es el que se utiliza para invocarla. Después del nombre hay que
incluir los paréntesis y una lista opcional de parámetros. La cabecera o definición de la función
termina con dos puntos.
Tras los dos puntos se incluye el cuerpo de la función (identado) que es el conjunto de
instrucciones que se encapsulan en dicha función y que le dan significado.
En último lugar y de manera opcional, se añade la instrucción con la palabra reservada return
para devolver un resultado.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Para usar o invocar a una función, simplemente hay que escribir su nombre pasando los
argumentos necesarios según los parámetros que defina la función.
Por lo tanto, los identificadores que se colocan al DEFINIR la función se denominan
PARÁMETROS y los identificadores que se utilizan en la INVOCACIÓN de la función se llaman
ARGUMENTOS. Es decir que los argumentos son los valores que se actualizan en el cuerpo de
la función a través de los parámetros.
Veamos un ejemplo, donde simulamos una calculadora que realiza las operaciones básicas, el
usuario ingresa dos operandos y puede elegir cuál operación realizar y además decidir si quiere
realizar otro cálculo o no.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En la sección 1 se definen las cuatro funciones correspondientes al cálculo que habrá disponible,
pero aún no son llamadas, osea no son utilizadas.
En la sección 2 se crea un bucle o ciclo (que se repite mientras el usuario ingresa una opción
distinta a “N”). Se solicitan los valores para ser operados y la operación deseada.
En la sección 3 se determina cuál operación eligió el usuario y se invoca a una de las cuatro
funciones diseñadas.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En la sección 4 se da la posibilidad al usuario de realizar otra operación con otros elementos. Si
ingresa “N”, se detiene el ciclo y termina el programa, si ingresa cualquier otro carácter el ciclo
vuelve a iterar.

ARGUMENTOS

ARGUMENTO DE ENTRADA
Empecemos por una función sencilla sin parámetros de entrada ni salida.

Luego de definir la función, el siguiente paso es invocarla y ver los resultados.

Ahora usaremos un argumento de entrada, modificaremos un poco la salida.

Por defecto, los valores de los argumentos se asignan a los parámetros en el mismo orden en el
que se los pasa al llamar a la función. Luego veremos que esto puede cambiar. Veamos un
ejemplo de en qué afecta el orden de los parámetros.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
PARÁMETROS POR VALOR Y PARÁMETROS POR REFERENCIA
Una función puede definir, opcionalmente, una secuencia de parámetros que poseen una
característica muy importante.
Paso por valor: Un lenguaje de programación que lo utiliza, lo que hace es copiar el valor de las
variables en los respectivos parámetros. Cualquier modificación del valor del parámetro, no
afecta a la variable externa correspondiente.
● Paso por referencia: Un lenguaje de programación que lo utiliza, lo que hace es copiar en los
parámetros la dirección de memoria de las variables que se usan como argumento. Hacen
referencia al mismo objeto y cualquier modificación del valor en el parámetro afectará a la variable
externa correspondiente.
En Python, si el tipo de dato que se pasa como argumento es inmutable, cualquier modificación
en el valor del parámetro no afectará a la variable externa pero, si es mutable (como una lista o
diccionario), sí se verá afectado por las modificaciones.
Veamos un ejemplo de paso por valor.

Veamos un ejemplo de paso por referencia.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ARGUMENTOS IDETERMINADOS

ARGS vs KWARGS
Python nos permite crear funciones que acepten un número indefinido de parámetros sin
necesidad de que todos ellos aparezcan en la cabecera de la función. Los operadores * y ** son
los que se utilizan para esta funcionalidad.
*Args
El parámetro especial *args en una función se usa para pasar, de forma opcional, un número
variable de argumentos posicionales.

 Quien indica que el parámetro es de este tipo es el símbolo ‘*’, el nombre args se usa por
convención.
 El parámetro recibe los argumentos como una tupla.
 Es un parámetro opcional.
 El número de argumentos al invocar a la función es variable.
 Son parámetros posicionales, es decir, su valor depende de la posición en la que se pasen
a la función.
La siguiente función toma dos parámetros y devuelve la suma de los mismos:

Si llamamos a la función con los valores 2 y 3, el resultado devuelto será 5.

Pero, ¿si necesitamos sumar un valor más?

Una posible solución sería agregar parámetros, pero tampoco sabríamos cuántos.
La mejor solución y más elegante es hacer uso de *args en la definición de esta función. De este
modo, podemos pasar tantos argumentos como queramos.
Primero hay que rediseñar la función sum y con esa nueva implementación, podemos llamar a la
función con cualquier número variable de valores:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
El comportamiento de la función siempre es el mismo, con independencia del número de
argumentos que pasamos.
Con esto resolvemos nuestro problema inicial, en el que necesitábamos un número variable de
argumentos.
*Kwargs
El parámetro especial **kwargs en una función se usa para pasar, de forma opcional, un número
variable de argumentos con nombre.
Las principales diferencias con respecto *args son:

 Lo que indica que el parámetro es de este tipo es el símbolo ‘**’, el nombre kwargs se usa
por convención.
 El parámetro recibe los argumentos como un diccionario.
 Al tratarse de un diccionario, el orden de los parámetros no importa. Los parámetros se
asocian en función de las claves del diccionario.
Este tipo de parámetros es muy útil al realizar consultas sobre una base de datos, tema que
veremos y ejemplificaremos más adelante.
Al combinar parámetros en la definición de una función hay que tener muy en cuenta el orden.
Tanto *args como **kwargs pueden aparecer de forma conjunta o individual, pero siempre al final
y de la siguiente manera:
def ejemplo(arg1, arg2, *args, **kwargs)
En resumen:

 Utiliza *args para pasar de forma opcional a una función un número variable de
argumentos posicionales.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
  El parámetro *args recibe los argumentos como una tupla.
 Emplea **kwargs para pasar de forma opcional a una función un número variable de
argumentos con nombre.
 El parámetro **kwargs recibe los argumentos como un diccionario.
Por último, utilizar *args y **kwargs ahorra tiempo y esfuerzo en cuanto a análisis e
implementación dado que flexibiliza el diseño de funciones, pero su uso indiscriminado puede
originar resultados inesperados cuya revisión y arreglo nos podría llevar más tiempo aún que el
diseño estratégico original.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
 EJE III: PERSISTENCIA DE DATOS.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
DICCIONARIOS.

La clase dict de Python es un tipo mapa que asocia claves a valores. A diferencia de los tipos
secuenciales como list, tuple o str, que son indexados por un índice numérico, los diccionarios
son indexados por claves. Estas claves siempre deben ser de un tipo inmutable, concretamente
un tipo hashable (un objeto es hashable si tiene un valor de hash que no cambia durante todo su
ciclo de vida).
Piensa en un diccionario como un contenedor de pares clave:valor, en el que la clave puede ser
de cualquier tipo hashable y es única en el diccionario que la contiene. Generalmente, se suelen
usar como claves los tipos int y str.
Las principales operaciones con diccionarios son:

 Almacenar un valor asociado a una clave

 Recuperar un valor a partir de una clave.
Esta es la esencia de los diccionarios y es aquí donde son realmente importantes. En un
diccionario, el acceso a un elemento a partir de una clave es una operación rápida, eficaz y que
consume pocos recursos si se compara con la forma en que se hace con otros tipos de datos.
Otras características para resaltar de los diccionarios:

 Es un tipo mutable, es decir, su contenido se puede modificar después de haber sido

creado.
 Es un tipo ordenado. Preserva el orden en que se insertan los pares clave: valor.
Creación de Diccionarios
La más simple es encerrar una secuencia de pares clave:valor separados por comas entre llaves
{}.

En el diccionario anterior, los enteros 1 y 89 y las cadenas 'a' y 'c' son las claves. Es posible
mezclar claves y valores de distinto tipo sin problema.
Para crear un diccionario vacío, simplemente asigna a una variable el valor {}.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
También se puede usar el constructor de la clase dict() de varias maneras:

 Sin parámetros. Esto creará un diccionario vacío.

 Con pares clave: valor encerrados entre llaves.
 Con argumentos con nombre. El nombre del argumento será la clave en el diccionario.
En este caso, las claves solo pueden ser identificadores válidos y mantienen el orden en
el que se indican. No se podría, por ejemplo, tener números enteros como claves.
 Pasando un iterable. En este caso, cada elemento del iterable debe ser también un
iterable con solo dos elementos. El primero se toma como clave del diccionario y el
segundo como valor. Si la clave aparece varias veces, el valor que prevalece es el último.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ACCESO A LOS ELEMENTOS DE UN DICCIONARIO
Acceder a un elemento de un diccionario es una de las principales operaciones por las que existe
este tipo de dato. El acceso a un valor se realiza mediante indexación de la clave. Para ello,
simplemente encierra entre corchetes la clave del elemento D[clave]. En caso de que la clave no
exista, se lanzará la excepción KeyError.

La clase dict también ofrece el método get(clave[, valor por defecto]). Este método devuelve el
valor correspondiente a la clave clave. En caso de que la clave no exista no lanza ningún error,
sino que devuelve el segundo argumento valor por defecto. Si no se proporciona este argumento,
se devuelve el valor None.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Otras tareas que pueden realizarse sobre un diccionario son:

 Recorrer el diccionario
 Añadir/Modificar/Eliminar un elemento
 Determinar el número de elementos
 Comprobar si un elemento está en un diccionario
 Comparar/Anidar diccionarios
 Obtener listado de clave de un diccionario

FICHEROS.

Prácticamente todo lo que hemos hecho hasta aquí fue crear pequeños scripts que manejan
información sobre la marcha, es decir, se definen variables asignando valores, o se ingresa por
teclado para luego manipularla, sin embargo imaginemos que debemos trabajar con un gran
caudal de datos, por ejemplo llevar un registro de asistencia a clases y notas de alumnos que
rindieron exámenes para determinar su condición de “regular” o “libre”, para ello podríamos crear
variables en el programa y asignar valores, pero tenemos al menos dos inconvenientes, simular
la situación nos consumiría el uso de demasiadas variables y aun así hay situaciones que no
podríamos reflejar, también podríamos pedir el ingreso estos valores por teclado pero luego de
cerrar el programa los perderíamos.
Lo que necesitamos es que nuestra información sea persistente y nos permita seguir trabajando
la próxima vez que abramos el programa. Existen dos maneras de trabajar con datos
persistentes, organizados en ficheros o almacenados en una base de datos.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Un fichero es un conjunto de bits almacenados en un dispositivo de memoria persistente,
normalmente un disco duro. Este conjunto de información se identifica con un nombre (el nombre
del fichero) y la dirección de la carpeta o directorio que lo contiene. Todos, absolutamente todos
los ficheros se localizan en un directorio determinado que se conoce como la ruta del fichero.
Se conocen también como archivos porque son equivalentes digitales a los archivos escritos por
ejemplo en expedientes o libretas alojados en una oficina tradicional.
Otra cosa importante es que los ficheros se suelen identificar también con una extensión (tex,
doc, csv, etc.). Una extensión es un código que se escribe después del nombre, con un punto y
varios caracteres y que nos permite identificar varios ficheros de un mismo tipo. En realidad esto
no deja de ser una formalidad, ya que a nuestros programas no les importa la extensión, sino
cómo deben interpretar los datos que hay escritos dentro.
Las operaciones que nos permiten los ficheros son:

 Creación: Proceso por el cual creamos un fichero en el disco.

 Apertura: Proceso por el cual abrimos un fichero para comenzar a trabajar.
 Cierre: Proceso por el cual cerramos un fichero para dejar de trabajar con él.
 Extensión: Proceso por el cual añadimos información al fichero.
Es posible realizar varias operaciones a la vez, como creación y apertura en la misma instrucción.
Sin embargo es necesario abrir un fichero para poder extenderlo o cerrarlo.
También debemos conocer el concepto de puntero que es la manera en cómo el ordenador
accede y escribe en el fichero correctamente. Hay que imaginar el puntero como si fuera el dedo
del ordenador mientras recorre el fichero, igual que nosotros seguimos con el dedo un texto
mientras lo leemos y así sabemos por dónde vamos.
El puntero es muy importante para evitar sobrescribir información.
CREACIÓN Y ESCRITURA
Veamos un ejemplo para crear y escribir dentro de un archivo de texto:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Se genera el siguiente archivo, que puede ser descargado en la computadora personal:

LECTURA

En este ejemplo leeremos el contenido de un archivo de texto y los mostraremos en pantalla:

Podemos usar el método readlines() del fichero para generar una lista con las líneas:

También se puede leer un fichero utilizando la instrucción estándar with de la siguiente forma:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
EXTENSIÓN (AGREGAR DATOS)
Este modo nos permite añadir datos al final de un fichero:

Observemos cómo quedó el archivo:

La variante 'a+' permite crear el fichero si no existe, usaremos otro archivo que no fue creado
antes:

El archivo_NUEVO.txt no existía, pero fue creado y además se agregó la línea deseada.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Es posible posicionar el puntero en el fichero manualmente usando el método seek e indicando
un número de caracteres para luego leer una cantidad de caracteres con el método read:

Para posicionar el puntero justo al inicio de la segunda línea, podríamos ponerlo justo en la
longitud de la primera:

Se puede abrir un fichero en modo lectura con escritura, pero éste debe existir previamente.
Además por defecto el puntero estará al principio y si escribimos algo sobre escribiremos el
contenido actual.
El siguiente ejemplo muestra detalladamente cómo hacerlo, tengan en cuenta los saltos de línea
y los caracteres especiales:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Archivo generado:

MODIFICAR UNA LÍNEA

Para lograr este fin lo mejor es leer todas las líneas en una lista, modificar la línea en la lista,
posicionar el puntero al principio y reescribir de nuevo todas las líneas:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Luego de esta serie de ejemplos para manipular ficheros podemos hacer el siguiente resumen:
La función open() requiere dos argumentos de entrada, el nombre del fichero y el modo de
apertura del fichero.

 ‘r’: Para leer el fichero.

 ‘w’: Para escribir en el fichero.
 ‘a’: Para añadir contenido a un fichero existente.
 ‘a+’: Para añadir contenido a un fichero existente o que aún no exista.
Otra cosa que debemos hacer cuando trabajamos con ficheros en Python, es cerrarlos una vez
que ya hemos acabado con ellos. Aunque es verdad que el fichero normalmente acabará
siendo cerrado automáticamente, es importante especificarlo para evitar tener comportamientos
inesperados.
Por lo tanto si queremos cerrar un fichero sólo tenemos que usar la función close() sobre el
mismo. Por lo tanto tenemos tres pasos:

 Abrir el fichero que queramos indicando el modo de hacerlo

 Usar el fichero para recopilar o procesar los datos que necesitábamos.
 Cuando hayamos acabado, cerramos el fichero.

FICHEROS CSV

El formato CSV (Comma Separated Values) es uno de los más comunes y sencillos para
almacenar una serie de valores como si de una tabla se tratara.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Cada fila se representa por una línea diferente, mientras que los valores que forman una columna
aparecen separados por un carácter concreto. El más común de los caracteres empleados para
esta separación es la coma, de ahí el nombre del formato.
Sin embargo, es habitual encontrar otros caracteres como el signo del dólar ($) o el punto y coma
(;). Gracias al formato CSV es posible guardar una serie de datos, representados por una tabla,
en un simple fichero de texto. Además, software para trabajar con hojas de cálculo, como, por
ejemplo, Microsoft Excel o Calc LibreOffice, nos permiten importar y exportar datos en este
formato.
Dentro de su librería estándar, Python incorpora un módulo específico para trabajar con ficheros
CSV, que nos permite, tanto leer datos, como escribirlos.
Son dos los métodos básicos que nos posibilitan realizar estas operaciones: reader() y writer().
El primero de ellos sirve para leer los datos contenidos en un fichero CSV, mientras que el
segundo nos ayudará a la escritura.

ESCRITURA DE LISTAS EN CSV

Archivo generado:

LECTURA DE LISTAS EN CSV

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ESCRITURA DE DICCIONARIOS EN CSV

Archivo generado:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
LECTURA DE DICCIONARIOS EN CSV

FICHEROS JSON

El formato JSON se ha convertido en uno de los más populares para la serialización e intercambio
de datos, sobre todo en aplicaciones web que utilizan AJAX. Recordemos que esta técnica
permite intercambiar datos entre el navegador cliente y el servidor sin necesidad de recargar la
página.
JSON son las siglas en inglés de JavaScript Object Notation y fue definido dentro de uno de
los estándares (ECMA- 262) en los que está basado el lenguaje JavaScript. Es en este lenguaje
donde, a través de una simple función (eval()), podemos crear un objeto directamente a través
de una cadena de texto en formato JSON. Este factor ha contribuido significativamente a que
sean muchos los servicios web que utilizan JSON para intercambiar datos a través de AJAX, ya
que el análisis y procesamiento de datos es muy rápido. Incluso, son muchas las que han
sustituido el XML por el JSON a la hora de intercambiar datos entre cliente y servidor.
Para estructurar la información que contiene el formato, se utilizan las llaves ({}) y se definen
pares de nombres y valor separados entre ellos por dos puntos. De esta forma, un sencillo
ejemplo en formato JSON, para almacenar la información de un empleado, sería el siguiente:
{"apellidos": "Fernández Rojas", "nombre": "José Luis", "departamento": "Finanzas",
"ciudad": "Madrid"}
JSON puede trabajar con varios tipos de datos como valores; admite cadenas de caracteres,
números, booleanos, listas y null. La mayoría de los lenguajes modernos de programación
incluyen API y/o librerías que permiten trabajar con datos en formato JSON.
En Python disponemos de un módulo llamado json que forma parte de la librería estándar del
lenguaje. Básicamente, este método cuenta con dos funciones principales, una para codificar y
otra para descodificar. El objetivo de ambas funciones es traducir entre una cadena de texto con
formato JSON y objetos de Python.
Obviamente, utilizando las funciones de ficheros de Python podemos leer y escribir ficheros que
contengan datos en este formato. No obstante, debemos tener en cuenta que las funciones
contenidas en json no permiten trabajar directamente con ficheros, sino con cadenas de texto.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ESCRITURA DE DATOS EN JSON

Contenido del archivo JSON

LECTURA DE DATOS EN JSON

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
BASES DE DATOS EN PYTHON.

Los pasos a seguir para conectar y usar una Base de Datos son:
Abrir/Crear la conexión
1. Crear puntero
2. Ejecutar una consulta SQL (query)
3. Administrar los resultados de la consulta
a. Insertar (Create)
b. Leer (Read)
c. Actualizar (Update)
d. Borrar (Delete)
4. Cerrar puntero
5. Cerrar conexión
CONEXIÓN A LA BASE DE DATOS, CREACIÓN Y DESCONEXIÓN
Al realizar la conexión, si la base de datos no existe, entonces la crea. Siempre debe cerrarse la
conexión al finalizar el uso, sino luego no se podrá seguir manipulándola.

CREAR UNA TABLA

Antes de ejecutar una consulta (query) en código SQL, tenemos que crear un cursor:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
INSERCIÓN O CARGA DE DATOS EN UNA TABLA
CARGAR UNA TUPLA

CARGAR VARIAS TUPLAS

Insertando varios registros con .executemany():

LECTURA DE DATOS EN UNA TABLA

LECTURA DE UNA TUPLA
Recuperando el primer registro con .fetchone():

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
LECTURA MÚLTIPLE
Recuperando varios registros con .fetchall():

ACTUALIZAR/MODIFICAR UN DATO EN UNA TABLA

Indicamos cuál campo queremos modificar, con qué valor lo haremos y a cuáles filas afectará el
cambio:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
ELIMINAR UN REGISTRO DE UNA TABLA
Indicamos cuál registro/fila queremos eliminar de acuerdo a alguna condición de alguno de los
campos:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
 EJE IV: PARADIGMA ORIENTADO A OBJETO.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
PROGRAMACION ESTRUCTURADA VS POO

Programación Estructurada.
Usando programación estructurada, de cierto modo, los programas son más fáciles de entender.
Un programa estructurado puede ser leído en secuencia, de arriba hacia abajo, sin necesidad de
estar saltando de un sitio a otro en la lógica. La estructura del programa es más clara puesto que
las instrucciones están más relacionadas entre sí, por lo que es más fácil comprender lo que
hace cada función. Algunas de sus ventajas son:

 Reducción del esfuerzo en las pruebas. El programa se puede tener listo para producción
normal en un tiempo menor del tradicional; por otro lado, el seguimiento de las fallas se
facilita debido a la lógica más visible, de tal forma que los errores se pueden detectar y
corregir más fácilmente. Programas más sencillos y rápidos.
 Aumento de la productividad del programador. Los programas quedan mejor
documentados internamente. La programación estructurada permite la escritura de
programas fáciles de leer y modificar. En un programa estructurado el flujo lógico se
gobierna por tres estructuras de control básico: secuenciales, repetitivas y selectivas.
Programación Orientada a Objetos (POO).
La Programación Orientada a Objetos (POO) es una forma especial de programar, más cercana
a la forma de expresar las cosas en la vida real que otros tipos de programación.
Con la POO tenemos que aprender a pensar las cosas de una manera distinta, para escribir
nuestros programas en términos de objetos, propiedades, métodos y otros conceptos nuevos.
Algunas de sus ventajas son:

 Reusabilidad: Cuando hemos diseñado adecuadamente las clases, se pueden usar en

distintas partes del programa y en numerosos proyectos.
 Mantenibilidad: Debido a la sencillez para abstraer el problema, los programas orientados
a objetos son más sencillos de leer y comprender, pues nos permiten ocultar detalles de
implementación dejando visibles sólo aquellos detalles más relevantes.
 Modificabilidad: La facilidad de añadir, suprimir o modificar nuevos objetos nos permite
hacer modificaciones de una forma muy sencilla.

CLASE, OBJETO, Y ATRIBUTOS.

Dentro del contexto de la POO, un objeto es un componente que tiene un rol específico y que
puede interactuar con otros. Se trata de establecer una equivalencia entre un objeto del mundo
real con un componente software. De esta forma, el modelado para la representación y resolución
de problemas del mundo real a través de la programación es más sencillo e intuitivo.
Si miramos a nuestro alrededor, todos los objetos presentan dos componentes principales: un
conjunto de características y propiedades y un comportamiento determinado. Por ejemplo,
pensemos en un auto. Esta tiene características como color, marca y modelo. Asimismo, su
comportamiento puede ser descrito en función de las operaciones que puede realizar, por
ejemplo, frenar, acelerar o girar. De la misma forma, en programación, un objeto puede tener
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
atributos y se pueden definir operaciones que puede realizar. Los atributos equivaldrían a las
características de los objetos del mundo real y las operaciones se relacionan con su
comportamiento.
Es importante distinguir entre clase y objeto. Para ello, introduciremos un nuevo concepto: la
instancia. La definición de los atributos y operaciones de un objeto se lleva a cabo a través de
una clase. La instanciación es un mecanismo que nos permite crear un objeto que pertenece a
una determinada clase. De esta forma, podemos tener diferentes objetos que pertenezcan a la
misma clase.
Definir Clases.
Lo primero es crear una clase, para ello usaremos el ejemplo del auto.
Class auto:
Pass
Se trata de una clase vacía y sin mucha utilidad práctica, pero es la mínima clase que podemos
crear. En realidad, el uso del “pass” no hace realmente nada, pero se generaría un error si
después de los “:” no tenemos contenido. Ahora que tenemos la clase, podemos crear un objeto
de la misma. Podemos hacerlo como si se tratase de una variable normal. Nombre de la variable
igual a la clase con los (). Dentro de los paréntesis irían los parámetros de entrada si los hubiera.
Mi_auto = auto()
Definir Atributos.
Empecemos creando un par de atributos para nuestro auto, recordemos que los atributos son las
características de los objetos, como bien podrían ser la marca y el modelo. Para ello podemos
hacer lo siguiente

Si bien esta es una forma sencilla de definir y establecer atributos a una clase, lo correcto seria
dejar que el usuario ingrese sus datos, esto puede realizarse colocando un input() en los campos
que deseamos que el usuario ingrese sus propios datos.

De esta forma el usuario puede ingresar sus datos, haciendo que el programa sea más útil.
Instituto Superior Del Milagro Nº 8207 (Salta)
Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En este punto, los atributos que definimos anteriormente se denominan atributos de clase,
existen otro tipo de atributo, como los de instancia que veremos cuando desarrollemos el termino
de métodos.

MÉTODOS.

Los métodos son como la función o el comportamiento de los objetos, por ejemplo en el caso de
una mesa, los atributos serian sus características como ser el color, la cantidad de patas, etc. Y
sus métodos seria su funcionalidad como sostener objetos.
Para el caso de nuestro auto su funcionalidad o métodos podrían ser arrancar, girar, detenerse,
etc.
Otra característica que presentan los objetos, o más bien otra funcionalidad es la capacidad de
“presentarse”, es decir mostrar sus características o sea sus atributos.
Para ejemplificar lo anteriormente dicho, supongamos que necesitamos crear un programa que
gestione alumnos, los alumnos son personas, por lo tanto podríamos hacer una clase llamada
persona.

Ahora estas personas tiene características diferentes como por ejemplo apellido, nombre y DNI,
estas características serian los atributos de la clase.

Como dijimos anteriormente estas personas son capaces de “presentarse”, esto es una acción o
una funcionalidad de la clase, por lo que se lo conoce como método.
Los métodos pueden ser vistos como funciones o procedimientos que solo pertenece a una clase
y solo esta puede utilizarlo, se lo define de la siguiente manera.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Expliquemos un poco el código que recién agregamos. Primero se debe colocar la palabra
reservada “def” seguida del nombre del método, en este caso se llama decir_nombre, luego se
abre y cierra paréntesis, dentro de estos paréntesis se puede colocar parámetros como si de una
función común se tratase, sin embargo, los métodos deben tener si o si como primer parámetro
a la palabra reserva “self”, luego pueden llevar cualquier cantidad de otros parámetros como ser
variables, listas, etc. Finalmente se colocan los dos puntos que hacen referencia a que se termino
de declarar el método y a continuación, debajo y con una identacion, se comienza a escribir el
código del método.
Para este ejemplo nosotros necesitamos que el método “decir_nombre” simplemente nos
muestra cual es el contenido del atributo “nombre, para ello hacemos lo siguiente.

Para poder saber si el método esta funcionando correctamente, debemos crear una instancia de
la clase Persona y luego “invocar” o “llamar” al método “decir_nombre”

Para poder “llamar” al método se debe colocar el nombre de la instancia, en este caso “persona1”
seguido de un punto y recién el nombre del método a invocar.
Ahora que hemos conocidos que son los métodos a grandes rasgos, debemos saber que existe
una variedad de tipos de métodos, algunos son “especiales” como por ejemplo los métodos
“mágicos” y otros más comunes como los métodos de clase e instancia.
Método Constructor.
Dentro de los métodos mágicos existe uno llamado método constructor, este método es muy
importante ya que se ejecuta cuando se esta creando el objeto y como su nombre lo indica, se
encarga de construir al objeto según las especificaciones que nosotros establezcamos.
Los atributos pueden definirse y establecerse con el método constructor, de esta manera los
atributos se convierten en atributos de instancia.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En este caso modificamos el código de la Clase Persona y le agregamos un método constructor
y transformamos sus atributos en atributos de instancia, esto quiere decir que ahora los atributos
de definen y establecen dentro del método constructor.
El método constructor es como una función por lo tanto se escribe la palabra reservada “def”,
luego se coloca el doble guion bajo el cual indica que es un método mágico, seguido de la palabra
reservada “init” y de nuevo el doble guion bajo, finalmente se abre y cierra paréntesis en donde
se pueden colocar parámetros de entrada. Estos parámetros generalmente son los que se va a
establecer en los atributos, sin embargo, siempre debe llevar el parámetro “self” que hace
referencia a la propia clase.
Dentro del método constructor se crean los atributos de la clase, para ello se coloca la palabra
reservada “self”, que viene de los parámetros de entrada, seguida de un punto y luego el nombre
que se le dará al atributo. Luego uno puede decidir si darle algún valor que llega de los
parámetros o se los podemos poner como algún literal. En el ejemplo anterior se coloco a los
atributos nombre, apellido y dni los datos que llegan como parámetros del método constructor.
Finalmente modificamos el método “decir_nombre”. Al convertirse en un atributo de instancia
para poder visualizar su contenido debemos utilizar la palabra reservada “self” luego un punto y
a continuación nos dejara elegir cual atributo mostrar de los que hallamos definido en el método
constructor.
Esta nueva forma de definir y establecer atributos, a través del método constructor, es la forma
correcta de hacerlo y es la forma en la que lo haremos a partir de ahora.
Setters y Getters.
Como dijimos anteriormente, un comportamiento (método), que tienen los objetos es el poder
“decir” o mostrar los datos de sus atributos, por ejemplo, en el caso de la clase persona, podemos
ver los datos que están guardados en los atributos apellido, nombre y DNI.
Cuando definimos un método para que una clase muestre sus datos, decimos que estamos
creando un getter.
Además de mostrar sus datos, las clases también pueden definir métodos para que los datos
alojados en los atributos puedan ser modificados, estos métodos se conocen como Setters.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
En este ejemplo el setter se llama “poner_nombre” y recibe como parámetro, aparte del
parámetro obligatorio self, un nombre que será el que reemplazará al anterior dato que se alojaba
en el atributo.
Es común y aconsejable que cada atributo de la clase tenga su par de setter y getter, sin
embargo, no es obligatorio, se puede crear un getter que muestre todos los atributos de una sola
vez.
Una de las características mas potentes y la razón por la que el paradigma es el mas utilizado,
es gracias a la capacidad de reutilización de código, y esta capacidad es gracias al concepto de
Herencia.

HERENCIA.

La herencia permite a los programadores crear clases que se basan en clases existentes, y esto
permite que una clase creada a través de la herencia herede los atributos y métodos de la clase
principal. Esto significa que la herencia admite la reutilización del código.
La clase de la que hereda una clase se llama padre o superclase. Una clase que hereda de una
superclase se llama subclase, también llamada clase heredera o clase hija.
Desarrollaremos el ejemplo de una tienda que vende 3 tipos de productos: adornos, alimentos y
libros. Todos los productos de la tienda tenían una serie de atributos comunes, como la
referencia, el nombre, el precio, pero algunos son específicos de cada tipo.
La idea de la herencia es identificar una clase base (la superclase) con los atributos comunes y
luego crear las demás clases heredando de ella (las subclases) y extendiendo sus campos
específicos. En nuestro caso esa clase sería el Producto en sí mismo:

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
Subclases
Para heredar los atributos y métodos de una clase en otra sólo tenemos que pasarla entre
paréntesis durante la definición.

En el código de ejemplo, creamos una clase llamada Alimento que hereda de la clase padre
llamada Producto, ya que un Alimento es un Producto.
Además de heredar todos sus atributos y métodos de la clase padre, también debemos crear los
atributos y métodos particulares de la clase hijo. Para ello primero debemos crear un método
constructor donde le pasaremos todos los atributos requeridos por la clase padre, en el ejemplo
serian referencia, nombre, precio y descripción. También debes agregar el parámetro necesario
para el atributo propio de la clase hija.
Una vez definido el método constructor, debemos llamar al método constructor pero de la clase
padre, esto se hace con la función super().
Dentro de dicha función, se pasan los parámetros particulares de la clase padre, como los son
referencia, nombre, precio y descripción.
Por último, solo queda crear los atributos particulares de la clase hijo y asignarles datos como lo
hacíamos de forma habitual.

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com
 Bibliografía

 Fundamentos de Programación 4ta Edicion. L. Joyanes Aguilar. Mc Graw Hill. 2008

 Metodología de la Programación 3ra Edición. O. Cairó. Alfaomega. 2005
 Python para todos. R. Gonzalez Duque. Licencia Creative Commons Reconocimiento 2.5 España.
 Python 3 al descubierto 2da Edición. A. Fernández Montoro. Alfaomega. Año 2013.
 Programa 1000 programadores – Ministerio de Educación – Ministerio de Economía y servicios
públicos – Universidad Nacional de Salta. 2020

Instituto Superior Del Milagro Nº 8207 (Salta)

Alvarado 951 y 1.164 – Tel. (087) 4311519 – Sitio Web: www.institutodelmilagro.com