Está en la página 1de 31

UNIVERSIDAD ANDRÉS BELLO

FACULTAD DE INGENIERÍA

INGENIERÍA EN AUTOMATIZACION Y ROBOTICA

APUNTES DEL CURSO


FUNDAMENTOS DE PROGRAMACION

(borrador)

Profesor:

Néstor Palominos

SANTIAGO – CHILE
30 de junio, 2019
Apuntes del curso Fundamentos de programación – Nestor Palominos

Contenido
DATOS DEL CURSO ........................................................................................................................................... 3
Bibliografia Recomendada: .............................................................................................................................. 4
INTRODUCCION ............................................................................................................................................... 4
INTRODUCCION A LENGUAJES DE PROGRAMACION ..................................................................................... 5
Salida de datos: ‘HOLAMUNDO’ ................................................................................................................... 7
COMENTARIOS ............................................................................................................................................ 7
INTRODUCCION A VARIABLES ...................................................................................................................... 8
ENTRADA DE DATOS .................................................................................................................................... 8
NUMEROS ALEATORIOS ............................................................................................................................... 9
CONDICIONALES (IF/ELSE).......................................................................................................................... 10
OPERADORES LOGICOS (AND,OR) .............................................................................................................. 10
CICLOS (FOR,WHILE) .................................................................................................................................. 13
ARREGLOS (listas) ...................................................................................................................................... 14
FUNCIONES O METODOS ........................................................................................................................... 15
MANEJO DE ARCHIVOS .............................................................................................................................. 16
Introducción a redes y sockets ....................................................................................................................... 17
Conexión serie ............................................................................................................................................... 19
Bases de datos (MySQL) ................................................................................................................................. 20
Graficos (Matplotlib) ...................................................................................................................................... 21
Timestamps (Marcas de tiempo) .................................................................................................................... 22
SINTESIS DE VOZ (TTS).................................................................................................................................... 23
SOLEMNE 1 2019 VERSION 1 .......................................................................................................................... 24
SOLEMNE 1 2019 VERSION 2 .......................................................................................................................... 26
Anexos: ............................................................................................................... ¡Error! Marcador no definido.
Algoritmo de ordenamiento (sorting)......................................................................................................... 29
Ordenamiento más aleatorios.................................................................................................................... 30
Manejo de archivos – continuación ............................................................................................................ 30
Coordenadas – Combinación de archivos y matrices .................................................................................. 30

2
Apuntes del curso Fundamentos de programación – Nestor Palominos

DATOS DEL CURSO

CONSULTAS: nestor.palominos@gmail.com

Lenguajes a utilizar: Python , C++, Arduino

CONTENIDOS

Unidad 1: Introducción

Conceptos básicos de programación.


Diseño de Algoritmo.
Depuración.
Instalación del lenguaje, IDE
Uso de SciTE

Unidad 2: Conceptos básicos

Entrada y salida de datos


Operatoria matemática básica
Estructuras de control
Ciclos
Operación de cadenas de texto

Unidad 3: Procesamiento de cadenas y archivos

Manejo de strings
Lectura de archivos
Guardado de archivos
Manejo de fechas, timestamps
Procesamiento de archivos csv

Unidad 4: Comunicaciones

Comunicacion serie
Introduccion a sockets y bases de datos

La nota de presentación a examen se calculará como sigue:

NP=35%S1+35%S2+30%LAB

NF=70%NP+30%NE

Eximicion: >5.5

Obs: También incluye sistema de “desafíos” , es decir.. Actividades hechas en clases que bonifican décimas
a modo de participación y superación personal

S1: segunda semana de abril


S2: tercera semana de mayo

Informe final: segunda semana de junio

3
Apuntes del curso Fundamentos de programación – Nestor Palominos

Proyecto semestral

El proyecto semestral, consiste en diseñar e implementar una solución a un problema real, aplicando ingeniería y
programación, tal de utilizar conceptos vistos en clases e investigación del tema.

La estructura a usar será una introducción al desarrollo de tesis, la cual contiene los siguientes puntos a considerar:

-PORTADA TESIS
-INDICE AUTOMATICO
-RESUMEN
-INTRODUCCION
-OBJETIVOS GENERALES Y ESPECIFICOS
-CARTA GANTT
-MARCO TEORICO
-ESTADO DEL ARTE
-DESARROLLO:
-DIAGRAMA DE BLOQUES Y DE FLUJO
-MATERIALES Y PRESUPUESTO
-IMPLEMENTACION
-DISCUSION
-CONCLUSION
-BIBLIOGRAFIA
-ANEXOS (CODIGOS, FOTOS, ESQUEMATICOS)

Para el informe, debe usar párrafos justificados, redacción en tercera persona y las referencias
bibliográficas, deben estar especificadas en formato APA. Puede investigar papers relevantes a su proyecto
en los recursos electrónicos de la página de biblioteca (biblioteca.unab.cl)

Bibliografia Recomendada:

https://codigofacilito.com/cursos/Python

Lectura Fundamental:

http://cienciesvirtuals.com/wp-content/uploads/2016/11/Arduino_Curso_Practico_de_Formacion.pdf

INTRODUCCION

4
Apuntes del curso Fundamentos de programación – Nestor Palominos

Estimado Alumno. Bienvenido al curso de fundamentos de programación, el cual es el primer curso del eje Robótica
de la carrera “Ingeniería en automatización y robótica” de la UNAB.

Para comenzar, es necesario saber que el bloque de cursos sigue una misma línea:

Fundamentos de programación
Electrónica
Microcontrol
Redes de datos

Se verán contenidos mezclados en los cuatro cursos, puesto a que todos ellos integran un sistema. Primeramente
se verá cómo funciona el bloque abstracto, el programa o código que manejara a la máquina (software) y le dará
cierta “inteligencia”, puesto a que en este eje de la carrera se desarrollaran dispositivos que implican lectura de
estímulos->procesamiento ->respuestas.

Luego en electrónica, se verá la parte física (hardware) donde se procesan los impulsos eléctricos 1 y 0 (binario) a
nivel de voltaje y que representan las acciones tomadas por el programa.

En microcontrol, se integraran estas dos áreas en un circuito programable y finalmente en redes de datos se verá
como las maquinas se comunican entre ellas, viendo en detalle los protocolos de comunicación.

Generalmente para quien nunca ha programado antes, las primeras notas son malas, pero esto no significa que no
tenga capacidad. Un futuro ingeniero debe saber ponerse de pie y seguir adelante.

Veremos inicialmente una introduccioin Python para posteriormente integrar nociones de C++ y Arduino

Este curso esta orientado a crear software que interactuara con hardware , por lo que se incluirán algunos tópicos
de electrónica básica , los cuales se verán en profundidad en el curso de sistemas digitales

Buena suerte

Néstor Palominos G.

Materiales (Necesarios para fundamentos de programación, electrónica, microcontrol y redes):

-Protoboard
-Multimetro
-Transformador 3 a 12 VDC multiuso
-Arduino (Nano o UNO)
-Leds
-Servomotor
-Puente H
-Cautin y soldadura

INTRODUCCION A LENGUAJES DE PROGRAMACION

5
Apuntes del curso Fundamentos de programación – Nestor Palominos

Un lenguaje de programación corresponde a un código diseñado a partir de un texto plano que a partir de
instrucciones y variables, representa una serie de pasos que la maquina debe ejecutar para efectuar una tarea
dada.

Algunas consideraciones necesarias:


-Un lenguaje se lee de izquierda a derecha y de arriba hacia abajo
-La mayoría distinguen entre mayúsculas y minúsculas (caso sensitivo)
-Si no funciona, observar el número de línea que arroja el error

Se usara este semestre Python Anaconda 2.7, y DEV C++

Se define un IDE como un entorno de programación (se puede crear el código por bloc de notas, pero es más
complejo el proceso de compilación)

Usaremos scite, puesto a que es liviano y portable a diferencias de otros IDE mas pesados como Eclipse o
Netbeans

Para usarlo, se debe copiar el contenido del scite a la carpeta bin del lenguaje a utilizar

Un programa representa a un proceso, es decir, la serie de pasos secuenciales necesarios para realizar una tarea.
Generalmente se diseñan como diagramas de flujo, los cuales dan pie para poder codificarlos posteriormente

Empecemos..

CAPITULO 1: PYTHON

6
Apuntes del curso Fundamentos de programación – Nestor Palominos

Salida de datos: ‘HOLAMUNDO’

El primer fundamento que veremos es la salida de datos, es decir que el programa nos muestre mensajes.
Haremos un programa que al ejecutar simplemente nos diga “hola mundo”.

print “HolaMundo”

(Las comillas se hacen con shift + 2)

Ahora, si queremos concatenar (unir) texto, se puede usar el operador ‘+’, el cual con numeros suma y con texto
concatena

Por ejemplo:

Print “hola”+ “mundo”

Si ponemos:

Print “Hola”
Print “mundo”

Se escribirán hacia abajo. Si queremos que escriba hacia al lado, al final del primer
print se le agrega una coma:

Print “hola”,
Print “mundo”

COMENTARIOS

7
Apuntes del curso Fundamentos de programación – Nestor Palominos

Se definen como bloques de programación que el lenguaje no toma en cuenta. Sirven para indicar al
programador, pasos para facilitar la comprensión del código (como notas al margen)

Ejemplo

#esto es un comentario

“””
Esto también es un comentario
Sirve para comentar más de una línea
“””

INTRODUCCION A VARIABLES

Def: variable: espacio de memoria con un nombre y un tipo de dato definido, el cual guarda un valor dado.

El tipo de dato puede ser:

int numero entero (sin decimales)


double o float número real (con decimales)
string cadena alfanumérica sin valor matemático
boolean verdadero/falso

Los nombres de variable no pueden llevar espacios

Ojo con las mayúsculas y minúsculas. La variable x minúscula no es lo mismo que la variable X mayúscula. Otra
cosa importante: las variables no llevan acentos, ni símbolos que no sean el guion bajo “_”

A=2
B=3
C=A+B
print C

o bien:

A=2
B=3
C=A+B
print “la suma de”+ str(A)+ “+” + str(B) “es” + str(C)
#la function str convierte un numero a string (parsing)

ENTRADA DE DATOS

8
Apuntes del curso Fundamentos de programación – Nestor Palominos

El próximo fundamento a estudiar es la entrada de datos, un programa por lo general necesita también que el
usuario ingrese datos. Estos datos se guardan originalmente como string, pero si se requiere un número, se puede
hacer un parsing a la variable correspondiente:

x=raw_Input("ingrese un numero")
y=int(x)+1 #la función int(x) convierte a string
print "el numero mas uno es: "+str(y)

Algunas funciones matematicvas de utilidad:

pow(2,3) #calcula 2 elevado a 3


abs(-2) #calcula valor absoluto de -2
sqrt(4) #calcula raíz cuadrada de 4
max(1,2,3) #calcula el máximo entre 1,2 y 3
min(1,2,3) #calcula el minimo entre 1,2 y 3

Actividad:

CREAR UN PROGRAMA QUE TOME 3 NUMEROS REALES Y CALCULE LAS RAICES DE UNA ECUACION CUADRATICA
AL TENER DICHA ECUACION 2 SOLUCIONES, DEBE IMPLEMENTAR 2 METODOS:

Recuerde que

Pruebe con los valores a=1 b=5 c=2

NUMEROS ALEATORIOS

Def:

Un número aleatorio es un número al azar, es como tirar un dado, en el cual se especifica el rango de números
donde puede caer la solución. Para utilizar rando, se debe importar su librería, poniendo como primera línea:
from random import *

La sintaxis es la siguiente:

random() #crea un aleatorio entre 0 y 1 del tipo real


randrange(0,10,1) #crea un aleatorio entre 0 y 10 con paso 1

9
Apuntes del curso Fundamentos de programación – Nestor Palominos

CONDICIONALES (IF/ELSE)

Def: un condicional es un bloque de programación, el cual analiza una condición lógica que puede ser verdadero
(true) o falso (false)

La idea es que el programa pueda tomar dos caminos según el valor lógico de la condición. En este punto, nuestro
programa podrá tomar decisiones a partir de variables de entrada. En robótica se usa mucho, por ejemplo un
robot móvil que detecta obstáculos. Si detecta una pared gira. En caso contrario sigue.

la sintaxis es:

if(condición):
#acá va el código si la condición es verdadera

Else:
#acá va el código si la condición es falsa

OJO!! Aca utilizaremos el concepto de ident. Todo lo que esta dentro del if debe estar tabulado

Ejemplo:

nota=4.5;

if(nota>=4):
print "Aprobado";
else
print "Reprobado";

OPERADORES LOGICOS (AND,OR)

10
Apuntes del curso Fundamentos de programación – Nestor Palominos

Def: conectores de proposiciones o condiciones lógicas, las cuales trabajan en conjunto con la función if/else
cuando se tiene más de una condición

La mayoría de las condiciones lógicas son compuestas. Por ejemplo un cajero automático: “ingreso bien la clave y
tiene saldo, entonces se entrega el dinero”. Ese “Y” es fundamental, puesto a que verifica que dos o más
condiciones se cumplen o no para ejecutar una acción.

Se definirán:

FUNCION”Y” (&&)

Todas las condiciones son verdaderas para que la función y sea verdadera

FUNCION “O” (||)

Al menos una condición debe ser verdadera para que la expresión sea verdadera

Ejemplo: Clasificación de edades

si la edad de una persona está entre 18 y 65, que muestre “A”, en caso contrario, “B”

edad=25;

if(edad>=18 and edad<65):


print "A"

else:
print "B"

Ejemplo: If mas números aleatorios

11
Apuntes del curso Fundamentos de programación – Nestor Palominos

Escribir un programa que pida un numero que represente la información de un sensor de luz (0-100).

Si el valor esta bajo 30 debe decir “bajo”


Si esta entre 31 y 50 debe decir “medio”
Si esta sobre 51 debe decir “alto”

Solucion:

from random import *

x=randint(0,10)

if x<30:
print “BAJO”
if x>=30 and x<50:
print “MEDIO”
if x>=50:
print “ALTO”

Ejemplo: Cachipun

Hacer programa que muestre el mensaje: "ingrese opción: 1=piedra 2=tijera 3=papel 0=salir"
El usuario debe ingresar un número entre 1 y 3 y el programa responde con piedra, papel o tijera.
Si el usuario ingresa un 0, sale del programa

from random import *

while(1):

print "elegir 1:papel 2:tijera 3:piedra 0:salir"


humano=int(raw_input("ingrese opcion:"))

if humano==1:
print "humano:papel"
if humano==2:
print "humano:tijera"
if humano==3:
print "humano:piedra"

maquina=randint(1,3)

if maquina==1:
print "maquina:papel"
if maquina==2:
print "maquina:tijera"
if maquina==3:
print "maquina:piedra"

#print str(humano) +" "+str(maquina)

if humano==0:
print "chao"
exit(0)

if(humano==maquina):
print "empate"

12
Apuntes del curso Fundamentos de programación – Nestor Palominos

if(humano==1 and maquina==2):


print "gana maquina"

if(humano==1 and maquina==3):


print "gana humano"

if(humano==2 and maquina==1):


print "gana humano"

if(humano==2 and maquina==3):


print "gana maquina"

if(humano==3 and maquina==1):


print "gana maquina"

if(humano==3 and maquina==2):


print "gana humano"

CICLOS (FOR,WHILE)

Def: un ciclo (también llamados loop o bucles) corresponde a un bloque de código, el cual se ejecuta tantas veces
como el usuario lo defina

Existen dos tipos de ciclos: FOR y WHILE. Estos hacen prácticamente lo mismo, solo se diferencian en su sintaxis

for i in range(valor)
#código a repetir
}

Ejemplo:

For i in range(10):
Print “holamundo”

O bien:

For i in range(10):
If i<5:
Print “holamundo”
Else if i>=5:
Print “chaomundo”

Tambien se puede especificar un valor de inicio, uno de término y un incremento:

13
Apuntes del curso Fundamentos de programación – Nestor Palominos

for i in range(0,10,1): #numeros del 0 al 10 consecutivos de 1 en 1


print i

for i in range(0,100,5): #numeros del 0 al 100 consecutivos de 5 en 5


print i

for i in range(10,0,-1): #numeros del 10 al 0 decrementando en 1


print i

Respecto a while este funciona con la siguiente sintaxis:

int i=1;
while(i<=10){
print i;
i+=1

Repite todo lo que este entre llaves hasta que corte la condición

Ahora, esta el caso particular del while(1) que repite indefinidamente todo lo que se indique
Ejemplo:

while(1):
print “hola”

ARREGLOS (listas)

Un arreglo o array (En python, ‘lista’) es un grupo de variables las cuales son declaradas solo en una línea, además
de poseer un único nombre identificador y un índice que identifica a cada variable. Veamos un ejemplo:

14
Apuntes del curso Fundamentos de programación – Nestor Palominos

x=[]

x.append(1)
x.append(2)
x.append(3)

resultado=x[0]+x[1]+x[2]
print resultado

o bien:

x=[]

x.append(1)
x.append(2)
x.append(3)

resultado=0
for i in range(3):
resultado=resultado+x[i]

print resultado

Veamos un ejemplo con strings:

x=[‘A’,’B’,’C’]
print x[0]+x[1]+x[2]

FUNCIONES O METODOS

Def.: Una función o método, consiste en un bloque de programación asociado a un nombre y un conjunto de
argumentos que permiten reutilizar un bloque de código cuantas veces se requiera. Se inician mediante la
instrucción ‘def’ Por ejemplo, definiremos una función llamada ‘sumar’ que recibirá dos argumentos representados
por las variables x e y.

Las funciones van en la parte superior del código y la rutina principal o “MAIN” la dejaremos al final por un asunto
de orden. Es opcional también separar mediante comentarios para delimitar ambas zonas

###################[FUNCIONES

def sumar(x,y):
z=x+y

15
Apuntes del curso Fundamentos de programación – Nestor Palominos

print z

###################[MAIN
sumar(1,3)
sumar(4,6)

En el código anterior, dentro de la rutina principal, se llamo (invoco) a la función sumar 2 veces pero con
argumentos diferentes (1,3 y 4,6 respectivamente).

Esto significa que se puede llamar ahora las veces que uno quiera a la función, sin tener que redefinirla en cada
operación.

Existen también funciones que retornan un valor (es decir que al llamar a la función, su resultado se guarda en
una variable) por ejemplo (comparar con código anterior):

###################[FUNCIONES

def sumar(x,y):
z=x+y
return z

###################[MAIN

#observar que el resultado de sumar ahora se esta guardando en una variable


n1=sumar(1,3)
n2=sumar(4,6)

print n1
print n2

MANEJO DE ARCHIVOS

Corresponde a la capacidad de un lenguaje de programación para poder almacenar información en un texto plano,
asi como leerla posteriormente. Sirve para poder llevar registro de determinados eventos como por ejemplo, algo
que haya ingresado el usuario, resultados de una operación o adquisición de datos de un sensor.

Grabar un dato en un archivo de texto:

f = open('holamundo.txt','a')
f.write('Hola Mundo')
f.close()

16
Apuntes del curso Fundamentos de programación – Nestor Palominos

Leer un dato desde un archivo de texto (el archivo debe existir primero)

f = open ('holamundo.txt','r')
mensaje = f.read()
print(mensaje)
f.close()

Ejemplo: Definir funciones para grabar y leer archivo. Leer el contenido de un archivo

def LeerArchivo(archivo):
f = open ('holamundo.txt','r')
mensaje = f.read()
print(mensaje)
f.close()

def GuardarArchivo(archivo,texto)
f = open('holamundo.txt','a')
f.write('Hola Mundo')
f.close()

###############[MAIN

GuardarArchivo(“hola.txt”,”123”)
LeerArchivo(“hola.txt”)

Introducción a redes y sockets

Sabiendo programar en un lenguaje de programación, tendremos la capacidad de poder enviar y recibir información
desde una maquina a otra conectadas a una red.

Es necesario saber que dentro de una red LAN (Local Area Network) cada equipo conectado esta asociado a una
dirección IP, la cual consiste en cuatro números separados por puntos los cuales representan al identificador de
determinado equipo en una red (algo así como el rut de una persona)

Un servidor es aquel equipo de la red que abre un puerto y que espera a que un cliente se conecte, tal de
intercambiar datos con éste. Un servidor puede atender a varios clientes a la vez.

17
Apuntes del curso Fundamentos de programación – Nestor Palominos

Dichos datos están estructurados en un lenguaje que entiende tanto el emisor como el receptor del mensaje,
llamado ‘protocolo de comunicación’. El mas utilizado actualmente es TCP/IP, el cual es el protocolo utilizado por
internet.

El cliente es aquel equipo que se conecta al servidor especificando su IP y el puerto a conectar.

El puerto es un número entero comprendido entre 1 y 65536 que representa al canal de comunicación donde el
servidor nos enviara los datos. Existen protocolos basados en TCP/IP que tienen puertos asignados de forma
standard (HTTP es el puerto 80, FTP es el puerto 21 por ejemplo)

Para probar un programa que utilice sockets dentro de una red si solo contamos con un computador, se puede
utilizar la IP de localhost donde el cliente y el servidor corren en la misma maquina (127.0.0.1)
Para mayor detalle, ver el manual de redes de datos.

Este código inicia un servidor TCP/IP en el puerto 4444. Puede probar este código utilizando la ip de localhost
127.0.0.1 y el software putty

Servidor.py

import socket, threading


import time

class ClientThread(threading.Thread):

def __init__(self,ip,port):
threading.Thread.__init__(self)
self.ip = ip
self.port = port
print "[+] Nuevo thread comenzado para la ip "+ip+":"+str(port)

18
Apuntes del curso Fundamentos de programación – Nestor Palominos

def run(self):
print "Conexion desde : "+ip+":"+str(port)

#clientsock.send("\nWelcome to the server\n\n")

data = " "

while len(data):
data = clientsock.recv(2048)
if data=='quit':
exit();
msg = time.strftime("%c")+":"+data
print data,
outfile = open('registro.txt', 'a')
outfile.write(msg);
outfile.close()
#clientsock.send("You sent me : "+data)

print "Cliente desconectado..."

#########################################################################
host = "0.0.0.0"
port = 4444
hola()

tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)


tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

tcpsock.bind((host,port))
threads = []

def hola(self):
print "holamundo"

while True:
tcpsock.listen(4)
print "\nServidor iniciado OK..."
(clientsock, (ip, port)) = tcpsock.accept()
newthread = ClientThread(ip, port)
newthread.start()
threads.append(newthread)

for t in threads:
t.join()

Conexión serie

Código Python:

import serial
import time

ser = serial.Serial('com1',9600)

time.sleep(1)

19
Apuntes del curso Fundamentos de programación – Nestor Palominos

print ser.readline

print ("1:ON 0:OFF")

while 1:

var = raw_input()

if (var == '1'):
ser.write('1')
print ("ON")

if (var == '0'):
ser.write('0')
print ("OFF")

Código Arduino:

int led = 13;

void setup() {
Serial.begin(9600);
pinMode(led, OUTPUT);
}

void loop(){
if (Serial.available()>0) {
char option = Serial.read();

if (option == '1'){
digitalWrite(pinLED, HIGH);
}

if (option == '1'){
digitalWrite(pinLED, LOW);
}
}

Bases de datos (MySQL)

Codigo 01:
import MySQLdb
import sys
import time
import datetime

db = MySQLdb.connect("host","user","password","dbase" )

ts = time.time()
timestamp = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
print timestamp

20
Apuntes del curso Fundamentos de programación – Nestor Palominos

cursor = db.cursor ()

cursor.execute ("SELECT * FROM datos")

data = cursor.fetchall ()

for row in data :


print row[0], row[1]

cursor.close ()

db.close ()
sys.exit()

Codigo 02:

import MySQLdb

db = MySQLdb.connect(host="localhost",user="root",passwd="",db="test")
cur = db.cursor()
cur.execute("SELECT * FROM tabla")

for row in cur.fetchall() :


print row[0]," | ",row[1]," | ",row[2]

Graficos (Matplotlib)

import pandas as pd
from matplotlib import pyplot
import matplotlib.dates as md
from datetime import datetime

#IMPORTACION DE DATOS CSV A PANDAS DATAFRAME


series = pd.read_csv('correlaciones.csv', squeeze=True, header=0, parse_dates = [0], sep=';')

df = pd.DataFrame(series, columns = ['TIMESTAMP', 'COBRE', 'USDCLP'])[100000:103000]


#print(df)

print df[1:10]

#EXTRAIGO LAS SERIES


t = df["TIMESTAMP"]
x = df["COBRE"]
y = df["USDCLP"]

print t

f1 = pyplot.figure()
f2 = pyplot.figure()

ax1 = f1.add_subplot(111)
ax2 = f2.add_subplot(111)

f1.autofmt_xdate(rotation=60)
f2.autofmt_xdate(rotation=60)

ax1.plot(t,x)
f1.savefig('f1.png')

ax2.plot(t,y)
f2.savefig('f2.png')

21
Apuntes del curso Fundamentos de programación – Nestor Palominos

pyplot.show()

Timestamps (Marcas de tiempo)

Codigo 01:

import time

print time.strftime("%c")

Codigo 02:

import datetime as dt

fecha=dt.date(2018,3,12)
print fecha

hora=dt.time(1, 2, 3)
print hora

timestamp = dt.datetime.combine(fecha, hora)


print timestamp

t = dt.time(1, 2, 3)
print t
print 'hour :', t.hour
print 'minute:', t.minute
print 'second:', t.second

today = dt.date.today()

print today

print 'ctime:', today.ctime()


print 'tuple:', today.timetuple()
print 'ordinal:', today.toordinal()

print 'Year:', today.year


print 'Mon :', today.month
print 'Day :', today.day

print 'Today :', today

one_day = dt.timedelta(days=1)
print 'One day :', one_day

yesterday = today - one_day


print 'Yesterday:', yesterday

tomorrow = today + one_day


print 'Tomorrow :', tomorrow

print 'tomorrow - yesterday:', tomorrow - yesterday


print 'yesterday - tomorrow:', yesterday - tomorrow

print 'Times:'
t1 = dt.time(12, 55, 0)
print '\tt1:', t1
t2 = dt.time(13, 5, 0)
print '\tt2:', t2
print '\tt1 < t2:', t1 < t2

22
Apuntes del curso Fundamentos de programación – Nestor Palominos

print 'Dates:'
d1 = dt.date.today()
print '\td1:', d1
d2 = dt.date.today() + dt.timedelta(days=1)
print '\td2:', d2
print '\td1 > d2:', d1 > d2

SINTESIS DE VOZ (TTS)

# -*- coding: iso-8859-15 -*-

import os
import pyttsx
import unicodedata
import serial

arduino = serial.Serial('/dev/ttyAMA0', 9600)

engine = pyttsx.init()
engine.setProperty('voice', "spanish-latin-american")

archi=open('stt.txt','r')
linea=archi.readline()
while linea!="":
print linea

linea=linea.replace("á","a")
linea=linea.replace("é","e")
linea=linea.replace("í","i")
linea=linea.replace("ó","o")
linea=linea.replace("ú","u")

print(linea)

if linea.find("enciende")>=0:
arduino.write('H')
print('LED ENCENDIDO')
elif linea.find("apaga")>=0:
arduino.write('L')
print('LED APAGADO')

arduino.close()

engine.say(linea)
engine.runAndWait()
#os.system('clear')

linea=archi.readline()
archi.close()

23
Apuntes del curso Fundamentos de programación – Nestor Palominos

SOLEMNE 1 2019 VERSION 1

Se requiere crear un parafraseador, es decir, a partir de un archivo de texto y una lista de equivalencias, sustituya
las ocurrencias de las palabras del diccionario por su sinónimo

Por ejemplo, si tiene un archivo de texto que contiene:

ABC
DEA
BCA

Y el diccionario: (guardado en archivo)

A;X
B;Y
C;Z

Debe transformar el archivo original a:

XYZ
DEX
YZX

Solución:

Supongamos los archivos de entrada:

Texto.txt
esta es
la pauta
de la solemne uno
de fundamentos de programacion

Diccionario.txt
solemne;prueba
pauta;solucion

El código es el siguiente:

####PAUTA SOLEMNE 1 - FTO DE PROGRAMACION


####NP2019

d1=[]
d2=[]

def LeerArchivo(archivo):
f = open(archivo,'r')
while True:
linea = f.readline()
if not linea: break
ProcesarLinea(linea)
print linea[:-1]

24
Apuntes del curso Fundamentos de programación – Nestor Palominos

f.close()

def ProcesarLinea(linea):
for i in range(len(d1)):
linea=linea.replace(d1[i],d2[i])

f = open ('out.txt','a') #append


f.write(linea)
f.close()

def Cargardiccionario(dicc):
print "###CARGANDO DICCIONARIO"
f = open(dicc,'r')
while True:
linea = f.readline()
if not linea: break
linea=linea[:-1]
y=linea.split(';')
d1.append(y[0])
d2.append(y[1])
print linea
f.close()

#####################################[MAIN

Cargardiccionario('diccionario.txt')
print "###ARCHIVO ORIGINAL:"
LeerArchivo('texto.txt')

25
Apuntes del curso Fundamentos de programación – Nestor Palominos

SOLEMNE 1 2019 VERSION 2

A partir de un archivo de texto con la siguiente estructura:

01/01/2019 10:00:00
01/01/2019 11:00:00
01/01/2019 12:00:00
01/02/2019 13:00:00
01/02/2019 14:00:00
01/02/2019 15:00:00
01/02/2019 16:00:00
01/03/2019 17:00:00
01/03/2019 10:00:00
01/04/2019 10:00:00
01/04/2019 11:00:00
01/04/2019 12:00:00
01/04/2019 13:00:00
01/04/2019 14:00:00
01/05/2019 15:00:00
01/05/2019 16:00:00
01/05/2019 17:00:00
01/05/2019 10:00:00

Que representa la activación de un determinado torniquete del metro según día y hora, se necesita que diseñe un
programa que pida una fecha y que muestre la cantidad de veces que se activó el torniquete, tanto como un
numero como en asteriscos

Solución:

def LeerArchivo(archivo):
f=open(archivo,'r')
mensaje=f.read()
mensaje=mensaje.replace('\n',' ')
y=mensaje.split(' ')
o=raw_input('ingrese la fecha que quiere analizar: ')
z=mensaje.count(o)
print 'El torniquete se activo en la fecha '+o+' un total de '+str(z)+" veces."

if k==z:
k='*'* int(z)
print k
f.close()

###############################################[MAIN
LeerArchivo('solemne1.txt')

26
Apuntes del curso Fundamentos de programación – Nestor Palominos

EXAMEN 1 2019 VERSION 1

Se requiere crear el software que calcule las votaciones de un plebiscito automáticamente. Suponga
que se ha diseñado una máquina, la cual toma los votos en papel, los escanea y vuelca los resultados
en un archivo de texto.

Suponga la siguiente estructura dentro del archivo votaciones.txt:

10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001012101010100010102010
10001010101010001010101000101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100210
10001010101010001010101000101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100010
10001010101010001010101000101010101010001010021010001010101010001010101000101010
10101000101200101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100010
10001010101010001010101002101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
101010

Donde un 0 representa un no, un 1 representa un sí y un 2 vota nulo

A partir del siguiente menú de selección múltiple:

1. Realizar el conteo de votos


2. Obtener el valor porcentual de votaciones
3. Exportar resultados a un archivo
4. Mostrar resultados con asteriscos
5. Salir

La opción 1, entrega en pantalla cuantos votos se obtuvieron para cada alternativa

La opción 2, entrega los resultados de forma porcentual (puede usar una regla de tres)

La opción 3, entrega los resultados a un archivo de texto

La opción 4, debe mostrar los resultados gráficamente de acuerdo al siguiente ejemplo:

Suponga que no=3 votos, si=5 votos y nulos=2 votos. La salida seria la siguiente:

27
Apuntes del curso Fundamentos de programación – Nestor Palominos

Si: *****
No: ***
NV: **

La opción 5 sale del programa

Al terminar, subir el código en unabvirtual.

Recuerde comentar todo lo que estime necesario

Éxito

##PAUTA EXAMEN FTO DE PROGRAMACION 24.06.19


##NESTOR PALOMINOS 2019

def GrabarArchivo(archivo,texto):
f= open (archivo,'w')
f.write(texto)
f.close()

def LeerArchivo(archivo):
f = open(archivo,'r')
votos = f.read()
f.close ()
return votos

def Menu():
print "1. Realizar el conteo de votos"
print "2. Obtener el valor porcentual de votaciones"
print "3. Exportar resultados a un archivo"
print "4. Mostrar resultados con asteriscos"
print "5. Salir"

def Asteriscos(numero):
for i in range(numero):
print "*",
print " "

##########################[MAIN

votos=LeerArchivo("examen.txt")

while(1):

Menu()
opcion=raw_input("opcion?")

nulos=0
si=0
no=0

##CUENTO PRIMERO LOS VOTOS


for i in range(len(votos)):

if votos[i:i+1]=="2":
nulos+=1
if votos[i:i+1]=="1":
si+=1

28
Apuntes del curso Fundamentos de programación – Nestor Palominos

if votos[i:i+1]=="0":
no+=1

if opcion=='1':
print "CONTEO DE VOTOS\n"
print " si:"+str(si)
print " no:"+str(no)
print " nulos:"+str(nulos)

if opcion=='2':
print "CONTEO PORCENTUAL DE VOTOS\n"
total=float(len(votos))
si=(si*100)/total
no=(no*100)/total
nulos=(nulos*100)/total

print " si:"+str(si)+"%"


print " no:"+str(no)+"%"
print " nulos:"+str(nulos)+"%"

if opcion=='3':
print "GRABANDO RESULTADOS\n"
texto=" si:"+str(si)+"\n no:"+str(no)+"\n nulos:"+str(nulos)
GrabarArchivo("resultados.txt",texto)

if opcion=='4':
print "ASTERISCOS\n"
print " si:",
print Asteriscos(si)
print " no:",
print Asteriscos(no)
print " nulos:",
print Asteriscos(nulos)

if opcion=='5':
print " programa finalizado"
exit(0)

Algoritmo de ordenamiento (sorting)

Este código, a partir de una lista con números desordenados, los ordena utilizando el algoritmo Bubblesort
(investigar)

x=[5,2,1,4]
print x

for j in range(len(x)):
for i in range(len(x)-1):
#print str(x[i])+","+str(x[i+1])

if(x[i]>x[i+1]):
aux=x[i]
x[i]=x[i+1]
x[i+1]=aux

print x

29
Apuntes del curso Fundamentos de programación – Nestor Palominos

Ordenamiento más aleatorios

Este código, pregunta al usuario por un tamaño de arreglo a rellenar con aleatorios y posteriormente los ordena.
Observar que se utilizan funciones para el ordenamiento

from random import *

def Ordenar(x):
for j in range(len(x)):
for i in range(len(x)-1):
#print str(x[i])+","+str(x[i+1])

if(x[i]>x[i+1]):
aux=x[i]
x[i]=x[i+1]
x[i+1]=aux
print x

##############################[MAIN
while(1):
x=[]
num=int(raw_input("ingrese largo de la lista:"))

for i in range(num):
x.append(randint(1,100))

print x
Ordenar(x)

Manejo de archivos – continuación

def LeerArchivo():
f= open ('coord.txt','r')
mensaje = f.read()
mensaje=mensaje.split('\n')
print(mensaje)

def GrabarArchivo(file,texto):
f= open (file,'w')
f.write(texto)
f.close

########################[MAIN
#LeerArchivo()
for i in range(10):
GrabarArchivo(str(i)+".txt","owned")

Coordenadas – Combinación de archivos y matrices

30
Apuntes del curso Fundamentos de programación – Nestor Palominos

Suponiendo un archivo de texto plano ‘coordenadas.csv’ creado con bloc de notas conteniendo los
siguientes datos

1;2
3;4
2;1

Se requiere rellenar una matriz de 5x5 con asteriscos en los puntos x,y representados en el archivo csv

M={}
def LeerArchivo(archivo):
abrir = open(archivo,'r')
i=0
while True:
linea = abrir.readline()
if not linea: break
print "linea "+str(i)+": "+linea[:-1]
i+=1
ProcesarLinea(linea)

def ProcesarLinea(x):
#global M
#print "entro a procesar linea"
y=x.split(";")
print "$X:"+y[0]
print "$Y:"+y[1]
M[int(y[0]),int(y[1])]='*'

def CrearMatriz(M):
for i in range(5):
for j in range(5):
M[i,j]='.'

def MostrarMatriz(M):
for i in range(5):
for j in range(5):
print M[i,j],
print ""

################################[MAIN
CrearMatriz(M)
LeerArchivo("coordenadas.csv")
MostrarMatriz(M)

31