Tipos Básicos

Enteros
In [1]:
2 + 4 # suma

6
Out[1]:

In [2]:
3 * 5 # multiplicación

15
Out[2]:

In [3]:
4 - 7 # resta de números enteros

-3
Out[3]:

In [4]:
8 // 0 # división entera, cociente

---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
/tmp/ipykernel_11442/3652237582.py in <module>
----> 1 8 // 0 # división entera, cociente

ZeroDivisionError: integer division or modulo by zero

In [5]:
8 % 3 # división entera, resto

2
Out[5]:

In [6]:
2 + 4 * 3 # la multiplicación tiene prioridad

14
Out[6]:

In [7]:
(2 + 4) * 3 # los paréntesis cambian esa prioridad

18
Out[7]:

In [8]:
2 ** 3 # potencia

8
Out[8]:

In [15]:
a = 5 # utilizamos el nombre a para acceder a un valor
b = a * 3 # podemos utilizar los nombres en las expresiones
a = 2 * a # se evalúa la expresión y se modifica el valor almacenado en a
a, b

(10, 15)
Out[15]:
 Los nombres de las variables pueden ser cualquier sucesión de letras y números, que no
empiece por un número. Hay que exceptuar las palabras reservadas del lenguaje:

In [16]:
help("keywords")

Here is a list of the Python keywords. Enter any keyword to get more help.

False class from or

None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for not

In [17]:
a = c * 3

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
/tmp/ipykernel_11442/686153141.py in <module>
----> 1 a = c * 3

NameError: name 'c' is not defined

In [18]:
n = 7
(n * (n + 1)) // 2 # los paréntesis no hacen falta en esta expresión

28
Out[18]:

In [19]:
def poli(x):
"""
Función que devuelve el valor del polinomio 3*x^2-4*x-6 en el punto x
"""
c2 = 3 * x**2
c1 = -4 * x
c0 = -6
return c2 + c1 + c0

poli(5)

49
Out[19]:

In [20]:
def poli(x):
"""
Función que devuelve el valor del polinomio 3*x^2-4*x-6 en el punto x
"""
s = 0
pot = 1
s = s + (-6 * pot)
pot = pot * x
s = s + (-4 * pot)
pot = pot *x
s = s + (3 * pot)
return s
 poli(5)

49
Out[20]:

Reales, aritmética de coma flotante

In [21]:
a = 2.0 # El punto indica la coma decimal
b = 3.0
a + b # suma

5.0
Out[21]:

In [22]:
a * 7.0 # multiplicación

14.0
Out[22]:

In [23]:
type(round(3.73))

int
Out[23]:

In [24]:
b = 10
type(b)

int
Out[24]:

In [25]:
a / 6.0 # división entre reales

0.3333333333333333
Out[25]:

In [26]:
a * 7 # los enteros se convierten en reales automáticamente

14.0
Out[26]:

In [27]:
3 / 2 # dividir dos enteros da un real (recordar que para la división enter

1.5
Out[27]:

In [28]:
def poli(x):
s = 0.0
pot = 1
s = s + (-6 * pot)
pot = pot * x
s = s + (-4 * pot)
pot = pot *x
s = s + (3 * pot)
return s

poli(5)
 49.0
Out[28]:

In [29]:
2.0 ** 3.1 # potencia

8.574187700290345
Out[29]:

In [30]:
math.pi

---------------------------------------------------------------------------
NameError Traceback (most recent call last)
/tmp/ipykernel_11442/929699079.py in <module>
----> 1 math.pi

NameError: name 'math' is not defined

In [31]:
import math # podemos usar muchas funciones matemáticas

In [32]:
radio = 3
2 * radio * math.pi # math.pi es un nombre que contiene el número pi

18.84955592153876
Out[32]:

In [33]:
math.sin(math.pi/3) # math.sin, el seno del ángulo en radianes

0.8660254037844386
Out[33]:

In [34]:
math.cos(math.pi/3) # math.cos, el coseno. Obsérverse el error obtenido

0.5000000000000001
Out[34]:

In [35]:
math.sqrt(5) # la raíz cuadrada

2.23606797749979
Out[35]:

In [36]:
int(3.9) # construye un entero truncando la parte decimal

3
Out[36]:

In [37]:
int(-3.9)

-3
Out[37]:

In [38]:
round(3.2)

3
Out[38]:

In [39]:
round(3.5)
 4
Out[39]:

In [40]:
round(-3.5)

-4
Out[40]:

In [41]:
round(-3.2)

-3
Out[41]:

In [42]:
math.floor(3.7)

3
Out[42]:

In [43]:
math.floor(-3.2)

-4
Out[43]:

In [44]:
math.ceil(3.2)

4
Out[44]:

In [45]:
math.ceil(-3.2)

-3
Out[45]:

Complejos
In [46]:
z = complex(2, 4) #números complejos
z**2

(-12+16j)
Out[46]:

In [47]:
# la unidad imaginaria es j
(2+3j)**2 # otra notación

(-5+12j)
Out[47]:

In [48]:
import cmath
cmath.sqrt(1.0) # en el módulo cmath se encuentran las versiones complejas

(1+0j)
Out[48]:

Booleanos
In [49]:
a = True # valor lógico de cierto
b = False # valor lógico de falso.
In [50]:
a and b # conjunción lógica

False
Out[50]:

In [51]:
a or b # disyunción lógica

True
Out[51]:

In [52]:
a or True

True
Out[52]:

In [53]:
b and False

False
Out[53]:

In [54]:
a = 2
b = 4
b == a * 2 # la comparación devuelve un valor lógico

True
Out[54]:

In [55]:
a * 3 >= 7

False
Out[55]:

In [56]:
b * 2 < 8

False
Out[56]:

In [57]:
b * 2 <= 8

True
Out[57]:

In [58]:
a>=2 and b<7

True
Out[58]:

In [59]:
a>=2 or b<7

True
Out[59]:

In [60]:
def is_in_circle(x, y ,r):
"""
Función que indica si el punto de coordenadas (x,y) está en el círculo
"""
return x**2 + y**2 <= r*r
 is_in_circle(0.5, 0.5, 1)

True
Out[60]:

In [61]:
is_in_circle(0.5, 0.9, 1)

False
Out[61]:

Cadenas de caracteres
In [62]:
a = "Hola"
b = 'Hola' # las cadenas de caracteres se pueden poner con comillas dobles
print(a,b)

Hola Hola

In [63]:
a == b

True
Out[63]:

In [64]:
nombre = "Juan"
saludo = "Hola " + nombre # + es la concatenación de cadenas de caracteres
saludo

'Hola Juan'
Out[64]:

In [65]:
"H" * 10 # replicación

'HHHHHHHHHH'
Out[65]:

In [66]:
"Juan" < "Jual" # las cadenas de caracteres se comparan según el orden lexi

False
Out[66]:

In [67]:
"Juan" < "Juap"

True
Out[67]:

In [68]:
"j" == "J" # las mayúsculas y las minúsculas son diferentes

False
Out[68]:

In [69]:
"j" < "K"

False
Out[69]:

In [70]:
len("Hola") # la longitud de una longitud de cadena de caraceres
 4
Out[70]:

In [71]:
ord("a"),ord("b"),ord("c"),ord('z')

(97, 98, 99, 122)

Out[71]:

In [72]:
ord("A"),ord("B"),ord("C"),ord("Z"),ord("a"),ord("á")

(65, 66, 67, 90, 97, 225)

Out[72]:

In [73]:
chr(225)

'á'
Out[73]:

In [74]:
a = "Hola"
type(a),len(a),type(len(a[0]))

(str, 4, int)
Out[74]:

Cadenas de caracteres largas

In [75]:
quijote = """En un lugar de la Mancha, de cuyo nombre no quiero acordarme,
no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero,
adarga antigua, rocín flaco y galgo corredor.
Una olla de algo más vaca que carnero, salpicón las más noches,
duelos y quebrantos los sábados, lantejas los viernes, algún palomino de añ
consumían las tres partes de su hacienda.
El resto della concluían sayo de velarte, calzas de velludo para las fiesta
y los días de entresemana se honraba con su vellorí de lo más fino.
Tenía en su casa una ama que pasaba de los cuarenta, y una sobrina que no l
y un mozo de campo y plaza, que así ensillaba el rocín como tomaba la podad
Frisaba la edad de nuestro hidalgo con los cincuenta años; era de complexió
enjuto de rostro, gran madrugador y amigo de la caza.
Quieren decir que tenía el sobrenombre de Quijada, o Quesada, que en esto h
aunque, por conjeturas verosímiles, se deja entender que se llamaba Quejana
Pero esto importa poco a nuestro cuento; basta que en la narración dél no s

In [76]:
print(quijote)
 En un lugar de la Mancha, de cuyo nombre no quiero acordarme,
no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero,
adarga antigua, rocín flaco y galgo corredor.
Una olla de algo más vaca que carnero, salpicón las más noches,
duelos y quebrantos los sábados, lantejas los viernes, algún palomino de añ
adidura los domingos,
consumían las tres partes de su hacienda.
El resto della concluían sayo de velarte, calzas de velludo para las fiesta
s, con sus pantuflos de lo mesmo,
y los días de entresemana se honraba con su vellorí de lo más fino.
Tenía en su casa una ama que pasaba de los cuarenta, y una sobrina que no l
legaba a los veinte,
y un mozo de campo y plaza, que así ensillaba el rocín como tomaba la podad
era.
Frisaba la edad de nuestro hidalgo con los cincuenta años; era de complexió
n recia, seco de carnes,
enjuto de rostro, gran madrugador y amigo de la caza.
Quieren decir que tenía el sobrenombre de Quijada, o Quesada, que en esto h
ay alguna diferencia en los autores que deste caso escriben;
aunque, por conjeturas verosímiles, se deja entender que se llamaba Quejan
a.
Pero esto importa poco a nuestro cuento; basta que en la narración dél no s
e salga un punto de la verdad.

Caracteres especiales
In [77]:
especial1 = "Las \"comillas\" son caracteres especiales"
especial1

'Las "comillas" son caracteres especiales'

Out[77]:

In [78]:
especial2 = "Las 'comillas' son caracteres especiales"
especial2

"Las 'comillas' son caracteres especiales"

Out[78]:

In [79]:
especial3 = "Por tanto la barra invertida también lo es \\"
print(especial3)

Por tanto la barra invertida también lo es \

In [80]:
especial4 = "Hay otros caracteres especiales como el salto de línea.\nQue s
print(especial4)

Hay otros caracteres especiales como el salto de línea.

Que sirve para representar el fín de línea en ficheros.
Lo veremos más adelante

Indicación de tipos.
Hemos visto cómo los objetos a los que se refiere una variable tienen un tipo, que podemos
consultar con la función type:

In [81]:
type(12345),type(2.5),type(type),type(is_in_circle)

(int, float, type, function)

Out[81]:
 Una variable puede referirse a objetos de distintos tipos, en distintos momentos de la
ejecución.

In [82]:
a = 17
c = a*13
a = "Hola"
c = "Adios"

Pero los tipos son de gran importancia, si opero con cosas de tipo inadecuado se producen
errores

In [83]:
z = a*c

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/tmp/ipykernel_11442/2751516809.py in <module>
----> 1 z = a*c

TypeError: can't multiply sequence by non-int of type 'str'

Si llamo a una función con parámetros de tipo no adecuado, también se producen errores.

In [84]:
is_in_circle("23","12","18")

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/tmp/ipykernel_11442/3345992370.py in <module>
----> 1 is_in_circle("23","12","18")

/tmp/ipykernel_11442/1318859247.py in is_in_circle(x, y, r)
3 Función que indica si el punto de coordenadas (x,y) está en el
círculo de radio r y centro (0,0)
4 """
----> 5 return x**2 + y**2 <= r*r
6
7 is_in_circle(0.5, 0.5, 1)

TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Al igual que hemos comentado lo que devuelve la función, conviene indicar el tipo de sus
parámetros y del valor que devuelve. Las versiones modernas de Python tienen una sintaxis
para ello

In [85]:
def is_in_circle(x:float, y:float ,r:float)->bool:
"""
Función que indica si el punto de coordenadas (x,y) está en el círculo
"""
return x**2 + y**2 <= r*r

Aunque el intérprete de Python no hace ningún uso de estas indicaciones

In [86]:
is_in_circle("23","12","18")
 ---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/tmp/ipykernel_11442/3345992370.py in <module>
----> 1 is_in_circle("23","12","18")

/tmp/ipykernel_11442/1712243736.py in is_in_circle(x, y, r)
3 Función que indica si el punto de coordenadas (x,y) está en el
círculo de radio r y centro (0,0)
4 """
----> 5 return x**2 + y**2 <= r*r

TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

In [87]:
def doble(a:int)->int:
"""
función que devuelve el doble de a
"""
return 2*a

doble("Hola")

'HolaHola'
Out[87]:

Sin embargo otras herramientas (como el programa mypy) son capaces de informarnos si en
un archivo con instruciones de Python hay llamadas a las funciones con los parámetros del
tipo no adecuado.

Aunque en otras situaciones, como en el caso de la función poli , la flexibilidad de Python

es interesante

In [88]:
def poli(x):
"""
Función que devuelve el valor del polinomio 3*x^2-4*x-6 en el punto x
x es de tipo float, entonces poli devuelve un float,
o int, entonces poli devuelve un int.
"""
s = 0
pot = 1
s = s + (-6 * pot)
pot = pot * x
s = s + (-4 * pot)
pot = pot *x
s = s + (3 * pot)
return s

poli(2),poli(3.5)

(-2, 16.75)
Out[88]:

In [ ]: