Tema 4.
Introducción a la programación.
•
•
•
•
•
•
•
•
Lenguajes de programación
El lenguaje Python
Elementos del lenguaje
Tipos de Datos
Operadores y expresiones
Variables
Entrada y salida por terminal
Primeros programas
Iniciación a la Computación Científica.
Grado en Matemáticas. Curso 2021 - 2022.
Programación
 Problema  Algoritmo  Programa/Código (fuente)
 Pasos  diagrama de flujo  pseudocódigo  programa
 Diseñar  codificar  depurar  mantener (programas)
 Implementar  compilar vs. interpretar
 Lenguaje de programación: sintaxis, paradigma
 Lenguajes de alto nivel / de bajo nivel (código máquina)
 Lenguajes utilizados: Fortran, COBOL, Basic Pascal, C, Lisp,
SQL, HTML, PHP, Java, JavaScript, Ruby, C++, C#, … Python,
R, Mathematica, Maple, MATLAB, Octave, SageMath, Go, Swift
2
2020
¿Porqué Pyhton?
3
2020
Características de Python
•
•
•
•
•
•
•
•
•
•
•
•
4
Lenguaje de programación de alto nivel
Interpretado; (script) aunque puede ser compilado
De código abierto; compatible GNU
Fácil de entender por su sintaxis, y buen “estilo”
Extensible e integrable (C, Java, HTML, …)
Multiplataforma; adaptado a múltiples S.O.
Multiparadigma; soporta diferentes paradigmas de programación:
Orientación a Objetos (POO), Imperativa, Funcional, …
De tipado dinámico; cambio de tipo en tiempo de ejecución
Maduro (30 años); creado por Guido van Rossum en 1990
Mantenido por una gran comunidad; versión 3.9 (Mayo 2020)
Desarrollado por la PSF (Python Software Foundation)
Documentación e instalación: www.python.org
2020
Interpretando y Compilando
Las formas de trabajar con Python son:
 Interpretado:
No requiere de un compilador que traduzca el código escrito
en Lenguaje Python a un código ejecutable en el ordenador
 Interpretado en Consola
 Interpretado en Fichero

5
Compilado:
 Python se puede compilar:
 Usando módulos o herramientas intermedias como;
bytecode, compiler, py_compile,
pyinstaler, Cython, py2exe
2020
Interpretando en consola
Sesiones interactivas: escribes código y obtienes respuesta del intérprete
 Teclea python (o python3) en un terminal y se pulsa [intro]:
se presenta el indicador (prompt) >>> del intérprete de Python.
 Se escribe una línea de código pyhton y se pulsa [intro]:
se ejecuta la instrucción y se vuelve a mostrar el indicador >>>
tras mostrar el resultado si corresponde
 Si el código no es correcto se muestra un mensaje de error de sintaxis.
 Si la instrucción está incompleta:
se presenta el indicador secundario ... del intérprete en espera y
… se continua completando la instrucción
 Para salir, manteniendo [ctrl] pulsada, se pulsa d; ctrl-d (ctrl-z en Windows)
Ejemplos:
$ python3
>>> print("Hola")
Hola
>>> nombre = "Pepe"
>>> print("Hola", nombre, "!")
Hola Pepe !
>>> 2 + 3
5
>>>
6
>>> print("Hola",
...
"y adiós")
Hola y adiós
>>> 2 + algo
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'algo' is not defined
>>> [ctrl]-d
$
2020
Interpretando en fichero
No en el tema 4
 Se leen y se ejecutan una a una todas las instrucciones del fichero.
Por ejemplo, con este fichero
# Fichero hola.py
nombre = "Pepe"
print("Hola", nombre)
Se obtiene este resultado:
$ python hola.py
Hola Pepe
 Se hace ejecutable el fichero indicando en la primera línea la ruta al intérprete
Creamos el fichero con este contenido
• #!/usr/bin/python3
• nombre = "Pepe"
• print("Hola"+nombre)
•
- El shebang (#!) indica al S.O. que ejecute el script usando el intérprete especificado
$ chmod +x hola.py
$ ./hola.py
HolaPepe
7
2020
Elementos del lenguaje






•




Datos: información que se manipula con el lenguaje
Tipos de datos: cadenas, entero, real, booleano, listas, vectores, …
Variables: espacios de memoria donde asignar valores que pueden cambiar
Constantes: valores inmutables; cuyo valor no se puede cambiar
Identificadores: nombres que dar a distintos elementos
Operadores: indican operaciones a realizar con los datos; unarias o binarias
aritméticos (+,-,*,…) relacionales (>,<,…), lógicos (and,or,…)
Comentarios: aclarar el código (#, """, ''', …)
Funciones: realizan cálculos a partir de datos y parámetros
Expresiones: combinación de símbolos expresando fórmulas matemáticas
Instrucciones: órdenes para que se ejecuten en el ordenador
• Secuenciales: una detrás de otra; en secuencia
• Selectivas: si ocurre o no ocurre algo
• Iterativas: repite pasos con algún cambio
 Estilo y convenciones: recomendaciones de escritura; PEPs en Python
• Atender a la PEP 8 (https://www.python.org/dev/peps/pep-0008/)
8
2020
Tipos de datos
 Tipos de datos
 Simples: números (entero, real, complejo), cadenas, booleanos, …
 Compuestos: listas, tuplas, conjuntos, diccionarios, …
 Tipado dinámico
 La asignación de tipo a variables y objetos puede cambiar durante la
ejecución de los programas de forma muy sencilla.
No es necesario declarar el tipo de la variable sino que se determina
por el valor que se le asigna; así se le cambia el tipo al asignarle un
valor de otro tipo.
 Fuertemente tipado
 No se puede tratar una variable como si fuera de otro tipo distinto si
no se convierte antes de forma explícita.
La conversión del tipo de los datos se realiza de forma sencilla y
natural
9
2020
Datos simples
Tipos de datos simples:
 Números (numbers): Secuencia de dígitos representando números positivos o
negativos (usando el signo menos -), enteros o reales (con el punto decimal) o
complejos (usando j en lugar de i). Se pueden expresar números reales usando la
notación exponencial o científica y enteros en binario, empezando con 0b, en octal,
empezando por 0o, o en hexadecimales, empezando con 0x.
Ejemplos: 37, 0, -5, 2.1732, 3+2j, 0b110101, 0x7b2, 22.3e5, 0o56
Los números enteros se almacenan, en principio, con 8 bits; aunque pueden llegar
a alcanzar un tamaño ilimitado. Los números reales (float) se almacenan
representados en punto flotante y tienen doble precisión (16 cifras significativas).
 Cadenas (str, strings): Secuencias de caracteres alfanuméricos que representan texto.
Se escriben entre comillas simples o entre comillas dobles.
Ejemplos: 'Hola', "Buenos días", "¿Qué tal?", "13", "Don't", ...
 Booleanos (boolean): Este tipo contiene únicamente dos elementos:
True y False, que representan los valores lógicos verdadero y falso.
Estos datos son inmutables; su valor es constante y no puede cambiar.
10
2020
Números





Números (numbers): Secuencia de dígitos representando números.
Pueden tener signo menos “–” representando números negativos
Pueden tener punto “.” para representar números reales; “float”
Se puede usar la notación científica con “e” o “E”; p.e.: 1e-2, 2.4E7
Se pueden usar cualquiera de los símbolos “j” o “J” para representar
números complejos; p.e.: 2+3j
 Si empiezan con 0b, 0o o 0x son números en binario, octal o hexadecimal
Ejemplos:
>>> type(1)
<class 'int'>
>>> type(-2)
<class 'int'>
>>> type(3.4)
<class 'float'>
>>> type(5+6j)
<class 'complex'>
>>> type(0b1101)
<class 'int'>
>>> type(012)
11
>>> type(1+j)
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
NameError: name 'j' is not defined
>>> type(0b121)
File "<stdin>", line 1
type(0b121)
^
SyntaxError: invalid syntax
2020
Binario, hexadecimal, …
 Las funciones bin(), oct() y hex() dan una cadena con la expresión binaria,
octal o hexadecimal de un número entero. Ejemplos:
bin(111):'0b1101111', oct(111):'0o157', hex(111):'0x6f'
 Los números binarios se pueden operar bit a bit con &, |, ^, ~, << y >>
 Se pueden operar con los operadores aritméticos; el resultado es un entero
 Un número entero se representa con 8 bits; aunque pueden tener tamaño ilimitado
Ejemplos:
>>> 0b1101
13
>>> 0b111
7
>>> bin(20)
'0b10100'
>>> '0b1101' + '0b111'
'0b11010b111'
12
>>> 0b1101 + 0b111
20
>>> bin(0b1101 + 0b111)
'0b10100'
>>> bin(0b1101 * 0b111)
'0b1011011'
>>> hex(0xd+0x7)
'0x14'
2020
Cadenas
Se tratarán en el tema 8
 Cadenas (str, strings): Son secuencia de caracteres alfanuméricos que
representan texto. Se escriben entre comillas simples o dobles.
•
Ejemplos: 'Hola', "Buenos días", "¿Qué tal?", "123"
 Algunos caracteres especiales
•
>>> '' # cadena vacía
•
•
•
>>> ' ' # espacio en blanco
>>> '\n' # cambio de línea
>>> '\t' # espacio de tabulación
 Se accede a los caracteres de la cadena con su índice
•
•
•
>>> c[i] # carácter i de la cadena c
>>> c[0] # primer carácter de la cadena c
>>> c[-1] # último carácter de la cadena c
H
o
l
a
0
1
2
3
 Subcadenas.
•
Cad[i:j:k]: es la subcadena de Cad formada por:
• los caracteres de Cad entre i y j tomados cada k.
Ejemplo: 'Computación Científica'[1:8:3] es 'ouc'
 La operación: 'cadena' in 'subcadena' devuelve True
13
2020
Datos compuestos
Se tratarán en el tema 6
Tipos básicos de datos compuestos:
 Lista (list): Secuencia ordenada de objetos de distintos tipos.
Sus elementos se delimitan por corchetes y se separan por comas.
Ejemplo: [3.5, True, "Si", [2, 4.0]]
 Tupla (tuple): Secuencia ordenada inmutables de objetos de distintos tipos.
(se dice inmutables porque no puede cambiar durante la ejecución)
Sus elementos se delimitan por paréntesis y se separan por comas.
Ejemplo: (3.0, 'tres', 3)
 Diccionario (dict): Colección de objetos con una clave asociada a cada uno.
Se representan por pares separados por comas, donde cada par contiene una clave
y su objeto asociado, separados por dos puntos, y delimitados por llaves.
Ejemplo: {'pi':3.1416, 'seis':6, '3':3}
 Conjunto (set): Colección de objetos distintos sin ordenar.
Sus elementos se delimitan por llaves y se separan por comas.
Ejemplo: {3.1416, 'seis', 3}
14
2020
La función type
• La clase (class) o tipo de un dato se obtiene con el comando type()
Ejemplos:
>>> type(1)
<class 'int'>
>>> type(5.3)
<class 'float'>
>>> type(5+3j)
<class 'complex'>
>>> type("Hola")
<class 'str'>
>>> type([1, 2, 3, 4])
<class 'list'>
>>> type({'pi':3.1, 'e':2.7})
<class 'dict'>
>>> type((1, 'dos', 3))
<class 'tuple'>
15
Dudas:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
type(3.0)
type(3+0j)
type(3e0)
type('3')
type("3")
type([3])
type((3))
type({3})
type([])
type({})
type(())
type(0)
type(None)
2020
Conversión de tipos
Las funciones con el mismo nombre que un tipo convierten un dato a ese tipo,
siempre y cuando la conversión sea posible.
 int() convierte a entero
Ejemplos: int('12') 12, int(True) 1, int(3.2) 3, int('III') Error
 float() convierte a real
Ejemplos: float('3.1') 3.1, float(True) 1.0, float(5) 5.0,
 str() convierte a cadena
Ejemplos: str(3.14) '3.14', str(True) 'True', str(0b11) '3'
 complex() convierte a complejo
Ejemplos: complex(3) (3+0j), complex('1.7') (1.7+0j),
 bool() convierte a lógico o booleano
Ejemplos: bool(0) False, bool('2,7') True, bool('') False
 list(), tuple(), set() convierten a lista, tupla o conjunto
Ejemplos: list((1,2,3)) [1,2,3], tuple([2,7]) (2,7),
set([2,2,1]) {1,2},
list('Hola') ['H','o','l','a']
Dudas: bool(), bool('0'), bool(-1), bool(0.1), bool(0.0),
float(4+0j), float('5'), int('five'), ...
16
 Nota: Las partes real e imaginaria de un complejo c se obtienen con: c.real y c.imag
2020
Operadores aritméticos
 Los operadores aritméticos son:
suma | resta | producto | división | potencia | división entera | resto entero
•
+ | - |
*
|
/
|
**
|
//
|
%
Ejemplos:
•
•
•
•
•
•
•
2+3
3-2
6*3
4/2
3**2
5//3
Se aplican a datos numéricos; números, no necesariamente del mismo tipo
El tipo del resultado depende del operador y del tipo de los operandos.
Ejemplos: 7//1.2 3.1–2.1 6.7%2.1 4.2/2.1 8j/2j
Si los operandos son de distinto tipo, se convierten a un tipo común para su operación
La división / entre dos enteros, aunque sea exacta, da un real (float).
Ejemplos: 8*1.5 6.7%2 28/2 4**0.5 8j/2j (-1)**0.1
Los operadores // y % se pueden usar con reales pero no con complejos
Observar el comportamiento de // y % con operandos negativos
Ejemplos: -7//2, -7%2, 7//-2, 7%-2, -7//-2, -7%-2
Algunas operaciones dan un resultado sorprendente; hay que experimentar y analizar
Ejemplos: 2/3, 7//0, 2.2-1.2, 5%1.2, (-1)**0.5, 10**100
 Operadores aritméticos unarios: positivo (+), negativo (-):
•
+3.2, -7,
-0b101,
5-3j,
-2+1.7,
17
13%3
2*-3, 3**-2
2020
Operadores lógicos
 Operadores de comparación:
Los operadores relacionales o de comparación son:
•
•
mayor que | menor que | igual | mayor o igual |
>
<
==
menor o igual | distinto.
>=
<=
!=
Ejemplos: 2>3 | 3.0==3 | 4>=5 | 5.2<=7 | 'a'>'b' | 2.8<3 | 3!='3'
'Hola'<'hola' | 0.6/2 == 0.3 | 0.1+0.2 == 0.3 | 'a'=="a"
• Se pueden comparar datos del mismo tipo y, a veces, de tipo distinto.
 Operadores booleanos:
Los operadores booleanos son tres:
“y”: and
|
“o”: or
|
“no”: not
Ejemplos: True and 2>3 | ('2' != 2) or False | [1,2] == (1,2) | not True
Nota: obsérvese el uso de mayúsculas y minúsculas con datos y operadores booleanos
•
18
•
Las comparaciones se pueden encadenar:
2 < 5 <= 7 equivale a (2 < 5) and (5 <= 7)
(la comparación, 2 < 5 > 3, aunque poco elegante, es válida)
•
Los datos booleanos True y False tienen asociados los valores enteros 1 y 0
Dudas: >>> 2-(3==-1)
>>> 2==3
-1>1
>>> true = False - 1
2020
Operaciones en binario
No en ICC
 Los operadores binarios operan bit a bit con la expresión en binario
 Se usan 8 bits para representar enteros; los negativos con complemento a 2
 Son los operadores:
&
|
^
~
<<
>>
• El operador binario & calcula la operación “and” bit a bit.
• El operador binario | calcula la operación “or” bit a bit
• El operador binario ^ calcula la operación “xor” bit a bit
• El operador unario ~ invierte los bits de su operando
• El operador binario << desplaza los bits a izquierda que indique
• El operador binario >> desplaza los bits a derecha que indique
Ejemplos:
>>> 5&12 # 00000101 & 00001100
4
# 00000100
>>> 5|12 # 00000101 | 00001100
13
# 00001101
>>> 5^12 # 00000101 ^ 00001100
9
# 00001001
19
>>> ~5
-6
>>> 5<<2
20
>>> 5>>1
2
#
#
#
#
#
#
~00000101
11111010
00000101<<2
00010100
00000101>>1
00000010
2020
Expresiones
Las expresiones son combinaciones de datos y operaciones entre ellos:
 Hay que tener en cuenta la precedencia de las operaciones y la asociatividad
Ejemplos: 1 * 2+3, 3*4/2, 12 / 3*2, 3**2**3, 4>3+3
 Prioridad: 1) potencias 2) productos/cocientes 3) sumas/restas 4) comparaciones
Ejemplos: 2*5+3, 2*5**2, 2**3*4, 2+3*2**3, 1>0+1
 Asociatividad: por grupo:
• Sumas/restas:
5-3-2,
• Productos/cocientes: 12/4/2,
• Potencias:
3**2**3,
(5-3)-2
(12/4)/2
3**(2**3)
por la izquierda
por la izquierda
por la derecha
 Con la misma prioridad, el orden dado por la asociatividad
Ejemplos: 5 - 1+3,
6 / 4*2,
8 / 4/2,
7 – 4-2
 Cambio del orden con paréntesis ( ); no se pueden usar [] ni {}
Ejemplos: 1–(2+3), 12/(3*2), 2 * (5+3), (3**2)**3
 El uso de espacios es arbitrario:
Ejemplos: -2 * 5+3, -2*5 + 3, -2*5+3, - 2*5+3
20
2020
Variables
 Las variables son espacios de memoria donde almacenar datos a los
que se accede mediante su nombre o identificador.
 Para asignar un valor a una variable se utiliza el operador “=”, y
para borrar una variable se utiliza la instrucción del.
 No se puede usar una variable a la que no se le ha asignado un valor.
Ejemplos:
lenguaje = 'Python'
Nombre = "Pepe"
x = 3.25
n = 25
y = 3 + 2
a = x + y
b = 4*x + y
media = suma/n
# ERROR
5 = m
# ERROR
a = 3x+2
# ERROR
mi_lista = [1, 'dos', (1,2), {0,1}]
21
2020
Asignaciones




Las asignaciones son las acciones de introducir valores a variables.
La asignación determina el tipo de la variable; no se declaran previamente
Se usa el signo = con la variable a la izquierda y una expresión a la derecha
Puede realizarse junto a otra acción:
a1, a2 = 1, 2
a, b = b, a
x += 2
x -= 1
x = None
del x
#
#
#
#
#
#
Asignación múltiple: a1 = 1, a2 = 2
Intercambio de valores: a <--> b
Incremento (equivale a x = x + 2)
Decremento (equivale a x = x - 1)
Asigna un valor no definido
Elimina la variable
 Asignaciones con operador: Todos los operadores aritméticos tienen su
operador de “asignación con operador” asociado.
Son los siguientes: += -=
*=
/=
**=
//=
%=
Ejemplos: x *= 2, x /= 0.1, x //= y, y **= 2
22
2020
Identificadores
 Identificadores:
Un identificador es un nombre con el que se hace referencia al contenido
de una variable o de una constante, o a una función, o a cualquier objeto …
 Elección de buenos identificadores:
 Formado por letras, números y guion bajo “_”
 No pueden contener espacios ni otros símbolos: *, /, +, -, : …
 Comienzan con una letra (mayúscula o minúscula)
 Se distingue entre mayúsculas y minúsculas
 No se pueden usar palabras reservadas:
(palabras que ya tienen un significado en Python)
 Deben ser naturales, significativos, claros, . . .
 En Python se suelen usar identificadores en minúsculas y con el guión
bajo “_” para separar las palabras que componen un identificador
 Ejemplos:
número_de_filas, tamaño_de_la_muestra, n_col
23
2020
Tipado dinámico
• A diferencia de otros lenguajes, las variables en Python no tienen asociado
un tipo y no se declaran antes de usarlas
• El tipo de una variable se establece al asignarle un valor.
Si a una variable se le asigna un entero, será de tipo int, pero si después se
le asigna un dato real a la misma variable, pasa a ser float.
• Esto es lo que se conoce como tipado dinámico.
Ejemplo:
>>> a = 3
>>> type(a)
<int>
>>> a = 2.3
>>> type(a)
<float>
24
•
•
No se permite tratar a una variable como si fuera de
un tipo distinto al que tiene, es necesario convertirla
de forma explícita al nuevo tipo previamente
Esto es lo que se conoce como fuertemente tipado.
Ejemplo:
>>> a = 3
>>> float(a)
3.0
>>> type(a)
<int>
2020
Conversión de tipo
 Para cambiar el tipo del dato de un variable basta con usar el nombre o
identificador del tipo como función, pero la variable no cambia.
Ejemplos:
>>>
>>>
1
>>>
1.0
>>>
>>>
3.0
>>>
3
>>>
>>>
3
y = 1.0
int(y)
y
z = 3
float(z)
z
x = 3.2
int(x)
>>> y = (1,2,3)
>>> list(y)
[1, 2, 3]
>>> y
(1,2,3)
>>> y = 5
>>> str(y)
'5'
>>> y = float('5.8')
>>> y
5.8
>>> y = 1e3
>>> str(y)
...
• Para cambiar el tipo de la variable es necesario hacer una asignación de la
forma: variable = tipo(variable)
Ejemplos: y = int(y)
z = float(z)
x = complex(x)
25
2020
Operando con float
 Los números reales o racionales (float ) se almacenan en base 2 (binario)
Por ejemplo: 0.125 en decimal es 0.001 en binario (0.125 = 1 · 2-3)
 Hay fracciones sencillas no tienen representación decimal exacta como 1/3 = 0.33333…
 Paralelamente, la mayoría de los decimales no tienen representación exacta en binario
Por ejemplo: 0.1 en binario es 0.00011001100110011001100...
 Los números que se almacenan no son decimales exactos sino aproximaciones,
por lo que no se pueden esperar siempre resultados exactos
Por ejemplo: 0.1 + 0.2 no da 0.3, 0.6/3 no da 0.2, 0.3%0.1 no da 0.0
Ejemplo:
>>> 0.1 + 0.2
0.30000000000000004
>>> 0.6/3
0.19999999999999998
>>> 0.1+0.2 == 0.3
False
>>> 0.3 % 0.1
0.09999999999999998
>>> 0.3 // 0.01
29.0
>>> 2 // 0.01
19.0
 Para eludir estos problemas Python cuenta, entre otras posibilidades, con
los módulos decimal y fractions y con la función round.
26
2020
Entrada por terminal
No se usa en el tema 4
 Función input: para asignar a una variable un valor introducido por el usuario en la
consola se usa la función input(mensaje), que muestra la cadena mensaje por la
terminal y devuelve una cadena con la entrada del usuario; siempre se devuelve una
cadena, incluso si el usuario introduce un dato numérico.
 Ejemplos:
>>> nombre = input('¿Cuál es tu nombre? ')
¿Cuál es tu nombre? Pepe
>>> nombre
'Pepe'
>>> edad = input('¿Cuál es tu edad? ')
¿Cuál es tu edad? 37
>>> edad
'37'
>>> edad = int(input('¿Cuál es tu edad? '))
>>> ¿Cuál es tu edad? 37
>>> edad
37
>>> edad = int(input('Pon tu edad real, '+nombre+': '))
>>> Pon tu edad real, Pepe: 47
>>> edad
47
27
2020
Salida por terminal
No se usa en el tema 4
 Función print(): para mostrar un dato por la terminal se utiliza la función print()
que, en general, puede tener los parámetros sep y end, de la forma:
print(datos, sep=' ', end='\n')
Donde datos son los datos a imprimir (pueden indicarse tantos datos como se desee
separados por comas), sep es el separador entre los datos; por defecto es un espacio
' ' y end es la cadena final de impresión; por defecto es un cambio de línea; '\n'
Ejemplo:
>>> print('Hola')
Hola
>>> nombre = 'Pepe'
>>> print('Hola', nombre)
Hola Pepe
>>> print('Hola', nombre, sep='')
HolaPepe
>>> print('Hola', nombre, end='!\n')
Hola Pepe!
 El formato de cadena (f-string) especifica como se imprimen números dentro de un
texto, para enteros el ancho en dígitos (tras los pos puntos : y antes de la letra d) y
para reales, además, la precisión (tras el punto . y antes de la letra f) de la forma:
Ejemplo:
>>> n, x = 12, 7.1234
>>> print(f'El entero es {n:4d} y el real es {x:6.2f} ')
El entero es
12 y el real es
7.12
>>> print(f'El entero es {10*n:4d} y el valor {10*x:6.2f} ')
El entero es 120 y el real es
71.23
28
2020
Comentarios No se usa en el tema 4
 El objetivo al introducir comentarios en el código fuente es explicar o
aclarar cómo está hecho el programa.
 Los comentarios son ignorados por el intérprete o compilador.
 """ o ''' delimitan los comentarios que pueden ocupar más de una línea.
 # especifica el comienzo de un comentario de una línea.
 Los comentarios apropiados dan calidad al código.
 Los espacios en blanco (horizontales y verticales) dan estructura
Ejemplos:
a = 3
# esto es un comentarios en una línea
""" esto es un comentario
que puede ocupar
varias líneas
"""
''' Esto es otro comentario '''
29
2020
Programas o script
No se usa en el tema 4
 Ejemplos: crear un fichero llamado ejemplo1.py con este contenido:
# CÓDIGO PYTHON PARA EL CÁLCULO DEL ÁREA DE UN TRIÁNGULO
print('\n Programa calcular el área de un triángulo\n')
base = float(input('¿Cuál es la base del triángulo? '))
altura = float(input('¿Cuál es la altura del triángulo? '))
print('El área del triángulo es:',base*altura/2)
Teclea en la consola: pyhton ejemplo1.py
Otro ejemplo: ejemplo1.py
''' El Índice de Masa Corporal (IMC)
se calcula dividiendo el peso (en kg)
por el cuadrado de la estatura (en m) '''
print('\n Cálculo del ICM (peso en kg)/(altura en m)^2')
peso = float(input('¿Cuál es el peso (en kg)? '))
estatura = float(input('¿Cuál es la estatura (en m)? '))
print('El IMC es:',round(peso/(estatura**2),2))
 Añadir #!/usr/bin/python3 en la primera línea para que Linux encuentre el
intérprete, si es necesario
30
2020
Uso de variables
 Ejemplos: cambiando entre formas de expresar el tiempo
#!/usr/bin/python3
# Programa para calcular horas, minutos y segundos
tiempo = int(input('Tiempo total en segundos: '))
print("Equivale a", tiempo//3600, "horas, ",
tiempo//60-60*(tiempo//3600), "minutos y",
tiempo-60*(tiempo//60), "segundos")
#!/usr/bin/python3
# Cálculo de horas, minutos y segundos a partir de tiempo
t = int(input('Tiempo total en segundos: '))
h = t//3600
m = t//60-60*h
s = t-60*(m+60*h)
print("Equivale a", h, "horas, ", m, "minutos y", s, "segundos")
31
2020
Repaso
 ¿Qué ocurre al usar el operador // con reales? Poner tres ejemplos.
 ¿Qué resultado se obtiene al usar el operador % con números negativos?
Poner tres ejemplos.
 ¿Qué ocurre al usar el operador ** cuando el primer operando es negativo y
el segundo en menor que 1? Poner tres ejemplos.
 Comprobar con los operadores // y % que la igualdad
“dividendo = divisor * cociente + resto”
se cumple también para números reales y números negativos
 ¿Qué responde Python al dividir por 0?
 ¿Qué ocurre en Python si aparecen dos o más operadores consecutivos?
p.e.: +-3, 3*-+5, 2++3, 3--2, 2/-4, 3.2%-2, 2-/5, 3* ¿Cómo se le cambia el tipo a una variable? De entero a real o real a entero
 ¿cómo se obtiene la parte fraccionaria de un real? ¿porqué muchas veces no
se obtiene el valor exacto en esto?
 ¿Cuál es el número más grande que puedes tener en Python?
32
2020
33
2020