Python

version python=3.9.7
Índice
INTRODUCCIÓN................................................................................................................................3
TIPOS DE DATOS..............................................................................................................................3
OPERADORES....................................................................................................................................4
COMENTARIOS.................................................................................................................................5
DECLARACIÓN DE VARIABLES....................................................................................................5
EXPRESIONES...................................................................................................................................8
ENTRADA Y SALIDA POR CONSOLA...........................................................................................9
ESTRUCTURAS ALTERNATIVAS Y REPETITIVAS..................................................................13
ALTERNATIVA SIMPLE............................................................................................................13
ALTERNATIVA DOBLE.............................................................................................................13
ALTERNATIVA ANIDADA........................................................................................................14
ESTRUCTURA REPETITIVA..........................................................................................................15
ESTRUCTURA REPETITIVA WHILE............................................................................................15
ESTRUCTURA REPETITIVA FOR............................................................................................16
FUNCIONES......................................................................................................................................17
LISTA.................................................................................................................................................20
INSTALACIÓN WINDOWS............................................................................................................23
INSTALACIÓN LINUX....................................................................................................................25
PUNTOS A MEJORAR O PARA POSTERIOR MODIFICACIÓN................................................26
INTRODUCCIÓN
Python es:

* Un lenguaje interpretado, multiplataforma de alto nivel cuyo formato de archivos es .py

* Multiparadigma, de propósito general, aunque su fuerte es la programación orientada a objetos

* Es de tipado dinámico

TIPOS DE DATOS
* int que corresponde con un entero, cualquier numérico sin punto

* float que corresponde con un numero real, cualquier numérico con punto

* str que corresponde con una cadena de caracteres, cualquier cadena encerrada entre comillas
simples o dobles

* bool que corresponde con los valores de True (verdadero) o False (falso)

Para saber el tipo de dato que manejamos podemos usar la función type de la siguiente manera:

type(7)
type(3.14)
type(‘hola’)
type(True)

En ocasiones es necesario convertir un dato de un tipo a en otro de un tipo b para trabajar con el,
esto se conoce como casting o conversión. Por ejemplo:

float(7)
int(‘7’)
str(‘7.34’)

OPERADORES
* Aritméticos: +, - (resta o operador unario para cambiar signo), *, / (división real o flotante), //
(división entera), ** (potencia), % (resto de una división)

* Relacionales: ==, !=, <, >, <=, >= . El resultado devuelto sera de tipo booleano y es aplicable a
cadenas de texto, cuyo resultado devuelto dependerá de la ordenación alfabética de los operandos,
distinguiéndose entre mayúsculas y minúsculas.

* Lógicos: and, or y not

El operador + y * se pueden usar con cadenas de caracteres resultando en su concatenación.

Ejemplos:

‘Alfonso’ + ‘Alejandro’
‘hola’ * 3
3**2
9.5/3
9.5//3
9.5%3
9/2
‘Antonio’ <= ‘Juan’
‘Antonio’ <= ‘Antonio’
‘Antonio’ <= ‘antonio’
not True

COMENTARIOS
En Python los comentarios de una sola linea empiezan por almohadilla y los que incluyen varias
lineas deben escribirse encerrados entre 3 comillas simples o dobles al principio y al final.

DECLARACIÓN DE VARIABLES
El nombre de las variables puede contener dígitos, letras y el guion bajo. Ademas no pueden
comenzar por un digito, no pueden tener el mismo nombre que las palabras reservadas por el
lenguaje y se distingue entre minúsculas y mayúsculas.

Las palabras reservadas son las siguientes:

Declaramos la variable y asignamos un valor

base = 5
altura =7
base * altura
Asignamos otro valor a la variable altura
altura=8
base * altura
Creamos una variable llamada auxiliar que contiene el mismo valor que altura
auxiliar = altura
auxiliar * base
altura=3
base*auxiliar
Guardamos en otra variable el resultado de una operación
area= base * altura
area

En Python no existe constantes como tales aunque por norma aquellas variables cuyo nombre este
en mayúsculas sera una constantes.

EXPRESIONES
Una expresión es una combinación de operadores y operandos que devuelven un resultado.
Los operadores tienen un orden de ejecución, aunque podemos usar paréntesis para agrupar
operaciones y así cambiar su orden de ejecución. Podemos consultar la tabla de prioridades en el
siguiente enlace:
https://docs.python.org/3/reference/expressions.html

En todo caso, las tablas de precedencia de todos los lenguajes suelen seguir una serie de reglas que
si se conocen pueden permitirnos escribir expresiones complejas sin abusar tanto del uso de los
paréntesis. Citaremos las cuatro reglas más básicas:

1. lo que está entre paréntesis se hace primero

2. los operadores aritméticos tienen más precedencia que los relacionales, y los relacionales más
que los lógicos

3. los operadores unarios de un grupo más que los binarios de ese mismo grupo

4. ** más que los multiplicativos (*, /, %), y éstos más que los aditivos (+, -). Esta regla también se
da con los lógicos (and más precedencia que or)

La única excepción a la regla tercera se da en el caso de el operador binario ** que tiene más
precedencia que los operadores unarios aritméticos, como el -, lo que explica que -1**2 de como
resultado -1, mientras que (-1)**2 da como resultado 1.

ENTRADA Y SALIDA POR CONSOLA

La función print saca contenido por pantalla
radio=2
area=5.0
print (area, radio)
print(‘el area es’, area, ‘y el radio es’, radio)

Podemos definir parámetros opcionales dentro del print de separación y final como en el ejemplo:
print (area, radio, sep=’ ‘, end=’\n’)

El argumento end por defecto es igual a \n.

Si el print no tiene ningún parámetro produce un salto de linea
print()

Las cadenas de caracteres que muestra la función print pueden contener caracteres especiales. Se
trata de caracteres que van precedidos por la barra invertida \ y que tienen un significado específico.
Los más utilizados son \n, el carácter de nueva línea, y \t, el de fabulación.
print("Hola\n\n\tmundo")

La función input recoge lo que el usuario escriba como cadena de caracteres hasta que se pulsa
enter o return.

entrada= input()
print(entrada)
type(entrada)

Es recomendable decirle al usuario lo que espera que se escriba mediante un parámetro del input
como en el ejemplo:
entrada=input(‘introduce tu nombre’)
print(entrada)
Si queremos recoger un numero podemos usar el casting para ello como en el ejemplo:
entrada=float(input(‘introduce tu peso en kg’))
print(entrada, type(entrada))

Aclarar que el el \n del input produce un salto de linea

ESTRUCTURAS ALTERNATIVAS Y REPETITIVAS

Una aclaración antes de ponernos con las estructuras. En Python no es obligatorio usar ; al final de
linea a excepción de que queramos escribir varias sentencias en una misma linea.

En Python, lo que “delimita” el bloque es que todas tengan el mismo nivel de indentación, es decir,
el mismo número de espacios por la izquierda. Aunque el número de espacios puede ser cualquiera
que se desee, ha de ser el mismo para todas las sentencias que componen el bloque. Es costumbre
que este número de espacios sea múltiplo de 4.

ALTERNATIVA SIMPLE

La condición será una expresión booleana cuyo resulutado será True o False. La condición no
necesita ir encerrada entre paréntesis (a diferencia de otros lenguajes como C o Java).
Tras la condición, se ponen dos puntos (:), finalizando así la línea.
La sentencia a ejecutar debe ir indentada, habitualmente cuatro espacios. Si se trata de un bloque en
lugar de una sola sentencia, todo el bloque irá indentado la misma cantidad de espacios.

nota=5
if nota >= 5.0:
print("Prueba superada")

ALTERNATIVA DOBLE

Si la condición es falsa, se ejecuta el segundo bloque de secuencias.

num=5
if num %2 == 0:
print("Es par")
else:
print("Es impar")

ALTERNATIVA ANIDADA

Son del tipo

if condición:
if condición:
bloque 1
elif condición:
bloque2
elif condición:
bloque3
....
elif condición:
bloque N

Como vemos no es obligatorio poner el else, es obligatorio mantener la indentaccion

correspondiente y si no queremos agrupar condiciones dentro del else todo el rato podemos usar
elif, que es la combinación de else-if. Sin embargo no se debe abusar de estas estructuras, de
necesitarlas lo ideal es usar funciones.

nota = int(input("Introduzca la nota del examen: "))

if (nota >= 0) and (nota < 5):
print("Suspenso")
elif (nota >= 5) and (nota < 7):
 print("Aprobado")
elif (nota >= 7) and (nota < 9):
print("Notable")
elif (nota >= 9) and (nota <= 10):
print("Sobresaliente")
else:
print("Nota no válida")

ESTRUCTURA REPETITIVA
Una estructura repetitiva es un bloque de sentencias (denominado cuerpo del bucle) que se va a
ejecutar varias veces. El bucle incluye una condición, que regula si se seguirá repitiendo o no. Las
instrucciones dentro del bloque modificarán los valores de algunas de las variables que forman parte
de la condición, haciendo que en algún momento la evaluación de esa condición cambie y por tanto
el bucle ya no se repita más.

ESTRUCTURA REPETITIVA WHILE

Se evalúa la condición, si es cierta se ejecuta el bucle sucesivamente suponiendo que en algún
momento el bloque de sentencias cambiara la condición del bucle a falsa y se acabara su ejecución.
De lo contrario tendremos un bucle infinito. Si la condición del bucle es falsa, ya no se ejecutaría el
bloque de sentencias.

while condición:
bloque

n = int(input("Numero entero: "))

a=n
digitos = 1
while a//10 != 0:
digitos = digitos + 1
a = a//10
print(n, "tiene", digitos, "digitos")

ESTRUCTURA REPETITIVA FOR

es muy frecuente que aparezca la necesidad de realizar un bucle para el que se conoce de antemano
el número de iteraciones a realizar. En este caso, el bucle normalmente está controlado por un
contador que parte de un valor inicial que se va incrementando (o decrementando) hasta superar un
valor final.

Python proporciona range() que genera una secuencia de enteros entre un valor inicial y final que se
le suministre y separados entre sí una cantidad que también se le puede suministrar. La sintaxis
general de range es range(inicial, final, paso), siendo:

*inicial el valor del primer entero de la secuencia. Puede omitirse, y entonces recibirá automá-
ticamente el valor cero.

*final el valor del primer entero “fuera” de la secuencia. Este valor ya no formará parte de la
secuencia de enteros generada, que se detendrá en el entero anterior a éste.

*paso es la distancia entre los enteros que se van generando. Puede omitirse y entonces recibirá
automáticamente el valor uno.

Con el bucle for iremos recorriendo los valores devueltos por el range de la siguiente forma:

for i in range(inicial, final, paso) :

sentencia1
sentencia2
...
Donde la variable i toma el valor correspondiente del range cada vez que se ejecuta el bloque de
sentencias.

Ejemplo donde a una cantidad inicial le sumamos una cantidad variable en cada iteración siendo el
numero de iteraciones n+2-2=n:

n = int(input("Entero (>=0): "))

termino = 1
for cantidad in range(2, n+2, 1):
print(termino, end=" ") # escribe en pantalla el término actual
termino = termino + cantidad
print()

FUNCIONES
Una forma de resolver un problema es descomponerlo es problemas mas pequeños y sencillos
sucesivamente hasta tener problemas (subproblemas) mas asequibles que resolver. Este método se
conoce como diseño descendente y da lugar a la programación modular. Una función es un
fragmento de código de un programa que resuelve un subproblema con entidad propia.

Python proporciona funciones trigonométricas, logaritmos, etc., pero no están directamente

disponibles cuando iniciamos una sesión (aunque algunos entornos de desarrollo incluyen por
defecto las más usadas).

abs(-3)
abs(round(2.45,1))
2.5 / abs(round(2.45,1))
abs(round(1.0/9, int(4/(1+1))))
Antes de utilizar las funciones hemos de indicar a Python que vamos a hacerlo. Para ello, debemos
importar el módulo que las contiene, consiguiendo así que Python las reconozca. Empezaremos por
importar el módulo matemático (math)

import math
math.sin(0)
math.sin(1)

Fijarnos que primero escribimos el modulo seguido de un punto y el nombre de la función con los
parámetros entre paréntesis.
Las funciones se crean al principio del código y deben respetar la indentación. La línea que
empieza con def es la cabecera de la función y el fragmento de programa que contiene los cálculos
que debe efectuar la función se denomina cuerpo de la función. Cuando estamos definiendo una
función, su parámetro se denomina parámetro formal (aunque, por abreviar, normalmente usaremos
el término parámetro, sin más). El valor que pasamos a una función cuando la invocamos se
denomina parámetro real o argumento. Las porciones de un programa que no son cuerpo de
funciones forman parte del programa principal: son las sentencias que se ejecutarán cuando el
programa entre en acción. El cuerpo de las funciones sólo se ejecutará si se producen las
correspondientes llamadas.

Las reglas para dar nombre a las funciones y a sus parámetros son las mismas que seguimos
para dar nombre a las variables: sólo se pueden usar letras (del alfabeto inglés), dígitos y el carácter
de subrayado; la primera letra del nombre no puede ser un número; y no se pueden usar palabras
reservadas. Tampoco debemos dar el mismo nombre a una función y a una variable. Por otro lado
unas funciones pueden invocarse dentro de otras.

Un ejemplo es una función que calcula el cuadrado de un numero:

def cuadrado(x):
return x**2

ahora la podemos invocar:

a = cuadrado(2)
print(a)
b = 1 + cuadrado(3)
print(cuadrado(b * 3))

Las variables que existen en el cuerpo de la función son locales, por ello se borran cuando acaba la
función y no alteran los valores de las variables globales. Llamamos variables globales aquellas que
existen fuera del cuerpo de las funciones.
LISTA
Una lista es una agrupación de datos de longitud variable, donde el acceso a cada elemento se
produce por indices (comenzando por cero) y puede contener distintos tipos de datos.

El tipo list se introduce simplemente encerrando entre corchetes la lista de datos, separados por
comas.
lista = [’velocidad’, 17, 3.1416]
v = [3, 4, 0]

Con len sacamos la longitud de la lista y con sum podemos sumar sus elementos si son numéricos.
Con max y min sacamos el máximo y el mínimo.
print(len(lista))
print(sum(v))
print(max(v))
print(min(v))
print (lista)
print(v)

Con sorted devolvemos los elementos de la lista de forma ordenada pero no modifica la lista.
print(sorted(v))
print(v)
v_ordenada=sorted(v)
print(v_ordenada)
Podemos concatenar listas, crear otras nuevas a partir de una existente o cambiar sus valores.

print(v+v)
otra=v+[100]
print(otra)
print(otra[0], otra[3])
otra[3]=7
print(otra[3])
print(type(otra[3]))
print(len(v))
Podemos añadir elementos a una lista con .extend y si es es uno solo con .append

v.append(12)
v.extend([13,14,15])
print(v)

Para eliminar un dato podemos hacerlo con .pop(posición) si conocemos su posición o si no le

indicamos nada borrara el ultimo elemento o con .remove(valor) si conocemos el valor a borrar. Si
el valor esta repetido, borrara el primer elemento con ese valor.

v.pop()
print(v)
v.pop(2)
print(v)
v.remove(13)
print(v)
Si usamos remove y el valor no esta en la lista se genera una excepción, por ello lo ideal es
comprobar que un valor esta en la lista con if 2 in v:

INSTALACIÓN WINDOWS
Descargamos python desde su pagina oficial:https://www.python.org/
Le daremos a instalar ahora:
Luego desactivaremos la longitud mínima del PATH:

Instalaremos PyCharm desde su pagina oficial

https://www.jetbrains.com/es-es/pycharm/download/#section=windows
Este entorno de desarrollo nos facilitara mucho el trabajo ya que genera entornos virtuales de forma
automática y de esta manera nos olvidamos de la gestión de nuestras librerías.
INSTALACIÓN LINUX
Tanto Python coo su gestor de paquetes pip vienen instalados en Linux, podemos comprobar la
versión con el comando python3 –version y si queremos cambiar de versión solo hay que
desinstalar el paquete de la versión que tenemos instalada e instalar la que queremos con apt-get.
Debemos instalar un gestor de entornos virtuales con apt install python3-venv
Crearemos un entorno virtual con python3 -m venv [directorio]
Para comenzar a trabajar activamos el entorno con source [directorio]/bin/activate

Y con deactivate lo desactivamos.

Con python3 nombrefichero.py ejecutamos un programa.

PUNTOS A MEJORAR O PARA POSTERIOR

MODIFICACIÓN
*Desarrollar mas lo ya escrito con gráficos, explicaciones y ejemplos

*Explicar el modelo vista controlador (MVC), aplicarlo así como sistemas alternativos

*C embebido

*algoritmos de ordenación (EDA) y arboles, grafos backtracking

*interactuar con bases de datos

*importar variables de fichero

*conjuntos, sets, gets, sort lambda, operadores binarios, arrays...

*Colas y pilas

*Objetos y herencia

*Acabar listas, funciones y cadenas

*Diccionarios

*Librerías como numpy, sys, so...

*Capacidad científica como procesamientos de datos satélites...

*Matrices y cadenas como listas

*Empleo en paginas web con django

*Anaconda

*IA

*Manejo de ficheros

*Captura y tratamiento de errores

*Break, continue, except, finally

*Mejorar explicación de los métodos

*Tratar rutas

*Compilar código

*Uso del depurador

*Uso del pip