INTRODUCCIÓN A PYTHON

Sitio oficial [Link]

¡Bienvenidos Paitonistas!

El logo de Python es una serpiente de la familia Pythonidae [Link]

Documento realizado por Jaime Fernando Meza Meza

Actualización # 0.3 octubre 23 de 2020©

Disponible en [Link]/

Fuente: [Link]
Una aplicación para editar y ejecutar código fuente de Python se llama Xcas, disponible en

[Link] aunque se puede utilizar cualquier otro IDE o SDK

e incluso la consola oficial de Python versión 3.9.0 [Link]/downloads

Después de instalado Xcas64, eliminamos la primera línea o panel de graficación porque no se usará al principio,
para esto se ubica el puntero del ratón (Mouse) en el numeral o línea [1] luego se oprime la tecla retroceso
[BackSpace ↤]

La nueva apariencia de Xcas es la siguiente

En la línea [1] se observa el panel de edición de programas, que también puede ser eliminado con [↤]
Luego seleccionamos en el menú Cfg submenú CAS configuration, posteriormente MicroPyhton que es una versión
reducida de Python.

Si deseamos trabajar al estilo de una calculadora u operación en la línea de comandos agregamos una nueva línea de
entrada (New Entry) disponible en el menú ToolBox

La nueva apariencia es
Luego simplemente digitamos las expresiones sobre cada numeral, por ejemplo, la línea de entrada número 1 esta
demarcada en la parte izquierda con [1] para ejecutar o calcular una expresión como 3+4 sobre esta línea oprimimos
la tecla [enter] de nuestro teclado.

Si deseamos escribir un programa, seleccionamos el menú PRG, luego el submenú NEW PROGRAM

Colocamos el nombre del programa, y por ahora los campos de texto ARGUMENTS y RETURN VALUE (devolución) los
dejamos vacíos

Nuestro primer programa va a imprimir la suma entre 4 y 3, para esto usamos la instrucción print(), note que esta
tiene que quedar tabulada, de la siguiente forma

def mi_primer_programa():
print( 3+4 )
#endDefinition

Es necesario mientras se edita la indentación continua, para determinar si la tabulación es correcta (Edit/Indent All)
Para almacenar en memoria temporal y detectar posibles errores de sintaxis oprimimos el botón [ok], si todo sale
bien debe aparecer en la línea de salida la palabra “Done”, Hecho en español, de lo contrario muestra el posible
error de sintaxis o similar.

Para ejecutar el programa que es lo mismo que la llamada del programa o la función principal colocamos en otra
línea el nombre del programa, en este caso mi_primer_programa(), luego pulsamos [enter]. Debemos obtener en la
salida y si todo se escribió bien el número 7

Los comentarios en Python inician con el símbolo numeral #. Para diferenciar los finales de los bloques de una
Subrutina se puede agregar un comentario #endDefinition sinónimo de endSuburutine, ya que Python no tiene
instrucciones de finalización de bloques como endIf, endFor, endSub o llave a la derecha }, como se presenta en el
caso de C++

Para guardar la sesión de trabajo oprimimos SAVE

Si se desea eliminar una línea de entrada por ejemplo la linea [2] que contiene la sentencia mi_primer_programa() se
ubica el puntero del mouse en el numeral de línea luego se oprime la tecla retroceso [BackSpace ↤]
La diferencia más significativa con otros lenguajes es que la llamada de la función o programa No siempre se realiza
dentro del mismo código fuente, sino en una línea de comandos externa.

Si la fuente de texto es pequeña entonces, para aumentar el tamaño de la fuente de texto en Xcas ir al menú Cfg /
General Configuration
Si no se desea usar XCAS con MicroPython podemos ejecutar la consola oficial de Python, disponible en:

[Link]/downloads, después de instalada, creamos un acceso directo al escritorio del archivo “Python 3.9.0
…exe”

La ejecución de la consola debe mostrar algo como

El símbolo >>> indica inicio de la línea de comandos u órdenes para introducir expresiones, en muchos lenguajes uno
o varios símbolos de corchete angular a la derecha > implica entrada y corchete angular a la izquierda < salida de
datos

El primer ejemplo se expresa como >>> 3+4 luego [enter]

El primer programa se expresa como (tener en cuenta la tabulación) que en la siguiente imagen se muestra como
espacio

Y se ejecuta como

Con la tecla [↑] se recupera las entradas anteriores (historial de entradas)

Veamos como en c++ el operador << actúa como acumulador de datos en la consola de salida

Y >> como entrada de datos en la consola

Código Fuente en C++

#include <iostream>
using namespace std;

int x = 100; // VARIABLE GLOBAL

int main()
{
int x; // VARIABLE LOCAL que enmascara a la global, es decir oculta el valor global
x = 10; // Asignamos el valor de la variable local x
cout << "el valor de x local es: " << x << endl; // Accedemos e imprimimos la variable local
cout << "el valor de x global es: " << ::x << endl; // Accedemos e imprimimos la variable global

::x = x+2; // Mediante el operador de ámbito modificamos la variable global x que es igual a xlocal + 2
cout << "el nuevo valor de x global es: " << ::x << endl; // Accedemos e imprimimos la variable global

cout << "entre valor de x: ";

cin >> x;
cout << "el nuevo valor local de x es: " << x << endl; // Accedemos e imprimimos la variable local
CARACTERÍSTICAS DEL LENGUAJE Python

Python es un lenguaje de programación profesional y de alto nivel cuya dos máxima o leyes son:

1: LEGIBILIDAD O CLARIDAD DEL CÓDIGO, ya que posee instrucciones que simplifican muchas operaciones que no
están codificadas por defecto en otros lenguajes.

2: MANIPULACIÓN DIRECTA DE TIPOS DE DATOS COMPUESTOS como son Listas, Tuplas, Conjuntos, Diccionarios.

LAS PRINCIPALES CARACTERÍSTICAS DE PYTHON SON LAS SIGUIENTES:

A: ES DINÁMICAMENTE TIPADO: Es decir, el tipo u objeto contenido de las variables puede cambiar en muchos casos
en tiempo de ejecución o en otras palabras se decide en tiempo de ejecución finalmente que tipo de dato es. Lo
contrario es ESTÁTICAMENTE TIPADO, es decir se define el tipo de dato al inicio y no puede cambiarse durante la
ejecución del programa, e incluso a la hora de codificar posiblemente se detecta y se muestra el error.

B: ES MULTIPARADIGMA, es decir se puede codificar siguiendo diferentes formas o lógica de programación como
programación imperativa, programación orientada a objetos y programación funcional esta ultima la que más
acogida está teniendo por los desarrolladores de software.

C: ES MULTIPLATAFORMA: Hay intérprete de Python para los principales sistemas operativos actuales como:
Windows, Linux y Mac OS.

D: ES FUERTEMENTE TIPADO: No se puede usar una variable en un contexto fuera de su tipo. Si se quisiera, habría
que hacer una conversión de tipos.

E: ES INTERPRETADO: El código no se compila a lenguaje máquina, sino que se interpreta línea por línea al iniciar el
programa.
F: ES CASE SENSITIVITY.

Sobre el Item A. recordemos que PSEINT es ESTÁTICAMENTE TIPADO esto es, si por ejemplo se define una variable
de nombre “c” como ENTERO inicialmente como 0, esta no puede posteriormente mutar o cambiar a REAL. Podemos
decir que el nombre identificador se adapta cada vez que el tipo de dato cambia.

Aritméticamente si dividimos dos números enteros no siempre obtenemos otro entero, por ejp ½ es 0.5 (real),
mientras que 4/2 es 2 (entero)

Código fuente en Pseint

Algoritmo ejp_estaticamente_tipado
definir a, b, c como enteros
a=1
b=2
c = 0 // c inicialmente es un numero entero
c = a/b // c no puede mutar a número real. Por lo tanto, generara un error de ejecución
imprimir c
FinAlgoritmo
 Código fuente en Python
def ejp_dinamicamente_tipado():
a=1
b=2
c = 0 # c inicialmente es un numero entero
c = a/b # ahora c es número real y no se genera error en tiempo de ejecución.
print( c )
#endDefinition
Ejecución
dinamicamente_tipado():

SmallBasic también es dinámicamente tipado

Código fuente en SBasic

ejp_dinamicamente_tipado()

Sub ejp_dinamicamente_tipado
a = 1
b = 2
c = 0 ' c inicialmente es un número entero
c = a/b ' ahora c es número real y no se genera error en tiempo de ejecución
[Link]( c )
EndSub
Sobre el Item F Python es sensible a mayúsculas y minúsculas, por ejemplo, la variable “A” internamente está

ubicada en un espacio de memoria diferente de la variable “a”, por esta razón son dos identificadores diferentes

Código fuente en Python

def programa1():
a=1
print(a)
A=2
print(A)
print(a)
#endDefinition

En la línea de comandos [2] llamamos al programa o función en este caso Programa1()

Las cadenas de texto en Python se encierran o delimitan entre comillas simples ' '

Código fuente en Python

def cadenas():
print( ' ¡Hola futuros desarrolladores de software! ' )
print( ' ************************************************* ' )
print( ' * ')
print( ' * Python es genial ' )
print( ' * ')
print( ' ************************************************* ' )
#endDefinition
Ejecución
cadenas() [Enter]
Python tiene la opción de asignar un valor (expresión que está a la derecha) a múltiples variables

Sintaxis var1 = var2 = varN, … = valor

ejemplo
a = b = c = (3+4)

y asignar múltiples valores paralelamente a múltiples variables. Esta es una forma compacta o rápida de asignación
en una sola línea o sentencia. No disponible en PseInt ni en SBasic

d, ee, f = 6, 3, 9

Código fuente en Python

def asignacion():
a = b = c = (3+4)
d, ee, f = 6, 3, 9*2
print( 'á=',a )
print( 'b=',b )
print( 'c=',c )
print( 'd=',d )
print( 'a=',ee )
print( 'a=',f )
#endDefinition
Ejecución
asignacion()

La sentencia a = b = c = (3+4) es equivalente a

a = (3+4)

b = (3+4)

c = (3+4)

y la sentencia d, ee, f = 6, 3, 9*2 es equivalente a

d =6

ee=3

f=9*2
Python también puede trabajar un numero entero en diferentes formatos o bases (binaria, octal, decimal,
hexadecimal) y Notación científica decimal

Código fuente en Python

def bases_numericas( ):
diez_decimal = 10
diez_binario = 0b1010 # prefijo 0b, b de binario
diez_octal = 0o12 # prefijo 0o, o de octal
diez_hexadecimal = 0xA # prefijo 0x, x de heXadecimal
print( diez_decimal )
print( diez_binario )
print( diez_octal )
print( diez_hexadecimal )
#endDefinition
Ejecución
bases_numericas( )

Si desea usar un conversor de bases puede usar la Hp-prime

Notación científica decimal. Python acepta escribir números enteros en notación científica.

Código fuente en Python

def notacion_cientifica( ):
un_real = 0.5 # debe incluir el carácter punto (.) si se trata de un número real literal
otro_real = 1/2 # El resultado de 1/2 es un número real (float)
real_notacion_cientifica = 500E-3 # número real en notación científica (500*10^-3)
print( un_real )
print( otro_real )
print( real_notacion_cientifica )
#endDefinition
Ejecución
notacion_cientifica ( )
TIPOS COMPUESTOS

DIFERENCIA ENTRE LISTAS Y CONJUNTOS

LISTAS (LIST), los datos se colocan entre corchetes [] y permanecen exactamente en la posición en que se definieron
CONJUNTOS (SET) los datos se colocan entre llaves {} o usando corchetes [] pero se antepone la función de
conversión set(), la característica principal de los conjuntos es que cuando se almacenan en memoria se pueden
reducir sus elementos, esto es si hay multiplicidades o repeticiones se eliminan.

Código fuente en Python

def tipos_compuestos( ):
conjunto1 = { 1, 1, 1, 2, 3, 3, 4 } # definición por defecto
conjunto1 = set( [ 1, 1, 1, 2, 3, 3, 4 ] ) # la lista se convierte a conjunto.

print( conjunto1 )

lista1 = [ 1, 1, 1, 2, 3, 3, 4 ]
print( lista1 )

lista2 = [ '123 456', 123 ]

print( lista2 )

conjunto2 = set( [ 'abc' , 'hola', 'mundo', 'hola', 'abc', 'hola', 'mundo' ] )

print( conjunto2 ) # se elimina la multiplicidad o repetición de elementos iguales

conjunto3 = set( [ 'abc' , 'hola', 'mundo', 'HOLa', 'ABC', 'hola ', 'mundo' ] )
print( conjunto3 ) # hay que tener en cuenta que un solo carácter que cambie implica un elemento diferente
#endDefinition
Ejecución
tipos_compuestos()
MUTABILIDAD O CAMBIO, ALTERACIÓN DE ELEMENTOS

DIFERENCIA ENTRE LISTAS Y TUPLAS

LISTAS los datos permanecen exactamente en la posición en que se definieron, pero se pueden modificar.
TUPLAS los datos van entre paréntesis y No se pueden modificar. tener en cuenta que el primer elemento de un tipo
o dato compuesto en Python es numerado desde 0 y no en 1

Código fuente en Python

def cambio_de_elementos():
lista1 = [ 4, 1, 1, 1, 2, 3, 3 ]
print( lista1 )

lista1[5] = 9 # una lista es mutable, esto es que se puede redefinir o cambiar los elementos internos
print( lista1 )

lista1[0] = 8
print( lista1 )

tupla1 = ( 4, 1, 1, 1, 2, 3, 3 ) # una tupla es inmutable, esto es que NO se puede redefinir o cambiar los
elementos internos
print( tupla1 )

tupla1[0] = 45
print( tupla1 ) # se genera un error en tiempo de ejecución, no en verificación de sintaxis
#endDefinition

Ejecución
cambio_de_elementos():

Aplicación de TUPLAS y LISTAS, si yo quiero que la base de datos no se altere, se tiene que definir como TUPLA, de lo
contrario se puede usar listas
LISTAS DE LISTAS

Python soporta definición de Listas de listas, es decir al menos un elemento puede ser otra lista e incluso todos y
más aun un elemento que es una lista puede a su vez anidar elementos tipo lista.

Es muy útil para agrupar campos similares, por ejemplo, si en la siguiente lista los elementos 3, 4 y 5 hacen
referencia a los teléfonos de un usuario entonces ¿cómo se puede agrupar?

lista_usuario1 = [ 'jaime meza', 71310567, 3185674567, 3173471495, 5072779, 'Calle 49 82F 37' ]
lista_usuario1 tiene 6 elementos

la solución es agruparlos como lista

lista_usuario1 = [ 'jaime meza', 71310567, [3185674567, 3173471495, 5072779], 'Calle 49 82F 37' ]

lista_usuario2 tiene solo 4 elementos, el tercer elemento tiene 3 elementos

Extrayendo partes de una lista de listas

Código fuente en Python

def listas_de_listas():
lista_usuario1 = [ 'jaime meza', 71310567, 3185674567, 3173471495, 5072779, 'Calle 49 82F 37' ]
# se define una segunda lista de lista
lista_usuario1a = [ 'jaime meza', 71310567, [3185674567, 3173471495, 5072779], 'Calle 49 82F 37' ]

print( lista_usuario1)
print( lista_usuario1a)

print( lista_usuario1[2]) # extrae el tercer elemento, pero solo es un numero

print( lista_usuario1a[2]) # extrae el tercer elemento, pero ahora es una lista
print( lista_usuario1a[2][0]) # extrae el primer elemento del tercer elemento
#enDefinition
Ejecución
listas_de_listas()
Ejemplo 2

Código fuente en Python

def listas_de_listas2():
listaA = [ 4, 'abc', [ 8, 'A', 5 ] ]
print( listaA )

print( listaA[0] )
print( listaA[1] )
print( listaA[2] )
print( listaA[3] ) # Genera un error por desbordamiento de índice
print( (listaA[2])[0] )
print( (listaA[2])[2] )
#endDefinition
Ejecución
listas_de_listas2():
Ejercicio 1

Hallar la suma de los elementos de una lista

Veamos primero como se codificaría en SmallBasic, para luego compararlo con Python

Código fuente en SBasic

'numeros = [ 9, 8, 7, 5, 6, 5 ] ' SBasic no permite definir una lista de números en una sola
sentencia
' hay que almacenarlos uno por uno o sentencia por sentencia, especificando su posición

numeros[1] = 9 ' el número 9 esta almacenado en la posición 1 de la lista o arreglo de nombre

números
numeros[2] = 8
numeros[3] = 7
numeros[4] = 5
numeros[5] = 6
numeros[6] = 5

suma = 0
sumaDenumeros()

Sub sumaDenumeros
for elemento_n=1 to 6 Step 1
suma = suma + numeros[ elemento_n ]
[Link]("la suma actual es: "+suma )
EndFor
[Link]( "la suma total de la lista es: "+suma )
EndSub

Código fuente en Python

def sumaDenumeros( numeros ):
suma = 0
for elemento_n in numeros # en cada elemento de la lista
suma = suma + elemento_n
print('la suma actual es: ', suma) # va mostrando el valor de la suma actual
#endFor
return('la suma total de la lista es: ', suma)
#endDefinition

En la línea de comandos se ejecuta la función o programa

sumaDenumeros( [ 9, 8, 7, 5, 6, 5 ] )
Una expresión en Python se puede dividir el contenido en varias líneas, e igualmente Python lo interpreta

sumaDenumeros( [ 9,
8, 7, 6
, 5, 4 ]
)

En pseint es algo similar cuando se usa el Ciclo FOR seguido de la instrucción CADA un identificador de posición de
elemento, esto es PARA CADA elemento_n

Código en pseint
Algoritmo uso_de_PARA_CADA_item_de_una_lista

//numeros = [ 9, 8, 7, 5, 6, 5 ] // Pseint no permite definir una lista de números

// hay que almacenarlos uno por uno especificando su posición
Definir numeros Como Real; Dimension numeros[6]
numeros[1] = 9 // el número 9 esta almacenado en la posición 1 de la lista o arreglo de nombre números
numeros[2] = 8
numeros[3] = 7
numeros[4] = 5
numeros[5] = 6
numeros[6] = 5

definir suma Como Real

suma = 0
Para cada elemento_n de numeros
suma = suma + elemento_n
Imprimir( "la suma actual es: "+ConvertirATexto(suma) )
FinPara

Imprimir( "la suma total de la lista es: "+ConvertirATexto(suma) )

FinAlgoritmo
// Versión estándar
Para elemento_n=1 hasta 5
suma = suma + numeros[elemento_n]
Imprimir( "la suma actual es: "+ConvertirATexto(suma) )
FinPara
Ahora la llamada de la función sin argumentos, para la cual se tiene que definir la lista del programa

Código fuente en Python

def sumaDenumeros2( ):
numeros = [ 9, 8, 7, 5, 6, 5 ]
suma = 0
for elemento_n in numeros:
suma = suma + elemento_n
print('la suma actual es: ', suma)
#endFor
return('la suma total de la lista es: ', suma )
#endDefinition
Ejecución
sumaDenumeros2( ):

Pruebe la suma cambiando la lista por conjunto -¿Se obtiene el mismo resultado?

numeros = [ 9, 8, 7, 5, 6, 5 ] -> numeros = { 9, 8, 7, 5, 6, 5 }

Matemática Aplicada

Fuente: [Link]

Aristarco de samos, por medio de razones trigonométricas realizo un cálculo aproximado de la distancia tierra al sol.
La luz del Sol tarda aproximadamente ocho minutos en llegar desde su superficie a la Tierra, y sabemos que el astro
rey se encuentra a, aproximadamente, 150 millones de kilómetros de distancia media. La distancia media es
149.597.870,700 y es conocida con el nombre de unidad astronómica 1UA, pero sabemos que la órbita de la tierra
no es una circunferencia, sino una elipse, por lo tanto, la distancia varia. A principios de enero se produce lo que
conocemos como perihelio, que es considerada como la aproximación más cercana de la Tierra al Sol, (unos 146
millones de kilómetros); mientras que afelio es el punto más alejado del Sol al que llega la Tierra. Ocurre a principios
de julio, y tiene alrededor de 152 millones de kilómetros.

Sabemos hoy que la distancia media entre la Tierra y la Luna es 384400 Km (cateto adyacente) y el ángulo promedio
entre el cateto adyacente y la hipotenusa es de 89.8527751647,asi que Aristarco de Samos estuvo muy cerca del
valor real.

Según los datos anteriores

Medida Hipotenusa = 384400 Km / Cos(89.8527751647) = 149.597870 Millones de kilómetros

Por regla de tres podemos hacer el calculo del ángulo en radianes

190 gragos (PI) 3.14159265359 rad

89.8527751647 grados X grados ?

X= (89.8527751647 grados * 3.14159265359 rad)/180 grados

X= (89.8527751647 * 3.14159265359)/180 rad X = 1.56822676868 radianes

Código fuente Python

from math import cos
def calculo_distancia_tierra_sol():
distancia_tierra_luna = 384400
angulo_grados = 89.8527751647 # grados
 angulo_rad = 1.56822676868 # radianes
distancia_tierra_sol = distancia_tierra_luna / cos( angulo_rad )
mensaje = 'distancia_tierra_sol = ' + str( distancia_tierra_sol ) # str convierte un número a cadena de texto
print( mensaje )
#endDefinition
Ejecución
calculo_distancia_tierra_sol() [enter]
"distancia_tierra_sol = 149597870.84800"

Nota: La concatenación en Python desde la función print() se puede realizar usando comas

print( 'distancia_tierra_sol = ', distancia_tierra_sol)

Método 2: Eratóstenes de Cirene

Fuente = [Link]
OPERACIONES CON DICCIONARIOS

Una forma más fácil de ubicar los elementos de una lista o dato compuesto es etiquetando cada item, un objeto
diccionario es un objeto similar a un conjunto, los datos se pueden ordenar en la ejecución, pero como cada
elemento esta etiquetado esto no afecta la lógica de ubicación.

Recordemos una lista definida anteriormente

lista_usuario1a = [ 'jaime meza', 71310567, [3185674567, 3173471495, 5072779], 'Calle 49 82F 37' ]
etiquetemos cada elemento

Código fuente en Python

def operaciones_con_dic():
diccionario1 = {
'usuario': 'jaime meza',
'cedula': 71310567,
'telefono': [ 3185674567, 3173471495, 5072779 ],
'direccion': 'Calle 49 82F 37'
}
print( diccionario1 )
print( diccionario1[ 'telefono' ] )
print( diccionario1[ 'usuario' ] )
telefono1 = diccionario1[ 'telefono' ][0] #primer teléfono
print(telefono1)
telefono3 = diccionario1[ 'telefono' ][2]# tercer teléfono
print(telefono3)

#endDefinition

operaciones_con_dic()
Funciones especializadas

Código fuente en Python

def operaciones_con_dic2():
diccionario1 = {
'usuario': 'jaime meza',
'cedula': 7122222,
'telefono': [ 31233333, 3131232222, 50727777 ],
'abc': 123,
'otro':123 }
# for etiqueta in diccionario1:
#print(etiqueta, ":", diccionario1[etiqueta])
dic2 = dict( cursos=[ 'Pseint', 'Sbasic', 'Python'], dia='martes', mes='octubre', identificador=123 )
print(dic2)

conjunto1 = set( [ 1,1,2,3,3,4] )

print(conjunto1)

print( [Link]() ) # obtiene el contenido de la etiqueta del diccionario o parte derecha

dic3 = [Link]()

[Link]()
print(dic2)

dic2 = dict( cursos=[ 'c++', 'Java', 'Python'] )

print(dic2)
print(dic3)

Mas info en

[Link]