Una función te permite definir un bloque de código reutilizable que se puede ejecutar muchas veces dentro de tu programa.

Las funciones te permiten crear soluciones más modulares y DRY para problemas complejos.

Si bien Python ya proporciona muchas funciones integradas como print() y len(), también puedes definir tus propias funciones para usar en tus proyectos.

Una de las grandes ventajas de usar funciones en tu código es que reduce el número total de líneas de código en tu proyecto.

Sintaxis

En Python, una definición de función tiene las siguientes características:

1. La palabra clave def
2. Un nombre de función
3. Paréntesis ’()’, y dentro de los paréntesis los parámetros de entrada, aunque los parámetros de entrada sean opcionales.
4. Dos puntos ’:’
5. Algún bloque de código para ejecutar
6. Una sentencia de retorno (opcional)

# función sin parámetros o retorno de valores
def diHola():
  print("Hello!")

diHola()  # llamada a la función, 'Hello!' se muestra en la consola

# función con un parámetro
def holaConNombre(name):
  print("Hello " + name + "!")

holaConNombre("Ada")  # llamada a la función, 'Hello Ada!' se muestra en la consola

# función con múltiples parámetros con una sentencia de retorno
def multiplica(val1, val2):
  return val1 * val2

multiplica(3, 5)  # muestra 15 en la consola

Las funciones son bloques de código que se pueden reutilizar simplemente llamando a la función. Esto permite la reutilización de código simple y elegante sin volver a escribir explícitamente secciones de código. Esto hace que el código sea más legible, facilita la depuración y limita los errores de escritura.

Las funciones en Python se crean usando la palabra clave def, seguida de un nombre de función y parámetros de función entre paréntesis.

Una función siempre devuelve un valor. La función utiliza la palabra clave return  para devolver un valor; si no desea devolver ningún valor, se devolverá el valor predeterminado None.

El nombre de la función se usa para llamar a la función, pasando los parámetros necesarios entre paréntesis.

# esta es una función básica de suma
def suma(a, b):
  return a + b

result = suma(1, 2)
# result = 3

Puedes definir valores predeterminados para los parámetros, de esa manera Python interpretará que el valor de ese parámetro es el predeterminado si no se proporciona ninguno.

def suma(a, b=3):
  return a + b

result = suma(1)
# result = 4

Puedes pasar los parámetros en el orden que desees, utilizando el nombre del parámetro.

result = suma(b=2, a=2)
# result = 4

Sin embargo, no es posible pasar un argumento de palabra clave antes que uno que no sea de palabra clave

result = suma(3, b=2)
#result = 5
result2 = suma(b=2, 3)
#Lanzará SyntaxError

Las funciones también son objetos, por lo que puedes asignarlas a una variable y usar esa variable como una función.

s = suma
result = s(1, 2)
# result = 3

Notas

Si la definición de una función incluye parámetros, debe proporcionar el mismo número de parámetros cuando llame a la función.

print(multiplica(3))  # TypeError: multiplica() utiliza exactamente 2 argumentos (0 proporcionados)

print(multiplica('a', 5))  # 'aaaaa' mostrado en la consola

print(multiplica('a', 'b'))  # TypeError: Python no puede multiplicar dos strings

El bloque de código que ejecutará la función incluye todas las declaraciones con indentación dentro de la función.

def miFunción():
    print('this will print')
    print('so will this')

x = 7
# la asignación de x no es parte de la función ya que no está indentada

Las variables definidas dentro de una función solo existen dentro del ámbito de esa función.

def duplica(num):
    x = num * 2
    return x

print(x)  # error - x no está definida
print(duplica(4))  # muestra 8

Python interpreta el bloque de funciones solo cuando se llama a la función y no cuando se define la función. Por lo tanto, incluso si el bloque de definición de función contiene algún tipo de error, el intérprete de Python lo señalará solo cuando se llame a la función.

Ahora veamos algunas funciones específicas con ejemplos.

Función max()

max() es una función incorporada en Python 3. Devuelve el elemento más grande en un iterable o el más grande de dos o más argumentos.

Argumentos

Esta función toma dos o más números o cualquier tipo de iterable como argumento. Mientras damos un iterable como argumento, debemos asegurarnos de que todos los elementos del iterable sean del mismo tipo. Esto significa que no podemos pasar una lista que tenga almacenados valores enteros y de cadena. Sintaxis: max (iterable, * iterables [, clave, predeterminado]) max (arg1, arg2, * args [, clave])

Argumentos válidos:

max(2, 3)
max([1, 2, 3])
max('a', 'b', 'c')

Argumentos inválidos:

max(2, 'a')
max([1, 2, 3, 'a'])
max([])

Valor devuelto

Se devuelve el elemento más grande del iterable. Si se proporcionan dos o más argumentos posicionales, se devuelve el mayor de los argumentos posicionales. Si el iterable está vacío y no se proporciona el valor predeterminado, se genera un ValueError.

Código de ejemplo:

print(max(2, 3)) # Devuelve 3 ya que 3 es el mayor de los dos valores
print(max(2, 3, 23)) # Devuelve 23 ya que 23 es el mayor de todos los valores

list1 = [1, 2, 4, 5, 54]
print(max(list1)) # Devuelve 54 ya que 54 es el valor más grande de la lista

list2 = ['a', 'b', 'c' ]
print(max(list2)) # Devuelve 'c' ya que 'c' es el valor más grande en la lista porque 'c' tiene un valor ascii mayor que 'a' ,'b'.

list3 = [1, 2, 'abc', 'xyz']
print(max(list3)) # Se genera TypeError ya que los valores en la lista son de tipos diferentes

#Soluciona el TypeError mencionado anterioremente antes de continuar con el siguiente paso

list4 = []
print(max(list4)) # Se genera ValueError ya que el argumento está vacío

Documentación oficial

Función min()

min() es una función incorporada en Python 3. Devuelve el elemento más pequeño en un iterable o el más pequeño de dos o más argumentos.

Argumentos

Esta función toma dos o más números o cualquier tipo de iterable como argumento. Mientras damos un iterable como argumento, debemos asegurarnos de que todos los elementos del iterable sean del mismo tipo. Esto significa que no podemos pasar una lista que tenga almacenados valores enteros y de cadena.

Argumentos válidos:

min(2, 3)
min([1, 2, 3])
min('a', 'b', 'c')

Argumentos inválidos:

min(2, 'a')
min([1, 2, 3, 'a'])
min([])

Valor devuelto

Se devuelve el elemento más pequeño del iterable. Si se proporcionan dos o más argumentos posicionales, se devuelve el más pequeño de los argumentos posicionales. Si el iterable está vacío y no se proporciona el valor predeterminado, se genera un ValueError.

Código de ejemplo:

print(min(2, 3)) # Devuelve 2 ya que 2 es el más pequeño de los dos valores
print(min(2, 3, -1)) # Devuelve -1 ya que -1 es el más pequeño de los dos valores

list1 = [1, 2, 4, 5, -54]
print(min(list1)) # Devuelve -54 ya que -54 es el más pequeño de los valores en la lista.

list2 = ['a', 'b', 'c' ]
print(min(list2)) # Devuelve 'a' ya que 'a' es el valor más pequeño de la lissta en orden alfabético

list3 = [1, 2, 'abc', 'xyz']
print(min(list3)) # Se genera TypeError ya que los valores en la lista son de tipos diferentes

#Soluciona el TypeError mencionado anterioremente antes de continuar con el siguiente paso

list4 = []
print(min(list4)) # Se genera ValueError ya que el argumento está vacío

Documentación oficial

Función divmod()

divmod() es una función incorporada en Python 3, que devuelve el cociente y el resto al dividir el número a por el número b. Toma dos números como argumentos a & b. El argumento no puede ser un número complejo.

Argumentos

Se necesitan dos argumentos a & b: un número entero o un número decimal. No puede ser un número complejo.

Valor devuelto

El valor de retorno será el par de números positivos que consiste en el cociente y el resto obtenido al dividir a por b. En el caso de tipos de operandos mixtos, se aplicarán las reglas para los operadores aritméticos binarios.
Para los argumentos de números enteros, el valor de retorno será el mismo que (a // b, a % b).
Para los argumentos de números decimales, el valor devuelto será el mismo que (q, a % b), donde q es normalmente math.floor (a / b) pero puede ser 1 menos que eso.

Código de ejemplo:

print(divmod(5,2)) # muestra (2,1)
print(divmod(13.5,2.5)) # muestra (5.0, 1.0)
q,r = divmod(13.5,2.5)  # Asigna q=cociente & r=resto
print(q) # muestra 5.0 porque math.floor(13.5/2.5) = 5.0
print(r) # muestra 1.0 porque (13.5 % 2.5) = 1.0

Documentación oficial

Función Hex(x)

hex(x) es una función incorporada en Python 3 para convertir un número entero en una cadena hexadecimal en minúscula con el prefijo "0x"

Argumentos

Esta función toma un argumento, x, que debería ser de tipo entero.

Valor devuelto

Esta función devuelve una cadena hexadecimal en minúscula con el prefijo "0x".

Código de ejemplo:

print(hex(16))    # muestra  0x10
print(hex(-298))  # muestra -0x12a
print(hex(543))   # muestra  0x21f

Documentación oficial

Función len()

len() es una función incorporada en Python 3. Este método devuelve la longitud (el número de elementos) de un objeto. Toma un argumento x.

Argumentos

Esta función toma un argumento, x. Este argumento puede ser una secuencia (como un string, bytes, tupla, lista o rango) o una colección (como un diccionario, conjunto o conjunto congelado).

Valor devuelto

Esta función devuelve el número de elementos del argumento que se pasa a la función len().

Código de ejemplo:

list1 = [123, 'xyz', 'zara'] # lista
print(len(list1)) # muestra 3 ya que hay 3 elementos en list1

str1 = 'basketball' # string
print(len(str1)) # muestra 10 ya que str1 tiene 10 carácteres

tuple1 = (2, 3, 4, 5) # tuple 
print(len(tuple1)) # muestra 4 ya que hay 4 elementos en tuple1

dict1 = {'name': 'John', 'age': 4, 'score': 45} # dictionary
print(len(dict1)) # muestra 3 ya que hay 3 pares clave/valor en dict1

Documentación oficial

Función Ord

ord() es una función incorporada en Python 3, para convertir la cadena que representa un carácter Unicode en un entero que representa el código Unicode del carácter.

Ejemplos:

>>> ord('d')
100
>>> ord('1')
49

Función chr

chr() es una función incorporada en Python 3, para convertir el número entero que representa el código Unicode en una cadena que representa un carácter correspondiente.

Ejemplos:

>>> chr(49)
'1'

Hay que tener en cuenta que, si el valor entero pasado a chr() está fuera del rango, entonces se generará un ValueError.

>>> chr(-10)
'Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    chr(-1)
ValueError: chr() arg not in range(0x110000)'

Funciones input()

Muchas veces, en un programa necesitamos alguna información del usuario. Recibir información del usuario hace que el programa se sienta interactivo. En Python 3, para recibir datos del usuario tenemos la función input(). Si se llama a la función input, el flujo del programa se detendrá hasta que el usuario haya introducido la información y haya finalizado la introducción de información con la tecla de retorno. Veamos algunos ejemplos:

1. Cuando solo queremos recibir información:

inp = input()

2. Para mostrar en la línea de comandos un mensaje:

promptwithmessage = input(’‘)

3. Cuando queremos tomar un número entero como información:

number = int(input('Please enter a number: '))

Sin embargo, las entradas se almacenan de forma predeterminada como un string. El uso de la función str() deja en claro al lector de código que la entrada será una "cadena". Es una buena práctica mencionar de antemano qué tipo de información se tomará.

Documentación oficial

Como llamar una función en Python

Una sentencia de definición de función no ejecuta la función. La ejecución (llamada) de una función se realiza utilizando el nombre de la función seguido de paréntesis que encierran los argumentos requeridos (si los hay).

>>> def di_hola():
...     print('Hello')
...
>>> di_hola()
Hello

La ejecución de una función introduce una nueva tabla de símbolos utilizada para las variables locales de la función. Más precisamente, todas las asignaciones de variables en una función almacenan el valor en la tabla de símbolos local; mientras que las referencias de variables primero buscan en la tabla de símbolos local, luego en las tablas de símbolos locales de las funciones adjuntas, luego en la tabla de símbolos global y finalmente en la tabla de nombres incorporados. Por lo tanto, a las variables globales no se les puede asignar directamente un valor dentro de una función (a menos que se mencionen en una declaración global), aunque se puede hacer referencia a ellas.

>>> a = 1
>>> b = 10
>>> def fn():
...     print(a)    # la variable local a no esta asignada, no esta incluida en la función, es una variable global
...     b = 20      # la variable local b está asignada en la tabla de símbolos locales para la función.
...     print(b)    # la variable local b esta referenciada.
...
>>> fn()
1
20
>>> b               # la variable global b no se ha modificado por la llamada a la función.
10

Los parámetros actuales (argumentos) para una llamada de función se introducen en la tabla de símbolos local de la función llamada cuando se llama; por lo tanto, los argumentos se pasan usando la llamada por valor (donde el valor es siempre una referencia de objeto, no el valor del objeto). Cuando una función llama a otra función, se crea una nueva tabla de símbolos local para esa llamada.

>>> def saluda(s):
...     s = "Hello " + s    # s en la tabla local de símbolos es reasignada
...     print(s)
...
>>> persona = "Bob"
>>> saluda(persona)
Hello Bob
>>> person                  # la variable persona utilizada en la llamada continua vinculada al objeto original, 'Bob'.
'Bob'

Los argumentos utilizados para llamar a una función no pueden ser reasignados por la función, pero los argumentos que hacen referencia a objetos mutables pueden cambiar sus valores:

>>> def fn(arg):
...     arg.append(1)
...
>>> a = [1, 2, 3]
>>> fn(a)
>>> a
[1, 2, 3, 1]

Traducido del artículo Python Function Guide with Examples

Imagina que tienes dos aplicaciones, App1 y App2. Ambos usan el paquete Pak, pero requieren versiones diferentes. Si instala Pak versión 2.3 para App1, no podrá ejecutar App2 porque requiere la versión 3.1.

Aquí es donde los entornos virtuales son útiles.

Beneficios:

• Puedes tener varios entornos, con varios conjuntos de paquetes, sin conflictos entre ellos. De esta manera, los requisitos de diferentes proyectos se pueden satisfacer al mismo tiempo.
• Puedes lanzar fácilmente tu proyecto con sus propios módulos dependientes.

Aquí hay dos formas en las que puede crear entornos virtuales Python.

Virtualenv

virtualenv es una herramienta que se utiliza para crear entornos Python aislados. Crea una carpeta que contiene todos los ejecutables necesarios para usar los paquetes que necesitaría un proyecto de Python.

Puedes instalarlo con pip:

pip install virtualenv

Verifica la instalación con el siguiente comando:

virtualenv --version

Crear un entorno

Para crear un entorno virtual utiliza:

virtualenv --no-site-packages my-env

Esto crea una carpeta en el directorio actual con el nombre del entorno (my-env/). Esta carpeta contiene los directorios para instalar módulos y ejecutables de Python.

También puedes especificar la versión de Python con la que quieres trabajar. Simplemente usa el argumento --python=/ruta/a/la/version/de/python. Por ejemplo, python2.7:

virtualenv --python=/usr/bin/python2.7 my-env

Lista de entornos

Puedes enumerar los entornos disponibles con:

lsvirtualenv

Activar un entorno

Antes de utilizar el entorno, debes activarlo:

source my-env/bin/activate

Esto asegura que solo se usen los paquetes bajo my-env/.

Notarás que el nombre del entorno se muestra a la izquierda de la línea de comandos. De esta forma puedes ver cuál es el entorno activo.

Instalar paquetes

Puede instalar paquetes uno por uno o configurando un archivo requirements.txt para tu proyecto.

pip install algun-paquete
pip install -r requirements.txt

Si quieres crear un archivo requirements.txt  a partir de los paquetes ya instalados, ejecuta el siguiente comando:

pip freeze > requirements.txt

El archivo contendrá la lista de todos los paquetes instalados en el entorno actual y sus respectivas versiones. Esto te ayudará a lanzar tu proyecto con sus propios módulos dependientes.

Desactivar un entorno

Si has terminado de trabajar con el entorno virtual, puedes desactivarlo con:

deactivate

Esto te devuelve al intérprete de Python predeterminado del sistema con todas sus bibliotecas instaladas.

Eliminar un entorno

Simplemente elimina la carpeta del entorno.

Conda

Conda es una gestión de paquetes, dependencias y entornos para muchos lenguajes, incluido Python.

Para instalar Conda, sigue estas instrucciones.

Crear un entorno

Para crear un entorno virtual, use:

conda create --name my-env

Conda creará la carpeta correspondiente dentro del directorio de instalación de Conda.

También puedes especificar con qué versión de Python quieres trabajar:

conda create --name my-env python=3.6

Lista de entornos

Puedes enumerar los entornos disponibles con:

conda info --envs

Activar un entorno

Antes de utilizar el entorno, debes activarlo:

source activate my-env

Instalar paquetes

Igual que con virtualenv.

Desactivar un entorno

Si has terminado de trabajar con el entorno virtual, puedes desactivarlo con:

source deactivate

Eliminar un entorno

Si quieres eliminar un entorno de Conda, utiliza:

conda remove --name my-env

Traducido del artículo - Python Virtual Environments Explained with Examples

Si a una sentencia de devolución le sigue una lista de expresiones, la lista de expresiones se evalúa y se devuelve el valor:

>>> def mayor_que_1(n):
...     return n > 1
...
>>> print(mayor_que_1(1))
False
>>> print(mayor_que_1(2))
True

Si no hay lista de expresiones especificada, se devuelve  None :

>>> def no_lista_expresion():
...     return    # No se devuelve una lista de expresiones.
...
>>> print(no_lista_expresion())
None

Si se alcanza una sentencia de devolución durante la ejecución de una función, la llamada a la función actual se deja en ese punto:

>>> def devuelve_media():
...     a = 1
...     return a
...     a = 2     # Esta sentencia nunca es alcanzada.
...
>>> print(devuelve_media())
1

Si no hay sentencia de devolución, la función devuelve None cuando alcanza el final

>>> def no_devolver():
...     pass     # No hay sentencia retornar.
...
>>> print(no_devolver())
None

Una única función puede tener muchas sentencias devolver. La ejecución de la función finaliza cuando una de las sentencias de devolución se alcanza:

 >>> def multiples_devoluciones(n):
 ...    if(n):
 ...        return "First Return Statement"
 ...    else:
 ...        return "Second Return Statement"
 ...
 >>> print(multiples_devoluciones(True))
 First Return Statement
 >>> print(multiples_devoluciones(False))
 Second Return Statement
 

Una única función puede devolver varios tipos:

 >>> def varios_tipos_de_devolucion(n):
 ...     if(n==1):
 ...         return "Hello World."   # Devuelve un string
 ...     elif(n==2):
 ...         return 42               # Devuelve un valor
 ...     else:
 ...         return True             # Devuelve un boolean
 ... 
 >>> print(varios_tipos_de_devolucion(1))
 Hello World.
 >>> print(varios_tipos_de_devolucion(2))
 42
 >>> print(varios_tipos_de_devolucion(3))
 True

Incluso es posible que una única función devuelva múltiples valores con un simple Retornar:

>>> def devolver_dos_valores():
 ...     a = 40
 ...     b = 2
 ...     return a,b
 ...
 >>> print("First value = %d,  Second value = %d" %(devolver_dos_valores()))
 First value = 40,  Second value = 2

Consulta la documentación de Python para más información

Traducido del artículo - Python Return Statements Explained: What They Are and Why You Use Them

Uso básico

Cómo crear una lista

Se crea una lista vacía usando un par de corchetes:

>>> lista_vacia = []
>>> type(lista_vacia)
<class 'lista'>
>>> len(lista_vacia)
0

Se puede crear una lista con elementos encerrando una lista de elementos separados por comas entre corchetes. Las listas permiten que los elementos sean de diferentes tipos (heterogéneos) pero más comúnmente son de un solo tipo (homogéneos):

>>> lista_homogenea = [1, 1, 2, 3, 5, 8]
>>> type(lista_homogenea)
<class 'lista'>
>>> print(lista_homogenea)
[1, 1, 2, 3, 5, 8]
>>> len(lista_homogenea)
6
>>> lista_heterogenea = [1, "¡Hola Campistas!"]
>>> print(lista_heterogenea)
[1, "¡Hola Campistas!"]
>>> len(lista_heterogenea)
2

El constructor list también se puede utilizar para crear una lista:

>>> lista_vaciat = list()                            # Crea una lista vacia
>>> print(lista_vacia)
[]
>>> lista_de_iterable = list("¡Hola Campistas!")    # Crea una lista a partir de un iterable.
>>> print(lista_de_iterable)
['!', 'H', 'o', 'l', 'a', ' ', 'c', 'a', 'm', 'p', 'i', 's', 't', 'a', 's', '!']

También puedes utilizar Compresión de listas (List Comprehension) para crear listas, que trataremos más adelante en este artículo.

Acceder a elementos en la lista

>>> mi_lista = [1, 2, 9, 16, 25]
>>> print(mi_lista)
[1, 2, 9, 16, 25]

Indexación al 0

>>> mi_lista[0]
1
>>> mi_lista[1]
2
>>> mi_lista[2]
9

Indexación desde el fin de la lista

>>> mi_lista[-1]
25
>>> mi_lista[-2]
16

Desempaquetado de listas para python-3

>>> print(*mi_lista)
1 2 9 16 25

Las Listas son mutables

Las listas son contenedores mutables. Los contenedores mutables son contenedores que permiten cambios en los objetos que contienen el contenedor.

Los elementos de una lista se pueden extraer y reorganizar utilizando otra lista como índice.

>>> mi_lista = [1, 2, 9, 16, 25, 34, 53, 21]
>>> mi_indice = [5, 2, 0]
>>> mi_nueva_lista = [mi_lista[i] for i in mi_indice]
>>> print(mi_nueva_lista)
[34, 9, 1]

Métodos de lista

len()

El método len() devuelve la longitud de un objeto, ya sea una lista, una cadena, una tupla o un diccionario.

len() toma un argumento, que puede ser una secuencia (como una cadena, bytes, tupla, lista o rango) o colección (como un diccionario, conjunto o conjunto "set" congelado "set frozen").

lista1 = [123, 'xyz', 'zara'] # lista
print(len(lista1)) # Muestra 3 ya que hay 3 elementos en lista1

str1 = 'baloncesto' # string
print(len(str1)) # Muestra 10 ya que str1 está compuesto por 10 carácteres

tupla1 = (2, 3, 4, 5) # tupla 
print(len(tupla1)) # Muestra 4 ya que hay 4 elementos en tupla1

dict1 = {'nombre': 'John', 'edad': 4, 'puntaje': 45} # diccionario
print(len(dict1)) # Muestra 3 ya que hay 3 pares de clave/valor en dict1

index()

index() devuelve la primera aparición / índice del elemento en la lista dada como argumento de la función.

numeros = [1, 2, 2, 3, 9, 5, 6, 10]
palabras = ["Yo", "amo", "Python", "Yo", "amo"]

print(numeros.index(9)) # 4
print(numeros.index(2)) # 1
print(palabras.index("Yo")) # 0
print(palabras.index("soy")) # Devuelve un ValueError ya que  'soy' no está en la lista `palabras`

Aquí la primera salida es muy obvia, pero la segunda y la tercera pueden parecer confusas al principio. Pero recuerda que index() devuelve la primera aparición del elemento y, por tanto, en este caso, 1 y 0 son los índices donde 2 y "Yo" aparecen primero en las listas, respectivamente.

Además, si un elemento no se encuentra en la lista, se devuelve un ValueError como en el caso de indexar "soy" en la lista palabras.

Argumentos opcionales

También puedes usar argumentos opcionales para limitar tu búsqueda a una sub secuencia particular de la lista:

palabras = ["Yo", "soy", "un", "Yo", "soy", "Pythonista"]

print(palabras.index("soy", 2, 5)) # 4

Aunque el elemento se busca entre los índices 2 (inclusive) y 5 (no incluido), el índice devuelto se calcula con relación al comienzo de la lista completa en lugar del argumento de inicio.

pop()

El método pop()  borra y retorna el último elemento de una lista.

Existe un parámetro opcional que es el índice del elemento que se eliminará de la lista. Si no se especifica ningún índice, pop() elimina y devuelve el último elemento de la lista.

Si el índice pasado al método pop() no está en el rango, se lanza la excepción IndexError: índice pop fuera del rango.

ciudades = ['New York', 'Dallas', 'San Antonio', 'Houston', 'San Francisco'];

print "Ciudad borrada y retornada es: ", ciudades.pop() # Ciudad borrada y retornada  es: San Francisco
print "Ciudad al índice 2 es  : ", ciudades.pop(2) # Ciudad en en el índice 2 es: San Antonio

Funcionalidad de pila básica

El método pop() se usa a menudo junto con append() para implementar la funcionalidad básica de la pila en una aplicación Python:

pila = []

for i in range(5):
    pila.append(i)

while len(pila):
    print(pila.pop())

Compresión de listas

La comprensión de listas es una forma de recorrer una lista para producir una nueva lista basada en algunas condiciones. Puede resultar confuso al principio, pero una vez que te acostumbras a la sintaxis, es muy potente y rápido.

El primer paso para aprender a utilizar la comprensión de listas es observar la forma tradicional de recorrer una lista. El siguiente es un ejemplo simple que devuelve una nueva lista de números pares.

# Lista para ejemplo de demostración
alguna_lista = [1, 2, 5, 7, 8, 10]

# Lista vacía que se rellenará con un bucle
lista_par = []

for numero in alguna_lista:
  if numero % 2 == 0:
    lista_par.append(numero)

# lista_par ahora es igual a [2, 8, 10]

Primero se crea una lista con algunos números. Luego, creas una lista vacía que contendrá los resultados del bucle. En el bucle, verificas si cada número es divisible por 2 y, si es así, lo agregas a lista_par. Se han utilizado 5 líneas de código sin incluir comentarios y espacios en blanco, lo que no es mucho en este ejemplo.

Ahora el ejemplo de comprensión de lista.

# Lista para ejemplo de demostración
alguna_lista = [1, 2, 5, 7, 8, 10]

# Compresión de lista
lista_par = [numero for numero in alguna_lista if numero % 2 == 0]

# lista_par ahora es igual a [2, 8, 10]

Otro ejemplo, con los mismos dos pasos: El código siguiente creará una lista de números que corresponden a los números en mi_lista_de_inicio multiplicados por 7.

mi_lista_de_partida = [1, 2, 3, 4, 5, 6, 7, 8]
mi_nueva_lista = []

for elemento in mi_lista_de_partida:
    mi_nueva_lista.append(elemento * 7)

Cuando se ejecuta el código el valor final de mi_nueva_lista es: [7, 14, 21, 28, 35, 42, 49, 56]

Un desarrollador que use la comprensión de listas podría lograr el mismo resultado usando la siguiente comprensión de listas, que da como resultado la misma mi_nueva_lista.

mi_lista_de_partida = [1, 2, 3, 4, 5, 6, 7, 8]

mi_nueva_lista = [elemento * 7 para elemento en mi_lista_de_partida]

Una fórmula sencilla para escribir en forma de lista de comprensión es:

mi_lista = [{operacion con entrada n} for n in {python iterable}]

Reemplace {operacion con entrada n} con la forma en que deseas cambiar el elemento devuelto por el iterable. El ejemplo anterior usa n * 7 pero la operación puede ser tan simple o tan compleja como sea necesario.

Reemplaza {python iterable} con cualquier iterable. Los tipos de secuencia serán los más comunes. En el ejemplo anterior se usó una lista, pero las tuplas y los rangos también son comunes.

La comprensión de listas agrega un elemento de una lista existente a una nueva lista si se cumple alguna condición. Es más ordenado, pero también mucho más rápido en la mayoría de los casos. En algunos casos, la comprensión de lista puede dificultar la legibilidad, por lo que el desarrollador debe sopesar sus opciones al elegir utilizar la comprensión de la lista.

Ejemplos de comprensión de listas con condicionales

El flujo de control en las listas por comprensión se puede controlar mediante condicionales. Por ejemplo:

solo_lista_par = [i for i in range(13) if i%2==0]

Este es equivalente al siguiente bucle:

solo_lista_par = list()
for i in range(13):
  if i%2 == 0:
    solo_lista_par.append(i)

La comprensión de listas también puede contener condiciones if anidadas. Considera el siguiente bucle:

divisible = list()
for i in range(50):
  if i%2 == 0:
    if i%3 == 0:
      divisible.append(i)

Usando la comprensión de listas, esto se puede escribir como:

divisible = [i for i in range(50) if i%2==0 if i%3==0]

La sentencia If-Else también se puede utilizar junto con la comprensión de listas.

lista_1 = [i if i%2==0 else i*-1 for i in range(10)]

Mas Información:

• Los mejores ejemplos de código Python

Traducido del artículo Python Lists Explained: Len, Pop, Index, and List Comprehension

Los módulos de terceros añaden mucha más funcionalidad a Python. Así que es hora de aprender a instalar estos módulos para que podamos usarlos en nuestros programas.

La forma más sencilla es utilizar pip.

pip install <module_name>

Si has utilizado npm, puedes pensar en él como el npm de Python.

Nota: la diferencia es que con npm, es que npm install instala de forma predeterminada los paquetes localmente en un proyecto, mientras que pip install de forma predeterminada los instala globalmente.

Para instalar módulos localmente, necesitas crear y activar lo que se llama un entorno virtual, por lo que pip install se instala en la carpeta donde se encuentra ese entorno virtual, en lugar de globalmente (que puede requerir privilegios de administrador).

La última vez en el wiki de la  import-statements usamos el módulo requests como ejemplo. Como es un módulo de terceros, tenemos que instalarlo por separado después de instalar Python.

Instalarlo sería tan simple como ejecutar  pip install requests. Incluso puedes pasar varios argumentos junto con él. El que te encontrarás con más frecuencia es --upgrade. Puede actualizar un módulo de Python mediante:

pip install <module_name> --upgrade

Por ejemplo para actualizar el módulo requests a la última versión es tan sencillo como: pip install requests --upgrade.

Antes de usar pip, deberás instalarlo (es bastante simple). Puedes instalarlo desde aquí

Haz clic en el enlace. Salva el fichero como get-pip.py Por favor, no olvides la extensión .py, y ejecútalo.

Una alternativa al uso de pip sería probar easy_install.

Utilizar easy_install es también muy sencillo. La sintaxis es:

easy_install <module_name>

Sin embargo, pip es más popular que usar easy_install.

Nota: en algunos sistemas donde están instalados Python 2 y Python 3, pip y pip3 harán cosas diferentes. pip instala la versión Python 2 del paquete y pip3 instalará la versión Python 3 del paquete.

Para obtener más información sobre la diferencia entre Python 2 y 3, consulta esta guía. Puedes verificar la versión de pip haciendo pip --version y/o pip3 --version:

pip3 --version
pip 18.0 from /usr/local/lib/python3.5/dist-packages/pip (python 3.5)

También podemos crear un archivo txt que contenga una lista de módulos que deberían instalarse usando pip. Por ejemplo, podríamos crear el archivo requirements.txt y su contenido:

Kivy-Garden==0.1.4
macholib==1.5.1
idna==2.6
geoip2nation==0.1.2
docutils>=0.14
Cython

En este archivo también podríamos establecer una versión para la instalación. Después de esto, invocando a pip con:

pip install -r <FICHERO QUE CONTIENE LOS MODULOS>
 
          O EN NUESTRO EJEMPLO
 
 pip install -r requirements.txt

debe instalar todos los módulos enumerados en el archivo.

Traducido del artículo How to use pip install in Python

Bloques de código e indentación

Una de las características más distintivas de Python es el uso de indentaciones para marcar bloques de código. Considera la declaración if de nuestro sencillo programa de verificación de contraseñas:

if pwd == 'manzana':
    print('Iniciando sesión ...')
else:
    print('Contraseña incorrecta.')

print('¡Todo terminado!')

Las líneas print('Iniciando sesión ...') y print('Contraseña incorrecta') son dos bloques de código separados. Estos resultan tener solo una línea de longitud, pero Python le permite escribir bloques de código que constan de cualquier número de declaraciones.

Para indicar un bloque de código en Python, debes indentar cada línea del bloque en la misma cantidad. Los dos bloques de código en nuestro ejemplo sentencia if están endentados con cuatro espacios que es una cantidad típica de sangría para Python.

En la mayoría de los otros lenguajes de programación, la indentación se usa solo para ayudar a que el código se vea bonito. Pero en Python, es necesario para indicar a qué bloque de código pertenece una declaración. Por ejemplo, la sentencia final print ("¡Todo terminado!") No está endentada, por lo que no es parte del bloque else.

Los programadores familiarizados con otros lenguajes a menudo se irritan ante la idea de que la indentación importa: a muchos programadores les gusta la libertad de formatear su código como les plazca. Sin embargo, las reglas de indentación en Python son bastante simples y la mayoría de los programadores ya utilizan indentación para hacer que su código sea legible. Python simplemente lleva esta idea un paso más allá y le da significado a la sangría.

Sentencia If/elif

Una sentencia if / elif es una sentencia if generalizada con más de una condición. Se utiliza para tomar decisiones complejas. Por ejemplo, supongamos que una aerolínea tiene las siguientes tarifas de billetes para "niños": los niños de 2 años o menos vuelan gratis, los niños mayores de 2 pero menores de 13 pagan una tarifa de niño con descuento y cualquier persona de 13 años o más paga una tarifa de adulto normal. El siguiente programa determina cuánto debe pagar un pasajero:

# pasaje.py
edad = int(input('¿Qué edad tiene usted? '))
if edad <= 2:
    print(' gratis')
elif 2 < edad < 13:
    print(' tarifa de niño)
else:
    print('tarifa para adultos')

Después de que Python obtiene la edad del usuario, ingresa la declaración if / elif y verifica cada condición una tras otra en el orden en que se dan. Entonces, primero verifica si edad es menor a 2, y si es así, indica que el vuelo es libre y salta de la condición elif. Si edad no es menor que 2, entonces verifica la siguiente condición elif para ver si edad está entre 2 y 13. Si es así, muestra el mensaje apropiado y salta de la declaración if / elif. Si ni la condición if ni la condición elif son True, entonces ejecuta el código en el bloque else.

Expresiones condicionales

Python tiene un operador lógico más que le gusta a algunos programadores (¡y a otros no!). Es esencialmente una notación abreviada para declaraciones if que se pueden usar directamente dentro de expresiones. Considera este código:

comida = input("¿Cuál es tu comida favorita? ")
respuesta = 'yuck' if comida == 'cordero' else 'yum'

La expresión en el lado derecho del = en la segunda línea se llama expresión condicional y se evalúa como "yuck" o "cordero". Es equivalente a lo siguiente:

comida = input("¿Cuál es tu comida favorita? ")
if comida == 'cordero':
   respuesta = 'yuck'
else:
   respuesta = 'yum'

Las expresiones condicionales suelen ser más cortas que las correspondientes sentencias if / else, aunque no son tan flexibles o fáciles de leer. En general, deberías utilizarlas cuando simplifiquen tu código.

Documentación oficial Python - Indentación

Traducido del artículo Indentation in Python with Examples

Estos son los diferentes tipos de operadores en Python:

1. Operadores aritméticos
2. Operadores relacionales
3. Operadores Bit a Bit
4. Operadores de asignación
5. Operadores lógicos
6. Operadores de pertenencia
7. Operadores de identidad

Operadores Aritméticos

Un operador aritmético toma dos operandos como entrada, realiza un cálculo y devuelve el resultado.

Considera la expresión, “a = 2 + 3”. Aquí, 2 y  3 son los operandos y  + es el operador aritmético. El resultado de la operación se almacena en la variable a.

Nota: Para obtener el resultado en tipo flotante, uno de los operandos también debe ser de tipo flotante.

Operadores Relacionales

Un operador relacional se emplea para comparar y establecer la relación entre ellos. Devuelve un valor booleano (true o false) basado en la condición.

Operadores Bit a Bit

Un operador bit a bit realiza operaciones en los operandos bit a bit.

Consideremos a = 2 (en binario = 10) y b = 3 (en binario = 11) para los siguientes casos.

Operadores de Asignación

Se utiliza un operador de asignación para asignar valores a una variable. Esto generalmente se combina con otros operadores (como aritmética, bit a bit) donde la operación se realiza en los operandos y el resultado se asigna al operando izquierdo.

Considera los siguientes ejemplos,

a = 18. Aquí = es un operador de asignación, y el resultado se almacena en la variable a.

a + = 10. Aquí += es un operador de asignación, y el resultado se almacena en la variable a. Es lo mismo que a = a + 10.

Operadores Lógicos

Se utiliza un operador lógico para tomar una decisión basada en múltiples condiciones. Los operadores lógicos utilizados en Python son  and, or y not.

Operadores de Pertenencia

Un operador de pertenencia se emplea para identificar pertenencia en alguna secuencia (listas, strings, tuplas).

in y not in son operadores de pertenencia.

in devuelve True si el valor especificado se encuentra en la secuencia. En caso contrario devuelve False.

not in devuelve True si el valor especificado no se encuentra en la secuencia. En caso contrario devuelve False.

a = [1,2,3,4,5]
  
#Esta 3 en la lista a?
print 3 in a # Muestra True 
  
#No está 12 en la lista a?
print 12 not in a # Muestra True
  
str = "Hello World"
  
#Contiene World el string str?
print "World" in str # Muestra True
  
#Contiene world el string str? (nota: distingue mayúsculas y minúsculas)
print "world" in str # Muestra False  

print "code" not in str # Muestra True

Operadores de Identidad

Un operador de identidad se emplea para comprobar si dos variables emplean la misma ubicación en memoria.

is y is not son operadores de identidad.

is devuelve True si los operandos se refieren al mismo objeto. En caso contrario devuelve False.

is not devuelve True si los operandos no se refieren al mismo objeto. En caso contrario devuelve False.

Ten en cuenta que dos valores, cuando son iguales, no implica necesariamente que sean idénticos.

a = 3
b = 3  
c = 4
print a is b # muestra True
print a is not b # muestra False
print a is not c # muestra True

x = 1
y = x
z = y
print z is 1 # muestra True
print z is x # muestra True

str1 = "FreeCodeCamp"
str2 = "FreeCodeCamp"

print str1 is str2 # muestra True
print "Code" is str2 # muestra False

a = [10,20,30]
b = [10,20,30]

print a is b # muestra False (ya que las listas son objetos mutables en Python)  

Traducido del artículo Basic Operators in Python With Examples

La estructura  if/elif/else es una forma común de controlar el flujo de un programa, lo que te permite ejecutar bloques de código específicos según el valor de algunos datos.

Sentencia if

Si la condición que sigue a la palabra clave if  se evalúa como verdadera, el bloque de código se ejecutará. Ten en cuenta que los paréntesis no se utilizan antes y después de la verificación de condición como en otros idiomas.

if True:
  print('¡el bloque If se ejecutará!')

x = 5

if x > 4:
  print("¡La condición era verdadera!") #Esta sentencia se ejecuta

Sentencia else

Opcionalmente, puedes agregar una respuesta else que se ejecutará si la condición es false

if not True:
  print('¡La sentencia If se ejecutará!')
else:
  print('¡La sentencia Else se ejecutará!')

O también puedes ver este ejemplo:

y = 3

if y > 4:
  print("¡No voy a imprimir!") #esta sentencia no se ejecuta
else:
  print("¡La condición no era verdadera!") #esta sentencia se ejecuta

Sentencia elif

Se pueden verificar varias condiciones al incluir una o más verificaciones elif después de su declaración if inicial. Ten en cuenta que solo se ejecutará una condición:

z = 7

if z > 8:
  print("¡No voy a imprimir!") #esta sentencia no se ejecuta
elif z > 5:
  print("¡Yo lo haré!") #esta sentencia se ejecuta
elif z > 6:
  print("¡Tampoco voy a imprimir!") #esta sentencia no se ejecuta
else:
  print("¡Yo tampoco!") #esta sentencia no se ejecuta

Nota: solo se ejecutará la primera condición que se evalúe como true. Aunque z > 6 es true, el bloque if/elif/else termina después de la primera condición verdadera. Esto significa que un else solo se ejecutará si ninguna de las condiciones es true.

Sentencias if anidadas

También podemos crear if anidados para la toma de decisiones.

Tomemos un ejemplo de cómo encontrar un número que sea par y también mayor que 10

python 
x = 34
if x %  2 == 0:  # así es como creas un comentario y ahora comprueba número par.
  if x > 10:
    print("Este número es par y es mayor que 10")
  else:
    print("Este número es par, pero no mayor 10")
else:
  print ("El número no es par. Así que punto de verificación más.")

Este fue solo un ejemplo simple de if anidados. No dudes en explorar más en línea.

Si bien los ejemplos anteriores son simples, puedes crear condiciones complejas utilizando comparaciones booleanas y operadores booleanos.

Declaración if-else de Python en línea
También podemos usar declaraciones if-else en funciones de Python en línea. El siguiente ejemplo debe verificar si el número es mayor o igual que 50, si es así, retorna True:

python 
x = 89
es_mayor = True if x >= 50 else False

print(es_mayor)

Salida:

>
True
>

Traducido del artículo If, Elif, and Else Statements in Python

Las expresiones lambda se usan idealmente cuando necesitamos hacer algo simple y estamos más interesados en hacer el trabajo rápidamente en lugar de nombrar formalmente la función. Las expresiones lambda también se conocen como funciones anónimas.

Las expresiones lambda en Python son una forma corta de declarar funciones pequeñas y anónimas (no es necesario proporcionar un nombre para las funciones lambda).

Las funciones Lambda se comportan como funciones normales declaradas con la palabra clave def. Resultan útiles cuando se desea definir una función pequeña de forma concisa. Pueden contener solo una expresión, por lo que no son las más adecuadas para funciones con instrucciones de flujo de control.

Sintaxis de una función Lambda

lambda argumentos: expresión

Las funciones Lambda pueden tener cualquier número de argumentos, pero solo una expresión.

Código de ejemplo:

# Función Lambda para calcular el cuadrado de un número
square = lambda x: x ** 2
print(square(3)) # Resultado: 9

# Funcion tradicional para calcular el cuadrado de un numero
def square1(num):
  return num ** 2
print(square(5)) # Resultado: 25

En el ejemplo de lambda anterior, lambda x: x ** 2 produce un objeto de función anónimo que se puede asociar con cualquier nombre. Entonces, asociamos el objeto de función con square. De ahora en adelante, podemos llamar al objeto square como cualquier función tradicional, por ejemplo, square(10)

Ejemplos de funciones lambda

Principiante

lambda_func = lambda x: x**2 # Funcion que recoge un número entero y devuelve su cuadrado
lambda_func(3) # Retorna 9

Intermedio

lambda_func = lambda x: True if x**2 >= 10 else False
lambda_func(3) # Retorna False
lambda_func(4) # Retorna True

Complejos

mi_dicc = {"A": 1, "B": 2, "C": 3}
sorted(mi_dicc, key=lambda x: my_dict[x]%3) # Retorna ['C', 'A', 'B']

Casos de uso

Supongamos que desea filtrar los números impares de una  lista. Podrías usar un bucle for:

mi_lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtrado = []

for num in mi_lista:
     if num % 2 != 0:
         filtrado.append(num)

print(filtrado)      # Python 2: impresión de filtrado
# [1, 3, 5, 7, 9]

O podría escribir esto en una línea con comprensión de listas (list-comprehensions). La compresión de listas ofrece una sintaxis más corta cuando deseas crear una nueva lista basada en los valores de una lista existente:

filtrado = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if x % 2 != 0]

Pero es posible que tengas la tentación de utilizar la función integrada filter. ¿Por qué? El primer ejemplo es demasiado detallado y la frase de una sola línea puede ser más difícil de entender. Pero filter ofrece lo mejor de ambas palabras. Además, las funciones integradas suelen ser más rápidas.

mi_lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

filtrado = filter(lambda x: x % 2 != 0, mi_lista)

list(filtrado)
# [1, 3, 5, 7, 9]

NOTA: en Python 3, las funciones integradas devuelven objetos generadores, por lo que se debe llamar la función list. La función list crea un objecto de lista.  En Python 2, por otro lado, devuelven una lista, tupla o  string.

¿Entonces qué ha ocurrido? Le dijiste a filter que tomara cada elemento en mi_lista y aplicara la expresión lambda. Los valores que devuelven False se filtran.

Más información:

• Documentación oficial

Traducido del artículo Lambda Expressions in Python

# declaración de diccionario 1
dict1 = dict()

# declaración de diccionario 2
dict2 = {}

# Añadir items al diccionario
# La sintaxis para añadir y recuperar elementos es la misma para los dos objetos que hemos definido anteriormente. 
key = "X"
value = "Y"
dict1[key] = value

# El diccionario no tiene un tipo especifico de datos. 
# Entonces, los valores pueden ser muy diversos. 
dict1[key] = dict2

Veamos ahora algunas formas de recuperar la información.

# Desde que existe "X" en nuestro diccionario, esta sentencia nos devolverá el valor
value = dict1[key]

# Esta clave no existe en el diccionario. 
# Entonces, esto devolverá un `KeyError`
value = dict1["random"]

Evitando el KeyError: Utiliza la función .get

En caso de que la clave proporcionada no exista en el diccionario, Python lanzará un  KeyError. Hay una solución sencilla. Veamos como podemos evitar el  KeyError utilizando la función  .get incluida en los diccionarios.

dict_ = {}

# Una clave aleatoria
random_key = "random"

# La manera más sencilla de hacer esto es comprobar que existe la clave 
# en el diccionario o no y solo recupera la clave si existe. 
# En caso contrario no. 
if random_key in dict_:
  print(dict_[random_key])
else:
  print("Key = {} doesn't exist in the dictionary".format(dict_))

Muchas veces podemos obtener un valor predeterminado cuando la clave no existe. Por ejemplo al construir un contador. Existe una manera mejor de obtener valores predeterminados del diccionario en caso de que falten claves en lugar de confiar en el if-else estándar.

# Digamos que queremos construir un contador de cuantas veces aparece un elemento en el siguiente arreglo
arr = [1,2,3,1,2,3,4,1,2,1,4,1,2,3,1]

freq = {}

for item in arr:
  # Trae un valor para 0 en caso de que no exista. En caso contrario trae el valor almacenado
  freq[item] = freq.get(item, 0) + 1

Entonces,  get(<key>, <defaultval>) es una operación útil para recuperar el valor predeterminado para cualquier clave dada del diccionario. El problema con este método surge cuando queremos tratar con estructuras de datos mutables como  list o set.

dict_ = {}

# Alguna clave aleatoria
random_key = "random"

dict_[random_key] = dict_.get(random_key, []).append("Hello World!")
print(dict_) # {'random': None}

dict_ = {}
dict_[random_key] = dict_.get(random_key, set()).add("Hello World!")
print(dict_) # {'random': None}

¿Has visto el problema?

El nuevo set o la list no se asigna a la clave del diccionario. Debemos asignar una nueva list o un set a la clave en caso de que falte un valor y luego append (append) o add (añadir) respectivamente. Mira un ejemplo para esto.

dict_ = {}
dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")
print(dict_) # {'random': set(['Hello World!'])}. Yay!

Evitar KeyError: Utiliza defaultdict

Esto funciona la mayoría de las veces. Sin embargo, existe una mejor forma de hacerlo. Una forma más pythónica. El defaultdict es una subclase de la clase dict incorporada. El defaultdict simplemente asigna el valor predeterminado que especificamos en caso de que falte una clave. Entonces, los dos pasos:

dict_[random_key] = dict_.get(random_key, set())
dict_[random_key].add("Hello World!")

Ahora se pueden combinar en un único paso. Por ejemplo:

rom collections import defaultdict

# Otra clave aleatoria
random_key = "random_key"

# list como defaultdict
list_dict_ = defaultdict(list)

# set como defaultdict
set_dict_ = defaultdict(set)

# integer como defaultdict
int_dict_ = defaultdict(int)

list_dict_[random_key].append("Hello World!")
set_dict_[random_key].add("Hello World!")
int_dict_[random_key] += 1

"""
  defaultdict(<class 'list'>, {'random_key': ['Hello World!']}) 
  defaultdict(<class 'set'>, {'random_key': {'Hello World!'}}) 
  defaultdict(<class 'int'>, {'random_key': 1})
"""
print(list_dict_, set_dict_, int_dict_)

Traducido del artículo Python Dictionary Data Structure Explained

Git es el sistema de control de versiones moderno más utilizado en el mundo hoy en día. Git es un proyecto de código abierto distribuido y mantenido activamente, el cual fue desarrollado originalmente en el 2005 por Linus Torvalds, el famoso creador del kernel del sistema operativo Linux.

Git es muy diferente a los sistemas de control de versiones centralizados más antiguos, como SVN y CVS, Git se distribuye. Con Git cada desarrollador cuenta con el historial completo de su repositorio de código localmente. Git también funciona bien en una amplia gama de sistemas operativos e IDE (entornos de desarrollo integrados).

En este artículo, te mostraré cómo instalar Git, configurarlo por primera vez, consejos útiles y recursos para aprender más conceptos avanzados de git. ¡Vamos a ello!

Un resumen rápido de lo que significa el control de versiones:

El control de versiones es el proceso de administrar cambios en el código fuente o en un conjunto de archivos a lo largo del tiempo.

El software de control de versiones realiza un seguimiento de cada modificación del código en un tipo especial de base de datos. Si se comete un error, los desarrolladores pueden restaurar y comparar versiones anteriores del código para ayudar a corregir el error y minimizar la interrupción para todos los miembros del equipo o colaboradores.

Ahora que sabes lo que significan Control de versiones y Git, vamos a instalarlo.

PARA EL SISTEMA OPERATIVO MAC:

Descarga Git para macOS o instálalo utilizando Homebrew

brew install git

PARA EL SISTEMA OPERATIVO LINUX:

Descarga Git para Linux o instálalo para:

Sistemas Linux basados en Debian

sudo apt-get update
 sudo apt-get upgrade
 sudo apt-get install git

o
Instálalo para sistemas Linux basados en Red Hat

sudo yum upgrade
 sudo yum install git

PARA EL SISTEMA OPERATIVO WINDOWS:

Descargar Git para Windows

EN LA DOCUMENTACIÓN OFICIAL DE GIT PUEDES ENCONTRAR UNA GUIA MAS DETALLADA DE INSTALACIÓN PARA SISTEMA OPERATIVO,

Ahora que tienes Git en tu sistema, configuremos el entorno de Git.
Git viene con una herramienta llamada git config que te permite obtener y establecer variables de configuración que controlan todos los aspectos de cómo se ve y funciona Git.

• Primero configura tu identidad, tu nombre y correo electrónico, por ejemplo:

git config --global user.name "bolajiayodeji"
 git config --global user.email mailtobolaji@gmail.com

la opción --global asegura que estos valores se utilizarán en todo tu sistema.

• A continuación, configure el editor de texto predeterminado que usarás siempre que necesites introducir un mensaje en Git. Este paso no es obligatorio, si no lo configuras, Git usará su editor predeterminado. Si deseas usar otro, puedes configurarlo así:

git config --global core.editor emacs

• A continuación, configura los colores para la consola de Git.

Los usuarios del sistema operativo Linux, pueden usar configuradores Zsh de terceros como oh my zsh para personalizar el aspecto del terminal con temas :).
Para configurar ejecuta:

git config --global color.ui true

Color.ui es una metaconfiguración que incluye todas las diversas configuraciones de color.* disponibles con los comandos git.

Ahora Git está listo para usarse.

COMPRUEBA TU CONFIGURACIÓN

git config --list

user.name=bolajiayodeji
 user.email=mailtobolaji@gmail.com
 color.ui=true

CONCLUSIONES

El software de control de versiones es una parte esencial del día a día de las prácticas modernas del desarrollador de software de hoy en día. Una vez acostumbrados a los poderosos beneficios de los sistemas de control de versiones, muchos desarrolladores no considerarían trabajar sin él, incluso para proyectos que no son de software.

Traducido del artículo de Bolaji Ayodeji - Git first time setup

¿Qué son los bucles?

Si estás aprendiendo a programar, los bucles son uno de los conceptos principales que debe comprender. Los bucles te ayudan a ejecutar una secuencia de instrucciones hasta que se cumple una condición.

Hay dos tipos principales de bucles en Python.

• Bucles For
• Bucles While

Ambos tipos de bucles se pueden utilizar para acciones similares. Pero a medida que aprendas a escribir programas eficientes, sabrás cuándo usar cual.

En este artículo, veremos los bucles while en Python. Para obtener más información sobre los bucles for, consulta este artículo publicado recientemente en freeCodeCamp.

Bucles While

El concepto detrás de un ciclo while es simple: mientras una condición es verdadera -> Ejecuta mis comandos.

El bucle while comprueba la condición cada vez, y si devuelve "true", ejecutará las instrucciones dentro del bucle.

Antes de comenzar a escribir código, veamos el diagrama de flujo para ver cómo funciona.

Ahora escribamos algo de código. Así es como se escribe un bucle while simple para imprimir números del 1 al 10.

#!/usr/bin/python

x = 1

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

Si observas el código anterior, el bucle sólo se ejecutará si x es menor o igual que 10. Si inicializa x como 20, el ciclo nunca se ejecutará.

Aquí está la salida del bucle while:

> python script.py
1
2
3
4
5
6
7
8
9
10

Bucle Do-While

Hay dos variantes del bucle while: while y do-While. La diferencia entre los dos es que do-while se ejecuta al menos una vez.

Es posible que un bucle while ni siquiera se ejecute una vez si no se cumple la condición. Sin embargo, do-while se ejecutará una vez, luego verificará la condición para bucles posteriores.

A pesar de estar presente en la mayoría de los lenguajes de programación populares, Python no tiene una declaración nativa do-while. Pero puede emular fácilmente un bucle do-while utilizando otros enfoques, como funciones.

Probemos el enfoque de hacer mientras envuelve los comandos en una función.

#!/usr/bin/python

x = 20

def run_commands():
	x = x+1
	print(x)


run_commands()
while(x <= 10):
	run_commands()

El código anterior ejecuta la función "run_commands ()" una vez antes de invocar el bucle while. Una vez que se inicia el bucle while, la función "run_commands" nunca se ejecutará ya que x es igual a 20.

While - Else

Puedes agregar una instrucción else para ejecutar si falla la condición de bucle.

Agreguemos una condición else a nuestro código para imprimir "Done" una vez que hayamos impreso los números del 1 al 10.

#!/usr/bin/python

x = 1

while(x <= 10):
	print(x)
	x = x+1
else:
	print("Done")

El código anterior imprimirá primero los números del 1 al 10. Cuando x es 11, la condición while fallará, desencadenando la condición else.

Sentencia While en una única línea

Si solo tiene una sola línea de código dentro de tu  bucle while, puedes usar la sintaxis de una sola línea.

#!/usr/bin/python

x = 1
while (x): print(x)

Bucles infinitos

Si no tienes cuidado al escribir bucles, creará bucles infinitos. Los bucles infinitos son aquellos en los que la condición siempre es cierta.

#!/usr/bin/python

x = 1
while (x >= 1):
	print(x)

El código anterior es un ejemplo de un bucle infinito. No hay ningún comando para alterar el valor de x, por lo que la condición "x es mayor o igual que 1" es siempre verdadera. Esto hará que el bucle funcione para siempre.

Tenga siempre cuidado al escribir bucles. Un pequeño error puede provocar un bucle infinito y bloquear su aplicación.

Control de bucles

Finalmente, veamos cómo controlar el flujo de un bucle mientras se está ejecutando.

Cuando esté escribiendo aplicaciones del mundo real, a menudo se encontrará con escenarios en los que necesita agregar condiciones adicionales para omitir un bucle o salir de un bucle.

Break

Veamos cómo salir del ciclo mientras la condición es verdadera.

#!/usr/bin/python

x = 1
while (x <= 10):
    if(x == 5):
    	break
    print(x)
    x += 1

En el código anterior, el bucle detendrá la ejecución cuando x sea 5, a pesar de que x sea mayor o igual que 1.

Continue

Aquí hay otro escenario: digamos que desea omitir el bucle si se cumple una determinada condición. Sin embargo, desea continuar con las ejecuciones posteriores hasta que la condición principal while se vuelva falsa.

Puede usar la palabra clave "continuar" para eso, así:

#!/usr/bin/python

x = 1
while (x <= 10):
    if(x == 5):
    	x += 1
    	continue
    print(x)

En el ejemplo anterior, el bucle se imprimirá de 1 a 10, excepto 5. Cuando x es 5, el resto de los comandos se omiten y el flujo de control vuelve al inicio del bucle while.

Resumen

Los bucles son uno de los componentes más útiles en la programación que utilizará a diario.

For y while son los dos bucles principales en Python. El bucle while tiene dos variantes, while y do-while, pero Python solo admite la primera.

Puede controlar el flujo del programa utilizando los comandos 'interrumpir' y 'continuar'. Siempre tenga en cuenta la creación accidental de bucles infinitos.

Escribo regularmente sobre temas que incluyen Inteligencia Artificial y Ciberseguridad. Si te gustó este artículo, puedes leer mi blog aquí.

Traducido del artículo de Manish Shivanandhan - Python While Loop Tutorial – Do While True Example Statement

¿Y si pudiera estar en formato Markdown, por lo que se distribuiría junto con el resto de tu código y se mostraría en GitLab / GitHub?

Suena muy bien, ¿verdad? Veamos cómo se hace.

Contexto

Personas como Simon Brown hacen un gran trabajo al convencerme de que no tengo suficiente documentación para mis proyectos. Y que la documentación debe estar actualizada y mostrar información concisa en una variedad de niveles de abstracción.

Me encantaría trabajar en un base de código con documentación como esa.

El Problema con la Documentación

He leído una buena cantidad de libros y artículos sobre arquitectura de software y cosas relacionadas. Pero nunca he podido reunir suficiente energía, o suficiente capital político, para poder crear documentación de acuerdo con este estándar. Y mucho menos mantenerlo actualizado.

Entonces, al menos para mi situación, necesito una forma de crear y actualizar documentación automáticamente.

También me gustaría almacenar los diagramas "como código", para que puedan registrarse en el repositorio. De esta manera, los cambios en ellos se pueden ver y discutir fácilmente en solicitudes de extracción y otras revisiones de código.

Hay muchas herramientas que pueden generar diagramas de dependencia del tiempo de construcción a partir del código, y he usado bastantes de ellas.

Pero el problema parece ser que estos diagramas siempre parecen espaguetis, incluso cuando el código es bueno. Y son complejos de configurar.

Parece muy difícil conseguir el nivel de detalle correcto. No hay forma de mostrar código relacionado en grupos lógicos para diagramas de alto nivel. Tampoco hay forma de seleccionar relaciones de código que sean específicas de un contexto particular para diagramas de bajo nivel.

Tampoco le brindan información sobre las relaciones de tiempo de ejecución del código, que generalmente es un problema mayor que las relaciones de tiempo de diseño.

Una solución

Para capturar las relaciones en tiempo de ejecución, la única opción es generar diagramas a partir del código en ejecución. Y ya tenemos mucho código que se ejecuta regularmente, en forma de pruebas.

Los repositorios ya deberían tener un buen conjunto de pruebas (unidad, integración y de extremo a extremo, por ejemplo), y cada prueba debería ser relativamente corta y sencilla.

Estas pruebas ya deberían incorporar agrupaciones lógicas de código y niveles sensibles de abstracción. Por lo que son un excelente candidato para generar documentación.

La solución implica instrumentar el código importado por un prueba. Este código instrumentado mantiene un registro de la jerarquía de llamadas en tiempo de ejecución y es capaz de escribir los resultados como un diagrama Mermaid en markdown (técnicamente un diagrama de secuencia).

Para cada prueba existente, crea una prueba de "envoltura", que es responsable de inicializar la jerarquía de llamadas y guardar el diagrama. Si tiene muchas pruebas, es posible que desees introducir un decorador para evitar la repetición.

from docs_from_tests.instrument_call_hierarchy import instrument_and_import_package, instrument_and_import_module, initialise_call_hierarchy, finalise_call_hierarchy
from samples.hello_world_combiner import HelloWorldCombiner

# puedes instrumentar paquetes / carpetas completos a la vez de esta manera
instrument_and_import_package(os.path.join(Path(__file__).parent.absolute(), '..', 'samples'), 'samples')
# Puedes instrumentar módulos individuales como este
# instrument_and_import_module('tests.blah')

# este es un contenedor alrededor de la prueba que también genera el diagrama de documentación / secuencia
def test_hello_world():
    # la inicializa la grabación de la jerarquía de llamadas
    initialise_call_hierarchy('start')

    # Esto ejecuta la prueba real
    _test_hello_world()
    
    # esto finaliza la jerarquía de llamadas y devuelve la raíz
    root_call = finalise_call_hierarchy()

    # esto devuelve un diagrama de secuencia de la jerarquía de llamadas
    sequence_diagram = root_call.sequence_diagram(
        show_private_functions=False,
        excluded_functions=[
            'HelloWorldCombiner.__init__',
        ]
    )

    # esto escribe la rebaja en el disco    
    sequence_diagram_filename = os.path.join(os.path.dirname(__file__), '..', 'doc', 'top-level-sequence-diagram.md')
    Path(sequence_diagram_filename).write_text(sequence_diagram)

# esta es la prueba original / fuente
def _test_hello_world():
    assert HelloWorldCombiner().combine() == 'Hello world'

Ejecutar pytest en este código dará como resultado la ejecución de la prueba y la creación del "diagrama como código" en markdown (a continuación) en el directorio doc:

sequenceDiagram
  start->>HelloWorldCombiner.combine: calls x1
  HelloWorldCombiner.combine->>hello: calls x1
  hello-->>HelloWorldCombiner.combine: returns str
  HelloWorldCombiner.combine->>world: calls x1
  world-->>HelloWorldCombiner.combine: returns str
  HelloWorldCombiner.combine-->>start: returns str

Esto representa como el siguiente diagrama:

Los cambios en el diagrama aparecerán en Git y se distribuirán junto con el código que provocó el cambio. Esto significa que el cambio en el código y el cambio en el diagrama están vinculados y se pueden ver juntos.

Los métodos privados generalmente se excluyen (aunque es opcional), y puede excluir otras funciones para que el gráfico tenga el aspecto deseado.

Debido a que la jerarquía de llamadas se almacena en una estructura de árbol, excluir una función también excluye todas las funciones incluidas en ella.

Calidad del código

Es de esperar que ya tengas pruebas en los niveles apropiados de abstracción (normalmente tendrías prueba unitarios, de integración y de extremo a extremo). Esto facilita la creación de diagramas en estos niveles.

Si no, entonces el deseo de crear buenos diagramas debería guiarlo hacia la creación también de buenas pruebas.

A veces, los diagramas se verán un poco desordenados y es posible que termines ignorando muchas funciones. Esta es una pista de que el código probablemente podría simplificarse. Y en este caso, el deseo de crear buenos diagramas debería guiarte hacia la simplificación del código.

Conclusión

¡Esperamos que este artículo le sirva como inspiración para crear y mantener la documentación que tus compañeros de equipo y tu futuro yo te agradecerán! Es bastante fácil de hacer.

Toda la funcionalidad está en un paquete de Python (docs-from-tests), y hay un repositorio de ejemplo que demuestra cómo usarlo.

Traducido del artículo de Cedd Burge - How to Create Documentation from Your Python Tests

SVG o Gráficos Vectoriales Escalables es un estándar web para definir gráficos basados en vectores en páginas web. Basado en XML, el estándar SVG proporciona marcado para describir rutas, formas y texto dentro de una ventana gráfica. El marcado se puede incrustar directamente en HTML para mostrarlo o guardarlo en un archivo .svg e insertarlo como cualquier otra imagen.

Puede escribir SVG a mano, pero se pueden diseñar gráficos más complicados en editores de gráficos vectoriales como Illustrator o InkScape y exportarlos a archivos o código SVG.

Conceptos básicos de SVG

Los desarrolladores inician un gráfico <svg> con la etiqueta  y el espacio de nombres XML así:

<svg xmlns="http://www.w3.org/2000/svg" version="1.1">

</svg>

El ejemplo incluye un atributo de version. El atributo version es opcional, pero se recomienda para cumplir con las especificaciones XML.

Este ejemplo no muestra nada, simplemente establece una ventana gráfica. Puede agregar los atributos height y width para establecer un tamaño de visualización para la ventana gráfica, esto esencialmente establece un canvas para que pueda trabajar.

Con una ventana gráfica en su lugar, puede agregar gráficos básicos, texto y elementos de ruta.

<svg
     version="1.1"
     width="100%"
     viewbox="0 0 600 300"
     xmlns="http://www.w3.org/2000/svg">
  <rect x="10" y="10" width="100" height="100" fill="#f7b2c1" />
  <circle cx="240" cy="60" r="50" fill="#c1b2f7" stroke="#b2c1f7" stroke width="15"/>
  <text x="450" y="70" font-size="20" text-anchor="middle">SVG Text es legible por el navegador!</text>
  <g stroke="#b2c1f7"> <!-- g es para el grupo -->
    <path stroke-width="2" d="M10 170 l590 0" />
    <path stroke-width="4" d="M10 190 l590 0" />
    <path stroke-width="6" d="M10 210 l590 0" />
  </g>  
</svg>  

Puedes ver la salida y jugar con el código en este codepen.

En la etiqueta svg de apertura agregamos un atributo width para establecer el ancho de la ventana gráfica al 100% del ancho del contenedor, puedes usar porcentajes o anchos de píxeles. La etiqueta svg de apertura también incluye el atributo viewbox que define una ventana a través de la cual los elementos de su svg son visibles, en este caso, el viewbox se extiende desde (0,0) a (600,300). En el espacio SVG, el eje X comienza con cero a la izquierda y aumenta a la derecha; el eje Y comienza con cero en la parte superior y aumenta hacia la parte inferior.

La etiqueta <rect /> define un rectángulo en la ventana gráfica SVG. En este caso, definimos un cuadrado que está a 10 unidades de la parte superior e izquierda y 100 unidades de alto y ancho. El atributo fill establece el color de relleno de la forma.

A continuación, definimos un círculo u óvalo con la etiqueta <circle />. El ejemplo define un círculo centrado en (240,60) con un radio de 50 unidades. Los atributos stroke and stroke-width establecen un color de trazo y un tamaño para el trazo.

Puede agregar texto al gráfico con la etiqueta text. El texto de ejemplo está anclado desde la mitad del texto hasta un punto en (450, 70) y tiene un tamaño de fuente de 20 unidades. Lo bueno del texto en SVG es que se escalará con el resto de su gráfico, pero el navegador y los bots web aún lo pueden leer.

Cuando desees aplicar los mismos atributos o estilos CSS a varios elementos SVG, puedes agruparlos con la etiqueta <g>. Los atributos asignados a la etiqueta <g>, como el atributo strokeel ejemplo, se aplicarán a todos los elementos dentro del grupo. En este caso, tres <path /> elementos .

El elemento <path /> define una ruta vectorial en la ventana gráfica. La ruta está definida por el atributo d. En el primer ejemplo, la definición dice "muévase a la coordenada absoluta (10, 170) y dibuje una línea a las coordenadas relativas 590 en la dirección X y 0 en la dirección Y".
Los siguientes comandos se pueden utilizar para crear su ruta:
M = moverse a; L = línea a; H = línea horizontal a; V = línea vertical a; Z = cerrar ruta; C = curva (bezier cúbica) a; S = curva suave a; Q = curva bezier cuadrática a; T = curva bezier cuadrática suave a; A = arco

El elemento canvas

Los gráficos del canvas se pueden dibujar en un

Se crea un contexto a través del método getContext en el

<p>Antes de canvas</p>
<canvas width ="120" height ="60"></canvas>
<p>Después canvas</p>
<script>
    var canvas = document.querySelector("canvas");
    var context = canvas.getContext("2d");
    context.fillStyle = "red";
    context.fillRect(10, 10, 100, 50);
</script>

Después de crear el objeto de contexto, el ejemplo dibuja un rectángulo rojo de 100 píxeles de ancho y 50 píxeles de alto, con su esquina superior izquierda en las coordenadas (10,10).

Dibujar un gráfico circular

La variable resultados contiene una serie de objetos que representan las respuestas de la encuesta.

var resultados = [
{ nombre : "satisfecho", cuenta: 1043, color: "lightblue"},
{ nombre : "Neutral", cuenta: 563, color: "lightgreen"},
{ nombre : "Insatisfecho", cuenta: 510, color: "pink"},
{ nombre : "No comentario", cuenta: 175, color: "silver"}
];

Para dibujar un gráfico circular, dibujamos una serie de sectores circulares, cada uno formado por un arco y un par de líneas en el centro de ese arco. Podemos calcular el ángulo que toma cada arco dividiendo un círculo completo (2 π) por el número total de respuestas y luego multiplicando ese número (el ángulo por respuesta) por el número de personas que eligieron una opción determinada.

<canvas width ="200" height ="200"> </canvas>
<script>
    var cx = document.querySelector("canvas").getContext("2d");
    var total = resultados.reduce(function (suma, opcion) {
    return suma + opcion.cuenta;
    }, 0);

    // Start at the top

    var anguloActual = -0.5 * Math.PI;
    resultados.forEach (function (resultado) {
    var anguloTejada = (resultado.cuenta / total) * 2 * Math.PI;
    cx.beginPath() ;
    // center = 100, 100, radius = 100
    // del angulo actual, en el setido del reloj por el angulo de la tajada
    cx.arc(100, 100, 100, anguloActual, anguloActual + anguloTejada);
    anguloActual += anguloTejada;
    cx.lineTo(100, 100);
    cx.fillStyle = resultado.color;
    cx.fill() ;
    });
</script>

El código anterior dibuja el siguiente gráfico:

Compatibilidad de los navegadores

La compatibilidad del navegador con SVG está disponible en todos los navegadores modernos. Hay algunos problemas con el escalado en IE 9 hasta IE 11, sin embargo, se pueden solucionar con el uso de width, height, viewbox y CSS.

Editores

• Vectr - herramienta web y de escritorio para crear y editar gráficos SVG, sin costes.

Herramientas para crear SVG

Hay pocas herramientas disponibles para crear SVG en forma de programa de dibujo.

• Inkscape - Es una herramienta de código abierto para el dibujo vectorial de última generación con una interfaz gráfica fácil de usar.
• Adobe Illustrator - Adobe Illustrator es una herramienta comercial para imágenes vectoriales

Para obtener más herramientas, consulte la lista W3C de herramientas que admiten SVG

Por qué debería usar SVG

Como formato de imagen vectorial, te permite cambiar el tamaño de una imagen sin pérdida de calidad y un peso particularmente ligero. Como formato XML, te permite beneficiarte de todo el poder de JavaScript y especialmente CSS.

Más información sobre SVG:

• Por qué deberías usar imágenes SVG
• Lo que necesitas saber para trabajar con SVG en VS Code
• Cómo hacer que tu elegante botón SVG sea accesible

Traducido del artículo - What Is an SVG File? SVG Image and Tags Explained

¿Qué es RSync?

Rsync es más rápido que herramientas como Secure Copy Protocol (SCP). Utiliza el algoritmo de transferencia delta que minimiza la transferencia de datos al copiar solo las secciones de un archivo que se han actualizado.

Algunas de las características adicionales de Rsync incluyen:

• Admite la copia de enlaces, dispositivos, propietarios, grupos y permisos
• No requiere privilegios de superusuario
• Transferencias de archivos mediante pipelines para minimizar los costes de latencia

Solo puedes transferir archivos de local a remoto o de remoto a local. Rsync no admite transferencias de archivos remotas a remotas.

¿Cómo funciona RSync?

Ahora que sabe qué es Rsync, veamos cómo trabajar con él.

Rsync funciona de manera similar a otras herramientas de administración de servidores remotos como SSH y SCP.

Esta es la sintaxis básica de Rsync:

rsync [options] source [destination]

Esta es la sintaxis para transferir un archivo desde el sistema local a un servidor remoto. También se denomina operación "push".

rsync local_file_path user@remote-host:remote_file_path

Esta es la explicación de cómo transferir un archivo desde un servidor remoto al sistema local, también llamada operación "pull".

rsync user@remote-host:remote_file_path local_file_path

Nota: cuando trabaje con sistemas remotos, asegúrese de tener acceso SSH al sistema remoto. Rsync establece la conexión mediante SSH para permitir la transferencia de archivos.

¿Cómo usar Indicadores en RSync?

Rsync te permite agregar opciones adicionales a través de indicadores de línea de comandos. Veamos algunos indicadores útiles.

Recursivo

Si agrega la opción -r, RSync ejecutará una transferencia de archivos recursiva. Esto es útil cuando se trabaja con directorios. Aquí hay un ejemplo:

rsync -r user@remote-host:remote_directory/ local_directory

Archivo

El indicador -a se usa para conservar los enlaces simbólicos mientras se transfieren archivos. El indicador de archivo también conserva los archivos especiales y de dispositivo, las horas de modificación y los permisos del directorio de origen.

El indicador archivo también sincroniza archivos de forma recursiva, por lo que se usa más que el indicador recursivo. Así es como se usa:

rsync -a user@remote-host:remote_directory/ local_directory

Compresión

También puedescomprimir archivos usando el indicador -z. La compresión de archivos puedes reducir la carga de la red y acelerar la transferencia de archivos.

rsync -az user@remote-host:remote_directory/ local_directory

Progreso

Para transferencias de archivos grandes, es útil conocer el progreso de la operación. Puedes utilizar el indicador -P para conocer el progreso de la transferencia de archivos. Con Rsync, también puedes reanudar las transferencias de archivos si se interrumpen.

rsync -aP user@remote-host:remote_directory/ local_directory

Verboso

Finalmente, el comando verboso nos ayuda  a comprender cada paso de la transferencia de archivos. Puedes usar el indicador -v para esto.

rsync -av user@remote-host:remote_directory/ local_directory

También puedes usar el comando de ayuda con RSync para obtener una lista de todas las opciones y indicadores.

rsync --help

Conclusión

Rsync simplifica todo el proceso de transferencia de archivos al ofrecer una herramienta robusta, versátil y flexible en comparación con alternativas como SCP.

RSync es ideal para operaciones de mantenimiento, copias de seguridad y operaciones generales de archivos entre máquinas locales y remotas.

Referencias

• https://www.digitalocean.com/community/tutorials/how-to-use-rsync-to-sync-local-and-remote-directories-on-a-vps
• https://linux.die.net/man/1/rsync
• https://www.geeksforgeeks.org/rsync-command-in-linux-with-examples/

Soy Manish y escribo sobre Ciberseguridad, Inteligencia Artificial y DevOps. Si te gustó este artículo, puedes encontrar mi blog aquí.

Traducido del artículo de Manish Shivanandhan - RSync Examples – Rsync Options and How to Copy Files Over SSH