Python Introducción
Python Introducción
FACULTAD DE INGENIERÍA
(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
CONSULTAS: [email protected]
CONTENIDOS
Unidad 1: Introducción
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
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
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.
-Protoboard
-Multimetro
-Transformador 3 a 12 VDC multiuso
-Arduino (Nano o UNO)
-Leds
-Servomotor
-Puente H
-Cautin y soldadura
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.
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
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”
Ahora, si queremos concatenar (unir) texto, se puede usar el operador ‘+’, el cual con numeros suma y con texto
concatena
Por ejemplo:
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.
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)
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
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:
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";
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
Al menos una condición debe ser verdadera para que la expresión sea verdadera
si la edad de una persona está entre 18 y 65, que muestre “A”, en caso contrario, “B”
edad=25;
else:
print "B"
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).
Solucion:
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
while(1):
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"
if humano==0:
print "chao"
exit(0)
if(humano==maquina):
print "empate"
12
Apuntes del curso Fundamentos de programación – Nestor Palominos
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”
13
Apuntes del curso Fundamentos de programación – Nestor Palominos
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
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
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.
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”)
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 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
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)
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)
#########################################################################
host = "0.0.0.0"
port = 4444
hola()
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
while 1:
var = raw_input()
if (var == '1'):
ser.write('1')
print ("ON")
if (var == '0'):
ser.write('0')
print ("OFF")
Código Arduino:
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);
}
}
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 ()
data = cursor.fetchall ()
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")
Graficos (Matplotlib)
import pandas as pd
from matplotlib import pyplot
import matplotlib.dates as md
from datetime import datetime
print df[1:10]
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()
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
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
one_day = dt.timedelta(days=1)
print 'One day :', one_day
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
import os
import pyttsx
import unicodedata
import serial
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
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
ABC
DEA
BCA
A;X
B;Y
C;Z
XYZ
DEX
YZX
Solución:
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:
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])
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
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
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.
10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001012101010100010102010
10001010101010001010101000101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100210
10001010101010001010101000101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100010
10001010101010001010101000101010101010001010021010001010101010001010101000101010
10101000101200101000101010101000101010100010101010101000101000101000101010101000
10101010001010101010100010100010100010101010100010101010001010101010100010100010
10001010101010001010101002101010101010001010001010001010101010001010101000101010
10101000101000101000101010101000101010100010101010101000101000101000101010101000
101010
La opción 2, entrega los resultados de forma porcentual (puede usar una regla de tres)
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: **
Éxito
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
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
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)
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
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
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)
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")
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