Sumario

Instalación ...................................................................................................................................... 3
Lenguaje Python..................................................................................................................... 3
Primer programa.................................................................................................................... 5
Instalando el IDE PyCharm ......................................................................................................... 6
Fundamentos .............................................................................................................................. 11
11
Variables
Comandos de Entrada y Salida................................................................................................. 12
Operadores.......................................................... 13
Lista de ejercicios A ................................................................................................................ 15
Estructuras condicionales ........................................................................................................... 18
Lista de ejercicios B
Estructuras de repetición........................................................................................................... 22
Lista de Ejercicios C ................................................................................................................ 23
Arreglos.......................................................................................................................................... 26
Funciones principales del array ..................................................................................................... 27
Algunos ejemplos prácticos........................................................................................................ 30
Arrays multidimensionales........................................................................................................ 31
Lista de ejercicios D
Funciones ....................................................................................................................................... 36
Características......................................................................................................................... 38
Ejemplo 01.............................................................................................................................. 39
Ejemplo 02.............................................................................................................................. 39
Ejemplo 03.............................................................................................................................. 40
Ejemplo 04.............................................................................................................................. 41
Ejemplo 05.............................................................................................................................. 41
Lista de ejercicios E................................................................................................................. 42
Estructura de Datos...................................................................................................................... 44
Diccionario de datos................................................................................................................. 45
Ejemplo: Relacionando meta-datos con datos.................................................................... 49
Lista de ejercicios F................................................................................................................. 50
Python y SQLite........................................................................................................................... 52
Manipulando la base de datos.............................................................................................. 53

1
 Comando INSERT..................................................................................................................... 53
Comando UPDATE................................................................................................................... 57
Comando DELETE .................................................................................................................... 58
Comando SELECT..................................................................................................................... 59
Comando WHERE.................................................................................................................... 60
Trabajando con más de una tabla.................................................................................... 61
Lista de ejercicio G.................................................................................................................. 63
Tratamiento de Excepción............................................................................................................... 64
Jerarquía de excepciones........................................................................................................... 65
Acción de limpieza ...................................................................................................................... 67
Comando raise ........................................................................................................................ 67
Lista de ejercicio H
Archivos ...................................................................................................................................... 70
Python y Arduino ........................................................................................................................ 71
Referencia Bibliográfica .............................................................................................................. 72

2
Instalación

En este capítulo aprenderemos cómo instalar el lenguaje Python y su IDE en

Sistema Operacional Windows.

Lenguaje Python

El lenguaje de programación Python se puede adquirir accediendo a su

aplicación a través de la direcció[Link].

Seleccione el menú Descargar y baje la versión Python 3.7.2. Ejecute el archivo

descargado e inicie su instalación.
En la primera pantalla marca la opción Agregar Python 3.7 al PATH y elige la opción

Instalación personalizada.

A continuación permanezca seleccionado todas las opciones y haga clic en Siguiente.

3
 Cada opción marcada tiene el siguiente significado:
Documentación: instala la documentación del lenguaje;
pip: instala o pip que es usado para descargar bibliotecas desarrolladas en Python;
tcl/tk e IDLE: instala la biblioteca Python para la creación de interfaces gráficas;
Suite de pruebas de Python: instala la biblioteca de Python responsable del tratamiento de

prueba de software;
py launcher: instala el lanzador para aplicaciones con la extensión py.

Adelante, marque las opciones recomendadas. En Instalar Personalizado

localización crea la siguiente ruta de instalación: c:\desarrollo\python3. Haz clic en
botónInstale siga el término de su instalación.

4
Primer programa

Ahora vamos a probar si la instalación

ocurrió según lo planeado, crearemos
nuestra primera aplicación. Abre el Símbolo del sistema

de Comando de Windows y escribe el

siguiente comando:

python –V

En este comando se mostrará la versión

instalada en su máquina. Para entrar en
ambiente de desarrollo digite o
comando

python

Utiliza el comandoprintpara imprimir algo en la pantalla. Prueba la siguiente línea de comando:

print("Hola mundo")

El comando presentado se trata de una función. Por definición, toda función debe poseer
paréntesis. En el caso presentado, la función print recibió un contenido del tipo texto. A
seguir entre con los siguientes comandos:

print("IF Goiano", "Trindade", 2019, sep=" ")

print(“IF Goiano”, “Trindade”, 2019, sep=”.“)

La función print permite la impresión de diversos valores. Repara que cada valor
debe ser separado por coma. Se permite presentar valores de otros tipos que no
sea texto. El último término: sep= ' ', define cuál es el carácter que se utilizará como
separador de los valores presentados.

A continuación se presenta la salida esperada para los comandos ingresados.

5
 Ahora escribe los siguientes comandos:

IF Goiano
tipo(institución)
ano = 2019
tipo(año)
print(institucion, "Trinidad", año, sep=" ")

Observe que el comandotype(institucion)etype(año)imprime respectivamente

as saídas<class ‘str’> e<class ‘int’>. Essa saída refere-se aos tipos das
variablesinstitucioneano.

Instalando el IDE PyCharm

Desarrollar programas utilizando el símbolo del sistema puede ser una tarea
extremadamente difícil dependendo da complexidade da aplicação. Devido a esse
problema los desarrolladores utilizan aplicaciones propias para el desarrollo de
software. Estas aplicaciones son conocidas por la sigla IDE, Entorno de Desarrollo Integrado
Ambiente de Desenvolvimento Integrado.
En este curso trabajaremos con la IDE PyCharm, desarrollada por la empresa Jet
Cerebros. Para realizar la descarga de esta herramienta acceda a la dirección:

[Link]/pycharm/descargar

y descargue la versión Windows Community.

6
 Ejecuta el archivo, en la pantalla que define la Carpeta de Destino instala la aplicación
en la siguiente dirección:

c:\desarrollo\PyCharm Community Edition 2018.3.2

A continuación, en Opciones de Instalación, marque las siguientes opciones:

lanzador de 64 bits;
Agrega el directorio del lanzador a la PATH;

.py
y haga clic en el botón Siguiente.

7
 Después de haber completado la instalación, abre el programa. Elige la opción Crear
Nuevo Proyecto.

Se dispondrá de una pantalla para definir la ruta del proyecto y cuál máquina virtual
a ser utilizada por el proyecto.

8
EmLocationcrie el siguiente camino:

c:\desarrollo\espacio de trabajo\python\curso\primero

En la opción Intérprete de Proyecto deja marcada la máquina virtual recomendada. Haz clic en

botónCrear.

Con el proyecto creado, haz clic con el botón derecho en el nombre del proyecto y elige la opción

Nuevo Archivo de Python. Nombra el archivo como [Link].

9
Digite el siguiente código:

Para ejecutar, haz clic en el menú Ejecutar Presiona las teclas Alt + Shift + F10.
el resultado se mostrará en la esquina inferior de la pantalla de la aplicación.

10
Fundamentos

Desarrollado por Guido van Rossum, el lenguaje Python surgió en 1991. Este
la lengua tiene las siguientes características:
Interpretada: no utiliza los recursos directamente de la máquina;
Alto nivel: basado en otros lenguajes;
Script: soporta la creación de descripts;

Paradigma orientado a objetos: utiliza los conceptos de clase y objetos;

Tipado dinámico: las variables no tienen tipos definidos.
La estructura del lenguaje de programación determina que todo código esté
debidamente indentado. Las estructuras y bloques no están limitados con un inicio y fin.

Comentarios

Un comentario permite que el desarrollador escriba algo en el programa que no

será interpretado por la lengua. Este comentario puede ser de una sola línea,
ejemplo:

Esto es solo un comentario

O de múltiples líneas:

´´´
Fui a la feria y escribí
los datos de los productos

que adquirí
´´´

El comentario de múltiples líneas debe estar envuelto por tres comillas simples al inicio
y cierre.

Variables

En Python, una variable debe tener solo un nombre y un valor. El tipo de la

la variable se define a través del valor recibido, es decir, el lenguaje ofrece la creación de
variables no tipadas, que no tienen un tipo predefinido.

11
 Siendo así, una variable puede ser un número o un texto. En caso de que sea un número,

esta podrá contener valores:

int almacena valores de enteros;
flotar almacena valores reales;
complejo almacena valores que tienen una parte real y otra imaginaria.
Normalmente, estos tipos se emplean en áreas como Ingeniería Eléctrica
e Estadística.

Un número también se puede generar mediante las funciones: int(); float();

e complexo(). Exemplo:

Las variables que tienen valores de tipo texto deben estar envolvidas por comillas simples

o duplas. Ejemplo:

Para nombrar una variable, se permite utilizar cualquier carácter que no sea
símbolo clave del lenguaje. Una variable puede tener cualquier nombre, con excepción
de las palabras reservadas del lenguaje.

Comandos de Entrada y Salida

12
 El desarrollador podrá imprimir una salida a través del comando print. Este
el comando puede ser utilizado de la siguiente forma:

Imprimiendo solo el texto deseado. Ejemplo:

¡Estoy imprimiendo este texto!

Imprimiendo una secuencia de datos (variables y textos). Ejemplo:

print("Hola", nombre)

Imprimiendo una secuencia de datos que están delimitados por un carácter o

Ejemplo:

print("Hoy", "tendremos", sep = "$")

En python se debe usar el comando input para capturar la entrada del usuario.
Este comando siempre devolverá un texto. Ejemplo:

Digite su nombre

Operadores

El lenguaje ofrece cuatro categorías de operadores: asignación; aritméticos;

relacionales y lógicos.

Operador de atribuição

Este operador tiene como objetivo definir el contenido y el tipo de una variable. Él
es representado por el símbolo igual (=).

Operadores Aritméticos

Corresponden a los operadores utilizados en la realización de cálculos

matemáticos. Son ellos:

13
 Descripción Símbolo
Adición +
Sustracción -
División /
Multiplicación *
Resto %

Operadores Relacionales

Correspondem a los operadores utilizados en la creación de oraciones relacionales.

Estos operadores se utilizan bastante en las estructuras condicionales y de repetición.
Son ellos:

Descripción Símbolo
Maior >
Menor <
Mayor o igual >=
Menor o igual <=
Igualdad ==
Diferente !=

Operadores Lógicos

Participan en la construcción de una sentencia lógica. También se utilizan en las

estructuras condicionales y de repetición. Son ellos:

Descripción Símbolo
Es lógico y
OU lógico o
NO lógico no

Cada operador posee la siguiente tabla de verdad:

y
P ¿Q? Py Q
Verdadero Verdadero Verdadero

14
 Verdadero Falso Falso
Falso Verdadero Falso
Falso Falso Falso

o
P Q Py Q
Verdadero Verdadero Verdadero
Verdadero Falso Verdadero
Falso Verdadero Verdadero
Falso Falso Falso

no
P no P
Verdadero Falso
Falso Verdadero

Lista de ejercicios A

1) Desarrolle un programa en Python en el que el usuario deberá ingresar el cateto adyacente y

cateto opuesto relativo a un triángulo rectángulo. El programa deberá calcular la hipotenusa de este
triángulo y sus respectivas razones trigonométricas (seno, coseno y tangente). Imprima los
valores del seno, coseno y tangente.

Cálculo de la hipotenusa:

h² = ca² + co²

Cálculo del seno, coseno y tangente

co ca co
seno coseno tangente
h h ca
, donde:

hipotenusa
ca = cateto adyacente;
co = cateto opuesto.

15
2) Desarrolla un programa en Python que genere un número aleatorio de cuatro dígitos (M
– Milhar, C – Centena, D – Dezena, U - Unidade) variando entre 1000 e 9999. El programa deberá
calcular e imprimir la siguiente expresión matemática:

U randi(M*10)
x
C 2 D

3) Desarrolla un programa en Python en el que el usuario ingresará el radio de un círculo, la base y

la altura de un triángulo. El programa deberá calcular el área del círculo y del triángulo e imprimir
la diferencia del área del triángulo por el área del círculo.

4) O IF Goiano – Campus Trindade desea verificar cuál fue la puntuación obtenida por un
determinado candidato inscrito no processo eleitoral para coordenador de curso. A equipe de
desarrolladores decidió ayudar en esta tarea a través de la creación de un programa de Python. En este
el algoritmo es necesario que el usuario ingrese: el número de votos válidos del segmento
docente al candidato; el total de votos válidos de los docentes; el número de votos válidos de
segmento discente al candidato; y el número de votos válidos de los discentes. El programa deberá
realizar el siguiente cálculo:

2VDo1VDi
Vt  , siendo:
3Do3Di

Vt: Votos válidos obtenidos por el candidato;

VDo: Votos válidos del segmento docente al candidato;
Hacer: Votos válidos de los docentes;
VDi: Votos válidos del segmento estudiantil al candidato;
Votos válidos de los discentes.

Al final del cálculo, el valor debe mostrarse en la pantalla.

16
5) Desarrolle un programa en Python en el cual el usuario digitara un ángulo. El programa
deberá calcular e imprimir el seno, el coseno y la tangente de este ángulo.

6) Desarrolle un programa en Python que genere un número aleatorio variando entre 0 y 100.
Imprima el valor generado.

7) Desarrolle un programa en Python que genere 3 números aleatorios variando

respectivamente entre: 0 y 50; 10 y 40; 100 y 999. Imprima los valores generados.

8) Desarrolla un programa en Python en el que el usuario ingresará un valor inicial y un valor

final. El programa deberá generar un número aleatorio dentro del intervalo elegido por el usuario.
Imprima el número generado.

9) Desarrolle un programa en Python en el que el usuario ingresará dos números (n1 y n2).
el programa deberá calcular e imprimir la siguiente fórmula:

resultados  n1 n2  3

Consejos:
Calcular la potencia de un número. Ejemplo:

2 ** 5 = 32

Calcular la raíz cuadrada de un número. Ejemplo:

4 ** (1/2) = 2

Generar números aleatorios. Ejemplo:

importar aleatorio

[Link](1, 9)

Generar PI

importar matemáticas

[Link]

Obtener seno, coseno y tangente

importar matemáticas

17
x = [Link](85) #convierte el ángulo de grados a radianos
[Link](x) #seno
[Link](x) #coseno
z = [Link](x) #tangente
y = [Link](z) #converte el ángulo de radianes a grados.

Estructuras condicionales

Una estructura condicional tiene como objetivo verificar una sentencia relacional y a partir de esta

la verificación ocurre en la toma de decisiones. Esta acción ocurre cuando la sentencia relacional
por verdadeira (True). También es posible realizar acciones el resultado de la sentencia
relacional sea falso (False).

El lenguaje ofrece tres tipos de estructuras condicionales: IF, ELIF y ELSE.

La estructura IF

Posee la siguiente sintaxis:

si condición:
comandos

donde:
si corresponde al nombre de la estructura de condición;
condición sentencia relacional a ser probada;
comandos todos los comandos a ser ejecutados por la
estructura.

La estructura ELIF

Utilizado existe la necesidad de probar varias oraciones relacionales. Para cada

teste condicional utiliza-se un ELIF. Esta estructura corresponde al if en cascada.
Observa su sintaxis:
si condicaoA:
comandoA
elif condicióB:

18
 comandoB
elif condicionC:
comandoC

dónde
si corresponde al nombre de la estructura de condición;
elif utilizado para testar outra condição além da
principal
condiciónA sentencias relacionadas a
serán probadas;
comandoA todos los comandos a ser
ejecutados en los diferentes bloques.

La estructura ELSE

Utilizando cuando alguna secuencia de comandos será ejecutada, incluso

todas las condiciones siendo falsas. Esta estructura debe venir acompañada de una
estructura IF. A continuación se muestra su sintaxis:

si condicao:
comandoA
else:
comandoB

onde:
si corresponde al nombre de la estructura de condición;
otro utilizado para ejecutar un comando cuando la condición
contida no if for falsa;
condición sentencia relacional a ser probada;
comandoA todos los comandos a ser ejecutados
nos diferentes bloques.

Dependiendo del problema propuesto, es posible integrar todas las estructuras condicionales.
en una sola estructura, siendo que el ELSE siempre será la última estructura asignada.

19
Lista de ejercicios B

1) Desarrolle un programa en Python en el que el usuario ingresará una letra (A hasta E) referente
un concepto de nota. El programa deberá convertir la letra digitada en una nota de acuerdo
con la tabla a continuación:

CONCEPTO NOTA
A 95
B 85
C 75
D 65
E 30

Cualquier letra digitada diferente de lo que se propuso en la tabla anterior, se imprimirá lo siguiente
Concepto inválido. Imprima la nota convertida.

2) Desarrolla un programa en Python en el cual el usuario ingresará un valor referente a x. El

el programa deberá calcular e imprimir el valor de def(x).

1 se x 1
2se1 x 2
f(x)
x²se2 x 3
x³se x 3

3) Desarrolle un programa en Python en el que el usuario ingresará un valor numérico variando

entre 1 a 7. El programa debe convertir este número en día de la semana de acuerdo con la
tabla a seguir.

VALOR SALIDA
1 DOMINGO
2 LUNES
3 MARTES
4 MIÉRCOLES
5 JUEVES
6 VIERNES
7 SÁBADO

4) Desarrolle un programa en Python que lea un peso en la Tierra y el número de un planeta y

imprima el valor de su peso en este planeta. La relación de planetas se da a continuación junto con
con el valor de las gravidades relativas a la Tierra:

20
 # GRAVEDAD RELATIVA PLANETA
1 0,37 MERCURIO
2 0,88 VENUS
3 0,38 MARTE
4 2,64 JÚPITER
5 1,15 SATURNO
6 1,17 URANO

Para el cálculo del peso considera la siguiente fórmula:

p m g, siendo que:

peso
masa
g: gravedad.

Calcule e imprima el peso en la Tierra y en el planeta elegido.

5) La escuela “APRENDER” paga a sus profesores por hora/clase. Haz un programa

en Python que calcule y muestre el salario de un profesor. Se sabe que el valor de la hora/clase sigue
la tabla abajo:

Profesor Nivel 1 R$12,00 por hora/clase

Profesor Nivel 2 R$17,00 por hora/aula
Profesor Nivel 3 R$25,00 por hora/aula

Una empresa otorgará un aumento de salario a sus empleados, variable de acuerdo

con el cargo, conforme a la tabla a continuación. Hacer un programa en Python que lea el salario y el

cargo de un empleado y calcula el nuevo salario. Si el cargo del empleado no está en la tabla,
salario_antigo
salarial.

CÓDIGO CARGO PORCENTAJE

101 Gerente 10%
102 Ingeniero 20%
103 Técnico 30%

7) Construya um programa em Python para determinar a situación

(APROBADO/EXAMEN/REPROBADO) de un alumno, dado su frecuencia (FREQ) (porcentaje
de 0 a 100%) y su nota (NOTA) (nota de 0.0 a 10.0), siendo que:

21
 Condición Situación
Frequencia hasta 75% REPROBADO
Frecuencia entre 75% y 100% y Nota hasta 3.0 REPROBADO
Frecuencia entre el 75% y el 100% y Nota de 3.0 hasta 7.0 EXAMEN
Frecuencia entre 75% y 100% y Nota entre 7.0 y 10.0 APROBADO

Estructuras de repetición

Las estructuras de repetición se utilizan cuando existe la necesidad de ejecutar el

mismo bloque de comandos un número finito de veces. En Python podemos utilizar dos
estructuras de repetición: WHILE; y FOR.

La estructura WHILE

O WHILE ejecuta un bloque de comandos N veces hasta que su condición sea satisfecha.
Esta estructura tiene la siguiente sintaxis:

mientras condicao:
comandos

donde
mientras palabra clave que define la estructura;
condición sentencia relacional que define la cantidad de
veces que los comandos serán repetidos;
comandos conjunto de instrucciones a ser ejecutadas.

Ejemplo:

lifeRock = 5000;
0
batida = 200;
mientras lifeRock >= 0:
hierro += 5
lifeRock -= batida
print('Pegó {0} hierro'.format(hierro))

La estructura FOR

Utilizado para rastrear una colección de datos. Sintaxis:

veintidós
para variable en lista:
comandos

donde:
para palabra clave de la estructura;
variable variable que recibirá cada elemento de la lista;
lista lista de elementos;
comandos conjunto de instrucciones.

Ejemplo:

compras = ['Cupim', 'Picanha', 'Carvão', 'Coração de galinha',

Pan de ajo
print('Lista de productos para el asado')
para n en compras:
imprimir(n)

Lista de Ejercicios C

01) Desarrolle un programa en Python en el que el usuario ingresará dos valores enteros (AeB).
El programa deberá generar 100 números aleatorios. Cada valor generado deberá estar dentro de
intervalo digitado por el usuario (AeB). Imprima el mayor valor generado por el programa.

02) Desarrolle un programa en Python en el que el usuario ingresará el nombre y las notas de 35
alumnos. Cada alumno tiene cinco calificaciones. El programa debe imprimir la media aritmética de cada uno.

alumno es el nombre del alumno que tiene la mayor media.

03) Desarrolla un programa en Python en el que el usuario ingresará los siguientes datos de un
el nombre de un alimento; su categoría (P - Proteína; C - Carbohidrato; G - Grasa); y
su valor calórico. El usuario digitara cuántos alimentos quiera. La digitación terminará cuando el
valor calórico digitado igual a cero. Imprima el valor calórico total de cada categoría.

04) Desarrolla un programa en Python en el que el usuario ingresará los siguientes datos de un
el nombre de un alimento; su categoría (P - Proteína; C - Carbohidrato; G - Grasa); y
su valor calórico. El usuario digitara cuántos alimentos desee. La digitación terminará cuando el
valor calórico digitado for igual a cero. Imprima:

23
 ¿Cuál categoría tiene mayor valor calórico?
¿Cuál es el nombre del alimento de mayor valor calórico?

05) Desarrolle un programa en Python que calcule la velocidad media de 100 vehículos. El
el programa deberá calcular e imprimir el porcentaje de vehículos cuya velocidad media
superó los 80 km/h. A continuación se muestra la fórmula de la velocidad media:

d
Vm , siendo que:
t

Vm velocidad media;
d distancia
t tempo.
06) Desarrolla un programa en Python que simule el lanzamiento de un dado de seis caras 2500
veces. El programa debe calcular e imprimir el porcentaje de números: uno; dos; tres;
cuatros; cincos y seis que fueron sacados durante las 2500 tiradas.

07) Desarrolla un programa en Python en el que el usuario ingresará la cantidad de

Kilovatio-hora (kWh) consumido en una casa durante 12 meses. El programa deberá presentar la
bandeira de cada mês. Sendo a bandeira definida por:

kWh Bandera
Hasta 172 kWh Verde
Entre 173 y 280 kWh Amarilla
Más que 281 kWh Roja

08) Un náufrago se encuentra atrapado en una isla. Él tiene una cantidad X de comida y Y de
bebida. Se sabe que por día consume el 5% de la comida total y el 3% de la bebida total. Desarrolla
un programa en Python en el que el usuario ingresará el número de comida (X) y bebida (Y) que el
náufrago posee inicialmente. El programa deberá presentar en cuántos días se demoró para
consumir toda comida y bebida.

24
09) Un candado tiene 10 cerraduras. Se desea crear un
programa que verifique cuántos intentos gastará una persona
hasta que abra el candado. Desarrolla un programa en Python
que genere aleatoriamente la cerradura correcta. El usuario deberá
elige la cerradura que deseas abrir hasta que tengas éxito.
Imprima cuántas veces el usuario intentó abrir el candado.

25
Arreglos

Umarraycorresponde a uma estrutura de dados do tipo lista que tem como objetivo
almacenar una colección de datos. El arreglo puede almacenar cualquier tipo de valor:
caracteres; enteros; reales. También puede almacenar incluso otro array.

Para definir una lista, declara una variable y haz que reciba corchetes.
Ejemplo:

x = []

En este momento, la variable x almacena un array sin elementos. En caso de ser necesario

inicializar la lista con elementos, añada los valores separados por comas. Ejemplo:

x = [5, 6, 7, 2, 4]

El vector ahora posee cinco elementos.

5 6 7 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

Cada elemento tiene un índice dentro de la lista, siendo que el primer índice es
el cero (0).

Para acceder a un elemento de la lista, utiliza el nombre de la variable y entre corchetes el índice

deseado.

x[3]
Se obtendrá el valor 2

En este caso se obtendrá el valor 2 que se encuentra en el índice 3.

Para sustituir un valor, haz que la variable en el índice deseado reciba el nuevo
valor.

x[2] = 35

26
 5 6 35 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

Se le asignará el valor 35 al índice 2.

Caso sea necesario descubrir cuántos elementos existen en la lista, utiliza la función
len().

len(x)

En el caso citado, se retornará el valor 5.

Principales funciones del array

Además de los recursos presentados, la lista (array) contiene un conjunto de funciones que
permite al desarrollador manipular sus elementos. En este tema se presentarán las
principales funciones de un array.

Sigue el conjunto de funciones:

[Link](el) Agrega un elemento al final de la lista. Ejemplo:

[Link](69)

5 6 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link](i, x) Añade un elemento en la posición deseada. Los

los demás elementos después del índice elegido se reubican a la derecha de la lista.
Ejemplo:

[Link](2, 24)

27
 5 6 24 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5 6

[Link](x) Elimina el primer elemento de la lista cuyo valor se cita

en la función. Ejemplo:

[Link](4)

5 6 24 35 2 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link]([i]) Retira el ítem de la lista de acuerdo con la posición especificada

y retorna el valor removido. Si no se especifica el índice, será removido
el último elemento de la lista. Ejemplo:

[Link](1)
El valor 6 será devuelto. El mismo será eliminado de la lista.

5 24 35 2 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](x[, inicio[, fin]]) Retorna el índice del valor deseado.

Ejemplo:

[Link](35)
# El valor retornado será 2

[Link](x) Retorna la cantidad de elementos iguales al valor de

entrada. Exemplo:

[Link](69)
El valor retornado será 1

28
 [Link]() Invierte los valores de la lista. Ejemplo:

[Link]()

69 2 35 24 5
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](clave=None, inverso=False) Ordena los elementos de la lista

en orden ascendente. Si el parámetro reverse recibe True, el método de
la ordenación ocurre en orden descendente. Ejemplo:

[Link]()

2 5 24 35 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](reverse=True)

69 35 24 5 2
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link]() Eliminar todos los elementos de la lista. Ejemplo:

[Link]()

Caso desee conocer y profundizar en las funciones disponibles, acceda al sitio web:

No puedo acceder a enlaces externos o contenido en línea.

29
Algunos ejemplos prácticos

Ejemplo 01) Haz un programa en Python que cargue una lista de 15 elementos
con valores aleatorios variando entre 100 y 1000. El programa deberá calcular y
mostrar

a) El mayor elemento de la lista;

b) El menor elemento de la lista.

importar aleatorio

x = []
i=0
mientras i <= 14:
[Link]([Link](100, 1000))
i += 1
[Link]()
imprimir(x)
imprimir(x[0])
imprimir(x[14])

Ejemplo 02) En una carrera hay 10 corredores. Desarrolla un programa en Python

que leía los valores del número del corredor y su respectivo tiempo en la carrera. Además
disso, el programa deberá imprimir la clasificación y el tiempo de carrera, del primero al
décimo colocado, identificando el número de inscripción del corredor correspondiente a esa
colocación.

corredor = []
i=0
mientras i <= 2:
inscripción
tempo = int(input('Digite el tiempo en la carrera: '))
dados = [inscricao, tempo]
[Link](dados)
i += 1
[Link](key = lambda corredor:corredor[1])
count = 1
para i en corredor:

30
 print(count, 'º lugar: ', i[0], ' -> Tiempo: ', i[1], sep='')
contar += 1

Ejemplo 03) Desarrolle un programa en Python en el que el usuario ingresará una

palavra
original.

palabra = input('Digite una palabra: ')

x = list(palabra)
[Link]()
''.join(x)
print('Palabra: ', palabra)
print('Palabra invertida: ', palabraInvertida)
si palabra == palabraInvertida:
print('PALABRAS IGUALES')
else:
print('PALABRAS DISTINTAS')

Arrays multidimensionales

Los arreglos multidimensionales, también conocidos como matrices, corresponden a una lista que
recibe una colección de datos. Esta colección de datos está representada por otroarray.
Ejemplo:

x = [[1, 4], [3, 6], [2, 4]]

Línea
0 1 4
1 3 6
2 2 4
↑ ↑
0 1
Columna

Para acceder a un dato de esta estructura utiliza dos corchetes añadiendo la dirección de
línea y columna.

31
x[1][0]
'''
El valor retornado será 3 que está presente en la línea 1 y columna 0
'''

El desarrollador también podrá crear un arreglo multidimensional con datos de

diversos tipos. Considere a imagem a seguir:

Considere que en la imagen mostrada, la listatabeladeberá tener cuatro columnas por

dado. Cada columna tiene una definición y un tipo de dato:
id recibirá un entero que corresponde al código de un usuario;
usuario recibirá un texto correspondiente al nombre de la cuenta de un usuario;
contraseña recibirá un texto correspondiente a la contraseña de la cuenta del usuario;

activo recibirá un booleano que corresponde si la cuenta del usuario está activa
se encuentra activa.
Para el caso citado, se puede crear un array multidimensional de la siguiente forma:

tabela = [
denecley@[Link]
pepy@[Link]
[Link]@[Link]
primopato@[Link]
[Link]@[Link]
]

32
 Línea
0 69 denecley@[Link] ****** Verdadero
1 124 pepy@[Link] pepylegal Verdadero
2 548 [Link]@[Link] 123321 Falso
3 96 primopato@[Link] primim2018 Verdadero
4 56 [Link]@[Link] alumnos2019 Falso
↑ ↑ ↑ ↑
0 1 2 3
Columna

¿Y si quisiéramos listar todas las cuentas desactivadas?

Para la pregunta anterior podemos resolver el problema de la siguiente manera:

para linha em tabela:

si no línea[3]:
imprimir(linha)

tú

lista(filtrar(lambda linha: não linha[3], tabela))

El comando list convierte una serie de datos en una lista, array. El comando filter retira
todos los datos de una lista a partir de un criterio de filtro. Para utilizar el filtro usa la
sintaxe

lambda valor: condicion

donde:
lambda palabra clave utilizada para crear una variable de
filtro
valor nombre de la variable de filtro. Esta variable recibirá
cada valor de la lista;
condición criterio de selección.

33
Ahora, ¿cómo podemos capturar todas las cuentas de dogmail?

lista(filtro(lambda linha: 'gmail' en linha[1], tabela))

Lista de ejercicios D

1) Crea un programa en Python que lea una lista de 40 posiciones. Contar y escribir cuántos
valores pares él posee.

2) Cree un programa en Python que lea dos listas de 20 posiciones y calcule otra lista
contendo, en las posiciones pares los valores del primero y en las posiciones impares los valores del
segundo.

3) Haz un programa en Python que determine cuántos números mayores que 100 hay en una
lista de enteros con 20 elementos. Rellena la lista con números aleatorios que varían entre 1 a
200.

4) Crea un programa en Python que lea la puntuación de 10 pruebas de un concurso y los nombres
dos respectivos participantes. Grabe los datos en una lista. Presente un ranking de los
colocados que obtuvieron más de 70 puntos.

5) Crea un programa en Python que lea quince números del usuario y los almacene en una lista.
raíz cuadrada de cada número. En caso de que el valor ingresado sea menor que cero, el número -1 debe ser
atribuído ao elemento da lista. Após isso, o programa deve imprimir todos os valores
almacenados.

6) Crea un programa en Python que reciba la altura de 10 atletas. Almacena la altura de

todos los atletas en una lista. Este programa debe imprimir la altura de aquellos atletas que tienen
altura mayor que la media.
7) Escribir un programa en Python que contenga una lista G(13) que sea el gabarito de una prueba
de lotería deportiva, conteniendo los valores: A, B o C para cada posición de G. Leer, a continuación, el
número del tarjeta de un apostador y otra lista respuesta R (13). Verificar el número de aciertos
e escribir el número del apostador y su número de aciertos. Si tiene 13 aciertos, añadir la
GANADOR, FELICITACIONES

8) Haz un programa en Python que:

a) Lee una frase;

b) Cuenta cuántos espacios hay en la frase;
c) Cuenta cuántas veces aparece la letra A;
d) Imprima lo que se calculó en los ítems b y c.

Consejo: Accede al sitio

No se puede traducir contenido de URL.

9) Haz un programa en Python que, dadas dos listas A y B de 20 elementos, realice las
respectivas operaciones indicadas por una otra lista C de 20 elementos, también proporcionada por
usuario, conteniendo las cuatro operaciones aritméticas en cualquier combinación. Almacene en

34
una lista resultado el valor de la operación realizada. Por ejemplo, suponga que A[1] = 10, B[1] = 3
si C[1] = '*', entonces D[1] = 30.

10) Haz un programa en Python que lea una lista de 3 elementos y una lista
multidimensional de 3 x 3 elementos. Em seguida o programa deve fazer a multiplicação da lista
simples por las columnas de la lista multidimensional. Muestra la nueva lista.

11) Cree un programa en Python en el que el usuario introducirá una matriz con dimensiones M × N.
Para la matriz introducida, imprima en la pantalla los números pares contenidos en la matriz, considerando
sepáralos por línea. Ve el ejemplo para una matriz 4×4:

Entrada:

1 2 3 4

5 6 7 8

10 11 23 21

1 2 3 1

Salida:

2 4 6 8 10 2

12) Crea un programa en Python que lea una matriz cuadrada de 10x10, de números enteros.
Verificar cuántos números de la diagonal principal son impares, escribir también, la suma y la
media de estos elementos.

13) Implemente un programa, utilizando el lenguaje Python, que lea 30 nombres y apellidos
de personas. A cada nombre y apellido leído, verifica si las palabras tienen el mismo tamaño.

Si el nombre y el apellido tienen la misma longitud, concatena las palabras y

escribe un mensaje mostrando el nombre completo;
Si el nombre y el apellido tienen tamaños diferentes, escribe un mensaje
mostrando que no tienen el mismo tamaño.

14) Hacer un programa en Python que lea al final de la mañana el cierre de la caja de una
tienda, es decir, su rendimiento al final de la mañana. Lo mismo se deberá hacer al final de la tarde.
Este levantamiento debe hacerse todos los días de la semana (de lunes a viernes). Al
final de la semana, después de haber hecho todas las lecturas, descubrir y escribir el día y el turno que tuvo mayor

rendimiento. Obs.: Utilizar el concepto de matriz para resolver este ejercicio.

35
Funciones

En este capítulo aprenderemos qué es y cuál es el propósito de una función. Considera la

siguiente situación:

i = 0
mientras i < 3:
print('Elige tres números')
n1 = int(input('Número 1: '))
j = 1
1
mientras j <= n1:
grasa *= j
j += 1
print('Factorial: {0}'.format(fat))
n2 = int(input('Número 2: '))
j = 1
fat = 1
mientras j <= n2:
grasa *= j
j += 1
imprimir('Factorial: {0}'.formato(fat))
n3 = int(input('Número 3: '))
j = 1
1
mientras j <= n3:
grasa *= j
j += 1
print('Fatorial: {0}'.format(fat))
i += 1

En este ejemplo, el desarrollador pide al usuario que ingrese tres números tres veces.
Para cada número se calcula su factorial (ejemplo: 4! = 4 x 3 x 2 x 1) e impreso en
tela. Repare que este código possui uma repetição das seguintes instruções:

36
j = 1
1
mientras j <= n1:
grasa *= j
j += 1
print('Factorial: {0}'.format(fat))

¿Y si el desarrollador quisiera calcular el factorial de 10 números 3 veces? ¿Puede hacerlo?

¿Imaginar la cantidad de líneas y códigos repetidos que se generarían?

Para evitar situaciones como estas, los lenguajes de programación ofrecen un recurso
denominada función.

Una función corresponde a un bloque de código que podrá ser invocado cuantas veces
son necesarias. Define un problema. El uso de funciones tiene como objetivo:
Minimizar la cantidad de código escrito;
Facilitar la comprensión del código fuente;
Distribuir la resolución del problema en pequeños módulos.

Entonces, ¿cómo quedaría el código anterior utilizando tal recurso?

def fatorial(n):
j = 1
1
mientras j <= n:
grasa *= j
j += 1
print('Fatorial: {0}'.format(fat))

i = 0
mientras i < 3:
print('Elija tres números')
n1 = int(input('Número 1: '))
fatorial(n1)
n2 = int(input('Número 2: '))
fatorial(n2)

37
 n3 = int(input('Número 3: '))
fatorial(n3)
i += 1

En el primer escenario, el código escrito tenía 25 líneas; con la aplicación de la función hubo
la reducción a 17 líneas, habiendo un ahorro del 32%. Observe también que el
trecho:

j = 1
1
mientras j <= n1:
grasa *= j
j += 1
print('Factorial: {0}'.format(fat))

fue escrito solo una vez, dentro de la función factorial. En el código principal la función fue
llamada por su nombre y el valor de entrada entre paréntesis.

fatorial(n1)
fatorial(n2)
fatorial(n3)

Características

La función tiene las siguientes características:

Sólo puede ser invocada después de su creación;

Puede recibir o no valores externos, parámetros;

Puede devolver o no un resultado. Cuando se desea devolver un valor es
es necesario utilizar el comando devolver.

Para crear la función utiliza esta sintaxis:

def nomeFuncao(parametros):
comandos
devolver valor

donde:

38
 def comando utilizado para definir una función;
nombreFuncion el nombre de la función. Evita caracteres especiales y
espacio
parámetros define una entrada de valores externos. Se a
si no hay función, solo abre y cierra paréntesis. En caso de que haya
más de uno, será necesario separarlos por coma;
comandos conjunto de instrucciones que buscan resolver el
problema;
regresar comando utilizado para retornar un valor. El return
permite retornar un único valor;
valor valor a ser retornado.

Es importante resaltar que un código podrá tener tantas funciones como sean necesarias.

necesarias.

Ejemplo 01

Desarrolla una función en Python que imprima una cantidad de líneas:

*
**
***
****
*****

El usuario deberá elegir cuántas líneas desea imprimir en el formato presentado.

Resolución:

def impresion(líneas):
para i en rango(1, lineas + 1):
print('*' * i)

Ejemplo 02

39
Desarrolle una función en Python que reciba una lista que contenga el nombre y
apellido. Esta función deberá retornar otra lista conteniendo el nombre completo de las
personas que empiezan con 'A'.

resolucion

def filtro(lista):
f = list(filter(lambda item : item[0][:1] == 'A', lista))
r = []
para i en f:
[Link](i[0] + ' ' + i[1])
regresar r

Ejemplo 03

Desarrolla una función en Python que reciba una lista de pedidos. Cada elemento
posee uno de los siguientes valores:

CREMA CHOCOLATE NAPOLITANO FLOCOS

La función deberá retornar el nombre del pedido más frecuente.

Resolución:

def pedido(lista):
itens = ['CREME', 'CHOCOLATE', 'FLOCOS', 'NAPOLITANO']
maior = 0
sabor
para item en itens:
q = len(list(filter(lambda i : i == item, lista)))
si q >= maior:
q
elemento
devolver sabor

40
Ejemplo 04

Desarrolla una función en Python que devuelva los elementos de la diagonal principal de una
matriz de orden N.

Resolución:

def dPrincipal(matriz):
index = 0
diagonal = []
para linha em matriz:
[Link](linha[index])
índice += 1
devolver diagonal

Ejemplo 05

Desarrolla una función en Python que reciba un número correspondiente a

cantidad de juegos de la MEGA SENA que se deben generar. La función debe retornar todos
los palpites sorteados por la computadora. Un boleto contiene números del 1 al 60 y una
la jugada tiene 6 números.

Resolución:

def cartelas(cantidad):
saida = []
para i en rango(1, cantidad + 1):
jogo = []
count = 0
mientras True:
num = [Link](1, 60)
si num no está en jogo:
[Link](num)
count += 1
si cuenta == 6:
descanso
[Link]()

41
 [Link](jogo)
devolver salida

Lista de ejercicios E

1) Desarrolle una función en Python que reciba un número entero. La función debe retornar
un booleano indicando: verdadero si el número es primo; y falso si el número no es primo. Utiliza la
siguiente firma.

defisPrimo(numero)

2) Desarrolle una función en Python que reciba una matriz de texto y un atributo más
también del tipo texto. La función deberá retornar una lista que contenga todos los textos que
contenga el valor de entrada. A continuación se muestra la firma del método:

def buscar(valores, entrada)

Ejemplo:

valores

Cachorro viejo no aprende truco nuevo Mi sapo jururu

Super Mario Hermanos Muestra en el río

río

retorno

Super Mario Hermano Mostra no río

3) Desarrolla una función en Python que reciba cuatro enteros: el primero indica la cantidad
de líneas; el segundo indica la cantidad de columnas; el tercero el intervalo inicial; y el cuarto el
intervalo final. La función deberá retornar una matriz de acuerdo con el tamaño especificado y
llenada con valores aleatorios de acuerdo con el intervalo estipulado. Sigue la firma de
función:

defmatrizAleatoria(fila, columna, intervaloInicial, intervaloFinal)

42
Ejemplo:

Entrada

matrizAleatoria(2, 3, 30, 60)

Salida:

45 32 56

31 50 41

43
Estructura de Datos

En este capítulo aprenderemos cómo montar un modelo conceptual a partir de un

estructura de datos. También veremos el significado de diccionario de datos y cómo
podemos hacer para gestionar este diccionario.

Considere la siguiente modelación de datos:

En el modelo presentado, los datos se distribuyen en las siguientes tablas:

Curso
Course La tabla Curso es responsable de guardar el nombre de cualquier curso
referente a cualquier institución de enseñanza;
Server La tabla Servidor es responsable de guardar la información de los
servidores que actúan como profesores. Cada servidor posee un nombre, un e-
correo y su área de actuación;
Disciplina La tabla Disciplina es responsable de guardar la información de
todas las disciplinas ofrecidas en un curso. Cada disciplina posee el curso al
cuál es ofrecida, su nombre, el período de oferta, la carga horaria total, la carga
horario presencial y su carga horaria a distancia;

44
 Matrix La tabla Matriz es responsable de relacionar cada disciplina con su
debido profesor.
Crearemos una estructura de datos que permitirá al desarrollador acceder al modelo.
relacional presentado. Los archivos que contienen el modelo y los datos están separados
en dos categorías: datos para archivos csv que almacenan los datos; y metadatos
para los archivos txt que almacenan la lógica estructural de cómo los datos son
organizados.

Por ejemplo, la tabla Curso tiene su estructura almacenada en data/meta-

data/[Link]. Este archivo define las características de la tabla Curso:

Id bigint.
NomeCurso varchar.
Institución varchar.

El archivo que contiene los datos se encuentra en data/data/[Link]. A continuación se muestra el formato

two dice

Ingeniería Eléctrica
2;Ingeniería Civil;IF Goiano - Campus Trindade
Engenharia da Computação;IF Goiano - Campus Trindade
Pós-graduação em Humanidades

Cada dado está separado por punto y coma (;), lo que corresponde a una columna de
tabla construida.

Para comenzar el trabajo, el primer paso es encontrar las estructuras de datos de cada
tabla y crear un diccionario. El diccionario que se creará se basará en los archivos
que definen la estructura y que están guardados en la carpeta de metadatos.

Diccionario de datos

También conocido como mapa o array asociativo, el diccionario de datos tiene como
función recibir una estructura de datos abstracta y relacionarlo en las diversas entradas de
dados.

Para crear un diccionario de datos obedece a una de las siguientes sintaxis.

45
diccionario = {
'Curso': []
}

Dónde:
diccionario nombre del diccionario de datos;
course nombre de la estructura de la tabla a buscar.

También puede escribirse de la siguiente manera:

dicionario = dict(Curso = [])

tú

diccionario
dicionario['Curso'] = []

Conociendo el modo de construcción, ahora necesitaremos crear un diccionario que reciba

toda la información de los archivos contenidos en el caminometa-datos. El diccionario
deberá ser construido en el siguiente formato:

{
'Curso': [
('Id', 'bigint')
varchar
Institución
]
}

La clave (key) estará compuesta por los nombres de las entidades ([Link], [Link],

[Link], [Link]) y su contenido por los campos que definen cada entidad.

Para montar el diccionario dinámicamente, necesitaremos cargar todos los archivos

contidos en la pastameta-datos. Para capturar el nombre de los archivos contenidos en una

pasta, utiliza el siguiente código fuente:

importar os

46
para archivo en [Link]('data/meta-data'):
imprimir(archivo)

El código presentado importa un módulo denominado 'os'. Este módulo permitirá

cargar los archivos contenidos en una carpeta a través de la función listdir, que devuelve la
lista que contiene el nombre de los archivos. La salida esperada para este código será:

[Link]
[Link]
[Link]
[Link]

Aunque tengamos los nombres de los archivos contenidos en la meta-data, observa que estos

poseen el nombre con su extensión. Necesitamos quitar la extensión .txt. Podemos quitar
a través de la siguiente función:

def retirarExtensao(arquivo):
return [Link]('.')[0]

Teniendo el camino y nombre de los archivos, ahora necesitamos crear una función que permita
cargar todo el contenido. Entonces crearemos la siguiente función:

def lerMetaData(arquivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
para linha en dados:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
devolver metaDatos

La función open abre el archivo, se debe enviar la ruta del archivo en ella y el
tipo de abertura, no caso es abierto solo para leer. Un archivo puede ser abierto
de acuerdo con los caracteres:

'r' abre para lectura (estándar);

47
 'w' abre para escritura;
'x' abre para creación. Si ya existe un archivo con el mismo nombre, ocurrirá un
error;
'a' abre para escritura, añadiendo el contenido al final del archivo si existe;
'b' modo binario;
t modo texto (padrão);
'+' abre el archivo de disco actualizando (leyendo y escribiendo);
'U' modo nueva línea (desactualizado).

La variable data recibe todo el contenido del archivo en la función open. Al cerrarlo es
es necesario utilizar la función close().

Juntando todo código producido llegamos al siguiente resultado:

importar os

def retirarExtensao(arquivo):
return [Link]('.')[0]

def leerMetaData(archivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
para linha em dados:
i = lí[Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
devolver metadatos

dicionario = {}
por archivo en [Link]('data/meta-data'):
retirarExtensao(file)
diccionario[tabla] = leerMetaData(archivo)

para chave, valor em [Link]():

print('Entidad: {}'.format(clave))
print('Atributos: ', valor)

48
Las informaciones contenidas en esta entidad están definidas por el nombre de tupla. Una tupla es

creada con paréntesis y a diferencia de la lista (corchetes), la tupla es inmutable, eso

significa que una vez que el contenido del definido, no será posible alterarlo.

Curso
Atributos: [
bigint
varchar
Institución
]

En el caso de Curso tenemos tres tuplas. En nuestro ejemplo, una tupla está constituida por dos

nombre del campo; y tipo del campo.

Ejemplo: Relacionando metadatos con datos

En este ejemplo relacionaremos los meta-datosCurso con sus datos.

Lé todos os meta-datos del archivo

# Devuelve una lista
def leerMetaData(archivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
para linha em dados:
i = lí[Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
devolver metaDatos

# Separa una línea de datos del CSV

Retorna los datos en formato de lista
def lerDado(tupla, linha):
linha = []
para l en rango(0, len(tupla)):
[Link]([Link](';')[l])
retornar línea

49
Crea el diccionario y extrae la información
# en una tupla
dicionario = {}
leerMetaData('[Link]')
tupla = []
para t en diccionario['Curso']:
[Link](t[0])

Relaciona los datos con las tuplas

dados = []
d = open('data/data/[Link]', 'rt')
por i en d:
línea = leerDato(tupla, i)
Crea un diccionario para cada línea de datos
x = {}
para clave, valor en zip(tupla, linha):
x[clave] = valor
[Link](x)

[Link]()

Lista de ejercicios F

1) Desarrolle un código Python que cree las tuplas de la entidad Servidor. Relacione cada tupla
con sus datos.

2) Desarrolle un código Python que cree las tuplas de la entidad Disciplina. Relacione cada tupla
con sus datos.

3) Con base en el ejercicio 2, desarrolla un código Python que visualice solo las disciplinas del
1º y 3º período.

4) Desarrolle un código Python que muestre los siguientes datos:

Nombre del Curso Unidad Curricular Período Carga Horaria Total

NombreCurso UnidadCurricular Periodo Cht

50
En este ejercicio será necesario relacionar las entidades Curso y Disciplina.

5) Crea la siguiente aplicación en Python:

Elija una opción:

1) Listar cursos
2) Listar disciplinas
3) Listar servidores
4) Listar disciplina por período
5) Listar disciplina por curso
6) Listar servidor por nombre
7) Salir

51
Python y SQLite

En este capítulo aprenderemos cómo conectar el lenguaje Python con bases de datos.
SQLite. Veremos cómo realizar las principales rutinas de manipulación en la base de datos.

consulta; inserción; actualización; y eliminación.

Un Sistema de Gestión de Bases de Datos (SGBD) se trata de una estructura

utilizada para almacenar datos. Además, permite que esos datos sean
almacenados de acuerdo con un modelo. El SGDB también ofrece recursos como
integridad y seguridad de la base de datos.

Para conectar el lenguaje de programación con la base de datos, no será

necesario importar bibliotecas externas. El lenguaje Python ya posee un recurso de
conexión nativa con la base de datos SQLite.

Para probar la conexión con la base de datos, crea un proyecto llamado BancoDatos.
En el proyecto creado, construye un archivo Python y nómbralo como [Link].

Baixa el archivo [Link] presente en la disciplina del Ambiente Virtual (Moodle).

Coloque este archivo en la misma carpeta que [Link]. Escriba el siguiente código:

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link]('SELECT * FROM produto')
05 imprimir([Link]())
06 [Link]()

Línea 01: Importa el recurso responsable de conectar el lenguaje con la base de datos
dados
Línea 02: El comando connect realiza la conexión con la base de datos seleccionada.
Esta función recibe solo el nombre de la base de datos, en caso de que el archivo esté junto con

[Link]. Si la base de datos está en otra carpeta, será necesario pasar todo
camino. Ejemplo:c:\carpeta\subcarpeta\[Link];
Líneas 03 a 05: Veremos el significado de estos comandos en los próximos temas;
Línea 06: El comandoclosefinaliza la conexión. Necesario para cerrar la base de datos.

dados.

52
Manipulando la base de datos

En este tema aprenderemos cómo manipular datos dentro de la base de datos. Para ello

considere el modelo a seguir.

En el modelo presentado tenemos tres tablas: producto; compra; compra_producto. Cada

la tabla tiene la siguiente función:
almacena todos los productos. Se registra la descripción del producto y su
precio unitario
almacena todas las compras realizadas. Se registra la fecha de
realización de la compra y el lugar en el que se realizó la compra;
almacena todos los productos que han sido comprados en una
determinada compra. Registra-se o código da compra, o código do produto e
cuántos productos fueron comprados (cantidad).

Comando INSERT

El comando INSERT se utiliza cuando se desea insertar un dato en la base de datos.

O INSERT tiene la siguiente sintaxis:

INSERTAR EN tabela (campos) VALORES (dados);

Dónde:
INSERT INTO: comando de la instrucción;
nombre de la tabla que recibirá el dato;
campos: nombre de los campos separados por comas (;)
valores: comando de la instrucción;

53
 datos: datos relativos a cada campo. Cada dato deberá ser separado por coma
Dados do tipo texto devem estar entre aspas simples.

Ejemplo 01: Se desea insertar en la tabla producto los siguientes datos:

Descripción Precio unitario

Cupim Bovino 12.89
Costillitas de Cerdo Sadia o Perdigão 10.99

Los comandos serían:

INSERT INTO produto (descricao, precounit) VALUES ('Cupim Bovino',

12.89);

INSERT INTO produto (descricao, precounit) VALUES ('Costelinha

Suína Sadia o Perdigão, 10.99;

Para cada conjunto de datos se realizó un INSERT. Sin embargo, también es posible
inserir de la siguiente forma:

INSERT INTO produto (descripcion, precounit) VALUES

('Cupim Bovino', 12.89)
Costelinha Suína Sadia ou Perdigão

Para realizar el comando INSERT dentro del lenguaje Python, tendremos que
escribir el siguiente código:

01 import sqlite3
02 conn = [Link]('base_de_datos.db')
03 cursor = [Link]()
04 [Link](
INSERTAR EN produto (descripcion, precounit) VALORES (?, ?), (?, ?)
06 ('Cupim Bovino', 12.89, 'Costelinha Suína Sadia ou Perdigão', 10.99))
07 [Link]()
08 [Link]()

54
Línea 03: La función cursor es responsable de realizar cualquier manipulación con el
base de datos. Siempre que haya la necesidad de trabajar con una tabla, será
es necesario llamar a esta función;
Líneas 04, 05 y 06: El comando execute recibe qué comando deberá ser ejecutado.
En este caso ejecutaremos el siguiente comando:

INSERTAR EN produto (descricao, precounit) VALORES (?, ?), (?, ?)

El símbolo de interrogación (?) denota que será necesario pasar un parámetro como
referencia. En este caso será necesario pasar cuatro parámetros:

Cupim Bovino

12.89 Costelinha Suína Sadia o Perdigão 10.99

↑ ↑ ↑ ↑
01 02 03 04

Línea 07: El comando commit graba la instrucción pasada en execute. Este comando
es necesario para realizar la operación en el banco.

Ejemplo 02: Se desea insertar en la tabla producto el siguiente dato:

Descripción Precio unitario

Filé de Tilápia Geneseas 7.79

INSERT INTO produto (descricao, precounit) VALUES ('Filé de

Tilápia Geneseas, 7.79

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link](
05 'INSERT INTO producto (descripcion, precounit) VALUES (?, ?)'
06 ('Filé de Tilápia Geneseas', 7.79)
07 [Link]()
08 [Link]()

Para probar si los datos se están almacenando en [Link], utiliza lo siguiente

site

55
[Link]

Para abrir el banco, haz clic en Archivo Abrir DB.

Haga clic con el botón derecho en el producto y elija Mostrar tabla.

56
Comando UPDATE

El comando UPDATE es responsable de editar un dato que ya existe en la tabla. Él

posee la siguiente sintaxis:

ACTUALIZAR tabla SET campo = nuevoValor DONDE campoClave = valor

Dónde:
ACTUALIZAR CONFIGURAR: comando de la instrucción;

tabela: nome da tabela a ser utilizada;

campo: nome del campo a ser editado. Si hay más campos a ser
alterados utilice coma (,) para separarlos;
nuevo valor del campo
DÓNDE: condición de actualización;
código de la tabla;
valor del código.

Ejemplo 03: Cambia el precio unitario del producto:

Id Descripción Precio unitario

21 Cupim Bovino 12.89

por R$ 21.99.

ACTUALIZAR produto SET precounit = 21.99 DONDE id = 21

Para realizar el comando UPDATE dentro del lenguaje Python, tendremos que
escribir el siguiente código:

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link](
05 actualizar producto establecer precounit = ? donde id = ?
06 [Link]()
07 [Link]()

57
Ejemplo 04: Cambia la descripción y el precio unitario del producto:

Id Descripción Precio unitario

23 Filé de Tilapia Geneseas 7.79

para

Id Descripción Precio unitario

23 Camarón DellMare 8.99

UPDATE produto SET descricao = 'Camarão DellMare', precounit =

8.99 DÓNDE id = 23

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link](
05 ACTUALIZAR produto SET descricao = ?, precounit = ? WHERE id = ?
Camarão DellMare
07 [Link]()
08 [Link]()

Comando ELIMINAR

El comando DELETE se utiliza para eliminar un dato de una tabla de la base de datos.
dados. Él posee la siguiente sintaxis:

ELIMINAR DE tabela DONDE campoChave = valor

Dónde:
ELIMINAR DE: comando de la instrucción;
nombre de la tabla a ser manipulada
DONDE: condición de eliminación;
código de la tabla
valor del código.

Ejemplo: Elimina el registro 23.

58
BORRAR DE produto DONDE id = 23

Para realizar el comando DELETE dentro del lenguaje Python, tendremos que
escribir el siguiente código:

01 importar sqlite3
02 conn = [Link]('base_de_datos.db')
03 cursor = [Link]()
04 [Link]('DELETE FROM produto WHERE id = ?', (23,))
05 [Link]()
06 [Link]()

Comando SELECT

El comando SELECT se utiliza para realizar consultas a las tablas de la base de datos.
dados. Él posee la siguiente sintaxis básica:

SELECCIONAR campos DE tablas;

Dónde:
SELECCIONAR: selecciona los campos a mostrar;
campos: campos elegidos para exhibición;
SELECCIONA LAS TABLAS UTILIZADAS;
tabelas escolhidas.

Ejemplo 05: Visualiza la descripción de todos los productos registrados.

SELECCIONAR descripcion DE producto

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link]('SELECT descricao FROM produto')
05 para linha em [Link]():
06 print(linha[0])
07 [Link]()
08 [Link]()

Ejemplo 06: Visualiza todos los datos de la tabla producto.

59
SELECCIONAR * DE producto

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link]('SELECT * FROM produto')
05 para linha em [Link]():
06 imprimir('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Para visualizar todos los campos de una tabla utiliza el símbolo asterisco (*). En el caso
se emitirá una lista que contiene: (id, descripción, precounit).

Posición 0 id
Posición 1 descripción
Posición 2 precounit

Comando WHERE

El comando WHERE se utiliza para probar una determinada condición. Puede ser
construido dentro de los comandos: INSERT; UPDATE; o WHERE.

Ejemplo 07: Muestra todos los productos cuyo precio unitario es mayor a R$ 500,00.

SELECCIONAR * DE produto DONDE precounit > 500

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link]('SELECT * FROM produto WHERE precounit > 500')
05 para linha em [Link]():
06 imprimir('{0} - R$ {1}'.formato(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Ejemplo 08: Muestra todos los productos cuya descripción comienza con la letra 'F'.

SELECCIONAR * DE producto DONDE descricao como 'F%'

60
 01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link]("SELECT * FROM produto WHERE descricao LIKE ?", ('F%',))
05 para línea en [Link]():
06 print('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Trabajando con más de una tabla

Supongamos que se desea mostrar todos los productos realizados en una determinada
compra. Neste caso precisaríamos:
de la tabla compra para identificar cuál fue la compra realizada;
de la tabla compra_producto para identificar cuáles son los productos de esa
compra; e
de la tabla producto para mostrar la descripción.

El código sería el siguiente:

SELECCIONAR
descripción
DE
producto
DÓNDE
[Link] = compra_produto.idcompra Y
[Link] = compra_produto.id Y
[Link] = 1

Interpretando el código anterior, selecciona la descripción del producto de la compra cuyo id es

igual a 1. Necesitamos relacionar las tablas, y para eso es necesario comparar los
campos claves de la tabla principal con sus respectivas referencias:

[Link] = compra_produto.idcompra Y
[Link] = compra_producto.id

A continuación se muestra el código en Python que resolvería este problema.

61
 01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link](
05 'SELECCIONAR descripcion DE producto, compra, compra_producto ' +
06 'DONDE [Link] = compra_produto.idcompra Y ' +
07 '[Link] = compra_produto.id Y [Link] = 1')
08 para linha em [Link]():
09 imprimir('{0}'.formato(linha[0]))
10 [Link]()
11 [Link]()

Ejemplo 09: Presente el valor total a ser pagado de la compra cuyo id es igual a 1.

Para obtener el total de una compra, será necesario multiplicar las columnas
precounitequantidadede cada item. Para isso precisamos realizar a seguinte
consulta:

SELECCIONAR
Descripción
DE
producto
DÓNDE
[Link] = compra_produto.idcompra Y
[Link] = compra_produto.id Y
[Link] = 1

A continuación tenemos el código que resuelve el problema.

01 importar sqlite3
02 conn = [Link]('[Link]')
03 cursor = [Link]()
04 [Link](
05 'SELECCIONAR descricao, precounit, quantidade DE produto, compra,
06 compra_produto DONDE [Link] = compra_produto.idcompra Y ' +
07 '[Link] = compra_produto.id Y [Link] = 1')
0
09 para linha em [Link]():
10 imprimir('{0} (R$ {1}) CANT: {2}'.format(linha[0], linha[1], linha[2]))
11 total += línea[1] * línea[2]
12 print('Total a pagar: R$ {0}'.format(total))

62
 13 [Link]()
14 [Link]()

Líneas 08 y 11: crea una variable y a continuación acumula la suma de la multiplicación del
precio unitario con la cantidad de cada producto.

Lista de ejercicio G

1) Con base en la base de datos presentada, crea el siguiente sistema.

El usuario entrará en un menú que tendrá las siguientes opciones:

Elige una opción:

1) Crear un nuevo producto
2) Crear una nueva compra
3) Agregar un producto a la compra
4) Consultar los productos por nombre
5) Consultar datos de la compra
6) Excluir una compra
7) Salir

Cada opción realiza la siguiente operación:

1 El usuario ingresará los datos del nuevo producto y los guardará en la base de datos;
2 El usuario podrá crear una nueva compra
3 A partir de una compra, el usuario podrá agregar un artículo, producto, a la lista de compras
4 A partir de la descripción, el usuario podrá consultar los productos registrados.
5 A partir de una compra, se enumerarán todos los datos del producto y su cantidad, así
como el total a pagar
6 El usuario saldrá del sistema

63
Manejo de Excepciones

Al escribir un código, el desarrollador puede cometer tres tipos de errores: error lógico;
error de sintaxis; error de ejecución.

El error lógico ocurre cuando el desarrollador comete un equívoco en las reglas de

negocio de la aplicación, este tipo de error normalmente se descubre cuando los usuarios que
utilizan el sistema descubren la incoherencia del problema con la solución presentada.

El error de sintaxis ocurre en el momento en que se está escribiendo el código. Este tipo de error
es el más simple de ser detectado teniendo en cuenta que ocurre durante la creación del
proyecto.

El error de ejecución ocurre cuando el usuario solicita la llamada a una acción y esta
por su parte no puede ser completada debido a un error en alguna instrucción del
código. La siguiente instrucción es un ejemplo clásico de un error de ejecución:

División por cero

En esta instrucción, el sistema no muestra error y permite que el código se ejecute. En

al ejecutarlo, se mostrará el siguiente mensaje:

Traceback (la llamada más reciente fue la última):

Archivo "C:/desenvolvimento/ [Link]", línea 1, en <módulo>

x = 1/0
ZeroDivisionError: división por cero

En este capítulo veremos cómo tratar errores de ejecución a través del tratamiento de
excepciones. Las palabras clave try/except se utilizan en la construcción del tratamiento
de excepción. Utilizando el manejo de excepciones, el mismo código podría escribirse de la
siguiente forma:

intentar
x = 1/0
excepto BaseException:
print('Error de división por cero')
print('Continuación...')

64
Aunque ocurra el error, la ejecución no se interrumpe.

Es posible declarar más de un except para manejar diferentes tipos de error. Ejemplo:

importar zipfile
intentar:
banco_zip = [Link]("[Link]")
banco_zip.extraer_todo(ruta="banco")
banco_zip.cerrar()
except FileNotFoundError:
print("Archivo inexistente")
excepto PermissionError:
print("Error de permiso")

En este caso, el código maneja dos tipos de excepciones: el primer caso es que no encuentre el archivo.

(FileNotFoundError); y en segundo lugar, en caso de que no tenga permiso para la extracción del
archivo (PermissionError).

Jerarquía de excepciones

Para cada error es posible especificar su tipo, por ejemplo, cuando un número es dividido.
por cero el error invocado será ZeroDivisionError. En Python existe una jerarquía
de errores.

ExcepciónBase
o SystemExit
o KeyboardInterrupt
o GeneratorExit
o Excepción
. DetenerIteración
. ErrorAritmético
ErrorDePuntoFlotante
Error de desbordamiento
Error de división por cero
. Error de afirmación
. AttributeError
. Error de buffer
. EOFError
. ImportError
. Error de búsqueda

65
 IndexError
Error de clave
. Error de memoria
. NameError
UnboundLocalError
. OSError
BlockingIOError
Error de Proceso Hijo
Error de Conexión
o BrokenPipeError
Error de conexión abortada
o ConnectionRefusedError
o ConnectionResetError
ErrorFileExists
Error de archivo no encontrado
Error de interrupción
IsADirectoryError
NoEsUnDirectorioError
Error de permiso
ErrorDeConsultaDeProceso
Error de tiempo de espera
. Error de referencia
. Error de tiempo de ejecución
ErrorNoImplementado
. Error de sintaxis
Error de sangría
o TabError
. Error del sistema
. TypeError
. ValueError
Error de Unicode
o UnicodeDecodeError
o UnicodeEncodeError
o UnicodeTranslateError
. Advertencia
Advertencia de desaprobación
Advertencia de desuso pendiente
Advertencia de tiempo de ejecución
Advertencia de sintaxis
Advertencia de usuario
Advertencia de futuro
Advertencia de importación
Advertencia de Unicode
Advertencia de Bytes
Advertencia de recurso

Si hay dudas sobre qué excepción utilizar, es posible invocar el tratamiento de errores.
primárioBaseException. Cada clase de excepción tiene sus particularidades.

66
Acción de limpieza

Al escribir un código que contenga el manejo de excepciones, puede ocurrir que

desarrollar necesitar limpiar alguna variable, cerrar algún archivo o procedimiento que
esté abierto. Considerando estos casos, existe un comando opcional que puede ser
utilizado juntamente com try/except. Este comando es conocido como finally.

El comando finalmente siempre ejecutará el código, independientemente de si ocurrió un error o no.

no. Ejemplo:

def leerMetaDatos(archivo):
intenta:
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
para linha em dados:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
except FileNotFoundError:
print('Archivo no encontrado.')
finalmente
[Link]()
devolver metaDatos

Comando raise

Este comando se utiliza cuando el desarrollador necesita provocar un error controlado.

Siga la sintaxis:

elevar Error

dónde
aumentar palabra clave utilizada para provocar el error;
Error error a ser invocado.

Ejemplo:

def verificar(sabor):

67
 si sabor no está en ('CREME', 'CHOCOLATE', 'NAPOLITANO'):
elevar BaseException

intentar
input('Elige el sabor de helado: ')
verificar(sabor)
Buena elección
excepto BaseException:
No trabajamos con este sabor.

Lista de ejercicios H

1) A partir del código presentado:

x = [1, 3, 5, 6, 7, 8]
i = 0
mientras i <= len(x):
imprimir(x[i])
i += 1

cree un tratamiento de excepción para evitar la ocurrencia del error.

2) Cree un programa en Python que reciba n números y sume esos números mientras la suma
no ser superior a 100. El programa deberá imprimir el valor sumado (antes de alcanzar el número
mayor que 100) y deberá informar cuántos números fueron sumados y cuál es la media. Refácea su
programa utilizando las siguientes reglas:
a. Utilice el tratamiento de excepciones para manejar la entrada de datos;
b. Cuando la suma sea superior a 100, el programa deberá generar una excepción.

3) Escribe un programa en Python que llene valores de un array con 10 posiciones. El

el usuario informará los valores a insertar y sus respectivas posiciones en el array. El
el programa debe manejar las excepciones cuando se informe una posición inexistente del array
cuando el valor informado no sea un número.

68
4) Suponga que el usuario realice transacciones en su cuenta corriente. Desarrolle un código en
Cual el usuario ingresará su saldo inicial. Podrá realizar un Débito o Crédito. Lance una
excepción en caso de que el saldo del cliente se vuelva negativo. El valor del saldo no deberá ser negativo.

69
Archivos

Cruz

70
Python y Arduino

71
Referencia Bibliográfica

CRUZ, [Link]: Escriba sus primeros programas. 1ª ed. Casa del Código: São
Paulo. 1998.

MENEZES, N. Introducción a la programación con Python: algoritmos y lógica de

programación para principiantes. 2ª ed. Novatec: São Paulo. 2014.

72