a = 42        #entero
b = 3.1416    #real
bexp = 3.14e0 #exponencial
c = 3+7j      #complejo
d = "Ejemplo de cadena de caracteres " # Cadena de caracteres, podría haberse definido exactamente igual con comillas simples: ' al principio y al final.
e = True      #lógica o booleana. Sólo admite dos valores: True o False.

#Imprimir por pantalla
print (a,b,bexp,c,d,e)

#Tipos de variables
print (type(a))
print (type(b))
print (type(bexp))
print (type(c))
print (type(d))
print (type(e))

42 3.1416 3.14 (3+7j) Ejemplo de cadena de caracteres  True
<class 'int'>
<class 'float'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bool'>

a,b=7.0,5.0

# Operadores aritméticos.
suma=a+b
resta=a-b
multip=a*b
div=a/b
div_entera=a//b
exp=a**b
modulo=a%b # resto de la división

print('a=',a,'b=',b)
print('Operadores aritméticos')
print("a+b=",suma)
print("a-b=",resta)
print("a*b=",multip)
print("a/b=",div)
print("División entera a/b=",div_entera)
print("a^b=",exp)
print("a modulo b", modulo)
print("")

# Operadores de comparación.
igual = a==b
distinto = a!=b
mayor = a>b
menor = a<b
mayoroigual = a>=b
menoroigual = a<=b

print('a=',a,'b=',b)
print("Operadores de comparación")
print('a==b', igual)
print('a!=b', distinto)
print('a>b', mayor)
print('a<b', menor)
print('a>=b', mayoroigual)
print('a<=b', menoroigual)
print("")

# Operadores lógicos.
ylogico = a>b and b>1.0
ologico = a<b or b>7.0
nologico = not(a<b or b>7.0)

print('a=',a,'b=',b)
print("Operadores lógicos")
print("a>b Y b>1.0", ylogico)
print("a<b O b>7.0", ologico)
print("niega(anterior)", nologico)
print("")

lista = [1.0, 2.0, 5.0, 9.0] # Más adelante se verá qué tipo de datos representa una lista.
#operadorees de pertenencia.
pertenece = a in lista
nopertenece = b not in lista

print("a=", a, "b=", b, "lista = ", lista)
print("Operadores de pertenencia")
print("a pertenece a lista", a in lista)
print("b no pertenece a lista", b not in lista)

a= 7.0 b= 5.0
Operadores aritméticos
a+b= 12.0
a-b= 2.0
a*b= 35.0
a/b= 1.4
División entera a/b= 1.0
a^b= 16807.0
a modulo b 2.0

a= 7.0 b= 5.0
Operadores de comparación
a==b False
a!=b True
a>b True
a<b False
a>=b True
a<=b False

a= 7.0 b= 5.0
Operadores lógicos
a>b Y b>1.0 True
a<b O b>7.0 False
niega(anterior) True

a= 7.0 b= 5.0 lista =  [1.0, 2.0, 5.0, 9.0]
Operadores de pertenencia
a pertenece a lista False
b no pertenece a lista False

a= "Hola\n"
b = "\t Este es un ejemplo de cadena de caracteres \n"
c = """        Es posible escribir saltos de linea sin necesidad de utilizar los códigos
de escape"""

print(a,b,c)
print('\n') # Salto de línea mediante \n.

d= a + b #concatenación
e = " repite "
f = 3*e #repetición
g = e*3 #equivale a lo anterior

print(d,f,g)

z = '\t Para escribir comillas, se usa \' y \".' # Tabulador mediante \t.
print('\n')
print(z)

Hola
 	 Este es un ejemplo de cadena de caracteres 
         Es posible escribir saltos de linea sin necesidad de utilizar los códigos
de escape


Hola
	 Este es un ejemplo de cadena de caracteres 
  repite  repite  repite   repite  repite  repite 


	 Para escribir comillas, se usa ' y ".

# Usos del if
'''
Ejemplo: ¿contiene la variable un número negativo?
'''
print("Ejemplo 1: usos del if")
a=-27.0
if a<0.0: # Nótese el ":" al final de la línea.
    print(a," es un número negativo.") # Línea indentada, se ejecuta si a<0.0
elif a==0: # Nueva orden de control, se ejecuta sólo si no se ha ejecutado el primer "if"
    print(a," es nulo.") # Línea indentada, se ejecuta si a==0.0
else: # Nueva orden de control, se ejecuta si no se ejecutado ningún "if" o "elif" previo
    print(a," es un número positivo.") # Línea indentada, se ejecuta si a>0.0

print("") # Línea no indentada, se recupera el flujo previo del programa, la estructura de control termina antes de que se ejecute esta línea.

'''
Ejemplo: utilizando la función isintance() nos preguntamos si la variable
a contiene un número real
'''
print("Ejemplo 2: usos del if")
a=37.3 + 2.1j
print(a, "Tipo de variable=",type(a))
if isinstance(a,float):
    print(a," es un número real")
else:
    print(a," no es un número real")

Ejemplo 1: usos del if
-27.0  es un número negativo.

Ejemplo 2: usos del if
(37.3+2.1j) Tipo de variable= <class 'complex'>
(37.3+2.1j)  no es un número real

#Bucle for
'''
Ejemplo: utilizando el método range proporciona una lista de números,
comprobamos si un número es postivo o negativo
'''
print("Ejemplo 1: bucle for")

rango=list(range(-5,5)) # Más adelante se verá qué hace el método list.
# range(inicio, fin, paso) crea una secuencia de números (convertida a lista en el ejemplo anterior) que empiezan en inicio, se incrementan de paso en paso y termina justo
# antes de llegar a fin. Por defecto, paso=1 (si no se indica) e inicio=0 (si no se indica).

print("De los siguientes números ",rango,"se comprueba cuáles son negativos")
for a in range(-5,5): # Nótese el ":" al final de la línea.
    if a<0.0: # Estructura de control anidada dentro de otra.
        print(a," es un número negativo.")  # Se ejecuta sólo si a<0.0 dentro de un bucle que barre entre -5 y +5 de 1 en uno.
    print("Se estudiaba: ", a) # Se ejecuta dentro del bucle "for", pero no del "if", ni del flujo principal.

'''
Ejemplo: una forma compacta de escribir el mismo loop..
'''
print("") # Se recupera el flujo principal del programa.
print("Ejemplo 2: bucle for")

[print(a," es un número negativo.") for a in range(-5,5) if(a < 0.0)]

'''
Ejemplo: Python permite bucles en cualquier objeto que sea iterable
'''
print("")
print("Ejemplo 3: bucle for")

lista = ["manzana","pera","gato"] # Más adelante se verá qué tipo de dato representa lista

for palabra in lista:
    print(palabra)

Ejemplo 1: bucle for
De los siguientes números  [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] se comprueba cuáles son negativos
-5  es un número negativo.
Se estudiaba:  -5
-4  es un número negativo.
Se estudiaba:  -4
-3  es un número negativo.
Se estudiaba:  -3
-2  es un número negativo.
Se estudiaba:  -2
-1  es un número negativo.
Se estudiaba:  -1
Se estudiaba:  0
Se estudiaba:  1
Se estudiaba:  2
Se estudiaba:  3
Se estudiaba:  4

Ejemplo 2: bucle for
-5  es un número negativo.
-4  es un número negativo.
-3  es un número negativo.
-2  es un número negativo.
-1  es un número negativo.

Ejemplo 3: bucle for
manzana
pera
gato

# Bucle while
'''
Ejemplo: Se representan los números pares empezando por 2 hasta llegar al número 20 (incluido).
OJO: los bucles while producen fácilmente bucles infinitos. En el ejemplo 1, esto ocurriría si se eliminase
la condición de salir del bucle (break) cuando el número se haga mayor que 20. En el ejemplo 2, la condición para
terminar se incluye en la definición del bucle mediante un operador lógico.
'''
print("Ejemplo 1: bucle while")

nopar=2
while (nopar > 0): # Nótese el ":" al final de la línea.
    print (nopar) # Se ejecuta con el bucle "while".
    nopar = nopar + 2 # Se ejecuta con el bucle "while".
    if (nopar > 20): # Estructura de control anidada dentro de otra.
        break # Termina el proceso de ejecución del bucle "padre" (dentro del que estaba anidado el "if"; es decir, el "while") y se sigue con el flujo principal.

print("")
print("Ejempo 2: bucle while")
nopar=2
while (nopar > 0 and nopar <= 20): # En esta versión, la terminación del bucle viene indicada en su propia condición.
    print (nopar)
    nopar = nopar + 2

Ejemplo 1: bucle while
2
4
6
8
10
12
14
16
18
20

Ejempo 2: bucle while
2
4
6
8
10
12
14
16
18
20

# Tuplas
'''
Una tupla es una secuencia inmutable y ordenada de elementos que pueden estar duplicados. Pueden ser de
de cualquier tipo (básico o no). Se pueden indexar.
Sintaxis para declarar una tupla: especificar los elementos separados por una coma (,)
'''
tupla_vacia = ( )
tupla1 = 1, 1, 3, 4 , 6,
tupla1b = (1 , 1 , 3 , 4 , 6)
tupla2 = "hola" , 2 ,3
tupla3 = tupla2 , 90
tupla4 = tuple ("ejemplo")

print("Tuplas")
print(tupla1)
print(tupla1[0:2])
print(tupla1b)
print(tupla2)
print(tupla3)
print(tupla4)

Tuplas
(1, 1, 3, 4, 6)
(1, 1)
(1, 1, 3, 4, 6)
('hola', 2, 3)
(('hola', 2, 3), 90)
('e', 'j', 'e', 'm', 'p', 'l', 'o')

# Listas
'''
Una lista es una secuencia mutable y ordenada de elementos que pueden estar duplicados. Pueden ser de
cualquier tipo (básico o no). Sus elementos
se pueden modificar a diferencia de las tuplas. Se pueden indexar.
Sintaxis para declarar una lista: los elementos de la lista se separan usando comas.
Se especifica que es una lista cerrando el conjunto entre corchetes [,].
'''
lista_vacia = []
lista1 = [1 ,1 ,3 ,4 ,6]
lista2 = ["hola" , 2 ,3]
lista3 = lista2+[90]
lista3b = [lista3, 10]
lista4 = list("ejemplo")
print("Listas")
print(lista1)
print(lista1[0:2])
print("lista2=",lista2)
print(lista3)
print(lista3b)
print(lista4)
# Se cambia un valor. Con una tupla daría error.
lista1[1] = 2
print(lista1)
# Se define una lista a partir de otra, operando sobre los elementos de la primera.
#
print("Métodos para definir una lista, mediante una operación sobre otra. Ejemplo con el cuadrado de lista1.")
# Forma compacta. Comprensión de listas.
lista5 = [x*x for x in lista1]
print("Comprensión de listas", lista5)
# Bucle for actuando mediante adicción de elementos a una lista inicialmente vacía.
lista6=[]  # Lista vacía. Se obtendrá el mismo resultado que con lista5
for x in lista1:
  lista6.append(x*x) # Se le añaden elementos a lista6 en cada iteración del bucle.
print("Bucle for", lista6)
# Método funcional. Se aplica (map) la función (lambda x: x*x en este caso) a cada elemento de lista1 
# que pasa a ser el argumento x de lambda.
# El resultado es una secuencia que se convierte a lista.
lista7=list(map(lambda x: x*x, lista1)) # La función lambda es una función anónima introducida 
                                        # en las reglas del cálculo matemático formal.
print("Método funcional", lista7)

Listas
[1, 1, 3, 4, 6]
[1, 1]
lista2= ['hola', 2, 3]
['hola', 2, 3, 90]
[['hola', 2, 3, 90], 10]
['e', 'j', 'e', 'm', 'p', 'l', 'o']
[1, 2, 3, 4, 6]
Métodos para definir una lista, mediante una operación sobre otra. Ejemplo con el cuadrado de lista1.
Comprensión de listas [1, 4, 9, 16, 36]
Bucle for [1, 4, 9, 16, 36]
Método funcional [1, 4, 9, 16, 36]

# Conjuntos
'''
Un conjunto es una secuencia inmutable y desordenada de elementos que no se pueden repetir. Pueden ser de
de cualquier tipo (básico o no). No se pueden indexar. Aunque no se pueden modificar sus elementos, sí que
se pueden añadir y eliminar.
Sintaxis para declarar un conjunto: especificar los elementos separados por una coma y encerrados por llaves {,}.
'''
conjunto_vacio = set() # Atención al diccionario vacío
conjunto1 = {1, 1, 3, 4 ,6}
conjunto1b = {1 , 3 , 4 , 6}
conjunto2 = {"hola" , 2 ,3}
conjunto3 = set(("ejemplo", "este"))
conjunto4 = set("ejemplo")
conjunto5 = set("templo")

print("Conjuntos")
print(conjunto1)
print(conjunto1b)
print(conjunto2)
print(conjunto3)
print(conjunto4)
print(conjunto5)
print("Conjunto - Intersección con otro conjunto", conjunto4 - conjunto5) # Elmentos que pertenecen a conjunto4 pero no a conjunto5.
print("Unión", conjunto4 | conjunto5) # Unión de conjunto4 y conjunto5.
print("Intersección", conjunto4 & conjunto5) # Intersección de conjunto4 y conjunto5.
print("Unión - Intersección", conjunto4 ^ conjunto5) # Unión de conjunto4 y conjunto5 menos su intersección.
conjunto4.remove('j')
print("Eliminar j de conjunto4", conjunto4)
conjunto4.add('s')
print("Añadir s a conjunto4", conjunto4)

Conjuntos
{1, 3, 4, 6}
{1, 3, 4, 6}
{2, 3, 'hola'}
{'este', 'ejemplo'}
{'e', 'l', 'p', 'j', 'm', 'o'}
{'e', 'l', 't', 'p', 'm', 'o'}
Conjunto - Intersección con otro conjunto {'j'}
Unión {'e', 'l', 't', 'p', 'j', 'm', 'o'}
Intersección {'e', 'l', 'p', 'm', 'o'}
Unión - Intersección {'t', 'j'}
Eliminar j de conjunto4 {'e', 'l', 'p', 'm', 'o'}
Añadir s a conjunto4 {'e', 'l', 's', 'p', 'm', 'o'}

# Diccionarios
'''
Un diccionario es una secuencia de pares de elementos (el primero de cada par se llama clave y el segundo valor) ordenada,
en la que los valores se pueden modificar pero las claves no y que no admiten repeticiones de las claves. Las claves funcionan
como índices de los valores y pueden ser añadidas o eliminadas junto con su respectivo valor.
Sintaxis para declarar un diccionario: los elementos de cada par van separados entre sí por : mientras que los distintos pares van
separados por comas y encerrados entre llaves {:, :, :}
'''
diccionario_vacio={} # Atención que no sirve para declarar el conjunto vacío.
diccionario1={'rojo':'red', 'negro':'black', 'azul':'blue'}
diccionario2={'rojo':'red', 'negro':'noir', 'negro':'black', 'azul':'blue'}
diccionario3=dict(rojo = 'red', negro = 'black', azul = 'blue')
diccionario4={'j':'jurídico','s':'sanidad','i':'intervencion','m':'música','e':'eclesiástico'}
diccionario4b={'if':'infantería','cb':'caballería','ar':'artillería','ig':'ingenieros','tr':'transmisiones','av':'aviet'}
diccionario5={'cuerpos':diccionario4, 'armas':diccionario4b} # Diccionarios anidaddos.

print("Diccionarios")
print(diccionario1)
print(diccionario2) # Con claves repetidas, sólo se toma el último valor que aparezca para una clave dada.
print(diccionario3)
print("Negro en inglés se dice ", diccionario1['negro'])
diccionario1['rojo'] = 'rouge' # Cambio de los valores para cada clave.
diccionario1['negro'] = 'noir'
diccionario1['azul'] = 'bleu'
print(diccionario1)
print("Negro en francés se dice ", diccionario1['negro'])
diccionario1['amarillo'] = 'jaune' # Adicción de un elemento a un diccionario.
print("Se ha añadido la clave amarillo. ", diccionario1)
diccionario1.pop('rojo') # Eliminación de un elemento de un diccionario.
print("Se ha eliminado la clave rojo. ", diccionario1)
print("Diccionario anidado. ", diccionario5)
print(diccionario5["cuerpos"]["i"])

Diccionarios
{'rojo': 'red', 'negro': 'black', 'azul': 'blue'}
{'rojo': 'red', 'negro': 'black', 'azul': 'blue'}
{'rojo': 'red', 'negro': 'black', 'azul': 'blue'}
Negro en inglés se dice  black
{'rojo': 'rouge', 'negro': 'noir', 'azul': 'bleu'}
Negro en francés se dice  noir
Se ha añadido la clave amarillo.  {'rojo': 'rouge', 'negro': 'noir', 'azul': 'bleu', 'amarillo': 'jaune'}
Se ha eliminado la clave rojo.  {'negro': 'noir', 'azul': 'bleu', 'amarillo': 'jaune'}
Diccionario anidado.  {'cuerpos': {'j': 'jurídico', 's': 'sanidad', 'i': 'intervencion', 'm': 'música', 'e': 'eclesiástico'}, 'armas': {'if': 'infantería', 'cb': 'caballería', 'ar': 'artillería', 'ig': 'ingenieros', 'tr': 'transmisiones', 'av': 'aviet'}}
intervencion

# Funciones
'''
Ejemplo: encapsulamos parte del código de los ejemplos previos en una función
'''
print("Ejemplo 1: funciones")

def isnegative(x): # Nótense los :
    if(a<0.0): #Los paréntesis no son necesarios
       print(a," es un número negativo.")

rango=list(range(-5,5)) # La definición de 'isnegative' ha terminado antes de ejecutar esta línea.
print("De los siguientes números ",rango,"se comprueba cuáles son negativos")
for a in range(-5,5):
   isnegative(a)


'''
Ejemplo: cálculo de un polinomio de grado n
'''
print("")
print("Ejemplo 2: funciones")

def polinomio(x,a):
    result=0
    n=len(a)-1
    i=0
    for factor in a:
         result=result+factor*x**i
         i=i+1
    return result

a=[1.0,1.0,1.0] # a_0*x**(0)+a_1*x**(1)+...a_n*x**n, donde n=len(a)
x=2.0
pol_x=polinomio(x,a)
txt="Polinomio de grado n="+str(len(a)-1)+"\n y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]="+str(a)
txt=txt+", en x="+str(x)+" tiene un valor igual a ="+str(pol_x)
print(txt)

'''
Ejemplo: cuerpo caída libre
'''
print("")
print("Ejemplo 3: funciones")
def y_t(t,y0,v0):
    g=9.8
    return y0+v0*t-0.5*g*t**2
y0=100.0 #m
v0= 50.0 #m/s
t = 5 #s
print("Para la condición inicial (y0,v0)=(",y0,"m,",v0,"m/s)")
print("La altura para un cuerpo en caída libre en t=",t,'(s), será de',y_t(t,y0,v0), 'm')

'''
Ejemplo: duplicar un valor
'''
print("")
print("Ejemplo 4: funciones")
a=3
print('Variable a definida externamente: ', a)

def duplica(x):
    a=2 # Variable a definida para su uso dentro de 'duplica'
    result=a*x
    print('Variable a definida internamente: ', a)
    return result

x=5.0
y=duplica(x)
print("El doble de", x, "es", y)
print("Tras ejecutar la función, a vale: ", a)

print("")

def triplica(x):
    result=a*x
    print('Variable a no está definida dentro de la función, vale: ', a)
    return result

y=triplica(x)
print("El triple de", x, "es", y)
print("Tras ejecutar la función, a vale: ", a)

print("")

def cuadruplica(x):
    global a
    a=4
    print('Variable a global: ', a)
    result=a*x
    return result

y=cuadruplica(x)
print("El cuadruple de", x, "es", y)
print("Tras ejecutar la función, a vale: ", a)

Ejemplo 1: funciones
De los siguientes números  [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] se comprueba cuáles son negativos
-5  es un número negativo.
-4  es un número negativo.
-3  es un número negativo.
-2  es un número negativo.
-1  es un número negativo.

Ejemplo 2: funciones
Polinomio de grado n=2
 y coeficientes [$a_0,a_{1},..,a_{n-1},a_n$]=[1.0, 1.0, 1.0], en x=2.0 tiene un valor igual a =7.0

Ejemplo 3: funciones
Para la condición inicial (y0,v0)=( 100.0 m, 50.0 m/s)
La altura para un cuerpo en caída libre en t= 5 (s), será de 227.5 m

Ejemplo 4: funciones
Variable a definida externamente:  3
Variable a definida internamente:  2
El doble de 5.0 es 10.0
Tras ejecutar la función, a vale:  3

Variable a no está definida dentro de la función, vale:  3
El triple de 5.0 es 15.0
Tras ejecutar la función, a vale:  3

Variable a global:  4
El cuadruple de 5.0 es 20.0
Tras ejecutar la función, a vale:  4

import numpy as np # numpy es la biblioteca con la que crear y operar con vectores/matrices y en general "tensores"

'''
Ejemplos básicos
'''
print("\n Ejemplo 1: Ejemplos básicos")
x=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4]])
print("Dimensión=",x.ndim,"Shape=",x.shape,"Tipo=",x.dtype)
print(x)
y=np.zeros(x.shape) # Crear una matriz con las mismas características que otra y rellenarla de ceros
print(y)
z=np.identity(3) # Crea una matriz identidad nxn. En el ejemplo n=3
print(z)

'''
Ejemplos : operaciones con vectores de tipo element-wise
'''
print("\n Ejemplo 2: operaciones con vectores de tipo element-wise ")
tmin,tmax= 0.0,10.0 #s
nopto=21
t=np.linspace(tmin,tmax,nopto) #Se define un vector de dimensión (nopto,), con valores en el intervalo [tmin,tmax]
y=np.array(t) # copia el vector, matriz, en general tensor t. Sirve para crear un vector y con las mismas dimensiones y valores que t, luego se podrá reescribir.

def y_t(t,y0,v0):
    g=9.8
    return y0+v0*t-0.5*g*t**2

y0=100.0 #m
v0= 5.0 #m/s

'''
Python permite cálculos "element-wise": un cálculo elemento a elemento de un vector.
No hay problema en sustituir en una función lo que
en principio son escalares (el tiempo t), por un vector/matriz/.... De la misma forma,
el resultado de la función que en principio es un escalar, puede devolver un vector/matriz/...
'''
y=y_t(t,y0,v0)
print(t)
print(y)

 Ejemplo 1: Ejemplos básicos
Dimensión= 2 Shape= (3, 4) Tipo= int64
[[1 2 3 4]
 [1 2 3 4]
 [1 2 3 4]]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

 Ejemplo 2: operaciones con vectores de tipo element-wise 
[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
  7.   7.5  8.   8.5  9.   9.5 10. ]
[ 100.     101.275  100.1     96.475   90.4     81.875   70.9     57.475
   41.6     23.275    2.5    -20.725  -46.4    -74.525 -105.1   -138.125
 -173.6   -211.525 -251.9   -294.725 -340.   ]

'''
Ejemplo 1: representación gráfica de una función
'''
print("\n Ejemplo 1: cuerpo en caída libre")

import numpy as np

tmin,tmax= 0.0,10.0 #s
nopto=101
t=np.linspace(tmin,tmax,nopto) #Se define un vector de dimensión (nopto,), con valores en el intervalo [tmin,tmax]
y=np.array(t) # copia el vector, matriz, en general tensor t.

g=9.80665 # Estándar para la Tierra. Calculada a una latitud de 45º.

def y_t(t,y0,v0):
    return y0+v0*t-0.5*g*t**2

y0=100.0 #m
v0= 5.0 #m/s
y=y_t(t,y0,v0)

g=1.625 # Estándar para la Luna.
y2=y_t(t,y0,v0)

g=3.72076 # Estándar para Marte.
y3=y_t(t,y0,v0)

print("Para la condición inicial (y0,v0)=(",y0,"m,",v0,"m/s)")

'''
Elementos esenciales en una representación gráfica
'''
# Se llama a las bibliotecas necesarias
import matplotlib.pyplot as plt
import numpy as np

txt="Tierra"
txt2="Luna"
txt3="Marte"

fig,ax = plt.subplots(figsize=(5,5))
ax.grid()
ax.plot(t,y, color="blue", linewidth=1,linestyle='-',marker=".",markersize=4, markevery=5, label=txt)
ax.plot(t,y2, color='green', linewidth=1,linestyle='-',marker="v",markersize=4, markevery=5, label=txt2)
ax.plot(t,y3, color='red', linewidth=1,linestyle='-',marker="+",markersize=4, markevery=5, label=txt3)
ax.set_ylabel("y(m)")
ax.set_xlabel("t(s)")
ax.set_title("Caída libre y(t)")
ax.legend()
plt.show()

'''
Ejemplo 2: representación gráfica de una función
'''
print("\n Ejemplo 2: representación de un polinomio")
#
# El polinomio es b_0 + b_1*x + b_2*x**2 + ... + b_n*x**n
# Se tiene una lista de (n+1) parámetros en b y un valor de la abscisa en x.
#
# Versión imperativa.
#
def polinomio(x,b):
    resultado = 0.0
    n=len(b)-1
    i=0
    for factor in b:
        resultado = resultado + factor*x**i
        i=i+1
    return resultado
#
# Versión recursiva terminal.
#
def polinomio_2(x,b):
    n=len(b)-1
    return polinomio_rt(b[n], x, b, n)
    
# Función auxiliar recursiva terminal.        
def polinomio_rt(r,x,b,p):
    if (p == 0):
        return r
    else:
        return polinomio_rt(b[p-1] + r*x, x, b, p-1)

# Se llaman las bibliotecas necesarias.
import matplotlib.pyplot as plt
import numpy as np

# Se definen los coeficientes del polinomio, se emplearán como variable de entorno
a=[20.0,-4.0,-0.4,0.1] # a_0 + a_1*x + a_2*x**2 + ... + a_n*x**n, donde n=len(a)-1
txt="Polinomio de grado n="+str(len(a)-1)+" y coeficientes "
txtl=txt+"[a_0,a_1,...,a_n]="+str(a)
print(txtl)
xmin,xmax,nopto=-10.0,10.0,101 # Límites del intervalo donde se define el polinomio y número de muestras
'''
Para cada valor asignado al vector x mediante el método np.linspace,
la función polinomio calcula su valor de modo imperativo.
'''
x=np.linspace(xmin,xmax,nopto) # Se define un vector de dimensión (nopto,), con valores en el intervalo [xmin,xmax]
y1=[polinomio(z,a) for z in x] # a se lee del entorno, z representa cada valor de x
'''
La forma equivalente utilizando una versión recursiva terminal de la función polinomio.
'''
y2=[polinomio_2(z,a) for z in x] # a se lee del entorno, z representa cada valor de x
'''
Elementos esenciales en una representación gráfica
'''
fig,ax = plt.subplots(figsize=(8,8))
ax.grid()
ax.plot(x,y1, color="blue", linewidth=1,linestyle='--',marker=".",markersize=6,label="Imperativo.")
ax.plot(x,y2, color="red", linewidth=1,linestyle='-',label="Recursivo terminal.")
ax.set_title("$a_0+a_{1} x+...+a_{n-1} x^{n-1}+a_n x^n$")
ax.set_ylabel("y")
ax.set_xlabel("x")
ax.legend()
plt.show()

 Ejemplo 1: cuerpo en caída libre
Para la condición inicial (y0,v0)=( 100.0 m, 5.0 m/s)

 Ejemplo 2: representación de un polinomio
Polinomio de grado n=3 y coeficientes [a_0,a_1,...,a_n]=[20.0, -4.0, -0.4, 0.1]

Introducción al lenguaje python mediante jupyter.¶

TRUCOS ¶

Variables ¶

Operadores ¶

Cadenas de caracteres ¶

Controles de flujo ¶

Condiciones ¶

Iteraciones. Bucles. ¶

Estructuras de datos en Python ¶

Funciones ¶

Bibliotecas ¶

Numpy ¶

Matplotlib ¶