Fundamentos en

Acerca de Fundamentos

Python es un lenguaje de programación dinámico y de tipado fuerte. Emplea tanto el duck typing como el tipado gradual, mediante anotaciones de tipo. Los estilos de programación imperativo, declarativo (por ejemplo, funcional) y orientado a objetos son todos compatibles, pero internamente todo en Python es un objeto.

Python pone un gran énfasis en la legibilidad del código y (al igual que Haskell) usa la indentación significativa para denotar definiciones de funciones, métodos y clases.

Python fue creado por Guido van Rossum y se publicó por primera vez en 1991. La Python Software Foundation gestiona y dirige los recursos para el desarrollo de Python y CPython, y recibe propuestas de cambios al lenguaje de miembros de la comunidad a través de las Propuestas de Mejora de Python o PEPs.

La documentación completa de la versión actual se encuentra en docs.python.org.

• Tutorial de Python
• Referencia de la biblioteca de Python
• Referencia del lenguaje Python
• Guías prácticas de Python
• Preguntas frecuentes de Python
• Glosario de términos de Python

Este primer concepto presenta 4 características principales del lenguaje Python:

1. Asignación de nombres (variables y constantes),
2. Funciones (la palabra clave def y la palabra clave return),
3. Comentarios, y
4. Docstrings.

Asignación de nombres (variables y constantes)

En Python, no se usan palabras clave para crear variables ni constantes. En su lugar, quienes programan pueden vincular nombres (también llamados variables) a cualquier tipo de objeto usando el operador de asignación =: <name> = <value>. Un nombre se puede reasignar (o volver a vincular) a distintos valores (distintos tipos de objeto) a lo largo de su existencia.

Por ejemplo, my_first_variable se puede reasignar muchas veces usando =, y puede referirse a distintos tipos de objeto en cada reasignación:

>>> my_first_variable = 1  # my_first_variable bound to an integer object of value one.
>>> my_first_variable = 2  # my_first_variable re-assigned to integer value 2.

>>> print(type(my_first_variable))
<class 'int'>

>>> print(my_first_variable)
2

>>> my_first_variable = "Now, I'm a string." # <--You may re-bind a name to a different object type and value.
>>> print(type(my_first_variable))
<class 'str'>

>>> my_first_variable = 'You can call me "str".' # <--Strings can be declared using single or double quote marks.
>>> print(my_first_variable)
You can call me "str".

>>> import collections
>>> my_first_variable = collections.Counter([1,1,2,3,3,3,4,5,6,7]) # <--Now my_first_variable has been re-bound to a Counter object.
>>> print(type(my_first_variable))
<class 'collections.Counter'>

>>> print(my_first_variable)
Counter({3: 3, 1: 2, 2: 1, 4: 1, 5: 1, 6: 1, 7: 1})

Constantes

Las constantes son nombres que se asignan una sola vez en un programa. Se definen a nivel de módulo (archivo) y, por lo general, son visibles para todas las funciones y clases del programa. Usar SCREAMING_SNAKE_CASE indica que el nombre no debe reasignarse ni su valor debe modificarse.

# All caps signal that this is intended as a constant.
MY_FIRST_CONSTANT = 16

# Re-assignment will be allowed by the compiler & interpreter,
# but this is VERY strongly discouraged.
# Please don't do this, it could create problems in your program!
MY_FIRST_CONSTANT = "Some other value"

Funciones

En Python, las unidades de funcionalidad se encapsulan en funciones, que a su vez son objetos (es tortugas hasta el fondo).

Las funciones se pueden ejecutar por sí solas, pasar como argumentos a otras funciones, anidar o vincular a una clase. Cuando las funciones se vinculan al nombre de una clase, se denominan métodos. Las funciones y clases relacionadas (con sus métodos) se pueden agrupar en el mismo archivo o módulo, e importar en parte o en su totalidad para usarlas en otros programas.

La palabra clave def inicia una definición de función. Cada función puede tener cero o más parámetros formales entre paréntesis (), seguidos de dos puntos :. Las sentencias del cuerpo de la función comienzan en la línea siguiente a def y deben estar indentadas en un bloque:

# The body of a function is indented by 2 spaces & prints the sum of the numbers.
def add_two_numbers(number_one, number_two):
  total = number_one + number_two
  print(total)  

>>> add_two_numbers(3, 4)
7


# Inconsistent indentation in your code blocks will raise an error.
>>> def add_three_numbers_misformatted(number_one, number_two, number_three):
...     result = number_one + number_two + number_three   # This was indented by 4 spaces.
...    print(result)     # <--This was only indented by 3 spaces.
...
...
  File "<stdin>", line 3
    print(result)
    ^
IndentationError: unindent does not match any outer indentation level

Las funciones devuelven explícitamente un valor u objeto mediante la palabra clave return:

# Function definition on first line, explicit return used on final line.
def add_two_numbers(number_one, number_two):
  return number_one + number_two   


# Calling the function in the Python shell returns the sum of the numbers.
>>> add_two_numbers(3, 4)
7

# Assigning the function call to a variable and printing 
# the variable will also return the value.
>>> sum_with_return = add_two_numbers(5, 6)
>>> print(sum_with_return)
11

Las funciones que no tienen una expresión explícita después de un return devolverán implícitamente el objeto None. Los detalles de None se verán en un concepto posterior. Para los fines de este ejercicio y esta explicación, None es un marcador de posición que representa nada, o null:

# This function will return `None`
def square_a_number(number):
    square = number * number
    return # <-- note that this return is not followed by an expression

# Calling the function in the Python shell appears 
# to not return anything at all.
>>> square_a_number(2)
>>>


# Using print() with the function call shows that 
# the function is actually returning the **None** object.
>>> print(square_a_number(2))
None

Las funciones que omiten return también devolverán implícitamente el objeto None. Esto significa que si no usas return en una función, Python devolverá el objeto None por ti.

# This function omits a return keyword altogether
def add_two_numbers(number_one, number_two):
  result = number_one + number_two

>>> add_two_numbers(5, 7)
>>> print(add_two_numbers(5, 7))
None

# Assigning the function call to a variable and printing 
# the variable will also show None.
>>> sum_without_return = add_two_numbers(5, 6)
>>> print(sum_without_return)
None

Llamar a funciones

Las funciones se llaman o se invocan usando su nombre seguido de (). La notación de punto (.) se usa para llamar a funciones definidas dentro de una clase o un módulo.

>>> def raise_to_power(number, power):
...     return number ** power
...

>>> raise_to_power(3,3) # Invoking the function with the arguments 3 and 3.
27


# A mis-match between the number of parameters and the number of arguments will raise an error.
>>> raise_to_power(4,)
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: raise_to_power() missing 1 required positional argument: 'power'


# Calling methods or functions in classes and modules.
>>> start_text = "my silly sentence for examples."
>>> str.upper(start_text)  # <--Calling the upper() method from the built-in str class on start_text.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Because a string is an instance of the str class, methods can also be called on them "directly".
>>> start_text = "my silly sentence for examples."
>>> start_text.upper()  # <--Calling the upper() method on start_text directly.
'MY SILLY SENTENCE FOR EXAMPLES.'

# Alternatively, we can skip the variable assignment (although this gets messy quick).
>>> "my silly sentence for examples.".upper()
'MY SILLY SENTENCE FOR EXAMPLES.'


# Importing the math module
>>> import math
>>> math.pow(2,4)  # <--Calling the pow() function from the math module.
16.0

Comentarios

Los comentarios en Python comienzan con un # que no forma parte de un string y terminan al final de la línea. A diferencia de muchos otros lenguajes de programación, Python no admite marcas de comentarios de varias líneas. Cada línea de un bloque de comentarios debe comenzar con el carácter #.

El intérprete ignora los comentarios:

# This is a single line comment.

x = "foo"  # This is an in-line comment.

# This is a multi-line
# comment block over multiple lines --
# these should be used sparingly.

Docstrings

La primera sentencia del cuerpo de una función puede ser, de forma opcional, un docstring, que resume de manera concisa el propósito de la función o del objeto. Los docstrings se declaran usando comillas triples dobles (""") indentadas al mismo nivel que el bloque de código:

# An example from PEP257 of a multi-line docstring
# reformatted to use Google style non-type hinted docstrings.
# Some additional details can be found in the Sphinx documentation:
# https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html#getting-started

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword Arguments:
        real (float): The real part of the number (default 0.0)
        imag (float): The imaginary part of the number (default 0.0)
        
    """

    if imag == 0.0 and real == 0.0:
        return complex_zero

Las herramientas de documentación automatizadas leen los docstrings, y estos se devuelven al llamar al atributo especial .__doc__ en el nombre de la función, el método o la clase. Se recomiendan para programas de cualquier tamaño en los que se necesite documentación, y sus convenciones se describen en PEP257.

Los docstrings también pueden funcionar como pruebas unitarias ligeras, que PyTest puede leer y ejecutar, o que se pueden leer y ejecutar importando el módulo doctest. Las pruebas y doctest se verán en un concepto posterior.

# An example on a user-defined function using a Google style docstring. 
>>> def raise_to_power(number, power):
    """Raise a number to an arbitrary power.

    Parameters:
        number (int): The base number.
        power (int): The power to raise the base number to.
    
    Returns:
        int: The number raised to the specified power.
    
    Takes a number and raises it to the specified power, returning the result.

    """

    return number ** power
...

# Calling the .__doc__ attribute of the function and printing the result.
>>> print(raise_to_power.__doc__)
Raise a number to an arbitrary power.

Parameters:
    number (int): The base number.
    power (int): The power to raise the base number to.

Returns:
    int: The number raised to the specified power.

Takes a number and raises it to the specified power, returning the result.

...

# Printing the __doc__ attribute of the built-in type: str.
>>> print(str.__doc__)
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or
errors is specified, then the object must expose a data buffer
that will be decoded using the given encoding and error handler.
Otherwise, returns the result of object.__str__() (if defined)
or repr(object).
encoding defaults to 'utf-8'.
errors defaults to 'strict'.