mi tesis ii
TRANSCRIPT
UNIVERSIDAD SAN PEDRO
FACULTAD DE INGENIERIA
ESCUELA DE INGENIERÍA CIVIL
TESIS II
PROYECTO DE INVESTIGACIÓN
SISTEMATIZACIÓN DE LOS PROCESOS DE CÁLCULO PARA EL DISEÑO DE ZAPATAS AISLADAS
DOCENTE : Ing. WALTER MAGUIÑA
ALUMNO : DEPAZ BAILON LUCIO YONEL
ASESOR : ING. EMILIO PEREZ ARROYO
Huaraz, 17 de abril de 2023
DEDICATORIA
A Dios Gestor del Conocimiento y Sabiduría,
A mi madre, por el amor y apoyo que me
brinda en la educación.
A mis hermanas por su apoyo y comprensión
que me demuestran constantemente.
AGRADECIMIENTO
Al Ing. Emilio Pérez Arroyo, por su apoyo y asesoramiento en la
culminación del presente estudio.
Al ing. Clemente Osorio, por su apoyo incondicional.
A los docentes de la facultad, que me brindaron conocimiento para la vida
profesional y Diaria.
I. PLANTEAMIENTO DE LA INVESTIGACIÓN.....................................................1
1.1. PLANTEAMIENTO DEL PROBLEMA.........................................................................11.1.1. CARACTERIZACIÓN DEL PROBLEMA............................................................11.1.2. ENUNCIADO DEL PROBLEMA..........................................................................21.1.3. JUSTIFICACIÓN Y VIABILIDAD.........................................................................2
1.2. OBJETIVOS.....................................................................................................................21.2.1. OBJETIVO GENERAL..........................................................................................21.2.2. OBJETIVOS ESPECÍFICOS................................................................................2
II. MARCO TEÓRICO................................................................................................3
2.1. ANTECEDENTES............................................................................................................3
2.1.1. SOFTWARE SAP2000...............................................................................................3
2.1.2. SOFTWARE ETABS..................................................................................................5
2.1.3. Tesis “Diseño de un edificio de concreto armado de cinco niveles”...........6
2.1.4. Archivos Excel conteniendo el formato de diseño de zapatas aisladas....7
2.2. BASES TEÓRICAS DE LA INVESTIGACIÓN............................................................7
2.2.1. Cimentación:..............................................................................................................7
2.2.2. Capacidad portante:.................................................................................................7
2.2.3. Tipos principales de suelos...................................................................................8
2.2.4. Tipos de cimentación:..............................................................................................8
2.2.5. Cimentaciones intermedias..................................................................................10
2.2.6. Las cimentaciones profundas son las siguientes:.........................................11
III. HIPÓTESIS.......................................................................................................... 12
3.1. HIPÓTESIS GENERAL:...............................................................................................12
3.2. HIPÓTESIS ESPECÍFICA:...........................................................................................12
IV. METODOLOGÍA..................................................................................................13
4.8. FUNDAMENTOS DE PROGRAMACIÓN..................................................................23
4.8.1. Lenguajes de programación.................................................................................23
4.8.2. Tipos de programación..........................................................................................27
4.8.3. Programación en PYTHON....................................................................................29
V. REFERENCIAS BIBLIOGRÁFICAS..................................................................54
ANEXO 1
- 1 -
PROYECTO DE INVESTIGACIÓN
SISTEMATIZACIÓN DE LOS PROCESOS DE CÁLCULO PARA EL
DISEÑO DE ZAPATAS AISLADAS
I. PLANTEAMIENTO DE LA INVESTIGACIÓN
I.1. PLANTEAMIENTO DEL PROBLEMA
I.1.1. CARACTERIZACIÓN DEL PROBLEMA
El requerimiento de la optimización del tiempo para la ejecución
de una determinada tarea es una ventaja que debería de
aprovecharse.
Las rutinas desarrolladas para el diseño de una zapata es
susceptible a cometer errores de cálculo, y que además requieren
de tiempo para llevarlos a cabo.
Considerando los dos puntos anteriores, nos vemos en la
necesidad de aplicar los conocimientos informáticos para el
desarrollo de un aplicativo informático que nos ayude realizar
óptimamente el correcto diseño de las zapatas combinadas de
concreto armado.
Debemos considerar que para el diseño de zapatas y en general
las cimentaciones son elementos estructurales que sirven para
equilibrar las cargas producidas por la construcción con la
reacción del terreno, por lo cual es indispensable, antes de
efectuar el cálculo de cualquier cimentación, conocer
perfectamente el tipo de terreno sobre el que se va a trabajar, cuál
es la capacidad de carga del mismo, así como su humedad,
densidad, etcétera, llegando en algunos casos a tener la
necesidad de requerir de estudios especializados sobre mecánica
de suelos para determinar el tipo de cimentación más conveniente
para cada caso.
- 1 -
Es importante saber que este tipo de zapatas son utilizadas en
terrenos de mediana a alta resistencia, así como tener en cuenta
que son poco recomendables para ser aplicadas en terrenos
compresibles cuando se deben transmitir cargas considerables,
ya que pueden tener problemas de asentamientos diferenciales
del terreno.
I.1.2. ENUNCIADO DEL PROBLEMA
¿El proceso de calculo para el diseño de zapatas aisladas son
procesos repetitivos que conllevan generalmente a invertir mucho
tiempo y cometer errores?
I.1.3. JUSTIFICACIÓN Y VIABILIDAD
El presente proyecto de investigación cobra importancia porque
contribuirá a mejorar y optimizar el proceso de cálculo empleado
en el diseño de zapatas aisladas.
La presente investigación es viable, por cuanto los procesos de
cálculo son repetitivos y los cuales deberían programarse en
algún lenguaje de programación.
I.2. OBJETIVOS
I.2.1. OBJETIVO GENERAL
Facilitar el cálculo y diseño de zapatas aisladas de concreto
reforzados usando un aplicativo informático desarrollado en el
lenguaje de programación PYTHON.
I.2.2. OBJETIVOS ESPECÍFICOS
Desarrollar un aplicativo informático para efectuar el diseño
óptimo y eficiente de zapatas.
Mostrar una alternativa de proceso de diseño de zapatas aisladas
de concreto.
- 2 -
II. MARCO TEÓRICO
2.1. ANTECEDENTES
2.1.1. SOFTWARE SAP20001
La mayoría de los ingenieros conocen o han oído sobre SAP2000,
el software líder en ingeniería estructural. Se pueden analizar
cualquier tipo de estructuras con este programa, e incluso diseñar
elemento por elemento de manera precisa con los reglamentos
más conocidos (ACI En EU, RCDF en México, EUROCODIGO en
Europa)
El nombre SAP ha sido sinónimo de métodos analíticos-de-punta
desde su introducción hace más de 30 años. SAP2000 sigue en la
misma tradición con una interfaz de usuario muy sofisticadas,
intuitiva y versátil impulsada por las herramientas de motor y
diseño un análisis sin precedentes para ingenieros de trabajo
sobre transporte, industrial, obras públicas, deportes y otras
instalaciones.
De su objeto 3D basado gráfica de entorno a la amplia variedad
de análisis y diseño opciones completamente integrada a través
de una interfaz de usuario potente, de modelado SAP2000 ha
demostrado para ser el propósito general más integrado,
productivo y práctico programa estructural en el mercado de hoy.
Esta interfaz intuitiva permite crear modelos estructurales
intuitivamente y rápidamente sin demoras larga curva de
aprendizaje. Ahora usted puede aprovechar el poder de SAP2000
para todas las tareas de análisis y diseño, incluyendo pequeños
problemas cotidianos. Modelos complejos pueden ser generados
y entrelazados con poderosas plantillas integradas en la interfaz.
1 www.sap2000.com
- 3 -
Las técnicas de analítica avanzada permiten paso a paso grande
deformaciones Analysis, múltiples P-Delta, Eigen y Ritz analisis,
análisis de cable, tensión o compresión sólo análisis, análisis
pandeo, Blast Analysis, Fast Nonlinear análisis para
amortiguadores, Isolators de base y plasticidad de soporte,
métodos de energía para el Control Drift y Glomeruloesclerosis de
construcción de análisis.
Diseñadores de puente pueden utilizar plantillas de puente de
SAP2000 de generar modelos de puente, automatizada puente
Live carga análisis y diseño, aislamiento de base de puente,
análisis de secuencias de construcción de puente, grandes
deformaciones Cable Supported puente análisis y análisis de
Pushover.
SAP2000 es para todos! SAP2000 es para cada proyecto! De un
análisis simple pequeño marco estáticas 2D a un gran complejo
3D no lineal dinámico análisis, SAP2000 es la respuesta a todas
las necesidades análisis y diseño estructurales.
SAMUEL A. MORA QUIÑONES (2008) El PAVADOQ HEX-
MACH: Experiencias con adoquines en el Perú. Las
experiencias realizadas en zonas de la Costa, Sierra y Selva
peruana, con excelentes resultados, nos permite plantear el
USO del Pavimento Adoquinado Hexagonal Machihembrado
(PAVADOQ HEX MACH) en los Sistemas Viales (Caminos
rurales, urbanos, interurbanos, plataforma de ferrocarriles, puertos
y aeropuertos), por ser una interesante alternativa de solución
Técnica (Estructuralmente resistente), Económica (Menor costo) y
fundamentalmente Social (Generador de empleo masivo).
2.1.2. SOFTWARE ETABS2
2 http://www.morrisoningenieros.com/etabs.htm
- 4 -
En los últimos 30 años, ETABS ha sido reconocido como el
estándar internacional para el Diseño y Análisis de Edificios y
tiene entre sus logros el diseño de la mayoría de estructuras
alrededor del mundo. El software es también internacionalmente
usado como una herramienta educativa y de investigación en
centenares de instituciones.
Actualmente, la nueva versión del ETABS está totalmente
integrada, realiza análisis basado en objetos, diseña, optimiza y
Dibuja. Con este programa se redefinen los estándares de
integración, tecnología numérica y productividad, estableciendo la
línea de desarrollo para los próximos 25 años.
Posee una poderosa interface grafica basada en objetos que la
hace versátil e intuitiva, potenciada por nuevas técnicas
numéricas que permite a los ingenieros crear diseños completos,
elaborando planos y cuantificando materiales para la construcción
con acero en pocas horas, sin estar limitado por el tamaño del
elemento y satisfaciendo los requerimientos de estabilidad, rigidez
y deformación.
Los nuevos y sofisticados métodos de análisis del ETABS
resuelven muchos aspectos del diseño de edificios en los cuales
los Ingenieros Estructurales se han esforzado por décadas, tales
como: Cálculo del Diagrama de Esfuerzo Cortante en Losas y
envolvente de fuerzas, Modelación de Estructuras de
Estacionamiento, Rampas rectas y curvas, Modelación de
deformación en zonas de juntas, Efectos de secuencia de carga
durante el proceso constructivo. El modelo integrado puede incluir
Pórtico resistentes a momentos, brazos rígidos, sistemas
reticulados, pórticos con secciones reducidas de vigas, placas
laterales, losas rígidas y flexibles, Techos inclinados, Rampas y
estructuras de parqueo, mezanines, edificios con torres múltiples
y sistemas de diafragmas conectados con sistemas complejos de
- 5 -
pisos, compuestos o de acero y mucho más, ahora esta al
alcance de sus manos.
ETABS es la solución, si usted está diseñando un pórtico simple
en 2D o está realizando el análisis dinámico de un complejo
rascacielos que utiliza amortiguadores de naturaleza no lineal
para el control de la deformación de entrepisos.
2.1.3. Tesis “Diseño de un edificio de concreto armado de
cinco niveles”3
En la página 48 de la tesis en mención, el autor realiza un ejemplo
de diseño de zapata aislada, siguiendo los pasos de:
Calculo de las dimensiones de la cimentación (B, L)
Calculo de esfuerzo actuante sobre la cimentación (σ)
Calculo del Esfuerzo actuante máximo amplificado
Verificación de las Dimensiones de Cimentación por Corte
Verificación de las Dimensiones de Cimentación por
Punzonamiento
Calculo del Cortante Resistente (Punzonamiento)
Calculo del Cortante ultimo actuante (Punzonamiento)
Calculo del Momento último actuante
3 NANCY SUSANA TAN NOZAWA, de la facultad de ciencias e ingeniería de la universidad Católica del Perú.
- 6 -
2.1.4. Archivos Excel4 conteniendo el formato de diseño
de zapatas aisladas
Finalmente en el internet podemos encontrar páginas en las
cuales profesionales tuvieron a bien colgar los archivos en Excel
que calcula justamente las zapatas aisladas, entre las que se
muestran son HC_rev_0.xls,
MEMORIA_CALCULO_ESTACION_DE_TRANSFERENCIA_Revi
sor_Estructural.xls
2.2. BASES TEÓRICAS DE LA INVESTIGACIÓN
2.2.1. Cimentación:
Se denomina cimentación al conjunto de elementos estructurales
cuya misión es transmitir las cargas de la edificación o elementos
apoyados a este al suelo distribuyéndolas de forma que no
superen su presión admisible ni produzcan cargas zonales.
Debido a que la resistencia del suelo es, generalmente, menor
que la de los pilares o muros que soportará, el área de contacto
entre el suelo y la cimentación será proporcionalmente más
grande que los elementos soportados
2.2.2. Capacidad portante:
En cimentaciones se denomina capacidad portante a la capacidad
del terreno para soportar las cargas aplicadas sobre él.
Técnicamente la capacidad portante es la máxima presión media
4 https://www.google.com.pe/url?sa=t&rct=j&q=&esrc=s&source=web&cd=5&cad=rja&ved=0CEIQFjAE&url=http%3A%2F%2Fwww.ingenieriamecanicayformacion.net%2Fformacion%2Ffo-11071%2Fdocumentacion%2FHC_rev_0.xls&ei=1PabUZ3ZLZLF4AOYk4GYCw&usg=AFQjCNEiU3oIYbvScU8t1mlH5tlJn7M3FA&bvm=bv.46751780,d.dmg
https://www.google.com.pe/url? sa=t&rct=j&q=&esrc=s&source=web&cd=9&cad=rja&ved=0CFkQFjAI&url=http%3A%2F%2Fwww.e-seia.cl%2Farchivos%2FMEMORIA_CALCULO_ESTACION_DE_TRANSFERENCIA_Revisor_Estructural.xls&ei=1PabUZ3ZLZLF4AOYk4GYCw&usg=AFQjCNFi9GcT3rBGg74_Dd4qTlOMl1ivrA&bvm=bv.46751780,d.dmg
- 7 -
de contacto entre la cimentación y el terreno tal que no se
produzcan un fallo por cortante del suelo o un asentamiento
diferencial excesivo. Por tanto la capacidad portante admisible
debe estar basada en uno de los siguientes criterios funcionales:
Si la función del terreno de cimentación es soportar una
determinada tensión independientemente de la deformación, la
capacidad portante se denominará carga de hundimiento.
Si lo que se busca es un equilibrio entre la tensión aplicada al
terreno y la deformación sufrida por éste, deberá calcularse la
capacidad portante a partir de criterios de asiento admisible.
De manera análoga, la expresión capacidad portante se utiliza en
las demás ramas de la ingeniería para referir a la capacidad de
una estructura para soportar las cargas aplicadas sobre la misma.
2.2.3. Tipos principales de suelos.
Los términos principales que usan los ingenieros civiles para
describir suelos son: grava, arena, limo y arcilla. La mayor parte
de los suelos naturales se componen por la mezcla de dos o más
de estos elementos, y pueden contener por añadidura material
orgánico parcial o completamente descompuesto.
2.2.4. Tipos de cimentación:
Cimientos de piedra: Los cimientos de piedra son los apoyos de
una construcción. Sirven para cargar el peso de toda una
vivienda, repartiéndolo uniformemente en el terreno sobre el que
se encuentra construido. La cimentación es necesaria en
cualquier construcción aunque en el caso de que esta se haga por
partes.
Cimientos de mampostería: En zonas donde la piedra es
abundante suele aprovecharse esta como material de
- 8 -
cimentación. Para grandes construcciones es necesario efectuar
en un laboratorio de ensayo pruebas sobre la resistencia de la
piedra de que se dispone. Tratándose de construcciones
sencillas, en la mayoría de casos resulta suficiente efectuar la
prueba golpeando simplemente la piedra con una maceta y
observando el ruido que se produce. Si este es hueco y sordo, la
piedra es blanda, mientras que si es aguda y metálico, la piedra
es dura.
Cimentaciones profundas: este tipo de cimentación se utiliza
cuando se tienen circunstancias especiales: -Una construcción
determinada extensa en el área de austentar. -Una obra con una
carga demasiada grande no pudiendo utilizar ningún sistema de
cimentación especial. -Que terreno al ocupar no tenga resistencia
o características necesarias para soportar construcciones muy
extensas o pesadas.
Cimentaciones superficiales: Son las ya antes mencionadas
como la mampostería la de zapatas aisladas también la zapata
corrida la de concreto ciclopeo y la losa de cimentación.
Son aquellas que se apoyan en las capas superficiales o poco
profundas del suelo, por tener éste suficiente capacidad de carga
o por tratarse de construcciones de importancia secundaria y
relativamente livianas.
Las cimentaciones superficiales reparten la fuerza que transmite
la estructura a través de sus elementos de apoyo sobre una
superficie de terreno suficientemente grande para admitir esas
cargas. Se consideran cimentaciones superficiales cuando tienen
entre 0.50 m y 3 m de profundidad, y cuando la capacidad de
carga del suelo permite apoyar el edificio en forma directa sin
provocar asentamientos excesivos que puedan afectar la
funcionalidad de la estructura.
- 9 -
Clasificación de cimentaciones superficiales:
Zapatas aisladas
Zapatas corridas
Losas de cimentación
Zapatas aisladas.- Las zapatas aisladas son elementos
estructurales, generalmente cuadrados o rectangulares y más
raramente circulares, que se construyen bajo las columnas con el
objeto de transmitir la carga de éstas al terreno en una mayor
área, para lograr una presión adecuada. Generalmente son
construidas de concreto reforzado. En ocasiones las zapatas
aisladas soportan más de una columna, en este caso se dice que
son zapatas combinadas.
Zapatas corridas.- las zapatas corridas son elementos análogos
a las zapatas aisladas, en las cuales la longitud supera por mucho
a su ancho. Se utilizan para soportar varias columnas o un muro y
pueden ser de concreto reforzados o de mampostería, en el caso
de cimentos que transmiten cargas no muy grandes. La zapata
corrida se usa, en el caso en que el suelo ofrezca una resistencia
baja, que obligue al empleo de mayores áreas de repartición o en
el caso en que deban transmitirse al suelo grandes cargas.
Losas de cimentación.- Cuando la resistencia del terreno sea
muy baja o las cargas muy altas, las dimensiones de zapatas
serian demasiado grandes. En este caso es necesario colocar una
losa de cimentación de concreto reforzado que puede llegar a
ocupar toda la superficie construida.
2.2.5. Cimentaciones intermedias
Son aquéllas cimentaciones en las que se busca reducir el
incremento total de carga que se aplica al subsuelo, realizando
- 10 -
excavaciones en el terreno y haciendo uso de un cajón de
cimentación que se desplanta a cierta profundidad. Este tipo de
cimentación es adecuada en suelos de mediana y alta
compresibilidad, y baja capacidad de carga.
Este tipo de cimentaciones se clasifican en:
Parcialmente compensadas
Sobre – compensadas
2.2.6. Las cimentaciones profundas son las siguientes:
Por sustitución: básicamente esta cimentación es material extra
excavación en el terreno y en el proporcional de la construcción
se debe conocer el tipo de estado coincidencial el peso
volumétrico de cada una de las capas que se construyen en el
terreno a excavar, para que el peso sea perfecto, se deben nivelar
con el de la construcción perfectamente conocida.
Por flotación: esta clase de cimentación se basa con el principio
de Arquímedes que dice que todo cuerpo sumergido en el liquido
experimenta un empuje vertical ascendente igual al peso del
volumen del liquido desalojado.
Por pilotación: se tienen tres formas de pilotes: -Pilotes
trabajando con apoyos directos. -Pilotes que trabajas mediante
fricción
- 11 -
III. HIPÓTESIS
III.1. HIPÓTESIS GENERAL:
El uso de programas mejora el análisis y diseño de las zapatas
aisladas
III.2. HIPÓTESIS ESPECÍFICA:
El uso de aplicativos informáticos mejora y optimiza el tiempo
de cálculo de las dimensiones de las zapatas aisladas
- 12 -
IV. METODOLOGÍA
IV.1. TIPO Y NIVEL DE LA INVESTIGACIÓN
El presente estudio se enmarcó dentro de los siguientes tipos de
investigación: Descriptiva, De Campo y Bibliográfica de nivel
explicativo
IV.2. DISEÑO DE LA INVESTIGACIÓN
Diseño de investigación: El diseño de la investigación es
experimental o de laboratorio.
IV.3. POBLACIÓN Y MUESTRA
IV.3.1. POBLACIÓN
Expedientes y estudios en la cual incluya un análisis de
zapatas aisladas.
IV.3.2. MUESTRA
Estudios y expedientes elaborados por algunos de los
ingenieros que dictan en la universidad San Pedro con
sede en Huaraz
IV.4. DEFINICIÓN Y OPERACIONALIZACIÓN DE LAS VARIABLES
IV.4.1.VARIABLES:
Variable Independiente
Esfuerzo del suelo
Solicitaciones de cargas de viento, sismo
Variable Dependiente
- 13 -
Recubrimiento mínimo
Fuerzas cortantes por punzonamiento
Cargas axiales
IV.5. PROCEDIMIENTOS
Se emplearán los diferentes procedimientos, técnicas en el
análisis y diseño de zapata. Las cuáles serán plasmadas en un
lenguaje de programación, a partir desde la creación del algoritmo
que permitirá tener éxito para la creación del programa el cual nos
permita calcular y dimensionar cualquier tipo de zapata.
IV.6. TÉCNICAS E INSTRUMENTOS
Determinación del esfuerzo del suelo. Se realizara un estudio
de mecánica de suelo.
Análisis Documental. Se comparara los resultados iniciales con
los ejercicios tipo de libros, para comprobar y determinar la
efectividad del programa elaborado.
Entrevistas. Se realizaran entrevistas especializadas a los
ingenieros más renombrados de la universidad San Pedro –
Huaraz de la carrera profesional de ingeniería civil. Con el cual se
determinara el tiempo que se demora un profesional para realizar
un dimensionamiento de la zapara.
Observaciones . Se empleará la observación participante directa,
con la finalidad de comprobar las hipótesis planteadas en el
desarrollo de las ciencias experimentales.
- 14 -
IV.7. PLAN DE ANÁLISIS
Para el diseño de zapatas aisladas se deben tomar en cuenta los
siguientes puntos:
a) Los esfuerzos en el suelo no deben sobrepasar los esfuerzos
admisibles
𝑞 ≤𝑞𝑟b) Cuando las combinaciones de carga incluyan el efecto de
solicitaciones accidentales como sismos o vientos, los esfuerzos
admisibles pueden incrementarse en un 33.3 %
𝑞𝑟𝑠≈1.33 𝑞𝑟c) El recubrimiento mínimo para el acero cuando la zapata este en
contacto directo con el terreno es de 7.5 cm, y 5.0 cm cuando se
tenga una plantilla de cimentación.
𝐻=𝑑+7.5 𝑐𝑚 ó 𝐻=𝑑+5 𝑐𝑚d) Las zapatas deberán diseñarse para resistir fuerzas cortantes
en cada dirección independientemente, tomando las secciones
críticas a una distancia 𝑑 (peralte efectivo) desde la cara de la
columna, el dado o el elemento vertical que transmite la carga
e) Las zapatas deberán diseñarse para resistir fuerzas cortantes
de punzonamiento o penetración, tomando como sección critica
aquella que se ubica a una distancia 𝑑/2 (medio peralte efectivo)
alrededor del elemento vertical de carga (columna, dado, muro,
etc.).
f) La sección crítica de flexión en una dirección se ubicará en las
caras de los elementos verticales de carga.
- 15 -
g) En cimentaciones de muros de mampostería, la sección crítica
a la flexión se considera ubicada a la mitad, entre el eje medio y el
paño del muro.
En zapatas reforzadas en una dirección y en zapatas
rectangulares reforzadas en dos direcciones, el refuerzo debe
distribuirse uniformemente a través del ancho total de la zapata.
Zapatas aisladas sujetas a carga axial
Pera el diseño de zapatas aisladas sujetas a carga axial se
recomienda aplicar el siguiente procedimiento:
1.- Cálculo de la descarga total de la cimentación
𝑃𝑇= 𝑃 + 𝑊𝑠W s={0.2P→df ≤1.5m
0.3 p→df >1.5m }2.- Dimensionamiento de la zapata
𝐴𝑧 = 𝑃𝑇/𝑞𝑟3.- Cálculo de la presión de contacto 𝑞= 𝑃𝑇/𝐴𝑍 ≤ 𝑞𝑟4.- Cálculo de la presión neta última
𝑞𝑛 = 𝑃/𝐴𝑧 ; 𝑞𝑛𝑢 = 𝐹𝐶(𝑞𝑛)5.- Cálculo del peralte necesario para resistir el cortante como viga ancha d= qnu∗l
vcr+qnu
𝑙= (𝐿−𝐶1)/2vCR=0.5FR∗√ f ' c
donde: 𝐹𝑅 = Factor de resistencia = 0.8- 16 -
6.- Cálculo del peralte necesario para resistir el cortante por penetraciónSe obtiene resolviendo la siguiente ecuación cuadrática:𝑞𝑛𝑢+4𝑣𝐶𝑅 𝑑2+ [( +2𝑣𝐶𝑅)(𝐶1+𝐶2) ]𝑑+ 𝑞𝑛𝑢𝐶1𝐶2−𝑃𝑢=0
vCR≤{ FR√ f 'cFR(0.5+γ )√ f ' c }
De los peraltes obtenidos en los pasos 5 y 6 se toma el mayor, y se calcula el espesor total como:𝐻= 𝑑 + 𝑟𝑒𝑐𝑢𝑏𝑟𝑖𝑚𝑖𝑒𝑛𝑡𝑜
Comprobación de que el peso real no exceda al peso propio
supuesto
𝑤𝑟𝑒𝑎𝑙 ≤ 𝑤𝑠𝑊𝑝𝑙𝑎𝑛𝑡𝑖𝑙𝑙𝑎 = 𝐵 ∗ 𝐿 ∗ 𝑒𝑠𝑝𝑒𝑠𝑜𝑟 ∗ 𝑃𝑒𝑠𝑜 𝑣𝑜𝑙𝑢𝑚é𝑡𝑟𝑖𝑐𝑜 𝑑𝑒𝑙 𝑚𝑎𝑡𝑒𝑟𝑖𝑎𝑙𝑊𝑙𝑜𝑠𝑎 = 𝐵 ∗ 𝐿 ∗ 𝐸𝑠𝑝𝑒𝑠𝑜𝑟 ∗ 𝑃𝑒𝑠𝑜 𝑣𝑜𝑙𝑢𝑚é𝑡𝑟𝑖𝑐𝑜 𝑑𝑒𝑙 𝑚𝑎𝑡𝑒𝑟𝑖𝑎𝑙𝑊𝑑𝑎𝑑𝑜 = 𝐶1 ∗ 𝐶2 ∗ 𝐴𝑙𝑡𝑢𝑟𝑎 ∗ 𝑃𝑒𝑠𝑜 𝑣𝑜𝑙𝑢𝑚é𝑡𝑟𝑖𝑐𝑜 𝑑𝑒𝑙 𝑚𝑎𝑡𝑒𝑟𝑖𝑎𝑙𝑊𝑟𝑒𝑙𝑙𝑒𝑛𝑜=[(𝐵∗𝐿)–(𝐶1∗𝐶2)]∗𝐴𝑙𝑡𝑢𝑟𝑎∗ 𝑃𝑒𝑠𝑜 𝑣𝑜𝑙𝑢𝑚é𝑡𝑟𝑖𝑐𝑜 𝑑𝑒𝑙 𝑚𝑎𝑡𝑒𝑟𝑖𝑎𝑙donde:
𝑊𝑟𝑒𝑎𝑙=𝑊𝑝𝑙𝑎𝑛𝑡𝑖𝑙𝑙𝑎+𝑊𝑙𝑜𝑠𝑎+𝑊𝑑𝑎𝑑𝑜+𝑊𝑟𝑒𝑙𝑙𝑒𝑛𝑜El peso real no debe exceder al peso supuesto en un 10%
- 17 -
7.- Diseño por flexión
ρ= f ' cf ' y [1−√1−
2M u
FRb d2 f ' c ]𝐴𝑠 = 𝜌 𝑏𝑑
Una vez obtenida el área de acero necesario se elige el diámetro
de varillas que se van a utilizar y se calcula la separación a la que
se van a colocar:
𝑆=(100 𝑎o)/𝐴𝑠Acero por temperatura
Cuando el espesor (𝐻) de la zapata sea mayor que 30 cm se
recomienda colocar acero por temperatura en el lecho superior.
La cantidad de acero por temperatura se calcula con la siguiente
expresión:
A st=660 Xify ¿¿
Si Xi no excede de 15 cm, el refuerzo puede colocarse en una
sola capa. Si 𝑋𝑖 es mayor de 15 cm, el refuerzo se colocará en
dos capas próximas a las caras del elemento.
Zapatas aisladas sujetas a carga axial y momento
En zapatas en las que además de carga axial existen momentos
en una o dos direcciones la distribución de presiones no es
uniforme, lo que hace complicado obtener una presión neta última
con la cual podamos diseñar la zapata. Sin embargo, empleando
la teoría de Meyerhof y haciendo algunas consideraciones se ha
desarrollado un método simplificado que resulta sencillo y muy
práctico.
El método consta de los siguientes pasos:
- 18 -
1.- Cálculo de la descarga total de la cimentación
En este caso además de la descarga de la superestructura y el
peso propio de la zapata se tiene un momento, el cual hay que
transformar en una carga equivalente.
En condiciones de la descarga de la superestructura
𝜎= 𝑃/𝐴En condiciones de la carga que transmite el momento
𝜎= (∅ 𝑀)/𝑆Igualando los esfuerzos:
𝑃/𝐴= ∅𝑀/ ; 𝑃=∅𝐴𝑀/SEs decir 𝑃= (𝐹𝑎𝑐𝑡𝑜𝑟) 𝑀Por lo tanto el momento (M) se transforma en carga equivalente
Pequiv.
𝑃equiv = 1.5 𝑀Para determinar la descarga total se toman en cuenta tres
condiciones.
Cargas estáticas o permanentes (CM + CV)
𝑃𝑇= 𝑃E + 𝑊𝑆 + 𝑃equiv
donde:
𝑊S = 0.25 𝑃e ;
𝑃equiv = 1.5 (𝑀EX + 𝑀EY)
- 19 -
Cargas estáticas más cargas por sismo en “ X “
(CM + CV + SISMO X)
𝑃𝑇= 𝑃E + 𝑃SX + 0.3𝑃SY + 𝑊S + 𝑃 EQUIV
𝑊S = 0.2 (𝑃E + 𝑃SX + 0.3 𝑃SY)
Pequiv= 1.5(𝑀EX + 𝑀EY + 𝑀SX + 0.3 𝑀SY)
Cargas estáticas más cargas por sismo en “ Y “
( CM + CV + SISMO Y)
Pt = 𝑃E +0.3 𝑃SX + 𝑃SY + 𝑊S + 𝑃 EQUIV
𝑊S = 0.2 (𝑃E + 0.3𝑃SX + 𝑃SY)
Pequiv= 1.5(𝑀EX + 𝑀EY + 0.3𝑀SX + 𝑀SY)
2.- Dimensionamiento de la zapata 𝐴𝑧 =𝑃𝑇/𝑞𝑟3.- Cálculo de las presiones de contacto
𝐿‘ = 𝐿 – 2𝑒𝑥 ; 𝐵’ = 𝐵 – 2𝑒𝑦𝑒𝑥=𝑀𝑥𝑃+𝑊𝑆 ; 𝑒𝑦=𝑀𝑦𝑃+𝑊𝑆 𝑞= 𝑃+𝑊𝑠𝐵′𝐿′ ≤𝑞𝑟
ex=MxP
+Ws
e y=MyP
+Ws
q= P+WsB ' L'
≤qr
4.- Cálculo de la presión neta última
- 20 -
q= PB ' L '
;qnu=fc(qn)
𝑞= 𝑃𝐵′𝐿′ ; 𝑞𝑛𝑢= 𝐹𝑐(𝑞𝑛)
5.- Cálculo del peralte necesario para resistir el cortante como
viga ancha
𝑑= (𝑞𝑛𝑢∗𝑙)/(𝑣𝐶𝑅+𝑞𝑛𝑢)𝑙=(𝐿−𝐶𝑥)/2; 𝑙=(𝐿−𝐶𝑦)/2
𝑣𝐶𝑅= 0.5 𝐹𝑅∗ (𝑓∗𝑐)1/2
6.- Cálculo del peralte necesario para resistir el cortante por
penetración
Debido a la acción del momento se complica obtener una
expresión general para calcular este peralte, sin embargo existe
una propuesta empírica que ha mostrado muy buenos resultados.
Dicha propuesta consiste en resolver la misma ecuación
cuadrática obtenida para zapatas sujetas a carga axial.
𝑞𝑛𝑢 + 4𝑣𝐶𝑅 𝑑2 + [(𝑞𝑛𝑢 + 2𝑣𝐶𝑅)(𝐶𝑥 + 𝐶𝑦)] 𝑑 + 𝑞𝑛𝑢𝐶𝑥𝐶𝑦 – 𝑃𝑢=0
Y una vez obtenido el peralte modificarlo de la siguiente forma:
Peralte = d + 5 cm Si hay momento en un sentido y CM + CV
Peralte = d + 10 cm Si hay momento en un sentido y CM + CV + CA
Peralte = d + 10 cm Si hay momento en dos sentidos y CM + CV
Peralte = d + 15 cm Si hay momento en dos sentidos y CM + CV + CA
Para verificar que el peralte obtenido es adecuado se revisa la
resistencia al corte según el reglamento, con la siguiente
expresión:
- 21 -
𝑣𝑢 ≤𝑣𝐶𝑅Vcr = 𝐹𝑅∗ 𝑓∗𝑐
𝐹𝑅 = 0.8 para CM + CV y 0.7 para CM + CV + CA
𝑣𝑢= 𝑉𝑢/𝑏𝑜𝑑 Si no hay transmisión de momento
𝑣𝑢= 𝑉𝑢𝑏𝑜𝑑+ 𝑎𝑦 𝑀𝑢𝑦 𝐶𝐵𝐷𝐽𝑐𝑥 Si solo hay transmisión de
momento en X
𝑣𝑢= 𝑉𝑢𝑏𝑜𝑑+ 𝑎𝑦 𝑀𝑢𝑦 𝐶𝐵𝐷𝐽𝑐𝑥 Si solo hay transmisión de
momento en Y
𝑣𝑢= 𝑉𝑢𝑏𝑜𝑑+𝑎𝑦 𝑀𝑢𝑦 𝐶𝐵𝐷𝐽𝑐𝑥+𝑎𝑦 𝑀𝑢𝑦 𝐶𝐵𝐷𝐽𝑐𝑥 Si
hay transmisión de momentos en X y Y
Para revisar si hay transmisión de momentos
Si 𝑀𝑢𝑥 >0.2 𝑉𝑢 𝑑 Hay transmisión de momento en X
𝑀𝑢𝑦 >0.2 𝑉𝑢 𝑑 Hay transmisión de momento en Y
𝑉𝑢=𝑃𝑢−𝑞𝑛𝑢 𝐴𝑓 𝐴𝑓=(𝐶𝑥+𝑑)(𝐶𝑦+𝑑) ; 𝐵𝑜=2[(𝐶𝑥+𝑑)+
(𝐶𝑦+𝑑)]
𝐶ab=(𝐶𝑥+ 𝑑)/2 ; 𝐶cd=(𝐶𝑦 + 𝑑)/2
ax=1− 1
1+0.67 √Cx+dCy+d
a y=1− 1
1+0.67√Cy+dCx+d
j cx=d ¿¿
j cy=d ¿¿
- 22 -
Espesor total
𝐻 = 𝑑 + 𝑟𝑒𝑐𝑢𝑏𝑟𝑖𝑚𝑖𝑒𝑛𝑡𝑜Comprobación de que el peso propio no supere al peso supuesto
7.- Diseño por flexión
ρ= f ' ' cfy [1−√1− 2Mu
FRbd2 f ' ' c ]Mu=
qnu l2
2, 𝐴𝑠= 𝜌𝑏𝑑; s=100a0
As
Acero por temperatura
IV.8. FUNDAMENTOS DE PROGRAMACIÓN
El diseño de aplicaciones ha cambiado drásticamente en los
últimos años y consecuentemente los estilos de programación. De
una programación secuencial se pasa a una programación
modular, para llegar a una programación estructurada con muy
buenos resultados. A partir de la programación estructurada los
esfuerzos se centraron en potenciar la modularidad y la
reutilización del código, lo que condujo a la programación
orientada a objetos que se complementa con una programación
basada en componentes software, pero que los estilos hayan
cambiado, no significa que el último elimine a los anteriores; al
contrario, se apoya en los anteriores.
IV.8.1.Lenguajes de programación
El desarrollo de las capacidades de Hardware ha experimentado
un auge desmesurado en los últimos años, pero el
aprovechamiento de estas posibilidades no es óptimo si no se
dispone del software adecuado. Con este fin se han diseñado
diversos lenguajes de programación, unos de propósito general,
- 23 -
es decir, para todo tipo de aplicaciones, y otros de aplicación
particular en algunos de los campos del ámbito informático.
Un lenguaje de programación es una notación para escribir
programas, a través de los cuales podemos comunicarnos con el
hardware y dar así las órdenes adecuadas para la realización de
un determinado proceso. Un lenguaje está definido por una
gramática o conjunto de reglas que se aplican a un alfabeto
constituido por el conjunto de símbolos utilizados.
Los distintos niveles de programación existentes nos permiten
acceder al hardware, de tal forma que según utilicemos un nivel u
otro, así tendremos que utilizar un determinado lenguaje ligado a
sus correspondientes traductores.
Una primera clasificación, atendiendo a su proximidad al lenguaje
de la máquina o al lenguaje de las personas (lenguaje natural),
establece los tres siguientes grupos:
Lenguajes de bajo nivel
Lenguajes intermedios
Lenguajes de alto nivel
Lenguajes de bajo nivel: Son los lenguajes más básicos. Los
lenguajes de bajo nivel o lenguajes máquina consisten en hileras
de números y son definidos por el diseño del hardware. En otras
palabras, el lenguaje máquina para una computadora Macintosh
no es el mismo que para el de una PC. Una computadora
comprende sólo su lenguaje máquina original, los comandos de
su equipo de instrucción. Estos comandos le dan instrucciones a
la computadora para realizar operaciones elementales: cargar,
almacenar, añadir y sustraer. Esencialmente, el código máquina
consiste por completo de los 0 y 1 del sistema numérico binario.
- 24 -
Lenguajes intermedios: En estos lenguajes los programadores
trabajan en editores de texto, que son simples procesadores de
palabras, para crear archivos fuente. Los archivos fuente
contienen instrucciones para que la computadora las ejecute, pero
tales archivos deben primero traducirse al lenguaje máquina. Los
investigadores crearon programas traductores llamados
ensambladores para realizar la conversión. Los lenguajes y
secretos, pero leer un código ensamblador es mucho más rápido
que trabajar con el lenguaje máquina. Los programadores rara
vez escriben programas de tamaño significativo en un lenguaje
ensamblador. En su lugar, se usan lenguajes ensambladores para
afinar partes importantes de los programas escritos en un
lenguaje de nivel superior.
Lenguajes de alto nivel: fueron desarrollados para hacer más
fácil la programación. Estos lenguajes son llamados de alto nivel
porque su sintaxis es más cercana al lenguaje humano que al
código del lenguaje máquina o ensamblador. Usan palabras
familiares en lugar de comunicar en el detallado embrollo de los
dígitos que comprenden las instrucciones de la máquina. Para
expresar las operaciones de la computadora estos lenguajes usan
operadores, como los símbolos de más o menos, que son los
componentes familiares de las matemáticas. Como resultado,
leer, escribir y comprender programas de cómputo es más fácil
con un programa de alto nivel, a pesar de que las instrucciones
todavía deban ser traducidas al lenguaje máquina antes de que la
computadora pueda comprenderlas y llevarlas a cabo.
Los comandos escritos en cualquier lenguaje ensamblador o de
alto nivel deben ser traducidos de nuevo a código máquina antes
de que la computadora pueda ejecutar los comandos. Estos
programas traductores se denominan compiladores. Los archivos
de programas compilados se vuelven ejecutables.
- 25 -
Los lenguajes de programación son discutidos algunas veces en
términos de generaciones, a pesar de que estas categorías son
arbitrarias de alguna manera. Se considera que cada generación
sucesiva contiene lenguajes que son más fáciles de usar y más
poderosos que la generación previa. Los lenguajes máquina son
considerados de la primera generación, y los ensambladores de la
segunda generación.
Lenguajes de la tercera generación
Los lenguajes de la tercera generación tienen la capacidad de
soportar programación estructurada, lo cual significa que
proporcionan estructuras explícitas para ramas y ciclos. Además,
debido a que son los primeros lenguajes que usan fraseo similar
al inglés, compartir el desarrollo entre los programadores es más
fácil.
Los lenguajes de la tercera generación incluyen:
FORTRANCOBOLBASICPASCALCC++JAVA
Lenguajes de la cuarta generación
Los lenguajes de cuarta generación son principalmente lenguajes
de programación para propósitos especiales, que son más fáciles
de usar que los de la tercera generación. Con los lenguajes de la
cuarta generación los programadores pueden crear aplicaciones
rápidamente. Como parte del proceso de desarrollo, los
programadores pueden utilizar los lenguajes de la cuarta
generación para desarrollar prototipos de una aplicación
rápidamente. Los prototipos dan a los equipos y clientes una idea
de cómo se vería y funcionaría la aplicación antes de que el
- 26 -
código esté terminado. Como resultado, cada uno de los
involucrados en el desarrollo de la aplicación puede proporcionar
retroalimentación sobre aspectos estructurales y de diseño al
principio del proceso.
Con una sola declaración en un lenguaje de la cuarta generación
se logra mucho más de lo que era posible con una declaración
similar en un lenguaje de generación anterior. A cambio de esta
capacidad de trabajar más rápido, los programadores han
demostrado disposición para sacrificar parte de la flexibilidad
disponible con los lenguajes anteriores.
Muchos lenguajes de la cuarta generación tienen capacidad para
bases de datos. Estos programas incluyen formas y cuadros de
dialogo para introducir información en las bases de datos.
Entre los principales lenguajes de la cuarta generación se tienen:
Visual Basic
Lenguajes de macros específicos para una aplicación
Ambientes de auditoria
Lenguajes de la quinta generación
La quinta generación de los lenguajes de cómputo incluye
inteligencia artificial y sistemas expertos. Estos sistemas tienen
por objeto pensar y anticipar las necesidades de los usuarios, en
lugar de sólo ejecutar un conjunto de órdenes. A pesar de que los
sistemas de inteligencia artificial se están volviendo más difíciles
de desarrollar de lo que se esperaba originalmente, los expertos
afirman que los sistemas, al igual que las redes nerviosas pronto
serán capaces de tomar hechos y luego usar el conjunto de datos
para formular una respuesta apropiada, exactamente como
hacemos los humanos.
- 27 -
IV.8.2.Tipos de programación
Existen dos tipos de programación:
Programación modular.- Es uno de los métodos de diseño más
flexible y potente para mejorar la productividad de un programa.
En programación modular el programa se divide en módulos
(partes independientes), cada una de las cuales ejecuta una única
actividad o tarea y se codifican independientemente de otros
módulos.
Programación estructurada.- La programación estructurada
significa escribir un programa de acuerdo a las siguientes reglas:
El programa tiene un diseño modular
Los módulos son diseñados de modo descendente
Cada módulo se codifica utilizando las tres estructuras
de control básicas: secuencia, selección y repetición
Esta técnica aumenta considerablemente la productividad del
programa reduciendo considerablemente el tiempo requerido para
escribir, verificar, depurar y mantener los programas. La
programación estructurada utiliza un número limitado de
estructuras de control que minimizan la complejidad de los
programas y por consiguiente reducen los errores; hace los
programas más fáciles de escribir, verificar, leer y mantener.
La programación estructurada es el conjunto de técnicas que
incorporan:
Recursos abstractos
Diseño descendente (top- down)
Estructuras básicas
- 28 -
IV.8.3.Programación en PYTHON
****ENTRADILLA: En la serie de cuatro artículos que aquí
comenzamos describiremos el lenguaje de programación Python.
Para ilustrar sus virtudes desarrollaremos un juego de tres en
raya, que según transcurra esta serie irá haciéndose cada vez
más sofisticado. Pasará de ser un simple juego con interfaz en
modo texto, a tener una interfaz gráfica, y de éste a ser una
aplicación web que accede a una base de datos.
****LADILLO: Introducción
En este primer artículo nos dedicaremos a introducir la sintaxis de
Python y a iniciarnos en la programación orientada a objetos a
través de Python. En un segundo artículo hablaremos de las
facilidades provistas por Python para la programación de
interfaces gráficas y la serialización de datos a ficheros. En la
tercera entrega explicaremos las bondades de Python para la
programación de aplicaciones web con acceso a bases de datos.
Finalmente, concluiremos la serie en una cuarta entrega hablando
de la programación de XML en Python y describiendo sus primos
hermanos Jython e IronPython.
Python, el otro lenguaje de programación libre que empieza con
‘P’ y que no es ni Perl ni PHP, fue creado por Guido van Rossum
(http://www.python.org/~guido/) en 1991. Dio este nombre al
lenguaje inspirado por el popular grupo cómico británico Monty
Python. Guido creó Python durante unas vacaciones de navidad
en las que (al parecer) se estaba aburriendo.
****SUBLADILLO: Hola Mundo en Python
- 29 -
Como con cualquier otro lenguaje de programación, comencemos
el aprendizaje de Python con el más simple de los ejemplos:
****CÓDIGO: print "Hola Mundo" # "Hola Mundo"
En este primer extracto de código ya podemos observar la
simplicidad de Python. Probablemente este es el ejemplo del
programa “hola mundo” más sencillo que jamás has visto. La
sentencia print imprime una cadena de caracteres a consola. Las
cadenas de caracteres en Python se pueden denotar bien entre
comillas dobles o comillas simples, por ejemplo 'Hola mundo'.
Nótese que los comentarios de línea se indican con el símbolo #,
mientras que los bloques de código pueden comentarse entre """
y """.
****LADILLO: Características de Python
Tras ver el primer extracto de código en Python , enumeremos
sus principales características:
Sintaxis elegante, minimalista y densa: En Python todo aquello
innecesario no hay que escribirlo (;, {, }, \n). Además como
veremos pocas líneas de código revierten en mucha
funcionalidad.
Moderno: Soporta objetos y estructuras de datos de alto nivel
tales como cadenas de caracteres (strings), listas y diccionarios.
Multi-paradigma: En vez de forzar a los programadores a adoptar
un paradigma de programación único, Python permite el uso de
programación orientada a objetos, programación estructurada o
procedural e incluso programación funcional.
Organizado y extendible: Dispone de múltiples formas de
organizar código tales como funciones, clases, módulos, y
paquetes. Si hay áreas que son lentas se pueden reemplazar por
- 30 -
plugins en C o C++, siguiendo la API para extender o empotrar
Python en una aplicación.
Interpretado: No es necesario declarar constantes y variables
antes de utilizarlas y no requiere paso de compilación/linkage. La
primera vez que se ejecuta un script de Python se compila y
genera bytecode que es luego interpretado. Python es dinámico,
encuentra errores de uso de tipos de datos en tiempo de
ejecución y usa un recolector de basura para la gestión de
memoria.
Multiplataforma: Python genera código interoperable, que se
puede ejecutar en múltiples plataformas (más aún que Java).
Además, es posible embeber Python dentro de una JVM, como
veremos en la cuarta entrega de esta serie.
Open source: Razón por la cual la librería de módulos de Python
(http://docs.python.org/lib/lib.html) contiene un sinfín de módulos
de utilidad y sigue creciendo continuamente.
De propósito general: Puedes programar en Python toda
aplicación y de cualquier tipo que puedes hacer con C# o Java.
****SUBLADILLO: Peculiaridades sintácticas
Python presenta unas diferencias sintácticas notables con
respecto a otros lenguajes de programación. Usa tabulación (o
espaciado) para mostrar una estructura de bloques. Se tabula una
vez para indicar el comienzo de bloque y se des-tabula para
indicar el final del bloque. Además, Python no usa el símbolo ‘;’
para indicar el final de una sentencia sino simplemente un retorno
de carro. El cuadro “C/Java vs. Python” compara un extracto de
código en C/Java con otro de código en Python. Obsérvese que
las peculiaridades sintácticas de Python traen consigo una
reducción de los caracteres utilizados y líneas de código. Además,
- 31 -
como efecto lateral, estas peculiaridades sintácticas obligan a
diferentes programadores a escribir el código del mismo modo. No
hace falta definir manuales de referencia de programación, para
asegurarte que todos los programadores que intervienen en un
proyecto utilizan las mismas convenciones. Como nota positiva,
comentar que la mayoría de las palabras claves utilizadas por
Python coinciden con las usadas en C o Java.
****TABLA:C/Java vs Python
Código en C/Java Código en Python
if (x) { if (y) { f1(); } f2();}
if x: if y: f1() f2()
****SUBLADILLO: Dominios de aplicación de Python
Todo ingeniero de software, como buen artesano, debería
dominar varios lenguajes de programación. Es inviable concebir
que con un solo lenguaje de programación podemos llevar a cabo
todo tipo de desarrollos. Hay aplicaciones o parte de ellas que se
adecuarán más a las características de un lenguaje de
programación que otro. En este apartado vamos a resaltar las
situaciones en las cuales deberíamos considerar el uso de Python
y en cuales otras lo deberíamos desdeñar.
Python, al ser un lenguaje de scripting e interpretado no es
adecuado para la programación de bajo nivel o de sistemas. Por
ejemplo, la programación de drivers y kernels, dado que Python al
ser de demasiado alto nivel, no tiene control directo sobre
memoria y otras áreas de bajo nivel. Tampoco es adecuado para
aplicaciones que requieren una alta capacidad de computo, tal es
- 32 -
el caso de sistemas de procesamiento de imágenes. Pare este
tipo de aplicaciones el “viejo” C o C++, o como no el código
ensamblador, nunca podrán ser superados.
Python es ideal, sin embargo, como lenguaje "pegamento" para
combinar varios componentes juntos, para llevar a cabo prototipos
de sistemas, para la elaboración de aplicaciones cliente web o
con interfaz gráfica, el desarrollo de sistemas distribuidos o la
programación de tareas científicas, en las que hay que simular y
prototipar rápidamente. Python ha sido utilizado para desarrollar
muchos grandes proyectos de software como el servidor de
aplicaciones Zope, el sistema de compartición de ficheros Mnet o
parte de la implementación de Google. Actualmente, Python es
uno de los tres lenguajes de programación que se usan en la
framework de desarrollo de servidores de aplicaciones libres
LAMP (Linux Apache MySQL y Python, Perl o PHP).
****LADILLO: Programando en Python
Una vez conocidas las características de Python es momento de
empezar a usarlo. Para ello habremos de descargar una versión
del mismo (actualmente 2.3.3) de la sección downloads del portal
de Python (http://www.python.org), mostrado en la Figura 1. La
instalación para Windows es tan sencilla como hacer doble clic en
el ejecutable bajado. Para Linux, podremos usar los rpms
disponibles en (http://www.python.org/2.3.3/rpms.html). El
comando que te permitirá su instalación será algo similar a: rpm -
iv python2.3-2.3.3-pydotorg.i386.rpm
****SUBLADILLO: Modos de programación
- 33 -
Python se puede usar de dos modos diferentes: interactivamente
o en modo script. Para arrancar Python en modo interactivo todo
lo que se necesita es ejecutar en una consola de comandos (cmd
en Windows o xterm en Linux) el intérprete de Python, esto es, el
ejecutable python. Una vez arrancado el intérprete podrás
introducir cualquier sentencia en Python. La figura 2 muestra dos
sesiones interactivas de Python. En la primera se ha codificado el
ejemplo “hola mundo” mostrado con anterioridad. Para salir del
intérprete se ha pulsado Ctrl-Z. Para realizar lo mismo en UNIX
deberíamos haber pulsado Ctrl-D. Alternativamente, se podrían
haber usado las dos sentencias mostradas en la segunda sesión
interactiva de la figura 2. La primera importa el módulo sys (más
detalles luego) y la segunda ejecuta el método exit()de ese
módulo, que hace que el hilo de ejecución del programa finalice.
Para utilizar Python en modo script, se guardan las sentencias del
programa en un fichero y luego se ejecuta el mismo escribiendo
python <nombre-fichero.py>. Por ejemplo, en UNIX podríamos
hacer lo siguiente para crear el fichero holamundo.py y luego
ejecutarlo:
$ cat > holamundo.py
#!/usr/bin/env python
print "Hello World"
Ctrl^D
$ python holamundo.py
Hello World
Nótese que la sentencia #!/usr/bin/env python se usaría en
entornos UNIX para indicar al sistema que el interprete Python se
- 34 -
debería utilizar para ejecutar un fichero que tenga atributos de
ejecución. En Windows es ignorada.
****SUBLADILLO: Sentencias y bloques
Para realizar un programa útil es necesario agrupar grupos de
sentencias en unidades lógicas o bloques. Recuerda que en
Python las sentencias se delimitan por el salto de línea y los
bloques se indican por tabulación que sigue a una sentencia
acabada en ‘:’. Por ejemplo, el siguiente bloque de código
contiene la comparación de una variable con un valor que imprime
diferentes mensajes según el resultado de su evaluación.
# bloque.pyname = "Diego1" # asignación de valor a variable if name == "Diego":print "Aupa Diego" else:
print "¿Quién eres?" print "¡No eres Diego!"
La ejecución del programa anterior mediante el comando python
bloque.py generaría la siguiente salida:
¿Quién eres?
¡No eres Diego!
****SUBLADILLO:Identificadores
Los identificadores sirven para nombrar variables, funciones y
módulos. Deben empezar con un carácter no numérico y contener
letras, números y ‘_’. Python es sensible al uso de mayúsculas y
minúsculas en identificadores. Las siguientes son palabras
reservadas y no se pueden utilizar como identificadores: and, elif,
global, or, assert, else, if, len, pass, break, except, import, print,
- 35 -
class, exec, in, raise, continue, finally, is, return, def, for, lambda,
try, del, from, not, while. Existen unos cuantos identificadores
especiales con prefijo __ para variables y funciones que
corresponden a símbolos implícitamente definidos:
__name__ nombre de función
__doc__ documentación sobre una función
__init__() constructor de una clase
__del__() destructor de una clase
****SUBLADILLO:Variables y Tipos de datos
Para declarar una variable en Python solamente es necesario
darle un nombre y asignarle un valor. La variable es del tipo del
valor asignado. Por defecto las variables son locales y accesibles
solamente dentro del bloque de código donde han sido
declaradas, para acceder a variables globales, es necesario
preceder el nombre de la variable con el identificador global. Si no
se quiere asignar ningún valor a una variable, se le puede asignar
el valor None, equivalente a null en Java.
Numéricos
Python define los siguientes tipos numéricos: integer, long integer,
floating-point, y complex. Sobre los valores numéricos se pueden
aplicar los mismos operadores que en Java o C++, esto es, +, -, *,
/ y % (resto). Su uso se ilustra en los siguientes comandos
escritos en modo interactivo:
>>> x = 4 >>> int (x) # convierte x a entero4 >>> long(x) # conviértelo a long
- 36 -
4L >>> float(x) # a float4.0 >>> complex (4, .2) (4+0.2j)
Strings
Python soporta las cadenas de caracteres que son delimitadas
por un par de ' o ". Dos strings juntos separados por un espacio se
unen, y los separados por comas aparecen separados por un
espacio.
>>> print "Hola" "Iñigo" # imprime HolaIñigo
>>> print "Hola", "Iñigo" # imprime Hola Iñigo
Se utilizan los mismos códigos de escape que en C y Java. Por
ejemplo, para imprimir una nueva línea utilizaríamos print '\n'. Las
cadenas de caracteres cuyos caracteres especiales no queremos
que sean interpretados se indican con el prefijo ‘r’ de raw.
Las cadenas de caracteres son objetos en Python a los cuales se
les pueden aplicar algunas de las funciones predefinidas por
Python, como len, que devuelve el número de elementos en una
secuencia o los métodos que define tales como upper para
convertir a mayúsculas y find para encontrar un sub-cadenas en
una cadena, entre otros muchos. Para más información tanto
sobre la clase String como cualquier otro clase o módulo de
Python es recomendable revisar la documentación de la librería
estándar de Python (http://docs.python.org/lib/lib.html), cuya tabla
de contenidos se muestra en la figura 3. A continuación
mostramos algunas sentencias que hacen uso de strings.
>>> len(‘La vida es mucho mejor con Python.’)
- 37 -
>>> 34
>>> ‘La vida es mucho mejor con Python.’.upper()
‘LA VIDA ES MUCHO MEJOR CON PYTHON’
>>> "La vida es mucho mejor con Python".find("Python")
27
>>> "La vida es mucho mejor con Python".find(‘Perl’)
-1
>>> ‘La vida es mucho mejor con Python’.replace(‘Python’, ‘Jython’)
‘La vida es mucho mejor con Jython’
El carácter ‘%’ representa al operador de formateo de cadenas,
que se usa de una manera muy similar a los formateadores en C
para la sentencia printf, tales como d para decimal, f para float o, x
para hexadecimal.
>>> provincia = ‘Álava’
>>> "La capital de %s es %s" % (provincia, "Vitoria-Gasteiz")
‘La capital de Álava es Vitoria-Gasteiz’
Boléanos
Las constantes booleanas definidas por Python son True y False.
El resultado de una condición siempre devuelve uno de esos dos
valores.
Listas
Una lista representa una secuencia dinámica que puede crecer, y
está indexada por un entero que comienza con el valor 0. Python
define el operador ‘:’ u operador de rodajas que permite indicar
dando el índice inicial y final fragmentos de una lista o string (lista
de caracteres) a recuperar. Una lista es una clase definida por
- 38 -
Python y por tanto tiene métodos para añadir (add) o insertar
(insert) valores. Para borrar un elemento se utiliza la función
predefinida del.
>>> meses = ["Enero", "Febrero"]
>>> print meses[0]
Enero
>>> meses.append("Marzo") >>> print meses[1:2]['Febrero']>>> del meses[0]>>> meses['Febrero', 'Marzo']
Tuplas
Las tuplas son como las listas, pero no se pueden modificar. Son
convenientes cuando queremos devolver varios valores como
resultado de invocar a una función. Se definen con el operador (,
por ejemplo: (1,2)
Diccionarios
Los diccionarios son arrays asociativos o mapas, indexados por
una clave en vez de un índice numérico. La clave puede ser
cualquier objeto Python, aunque normalmente es una tupla. Como
se trata de una clase define una serie de métodos que podemos
invocar tales como has_key. El operador in se utiliza para
comprobar si un elemento forma parte de una secuencia.
>>> mydict = {"altura" : "media", "habilidad" : "intermedia"} >>> print mydict {'altura': 'media', 'habilidad': 'intermedia'} >>> print mydict["habilidad"] intermedia >>>if mydict.has_key('altura'):
- 39 -
>>> print 'Nodo encontrado'Nodo encontrado>>> if 'altura' in mydict:>>> print 'Nodo encontrado'Nodo encontrado
****SUBLADILLO:Control de flujo
Condicionales
La sentencia if se utiliza para la definición de condiciones y puede
ir seguida de varias partes elif y una else. En Python los
operadores boléanos definidos son: or, and y not. Los operadores
relacionales definidos son ==, >, < y =.
q = 4 h = 5 d = 3if q < h: print "primer test pasado" elif d<h: print "segundo test pasado"else: print "tercer test pasado" >>> python condicional.pyprimer test pasado
Bucles
Para la definición de bucles podemos usar el operador for o while.
for se utiliza principalmente para iterar sobre los miembros de una
secuencia: listas, tuplas o diccionarios. for se utiliza a menudo con
la función predefinida range, que crea una secuencia descrita por
([start,] end [,step]), donde los campos start y step son opcionales.
start es 0 y step es 1 por defecto.
>>> for x in range(1,5):
>>> print x
- 40 -
>>> 1 2 3 4
La sentencia while es otra sentencia de repetición. Se utiliza para
ejecutar un bloque de código hasta que una condición sea falsa.
La sentencia break se utiliza a menudo dentro de un bucle while y
sirve para salir del bucle.
>>> reply = 'repite'>>> while reply == 'repite':... print 'Hola'... reply = raw_input('Introduce "repite" para hacerlo de nuevo: ')...HolaIntroduce "repite" para hacerlo de nuevo: adiós>>>
****SUBLADILLO:Funciones
Una función se declara usando la palabra clave def, seguida del
nombre de la función y entre paréntesis una lista de argumentos.
Los argumentos si corresponden a tipos numéricos, boléanos o
strings se pasan por valor y si corresponden a secuencias por
referencia. A una función se le pueden asignar parámetros por
defecto, preasignado un valor a cada parámetro de una función.
Por ejemplo:
def myfunc(a,b=2):
sum = a + b
return sum
print myfunc(2) # devuelve el valor 4
A una función se le puede pasar un número variable de
argumentos (argumento con prefijo *) y argumentos basados en
palabras clave no predefinidas (argumento con prefijo **):
- 41 -
def testArgLists_1(*args, **kwargs):
print ‘args:’, args
print ‘kwargs:’, kwargs
testArgLists_1(‘aaa’, ‘bbb’, arg1=‘ccc’, arg2=‘ddd’)
que visualizaría:
args: (‘aaa’, ‘bbb’)
kwargs: {‘arg1’: ‘ccc’, ‘arg2’: ‘ddd’}
****SUBLADILLO:Clases
Las clases en Python son creadas usando la sentencia class. Una
clase contiene una colección de métodos. Cada método contiene
como primer parámetro (self) que hace referencia a la instancia de
la clase, es equivalente al this de C++ o Java. Python soporta
múltiple herencia de clases. Existe un soporte limitado para
variables privadas, usando una técnica llamada name mangling.
Todo identificador de la forma __spam es textualmente
reemplazado por _classname__spam. Sin embargo, el
identificador todavía podría ser accedido por código que usa la
instancia de la clase mediante _classname__spam. El listado 1
muestra un simple ejemplo de herencia.
****LISTADO 1: Un simple ejemplo de herencia
# clasesherencia.py
class Basic:
def __init__(self, name):
- 42 -
self.__name = name
def show(self):
print ‘Basic -- name: %s’ % self.__name
class Special(Basic): # entre paréntesis la clase base
def __init__(self, name, edible): Basic.__init__(self, name) self.__upper = name.upper() self.__edible = edible def show(self): Basic.show(self) print ‘Special -- upper name: %s.’ % self.__upper, if self.__edible: print "It’s edible." else: print "It’s not edible." def edible(self): return self.__edible
obj1 = Basic(‘Manzana’)obj1.show() print ‘=‘ * 30 obj2 = Special(‘Naranja’, 1) obj2.show()print obj2._Basic__nameprint obj2.__upper # lanzará una excepción
****SUBLADILLO:Excepciones
Cada vez que un error ocurre se lanza una excepción,
visualizándose un extracto de la pila del sistema. La ejecución de
la última sentencia del ejemplo anterior produciría:
Traceback (most recent call last): File "clasesherencia.py", line 28, in ? print obj2.__upperAttributeError: Special instance has no attribute ‘__upper’
- 43 -
Para capturar una excepción se usa except y para lanzar una
excepción se usa raise. Se pueden crear excepciones
personalizadas creando una nueva clase que derive de la clase
RuntimeError definida por Python. El siguiente fragmento ilustra el
uso de excepciones.
# excepcion.pytry: fh=open("new.txt", "r")except IOError, e: print e$ python excepcion.py[Errno 2] No such file or directory: ‘new.txt’
****SUBLADILLO:Módulos
Las librerías de métodos y clases se agrupan en Python en
módulos. Un módulo es una colección de métodos o clases en un
fichero que acaba en .py. El nombre del fichero determina el
nombre del módulo en la mayoría de los casos. Para usar un
módulo se usa la sentencia import <nombre-modulo> que hace
que un módulo y su contenido sean disponibles para su uso.
Alternativamente se puede usar la sentencia from <nombre-
module> import <elementos a importar separados por comas o *
para todo el contenido>. Por ejemplo, un módulo se podría definir
como:
# modulo.pydef one(a): print "in one"def two (c): print "in two"
Este modulo se usaría como sigue. Nótese la diferencia que
existe entre el uso de la cláusula import y la from:
>>> import modulo>>> modulo.one(2)in one
- 44 -
>>> from modulo import *>>> one(2)in one>>>
Un conjunto de módulos puede agruparse como una unidad
representada por un paquete. Referimos al lector a la Python
Library Referente para encontrar más detalles sobre cómo crear
un paquete.
****LADILLO:Desarrollando tu primera aplicación
Para poner en práctica la sintaxis del lenguaje Python vamos a
desarrollar una simple implementación del juego de tres en raya.
Aparte de permitirnos jugar contra la máquina, este juego requiere
que el jugador se autentifique antes de jugar y además guarda
estadísticas en memoria sobre las partidas ganadas, perdidas o
empatadas por cada jugador. Por el momento la máquina usa un
algoritmo sencillísimo para la elección de la casilla a tachar por la
máquina, la elige de manera aleatoria. En próximas entregas de
esta serie discutiremos algoritmos mejores basados en
inteligencia artificial. El listado 2 muestra la clase
RegistroJugadores que es utilizada para mantener las estadísticas
de las partidas de los jugadores.
****LISTADO 2: La clase RegistroJugadores
# imports para toda la aplicación
import os
import sys
import random
from types import *
class RegistroJugadores:
- 45 -
def __init__(self):
self.__jugadores = {'solop':'solop'}
self.__estadisticas = {'solop':[0, 0, 0]} # jugador -> [ganados, empatados, perdidos]
def registrarJugador(self, jugador, clave):
if len(trim(jugador)) == 0 or len(trim(clave)) == 0:
raise "Los campos jugador y clave no pueden estar vacios"
if self.__jugadores.has_key(jugador):
raise "Jugador " + jugador + " ya ha sido registrado!"
self.__jugadores[jugador] = clave
self.__estadisticas[jugador] = [0, 0, 0]
def login(self, jugador, clave):
if not self.__jugadores.has_key(jugador):
raise "Jugador " + jugador + " no registrado!"
if not self.__jugadores[jugador] == clave:
raise "Clave de jugador " + jugador + " es invalida"
return True
def registrarVictoria(self, userName):
self.__estadisticas[userName][0] += 1
def registrarEmpate(self, userName):
self.__estadisticas[userName][1] += 1
- 46 -
def registrarPerdida(self, userName):
self.__estadisticas[userName][2] += 1
def getEstadisticas(self, userName):
return self.__estadisticas[userName]
El constructor de RegistroJugadores define dos atributos privados
de tipo diccionario que guardan los jugadores registrados
(self.__jugadores) y las estadísticas de las partidas
(self.__estadisticas). Se carga un solo jugador con nombre de
usuario 'solop' y contraseña 'solop', e inicializamos las
estadísticas para el jugador 'solop', con la lista [0.0,0] que indica
que el usuario no ha ganado, ni empatado, ni perdido ningún
juego todavía. La clase RegistroJugadores define el método
registarJugador que permita registrar los detalles de login de un
nuevo jugador. Si ya existe un usuario con el nombre de usuario
pasado, se lanza una excepción y si no se crea una nueva
entrada en el atributo self.__jugadores. El método login permite la
autenticación de un usuario, y en caso de proveerse un nombre
de usuario o clave erróneas se lanza una excepción. Por su parte,
los métodos registrarVictoria, registrarEmpate y registrarPerdida
sirven para modificar el atributo self.__estadisticas con los
resultados de las partidas de cada jugador. Finalmente el método
getEstadisticas devuelve una lista con los resultados obtenidos
por un jugador.
****LISTADO 3: Constructor de la clase JuegoTresEnRaya
class JuegoTresEnRaya: def __init__(self, registro, userName, password):
- 47 -
self.__registro = registro try: self.__registro.login(userName, password) except Exception, e: print 'Problemas realizando login: ', e.message() sys.exit(0) # Constantes de la clase # combinaciones ganadoras en 3 en raya self.__combiGanadoras = [ [0,1,2], [3,4,5], [6,7,8], [0,3,6], [1,4,7], [2,5,8], [0,4,8], [2,4,6] ] self.__marcaJugador = 'o' self.__marcaMaquina = 'x'
# miembros de la clase self.__userName = userName # recordamos username de jugador self.__casillasMarcadas = 0 self.__casillero = [[None, None, None], [None, None, None], [None, None, None]]
random.seed() # inicilizar semilla numeros random
****LISTADO 4: Métodos de ayuda de la clase JuegoTresEnRaya def __elegirMarcaMaquina(self): # elije cual de las casillas no seleccionadas hay que marcar casillaMarcarIndex = random.randint(0, 8-self.__casillasMarcadas) casillaNoneExaminada = 0 for i in range(3): for j in range(3): if not self.__casillero[i][j] and casillaNoneExaminada == casillaMarcarIndex: return (i, j) elif not self.__casillero[i][j]: casillaNoneExaminada += 1
def __verTablero(self): #clear_screen() print '\n\nEstado actual de la partida:\n' print "-"*13 # imprime 13 veces - for i in range(3): fila = "| " for j in range(3): if self.__casillero[i][j] == None: fila += ('_' + " | ")
- 48 -
else: fila += (self.__casillero[i][j] + " | ") print fila print "-"*13 print '\n'
def __hayGanador(self): for i in range(len(self.__combiGanadoras)): a = self.__combiGanadoras[i][0] b = self.__combiGanadoras[i][1] c = self.__combiGanadoras[i][2] if self.__casillero[a/3][a%3] and self.__casillero[b/3][b%3] and self.__casillero[c/3][c%3]: if self.__casillero[a/3][a%3] == self.__casillero[b/3][b%3] == self.__casillero[c/3][c%3]: # marcar las casillas de la combinacion ganadora en mayusculas self.__casillero[a/3][a%3] = self.__casillero[b/3][b%3] = self.__casillero[c/3][c%3] = self.__casillero[c/3][c%3].upper() return True return False ****LISTADO 5: Método jugar de la clase JuegoTresEnRaya def jugar(self): while self.__casillasMarcadas < 9: # mientras el usuario no introduce las coordenadas de una casilla no seleccionada while True: casillaCoords = () # declara una variable de tipo tupla vacia while True: try: s = raw_input("Escribe la casilla que quieres marcar entre (1, 1) y (3, 3), e.j. (2,1): ") casillaCoords = eval(s) # interpreta la entrada como una tupla if not type(casillaCoords) is TupleType: print 'ERROR: Introduce las coordenadas en el formato (x, y), donde x e y estan en el rango [1-3]' continue break except: print 'ERROR: Introduce las coordenadas en el formato (x, y), donde x e y estan en el rango [1-3]' x = casillaCoords[0] - 1
- 49 -
y = casillaCoords[1] - 1 if x > 2 or y > 2 or x < 0 or y < 0: print "ERROR: Indica indices de fila y columna entre 1 y 3" if self.__casillero[x][y] == None: self.__casillero[x][y] = self.__marcaJugador self.__casillasMarcadas += 1 break else: print 'ERROR: Casilla ya marcada' if self.__hayGanador(): self.__verTablero() self.__registro.registrarVictoria(self.__userName) print 'RESULTADO: El usuario ha ganado' return
if self.__casillasMarcadas == 9: self.__verTablero() break casillaIndex = self.__elegirMarcaMaquina() self.__casillero[casillaIndex[0]][casillaIndex[1]] = self.__marcaMaquina self.__casillasMarcadas += 1
if self.__hayGanador(): self.__verTablero() self.__registro.registrarPerdida(self.__userName) print 'RESULTADO: La maquina ha ganado' return self.__verTablero() self.__registro.registrarEmpate(self.__userName) print 'RESULTADO: Ha habido empate' self.__registro.registrarEmpate(self.__userName) print 'RESULTADO: Ha habido empate'
El listado 3 muestra la implementación del constructor de la clase
JuegoTresEnRaya, que define la lógica principal de la aplicación.
El constructor de esta clase recibe como parámetros una
referencia al registro de jugadores, el nombre de usuario y la
clave del jugador que quiere competir con la máquina. El
constructor en primer lugar guarda la referencia al registro en la
- 50 -
variable privada self.__registro y valida que los datos de
autentificación del jugador son correctos. A continuación, declara
las constantes self.__combiGanadoras con las combinaciones
ganadoras del juego, self.__marcaJugador con el carácter 'o' que
indica la marca de un jugador y self.__marcaMaquina con el valor
'x' que denota las casillas marcadas por la máquina. Finalmente,
el contructor declara las variables self.__userName donde
memoriza el identificador del jugador, self.__casillasMarcadas
donde cuenta cuantas casillas están marcadas hasta el momento
y el array bidimensional self.__casillero que recoge los valores
marcados en cada casilla, inicialmente ninguno.
El listado 4 muestra los siguientes métodos de ayuda definidos
por la clase JuegoTresEnRaya: __elegirMarcaMaquina,
__verTablero y __hayGanador. El método __elegirMarcaMaquina
hace uso del módulo random para elegir de manera aleatoria una
de las casillas no marcadas. El módulo __verTablero visualiza en
modo texto el tablero. Finalmente, el método __hayGanador
determina si alguna de las combinaciones ganadoras ha sido
alcanzada.
El listado 5 muestra el único método público jugar() que define
toda la lógica del juego de tres en raya entre un usuario y la
máquina. Asume que el usuario siempre comienza. La partida no
concluye hasta que se ha encontrado una combinación ganadora
o se han tachado las nueve casillas del tablero. Mientras el
usuario no introduce los datos de una casilla correctamente el
método itera sobre un bucle. Para recoger la entrada del usuario
se utiliza la función raw_string(<mensaje>). Además dado que se
pretende que la entrada tenga el formato (x, y), se evalúa si los
datos introducidos corresponden a una tupla, mediante la función
eval que convierte un string al tipo de datos representado.
Además se valida si el valor interpretado corresponde a una tupla
haciendo uso del método type del módulo types y del operador is
- 51 -
que permite la comparación entre un valor y su tipo: if not
type(casillaCoords) is TupleType. Además en cada iteración se
comprueba que el valor de la celda introducida esté dentro del
rango de valores validos y además no haya sido ya marcado.
Después de que el usuario introduzca una casilla válida se evalúa
si ha ganado invocando el método __hayGanador. Si es así se
registra la victoria del usuario invocando
self.__registro.registrarVictoria(self.__userName). Si todavía no se
han marcado las nueve casillas del tablero se pasa el turno a la
máquina, eligiéndose la casilla a marcar mediante la llamada al
método privado __elegirMarcaMaquina. A continuación, se
comprueba si tras marcar la última casilla la máquina ha ganado
la partida y si es así se registra que el usuario la ha perdido.
Cuando las casillas marcadas sean nueve y no ha habido ningún
ganador se registrará el hecho de que el juego ha acabado en
empate.
****LISTADO 6: El bloque main
if __name__ == '__main__': registro = RegistroJugadores() juego = JuegoTresEnRaya(registro, sys.argv[1], sys.argv[2]) juego.jugar() while True: s = raw_input("¿Quieres jugar otra vez? (s) o (n): ") if s.strip().lower() == 's': juego = JuegoTresEnRaya(registro, 'solop', 'solop') juego.jugar() else: print 'Gracias por jugar al tres en raya!' print 'Estadísticas de juego de solop: victorias (' + str(registro.getEstadisticas('solop')[0]) +\ ') - empates (' + str(registro.getEstadisticas('solop')[1]) + \ ') - derrotas (' + str(registro.getEstadisticas('solop')[2]) + ')' break
- 52 -
El listado 6 muestra el bloque de entrada del programa. Todo
bloque que comience con if __name__ == '__main__':, es
equivalente a un bloque main en C o Java. El bloque main, en
primer lugar, obtiene una referencia al registro. En futuras
entregas recuperaremos ese registro bien de un fichero o de una
base de datos. Por el momento, esto se consigue invocando al
constructor de RegistroJugadores que mantiene un diccionario en
memoria con los jugadores registrados y otro con las estadísticas
de juego de los mismos. En segundo lugar, el bloque main crea
una instancia de la clase JuegoTresEnRaya, pasando como
referencia el registro obtenido y el nombre y contraseña del
jugador. Estos dos últimos valores son recuperados a partir de los
parámetros pasados en la invocación del programa, mediante la
sentencia sys.argv[x], donde x indica el orden del parámetro,
apuntando el índice 0 al nombre del script. A continuación, se
permite que el usuario inicie una partida llamando al método
jugar() de la instancia de JuegoTresEnRaya. Al finalizar esta
partida se pregunta al usuario si quiere seguir jugando y se repite
este proceso hasta que el usuario no responda s. Finalmente,
antes de terminar el programa se muestran las estadísticas de
resultados de los enfrentamientos entre la máquina y el usuario
indicado. La figura 4 muestra una sesión del juego de tres en
raya.
****LADILLO: Conclusión
Este artículo ha mostrado la sintaxis del lenguaje Python y ha
ilustrado su uso a través de la elaboración de un simple juego de
tres en raya. A través de la elaboración de este pequeño
programa hemos podido comprobar la simplicidad de Python y
sus capacidades para elaborar de manera rápida cualquier tarea
de programación que tengamos en mente. En la siguiente entrega
- 53 -
de esta serie veremos como proporcionar una interfaz gráfica a
este juego y cómo mantener el registro de jugadores y sus
estadísticas en varios ficheros.
****FIG1.TIF: Página web Python.org
****FIG2.TIF: Sesiones interactivas en Python.****FIG3.TIF: Documentación de la Librería de Python.****FIG4.TIF: Sesión de Juego del Tres en Raya
V. REFERENCIAS BIBLIOGRÁFICAS
1. Publicaciones ICG (Instituto de Construcción y Gerencia).
PAVIMENTOS. 3ra.Edición 2009. Lima Perú. Págs. 185 – 195.
2. ORTA, Pedro Andrés. Pavimentación con Adocretos, una tecnología
amistosa con el medio ambiente. Tecnología y Construcción. [online].
dic. 2009, vol.25, no.3 [citado 12 Agosto 2010], p.47-58. Disponible en la
World Wide Web:
<http://www2.scielo.org.ve/scielo.php?script=sci_arttext&pid=S0798-
96012009000300004&lng=es&nrm=iso>. ISSN 0798-9601.
3. ICPA (Instituto Cemento Portland). Construcción de Pavimentos de
Adoquín de Hormigón. Lima Peru 2009.
4. Reglamento Nacional de Edificaciones. Norma CE.010. Pavimentos
Urbanos. Lima Perú 2010. Pág. 38
5. Reglamento Nacional de Edificaciones. Norma CE.010. Pavimentos
Urbanos. Lima Perú 2010.
6. German Vivar Romero. Diseño y Construcción de Pavimentos. CIP.
Segunda Edición Setiembre 2005. Lima Perú.
7. Caballos, Sierra Javier, “Curso de programación”, México D.F., Editorial
Alfa Omega, 2a edición.
- 54 -
8. Jonanes, Aguilar Luis.” Algoritmos, estructuras y objetos”, Editorial
McGraw– Hill.
9. Juárez, Badillo, Rico Rodríguez. “Teoría y aplicaciones de la mecánica
de suelos”, tomo II. México D.F., Editorial limusa, 1995
10. Plazola, Cisneros, Plazola Anguiano.”Normas y técnicas de
construcción”, volumen 1, Editorial Limusa, 3° edición, México D.F.
11. Reglamento de construcción del Distrito Federal, Gaceta oficial del
Distrito Federal, Tomo I No.103-BIS, décima cuarta época, México 2004
12. Sánchez Ibarra Alma Rosa, Olmos Navarrete Bertha Alejandra,
Navarro Caballero Enrique Omar, Manual De Apuntes “Análisis Y Diseño
Estructural De Casas Habitación”
- 55 -
VI. ANEXO
Anexo 01: CRONOGRAMA DE ACTIVIDADES
FECHA DE INICIO: Abril 2013
FECHA DE TÉRMINO: Julio del 2013.
ACTIVIDADES SEMANAS / 20131 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Revisión Bibliográfica
Búsqueda y adquisición de bibliografíaElaboración del ProyectoAntecedentes y formulación del ProblemaElaboración del instrumentoCaptación de datosEntrevistaProcesamiento y AnálisisPresentación del Borrador del ProyectoProcesamiento de los datosAnálisis e interpretaciónDiscusión de los resultadosRevisión general de los. ResultadosPreparación del informe finalPublicaciónPresentación y sustentación del informe final
- 1 -