Introducción a la programación en Python
clase 4

Listas y strings II

Las listas y las cadenas de caracteres (strings) son dos tipos de objeto de los denominados secuencias.

Como tales, las listas y las cadenas de caracteres comparten varias funciones y métodos, aunque también tienen diferencias.

Las cadenas de caracteres son:

  • homogéneas: todos sus elementos son del tipo carácter (car).
  • inmutables: las cadenas no pueden cambiar sus elementos.

Las listas, por su parte, son:

  • heterogéneas: sus elementos pueden ser de diferentes tipos, incluidas otras listas.
  • mutables: se pueden modificar sus elementos, así como cambiar su longitud.
  • multidimensionales: las listas pueden anidar otras listas hasta cualquier nivel arbitrario, pudiendo generar así estructuras de datos multidimensionales.

Indexado y particionado

Una vez que una lista está definida, sus elementos pueden accederse mediante su índice.

In [1]: 
lista = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lista)

[1, 2, 3, 4, 5, 6, 7, 8, 9]
In [2]: 
lista[0]
Out[2]:
1

Puede accederse a una porción de una lista, indicando un rango entre dos índices separado por dos puntos. Por ejemplo, para ir del elemento de índice 0 hasta el índice 3, pero sin incluirlo:

In [3]: 
lista[0:3]
Out[3]:
[1, 2, 3]

Omitiendo el índice inicial, se entiende que se comienza en el primer elemento.

In [4]: 
lista[:3]
Out[4]:
[1, 2, 3]

Omitiendo el segundo índice, se llega hasta el final de la lista.

In [5]: 
lista[5:]
Out[5]:
[6, 7, 8, 9]

Por lo tanto, omitiendo ambos índices se recorre toda la lista.

In [6]: 
lista[:]
Out[6]:
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Se pueden usar índices negativos; -1 corresponde al último elemento de la lista, y -len(lista) corresponde al primer elemento.

In [7]: 
lista[1:-1]
Out[7]:
[2, 3, 4, 5, 6, 7, 8]

Opcionalmente se puede dar un tercer argumento, para determinar el incremento (por defecto, 1).

In [8]: 
lista[1:8:2]
Out[8]:
[2, 4, 6, 8]
In [9]: 
lista[1:8:3]
Out[9]:
[2, 5, 8]

Si se ingresa un índice que excede el rango de la lista, genera un error:

In [10]: 
lista[10]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-10-e831eade8105> in <module>()
----> 1 lista[10]

IndexError: list index out of range

Las mismas operaciones son válidas para las cadenas de caracteres.

In [11]: 
cadena = "En un lugar de la Mancha"
print(cadena)

En un lugar de la Mancha
In [12]: 
cadena[0]
Out[12]:
'E'
In [13]: 
cadena[-1]
Out[13]:
'a'
In [14]: 
cadena[3:9]
Out[14]:
'un lug'
In [15]: 
cadena[4:-1:2]
Out[15]:
'nlgrd aMnh'
In [16]: 
cadena[-1::-1]
Out[16]:
'ahcnaM al ed ragul nu nE'

Operaciones, funciones y métodos comunes a las secuencias

+ : concatenación

El operador + sirve para concatenar secuencias del mismo tipo, tanto cadenas como listas.

In [17]: 
cadena = "foo" + "bar"
print(cadena)

foobar
In [18]: 
lista = ['A', 1] + ['B', 2]
print(lista)

['A', 1, 'B', 2]

* : repetición

In [19]: 
linea = '-' * 80
print(linea)

--------------------------------------------------------------------------------
In [20]: 
lista_rep = ['A', 1] * 5
print(lista_rep)

['A', 1, 'A', 1, 'A', 1, 'A', 1, 'A', 1]

len()

Devuelve la longitud (cantidad de elementos) de una secuencia, tanto lista como cadena de caracteres.

In [21]: 
lista_len = [1, 2, 3, 'A', 'B', 'C', [100, 'foo']]
cadena_len = "cadena de caracteres"
print(len(lista_len))
print(len(cadena_len))

7
20

min(), max()

Estas funciones devuelven el mínimo y el máximo respectivamente, de una secuencia. Pueden aplicarse sin limitaciones a cualquier cadena.

In [22]: 
cadena_m = "TheQuickBrownFoxJumpsOverTheLazyDog"
print(min(cadena_m))
print(max(cadena_m))

B
z

En el caso de las listas, estas funciones sólo pueden aplicarse si la lista es homogénea.

  • si sus elementos son números, devuelven el de mínimo y máximo valor
  • si son cadenas, devuelven el mínimo y el máximo de su ordenamiento alfabético.
In [23]: 
lista_1 = [13, 23, 77, 9]
print(min(lista_1))
print(max(lista_1))

9
77
In [24]: 
lista_2 = ['foo', 'bar', 'hola Python', 'zz']
print(min(lista_2))
print(max(lista_2))

bar
zz

Estas funciones no pueden operar sobre listas heterogéneas, que no son ordenables.

In [25]: 
lista_3 = ['foo', 23, 11, 'bar']
print(max(lista_3))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-25-c0f008196b63> in <module>()
      1 lista_3 = ['foo', 23, 11, 'bar']
----> 2 print(max(lista_3))

TypeError: unorderable types: int() > str()

sum()

Esta función también puede aplicarse solamente a listas homogéneas, cuyos elementos sean todos de tipo numérico.

In [26]: 
lista_4 = [1, 2, 3, 4]
print(sum(lista_4))

10

sorted()

La función sorted() devuelve una lista ordenada de los elementos de la secuencia que recibe como argumento (lista o cadena). La secuencia original no es modificada.

In [27]: 
lista = [23, 13, 7, 37]
print(sorted(lista))
print(lista)

[7, 13, 23, 37]
[23, 13, 7, 37]

La función sorted() siempre devuelve una lista, aunque reciba como argumento una cadena de caracteres.

In [28]: 
cadena = "asdlk"
print(sorted(cadena))

['a', 'd', 'k', 'l', 's']

in

El operador in verifica si un elemento pertenece a una secuencia (lista o cadena), y devuelve la variable booleana True or False correspondiente.

In [29]: 
"o" in "foo"
Out[29]:
True
In [30]: 
"x" in "foo"
Out[30]:
False
In [31]: 
lista_a = [12, 32, 14]
12 in lista_a
Out[31]:
True
In [32]: 
13 in lista_a
Out[32]:
False

Como se vio en la clase 3, el operador in también se utiliza para recorrer secuencias u otros objetos iterables, en los ciclos generados por un for.

In [33]: 
for i in lista_a:
    print(i)

12
32
14

not in

Es el contrario de in, devuelve verdadero cuando un elemento no está en una secuencia.

In [34]: 
"o" not in "foo"
Out[34]:
False
In [35]: 
"x" not in "foo"
Out[35]:
True

Operaciones para listas

Por ser secuencias mutables, las listas admiten operaciones que las modifican.

asignación

Mediante el operador de asignación, se puede modificar el elemento correspondiente a un índice determinado.

In [36]: 
mi_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(mi_lista)
mi_lista[0] = "A"
print(mi_lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
['A', 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [37]: 
mi_lista[0:3] = "B"
print(mi_lista)

['B', 3, 4, 5, 6, 7, 8, 9]
In [38]: 
mi_lista[0:1] = [0, 1, 2]
print(mi_lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [39]: 
mi_lista[-1:] = ['A', 'B']
print(mi_lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 'A', 'B']

del

Se pueden eliminar elementos o porciones de lista con el operador del.

In [40]: 
mi_lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(mi_lista)
del(mi_lista[0])
print(mi_lista)
del(mi_lista[7:])
print(mi_lista)
del(mi_lista[0:5:2])
print(mi_lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7]
[2, 4, 6, 7]

Métodos de listas

Los métodos son funciones que se aplican a un determinado tipo de objeto.

.append()

Agrega un elemento al final de una lista.

In [41]: 
mi_lista = [0, 1, 2, 3, 4]
print(mi_lista)
mi_lista.append("A")
print(mi_lista)

[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 'A']

.extend()

Extiende una lista agregando un iterable al final.

In [42]: 
mi_lista = [0, 1, 2]
print(mi_lista)

mi_lista.extend([3, 4, 5])
print(mi_lista)

mi_lista.extend(range(6,9))
print(mi_lista)

[0, 1, 2]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8]

.sort()

Ordena los elementos de una lista.

In [43]: 
mi_lista = [4, 7, 5, 2, 11, 6]
print(mi_lista)
mi_lista.sort()
print(mi_lista) # la lista está ahora ordenada

[4, 7, 5, 2, 11, 6]
[2, 4, 5, 6, 7, 11]

La función sort() admite la opción reverse, por defecto, con valor False.
De tener valor True, el ordenamiento se hace en sentido inverso.

In [44]: 
otra_lista = [13, 17, 5, 9, 11, 6]
otra_lista.sort(reverse=True)
print(otra_lista)

[17, 13, 11, 9, 6, 5]

.reverse()

Invierte el orden de los elementos de una lista.

In [45]: 
mi_lista = [4, 7, 5, 2, 11, 6]
print(mi_lista)
mi_lista.reverse()
print(mi_lista)

[4, 7, 5, 2, 11, 6]
[6, 11, 2, 5, 7, 4]

.count()

Esta función recibe un elemento como argumento, y cuenta la cantidad de veces que aparece en la lista.

In [46]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print("11 -> ", lista.count(11))
print("5 -> ", lista.count(5))
print("9 -> ", lista.count(9))

11 ->  1
5 ->  3
9 ->  0

.index()

Recibe un elemento como argumento, y devuelve el índice de su primera aparición en la lista.

In [47]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print(lista.index(5))

1

La función admite como argumento adicional un índice inicial a partir de donde comenzar la búsqueda, opcionalmente también el índice final.

In [48]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print(lista.index(5, 3))

4

La función devuelve un error si el elemento no se encuentra en la lista, o en el entorno definido.

In [49]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print(lista.index(9))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-49-ccfe211b7dec> in <module>()
      1 lista = [3, 5, 11, 13, 5, 7, 3, 5]
----> 2 print(lista.index(9))

ValueError: 9 is not in list

.insert()

La función se invoca de esta manera:

    lista.insert(i, x)

Inserta el elemento x en la lista, en el índice i.

In [50]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
lista.insert(2, "foo")
print(lista)

[3, 5, 'foo', 11, 13, 5, 7, 3, 5]

.remove()

Recibe como argumento un elemento, y borra su primera aparición en la lista.

In [51]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
lista.remove(5)
print(lista)

[3, 11, 13, 5, 7, 3, 5]

Devuelve un error si el elemento no se encuentra en la lista.

.pop()

Devuelve el último elemento de la lista, y lo borra de la misma.

In [52]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print(lista.pop())
print(lista)

5
[3, 5, 11, 13, 5, 7, 3]

Opcionalmente puede recibir un argumento numérico, que funciona como índice del elemento (por defecto, -1)

In [53]: 
lista = [3, 5, 11, 13, 5, 7, 3, 5]
print(lista.pop(2))
print(lista)

11
[3, 5, 13, 5, 7, 3, 5]

Definiendo una lista

  • una lista puede crearse por extensión, es decir, escribiendo entre corchetes cada uno de sus elementos por orden, separados por comas:
In [54]: 
lista_extension = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(lista_extension)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • también puede crearse una lista mediante la función list() de un iterable. Por ejemplo, la lista anterior podría crearse mediante la función range(10):
In [55]: 
lista_list = list(range(10))
print(lista_list)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • es posible también crear una lista vacía, y agregar elementos iterativamente mediante el método .append, dentro de un bucle while o for:
In [56]: 
lista_loop = []
for i in range(10):
    lista_loop.append(i)

print(lista_loop)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  • un principio similar al del método anterior puede expresarse de manera compacta en la propia asignación de la lista, mediante la operación llamada compresión de lista (list comprehension).
In [57]: 
lista_comprension = [x for x in range(10)]
print(lista_comprension)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

La forma general de la definición de una lista por comprensión es:

    [expresión for ítem in iterable]

Opcionalmente, se puede incluir un condicional en la expresión:

    [expresión for ítem in iterable if condición]

expresión puede ser cualquier expresión computable en Python, generalmente involucrando un ítem del iterable iterable puede ser cualquier objeto iterable, como una secuencia (lista o cadena), la función range(), etc.

La salida siempre es una lista.

In [58]: 
# crea una lista de números por extensión
numeros = [23, 7, 11, 41, 13, 38]
# eleva al cuadrado los números de la listas que sean menores que 20
# y crea una nueva lista
cuadrados = [x**2 for x in numeros if x < 20]
print(cuadrados)

[49, 121, 169]
In [59]: 
cadena = "Hola Python"
lista = [x*2 for x in cadena if x != " "]
print(lista)

['HH', 'oo', 'll', 'aa', 'PP', 'yy', 'tt', 'hh', 'oo', 'nn']

Módulos de la Biblioteca Estándar

La biblioteca estándar de Python incluye un conjunto de módulos que agregan funciones especiales al lenguaje.

La forma de importar un módulo es mediante la instrucción import, y la sintaxis estándar es:

import modulo

Las funciones que aporta el módulo estarán disponibles de esta manera:

modulo.funcion()

math

El módulo math agrega un conjunto de funciones matemáticas (log, factorial, sqrt, funciones trigonométricas, etc), así como también algunas constantes tales como pi o e [ https://docs.python.org/3/library/math.html ].

In [60]: 
import math

print("raíz cuadrada de 2:", math.sqrt(2))
print("factorial de 12:", math.factorial(12))
print("3/2 expresado en cents:", 1200 * math.log(3/2, 2))
print("valor de la constante π:", math.pi)
print("seno de π/2:", math.sin(math.pi/2))

raíz cuadrada de 2: 1.4142135623730951
factorial de 12: 479001600
3/2 expresado en cents: 701.9550008653874
valor de la constante π: 3.141592653589793
seno de π/2: 1.0

random

Otro módulo numérico es random, que incluye un conjunto de funciones para la generación de números pseudo-aleatorios de distintas características [ https://docs.python.org/3/library/random.html ].

El módulo random tiene funciones para operar sobre números enteros, sobre números de coma flotante, y sobre secuencias.

funciones para números enteros

  • random.randrange()

La función puede invocarse con uno, dos, o tres argumentos:

    random.randrange(stop)
    random.randrange(start, stop[, step])

y devuelve un entero aleatorio dentro del rango definido.

Los argumentos se comportan como en la función range():

     - con un único argumento, la función devuelve un entero aleatorio entre 0 y stop-1
     - con dos argumentos, devuelve un entero aleatorio entre start y stop-1
     - el tercer argumento opcional determina el incremento.

In [61]: 
print(random.randrange(10))
print(random.randrange(10, 20))
print(random.randrange(50, 100, 5))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-61-9dd471d12c35> in <module>()
----> 1 print(random.randrange(10))
      2 print(random.randrange(10, 20))
      3 print(random.randrange(50, 100, 5))

NameError: name 'random' is not defined
  • random.randint()

La función se invoca:

    random.randint(a, b)

y devuelve un número entero aleatorio N tal que a <= N <= b.

Es equivalente a randrange(a, b+1).

In [62]: 
print(random.randint(10, 20))

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-62-5dcfb39935d9> in <module>()
----> 1 print(random.randint(10, 20))

NameError: name 'random' is not defined

funciones para números de coma flotante

El módulo random dispone de una serie de funciones que generan números pseudo-aleatorios de diferentes distribuciones.

Algunas de las más importantes son:

  • random.random()

Devuelve un número aleatorio de coma flotante (con distribución uniforme) en el rango [0.0, 1.0)

  • random.uniform()

La función se invoca:

    random.uniform(a, b)

y devuelve un número aleatorio de coma flotante (con distribución uniforme) en el rango [a, b]

  • random.triangular()

La función se invoca:

    random.triangular(low, high, mode)

Devuelve un número aleatorio de coma flotante con distribución triangular en el rango [low, high], que por defecto valen 0 y 1 respectivamente.

El argumento mode por defecto es el valor intermedio entre low y high, generando así una distribución simétrica.

Ejemplo 4.1

In [63]: 
import random

# crea una lista invocando 50 veces la función random.triangular()
# por defecto: low = 0, high = 1, mode = 0.5
triangular_simetrica = [round(random.triangular(), 2) for i in range(50)]
print(triangular_simetrica)
triangular_simetrica.sort()
print(triangular_simetrica)

# distribución asimétrica com mode = 0.9
triangular_asimetrica = [round(random.triangular(0, 1, 0.9), 2) for i in range(50)]
print(triangular_asimetrica)
triangular_asimetrica.sort()
print(triangular_asimetrica)

[0.45, 0.26, 0.41, 0.37, 0.49, 0.38, 0.67, 0.44, 0.45, 0.47, 0.12, 0.37, 0.59, 0.3, 0.88, 0.63, 0.03, 0.23, 0.57, 0.42, 0.57, 0.49, 0.68, 0.37, 0.66, 0.52, 0.48, 0.49, 0.14, 0.55, 0.78, 0.63, 0.35, 0.54, 0.25, 0.61, 0.54, 0.49, 0.5, 0.24, 0.31, 0.7, 0.89, 0.58, 0.83, 0.51, 0.61, 0.88, 0.5, 0.54]
[0.03, 0.12, 0.14, 0.23, 0.24, 0.25, 0.26, 0.3, 0.31, 0.35, 0.37, 0.37, 0.37, 0.38, 0.41, 0.42, 0.44, 0.45, 0.45, 0.47, 0.48, 0.49, 0.49, 0.49, 0.49, 0.5, 0.5, 0.51, 0.52, 0.54, 0.54, 0.54, 0.55, 0.57, 0.57, 0.58, 0.59, 0.61, 0.61, 0.63, 0.63, 0.66, 0.67, 0.68, 0.7, 0.78, 0.83, 0.88, 0.88, 0.89]
[0.38, 0.66, 0.78, 0.77, 0.86, 0.34, 0.7, 0.88, 0.66, 0.47, 0.98, 0.86, 0.84, 0.63, 0.77, 0.65, 0.71, 0.61, 0.44, 0.26, 0.37, 0.42, 0.61, 0.64, 0.89, 0.13, 0.36, 0.6, 0.75, 0.78, 0.47, 0.62, 0.12, 0.55, 0.73, 0.68, 0.32, 0.69, 0.93, 0.53, 0.43, 0.23, 0.79, 0.5, 0.51, 0.9, 0.85, 0.97, 0.71, 0.6]
[0.12, 0.13, 0.23, 0.26, 0.32, 0.34, 0.36, 0.37, 0.38, 0.42, 0.43, 0.44, 0.47, 0.47, 0.5, 0.51, 0.53, 0.55, 0.6, 0.6, 0.61, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.66, 0.68, 0.69, 0.7, 0.71, 0.71, 0.73, 0.75, 0.77, 0.77, 0.78, 0.78, 0.79, 0.84, 0.85, 0.86, 0.86, 0.88, 0.89, 0.9, 0.93, 0.97, 0.98]
  • random.gauss()

La función se invoca:

    random.gauss(mu, sigma)

y devuelve un número aleatorio de coma flotante con distribución gaussiana (distribución normal), de media mu y desviación estándar sigma.

funciones para secuencias

  • random.choice()

La función se invoca:

    random.choice(secuencia)

y devuelve un elemento aleatorio de la secuencia.

In [64]: 
import random

lista = ["foo", 17, "bar", 23, "hola"]
cadena = "asldkfjowerldjf"
print(random.choice(lista))
print(random.choice(cadena))

bar
f
  • random.shuffle()

La función se invoca:

    random.shuffle(secuencia)

Reordena aleatoriamente los elementos de una secuencia.

In [65]: 
lista = [x for x in range(10)]
print(lista)
random.shuffle(lista)
print(lista)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 4, 0, 3, 6, 8, 1, 9, 2, 5]

Modifica la secuencia en el lugar, y por lo tanto puede operar en listas pero no en cadenas, que son inmutables.

  • random.sample()

La función se invoca:

    random.sample(secuencia, k)

Devuelve una lista de k elementos elegidos aleatoriamente de secuencia.

Si k == len(secuencia), el resultado es una permutación aleatoria de los elementos de la secuencia. A diferencia de random.shuffle(), la secuencia original no es modificada.

Ejemplo 4.2

Generar series dodecafónicas aleatorias a partir de una lista ordenada de las doce clases de altura.

In [66]: 
import random

# lista ordenada de las 12 clases de altura
k = 12
total_cromatico = [x for x in range(k)]

# se generan permutaciones aleatorias del total cromático
serie1 = random.sample(total_cromatico, k)
serie2 = random.sample(total_cromatico, k)
serie3 = random.sample(total_cromatico, k)

print(total_cromatico)
print(serie1)
print(serie2)
print(serie3)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
[0, 5, 4, 7, 11, 2, 1, 6, 9, 3, 8, 10]
[5, 11, 2, 7, 3, 8, 1, 6, 0, 4, 10, 9]
[10, 11, 6, 0, 2, 3, 5, 1, 8, 4, 9, 7]


Como la función opera sobre la secuencia sin modificarla, puede aplicarse tanto a listas como a cadenas de caracteres. Siempre devuelve una lista.

In [67]: 
import random

cadena = "asdlkjfh"
print(random.sample(cadena, 3))
print(random.sample(cadena, 6))

['s', 'h', 'j']
['j', 'k', 'f', 'd', 's', 'a']

funciones de estado

  • random.seed()

Inicializa el generador de números aleatorios.

Si se le pasa un argumento entero, se usa como semilla, garantizando el mismo resultado cada vez que se ejecuta el código.
Si se deja vacío (o se usa un objeto de tipo None), se inicializa con el reloj del sistema

In [68]: 
import random

random.seed(1)
print(random.randrange(1000))
print(random.randrange(1000))

random.seed()
print(random.randrange(1000))
print(random.randrange(1000))

137
582
530
824

Importando un módulo

  • la forma estándar de importar un módulo es mediante la instrucción import, tal como se vio arriba:

    import modulo

    las funciones se acceden poniendo el nombre del módulo seguido de un punto y el nombre de la función:

    modulo.funcion()
  • al importarse un módulo se le puede asignar un nombre alias mediante la instrucción import ... as.

    import modulo_de_nombre_largo as mod

    Las funciones se accederán entonces de esta manera:

    mod.funcion()
  • también de un módulo se puede importar una o más funciones específicas, mediante la instrucción from ... import:

    form modulo import func1, func2, ...., funcN

    En ese caso, las funciones se acceden directamente a través de su nombre.

    func1()
In [69]: 
# el módulo time provee varias funciones relacionadas
# con el tiempo coronométrico y el reloj

from time import ctime

# la función ctime() devuelve la fecha completa
# indicada por el reloj del sistema
fecha = ctime()
print(fecha)

Thu Sep 11 00:12:57 2014
  • de la manera anterior es posible importar todas las funciones de un módulo usando la estrella [ ***** ] como carácter comodín:

    from modulo import *

    En general este procedimiento es desaconsejado, porque puede generar conflictos entre funciones de mismo nombre pertenecientes a módulos diferentes. También dificulta ver a qué módulo pertenece una función utilizada en el código.
    Esta forma debe utilizarse con mucha precaución, y solamente cuando se esté seguro de que no genera conflictos.

La referencia de los módulos disponibles en la biblioteca estándar de Python3 se puede encontrar en:

https://docs.python.org/3/library/index.html

Ejercicio 4.1

  1. Crear una función que para un cociente de multiplicación dado, calcule su valor en cents. Utilizar la función math.log.
  2. Utilizando esa función, modificar el ejercicio 3.2, de modo de que calcule el factor de multiplicación del armónico 8 al 16, e imprima en pantalla:
  • el número de armónico
  • el factor de multiplicación, redondeado a tres dígitos después de la coma
  • el valor en cents

Ejemplo de salida:

8   1.0       0
9   1.125   204
10  1.25    386
11  1.375   551
12  1.5     702
13  1.625   841
14  1.75    969
15  1.875  1088
16  2.0    1200

Ejercicio 4.2

  1. Crear una función que reciba una lista de notas en número de nota MIDI, y haga la inversión melódica tomando como eje la primera nota.
  2. Modificar la función anterior de modo de que pueda recibir el eje de inversión como argumento opcional.
  3. Crear una función que transporte una secuencia de notas a un intervalo dado.

Ejercicio 4.3

Utilizando las dos funciones anteriores, crear una función que devuelva la matriz serial de una serie dada.