LAB.01
system:sage


<h1>Bienvenidas a Sage</h1>
<p>En esta asignatura usaremos el programa <strong>Sage</strong> para resolver distintos problemas de matem&aacute;ticas con el ordenador. El programa es libre, lo que nos permite copiarlo, modificarlo y redistribuirlo libremente. Sage consta de un buen n&uacute;mero de librer&iacute;as para ejecutar c&aacute;lculos matem&aacute;ticos y para generar gr&aacute;ficas. Para llamar a estas librer&iacute;as se usa el lenguaje de programaci&oacute;n <strong>python</strong>, para el que existen un buen n&uacute;mero de recursos did&aacute;cticos disponibles. Os listamos unos pocos</p>
<h4>Libros electr&oacute;nicos</h4>
<ul>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/Introduccion_a_SAGE.pdf">Introduccion_a_SAGE.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/sage-tutorial.pdf">sage-tutorial.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/sage_for_newbies_v1.23.pdf">sage_for_newbies_v1.23.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/sage-group-theory-primer.pdf">sage-group-theory-primer.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/sage_numtheory-rsa.pdf">sage_numtheory-rsa.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/hoffman-stein-calculus.pdf">hoffman-stein-calculus.pdf</a></li>
<li><a href="http://www.uam.es/personal_pdi/ciencias/pangulo/laboratorio/numerical_sage.pdf">numerical_sage.pdf</a></li>
</ul>
<h4>Links</h4>
<ul>
<li><a href="http://sagemath.org/library" target="_top">Recursos para aprender sage</a></li>
<li><a href="http://www.greenteapress.com/thinkpython/thinkpython.html">Think Python: How to Think Like a Computer Scientist</a></li>
<li><a href="http://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_2.0" target="_top">Non programmer's tutorial to python</a></li>
</ul>
<p>&nbsp;</p>
<h2>El cuaderno de apuntes</h2>
<p>SAGE es un entorno de c&aacute;lculos matem&aacute;ticos (MCE, siglas de Mathematics computing environment) que realiza c&aacute;lculos algebraicos, simb&oacute;licos y num&eacute;ricos. La comunicaci&oacute;n con el int&eacute;rprete de comandos se efect&uacute;a por medio de <em>cuadros de c&oacute;digo</em>, que contienen, en el lenguaje apropiado, l&iacute;neas que ser&aacute;n evaluadas y producir&aacute;n un resultado, visible o no. Pero tambi&eacute;n podemos acompa&ntilde;ar estos c&aacute;lculos de texto, im&aacute;genes o cualquier otro material ilustrativo, que nos permiten recrear un cuaderno de apuntes. Para ello, lanzamos SAGE con la compa&ntilde;&iacute;a de un navegador, y editamos <em>cuadros de texto</em> y <em>cuadros de c&oacute;digo</em>.</p>
<p>Antes de abrir el cuaderno por alguna hoja concreta, tenemos, en la portada${}^*$, una lista de hojas ya utilizadas y podemos acceder a abrir otras que se nos hayan facilitado (descargadas, guardadas por otro usuario, accesibles desde alg&uacute;n servidor, ...)</p>
<p><span style="font-size: small;">${}^*$ se accede a la portada pinchando sobre <a href="../" target="_blank">Home</a> en la parte superior de la hoja.</span></p>

{{{id=1|

///
}}}

<h2>Cuadros de texto</h2>
<p>Los cuadros de texto como este permiten incluir comentarios en una  hoja de trabajo. Si haces doble click sobre el cuadro de texto puedes  editar el contenido. Al cambiar a modo de edici&oacute;n, aparecen botones y  desplegables para cambiar algunos aspectos del estilo del texto. Lo m&aacute;s  importante para mantener un orden en la hoja de trabajo es el primer  desplegable, que permite elegir si se trata de un p&aacute;rrafo, un  encabezado.</p>

{{{id=2|

///
}}}

<h2>Cuadros de c&oacute;digo</h2>
<p>Los cuadros de c&oacute;digo son rectagulares y su borde cambia de color al  seleccionarlos. Dentro de los cuadros de c&oacute;digo podemos escribir &oacute;rdenes  que ser&aacute;n ejecutadas al pulsar el bot&oacute;n evaluate o pulsar<em> may&uacute;sculas+Enter</em>.</p>
<p>Puedes crear un nuevo cuadro de c&oacute;digo pulsando sobre la l&iacute;nea azul  que aparece al poner el cursor ligeramente por encima de un cuadro de c&oacute;digo existente, o  pulsando <em>control+Enter</em> dentro de un cuadro de c&oacute;digo. Puedes  crear un nuevo cuadro de texto pulsando sobre la misma l&iacute;nea azul, pero  manteniendo pulsada la tecla de may&uacute;sculas.</p>

{{{id=3|

///
}}}

<h3>Tarea 1</h3>
<ul>
<li>Crea, desde la portada, una hoja nueva.</li>
<li>N&oacute;mbrala con el formato <em>nombre.apellidos_ejercicio1.1</em></li>
<li>Copia el enunciado de esta tarea.</li>
<li>Resuelve, a su debido tiempo, el resto de tareas de la sesi&oacute;n de hoy.</li>
<li>Guarda la hoja y env&iacute;ala por correo electr&oacute;nico al profesor.</li>
</ul>

{{{id=4|

///
}}}

<p>Si ponemos varias l&iacute;neas de c&oacute;digo, se ejecutan una tras otra de arriba a abajo. El <strong>int&eacute;rprete de instrucciones</strong> lee las instrucciones, las interpreta y ejecuta lo que se le pide. Algunas instrucciones producen una <em>salida,</em> que se muestra debajo del cuadro de c&oacute;digo.</p>
<p>&nbsp;</p>
<p><em>Ejecuta el c&oacute;digo siguiente, para ello sit&uacute;a el cursor dentro del mismo y pulsa evaluate o teclea May.+Enter. &iquest;Encuentras algo a faltar en la respuesta?</em></p>

{{{id=14|
print 'Hola, mundo'
2+2
print 3<4
4^5-6
///
}}}

<p>Dentro de un cuadro de c&oacute;digo, cualquier l&iacute;nea que comience con el car&aacute;cter # no ser&aacute; evaluada por el int&eacute;rprete.</p>
<p><em>Ejecuta el c&oacute;digo siguiente.</em></p>

{{{id=5|
print 2+2 #Ahora sí me lo muestra

print 'Mi primera gráfica'
#El comando plot esboza y nos muestra diversos objetos,
#en este caso la gráfica de una función de una variable.
plot(x*(x^2-3),-2,2)
///
}}}

<h3>Uso como calculadora</h3>
<p>Podemos usar los bloques de c&oacute;digo como una simple calculadora,  escribiendo operaciones aritm&eacute;ticas y observando el resultado debajo del  cuadro. Podemos introducir n&uacute;meros con decimales usando el punto  decimal. Los par&eacute;ntesis marcan qu&eacute; operaci&oacute;n se ejecuta antes,  naturalmente. Podemos anidar par&eacute;ntesis si es necesario, pero no se  pueden usar corchetes ni llaves, caracteres estos reservados a otros prop&oacute;sitos.</p>

{{{id=6|
(1*2)+(3*4)+5
///
}}}

{{{id=7|
1*(2+3)*(4+5)
///
}}}

{{{id=8|
(1*(2+3)*4)+5
///
}}}

<h3>Operaciones booleanas</h3>
<p style="text-align: left;">Aparte de las operaciones de la artim&eacute;tica elemental, se puede operar con valores booleanos: True y False. Las operaciones son:</p>
<table style="text-align: left;" border="1">
<tbody>
<tr>
<td><strong>and</strong></td>
<td><em>True</em></td>
<td><em>False</em></td>
<td>&nbsp;&nbsp;&nbsp;</td>
<td>&nbsp;&nbsp;&nbsp;</td>
<td><strong>or</strong></td>
<td><em>True</em></td>
<td><em>False</em></td>
<td>&nbsp;&nbsp;&nbsp;</td>
<td>&nbsp;&nbsp;&nbsp;</td>
<td>&nbsp;</td>
<td><strong>not</strong></td>
</tr>
<tr>
<td><em>True</em></td>
<td>True</td>
<td>False</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td><em>True</em></td>
<td>True</td>
<td>True</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td><em>True</em></td>
<td>False</td>
</tr>
<tr>
<td><em>False</em></td>
<td>False</td>
<td>False</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td><em>False</em></td>
<td>True</td>
<td>False</td>
<td>&nbsp;</td>
<td>&nbsp;</td>
<td><em>False</em></td>
<td>True</td>
</tr>
</tbody>
</table>
<p>&nbsp;</p>
<h3>Reglas de precedencia</h3>
<p>Se ha de tener en cuenta que, en ausencia de par&eacute;ntesis, SAGE decide qu&eacute; operaciones se ejecutan  antes y cu&aacute;les se ejecutan despu&eacute;s.&nbsp; Se siguen una reglas fijas conocidas  como <em>reglas de precedencia de operadores</em>.</p>
<p>&nbsp;</p>
<h3><em>Ejercicio<br /></em></h3>
<ul>
<li>Intenta predecir el resultado de ejecutar las instrucciones de debajo antes de pulsar el bot&oacute;n de evaluar.</li>
<li>Eval&uacute;alas.</li>
<li>Indaga sobre las reglas de precedencia seguidas en cada caso.</li>
</ul>

{{{id=124|
print 2^3
2**4
///
}}}

{{{id=26|
2*3^1+1*3^2
///
}}}

{{{id=32|
2*3^(1+1)*3^2
///
}}}

{{{id=33|
-2*3-1
///
}}}

{{{id=34|
-2*(3-1)
///
}}}

{{{id=35|
-(2*3-1)
///
}}}

{{{id=91|
True or False
///
}}}

{{{id=19|
True or True and False
///
}}}

{{{id=31|
(True or True) and False
///
}}}

{{{id=92|
1==2-1
///
}}}

{{{id=30|
2 < 3 and 1 == 2
///
}}}

{{{id=29|
2 < 3 and not 1 == 2
///
}}}

{{{id=37|
(not 2 < 3) and 1 == 2
///
}}}

{{{id=62|
not ( 2 < 3 and 1 == 2 )
///
}}}

{{{id=93|
not  2 < 3 and 1 == 2
///
}}}

<p>La regla m&aacute;s importante: <em>en caso de duda, usa par&eacute;ntesis</em>.</p>

<h3>Tarea 2</h3>
<ul>
<li>Abre la hoja de ejercicios de esta sesi&oacute;n. Copia y resuelve los dos primeros en tu hoja de entrega.</li>
</ul>

<h3>Funciones</h3>
<p>Adem&aacute;s de las operaciones aritm&eacute;ticas, podemos usar las muchas funciones disponibles. Por ejemplo, seno (<span style="font-family: courier new,courier;">sin</span>), coseno (<span style="font-family: courier new,courier;">cos</span>), exponencial (<span style="font-family: courier new,courier;">exp</span>). La forma de usarlas es escribir el nombre de la funci&oacute;n, seguido del argumento entre par&eacute;ntesis.</p>

{{{id=68|
sin(pi/3)
///
}}}

{{{id=64|
(1+sin(pi/3))/2
///
}}}

{{{id=38|
cos(0.032)*exp(-0.5)
///
}}}

{{{id=128|
pi.n()
///
}}}

<p>Incluso esbozar sus gr&aacute;ficas:</p>

{{{id=136|
plot(sin(x),-pi,pi)
///
}}}

<h2>Variables</h2>
<p>Las variables permiten almacenar el valor de un c&oacute;mputo en la  memoria, y utilizar ese valor posteriormente. Para guardar el valor de  una expresi&oacute;n dentro de una variable, usamos la sintaxis:</p>
<pre><span style="font-size: x-large;">variable = expresion</span><br /></pre>
<p>Por ejemplo,</p>
<pre><span style="font-size: x-large;">numero = 1+2+3+4+5+6<br />largo = 2.56*20<br />angulo = pi/3</span><br /></pre>
<p>Para poder ver el valor de una variable podemos usar el comando <span style="font-size: large;"><strong><span style="font-family: courier new,courier;">print</span></strong></span>:</p>
<pre><span style="font-size: x-large;">print numero<br />print largo, angulo<br />print largo * sin(angulo)</span></pre>
<p>Una vez hemos guardado un valor en una variable, podemos hacer c&aacute;lculos con el valor de la variable:</p>
<pre><span style="font-size: x-large;">masa = 3<br />aceleracion = 10<br />fuerza = masa*aceleracion<br />print fuerza<br /></span></pre>

{{{id=134|

///
}}}

{{{id=79|
numero = 1+2+3+4+5+6
largo = 2.56*20
angulo = pi/3
///
}}}

{{{id=78|
print numero
print largo, angulo
print largo * sin(angulo)
///
}}}

{{{id=65|
distancia = 2.56*20
print distancia
///
}}}

<p><em>Nota</em>: los nombres de las variables deben empezar por una letra o un gui&oacute;n bajo (_), pueden contener n&uacute;meros, y son distintos si se usan may&uacute;sculas o min&uacute;sculas. <em>Las variables </em><span style="font-family: courier new,courier;">distancia</span><em> y </em><span style="font-family: courier new,courier;">Distancia</span><em> son distintas</em>.</p>

{{{id=59|
print Distancia
///
}}}

<h4>Ejemplo: &aacute;rea y per&iacute;metro de una circunferencia</h4>
<p>Guardamos en una variable el valor del radio, luego calculamos y guardamos en dos variables el &aacute;rea y el per&iacute;metro, y escribimos el resultado:</p>

{{{id=43|
radio = 5
///
}}}

{{{id=45|
area = pi * radio^2
perimetro = 2*pi*radio
print 'Area:', area
print 'Perimetro:', perimetro
///
}}}

<p><em>Salida num&eacute;rica</em>: para obtener valores aproximados de n&uacute;meros irracionales, podemos usar el m&eacute;todo .<strong>n()</strong></p>

{{{id=61|
print 'Area: ', area.n()
print 'Perimetro: ', perimetro.n()
///
}}}

<h3>Actualizar una variable</h3>
<p>Con bastante frecuencia se realiza un c&aacute;lculo que depende del valor de una variable, y se asigna el resultado a esa misma variable. Aunque conceptualmente no suponga ning&uacute;n problema, la sintaxis suele confundir cuando se ve por primera vez. Por ejemplo:</p>
<pre><span style="font-size: x-large;">k=k+1</span></pre>
<p>realiza el c&aacute;lculo consistente en sumar 1 al valor de la variable <span style="font-family: courier new,courier;">k</span>, y despu&eacute;s guarda dentro de la variable <span style="font-family: courier new,courier;">k</span> el resultado de la operaci&oacute;n.</p>
<p><em>Atenci&oacute;n</em>: Se ha de tener en cuenta que, en la sintaxis habitual de los lenguajes de programaci&oacute;n, un s&iacute;mbolo igual '=' se utiliza para asignar valores a variables, y no para escribir una ecuaci&oacute;n.</p>

{{{id=69|
k = 5
print k
k = k + 1
print k
///
}}}

<h3>Liberar una variable</h3>
<p>Usando el comando <span style="font-size: large;"><span style="font-family: courier new,courier;"><strong>del</strong></span></span>, podemos liberar una variable, y a partir de ese punto el nombre de la variable deja de estar definido.</p>
<pre><span style="font-size: x-large;">del variable</span><br /></pre>

{{{id=122|
numero = 12
print 2*numero
///
}}}

{{{id=121|
del numero
print 3*numero
///
}}}

{{{id=130|
factorial (1000)/factorial (1001)
///
}}}

<h2>Tipos de datos</h2>
<p>En las variables podemos almacenar cualquier tipo de datos que resulte de evaluar una expresi&oacute;n. La funci&oacute;n <span style="font-family: courier new,courier;"><strong>type()</strong></span> nos informa del tipo de datos que estamos manejando.</p>
<p>M&aacute;s adelante en el curso, guardaremos en las variables vectores,  matrices e incluso gr&aacute;ficas. Por ahora hemos usado los siguientes tipos  de datos:</p>
<ul>
<li>Booleanos: s&oacute;lo toman el valor <span style="font-size: large;"><span style="font-family: courier new,courier;">True</span></span> o<span style="font-size: large;"> <span style="font-family: courier new,courier;">False</span></span>.</li>
<li>Enteros: cualquier n&uacute;mero entero, positivo o negativo, de longitud arbitraria. Ejemplos: 1, 10, -30</li>
<li>Racionales como: 1/2, -3/4</li>
<li>N&uacute;meros de coma flotante: un n&uacute;mero con unos cuantos d&iacute;gitos  decimales y un exponente, que representa un n&uacute;mero real de forma  aproximada. Ejemplos: 1.25, -1.5e6</li>
<li>Expresiones simb&oacute;licas: expresiones matem&aacute;ticas que representan  n&uacute;meros reales de forma exacta. Ejemplos: pi/4 ($\pi/4$), (1+sqrt(2))/2  ($\frac{1+\sqrt{2}}{2}$)</li>
</ul>

{{{id=94|
Test1=2 >=3
Test1, type(Test1)
///
}}}

{{{id=72|
var1=2
var2=3
es_menor = var1 < var2
///
}}}

{{{id=81|
print es_menor
///
}}}

{{{id=95|
factorial(1000)
///
}}}

{{{id=86|
numero = factorial(1000)
type(numero)
///
}}}

{{{id=84|
numero/factorial(1001)
///
}}}

{{{id=139|
floor(pi^(10)), floor(-pi^(10))
///
}}}

<h3>N&uacute;meros de coma flotante y expresiones simb&oacute;licas</h3>
<p>Al usar el ordenador para hacer matem&aacute;ticas es importante saber si los datos del ordenador representan los objetos matem&aacute;ticos de forma exacta.</p>
<p>Es imposible almacenar en un ordenador, con una cantidad finita de memoria, todas las cifras decimales del n&uacute;mero <strong>pi</strong>. Una alternativa es almacenar s&oacute;lo unas cuantas cifras, y cometer por tanto un peque&ntilde;o error. Para la mayor&iacute;a de las aplicaciones es m&aacute;s que suficiente usar 10 o 20 <em>cifras decimales significativas</em>. Con esto queremos decir que al escribir el n&uacute;mero en notaci&oacute;n exponencial, descartamos todas las cifras a partir de la n&uacute;mero 10. Por ejemplo, el n&uacute;mero $1/\pi$ con diez d&iacute;gitos significativos:</p>
<p>$$</p>
<p>3.183098861 \cdot 10^{-1}</p>
<p>$$</p>
<p>y la constante de Planck con seis d&iacute;gitos significativos:</p>
<p>$$</p>
<p>6.62606 \cdot 10^{-34}</p>
<p>$$</p>
<p>Al hacer operaciones con n&uacute;meros que contienen errores, los errores se suman y multiplican, y pueden acabar estropeando un c&aacute;lculo. Otra alternativa es usar una variable simb&oacute;lica, y no hacer los c&aacute;lculos, exactamente igual que os contaban en el instituto:</p>
<p>$$</p>
<p>\frac{\sqrt[3]{2}\cdot 3^2}{\frac{3 \cdot 4}{\sqrt[3]{4}}}= 2^{1/3-2+2/3}3^{2-1}=2^{-1}3=3/2</p>
<p>$$</p>
<p>Al estar orientado preferentemente al p&uacute;blico matem&aacute;tico, Sage prefiere usar expresiones simb&oacute;licas exactas antes que resultados num&eacute;ricos. Como vimos antes, para obtener una representaci&oacute;n decimal de una expresi&oacute;n simb&oacute;lica, podemos usar el m&eacute;todo <strong>.n()</strong> (n de num&eacute;rico).</p>

{{{id=76|
1/pi
///
}}}

{{{id=46|
(1/pi).n()
///
}}}

{{{id=119|
a = sqrt(2)
///
}}}

{{{id=120|
a.n()
///
}}}

{{{id=118|

///
}}}

<h3>M&eacute;todos espec&iacute;ficos de cada tipo de datos</h3>
<p>Cada tipo de datos tiene sus propios m&eacute;todos: funciones que se  aplican s&oacute;lo a datos de este tipo y que se llaman escribiendo primero la  variable que contiene el dato, despu&eacute;s un punto (.) y, por &uacute;ltimo, el  m&eacute;todo:</p>
<pre><span style="font-size: x-large;">variable.metodo()</span></pre>
<p>Por ejemplo, podemos calcular la factorizaci&oacute;n de un n&uacute;mero entero,  pero no de un n&uacute;mero real, o podr&iacute;amos intentar simplificar una  expresi&oacute;n simb&oacute;lica, pero no podemos simplificar un n&uacute;mero entero.</p>

{{{id=110|
a = 12
print a.factor()                #Factorizacion del entero 'a'
///
}}}

{{{id=111|
b = 4.7
print b.integer_part()            #Parte entera del numero real 'b'
///
}}}

{{{id=117|
c = (3*sqrt(6)+sqrt(2))/sqrt(8)
print c.full_simplify()            #Intenta simplificar la expresion 'c'
///
}}}

{{{id=115|
print b.factor()
///
}}}

{{{id=116|
print a.full_simplify()
///
}}}

{{{id=113|

///
}}}

<h3>N&uacute;meros de Sage y de python</h3>
<p>Aunque Sage utiliza el lenguaje python, los tipos num&eacute;ricos en Sage no corresponden exactamente a los tipos num&eacute;ricos de python, ya que los n&uacute;meros en Sage tienen m&aacute;s funcionalidad. Por ejemplo, los enteros de Sage permiten calcular su lista de divisores, su expresi&oacute;n binaria, etc&eacute;tera. Por defecto, los tipos num&eacute;ricos son enteros, racionales y numeros reales de Sage, no de python.</p>

{{{id=96|
a = 12          #Entero de Sage
#a = Integer(12) #Otra forma equivalente de definir un entero de Sage
b = int(12)     #Entero de 32 bits de python
///
}}}

{{{id=99|
print a.divisors(), a.digits(base = 2)
///
}}}

{{{id=98|
print b.divisors()
///
}}}

{{{id=104|
c = 1.2                #Real de Sage (de precision limitada)
c = RealNumber(1.2)    #Otra forma equivalente de definir un real de Sage
d = float(1.2)         #Real de 64 bits de python
///
}}}

{{{id=105|
d.exact_rational()
///
}}}

{{{id=106|
c.exact_rational()
///
}}}

{{{id=74|

///
}}}

<h2>Mostrar informaci&oacute;n por pantalla</h2>
<p>Para poder ver en pantalla los valores de las variables, hemos usado el comando <strong><span style="font-family: courier new,courier;">print</span></strong>.</p>
<pre><span style="font-size: x-large;">print var1<br />print var1, var2, ...</span></pre>
<p>De esta forma podemos mostrar los valores de las variables. Tambi&eacute;n podemos escribir texto que contenga los valores de estas variables usando el operador<strong> <span style="font-family: courier new,courier;">%</span></strong> y los c&oacute;digos de formato. Para usarlo, escribimos una cadena que contiene c&oacute;digos de formato seguida del operador <span style="font-family: courier new,courier;">% </span>y a continuaci&oacute;n las variables que queremos sustituir dentro de la cadena. Si hay m&aacute;s de una variable, los escribimos dentro de parent&eacute;sis, y separados por comas. Ejemplos:</p>
<pre style="padding-left: 30px;"><span style="font-size: x-large;">lados = 8<br />print 'El n&uacute;mero de lados es %d'%lados<br />area = 17.5<br />print 'El &aacute;rea es %f'%area<br />print 'El &aacute;rea del pol&iacute;gono de %d lados es %f'%(lados, area)<br />nombre = 'Juan'<br />print '%s vino ayer a cenar'%nombre</span><br /></pre>
<p>Los c&oacute;digos m&aacute;s usuales son:</p>
<ul>
<li><strong><span style="font-size: large;"><span style="font-family: courier new,courier;">%d</span></span> </strong>: n&uacute;mero entero</li>
<li><span style="font-size: large;"><strong><span style="font-family: courier new,courier;">%f</span> </strong></span>: n&uacute;mero de coma flotante, con decimales</li>
<li><span style="font-size: large;"><strong><span style="font-family: courier new,courier;">%.3f</span></strong></span> : n&uacute;mero de coma flotante, con 3 decimales exactamente</li>
<li><span style="font-size: large;"><strong><span style="font-family: courier new,courier;">%s</span> </strong></span>: cadena de caracteres</li>
</ul>

{{{id=51|
lados = 8
print 'El número de lados es %d'%lados

area = 17.5
print 'El área es %.3f'%area

print 'El área del polígono de %d lados es %f'%(lados, area)

nombre = 'Juan'
print '%s vino ayer a cenar'%nombre
///
}}}

<h3>Tarea 3</h3>
<ul>
<li><span id="cell_outer_133"> Copia y resuelve </span>el resto de ejercicios propuestos, <span id="cell_outer_133">en tu hoja de entrega.</span></li>
<li><span id="cell_outer_133">Entrega 24 horas antes de la siguiente sesi&oacute;n.<br /></span></li>
</ul>

{{{id=73|

///
}}}

{{{id=131|

///
}}}

{{{id=133|

///
}}}

{{{id=137|

///
}}}

{{{id=138|

///
}}}