• Carpeta Documentos
• Carpeta Escritorio
• Otras carpetas y documentos importantes (.bashrc, .aliases, etc.)
• Libreta de direcciones de los navegadores
• Certificados digitales de los navegadores
• Contraseñas guardadas en los navegadores
• Lista de contactos del cliente de correo
• Firmas del cliente de correo
• Lista de wifis y sus contraseñas

$ scp user@123.123.123.123:/home/user/database_name.sql .

$ scp ./README.txt user@123.123.123.123:/home/user/

$ scp ./README.txt ./README.md user@123.123.123.123:/home/user/
$ scp ./README. user@123.123.123.123:/home/user/

$ scp -r ./data user@123.123.123.123:/home/user/

$ tar -czvf Directorio.tar.gz Directorio

$ rsync -a -P remote_user@remote_host_or_ip:/opt/media/ /opt/media/

• Guardar el código dentro de la carpeta de proyecto con el nombre de django.sh
• Dar al archivo permisos de ejecución: chmod -x django.sh
• Ejecutar el archivo seguido del nombre del proyecto Django y nombre de la aplicación (opcional):
  • ./django.sh ‘nombre_proyecto’ [‘nombre_aplicación’]
• Registrar la aplicación en settings.py
• Cambiar al interprete del entorno virtual en VS Code
  • Ctrl+Shift+P -> Python: Select Interpreter
• Activar el entorno virtual: source .venv/bin/activate

#! /bin/bash

if [ "$#" -eq 0 ]; then
    echo
    echo "ERROR: Faltan parámetros"
    echo "USO: django.sh 'nombre_proyecto' ['nombre_aplicación']"
    exit 1
fi

# Creamos un entorno virtual y lo activamos
python3.11 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip

# Instalamos Django y creamo un proyecto
python -m pip install Django
django-admin startproject $1 .

# Creamos carpetas para plantillas y contenido estático
mkdir templates
mkdir static
touch templates/base.hml
touch templates/home.html

# Si hemos pasado un nombre de aplicación se crea la aplicación
if [ -n "$2" ]; then
    python manage.py startapp $2
    mkdir templates/$2
fi

# Hacemos la migraciones y creamos un superusuario
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser --username admin --email admin@admin.com
# AQUÍ NOS PEDIRÁ UNA CONTRASEÑA PARA EL USUARIO CREADO

if [ -n "$2" ]; then
    echo
    echo "------------------------------"
    echo "  No olvides registrar tu aplicación '$2' en settings.py"
    echo "------------------------------"
fi
echo "  No olvides cambiar el interprete en VS Code"
echo "      Ctrl+Shift+P -> Python: Select Interpreter"
echo "------------------------------"

class A(object):
    def foo(self,x):
        print ("ejecutando foo(%s,%s)"%(self,x))

    @classmethod
    def class_foo(cls,x):
        print ("ejecutando class_foo(%s,%s)"%(cls,x))

    @staticmethod
    def static_foo(x):
        print ("ejecutando static_foo(%s)"%x)

a=A()

A continuación se muestra la forma habitual en que una instancia de objeto llama a un método. La instancia del objeto a se pasa implícitamente como primer argumento. Mientras que si llamamos al método directamente desde la clase, debemos pasarle el argumento.

a.foo(1)
# ejecutando foo(<__main__.A object at 0x7f39ff41e390>,1)

A.foo(2,1)
#ejecutando foo(2,1)

Con los métodos de clase (@classmethod), la clase de la instancia del objeto se pasa implícitamente como primer argumento en lugar de self.

a.class_foo(1)
# ejecutando class_foo(<class '__main__.A'>,1)

También puedes llamar a class_foo utilizando la clase. De hecho, si defines algo como un método de clase (@classmethod), probablemente es porque pretendes llamarlo desde la clase en lugar de desde una instancia de clase.

A.foo(1) habría producido un TypeError, pero A.class_foo(1) funciona perfectamente:

A.class_foo(1)
# ejecutando class_foo(<class '__main__.A'>,1)

Un uso que la gente ha encontrado para los métodos de clase es crear constructores alternativos heredables.

Con los métodos estáticos (@staticmethod), ni self (la instancia del objeto) ni cls (la clase) se pasan implícitamente como primer argumento. Se comportan como funciones simples, excepto que puedes llamarlas desde una instancia o desde la clase:

a.static_foo(1)
# ejecutando static_foo(1)

A.static_foo('Hola')
# ejecutando static_foo(Hola)

Los métodos estáticos se utilizan para agrupar funciones que tienen alguna conexión lógica con una clase.

Fuente: Stack Overflow

zip()

a = ("John", "Charles", "Mike")
b = ("Jenny", "Christy", "Monica")

x = zip(a, b)

# use the tuple() function to display a readable version of the result:

print(tuple(x))

# SALIDA
# (('John', 'Jenny'), ('Charles', 'Christy'), ('Mike', 'Monica'))

pairwise()

from itertools import pairwise  # Python 3.10 

cadena = 'ABCDEFG' # Iterable
# pairwise('ABCDEFG') --> AB BC CD DE EF FG

for primero, segundo in pairwise(cadena):
    print(f'{primero}{segundo} ', end='')
print()

# SALIDA: AB BC CD DE EF FG 

cycle()

from itertools import cycle 

cadena = 'ABCD' # Iterable
# cycle('ABCD') --> A B C D A B C D A B C D ...
iterador = cycle(cadena)

for _ in range(1, 5):
    elemento = next(iterador)

print(elemento) # Elemento 4: D

map()

from itertools import repeat # Crea un iterable con el valor que se le pase

def myfunc(a):
  return len(a)

x = map(myfunc, ('apple', 'banana', 'cherry'))

print(x) # <map object at 0x056D44F0>

#convert the map into a list, for readability:
print(list(x)) # SALIDA: [5, 6, 6]

print(list(map(pow, range(10), repeat(2)))) # pow() necesita 2 argumentos. n^2
# SALIDA: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

if (yourls_is_valid_user() != 1) {

to

if( defined( 'YOURLS_USER' ) ) {

Fuente: https://github.com/Flynntes/Sleeky/issues/127

Multi-cursor: Ctrl + D
Multi-cursor: Ctrl + Shift + Up/Down Arrows

Cambiar color de fondo en VS Code

Ctrl + Shift + P -> Open User Settings (JSON)
...
"workbench.colorCustomizations": {
        "editor.background": "#1f3240"
    }

>>> lb = Book.objects.filter(id=1)
>>> lb = Book.objects.filter(author=’J.R.R. Tolkien’)
>>> lb = Book.objects.filter(id__gt=5) 	# greaterthan	>
>>> lb = Book.objects.filter(id__lt=5) 	# lowerthan		< 
>>> lb = Book.objects.filter(id__gte=5)	# greaterthanequal	>=
>>> lb = Book.objects.filter(id__lte=1)	# lowerthanequal	<=
>>> lb = Book.objects.filter(title__contains=”Kill”)
>>> lb = Book.objects.filter(title__startswith=”The”)

>>> loan = Loan.objects.filter(loan_date__year=2022)
>>> loan = Loan.objects.filter(book_id__title='Don Quijote')
[Cuando es un campo con una relación busca en la tabla relacionada
hasta que encuentra la etiqueta en cuestión]

Comando para ver la consulta SQL

>>> book = Book.objects.filter(id__gt=5)
>>> book.query.__str__()
'SELECT "biblio_book"."id", "biblio_book"."title", "biblio_book"."author", "biblio_book"."genre_id", "biblio_book"."year", "biblio_book"."publisher_id" FROM "biblio_book" WHERE "biblio_book"."id" > 5'

• Abrir menú de usuario [arriba a la derecha]
  • Configuración de cuenta
    • Dinero, cuentas bancarias y tarjetas [Bajo hasta el final]
      • Pagos automáticos

Para poder utilizar una unidad externa realizaremos los siguientes pasos:

1. Instalar Bitcoin Core mediante Flatpak

$ flatpak install flathub org.bitcoincore.bitcoin-qt

2. Dar permiso a la aplicación para acceder a una carpeta del disco duro externo:

$ sudo flatpak override org.bitcoincore.bitcoin-qt --filesystem=/media/[user_name]/Blockchain/blockchain-fullnode

3. Lanzo la aplicación Flatpak con parámetros

$ flatpak run org.bitcoincore.bitcoin-qt --datadir=/media/[user_name]/Blockchain/blockchain-fullnode

4. [Opcional] Crear un lanzador en el Escritorio.