Todo lo que necesitas saber para iniciar en Python

En este apartado, vamos a dar una introducción a Python, esta sección la puedes tomar como reforzamiento para lo que es el desarrollo del framework que haremos en la siguiente sección.

Es importante señalar que esta sección es un reforzamiento y no una introducción desde cero a la programación, por lo tanto, se da por hecho de que el lector tiene conocimientos al menos básicos en la programación y en Python en general.

Consola interactiva/consola de Python

La primera herramienta que puedes emplear al momento de desarrollar en Python es la consola interactiva, una vez instalado Python en tu equipo y configurado la variable de entorno para que pueda ser empleado mediante la terminal, al abrir una CMD o Terminal y escribir:

$ python
Los caracteres de:
>>>

Indican que la consola está esperando que escribas algo, y no son caracteres que debes de escribir al realizar las diversas pruebas que haremos en esta sección.

Verás que la consola queda activa lista para realizar las primeras pruebas con Python, desde aquí puedes crear variables, funciones, listas, clases, etc, todo de propósito de pruebas, y esta herramienta es ideal para cuando quieres dar conocer la desarrollar en el lenguaje o realizar algunas pruebas con algún script.

Por ejemplo, si escribes un número, veras la salida por pantalla:

>>> 6
6
>>>

O un texto:

>>> hello world
hello world
>>>

En definitiva, puedes tomar la consola interactiva de Python como una herramienta más que tienes fácilmente disponible para realizar pruebas.

Archivos de Python

La manera tradicional de desarrollar en cualquier lenguaje de programación es mediante un archivo que luego es o compilado o interpretado como en el caso de Python, puedes crear una carpeta en cualquier ubicación de tu equipo que llamaremos:

C:\Users\andres\Escritorio\proyectos\python

Desde aquí desarrollaremos los distintos scripts que veremos en este apartado.

Crearemos un archivo llamado:

test.py

En el caso de este escrito, colocamos el archivo en la ubicación anterior en el escritorio y desde aquí, haremos un hola mundo:

C:\Users> cd C:\Users\andres\Escritorio\proyectos\python

La función de print() permite imprimir un texto por la terminal o CMD y es una herramienta que usaremos enormemente para hacer rápidamente debug al momento de desarrollar las distintas funcionalidades de nuestra aplicación, así que, siguiendo nuestro ejemplo colocamos:

test.py

print("hello world")

Y para ejecutar, desde la terminal y sin ejecutar la consola interactiva de Python, ejecutamos:

$ python test.py

Y veremos por la consola:

hello world

También puedes ejecutar el contenido anterior desde la consola interactiva de Python:

>>> print("hello world")
hello world

En esta sección, tú puedes decidir cuándo emplear una o la otra dependiendo de tus preferencias.

Variables y tipo de datos

Lo primero que debemos de conocer en cualquier lenguaje de programación es el uso de las variables para almacenar datos y de los tipos de datos, que son las primitivas en cualquier lenguaje de programación, en Python, podemos almacenar números y cadenas de textos o strings; específicamente:

• Text Type: str
• Numeric Types: int, float, complex
• Sequence Types: list, tuple, range
• Mapping Type: dict
• Set Types: set, frozenset
• Boolean Type: bool
• Binary Types: bytes, bytearray, memoryview
• None Type: NoneType

Python no es un lenguaje en el cual debemos de colocar el tipo de dato al momento de declarar la variable, es de tipificado dinámico, lo que significa que Python lo infiera al momento de inicializar un valor:

n = 5

Si no, como en JavaScript se infiere el tipo en base al valor declarado; si es un entero:

n = 5

Si es un flotante:

n = 5.2

O un String:

t = 'text'

Un booleano:

b = True

En python, tenemos una función llamada type() con la cual podemos preguntar el tipo de datos:

>>> t = 'text'
>>> type(t)
<class 'str'>

O para medir la longitud:

>>> t = 'text'
>>> len(t)
4

Operaciones matemáticas

Las operaciones matemáticas no cambian en absoluto si las comparamos con otros lenguajes de programación, independientemente de si el resultado a operar se encuentra almacenado en una variable, o es un valor fijo o retornado de una función o similar:

>>> a = 5
>>> 4 + a
9

Siempre podemos realizar operaciones matemáticas:

>>> a = 5
>>> 4 + a
9
>>> 4 - a
-1
>>> -4 + a
1
>>> 4 / a
1.0
>>> 4 % a
4
>>> 4 * a
20

Concatenación de String

Muchas veces tenemos dos o más String y queremos convertirlo en uno, para eso, debemos de concatenar los textos, para eso, empleamos el mismo operador que el de la adición o suma visto anteriormente:

>>> name = 'andres'
>>> surname = 'cruz'
>>> name+surname
'andrescruz'

Aquí puedes ver que con el mismo operador + variar de tipo de dato, la operación es diferente.

Casteos

También podemos convertir entre tipos de datos, para ello, tan solo hay que emplear funciones como int(), str(), float() para castear los datos al correspondiente tipo; por ejemplo, de un entero a flotante:

>>> n = 5
>>> float(n)
5.0

De un flotante a un entero:

>>> n = 5.2
>>> int(n)
5

Un número a un booleano:

>>> n = 5
>>> float(n)
5.0
>>> n=5
>>> bool(n)
True
>>> n=-5
>>> bool(n)
True
>>> n=0
>>> bool(n)
False
>>>

Si intentamos castear a un valor que no es válido, por ejemplo de un string a un número, dará una excepción:

>>> int('50.X')
ValueError: invalid literal for int() with base 10: '50.X'

Listas

Las listas no son más que una colección de datos, cuando entras a aplicaciones como X, WhatsApp o un correo electrónico como Outlook o Gmail, y ves un listado de correos o mensajes, se emplean estructuras como listas, por lo tanto, las listas son una estructura de lo más empleado en los cuales podemos definir las primitivas como vistos antes u objetos como veremos en el apartado de las clases:

>>> list = [1,2,3]
>>> list
[1, 2, 3]

Para operar con estas listas, también tenemos operaciones para conocer su longitud:

>>> len(list)
3

O para sumar todos los elementos de la lista:

>>> list = [1,2,3]
>>> sum(list)
6

Agregar nuevos elementos al final de la lista:

>>> list.append(5)
>>> list
[1, 2, 3, 5]

O remover un elemento por el valor (no el índice):

>>> list.remove(1)
>>> list
[2, 3, 5]

Obtener un valor de la lista, colocamos el índice comenzando desde cero:

>>> list = [1,2,3]
>>> list[1]
2

Si colocamos un índice que no exista, dará una excepción como la siguiente:

>>> list = [1,2,3]
>>> list[3]
IndexError: list index out of range

Existen muchas otras operaciones que puedes emplear sobre las listas y que puedes consultar en la documentación oficial.

https://www.w3schools.com/python/python_lists.asp

Desde el framework, cuando tenemos un listado de usuarios o publicaciones es precisamente eso, una lista de objetos que luego podemos iterar en un ciclo o alguna operación similar.

Condicionales

El uso de condicionales para ejecutar bloques de código en base a una condición de verdadero y falso y con esto, hacer bifurcaciones en nuestro código son de las estructuras más empleadas en cualquier programa en y en los frameworks no es la excepción; en un condicional, podemos evaluar en base a operadores como:

• > Devuelve True si el operador de la izquierda es mayor que el operador de la derecha
• < Devuelve True si el operador de la derecha es mayor que el operador de la izquierda
• >= Devuelve True si el operador de la izquierda es mayor o igual que el operador de la derecha
• <= Devuelve True si el operador de la derecha es mayor o igual que el operador de la izquierda
• == Devuelve True si ambos operandos son iguales
• != Devuelve True si ambos operandos no son iguales

Condiciones de verdadero y falso y si la condición a evaluar es verdadero, entonces se ejecuta el bloque de código que gobierna el condicional:

age=15

if age >= 18:
    print("You're of age")

Podemos hacer condiciones complejas anidando varias condiciones con el and:

age=15
woman=False
if age >= 18 and woman:
    print("You are a man of legal age")

En donde se deben de cumplir todas las condiciones para ejecutar el bloque del condicional, o el or, para ejecutar el bloque del condicional con tan solo se cumpla algunas de las condiciones:

age=19
woman=False
if age >= 18 or woman:
    print("Message 1")

age=15
if age >= 18 or woman:
    print("Message 2")

age=15
woman=True
if age >= 18 or woman:
    print("Message 3")

También tenemos el bloque del else que se ejecutaría cuando no se cumple la condición del condicional:

age=19
if age >= 18:
    print("You're of age")
else:
    print("You are a minor")

Y podemos evaluar múltiples condiciones o anidar múltiples condicionales:

age=19
woman=False
age=19
if age >= 18:
    print("You're of age")
elif woman:
    print("You're a woman")
else:
    print("You are a men")

Ciclos

Al igual que en cualquier lenguaje de programación, tenemos el acceso a los ciclos para poder iterar listados; tenemos el while, con el cual se ejecuta un bloque hasta que se cumple la condición:

i = 1
while i < 10:
  print(i)
  i += 1

Y el ciclo for, en el cual tenemos una variable que mantiene el valor de la estructura a iterar, en cada iteración:

numbers = [1,2,3,4,5]
for i in numbers:
  print(i)

Una configuración común, es emplear el ciclo for junto con la función range(), la cual, permite crear un rango como el siguiente:

for i in range(0,10):
   print(i)
0 1 2 3 4 5 6 7 8 9

Y de esta manera, la variable i corresponde a un elemento del rango a iterar.

Clases

Uno de los aspectos más importantes de los lenguajes de programación, son las clases, el uso de las clases en ciertos lenguajes de programación como Python, son los que definen a un lenguaje de programación como “lenguaje de programación basado en objetos” en donde los objetos no son más que instancias de las clases, anteriormente cuando presentamos los tipo de datos, al imprimir el tipo, vimos una salida como la siguiente:

>>> n=5
>>> type(n)
<class 'int'>
>>> name='andres'
>>> type(name)
<class 'str'>
>>> type(True)
<class 'bool'>

Puedes ver que la palabra reservada class, está presente, y esto se debe a que en Python todo es un objeto que no es más que una instancia de una clase:

class MyClass:
  pass

Las clases no son más que un plano en el cual podemos crear todo tipo de objetos que representen al mundo real, como sus primitivas, enteros, flotantes, cadenas de textos o por ejemplo, podemos crear una clase que represente a un auto:

class Car:
  pass

O un animal:

class Animal:
  pass

Como puedes ver, en ambos casos se emplea la palabra reservada class para marcar a ese código como una clase.

Una clase vacía no nos sirve para mucho, para que sea funcional, podemos definir variables y funciones dentro de las clases, cuando definidos variables y funciones dentro de una clase, estos reciben el nombre de atributos y métodos respectivamente:

class Car:
  brand='MyBrand'
  model='MyModel'
  price=50.2
  
  def getCompleteDescription(self):
    return f"{self.brand} - {self.model} - {self.price}"

La palabra reservada self, hace referencia a la instancia de la clase con la cual se puede acceder a sus atributos y métodos.

Para el código anterior, podemos crear una instancia, que no es más que una variable la cual podemos manipular a nuestro antojo, por ejemplo, crear una instancia por algún tipo de carro que vamos a manipular en una aplicación:

>>> car = Car()

Y con esto, acceder a sus métodos y propiedades:

>>> print(car.brand)
>>> print(car.getCompleteDescription())
MyBrand
MyBrand - MyModel - 50.2

Los métodos y propiedades son la forma que tenemos para personalizar la clase, por ejemplo, para cambiar de marca:

car = Car()
car.brand='OtherBrand'
print(car.brand)
print(car.getCompleteDescription())

O emplear el método constructor de la clase, que sería, el método __init__() en el cual, se suministran los argumentos:

class Car:
  # brand='MyBrand'
  # model='MyModel'
  # price=50.2
  
  def __init__(self,brand,model,price):
    self.brand=brand
    self.model=model
    self.price=price
  
  def getCompleteDescription(self):
    return f"{self.brand} - {self.model} - {self.price}"
    
car = Car('OtherBrand','OtherModel',100)
# car.brand='OtherBrand'
print(car.brand)
print(car.getCompleteDescription())

Al emplear el constructor de la clase, no es necesario definir los argumentos desde la clase, se crean automáticamente desde el constructor.

Herencia

Podemos crear clases que se relacionen, por ejemplo, podemos tener una clase animal y de la misma, poder emplearla como base para crear clases específicas, por ejemplo, una clase perro y gato:

class Animal:
      def __init__(self, kind):
        self.kind = kind
        
      def legs(self):
          pass
            
      def fly(self):
          pass
            
      def type(self):
          print(f"The type is {self.kind}")
            
class Dog(Animal):
    def legs(self):
            return 4
            
    def fly(self):
        return False

    def other(self):
        print("To Do")
        
class Bird(Animal):
    def legs(self):
            return 2
            
    def fly(self):
        return True
    

dog = Dog('canine')
dog.type()
bird = Bird('bird')

En el ejemplo anterior, tenemos una clase Animal que cuenta con características comunes para un animal, luego, creamos dos clases Dog y Bird para representar a perros y pájaros, que son animales y por lo tanto, heredan de la clase Animal y con esto sus atributos y métodos, que son sobrescritos e inclusive podemos implementar métodos personalizados y atributos como el de other() que no forman parte de la clase Animal.

El uso de las clases y la herencia es fundamental en los frameworks ya que existen clases predefinidas por el framework para definir modelos, controladores/vistas, entre otros tipos y que luego pueden ser personalizadas conservando el comportamiento por defecto.

Módulos en Python

Los módulos en Python son una parte crucial en el lenguaje de programación y lo que lo diferencian de otros lenguajes de programación y lo que permite que Python sea un lenguaje de programación modular en los que se aprovechan los framework implementados en dicho lenguaje.

Los módulos permiten reutilizar código fácilmente entre otros archivos que corresponden al proyecto.

Un módulo en Python no es más que un archivo con extensión .py que puede contener un conjunto de funciones, variables o clases que luego podemos emplear desde otros archivos que importen dicho módulo.

Los módulos pueden utilizar otros módulos, lo que facilita la reutilización de código y modularización de la aplicación.

Crear un módulo

Crearemos un archivo para manejar las operaciones matemáticas:

mymath.py

def sum(a:int, b:int):
  return a+b
  
def subtract(a:int, b:int):  
  return a-b
  
def multiply(a:int, b:int):  
  return a*b
  
def divide(a:int, b:int):  
  return a/b

Importar un módulo

Usando import, podemos importar todo el contenido del módulo definido anteriormente:

app.py

import mymath 

print(mymath.sum(1,2))

O también podemos importar componentes específicos:

from mymath import sum, divide, multiply, subtract

print(sum(1,2))

Incluso podemos importar todo el módulo usando *:

from mymath import *

print(sum(1,2))

Y de esta forma, podemos reutilizar el módulo de operaciones matemáticas desde cualquier parte de la aplicación.

Los módulos son una parte fundamental en los frameworks, que al estar organizados en varias carpetas según las capas definidas para representar cada uno de los componentes del MVC o MTV, el manejo de las rutas, entre otros, la forma de unir todas estas capas es mediante módulos que vamos importante en partes específicas del framework

También los módulos son empleados en los frameworks para importar las distintas características del framework y paquetes asociados y poder emplear las mismas.

24-03-2024 - Andrés Cruz

In english

• Categoría
• /
• Python
• /
• Todo lo que necesitas saber para iniciar en Python