apuntes del curso fundamentos de programacion
Post on 06-Nov-2021
13 Views
Preview:
TRANSCRIPT
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
2
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
3
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
4
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
5
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
6
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
7
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
8
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
9
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
10
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)
Apuntes del curso Fundamentos de programación – Nestor Palominos
11
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
12
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"
Apuntes del curso Fundamentos de programación – Nestor Palominos
13
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:
Apuntes del curso Fundamentos de programación – Nestor Palominos
14
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:
Apuntes del curso Fundamentos de programación – Nestor Palominos
15
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
16
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()
Apuntes del curso Fundamentos de programación – Nestor Palominos
17
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.
Apuntes del curso Fundamentos de programación – Nestor Palominos
18
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)
Apuntes del curso Fundamentos de programación – Nestor Palominos
19
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)
Apuntes del curso Fundamentos de programación – Nestor Palominos
20
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
21
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')
Apuntes del curso Fundamentos de programación – Nestor Palominos
22
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
23
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()
Apuntes del curso Fundamentos de programación – Nestor Palominos
24
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: A B C D E A B C A Y el diccionario: (guardado en archivo) A;X B;Y C;Z Debe transformar el archivo original a: X Y Z D E X Y Z X
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]
Apuntes del curso Fundamentos de programación – Nestor Palominos
25
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')
Apuntes del curso Fundamentos de programación – Nestor Palominos
26
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')
Apuntes del curso Fundamentos de programación – Nestor Palominos
27
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:
Apuntes del curso Fundamentos de programación – Nestor Palominos
28
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
29
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
30
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
Apuntes del curso Fundamentos de programación – Nestor Palominos
31
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)
top related