Programación:

Hardware: parte física de la máquina.

Software: parte lógica, programas.

S.O.: Conjunto de programas que interactúan con y controlan directamente el hardware. Capa
inferior del software.

Lenguaje de programación: lenguaje formal diseñado para realizar procesos que pueden ser
llevados a cabo por máquinas como las computadoras. Un lenguaje de programación es:

 Preciso
 Restringido
 Tiene una sintaxis

Una máquina, en abstracción, funciona con ceros y unos. Es decir, con posiciones que bien
tienen o no tienen carga eléctrica.

Un bit es un valor de memoria que puede tener dos estados posibles. Las combinaciones de
bits se dan normalmente en potencias de 2. Un byte = 8 bits.

Cuando se dice que un ordenador tiene arquitectura de 64 bits, significa que el procesador
recoge y procesa 64 bits de información en cada ciclo.

Script: Programa escrito en código fuente. Se usa más para código interpretado.

Depurar un programa: corregir los errores. Eliminar los errores que contenga.

Errores:

- Sintáctico: es un error que detecta el intérprete porque no entiende lo que nosotros

hemos escrito.
- Semántico: el programa está bien escrito, pero no produce el resultado que
esperábamos. Cuando ocurre suele ser porque el algoritmo estaba mal planteado.

Bug: error.

Debug: depurar, en inglés.

Debugger: programa que nos ayuda a buscar y corregir errores.

Para escribir un programa primero tengo que pensar lo que quiero hacer.

Python: más fácil de aprender, potente, sencillo sintácticamente. Más moderno, propósito
general y multiplataforma.

Memoria RAM: se divide en posiciones de memoria (donde se puede leer o escribir -> CPU).

Dentro de estas posiciones hay posiciones más pequeñas (valores altos y bajos).

Bus: es el que lleva la información a los distintos componentes.

8 byte = 64 bits -> bloques de tamaño fijo.

1 byte = 8 bits.
Introducción a Python:

Los registros de la CPU son muy rápidos.

Código fuente (Alto Nivel): Por ejemplo, Python. Fácil de entender para el programador, pero
difícil para la CPU. Por eso hay que traducirlo a código máquina y se pueda ejecutar.

La traducción la hace un programa. Existen dos formas de traducción: Intérprete o Compilador.

Cuando le damos a Run en el programa está INTERPRETANDO.

Algoritmo: Serie de pasos a seguir para resolver un problema.

PYTHON:

Una constante o literal es un valor inalterable. No cambia.

Todos los lenguajes de programación tienen tipos de constantes. Hay clases de constantes
diferentes:

Int = número entero. Operadores = [+ - * / // ** ()]. Operadores de comparación= [==

“significa igualdad y comprueba si es TRUE o FALSE”] [= “para asignar”]

Str (string) = cadena. Operadores = “+” se llama concatenación. Ejemplo: (‘a’) + (‘b’) 
resultado ‘ab’. Porque los junta. Operadores de comparación= [== “significa igualdad”] [=
“para asignar”]. SIEMPRE ENTRE COMILLAS ‘’

Float = números decimales. Operadores = [+ - * / // ** ()]. Operadores de comparación= [==

“significa igualdad”] [= “para asignar”].

Bool = Solo puede tener dos valores posibles ‘True’ o ‘False’

------------------------------------------------------------------------------------------------------------------------------

FUNCIONES (devuelve un valor, pero no modifica el argumento/parámetro)

Funcionalidad predefinida del lenguaje = nombre (parámetros)  eso da un VALOR

Por ejemplo= abs (-7)  7 Este sirve para saber el valor absoluto de ese número

Ejempl. type (8)  Sirve para saber el tipo de constate a la que pertenece 8.

Type (‘David’)  reconoce David como una cadena de caracteres. Sin comillas da fallo
porque cree que es una variable.

Ejemplo: Len (‘Hola David’)  mide la longitud de la secuencia que sería 10 contando el
espacio en blanco

Ejemplo: min (3,-8,9,3,76,0)  el resultado dice el menor de todos que es -8

min (‘a’, ‘b’)  te dice el valor menor que es “a”

Ejemplo: max (7,9,8,3,4,5)  te dice el valor máximo “9”

Ejemplo: print (‘Hola’, Var, 3+x)  una salida de la máquina a la pantalla

Ejemplo: input (‘introduce un número’)  una entrada del teclado a la máquina y el texto de
dentro es una petición en pantalla para el usuario. El número que introduce el usuario se
guarda en una variable (var = input (‘introduce un número’)).

Todas las entradas de teclados son de tipo str. Si queremos que los use como número tenemos
que hacer una conversión.

Ejemplo: range(n) produce un objeto iterable que devuelve valores numéricos de 0 a n-1

n=el número de repeticiones

range(a,b): dará a, a+1,a+2,a+3….hasta b excluida.

range(start=incluido,stop=excluido,steps=cantidad de salto).

 Stop +1 hará que esté incluido.

--------------------------------------------------------------------------------------------------------------------------

FUNCIONES DE CONVERSIÓN

Sirven para cambiar de tipo. Y siempre coinciden con los nombres de los tipos:

Si quiero convertir a Int  int (var)  int (‘121’) resultado: 121 ya es entero y no de tipo str
como antes.

Cuando una variable se crea con el mismo nombre se destruye la anterior:

Ejemplo: En el ejemplo pepe al principio era de tipo literal/str pero al crear la nueva variable
ahora pepe es entero. Convertir de str a int

Convertir de float a str: Da error al guardarlo en una variable cadena. Porque con str (numero)
solo estamos pidiendo una respuesta. No guardamos el resultado hasta que no la guardamos
en una función cadena.
Ejemplo de convertir a float:

Convertir Bool a int :

Convertir tres a bool:

------------------------------------------------------------------------------------------------------------------------------

Una variable se crea en el momento en el que se asigna.

Una variable no tiene un tipo predefinido y no se define.

Se dice que python es un programa multitipo.

¿Cómo se construye una variable?

Nombre de la variable = constante

Por ejemplo: >>> x=13

>>> print (x)  dirá 13

También puede ser de forma más completa: Nombre de la variable = <expresión>

“<Expresión>” puede ser una constate, una variable, o una combinación de variables,
constantes y operadores…etc.

Ejemplo: d=3

X=d  resultado dará 3

Ejemplo: x= 10**10

x= 10000000000

Primero se evalúa la expresión (10**10) y el resultado se guarda en la variable (x).

Ejemplos:

Crear variables (nombre, apellido y completo) y aplicarles funciones (min):

También comparamos con los bool:

COMENTARIOS (Se usan como documentación interna de programa):

De línea #  Lo que hay después de ese carácter no lo lee el intérprete.

Multilínea ‘’’-----------

-------

-------------

------‘’’  Una cadena de caracteres que no lee el intérprete. (tres comillas)

Pondremos siempre el uso de Docstream en funciones para explicar que hace la función

Actividad clase 1: Hacer un programa que nos pregunte nuestro nombre y nos responda Hola +
el nombre. El prompt es el mensaje que se envía al usuario, ayuda a que el usuario sepa que
tiene que escribir algo.

IDENTIFICADORES: Nombres que le damos a algo (variables, clases, referencias…).

- No deben coincidir con palabras reservadas del lenguaje. Por ejemplo, no debo llamar
a algo Bool como el tipo…me puedo equivocar.
- Respetaremos todas las normas de estilo de Python.
o Solo usar minúsculas
o Si quiero hacer un espacio entre palabras pondremos un guion bajo.
 o Cualquier operador va precedido de espacios (x + y)
- No se dejan espacios en blanco NUNCA. Porque es un separador.
- Para los nombres de clases: Los nombres empiezan por mayúscula y lo demás
minúscula. Si hay más de una palabra en el nombre usaremos la notación Camello 
Suma Total.
- Solo se pueden usar Letras, Números y guion bajo.
- Tienen que ser significativos. Que al programador le recuerde a algo.
- Para constantes definidas por el usuario SIEMPRE van en MAYÚSCULA.
IVA_REDUCIDO = 4, PI = 3.1415
- Cuando una variable empieza por _ tienen un uso privado.

CADENA DE CARACTERES: Es una secuencia indexables y segmentables

Ejemplo. Cadena = ‘Hola don Pepito’

Indexación:

Las cadenas de caracteres siempre tienen un índice: cadena [n]. Eso te dice la posición del
carácter. Empiezan a contar desde 0 hasta n-1, n-1.

Para saber el último valor de la cadena:

Segmentación: Nunca tiene fallo fuera de rango. Incluye el primer valor y excluye el ultimo

Para ver un segmento:

Cadena vacía es un stream que no contiene ningún carácter. Y se representa como: ‘_’

Cadena [3 :]

3 = Inicial

: = Final

Cadena [: 7]

7 = excluida
[a : b]

a = incluida

b = excluida

Si no se dice nada del programa la ejecución es secuencial.

S1

S2

S3

Sentencia de control de flujo: podemos cambiar que la ejecución de un programa no sea

secuencial.

While Condición

Se utiliza para que se repita muchas veces (bucle) una condición si es verdadera, y no parará
hasta que esta sea falsa.

Sentencias

False
¿Condición?

True

Sentencia -

- -

-
Una condición es cualquier expresión válida que devuelva un valor booler.

Los bloques de sentencia en Python no se representan con delimitadores.

Ejemplo:

x=1

While X > 0 :

print (x)

Dará 1.

x=1

x=x+1

While X > 0 :

print (x)

Dará 2.

Ejemplo: escribir desde uno hasta 9:

Ejercicio 1: escribir desde uno hasta un millón:

Ejercicio 2: escribir los 1000 primeros números pares con la siguiente estructura:

Orden N.º Par

1 2

2 4

3 6

. .
. .
. .
. .
1000 2000

Ejercicio 3: cuantos números queremos que saque por pantalla (10) y de quien queremos que
sea el múltiplo (5) (es una variación del ejercicio anterior).

Orden múltiplo
1 5
2 10
3 15
. .
. .
. .
. .
10 50
4. Escribir un programa que nos pida el radio de un círculo y que imprima el área. También
que nos diga el número de cálculos realizados:

Esquema de lectura adelantada: Se define un esquema de lectura adelantada cuando se lee

fuera del bucle, compara la condición, procesa y vuelve a empezar.

Lectura

Mientras condición : (pregunto)

Procesa

Lectura

Lectura

(También se usa para leer ficheros…etc.)

CONTADOR: N=n+1  es un contador

Lectura de valor
 Mientras condición:

Procesa valor

LECTURA

Sentencia de control de flujo (condicional):

If condición

Proceso

- Condición False

- True

Otra sentencia de control de flujo es el IF y ELSE. En estas se compara la condición y si cumple

PROCESO
con los requisitos, ejecuta el procesoA, si es falso usamos el else y se ejecuta el procesoB.

if condición : True False

- Condición
Proceso A
-

else : (si no) PA PB

Proceso B

PA o PB

5. Escribir un programa que nos pida el nombre y la edad. Si somos mayores de 18 nos
pondrá un don o doña delante del nombre.
Ejemplo de Uso de while:

Ejemplo de que no se ejecuta While: porque uno no es mayor que 10 entonces no se ejecuta.

Cntr+C= interrumpimos la ejecución del programa.

Ejemplo clase con While: Escribir todos los números naturales entre uno y un millón:

ELIF: Es una opción por si no se cumple la primera condición IF …. De manera que hay otra
opción que si se cumple la condición y ejecuta su parte. En un bloque de elif solo se ejecuta un
bloque. Si se ejecuta uno, el resto no (si se ejecuta B, se ejecuta solamente B).

If condición

(ejecutar A)
elif condición

(ejecutar B)

elif condición

(ejecutar C)

else :

(ejecutar D)  Else se ejecuta cuando no se cumple ninguna de las 3 condiciones.

FOR es otro tipo de while: La siguiente estructura nos describe una variable que toma un valor
de forma automática y consecutiva para cada elemento de la secuencia:

For elemento in secuencia:

Procesa elemento || Bloque de sentencias

Ejemplo:
Se asigna variable que almacene la cadena (cadena=…)
For carácter in cadena:
Print (caracter)

Ejemplo del uso de For con función range:

Asignar variable texto (texto=…)
For i in range (0,130,1)
Print (texto[i])

Ejemplo: for i in range(10,20)

Print (i)
-------------------------------------------------------------------------------------------------------------------------
Conjunciones

x AND y, =true/false Comprueba si las dos son verdad. Y si una de las dos no se cumple es
FALSE.
Ejemplo: Asignas la variable x y le das un valor (ej. X=5). Y luego hacemos lo que viene a
continuación:

x>o and x<100  True (porque x es mayor que 0 y menor que 100, se cumplen las dos)

Por lo tanto, en todas las conjunciones AND ocurrirá lo siguiente:

True and true = true

True and false = false

False and true = false

False and false = false

------------------------------------------------------------------------------------------------------------------------------

Disfunciones

x OR y = true/false

Cuando se define una función no se ejecuta.

Cuando se invoca la función se copia el valor del argumento sobre el parámetro formado y se
ejecuta el cuerpo de la función con el valor del parámetro actual.

Después de ejecutarse se transfiere el control de la llamada a la línea posterior.

Ventajas de una función:

- Reutilización del código.

- Facilidad de depuración.
- Legibilidad del programa.

Existen dos tipos de funciones:

Funciones procedimentales: realizan una tarea, pero no devuelven un valor.

Funciones de valor: calculan un resultado y lo devuelven.

Deben estar separadas en la tarea de devolver un valor (no mezclarlas).

Todos los programas los vamos a escribir siguiendo un orden:

- Arriba los import.

- Después la definición de constantes.
- Después la definición de variables globales.
- Después las declaraciones de funciones.
- Después de hacer todo eso (debajo) ponemos el código ejecutable.

El ámbito de una variable (de un identificador) es el área de programa donde se reconoce a

esta variable.

En Python se puede utilizar una variable global dentro de una función, pero no puedo
modificarla.
Si la variable está dentro de la función se llama variable de ámbito local. Es conocida sólo
dentro de la función.

Una variable local es reconocida con prioridad dentro de su ámbito.

X = 0  fuera

def algo ():

x=3  dentro (prioridad)

print(x)

print (x)  fuera

algo ()

docstring = es una forma de auto documentación del programa.

Def f(x)

‘’’----------------------

-----------------

‘’’

f(a)

help: Nos ofrece una ayuda. Da una breve explicación de la función.

help (len)

Si la función calcula y devuelve un valor no imprime.

Una función de cálculo no debe tener ni entradas ni salidas. La entrada a la función se realiza a
través del parámetro y la salida de la función a través de un return.

Una función de Python siempre devuelve algo.

Si no le pongo return devuelve None.

Return: devuelve un valor y sale de la función.

Por tanto, el código de debajo de return es código muerto.

En una función puede haber más de un return, pero tiene que estar en una ejecución
condicionada (if).