INSTITUTO TECNOLÓGICO NACIONAL DE

MÉXICO
INSTITUTO TECNOLÓGICO DE VERACRUZ

LENGUAJES Y AUTÓMATAS II.

CATEDRÁTICA:
MARTINEZ MORENO MARTHA

ALUMNOS:
VICTOR MANUEL MARTINEZ FUENTES
JUAN EDUARDO LICONA GUEVARA
JESUS MANUEL LOPEZ GARCIA

TEMA
PYTHON

HORARIO:
07:00-08:00 am

Veracruz, ver. Enero 2018

indice
INTRODUCCIÓN ............................................................................................................................................... 3
UN POCO DE HISTORIA…. ............................................................................................................................. 4
PRINCIPALES INFLUENCIAS DE OTROS LENGUAJES ................................................................................. 5
CRONOLOGIA DE PYTHON ............................................................................................................................. 7
PRINCIPALES CARACTERÍSTICAS DEL LENGUAJE PYTHON...................................................................... 8
SIMPLE: ......................................................................................................................................................... 8
PROPÓSITO GENERAL: ............................................................................................................................... 8
OPEN SOURCE: ............................................................................................................................................ 8
LENGUAJE ORIENTADO A OBJETOS: ....................................................................................................... 9
LENGUAJE DE ALTO NIVEL: ....................................................................................................................... 9
INCRUSTABLE: ............................................................................................................................................. 9
EXTENSAS LIBRERÍAS: ............................................................................................................................... 9
SINTAXIS CLARA: ........................................................................................................................................ 9
SINTAXIS Y SIMBOLOGÍA. .............................................................................................................................. 9
Valores y Tipos de Datos ............................................................................................................................ 9
Tipos de Datos ......................................................................................................................................... 9
Valores .................................................................................................................................................... 10
VARIABLES.................................................................................................................................................. 12
ESCRIBIR EN PAPEL .................................................................................................................................. 13
NOMBRES DE VARIABLES Y PALABRAS CLAVES................................................................................... 14
PALABRAS CLAVES .................................................................................................................................... 15
SENTENCIAS ............................................................................................................................................... 16
EVALUACIÓN DE EXPRESIONES .............................................................................................................. 16
OPERADORES Y OPERANDOS .................................................................................................................. 17
FUNCIONES DE TIPO CONVERTIDOR .................................................................................................... 18
ORDEN DE LAS OPERACIONES................................................................................................................ 20
OPERACIONES SOBRE CADENAS ............................................................................................................ 20
ENTRADA (INPUT) ..................................................................................................................................... 21
GLOSARIO ....................................................................................................................................................... 23
ERRORES SEMANTICOS..................................................................................................................................... 25
CONCLUCION .................................................................................................................................................... 35
BIBLIOGRAFIA:............................................................................................................................................... 36

pág. 2
INTRODUCCIÓN

Python es un lenguaje de programación poderoso y fácil de aprender. Cuenta con

estructuras de datos eficientes y de alto nivel y un enfoque simple pero efectivo a la
programación orientada a objetos. La elegante sintaxis de Python y su tipado
dinámico, junto con su naturaleza interpretada, hacen de éste un lenguaje ideal para
scripting y desarrollo rápido de aplicaciones en diversas áreas y sobre la mayoría de
las plataformas.
El intérprete de Python puede extenderse fácilmente con nuevas funcionalidades y
tipos de datos implementados en C o C++ (u otros lenguajes accesibles desde C).
Python también puede usarse como un lenguaje de extensiones para aplicaciones
personalizables.

pág. 3
UN POCO DE HISTORIA….

El origen del lenguaje Python se remonta a principios de los noventa. Por este tiempo, un
investigador holandés llamado Guido van Rossum, que trabajaba en el centro de
investigación CWI (Centrum Wiskunde & Informática) de Ámsterdam, es asignado a un
proyecto que consistía en el desarrollo de un sistema operativo distribuido llamado Amoeba.
Por aquel tiempo, el CWI utilizaba un lenguaje de programación llamado ABC. En lugar de
emplear este lenguaje para el proyecto Amoeba, Guido decide crear uno nuevo que pueda
superar las limitaciones y problemas con los que se había encontrado al trabajar en otros
proyectos con ABC. Así pues, es esta la principal motivación que dio lugar al nacimiento de
Python.

La primera versión del lenguaje ve la luz en 1991, pero no es hasta tres años después
cuando decide publicarse la versión 1.0. Inicialmente el CWI decidió liberar el intérprete del
lenguaje bajo una licencia open source propia, pero en septiembre de 2000 y coincidiendo
con la publicación de la versión 1.6, se toma la decisión de cambiar la licencia por una que
sea compatible con la licencia GPL (GNU General Public Licence). Esta nueva licencia se
denominará Python Software Foundation Licence y se diferencia de la GPL al ser una licencia
no copyleft. Este hecho implica que es posible modificar el código fuente y desarrollar código
derivado sin la necesidad de hacerlo open source.

Hasta el momento solo se han liberado tres versiones principales, teniendo cada una de
ellas diversas actualizaciones. En lo que respecta a la versión 2, la última en ser liberada fue
la 2.7, en julio de 2010. Actualmente, la versión cuenta con la actualización 3.3, liberada en
septiembre de 2012. Ambas versiones, la de 2 y 3, son mantenidas por separado. Esto
implica, que tanto la 2.7 como la 3.3 se consideran estables, pero, lógicamente,
correspondientes a diferentes versiones. ¿Por qué mantener ambas versiones y no seguir
una evolución lógica? La respuesta a esta pregunta es fácil de responder: Entre ambas
versiones existen diferencias que las hacen incompatibles.

Muchos se preguntan el origen del nombre de Python. Guido van Rossum decidió darle este
nombre en honor a la serie de televisión Monty Python's Flying Circus, de la cual era fan.
Esta es una serie cómica protagonizada por el grupo de humoristas Monty Python, famoso
por películas como La vida de Brian o El sentido de la vida. Desde el principio de su diseño,
se pretendía que Python fuera un lenguaje que resultara divertido de utilizar, de ahí que en
el nombre influyera la mencionada serie cómica. También resulta curioso que, tanto en
tutoriales, como en ejemplos de código, se suelen utilizar referencias a los Monty Python.
Por ejemplo, en lugar de emplear los tradicionales nombres de variables foo y bar, se suele
utilizar spam y egss, en referencia a sketchs de este grupo de cómicos.

El desarrollo y promoción de Python se lleva a cabo a través de una organización, sin ánimo
de lucro, llamada Python Software Foundation, que fue creada en marzo de 2001. Entre las
actividades que realiza esta organización destacan el desarrollo y distribución oficial de
Python, la gestión de la propiedad intelectual del código y documentos realizados, así como
la organización de conferencias y eventos dedicados a poner en contacto a todas aquellas
personas interesadas en este lenguaje de programación.

pág. 4
PRINCIPALES INFLUENCIAS DE OTROS LENGUAJES

El núcleo de la sintaxis de Python y grandes aspectos de su filosofía fueron heredados

directamente del lenguaje de programación ABC. Por ejemplo el siguiente código muestra
una función para obtener el conjunto de todas las palabras en un documento en ABC4 y en
Python:

pág. 5
Las principales ideas de ABC que influyeron o se incluyeron en Python fueron según el propio
Guido:

 La indentación para agrupar el código

 El carácter: para indicar que comienza un bloque indentado (después de pruebas con
usuarios)
 El diseño simple de las instrucciones: if , while , for , ...
 Tuplas, listas, diccionarios (fuertemente modificados en Python)
 Tipos de datos inmutables
 No imponer límites, como tamaño de un array, etc...
 El "prompt" >>>
Otras ideas que influyeron en la concepción de Python fue tener un lenguaje que pudiera
ser tan potente como C pero también expresivo para ejecutar "scripts" como sh. De hecho,
la sintaxis de Python copia muchísimo de C. Por ejemplo, las palabras claves
( if , else , while , for , etc.) son las mismas que en C, los identificadores tienen las mismas
reglas para nombrarlos que C, y la mayoría de los operadores estándar tienen el mismo
significado que en C. Una de las mayores diferencias es que Python en lugar de usar llaves
para agrupar código usa indentación, la otra gran diferencia es que Python usa tipado
dinámico.
Los generadores e iteradores fueron inspirados por Icon, y fusionados con las ideas de la
programación funcional en un modelo unificado. Modula-3 fue la base del modelo de
excepciones y del sistema de módulos. Perl contribuyó en las expresiones regulares, usadas
para la manipulación de "string". Las adiciones a biblioteca estándar de Python standard

pág. 6
library y algunas opciones sintácticas fueron influenciadas por Java algunos ejemplos son:
el paquete de logging , introducido en la versión 2.3, el paquete threading para
aplicaciones multihilos, el parser SAX, introducido en la versión 2.0, y la sintaxis
del decorador que usa @ , incluida en la versión 2.4.

CRONOLOGIA DE PYTHON
Fechas de publicación:

 Comienzo de la implementación - diciembre, 1989

 Publicación interna en CWI - 1990
 Python 0.9 - 20 de febrero de 1991 (publicado en alt. source)
 Python 0.9.1 - febrero de 1991
 Python 0.9.2 - otoño de 1991
 Python 0.9.4 - 24 de diciembre de 1991
 Python 0.9.5 - 2 de enero de 1992 (solo para Macintosh)
 Python 0.9.6 - 6 de abril de 1992
 Python 0.9.7 beta - 1992
 Python 0.9.8 - 9 de enero de 1993
 Python 0.9.9 - 29 de julio de 1993
 Python 1.0 - enero de 1994
 Python 1.5 - 31 de diciembre de 1997
 Python 1.6 - 5 de septiembre de 2000
 Python 2.0 - 16 de octubre de 2000
 Python 2.1 - 17 de abril de 2001
 Python 2.2 - 21 de diciembre de 2001
 Python 2.3 - 29 de julio de 2003
 Python 2.4 - 30 de noviembre de 2004
 Python 2.5 - 19 de septiembre de 2006
 Python 2.6 - 1 de octubre de 2008
 Python 2.7 - 3 de julio de 2010
 Python 3.0 - 3 de diciembre de 2008
 Python 3.1 - 27 de junio de 2009
 Python 3.2 - 20 de febrero de 2011
 Python 3.3 - 29 de septiembre de 2012
 Python 3.4 - 16 de marzo de 2014

pág. 7
 Las versiones indicadas en rojo se consideras obsoletas.

PRINCIPALES CARACTERÍSTICAS DEL LENGUAJE PYTHON

Python es un lenguaje de programación creado por Guido van Rossum a finales de los
ochenta, y que gracias a sus características ha llegado a ser un lenguaje muy conocido en
la actualidad. A continuación, se listan las principales características que este lenguaje
posee:

SIMPLE:

Python es un lenguaje muy simple, por lo que es muy fácil iniciarse en este lenguaje. El
pseudo-código natural de Python es una de sus grandes fortalezas.

PROPÓSITO GENERAL:

Usando el lenguaje Python se puede crear todo tipo de programas; programas de propósito
general y también se pueden desarrollar páginas Web.

OPEN SOURCE:

Debito a la naturaleza de Python de ser Open Suorce; ha sido modificado para que pueda
funcionar en diversas plataformas (Linux, Windows, Macintosh, Solaris, OS/2, Amiga, AROS,
AS/400, BeOS, OS/390, z/OS, Palm OS, QNX, VMS, Psion, Acorn RISC OS, VxWorks,
PlayStation, Sharp Zaurus, Windows CE y PocketPC).

pág. 8
Al ser Open Source es gratuito.

LENGUAJE ORIENTADO A OBJETOS:

Al ser un Lenguaje Orientado a Objetos es construido sobre objetos que combinan datos y
funcionalidades.

LENGUAJE DE ALTO NIVEL:

Al programar en Python no nos debemos preocupar por detalles de bajo nivel, (como
manejar la memoria empleada por el programa).

INCRUSTABLE:

Se puede insertar lenguaje Python dentro un programa C/C++ y de esta manera ofrecer las
facilidades del scripting.

EXTENSAS LIBRERÍAS:

Python contiene una gran cantidad de librerías, tipos de datos y funciones incorporadas en
el propio lenguaje, que ayudan a realizar muchas tareas comunes sin necesidad de tener
que programarlas desde cero.

Las librerías pueden ayudar a hacer varias cosas como expresiones regulares, generación
de documentos, evaluación de unidades, pruebas, procesos, bases de datos, navegadores
web, CGI, ftp, correo electrónico, XML, XML-RPC, HTML, archivos WAV, criptografía, GUI, y
también otras funciones dependientes del Sistema.

SINTAXIS CLARA:

Python tiene una sintaxis muy visual, gracias a que maneja una sintaxis identada (con
márgenes), que es de carácter obligatorio. Para separar los bloques de código en Python se
debe tabular hacia dentro. Esto ayuda a que todos los programadores adopten las mismas
notaciones y que los programas hechos en Python tengan un aspecto muy similar.

SINTAXIS Y SIMBOLOGÍA.

Valores y Tipos de Datos

Tipos de Datos
Los tipos de datos se pueden resumir en esta tabla:

pág. 9
Valores
Un valor es una de las cosas fundamentales que un programa manipula — como una letra
o un número. Los valores que hemos visto hasta ahora son el número 4 (resultado de la
adición de 2 + 2), y "¡Hola, todo el mundo!".

Estos valores pertenecen a diferentes clases (classes) o tipos: 4 es un entero, y "¡Hola,

todo el mundo!" es una cadena, llamada así porque contiene una cadena de letras. Usted
(y el intérprete) puede identificar cadenas porque están encerradas entre comillas.

Si usted no está seguro de que clase se divide en un valor, Python tiene una función
llamada tipo (type) la cual le incida a usted.

>>> type("Hola, todo el mundo!")

<class 'str'>

>>> type(17)

<class 'int'>

No es sorprendente que las cadenas pertenezcan al tipo str y los enteros pertenezcan al
tipo int . Los números con un punto decimal pertenezcan a un tipo llamado float, porque
éstos se representan en un formato denominado punto flotante. En esta etapa, se puede
tratar la clase y el tipo de palabras de manera intercambiable. Volveremos a una
comprensión más profunda de lo que es una clase en capítulos posteriores.

>>> type(3.2)

<type 'float'>

¿Qué ocurre con valores como “17” y “3.2"? Parecen números, pero están encerrados entre
comillas como las cadenas.

pág. 10
>>> type("17")

<type 'str'>

>>> type("3.2")

<type 'str'>

Ellos son cadenas.

Cadenas en Python puede ser incluida en cualquiera de las dos comillas simples (') o comillas
dobles (") o también comillas triples de cada una (''' o """)

>>> type('Esta es una cadena.')

<type 'str'>

>>> type("y esta es tambien.")

<typle 'str'>

>>> type("""y esta.""")

<typle 'str'>

>>> type('''e incluso esta...''')

<class 'str'>

Cadenas de comillas doble pueden contener comilla simple dentro de ellas, como en “Bruce’s
Beard”, y cadenas de comilla simple pueden tener comillas dobles dentro de ellas también,
¡como en ‘Los caballeros que dicen “Ni!"'.

Cadenas cerradas con tres apariciones de los símbolos citan son llamados cuerdas triples
cita. Pueden contener comillas simples o dobles:

>>> print('''"Oh no", ella exclamó, "La moto de Ben está dañada!"''')

"¡Oh no”, ella exclamó, “La moto de Ben está dañada!"

>>>

Cadenas triple cita incluso puede abarcar varias líneas:

>>> mensaje = """Este mensaje

... span several

... lines."""

pág. 11
>>> print(mensaje)

Este mensaje

abarcar varios

líneas.

>>>

Python no le importa si usted usa comillas simples o dobles, o las citas de tres de su tipo,
para rodear las cuerdas: una vez que se ha analizado el texto de su programa o comando,
la forma en que almacena el valor es idéntico en todos los casos y las comillas rodean no
forman parte del valor. Pero cuando el intérprete se quiere mostrar una cadena, que tiene
que decidir que cita a utilizar para hacer que se vea como una cadena.

>>> "Esto es una cadena".

'Esto es una cadena'

>>> """Y asi es esto."""

'Y por lo tanto es este'

Así que los diseñadores del lenguaje Python generalmente elegido para rodear sus cadenas
de comillas simples. ¿Qué crees que pasaría si la cadena que ya figuran entre comillas
simples? Pruébelo usted mismo y vea.

Cuando se escribe un entero grande, que podría tener la tentación de usar comas entre
grupos de tres dígitos, como en 42.000. Esto no es un entero legal en Python, pero sí quiere
decir algo más, que es legal:

>>> 42000

42000

>>> 42,000

(42, 0)

¡Bueno, eso no es lo que esperábamos en absoluto! Debido a la coma, Python optó por
tratar esto como un par de valores. Vamos a volver a aprender acerca de los pares más
tarde. Pero, por el momento, recuerde no poner comas o espacios en sus enteros, no
importa lo grandes que son. También volver a lo que dijimos en el capítulo anterior:
lenguajes formales son estrictas, la notación es concisa, e incluso el más pequeño cambio
puede significar algo muy distinto de lo que pretende.

VARIABLES

pág. 12
Una de las características más poderosas en un lenguaje de programación es la capacidad
de manipular variables. Una variable es un nombre que se refiere a un valor.

La sentencia de asignación crea nuevas variables y les da valores:

>>> mensaje = "¿Qué Onda?"

>>> n = 17

>>> pi = 3.14159

Este ejemplo hace tres asignaciones. La primera asigna la cadena "¿Que Onda?" a una
nueva variable denominada mensaje. La segunda le asigna el entero 17 a n, y la tercera le
da el número de punto flotante 3.14159 a pi.

No debe confundirse el operador de asignación, =, con el signo de igualdad (aún y cuando

se usa el mismo símbolo). El operador de asignación enlaza un nombre, en el lado izquierdo
del operador, con un valor en el lado derecho. Esta es la razón por la que obtendrá un error
si escribe:

>>> 17 = n

Tip

Al leer or escribir código, dígase a sí mismo “n se le asigna 17” o “n se obtiene el valor de

17”. No diga “n es igual a 17”

ESCRIBIR EN PAPEL

Una manera común de representar variables en el papel es escribir el nombre de la variable

con una flecha apuntando a su valor. Esta clase de dibujo se denomina diagrama de estado
porque muestra el estado de cada una de las variables (piense en los valores como el estado
mental de las variables). Este diagrama muestra el resultado de las sentencias de asignación
anteriores:

Si le preguntas a el intérprete para evaluar una variable, se producirá el valor que está
vinculado a la variable:

>>> print mensaje

'What's up, Doc?'

>>> print n

17

>>> print pi

3.14159

En cada caso el resultado es el valor de la variable. Las variables también tienen tipos;
nuevamente, le podemos preguntar al intérprete cuáles son.

pág. 13
>>> type(mesaje)

<type 'str'>

>>> type(n)

<type 'int'>

>>> type(pi)

<type 'float'>

El tipo de una variable es el tipo del valor al que se refiere.

Usamos las variables en un programa para “recordar” las cosas, al igual que la puntuación
actual en el partido de fútbol. Sin embargo, las variables son variables. Esto significa que
pueden cambiar con el tiempo, al igual que el marcador de un partido de fútbol. Se puede
asignar un valor a una variable, y luego asignar un valor diferente a la misma variable.

Nota:

Esto es diferente que en matemáticas. ¡En matemáticas, si se le da x el valor 3, no puede

cambiar un enlace a un valor diferente a medio camino a través de sus cálculos!

>>> dia = "Jueves"

>>> dia

'Jueves'

>>> dia = "Viernes"

>>> dia

'Viernes'

>>> dia = 21

>>> dia 21

Usted notará que nosotros cambiamos el valor del dia en tres ocasiones, y en la tercera
asignación nosotros le dimos un valor que era de un tipo diferente.

Una gran parte de la programación se trata de que la computadora pueda recordar las
cosas, por ejemplo, el número de llamadas perdidas es su teléfono, y la organización de
alguna actualización o cambio de la variable cuando se olvida otra llamada.

NOMBRES DE VARIABLES Y PALABRAS CLAVES

Nombres de variables válidos en Python debe ajustarse a las siguientes tres simples reglas:

Son secuencias arbitrariamente largas de letras y dígitos.

La secuencia debe empezar con una letra.

pág. 14
Además de a..z, y A..Z, el guion bajo (_) es una letra.

Los programadores generalmente escogen nombres significativos para sus variables — que
especifiquen para qué se usa la variable.

Aunque es permitido usar letras mayúsculas, por convención no lo hacemos. Si usted lo

hace, recuerde que las letras mayúsculas importan, Pedro y pedro son variables diferentes.

El carácter subrayado (_) puede aparecer en un nombre. A menudo se usa en nombres con
múltiples palabras, tales como mi_nombre ó́ precio_de_la_porcelana_en_china.

Hay algunas situaciones en las que los nombres que comienzan con un guión tienen un
significado especial, por lo que una regla segura para los principiantes es empezar todos los
nombres con una letra que no sea un guión.

Si usted le da un nombre inválido a una variable obtendrá un error de sintaxis:

>>> 76trombones = "gran desfile"

SyntaxError: invalid syntax

>>> mas$ = 1000000

SyntaxError: invalid syntax

>>> class = "Informática 101"

SyntaxError: invalid syntax

76trombones es inválido porque no empieza con una letra. mas$ es inválido porque contiene
un carácter ilegal, por el símbolo de dolar $. PerPero, ¿Que sucede con class?

Resulta que class es una de las palabras claves de Python. Las palabras claves definen las
reglas del lenguaje y su estructura, y no pueden ser usadas como nombres de variables.

PALABRAS CLAVES

Python tiene treinta y tantas palabras clave (y todas son mejoradas de vez en cuando para
que Python introduzca o elimine una o dos):

and as assert break class continue

def del elif else except exec

finally for from global if import

in is lambda nonlocal not or

pass raise return try while with

yield True False None

Usted puede mantener esta lista a mano. Si el intérprete se queja por alguno de sus nombres
de variables, y usted no sabe por qué, búsquelo en esta lista.

pág. 15
Los programadores generalmente eligen nombres para sus variables que son significativas
para los lectores humanos del programa — que ayudan a los documentos de programación,
o recordar, lo que la variable se utiliza.

Precaución:

Los principiantes a veces se confunden “con sentido para los lectores humanos” con
“significativo de la computadora”. Por lo que ellos erróneamente piensan que, porque han
llamado algunas variables promedio o pi, de alguna manera automáticamente calcula un
promedio, o automáticamente asocia la variable pi con el valor de 3,14159. ¡No! La
computadora no se fija el significado semántico de los nombres de las variables.

Por lo que encontrarás algunos instructores que deliberadamente no eligen nombres

significativos cuando enseñan a los principiantes — no porque ellos no piensen que sea un
buen hábito, sino porque está tratando de reforzar el mensaje que usted, el programador,
tiene que escribir el código del programa para calcular el promedio, o tiene que escribir una
instrucción de asignación a una variable del valor que desea que tenga.

SENTENCIAS

Una sentencia es una instrucción que el intérprete de Python puede ejecutar. Hemos visto
otras clases de sentencias hasta el momento. Otros tipos de sentencias que se verá en breve
son la sentencias de while, for, if, y de import. (¡Hay otros tipos también!)

Cuando usted escriba una sentencia en la línea de comandos, Python la ejecuta. Las
sentencias de asignación no producen un resultado.

EVALUACIÓN DE EXPRESIONES

Una expresión es una combinación de valores, variables, operadores, y llamadas funciones.

Si escribe una expresión en la línea de comandos de python, el intérprete la evalúa y
despliega el resultado:

>>> 1 + 1

>>> len("hola")

En este ejemplo len es una función integrada de Python que devuelve el número de
caracteres de una cadena. ¡Hemos visto anteriormente las funciones de print y el type, por
lo que este es nuestro tercer ejemplo de una función!

pág. 16
La evaluación de una expresión produce un valor, esta es la razón por la que las expresiones
pueden aparecer en el lado derecho de las sentencias de asignación. Un valor, por si mismo,
se considera como una expresión, lo mismo ocurre para las variables.

>>> 17

17

>>> y = 3.14

>>> x = len("hello")

>>> x

>>> y

3.14

OPERADORES Y OPERANDOS

Los operadores son símbolos especiales que representan cómputos como la suma y la
multiplicación. Los valores que el operador usa se denominan operandos.

Los siguientes son expresiones válidas en Python cuyo significado es más o menos claro

20 + 32 hora - 1 hora * 60 + minuto minuto / 60 5 ** 2

(5 + 9) * (15 - 7)

Los símbolos +, - y *, y los paréntesis para agrupar, significan en Python lo mismo que en
matemáticas. El asterisco (*) es el símbolo para la multiplicación, y ** es el símbolo para la
potenciación.

>>> 2 ** 3

>>> 3 ** 2

Cuando el nombre de una variable aparece en la posición de un operando, se reemplaza

por su valor antes de realizar la operación.

La suma, resta, multiplicación y potenciación realizan lo que usted esperaría.

Ejemplo: así que vamos a convertir 645 minutos en horas:

>>> minutos = 645

>>> horas = minutos / 60

pág. 17
>>> horas

10.75

¡Uy! En Python 3, el operador de división / siempre da un resultado de punto flotante (float).

Lo que hubiera querido saber cuántas horas enteras hay y cuantos minutos quedan. Python
nos da dos versiones diferentes del operador de división. La segunda, es llamada división
entera utilizando el símbolo //. Siempre se trunca su resultado hasta el número entero
inmediatamente inferior (a la izquierda en la recta numérica).

>>> 7 / 4

1.75

>>> 7 // 4

>>> minutos = 645

>>> horas = minutos // 60

>>> horas

10

Tenga cuidado en elegir el sabor correcto del operador de división. Si está trabajando con
expresiones que usted necesita valores de punto flotante, utilice el operador de división que
realiza la división de precisión.

FUNCIONES DE TIPO CONVERTIDOR

Aquí vamos a ver otras tres funciones de Python como int, float, y str. que (intenta de)
convertir sus argumentos en tipos int, float y str respectivamente. Nosotros llamamos
funciones de tipo convertidor.

La función int puede tomar un número de punto flotante o una cadena, y convertirlo en un
int. Para los números de punto flotante, descarta la parte decimal del número - un proceso
que llamamos truncamiento a cero en la recta numérica. Vamos a ver esto en acción:

>>> int(3.14)

>>> int(3.9999) # This doesn't round to the closest int!

>>> int(3.0)

pág. 18
3

>>> int(-3.999) # Note that the result is closer to zero

-3

>>> int(minutes/60)

10

>>> int("2345") # parse a string to produce an int

2345

>>> int(17) # int even works if its argument is already an int

17

>>> int("23 bottles")

Traceback (most recent call last):

File "<interactive input>", line 1, in <module>

ValueError: invalid literal for int() with base 10: '23 bottles'

El último caso muestra que una cadena tiene que ser un número sintácticamente legal, de
lo contrario obtendrá uno de esos molestos errores de ejecución.

El convertidor de tipo float puede convertir un número entero, en floar, o una cadena
sintácticamente en un float.

>>> float(17)

17.0

>>> float("123.45")

123.45

El convertidor de tipo str convierte su argumento en una cadena:

>>> str(17)

'17'

>>> str(123.45)

'123.45'

pág. 19
ORDEN DE LAS OPERACIONES

Cuando hay más de un operador en una expresión, el orden de evaluación depende de las
reglas de precedencia. Python sigue las mismas reglas de precedencia a las que estamos
acostumbrados para sus operadores matemáticos. El acrónimo PPMDAS es útil para recordar
el orden de las operaciones:

Los Paréntesis tienen la precedencia más alta y pueden usarse para forzar la evaluación de
una expresión en el orden que usted desee. Ya que las expresiones en paréntesis se evalúan
primero, 2 * (3-1) es 4, y (1+1)**(5-2) es 8. También puede usar paréntesis para que una
expresión quede más legible, como en (minute * 100) / 60, aunque esto no cambie el
resultado.

La Exponenciación tiene la siguiente precedencia más alta, así que 2**1+1 es 3 y no 4, y

3*1**3 es 3 y no 27.

La Multiplicación y División tienen la misma precedencia, que es más alta que la de la Adición
y la Sustracción, que también tienen la misma precedencia. Así que 2*3-1 da 5 en lugar de
4, y 5-2*2 es 1, no 6.

Los operadores con la misma precedencia se evalúan de izquierda a derecha. En álgebra

nos dicen que están asociados por la izquierda. Así, que en la expresión 6-3+2, la resta se
hace primero, produciendo 3. A continuacion, añadiremos 2 para obtener el número 5. Si
las operaciones había sido evaluada de derecha a izquierda, el resultado habría sido 6-(3 +
2), que es 1. (La siglas PEDMAS podría inducir un error a pensar que la división tiene mayor
precedencia que la multiplicación, y además se lleva a cabo antes de la sustracción - No se
deje engañar suma y resta se encuentran en la misma precendencia, y se aplica la regla de
izquierda a derecha.)

Nota:

Debido a un capricho histórico, una excepción a la izquierda a derecha - izquierda asociativa

regla es el operador de exponenciación **, asi que un consejo útil es utilizar siempre
paréntesis para forzar el orden exacto que usted desea cuando se trata del exponenciación:

>>> 2 ** 3 ** 2 # el operador más a la derecha ** se hace primero!

512

>>> (2 ** 3) ** 2 # Utilizar paréntesis para forzar el orden que desea!

El indicador de modo de mando inmediato de Python es ideal para explorar y experimentar

con expresiones como esta.

OPERACIONES SOBRE CADENAS

En general, usted no puede realizar operaciones matemáticas sobre cadenas, incluso si las
cadenas están compuestas por números. Las siguientes operaciones son inválidas
(suponiendo que mensaje tiene el tipo cadena):

pág. 20
mensaje-1 "Hola"/123 mensaje*"Hola" "15"+2

Sin embargo, el operador + funciona con cadenas, aunque no calcula lo que usted esperaría.
Para las cadenas el operador + representa la operación de concatenación, que significa unir
los dos operandos enlazándolos en el orden en que aparecen. Por ejemplo:

bien_cocinado = "pan de nuez y"

fruta = "plátano"

print(bien_cocinado + fruta)

La salida de este programa es pan de nuez y plátano. El espacio antes de la palabra plátano
es parte de la cadena y sirve para producir el espacio entre las cadenas concatenadas.

El operador * también funciona con las cadenas; hace una operación de repetición. Por
ejemplo, 'Ja'*3 resulta en 'JaJaJa'. Uno de los operandos tiene que ser una cadena, el otro
tiene que ser un entero.

Estas interpretaciones de + y * tienen sentido por la analogía existente con la suma y la

multiplicación. Así como 4*3 es equivalente a 4+4+4, esperamos que "Ja"*3 sea lo mismo
que "Ja"+"Ja"+"Ja", y lo es. Sin embargo, las operaciones de concatenación y repetición
sobre cadenas tienen una diferencia significativa con las operaciones de suma y
multiplicación. ¿Puede usted pensar en una propiedad que la suma y la multiplicación tengan
y que la concatenación y repetición no?

ENTRADA (INPUT)

Hay una función integrada en Python para obtener la entrada (input) del usuario

name = input ("Por favor entre su nombre: ")

El usuario del programa puede introducir el nombre y pulsar return (volver). Cuando esto
suceda, el texto que se ha introducido es devuelto por la función de input (entrada) y en
este caso asignado a la variable de nombre.

Incluso si se le pregunta al usuario que introduzca su edad, debe regresar una cadena como
"17". Sería su trabajo, ya que el programador, para convertir esa cadena en un int o un
float, utilizando el int o float de las funciones que vimos anteriormente.

2.11. Composición

Hasta aquí hemos visto aisladamente los elementos de un programa — variables,

expresiones, y sentencias — sin especificar cómo combinarlos.

Una de las características más útiles de los lenguajes de programación es su capacidad de

tomar pequeños bloques para componer con ellos.

Por ejemplo, sabemos cómo hacer que el usuario introduzca alguna entrada (input),
sabemos cómo convertir la cadena de entrada en un flotador (float), que sabemos cómo
escribir una expresión compleja, y tambien sabemos cómo imprimir los valores. Vamos a

pág. 21
poner las fotos en un pequeño programa de cuatro pasos que le pide al usuario que
introduzca un valor para el radio de un círculo, y luego calcular el área del círculo de la
fórmula

formula del area de un círculo

En primer lugar, vamos a hacer los cuatro pasos de uno en uno:

response = input(¿Cuál es su radio?)

r = float(respuesta)

area = 3.14159 * r**2

print("El area es ", area)

Ahora vamos a componer las primeras dos líneas en una sola línea de código, y componer
las segundas dos líneas en otra línea de código.

r = float(input("¿Cuál es su radio?"))

print("El area es ", 3.14159 * r**2)

Si de verdad queremos que se ha complicado, se podría escribir todo en un solo comunicado:

print("El area es ", 3.14159*float(input("¿Cuál es su radio?"))**2)

Como el código campacto no podrá ser más comprensible para los seres humanos, pero
sirve para ilustrar cómo se puede componer grandes pedazos de bloques de nuestro efificio.

Si alguna vez le entra la duda sobre si se debe escribir código o fragmento en pasos más
pequeños, trate de hacerlo lo más simple posible para el ser humano pueda seguirlo. Mi
elección sería el primer caso, con cuatro pasos separados.

pág. 22
GLOSARIO
cadena
Un tipo de dato en Python que tiene una “cadena” de caracteres.
comentario
Información que se incluye en un programa para otro programador (o lector
del código fuente) que no tiene efecto en la ejecución.
composición
La capacidad de combinar expresiones y sentencias simples dentro de
sentencias y expresiones compuestas para representar concisamente
cálculos complejos.
concatenar
Unir dos operandos, en el orden en que aparecen.
diagrama de estado
Una representación gráfica de un conjunto de variables y los valores a los que
se refieren.
división entera
Una operación que divide un entero por otro y retorna un entero. La división
entera retorna el número de veces que el denominador cabe en el
numerador y descarta el residuo.
entero
Un tipo de dato en Python que tiene números enteros postivos y negativos.
evaluar
Simplificar una expresión ejecutando varias operaciones hasta obtener un
sólo valor.
expresión

pág. 23
Una combinación de variables, operadores y valores cuyo resultado se
representa por un único valor.
nombre de variable
Es el nombre dado a una variable. Los nombres de variables en Python
consisten en una secuencia de letras (a..z, A..Z, and _) y dígitos (0..9) que
empiezan con una letra. De acuerdo con las buenas prácticas de la
programación, los nombres de variables se eligen, de forma tal, que
describan su uso en el programa haciéndolo autodocumentado.
operador
Un símbolo especial que representa cálculos simples como la suma,
multiplicación, o concatenación de cadenas.
operador de asignación
El símbolo = es el operador de asignación de Python, que no debe
confundirse con el <em>signo igual</em>, utilizado para indicar la igualdad
matemática.
operando
Uno de los valores sobre el cual actúa un operador.

pág. 24
ERRORES SEMANTICOS

01.ERROR DE DECLARACION DE VARIABLES.

En este caso vamos a imprimir una variable que no fue previamente declarada con anterioridad
borramos la variable “resultado” de nuestro código y lo corremos.

Como vemos nos arroja un error ya que no encuentra la variable.

pág. 25
 02.REPETICION DE VARIABLES

En esta parte repetiremos una misma variable para ver si nos acepta o no las variables repetidas
en este caso la variable a repetir será “opción”.

En este casi Python si deja poner variables repetidas ya que aquí lo comprobamos no nos arrojó
ningún error y por defecto tomara la última variable que se repite.

pág. 26
 03.PONER UNA CADENA EN LA CONDICION

Aquí pondremos un if y dentro de ese ir pondremos una cadena en este caso la cadena a poner
será HOLA.

En este caso Python nos arrojara un error ya que no es compatible un entero y un string

pág. 27
 04.UTILIZAR UNA BANDERA.

En el código declaramos una variable bandera y la declaramos como “true”.

nos marcara error ya que considerara la palabra true como una variable que no está definida.

pág. 28
 05.AGREGAR UNA CADENA A NUESTRA VARIABLE RESULTADO.

En la opción número uno se le agregara una cadena en nuestra variable resultado.

Nos marcara un error de compatibilidad ya que son float y queremos sumar una cadena.

pág. 29
 06.INGRESAR UN TIPO DE DATO ERRONEO

Cambiaremos el comentario de imprime un número a imprime una cadena para que el usuario
agregue la cadena.

Nos marcara el error ya que el programa espera que se ingresara un dato numérico y no una
cadena.

pág. 30
 07.DIVISION ENTRE CERO

Aquí cambiaremos la variable de resultado por una división.

aquí haciendo la división entre cero veremos que Python si nos permite hacerla sin marcarnos
ningún error.

pág. 31
 08.MULTIPLICAR UNA CADENA POR UN ENTERO

Nos iremos a la opción 3 del código y aremos que el primer dato lo detecte como un entero y el
segundo como una cadena.

Nos daremos cuenta que si nos hace la operación de entero y cadena replicando la cadena.

pág. 32
 09 y 10. ARREGLOS DE NUMEROS ENTEROS

Aquí trabajamos sobre la opción número 15 ya que tiene un arreglo de números enteros, dentro
de ese arreglo meteremos una cadena en este caso será la cadena “hola”.

Nos daremos cuenta que al ejecutar si nos permite almacenar en un arreglo datos enteros y
cadenas al mismo tiempo.

pág. 33
Ahora intentaremos guardar un entero y una cadena al mismo tiempo en este caso será 2+” hola”.

Nos mandara error por compatibilidad.

pág. 34
CONCLUCION
El análisis semántico se trata de determinar el tipo de los resultados intermedios, comprobar que
los argumentos que tiene un operador pertenecen al conjunto de los operadores posibles si son
compatibles entre sí comprobara que le significado de lo que se vaya leyendo sea válido, en si
como hemos visto en partes del video, que un operador entero con un operador string se puede
manejar juntos sin ningún problema en el lenguaje Python, si lo vemos de otra manera en otro
lenguaje como java por ejemplo o C o C++ o C# nos marcaria una error de compilación pero
Python si lo deja realizar sin ningún problema y es lo diferente que se ha visto dentro de los
lenguajes que hemos conocido durante el transcurso de la carrera.

pág. 35
BIBLIOGRAFIA:

GUIDO VAN ROSSUMA. (SEPTIEMBRE 2009). EL TUTORIAL DE PYTHON. FRED L.

DRAKE, JR..
Cómo Pensar como un Informático: El aprender con Python . 2009, de Sitio web:
http://www.openbookproject.net/thinkcs/archive/python/thinkcspyesp3e_aba
ndonado/cap02.html

Videos de los errores semánticos:

https://www.youtube.com/watch?v=xb6OGYlXkoY

pág. 36