Módulos en Python

Sitio:	Facultad de Ingeniería U.Na.M.
Curso:	Informática ET241/EM241/IC241/IN241/IM204
Libro:	Módulos en Python

Imprimido por:	Invitado
Día:	miércoles, 18 de diciembre de 2024, 05:27

Tabla de contenidos

1. Introducción 1 de 2
2. Introducción 2 de 2
3. Módulos
4. Tipos de Módulos
5. pip: Instalando módulos en Python
6. pip: IPython Console -Spyder
7. Estructura-Orden de un Programa en Python
8. import: Importando módulos
9. import vs import from
10. La sentencia import ...from
11. La sentencia import as (alias)
12. Espacios de Nombres.
13. Ejercicios Resueltos
14. Tiro parabólico.

1. Introducción 1 de 2

Ingredientes Recetas De Cupcakes Escritas | Recetas faciles postres, Cupcakes recetas, Recetas de cocina casera Receta ( equivalente a método)

100 recetas de postres Libro de Recetas ( equivalente a módulo)

Estantería con libros de Recetas ( equivalente a Paquetes, contiene múchos módulos)

Si hacemos una analogía entre una función y una receta de un postre, un módulo sería un libro de recetas.

Así como hay libros de postres, de comidas con pescado, con carne asada hay módulos de que agrupan determinadas funcionalidades.

El programador que utilice sepa utilizar los módulos, trabajará menos, hará un programa mejor.

Será como un operatirio que sepa utilizar las herramientas adecuadas.

    a
   abc    Abstract Base Classes
   argparse    Análisis de opciones y argumentos de línea de comando
   array    Administrar secuencias de datos de tipo fijo de manera eficiente.
   asyncio    E/S asíncrona, bucle de eventos y herramientas de concurrencia
   atexit    Registro de devoluciones de llamada de salida

   b
   base64    Codificar datos binarios con caracteres ASCII.
   bisect    Mantiene una lista ordenada sin tener que ordenarla cada vez que se agrega un elemento a la lista.
   bz2    Compresión bzip2

   c
   calendar    Clases para trabajar con valores de año, mes y semana.
   cgitb    Módulo mal nombrado que proporciona información de rastreo ampliada.
   cmd    Crear procesadores de comandos orientados a líneas.
   codecs    Codificación y decodificación de cadenas.
-     collections    colecciones --- Tipos de datos de contenedores.
   compileall    Byte-compilar archivos fuente
-     concurrent
   configparser    Leer y escribir archivos de configuración similares a los archivos INI de Windows
   contextlib    Utilidades para crear y trabajar con gestores de contexto.
   copy    Duplicando objectos.
   csv    Lee y escribe archivos de valores separados por comas.

   d
   datetime    Manipulación de valores de fecha y hora.
   dbm    Bases de datos clave-valor de Unix
   decimal    Matemáticas de coma fija y flotante
   difflib    Comparar secuencias, especialmente lineas de texto.
   dis    Desensamblador de bytecodes de Python
   doctest    Escribir pruebas automatizadas como parte de la documentación de un módulo.

   e
   ensurepip    Instala pip, el instalador de paquetes Python
   enum    Define tipo de enumeración

   f
   filecmp    Compara archivos y directorios en el sistema de archivos.
   fileinput    Procesa líneas del flujo de entrada,
   fnmatch    Comparar nombres de archivos con patrones glob al estilo Unix.
   fractions    Implementa una clase para trabajar con números racionales.
   functools    Herramientas para trabajar con funciones

   g
   gc    Recolector de basura
   getopt    Análisis de opciones de línea de comando
   getpass    Solicitar una contraseña de forma segura
   gettext    Catálogos de mensajes
   glob    Usa las reglas de shell de Unix para buscar nombres de archivos que coincidan con un patrón.
   grp    Base de datos de grupo Unix
   gzip    Leer y escribir archivos zip

   h
   hashlib    Hashes criptográficos y resúmenes de mensajes.
   heapq    Algoritmo de ordenación de montículo in situ.
   hmac    Firma y verificación criptográfica de mensajes.
-     http

   i
   imaplib    Biblioteca de cliente IMAP4
   importlib    Interfaz para el mecanismo de importación de módulos.
   inspect    Inspeccionar objetos en vivo
   io    Implementa E/S de archivos y proporciona clases para trabajar con búffers utilizando intrfaz de progrmación de tipo archivo.
   ipaddress    Clases para trabajar con direcciones del protocolo de Internet (IP)
   itertools    Funciones de iterador para un bucle eficiente

   j
   json    Serializador de notación de objetos JavaScript

   l
   linecache    Leer archivos de texto eficientemente
   locale    Interfaz de programación de localización cultural POSIX
   logging    Informe de estado, error y mensajes informativos.

   m
   mailbox    Accede y manipule archivos de correo electrónico.
   math    Funciones Matemáticas
   mmap    Archivos de mapas de memoria
   multiprocessing    Gestionar procesos como hilos

   o
   operator    Interfaz funcional para operadores incorporados
-     os    Acceso portable a funciones específicas del sistema operativo.

   p
   pathlib    Tratar las rutas del sistema de archivos como objetos.
   pdb    Depurador interactivo
   pickle    Serialización de objetos
   pkgutil    Utilidades de paquetes
   platform    Información de versión del sistema
   pprint    Impresión bonita de estructuras de datos
   profile    Análisis de rendimiento de programas Python.
   pstats    Manipular y analizar estadísticas de perfil.
   pwd    Base de datos de contraseñas de Unix
   pyclbr    Navegador de clases
   pydoc    Ayuda en línea para módulos

   q
   queue    Implementación FIFO segura para hilos

   r
   random    Generadores de números pseudoaleatorios
   re    Buscar dentro y cambiar texto usando patrones formales.
   readline    La biblioteca readline de GNU
   resource    Gestión de recursos del sistema

   s
   sched    Programador genérico de eventos.
   select    Esperar E/S eficientemente
   selectors    Abstracciones de multiplexación de E/S
   shelve    Almacenamiento persistente de objetos.
   shlex    Análisis léxico de sintaxis de estilo shell.
   shutil    Operaciones de archivo de alto nivel.
   signal    Eventos asíncronos del sistema
   site    Configuración de todo el sitio
   sitecustomize    Configuración específica del sitio
   smtpd    Incluye clases para implementar servidores SMTP.
   smtplib    Cliente de protocolo simple de transferencia de correo.
   socket    Comunicación en red
   socketserver    Creación de servidores de red.
   sqlite3    Base de datos relacional integrada
   statistics    Cálculos estadísticos
   string    Contiene constantes y clases para trabajar con texto.
   struct    Convierte entre canedas y datos binarios.
   subprocess    Generar procesos adicionales
   sys    Configuración específica del sistema
   sysconfig    Configuración en tiempo de compilación del intérprete

   t
   tabnanny    Escanear el código fuente de Python en busca de sangría sospechosa.
   tarfile    Acceso a archivos Tar
   tempfile    Objetos temporales del sistema de archivos
   textwrap    Formateando párrafos de texto
   threading    Gestionar operaciones concurrentes
   time    Hora del reloj
   timeit    Cronometrar la ejecución de pequeños fragmentos de código Python.
   trace    Seguir el flujo del programa
   traceback    Excepciones y rastreos de pila

   u
   unittest    Marco de prueba automatizado
-     urllib
   usercustomize    Configuración específica del usuario
   uuid    Identificadores universalmente únicos

   v
   venv    Crear contextos de instalación y ejecución aislados.

   w
   warnings    Alertas no fatales
   weakref    Referencias no-permanentes a objetos
   webbrowser    Mostrar páginas Web

   x
-     xml
-     xmlrpc

   z
   zipfile    Acceso al archivo ZIP
   zipimport    Cargar código Python desde archivos ZIP
   zlib    Biblioteca de compresión zlib de GNU

2. Introducción 2 de 2

Recordemos que método es una función de un objeto y que el punto (.) era el operador que me permite vincular el objeto y el método.

Para tener una idea de la cantidad de métodos tienen los distintos módulos y que nos pueden ayudar y facilitar la tarea de programar, vamos a mostrar solo los de math...algo necesario para los ingenieros. Desde una terminal invocamos el interprete python.

Con el comando import math, incorporamos TODO el código de math, todos los métodos ( funciones) , luego con help (math) , último comando mostraría los distintos métodos ( funciones) de math.

NAME
    math

DESCRIPTION
    This module is always available. It provides access to the
    mathematical functions defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.

    acosh(x, /)
        Return the inverse hyperbolic cosine of x.

    asin(x, /)
        Return the arc sine (measured in radians) of x.

    asinh(x, /)
        Return the inverse hyperbolic sine of x.

    atan(x, /)
        Return the arc tangent (measured in radians) of x.

    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.

        Unlike atan(y/x), the signs of both x and y are considered.

    atanh(x, /)
        Return the inverse hyperbolic tangent of x.

    ceil(x, /)
        Return the ceiling of x as an Integral.

        This is the smallest integer >= x.

    copysign(x, y, /)
        Return a float with the magnitude (absolute value) of x but the sign of y.

        On platforms that support signed zeros, copysign(1.0, -0.0)
        returns -1.0.

    cos(x, /)
        Return the cosine of x (measured in radians).

    cosh(x, /)
        Return the hyperbolic cosine of x.

    degrees(x, /)
        Convert angle x from radians to degrees.

    erf(x, /)
        Error function at x.

    erfc(x, /)
        Complementary error function at x.

    exp(x, /)
        Return e raised to the power of x.

    expm1(x, /)
        Return exp(x)-1.

        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.

    fabs(x, /)
        Return the absolute value of the float x.
         factorial(x, /)
        Find x!.

        Raise a ValueError if x is negative or non-integral.

    floor(x, /)
        Return the floor of x as an Integral.

        This is the largest integer <= x.

    fmod(x, y, /)
        Return fmod(x, y), according to platform C.

        x % y may differ.

    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).

        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.

    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.

        Assumes IEEE-754 floating point arithmetic.

    gamma(x, /)
        Gamma function at x.

    gcd(x, y, /)
        greatest common divisor of x and y

    hypot(x, y, /)
        Return the Euclidean distance, sqrt(x*x + y*y).

    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
     factorial(x, /)
        Find x!.

        Raise a ValueError if x is negative or non-integral.

    floor(x, /)
        Return the floor of x as an Integral.

        This is the largest integer <= x.

    fmod(x, y, /)
        Return fmod(x, y), according to platform C.

        x % y may differ.

    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).

        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.

    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.

        Assumes IEEE-754 floating point arithmetic.

    gamma(x, /)
        Gamma function at x.

    gcd(x, y, /)
        greatest common divisor of x and y

    hypot(x, y, /)
        Return the Euclidean distance, sqrt(x*x + y*y).

    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

factorial(x, /)
        Find x!.

        Raise a ValueError if x is negative or non-integral.

    floor(x, /)
        Return the floor of x as an Integral.

        This is the largest integer <= x.

    fmod(x, y, /)
        Return fmod(x, y), according to platform C.

        x % y may differ.

    frexp(x, /)
        Return the mantissa and exponent of x, as pair (m, e).

        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.

    fsum(seq, /)
        Return an accurate floating point sum of values in the iterable seq.

        Assumes IEEE-754 floating point arithmetic.

    gamma(x, /)
        Gamma function at x.

    gcd(x, y, /)
        greatest common divisor of x and y

    hypot(x, y, /)
        Return the Euclidean distance, sqrt(x*x + y*y).

    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
Determine whether two floating point numbers are close in value.

          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values

        Return True if a is close in value to b, and False otherwise.

        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.

        -inf, inf and NaN behave similarly to the IEEE 754 Standard. That
        is, NaN is not close to anything, even itself. inf and -inf are
        only close to themselves.

    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.

    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.

    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.

    ldexp(x, i, /)
Determine whether two floating point numbers are close in value.

          rel_tol
            maximum difference for being considered "close", relative to the
            magnitude of the input values
          abs_tol
            maximum difference for being considered "close", regardless of the
            magnitude of the input values

        Return True if a is close in value to b, and False otherwise.

        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.

        -inf, inf and NaN behave similarly to the IEEE 754 Standard. That
        is, NaN is not close to anything, even itself. inf and -inf are
        only close to themselves.

    isfinite(x, /)
        Return True if x is neither an infinity nor a NaN, and False otherwise.

    isinf(x, /)
        Return True if x is a positive or negative infinity, and False otherwise.

    isnan(x, /)
        Return True if x is a NaN (not a number), and False otherwise.

    ldexp(x, i, /)
Return x * (2**i).

        This is essentially the inverse of frexp().

    lgamma(x, /)
        Natural logarithm of absolute value of Gamma function at x.

    log(...)
        log(x, [base=math.e])
        Return the logarithm of x to the given base.

        If the base not specified, returns the natural logarithm (base e) of x.

    log10(x, /)
        Return the base 10 logarithm of x.

    log1p(x, /)
        Return the natural logarithm of 1+x (base e).

        The result is computed in a way which is accurate for x near zero.

    log2(x, /)
        Return the base 2 logarithm of x.

    modf(x, /)
        Return the fractional and integer parts of x.

        Both results carry the sign of x and are floats.

    pow(x, y, /)
        Return x**y (x to the power of y).
         radians(x, /)
        Convert angle x from degrees to radians.

    remainder(x, y, /)
        Difference between x and the closest integer multiple of y.

        Return x - n*y where n*y is the closest integer multiple of y.
        In the case where x is exactly halfway between two multiples of
        y, the nearest even value of n is used. The result is always exact.

    sin(x, /)
        Return the sine of x (measured in radians).

    sinh(x, /)
        Return the hyperbolic sine of x.

    sqrt(x, /)
        Return the square root of x.

    tan(x, /)
        Return the tangent of x (measured in radians).

    tanh(x, /)
        Return the hyperbolic tangent of x.

    trunc(x, /)
        Truncates the Real x to the nearest Integral toward 0.

        Uses the __trunc__ magic method.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793
    tau = 6.283185307179586

FILE
    (built-in)

Aqui hay algo en castellano, obtenido de: https://docs.python.org/es/3/library/math.html

método ceil(x)

Retorna el «techo» de x, el número entero más pequeño que es mayor o igual que x. Si x no es un flotante, delega en x.__ceil__(), que debería retornar un valor Integral.
método comb(n, k): Retorna el número de formas posibles de elegir k elementos de n, de forma ordenada y sin repetición.; Se evalúa como n! / (k! * (n - k)!) cuando k <= n y como cero cuando k > n.; También se llama coeficiente binomial porque es equivalente al coeficiente del k-ésimo término en el desarrollo polinomial de la expresión (1 + x) ** n.; Lanza una excepción TypeError si alguno de los argumentos no es un entero. Lanza una excepción ValueError si alguno de los argumentos es negativo.; Nuevo en la versión 3.8.
método copysign(x, y): Retorna un flotante con la magnitud (valor absoluto) de x pero el signo de y. En plataformas que admiten ceros con signo, copysign(1.0, -0.0) retorna -1.0.
método fabs(x): Retorna el valor absoluto de x.
método factorial(x): Retorna el factorial de x como un número entero. Lanza una excepción ValueError si x no es un entero o es negativo.; Obsoleto desde la versión 3.9: Aceptar flotantes con valores integrales (como 5.0) está obsoleto.
método floor(x): Retorna el «suelo» de x, el primer número entero mayor o igual que x. Si x no es un flotante, delega en x .__floor__(), que debería retornar un valor Integral.
método fmod(x, y): Retorna fmod(x, y), tal como se define en la biblioteca de C de la plataforma. Ten en cuenta que la expresión x % y de Python puede no retornar el mismo resultado. La intención del estándar de C es que fmod(x, y) sea exactamente (matemáticamente; con precisión infinita) igual a x - n*y para algún número entero n tal que el resultado tenga el mismo signo que x y magnitud menor que abs(y). La expresión x % y de Python retorna un resultado con el signo de y en su lugar, y es posible que no pueda calcularse con exactitud para argumentos flotantes. Por ejemplo, fmod(-1e-100, 1e100) es -1e-100, pero el resultado de -1e-100 % 1e100 en Python es 1e100-1e-100, que no se puede representar exactamente como un flotante, y se redondea sorprendentemente a 1e100. Por esta razón, generalmente se prefiere la función fmod() cuando se trabaja con flotantes, mientras que se prefiere el uso de x % y de Python cuando se trabaja con enteros.
método frexp(x): Retorna la mantisa y el exponente de x como el par (m, e). m es un flotante y e es un número entero tal que x == m * 2**e exactamente. Si x es cero, retorna (0.0, 0), y retorna 0.5 <= abs(m) < 1 en caso contrario. Se utiliza como una forma portable de «extraer» la representación interna de un flotante.
método fsum(iterable): Retorna una suma precisa en coma flotante de los valores de un iterable. Evita la pérdida de precisión mediante el seguimiento de múltiples sumas parciales intermedias:; >>>

>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0

La precisión del algoritmo depende de las garantías aritméticas de IEEE-754 y del caso típico en el que se usa el «medio redondo a par» (half-even) como método de redondeo. En algunas compilaciones que no son de Windows, la biblioteca de C subyacente utiliza la adición de precisión extendida y, ocasionalmente, puede realizar un doble redondeo en una suma intermedia, haciendo que el bit menos significativo tome el valor incorrecto.; Para una discusión más amplia y dos enfoques alternativos, consultar ASPN cookbook recipes for accurate floating point summation.
método gcd(*integers): Retorna el máximo común divisor de los argumentos enteros. Si cualquiera de los argumentos no es cero, entonces el valor retornado es el entero positivo más grande que divide a todos los argumentos. Si todos los argumentos son cero, entonces el valor retornado es 0. gcd() sin argumentos retorna 0.; Nuevo en la versión 3.5.; Distinto en la versión 3.9: Agregado soporte para un número arbitrario de argumentos. Anteriormente sólo se soportaba dos argumentos.
método isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0): Retorna True si los valores a y b están cerca el uno del otro y False en caso contrario.; Que dos valores se consideren cercanos o no, se determina de acuerdo con las tolerancias absolutas y relativas dadas.; rel_tol es la tolerancia relativa: esta es la diferencia máxima permitida entre a y b, en relación con el valor absoluto mayor de a o b. Por ejemplo, para establecer una tolerancia del 5%, pasa rel_tol=0.05. La tolerancia predeterminada es 1e-09, lo que garantiza que los dos valores sean iguales considerando 9 dígitos decimales aproximadamente. rel_tol debe ser mayor que cero.; abs_tol es la tolerancia absoluta mínima, útil para las comparaciones cercanas a cero. abs_tol debe valer al menos cero.; Si no se encuentran errores, el resultado será: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).; Los valores especiales de IEEE 754 NaN, inf e -inf se manejarán de acuerdo con las reglas del IEEE. Concretamente, NaN no se considera cercano a ningún otro valor, incluido NaN. Por su parte, inf e -inf solo se consideran cercanos a sí mismos.; Nuevo en la versión 3.5.

Ver también

PEP 485 – Una función para comprobar la igualdad aproximada
método isfinite(x): Retorna True si x no es infinito ni NaN, o False en caso contrario. (Ten en cuenta que 0.0 es considerado finito.); Nuevo en la versión 3.2.
método isinf(x): Retorna True si x es infinito positivo o negativo, o False en caso contrario.
método isnan(x): Retorna True si x es NaN (not a number, en español: no es un número), o False en caso contrario.
método isqrt(n): Retorna la raíz cuadrada del número entero no negativo n. Es el resultado de aplicar la función suelo al valor exacto de la raíz cuadrada de n, o de forma equivalente, el mayor entero a tal que a² ≤ n.; Para algunas aplicaciones, puede ser más conveniente tener el menor número entero a tal que n ≤ a², en otras palabras, el resultado de aplicar la función techo a la raíz cuadrada exacta de n. Para n positivo, esto se puede calcular usando a = 1 + isqrt(n - 1).; Nuevo en la versión 3.8.
método lcm(*integers): Retorna el mínimo común múltiplo de los argumentos enteros. Si todos los argumentos no son cero, entonces el valor retornado es el entero positivo más pequeño que es un múltiplo de todos los argumentos. Si cualquiera de los argumentos es cero, entonces el valor retornado es 0. lcm() sin argumentos retorna 1.; Nuevo en la versión 3.9.
método ldexp(x, i): Retorna x * (2**i). Esta es esencialmente la función inversa de frexp().
método modf(x): Retorna la parte fraccionaria y entera de x. Ambos resultados son flotantes y tienen el mismo signo que x .
método nextafter(x, y): Retorna el siguiente valor flotante después de x en la dirección de y.; Si x es igual a y, retorna y.; Ejemplos:

método nextafter(x, método inf) va hacia el infinito positivo.
método nextafter(x, -método inf) va hacia el infinito negativo.
método nextafter(x, 0.0) va hacia cero.
método nextafter(x, método copysign(método inf, x)) se aleja de cero.

Ver también método ulp().; Nuevo en la versión 3.9.
método perm(n, k=None): Retorna el número de formas posibles de elegir k elementos de n elementos, sin repetición y en orden.; Se evalúa como n! / (n - k)! cuando k <= n y como cero cuando k > n.; Si k no se especifica o es None, k será igual a n por defecto y la función retornará n!.; Lanza una excepción TypeError si alguno de los argumentos no es un entero. Lanza una excepción ValueError si alguno de los argumentos es negativo.; Nuevo en la versión 3.8.
método prod(iterable, *, start=1): Calcula el producto de todos los elementos en la entrada iterable. El valor start predeterminado para el producto es 1.; Cuando el iterable está vacío, retorna el valor inicial. Esta función está diseñada específicamente para su uso con valores numéricos y puede rechazar tipos no numéricos.; Nuevo en la versión 3.8.
método remainder(x, y): Retorna el resto o residuo según la norma IEEE 754 de x con respecto a y. Para un valor x finito y un valor y finito distinto de cero, es la diferencia x - n * y, donde n es el número entero más cercano al valor exacto del cociente x / y. Si x / y está exactamente en mitad de dos enteros consecutivos, el entero par más cercano se utiliza para n. Por lo tanto, el residuo r = remainder(x, y) siempre satisface abs(r) <= 0.5 * abs(y).; Los casos especiales siguen el estándar IEEE 754: en particular, remainder(x, método inf) es x para todo x finito, y remainder(x, 0) junto a remainder(método inf, x) lanzan una excepción ValueError para todo x que no sea NaN. Si el resultado de la operación residuo es cero, este cero tendrá el mismo signo que x.; En plataformas que utilizan la norma IEEE 754 para números en coma flotante binarios, el resultado de esta operación siempre es exactamente representable: no se introduce ningún error de redondeo.; Nuevo en la versión 3.7.
método trunc(x): Retorna el valor Real x truncado a un Integral (generalmente un entero). Delega en x.__trunc__().
método ulp(x): Retorna el valor del bit menos significativo del flotante x:

Si x es un NaN (not a number), retorna x.
Si x es negativo, retorna ulp(-x).
Si x es un infinito positivo, retorna x.
Si x es igual a cero, retorna el flotante representable desnormalizado positivo más pequeño (menor que el flotante normalizado positivo mínimo, sys.float_info.min).
Si x es igual al flotante representable positivo más pequeño, retorna el bit menos significativo de x, de tal manera que el primer flotante menor que x es x - ulp(x).
De lo contrario (x es un número finito positivo), retorna el valor del bit menos significativo de x , de tal forma que el primer flotante mayor a x es x + ulp(x).

ULP significa Unit in the Last Place (unidad en el último lugar).

Ver también

método
		nextafter()

y sys.float_info.epsilon.

Nuevo en la versión 3.9.

Ten en cuenta que frexp() y modf() tienen un patrón de llamada/retorno diferente al de sus equivalentes en C: toman un solo argumento y retornan un par de valores, en lugar de retornar su segundo valor de retorno a través de un parámetro de salida (no existe tal cosa en Python).

Para las funciones ceil(), floor() y modf(), ten en cuenta que todos los números de coma flotante de magnitud suficientemente grande son enteros exactos. Los flotantes de Python normalmente no tienen más de 53 bits de precisión (lo mismo que el tipo double de C en la plataforma), en cuyo caso cualquier flotante x con abs(x) >= 2**52 no necesariamente tiene bits fraccionarios.

Funciones logarítmicas y exponenciales

método exp(x): Retorna e elevado a la x potencia, dónde e = 2.718281… es la base de los logaritmos naturales. Esto generalmente es más preciso que método e ** x o pow(método e, x).
método expm1(x): Retorna e elevado a la x potencia, menos 1. Aquí e es la base de los logaritmos naturales. Para flotantes x pequeños, la resta en exp(x) - 1 puede resultar en una pérdida significativa de precisión; la función expm1() proporciona una forma de calcular este valor con una precisión total:; >>>

>>> from math import exp, expm1
>>> exp(1e-5) - 1  # gives result accurate to 11 places
1.0000050000069649e-05
>>> expm1(1e-5)    # result accurate to full precision
1.0000050000166668e-05

Nuevo en la versión 3.2.
método log(x[, base]): Con un argumento, retorna el logaritmo natural de x (en base e).; Con dos argumentos, retorna el logaritmo de x en la base dada, calculado como log(x)/log(base).
método log1p(x): Retorna el logaritmo natural de 1+x (base e). El resultado se calcula de forma precisa para x cercano a cero.
método log2(x): Retorna el logaritmo en base 2 de x. Esto suele ser más preciso que log(x, 2).; Nuevo en la versión 3.3.

Ver también

int.bit_length() retorna el número de bits necesarios para representar un entero en binario, excluyendo el signo y los ceros iniciales.
método log10(x): Retorna el logaritmo en base 10 de x. Esto suele ser más preciso que log(x, 10).
método pow(x, y): Retorna x elevado a la potencia y. Los casos excepcionales siguen el Anexo “F” del estándar C99 en la medida de lo posible. En particular, pow(1.0, x) y pow(x, 0.0) siempre retornan 1.0, incluso cuando x es cero o NaN. Si tanto x como y son finitos, x es negativo e y no es un número entero, entonces pow(x, y) no está definido y se lanza una excepción ValueError.; A diferencia del operador incorporado **, método pow() convierte ambos argumentos al tipo float. Utiliza ** o la función incorporada pow() para calcular potencias enteras exactas.
método sqrt(x): Retorna la raíz cuadrada de x.

Funciones trigonométricas

método acos(x): Retorna el arcocoseno de x, en radianes. El resultado está entre 0 y pi.
método asin(x): Retorna el arcoseno de x, en radianes. El resultado está entre -pi/2 y pi/2.
método atan(x): Retorna la arcotangente de x, en radianes. El resultado está entre -pi/2 y pi/2.
método atan2(y, x): Retorna atan(y / x), en radianes. El resultado está entre -pi y pi. El vector del plano que va del origen al punto (x, y), forma este ángulo con el eje X positivo. La ventaja de atan2() es que el signo de ambas entradas es conocido, por lo que se puede calcular el cuadrante correcto para el ángulo. Por ejemplo, atan(1) y atan2(1, 1) son ambas pi/4, pero atan2(-1, -1) es -3*pi/4.
método cos(x): Retorna el coseno de x radianes.
método dist(p, q): Retorna la distancia euclidiana entre dos puntos p y q, cada uno de ellos dado como una secuencia (o iterable) de coordenadas. Los dos puntos deben tener la misma dimensión.; Aproximadamente equivalente a:

sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

Nuevo en la versión 3.8.
método hypot(*coordinates): Retorna la norma euclidiana, sqrt(sum(x**2 for x in coordinates)). Esta es la longitud del vector que va desde el origen hasta el punto dado por las coordenadas.; Para un punto bidimensional (x, y), esto equivale a calcular la hipotenusa de un triángulo rectángulo usando el teorema de Pitágoras, sqrt(x*x + y*y).; Distinto en la versión 3.8: Agregado soporte para puntos n-dimensionales. Anteriormente, solo se admitía el caso bidimensional.; Distinto en la versión 3.10: Improved the algorithm’s accuracy so that the maximum error is under 1 ulp (unit in the last place). More typically, the result is almost always correctly rounded to within 1/2 ulp.
método sin(x): Retorna el seno de x radianes.
método tan(x): Retorna la tangente de x radianes.

Conversión angular

método degrees(x): Convierte el ángulo x de radianes a grados.
método radians(x): Convierte el ángulo x de grados a radianes.

Funciones hiperbólicas

Las funciones hiperbólicas son análogas a las funciones trigonométricas pero basadas en hipérbolas en lugar de en círculos.

método acosh(x): Retorna el coseno hiperbólico inverso de x.
método asinh(x): Retorna el seno hiperbólico inverso de x.
método atanh(x): Retorna la tangente hiperbólica inversa de x.
método cosh(x): Retorna el coseno hiperbólico de x.
método sinh(x): Retorna el seno hiperbólico de x.
método tanh(x): Retorna la tangente hiperbólica de x.

Funciones especiales

método erf(x): Retorna la función error en x.; La función erf() se puede utilizar para calcular funciones estadísticas tradicionales como la distribución normal estándar acumulativa:

def phi(x):
    'Cumulative distribution function for the standard normal distribution'
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

Nuevo en la versión 3.2.
método erfc(x): Retorna la función error complementaria en x. La función error complementaria se define como 1.0 - erf(x). Se usa para valores grandes de x donde una resta de 1 causaría una pérdida de presición.; Nuevo en la versión 3.2.
método gamma(x): Retorna la función gamma en x.; Nuevo en la versión 3.2.
método lgamma(x): Retorna el logaritmo natural del valor absoluto de la función gamma en x.; Nuevo en la versión 3.2.

Constantes

método pi: La constante matemática π = 3.141592…, hasta la precisión disponible.
método e: La constante matemática e = 2.718281…, hasta la precisión disponible.
método tau: La constante matemática τ = 6.283185…, hasta la precisión disponible. Tau es una constante del círculo igual a 2π, la razón entre la circunferencia de un círculo y su radio. Para obtener más información sobre Tau, consulta el video de Vi Hart,
, y comienza a celebrar el el día de Tau ¡comiendo el doble de tarta!; Nuevo en la versión 3.6.
método inf: Un valor infinito positivo en punto flotante. (Para un valor infinito negativo, usa -método inf.) Equivalente a la salida de float('inf').; Nuevo en la versión 3.5.
método nan: Un valor de punto flotante que «no es un número» (NaN). Equivalente a la salida de float('nan').; Nuevo en la versión 3.5.

CPython implementation detail: El módulo math consiste principalmente en delgados envoltorios alrededor de las funciones matemáticas de la biblioteca de C de la plataforma. El comportamiento en casos excepcionales sigue el Anexo F del estándar C99 cuando corresponda. La implementación actual lanzará un ValueError para operaciones no válidas como sqrt(-1.0) o log(0.0) (donde el estándar C99 recomienda señalar que la operación no es válida o que hay división entre cero), y un OverflowError para aquellos resultados de desbordamiento (por ejemplo, exp(1000.0)). No se retornará NaN para ninguna de las funciones anteriores, a no ser que al menos uno de los argumentos de la función sea NaN. En este caso, la mayoría de las funciones retornan NaN, pero de nuevo (de acuerdo con el apéndice F del estándar C99) hay algunas excepciones a esta regla, por ejemplo pow(float('nan'), 0.0) o hypot(float('nan'), float('inf')).

Ten en cuenta que Python no hace ningún esfuerzo por distinguir los NaN de señalización de los NaN silenciosos, y el comportamiento de señalización de los NaN permanece sin especificar. El comportamiento estándar es tratar a todos los NaN como silenciosos.

3. Módulos

Un módulo es un archivo de Python que contiene declaraciones y definiciones, variables, constantes de Python. Por ejemplo, un archivo mi_programa.py es un módulo, y lo llamamos "mi_programa". Los que saben, agrupan código similar juntos ,en un módulo.

Esto nos ayuda a modularizar nuestro código y hacer que sea mucho más fácil tratarlo. Y no solo eso, un módulo nos garantiza la reutilización. Con un módulo, no necesitamos volver a escribir el mismo código para un nuevo proyecto que emprendemos, no reinventamos la rueda, solo la usamos.

Observación:

Algunas de las declaraciones de nombres, variables funciones podrían tener el mismo nombre que las que utilizamos en nuestros programas...esto implica que debemos ver la manera de evitar estos conflictos, veremos como hacerlo mas adelante.

La idea es que el usuario importe de lo que otros programaron solo lo que vaya a usar ( tomar lo que se necesita).

Analogía:

Si vamos de vacaciones a la playa, por ejemplo al Caribe, Ud. llevaría en su equipaje bufanda, campera?
Si vamos de expedición a la Antártida Ud. llevaría traje de baño en su equipaje?

Figura 1

Estas preguntas sirven para Justificar por que NO siempre tenemos que "tomar TODO" (importar todos) los elementos de un módulo. Ya veremos mas sobre esto.

Modulos-Paquetes

Si bíen en Funciones ya hicimos referencia a este tema vamos a profundizar en esta sección. Los módulos se organizan en Paquetes.

¿Que es un módulo o module ?

En Python un modulo es un fichero que contiene codigo del lenguaje almacenados con la extension .py en donde se almacenan la declaracion de variables, funciones, objetos y demás.

¿Que es un Paquete o Packages en Python?

Un Packages en Python es como colección de Módulos y puede estar divido en Sub Paquetes.

Figura 1

Podemos ver que los módulos son archivos del tipo .py
Podemos ver que un Paquete contiene una organización jerárquica de sub-paquetes los cuales contienen módulo.
Veremos que si incorporamos un Paquete, estaremos incorporando también muchos módulos ( archivos .py)
Veremos que existe la posibilidad de incorporar solo un módulo de un paquete, en ese caso solo estaríamos incorporando lo que necesitamos.

Observación:

Hay un termino que se suele usar llamado Librería o Library el mismo es software escrito en cualquier lenguaje y no solo Python ( como los módulos o paquetes ) que permiten acceder funcionalidades escritos por otros en otros lenguajes, evitando así la pérdida de horas productivas en hacer algo que ya se ha hecho. Sobre esto no trataremos en la materia.

Veamos como importar módulos en Python.

4. Tipos de Módulos

Librerías de Estándar de Python

Python viene con una biblioteca de módulos estándar, sobre la podemos encontrar toda a información en The Python Standard Library

Mencionemos algunos:

OS ( Sistema Operativo)
Módulo Matemáticas ( math )
Módulo de Estadísticas ( statistics )
Acceso a Internet.
Comprimir datos.
datetime
time
sys
locale
MySQLdb

Librerías no estándar

También hay otros módulos que no son estándar de Python como ser:

numpy
matplotlib
pylab, parte de matplotlib
sympy
panda

1) NumPy :

Acrónimo de Numerical Python. Su características más potente es que puede trabajar con matrices (array) de n dimensiones. También ofrece funciones básicas de algebra lineal, transformada de Fourier, capacidades avanzadas con números aleatorios, y herramientas de integración con otros lenguajes de bajo nivel como Fortran, C y C++. Para mayor información podemos remitirnos a : https://numpy.org/doc/stable/reference/.

2) Matplotlib:

Es una librería de gráficos, desde histogramas, hasta gráficos de líneas o mapas de calor. Fue creada teniendo en mente una aplicación llamada Matlab. También se pueden usar comandos de Latex para agregar expresiones matemáticas a tu gráfica. Para mayores detalles sobre el módulo matplotlib se pueden remitir al sitio : https://matplotlib.org . Hay una gran cantidad de ejemplos en : https://matplotlib.org/tutorials/index.html

3) Pylab:

Es un módulo de Matplotlib para matemáticas y para trabajar con matrices en un solo espacio de nombres, haciendo que ese espacio de nombres (o entorno) sea aún más parecido a MATLAB.

4) SymPy:

Es una biblioteca de Python para matemática simbólica. Su objetivo es convertirse en un sistema de álgebra computacional (CAS) con todas las funciones, manteniendo el código lo más simple posible para que sea comprensible y fácilmente extensible. SymPy está escrito completamente en Python. Para mayores detalles sobre el módulo matplotlib se pueden remitir al sitio : https://www.sympy.org/en/index.html

5) Pandas:

Es una herramienta de análisis y manipulación de datos de código abierto rápida, potente, flexible y fácil de usar, construido sobre el lenguaje de programación Python. Para mayores detalles sobre el módulo matplotlib se pueden remitir al sitio : https://pandas.pydata.org/

Veremos a continuación como instalar Módulos no estándar en el siguiente capítulo.

¿Si Matplotlib fue creado pensando en Matlab, porqué debería usarlo en vez de usar el mismo Matlab?

El Matlab es una herramienta muy poderosa de uso en la Ingeniería, por ejemplo es probalbe que la utilicen en Matemática Aplicada.

MATLAB (abreviatura de MATrix LABoratory, «laboratorio de matrices») es un sistema de cómputo numérico que ofrece un entorno de desarrollo integrado (IDE) gráfico ( como el Spyder) con un lenguaje de programación propio (lenguaje M). Está disponible para las plataformas Unix, Windows, macOS y GNU/Linux.

Es una herramienta que tiene un costo importante como podemos ver en su sitio:

Figura 1

Es por eso que si no disponemos de 940u$ para una licencia de un año o 2350u$ para una licencia a perpetuidad ( no caduca ) tenemos que considerar opciones Libre como ser Octave o Matplotlib.

Octave es una herramienta libre Octave es parte del proyecto GNU. Es considerado el equivalente libre de MATLAB ( sin costo $). Existe para todos los Sistemas Operativos tal como se muestra en su sitio: https://www.gnu.org/software/octave/

Matplotlib no trata de ser un reemplazo a Matlab como si lo es Octave. Matplotlib es un librería para Python que permite realizar gráficas brindando múltiples facilidades para lograr ese objetivo. Si queremos realizar gráficas de cualquier tipo y no necesitamos toda la cantidad de toolboxes que vienen con Matlab, matplotlib es justo lo que necesitamos y sin costo.

Matplotlib fue creado tomando como base a Matlab por lo que para las personas que han gráficado alguna vez en su vida con Matlab, Matplotlib les va a resultar muy familiar. Podemos exportar nuestras gráficas en los formatos de imágenes mas populares e incluso a formato latex para su inclusión en artículos científicos.

5. pip: Instalando módulos en Python

Instalar módulos de Python usando pip

Puedes usar la utilidad pip para instalar módulos y paquetes. En algunas ocasiones si tenemos instalado Python 2.x y 3.x deberíamos usar pip2 o pip3 respectivamente para instalar el módulo en la versión 2.x o 3.x.

pip install panda
pip3 install panda
pip2 install panda

La mayoría de los desarrolladores prefieren instalar módulos utilizando pip, si bien hay otros.

Lo mejor de pip es que maneja la comprobación de dependencias, esto de dependencias quiere decir que toma todo lo necesario para que funcione el módulo, ya que algunas veces estos módulos dependen de otros.. es por eso que al decir que comprueba las dependencias, lo que hace es ver que necesita e incluirlo en la instalación.

Puedes instalar módulos Python usando pip de la siguiente forma:

Figura 1

En este caso estamos instalando el módulo panda.

Observación :

Instalar un módulo es la primer parte, luego debemos IMPORTARLO a script para poder usarlo. Ya veremos esto.

Nota:

En algunos casos, para el sistema operativo Linux, puede existir la posibilidad de que se pueda utilizar el comando:

pip3 install --user gym --break-system-packages

En caso que tire un error del tipo:

6. pip: IPython Console -Spyder

IPython Console

Si usamos Spyder, la consola del interprete de Python se llama: IPython Console ( que no es el interprete de Python!! , es parecido)
Podemos ver la documentación sobre esta sub aplicación de Spyder https://docs.spyder-ide.org/ipythonconsole.html

Y por que es parecido al interprete de Python pero no igual es por eso que existen algunas diferencias entre ejecutar el pip desde la terminal del Sistema Operativo a ejecutar desde la consulta del IPython Console del Spyder.

Ejemplo, para instalar un módulo sympy:

Desde una terminal de Linux : pip install sympy
Desde IPython Console: %pip install sympy

Si la pregunta que surge es por que ponemos el % para invocar al comando pip, podemos escribir pip en la consola de Ayuda de lal interface de Python.

Figura 1

Figura 2

Entonces desde la consola de IPython console escribimos:

Figura 3

Y ya tendremos instalada la librería!!!

7. Estructura-Orden de un Programa en Python

Como se comentó muchas veces a lo largo del curso, Python entre otras cosas es un lenguaje estructurado, y para ello utiliza la sintaxis, como ser indentación.

Por lo tanto la sintaxis es parte del lenguaje, es por ello que debemos respetar el siguiente orden al escribir un programa

Comentarios, aclaraciones
Importación de módulos o partes de módulos
Definición de constantes
Definición de funciones
Cuerpo Principal del Programa

8. import: Importando módulos

Luego que se haya instalado un módulo o paquete este puede ser usado en un programa.

Para ello se usa la sentencia: import

Los módulos deben importarse al principio del programa, en orden alfabético.

Primero los propios de Python, luego los de terceros ( en caso de existir) y , finalmente, los de la aplicación.

Figura 1

vemos su salida:

Figura 2.

1) Observemos que se importa TODO lo que tiene el módulo math, pese a que SOLO se usa la definición de la constante PI y el seno !!

2) Observemos que se usa el operador . (punto) para sin o pi , o sea que es un método de math.

Analogía:

Sería como llevar un cajón de herramientas completo muy pesado y para luego solo usar un destornillador y una pinza.

Otro ejemplo:

Figura 3

tendría una salida:

Figura 4

Donde podemos ver que muestra la hora del ordenador donde se ejecutó el programa. datetime es una librería estándar de Python ( https://docs.python.org/3/library/datetime.html ). Lamentablemente el nombre del método y de la libraría coinciden :-(. Veremos mas adelante que se pueden cambiar de nombre las librerías al importar.

Error: No module named..

Podría suceder que el módulo que estamos importando no esté instalado, en ese caso se vería algo como:

Figura 5

y el Error al intentar ejecutar:

Figura 6

9. import vs import from

Si desarrollé un modulo personal que se llama mi_modulo.py el cual contiene

Vemos que el mismo tiene 2 funciones, factorial y suma. Si importo factorial desde mi_modulo.py el programa quedaría:

En este caso SOLO se importa uno de las funciones.. factorial. Al ejecutar quedaría:

Nota: podemos observar que : el directorio de mi_modulo y programa.py son el mismo!!

Pero que pasaría si mi_modulo.py tuviera muchas funciones que debo usar? .
Una respuesta sería poner una línea form mi_modulo impor xzy donde xzy sería el nombre de la función.
Otra forma sería importar TODAS las funciones de mi_modulo de la siguiente forma :

ç

Vemos la línea 7: import mi_modulo, aqui importamos TODOS los módulos.
Pero para poder usarlos debemos pensarlos como métodos de un módulo y usar el operador . ( punto) , tal como se muestra en las líneas:

Al ejecutar este script tendríamos:

Re-nombrando Módulos.

En el caso de que nos resultase largo o difícil el nombre mi_modulo, podríamos re-nombrarlo , en ese caso quedaría:

Podemos ver que en las líneas 11 y 13 ahora se menciona a pepito en lugar de mi_modulo.

10. La sentencia import ...from

Luego que se haya instalado un módulo o paquete este puede ser usado en un programa. Para ello se usa la sentencia: import

Como mencionamos anteriormente, la sentencia from carga solo atributos especificados.

Vamos a crear un módulo propio, recordemos que un módulo no es mas que un archivo de Python, Nuestro archivo se llama mi_modulo.py

Figura 1

Guardo este "modulo" propio creado por mi en el mismo directorio que el archivo python siguiente que se llama programa1.py

Utilizar la sentencia from permite que escribamos menos debido a que no tienes que especificar el nombre completo del módulo cuando lo llamas,

De hecho, en su interior, la sentencia from es una extensión de sentencia import, también se carga el archivo completo ( *, quiere decir TODOS los elementos del Módulo), pero se le proporcionarán todos los atributos directamente desde tu código.

Figura 2

Vemos que si bien el diccionario persona1 , no está definido ni declarado en el código está importado, solo ese diccionario. Esta sería la salida:

Figura 3

El peligro de utilizar la sentencia From:

Algunos desarrolladores de Python recomiendan usar siempre la sentencia import y evitar la from. ¿Pero esto es cierto? ¿La sentencia from no es segura?.

Bueno, si utilizamos el archivo from para importar variables o funciones, como el caso anterior que importamos el diccionario persona1, sobrescribirá cualquier variable que tenga el mismo nombre si existe sin previo aviso. Esto genera confusión y hay que tomar mucho cuidado. Veamos un ejemplo.

mi_modulo.py

Figura 4

programa1.py

Figura 5

La salida sería:

Figura 6

Vemos que la variable x en mi_modulo.py vale 999, pero en la ejecución se toma el valor local 5. Esto se agrava si no somos nosotros los que escribimos el módulo..por lo que es muy probable que desconozcamos muchos nombres de variables, constantes y funciones.

import ..from vs. import.

El uso de uno u otro modifica la forma en que voy a hacer referencia a los elementos, de esta manera minimizamos el problema anterior (usando import. ) ya que debemos usar el nombre completo del módulo .(punto) nombre de la función o método. Veamos con un ejemplo.

mi_modulo.py

Figura 7

programa1.py

Figura 8

Vemos que al usar el operador . (punto) no hay posibilidades de equivocarse, ya que en la línea 8 el operador . hace que se ejecute saludos de mi_modulo.py y en la línea 9 se ejecuta saludos de la línea 4. Esta sería la salida.

Figura 9

11. La sentencia import as (alias)

Es posible que desee cambiar un nombre porque ya ha usado el mismo nombre para otra cosa en su programa, otro módulo que ha importado también usa ese nombre, o puede querer abreviar un nombre más largo que está usando mucho.

La construcción de esta declaración se ve así:

import [nombre del módulo] as [alias o nombre nuevo]

Veamos un ejemplo:

vemos que en la línea 1 se declara un apodo o alias para math, de ahora en mas se puede hacer referencia usando la m, tal como se hace en la línea 3 y 4.

Esto se vuelve mas importante cuando por ejemplo usamos el módulo matplotlib.pyplot

Veamo un ejemplo:

import numpy as np #ver aquí el Alias o apodo
import matplotlib.pyplot as plt #ver aquí el Alias o apodo

x = np.linspace(0, 10, 500)
y = np.sin(x)

fig, ax = plt.subplots()

# Using set_dashes() to modify dashing of an existing line
line1, = ax.plot(x, y, label='Usando líne y puntos set_dashes()')
line1.set_dashes([2, 2, 10, 2])  # 2pt line, 2pt break, 10pt line, 2pt break

# Using plot(..., dashes=...) to set the dashing when creating a line
line2, = ax.plot(x, y - 0.2, dashes=[6, 2], label='Setenado parámetros de - ')

ax.legend()
plt.show()


Este código ejecutado en Spyder tendía esta salida:

12. Espacios de Nombres.

Libro de recetas en blanco para crear tus propios platos: Barcelover: Barcelover: 9781519646262: Amazon.com: Books Amazon.com: Mi gran libro de recetas libro de recetas en blanco: 200 páginas Mis Recetas Favoritas - Libro de recetas mis platos - En blanco para crear tus ... por 100 tarjetas

Que pasa si dos libros de recetas tienen recetas con el mismo nombre pero que en realidad son comidas diferentes?

__init__.py => indica s python que es un paquete!! , esto le indica a Python que donde encuentre este archivo el contenido de este directorio es un paquete ( muchos libros de recetas)

Organizando nuestro código. Todo el sistema de
2:08 / 4:11

Velocidad: Presiona ARRIBA para acceder al menú, luego usa las teclas de ARRIBA y ABAJO para cambiar a diferentes velocidades, y presiona ENTER para cambiar a la velocidad seleccionada.

Haz clic en este botón para silenciar o activar el sonido del vídeo o usa los botones ARRIBA o ABAJO para aumentar o disminuir el nivel de volumen.
Muy alto Volumen.
Transcripción de video

    Inicio de la transcripción. Saltar al final.
    Hola en este vídeo vamos a hablar sobre los paquetes y espacios
    de nombre en Python. Como vimos en el vídeo anterior, por un lado
    están las funciones que son común recetas. Y luego
    están los módulos que son libros de recetas y los paquetes
    que son estanterías llenas de libros de recetas.
    Y una cosa que tenemos que tener claro es los espacios de nombre.
    Tú cuando quieres ver una receta es importante saber
    que la receta es la de un libro en concreto o la de otro. Porque
    a lo mejor dos libros tienen la misma receta sobre cómo hacer
    una hamburguesa pero no las dos van a ser igual, no las dos
    te van a gustar igual. Y no es lo mismo una hamburguesa como
    veis aquí que una hamburguesa en otro restaurante.
    Normalmente un módulo que es un archivo punto py y que tienen
    la funcionalidad que queremos tener que es nuestro libro de
    recetas. Pues es simplemente como podemos ver aquí un ejemplo. Este
    tenemos, hemos escrito un libro de recetas punto py. En el cual,
    hemos definido una constante de gravedad nueve coma ocho y
    una función suma que tiene dos parámetros y devuelve el valor
    de la suma. Esto sería un ejemplo de un módulo muy sencillo
    que habríamos hecho nosotros y queremos tener varios módulos
    para organizar nuestros distintos libros de recetas.
    Entonces, necesitamos crear una carpeta, como por ejemplo esta
    que llamado estantería. Y si veis esta carpeta empieza con
    un archivo que tiene dos guiones bajos, init, los guiones bajos
    punto py. Ese archivo no hace falta que tenga nada, pero ese
    archivo le está diciendo a esta carpeta que es un paquete. Entonces,
    Python cuando vea ese archivo sabe que tiene tratarlo como
    un paquete y que todos los módulos que están aquí dentro
    pertenecen a ese paquete. Entonces, nosotros igual que hacíamos
    import del del módulo podemos hacer import del paquete y lo
    que nos traeremos serán todos los libros de recetas que están
    dentro del paquete.

¿Que es un paquete?

Un paquete es un módulo que sirve para contener otros módulos y paquetes. En la práctica es un directorio que contiene un archivo ‘__init__.py’. Dentro de dicho directorio podemos tener almacenados otros módulos o paquetes.

13. Ejercicios Resueltos

Ejercicios resueltos con módulos, librerías, etc.

14. Tiro parabólico.

Al ejecutar este script se vería algo como:

Solución: