PySanti's Questions

PySanti

Asked: 2022-10-04 01:59:30 +0800 CST

Why is the HTML document.getElementsByTagName() method not working as expected?

1

Good, it turns out that I am doing some practices with HTMLand the method document.getElementsByTagNamedoes not work as I expect. This method is supposed to return a HTMLColletion, which despite not being an array, is iterable as one, however when I try to iterate the HTMLCollectionreturn, it gives me unexpected results, let's see:

Code:

 'use strict';
    let body = document.getElementsByTagName('body'); // por qué no funciona como se espera el getElementByTagName
    console.log(body)

-This code returns what could be expected...

Result:

HTMLCollection { length: 0 }

However, if I try to iterate it the following happens...

Code:

 'use strict'; let body = document.getElementsByTagName('body')[0]; 
 console.log(body)

Result:

null

On the other hand, if we iterate using the method .item(0), instead of returning nullreturns undefined. On the other hand, on the console, everything works as I expect. What is this behavior due to?

PySanti

Asked: 2022-08-11 04:23:13 +0800 CST

CSS position: absolute does not work as I expect

2

I just finished rendering an effect with HTML and CSS .

It is the following:

    .contenido > section 
    {
        background-color : rgb(16, 100, 16);
        border-radius: 20px;
        padding : 10px;
        margin-right : 200px;
        margin-left: 50px;
        margin-top : 100px;
        color : #fff;
        transition-property: box-shadow, background-color;
        transition-duration : .3s
    }
    
    
    .contenido > section:hover 
    {
        background-color : rgb(27, 110, 27);
        box-shadow : 0px 0px 5px 5px rgb(44, 138, 44);
    }
    
    
    
    section > h2
    {
        text-align : center;
    }
    
    /* ----------------------------------------------------- Universidades Section */
    
    
    .category_container
    {
        height              : 20em;
        margin              : 10px;
        padding             : 10px;
        border-radius       : 20px;
        overflow            : hidden;
        transition-property : height;
        transition-duration : .5s;
    }
    
    .category_name
    {
        background-color    : #0f0;
        position            : relative;
        text-align : center;
        display             : inline;
        border-radius       : 20px;
        padding             : 2em;
        border : 5px inset rgb(42, 206, 42);
        top                 : 45%;
        left                : 45%;
        color               : #000;
        transition-property: left;
        transition-duration : .5s;
    }
    
    .universities
    {
        display             : inline-flex;
        flex-direction      : column;
        align-items         : center;
        padding             : 2em;
        position            : relative;
        background-color    : #0f0;
        left                : 110%;
        border-radius       : 20px;
        transition-property :  left;
        transition-duration : .5s;
    }
    
    
    
    .universities > *
    {
        margin : 15px;
        padding : 10px;
        border-radius: 10px;
        color : #000;
        background-color : rgb(0, 255, 0);
        transition-property: background-color, transform;
        transition-duration : .3s;
    }
    
    .category_container:hover > .universities
    {
        left : 16em;
    }
    
    @media (max-width : 1500px)
    {
        .category_container:hover > .universities
        {
            left : 1em;
        }
    }
    
    .category_container:hover
    {
        height: 600px;
    }
    
    .category_container:hover > .category_name
    {
        left : -50%;
    }
    .universities > *:hover
    {
        background-color : rgb(47, 180, 47);
        transform : scale(1.1, 1.1)
    }
    
    
    
    /* ----------------------------------------------------- Universidades Section */

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <link rel="stylesheet" href="css.css">
        <title>Document</title>
    </head>
    <body>
        <div class="contenido">
            <!-- todo: terminar seleccion de universidades, refactorizar, estruxturar paginas de universidades -->
        
            <section id = "primeros_pasos_section">
                <h2> Primeros pasos </h2>
            </section>
        
            <section id = "universidades_section">
                <h2> Universidades </h2>
                <div class = "category_container">
                    <div class="category_name">
                        Top
                    </div>
                    <div class="universities">
                        <a href = "html_universidades/harvard.html"> Universidad de Harvard                  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/stanford.html"> Universidad de Stanford                 (Stanford, California)</a>
                        <a href = "html_universidades/mit.html"> Instituto Tecnológico de Massachusetts  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/california.html"> Universidad de California               (Berkeley, California)</a>
                        <a href = "html_universidades/michigan.html"> Universidad de Michigan                 (Ann Arbor, Míchigan)</a>
                        <a href = "html_universidades/washington.html"> Universidad de Washington               (Seattle, Washington)</a>
                    </div>
                </div>
                <div class = "category_container">
                    <div class="category_name">
                        Target
                    </div>
                    <div class="universities">
                        <a href = "html_universidades/harvard.html"> Universidad de Harvard                  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/stanford.html"> Universidad de Stanford                 (Stanford, California)</a>
                        <a href = "html_universidades/mit.html"> Instituto Tecnológico de Massachusetts  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/california.html"> Universidad de California               (Berkeley, California)</a>
                        <a href = "html_universidades/michigan.html"> Universidad de Michigan                 (Ann Arbor, Míchigan)</a>
                        <a href = "html_universidades/washington.html"> Universidad de Washington               (Seattle, Washington)</a>
                    </div>
                </div>
                <div class = "category_container">
                    <div class="category_name">
                        Safety
                    </div>
                    <div class="universities">
                        <a href = "html_universidades/harvard.html"> Universidad de Harvard                  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/stanford.html"> Universidad de Stanford                 (Stanford, California)</a>
                        <a href = "html_universidades/mit.html"> Instituto Tecnológico de Massachusetts  (Cambridge, Massachusetts)</a>
                        <a href = "html_universidades/california.html"> Universidad de California               (Berkeley, California)</a>
                        <a href = "html_universidades/michigan.html"> Universidad de Michigan                 (Ann Arbor, Míchigan)</a>
                        <a href = "html_universidades/washington.html"> Universidad de Washington               (Seattle, Washington)</a>
                    </div>
                </div>
            </section>
        
            <section id = "requisitos_generales_section">
                <h2> Requisitos generales </h2>
            </section>
            
        </div>
        
    </body>
    </html>

Well, the doubt comes in position: relativethe .universities.

It is assumed that when it positionis relativethe element is part of the flow, and when it is absoluteit stops doing so and, therefore, stops taking up space.

Well, the exact opposite happens here. When it is relative(that is, as I put it in the example) it is not part of the flow, and when it is absoluteit is. In fact, the page is scrollable when it .universitiesis "hidden" and its positionis absolute.

Why?

PySanti

Asked: 2022-07-20 13:50:16 +0800 CST

Destruction of automatic variables in C

6

In this forum question which I visited for a totally external problem to the aspect of this question, I saw an answer in which something quite interesting is mentioned (specifically the trauma response). In a part of the code of the user who asks the question (francesc), he returns the reference to a string in a function (or at least that was his intention) and the following is put in the answer...

Taking into account that rever is an automatic variable, whose lifetime is limited to the time it takes to execute your function, you will end up returning a pointer to a memory area that no longer contains what you expect.

This makes total sense, however, I started checking and something a bit unexpected happened...

code:

#include <stdio.h>
#include <stdlib.h>

char *cadena();


char *cadena(){
    char *cadena = "Hola";
    return cadena;
}

int main(){
    int arreglo[20];
    char *cadena2 = cadena();

    printf("%s", cadena2);
    return 0;
}

exit:

Hola

Basically even when the function returns the reference to an array that is supposed to no longer exist and also doesn't load into dynamic memory like it does in @trauma's answer, the string is returned normally... Bearing this in mind, The question would be: why is this happening? isn't the string return value supposed to die after the function has finished?

Regarding this, I have an assumption: when this type of allocation is actually made, the C compiler (in my case gcc 9.3.0, I'm on ubuntu at the moment) loads cadenainto dynamic memory and that is why there is still getting to the line 16.

Final edit: I've been doing a lot of testing and came to the following conclusion... Apparently, when arrays are created as 'raw' pointers, in functions, their value persists after function completion, otherwise it doesn't. .

Example 1:

code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int *arreglo();


int *arreglo(){
    int *array = (int *) calloc(sizeof(int), 2);
    array[0] = 1;
    array[1] = 2;
    printf("referencia a array desde funcion <main> %i\n", array);
    return array;
}

int main(){
    printf("referencia a array desde funcion <main> %i\n", arreglo());
    return 0;
}

exit:

referencia a array desde funcion <main> 642618016
referencia a array desde funcion <main> 642618016

example 2:

code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int *arreglo();


int *arreglo(){
    int array[2] ;
    array[0] = 1;
    array[1] = 2;
    printf("referencia a array desde funcion <main> %i\n", array);
    return array;
}

int main(){
    printf("referencia a array desde funcion <main> %i\n", arreglo());
    return 0;
}

exit:

referencia a array desde funcion <main> -258186320
referencia a array desde funcion <main> 0

Although I am checking this with examples, this may be working by many coincidences (unfortunately, this has already happened to me (^ _ ^) ), so it would be nice if someone who knew confirmed all this

PySanti

Asked: 2022-07-18 09:11:22 +0800 CST

Problem with buffer cleanup in C

-1

I was just reviewing Cand I was making a program, I had the problem that when reading data with fgets()it I had elements left in the standard input for the next reading when the character limit of the string was exceeded, this broke the program very easily. This of course is because it fgets()only takes the x elements of the input that it needs (where x is : fgets(cadena, x, stdin)), so if there are more than it needs, they will stay there. I created a solution, it is the following (also add doubly linked lists so that the elements that were left in the buffer would be seen) ...

#include <stdio.h>
#include <stdlib.h>
#define MAX_STR_LEN 5

// estructuras
typedef struct nodo {
    int element;
    struct nodo* siguiente; 
    struct nodo* anterior;
} nodo;
typedef struct lista {
    nodo *cabeza;
} lista;

// prototipos
void limpiar_buffer();
lista *crear_lista();
nodo *crear_nodo(int element);
void mostrar_lista(lista *lista);
void agregar_elemento(lista *lista,nodo *nuevo_nodo);
void vaciar_lista(lista *lista);
void eliminar_nodo(nodo *nodo_a_eliminar);


void limpiar_buffer(){
    char curr_char = getchar();
    lista *elementos_restantes = crear_lista();
    while ( curr_char != EOF && curr_char != '\n' ){
        agregar_elemento(elementos_restantes, crear_nodo(curr_char));
        curr_char = getchar();
    }
    mostrar_lista(elementos_restantes);
    vaciar_lista(elementos_restantes);
}


void eliminar_nodo(nodo *nodo_a_eliminar){
    nodo_a_eliminar->siguiente = nodo_a_eliminar->anterior =  NULL;
    free(nodo_a_eliminar);
}


void vaciar_lista(lista *lista){
    if ( lista->cabeza == NULL){
        // en caso de que no hayan elementos
        return;
    } else  if ( lista->cabeza->siguiente == NULL ){
        lista->cabeza = NULL;
    } else {
        nodo *nodo_actual = lista->cabeza;
        nodo *nodo_anterior, *nodo_eliminable;
        while ( nodo_actual->siguiente != NULL){
            nodo_anterior = nodo_actual;
            nodo_actual = nodo_actual->siguiente;
        }
        // llegamos hasta el final de la lista
        while ( nodo_anterior != NULL){
            nodo_eliminable = nodo_actual;
            nodo_anterior = nodo_anterior->anterior;
            nodo_actual = nodo_actual->anterior;
            free(nodo_eliminable);
        }
        // eliminamos todos los elementos menos la cabeza
        lista->cabeza = NULL;
    }
}

lista *crear_lista(){
    lista *nueva_lista = (lista *) malloc(sizeof(lista));
    nueva_lista->cabeza = NULL;
    return nueva_lista;
}

nodo *crear_nodo(int element){
    nodo *nuevo_nodo= (nodo *) malloc(sizeof(nodo));
    nuevo_nodo->element = element;
    nuevo_nodo->siguiente = nuevo_nodo->anterior =  NULL;
    return nuevo_nodo;
}
void mostrar_lista(lista *lista){
    if ( lista->cabeza == NULL ){
        return;
    } else {
        nodo *nodo_actual = lista->cabeza;
        printf("\n Elementos que quedaron en el buffer -> [ ");
        while ( nodo_actual != NULL ){
            if ( nodo_actual->siguiente != NULL ){
                printf("%c, ", nodo_actual->element);
            } else {
                printf("%c ", nodo_actual->element);
            }
            nodo_actual = nodo_actual->siguiente;
        }
        printf(" ]\n");
    }
}
void agregar_elemento(lista *lista,nodo *nuevo_nodo){
    if ( lista->cabeza == NULL ){
        lista->cabeza = nuevo_nodo;
        lista->cabeza->siguiente = NULL;
        lista->cabeza->anterior = NULL;
    } else {
        nodo *nodo_actual = lista->cabeza; 
        nodo *nodo_anterior;
        while ( nodo_actual != NULL ){
            nodo_anterior = nodo_actual;
            nodo_actual = nodo_actual->siguiente;
        }
        nodo_anterior->siguiente = nuevo_nodo;
        nodo_anterior->siguiente->anterior = nodo_anterior;
        nodo_anterior->siguiente->siguiente = NULL;
    }
}


int main(){
    char cadena[MAX_STR_LEN];
    while (1){
        printf("Introduce tu nombre completo -> ");
        fgets(cadena, MAX_STR_LEN, stdin);
        printf("Tu nombre completo es %s\n", cadena);
        limpiar_buffer();
    }
    return 0;
}

In case you have any suggestions for improving the code, I'm all ears. The problem is that when the character limit is not exceeded when reading ( MAX_STR_LEN), for some reason the program stops and you have to hit again to entercontinue... Any explanation? Obviously it has something to do with the function limpiar_bufferI use to run the cursor again at the end of the standard input... Thanks in advance :)

PySanti

Asked: 2022-06-12 08:34:36 +0800 CST

Mutability vs Immutability (Python)

0

Through this question, I would like to know what is the difference between mutability and immutability in Python, beyond the fact that some can be modified and others cannot . I pose the question for two reasons:

1-I am quite curious about the fact that some iterable objects in Python only support immutable objects (dictionaries, sets, etc...). I can come to understand in the case of dictionaries that it is for example so that the programmer does not accidentally change the key of some value, and subsequently does not know why he cannot access the dictionary, but what about sets, why don't support mutable objects?

2-In a part of the documentation , right at the beginning of the explanation of the dictionaries), it says the following...

The keys of a dictionary can be of almost any type. Values that are not hashable, such as values that contain lists, dictionaries, or other mutable types (that are compared by value, not by reference), cannot be used as keys."

This means that mutable objects are compared by value and not by reference, and immutable objects do exactly the opposite. And this makes sense when we look at Python's behavior in assigning values. When dealing with strings, Python checks if the value is in the internal string table , and we can see this in the following example:

>>> a = 'foo'
>>> b = 'foo'
>>> a is b
True

However, if we try it with any other data type, mutable or immutable, it doesn't work... (Note that in fact, when the strings are very long, the interpreter doesn't check the existence of underlying strings)

>>> a = 1
>>> b = 1
>>> a is b
True (ver modificacion)


>>> a = set([1])
>>> b = set([1])
>>> a is b
False

It's pretty clear that what happened to strings is due to pure chance (or that Python only searches for existing strings when the one being searched for is short??), since this only happens from time to time with strings and integers (see modification). The point is this: if immutable objects are compared by reference, why isn't there a larger reference passing system, in other words, why isn't the existence of underlying objects checked more often, precisely so that the comparison by reference be more exact .

Not to mention, that immutable objects are compared through references and not values, is not entirely clear...

>>> a = (1,2)
>>> b = (1,2)
>>> a == b
True
>>> a is b
False
>>> 


>>> a = frozenset([1,2])
>>> b = frozenset([1,2])
>>> a == b
True
>>> a is b
False

Finally, the question would be : what is the difference between the administration of mutable and immutable objects in Python, except that some can be modified and others cannot?

Modification: in the example of the integers, a is bsince the value 10is 'precreated' (like all numbers from -5 to 256), therefore when saying a = 10, ait will point to the 10one that already exists and the same happens with b, which generates that a is b( reference ).

PySanti

Asked: 2022-06-08 07:41:50 +0800 CST

How is it that extremely large numbers are stored in memory?

6

-The question is simple: how does Python store extremely large numbers in memory, in other words...

def factorial(n):
    facto = 1
    while n > 0:
        facto = facto*n
        n-=1
    return facto

print(factorial(100000000000000000000000000000000000000000000))

-How does this work? It is assumed that a number of such magnitude would never fit into a single memory space...

Clarification: I propose the example in Python, since it is the only language that I know that is capable of storing numbers that are too large, I have never managed to do something like that with C for example, in fact in C, using the data type more large (long double) it is not capable of storing a result of such magnitude. In the event that someone can make some code inCwhich a number like this is stored in memory, it would be pertinent to establish it as an answer

PySanti

Asked: 2022-06-05 12:59:54 +0800 CST

Why is it that the property decorator creates a class attribute? (Python)

0

-As the title implies, I already know how the decorator works property, it simply creates a class attribute and constantly updates it with the methods we define. However, I don't quite understand why it generates a class attribute and not an instance attribute, I consider this much worse... Obviously there is a reason for that, so the question would be: "what is the reason why property creates class attributes and not instance attributes"

Plot ...

class persona:
    def __init__(self, nombre, apellido):
        self.nombre = nombre
        self.apellido = apellido
    @property
    def nombre_completo(self):
        return self.nombre.capitalize() + ' ' + self.apellido.capitalize()
    @nombre_completo.setter
    def nombre_completo(self, nuevo_nombre):
        nombre,apellido = nuevo_nombre.split(' ')
        self.nombre = nombre
        self.apellido = apellido
    @nombre_completo.deleter
    def nombre_completo(self):
        del persona.nombre_completo

persona_nueva = persona('Juan', 'Peres')
print(persona_nueva.nombre_completo)
persona.nombre_completo = 'Nelson Martinez'
print(persona_nueva.nombre_completo)
print(persona.nombre_completo)
print(persona.__dict__['nombre_completo'])

PySanti

Asked: 2022-06-05 12:36:51 +0800 CST

Why doesn't this code work in python? (delete)

0

-I don't like to ask this type of questions, however I'm a bit short on time and I'm quite curious to know why a code as simple as this doesn't work...

class Persona:
    def __init__(self, nombre, apellido):
        self.nombre = nombre
        self.apellido = apellido
    @property
    def nombre_completo(self):
        return self.nombre.capitalize() + ' ' + self.apellido.capitalize()
    @nombre_completo.setter
    def nombre_completo(self, nuevo_nombre):
        nombre,apellido = nuevo_nombre.split(' ')
        self.nombre = nombre
        self.apellido = apellido
    @nombre_completo.deleter
    def nombre_completo(self):
        del self.nombre
        del self.apellido

persona_nueva = persona('Juan', 'Peres')
print(persona_nueva.nombre_completo)
persona.nombre_completo = 'Nelson Martinez'
print(persona_nueva.nombre_completo)
del persona_nueva.nombre_completo

-Returns (at least on my machine with windows 10 and python 3.9.5) AttributeError, it is due to a problem in deleterwhich I cannot identify...

PySanti

Asked: 2022-06-04 09:44:41 +0800 CST

What is indirection in multiple inheritance in Python?

4

-I was reading an article (https://rhettinger.wordpress.com/2011/05/26/super-considered-super/)about the function super()for multiple inheritance in Python. It caught my attention because, literally in the first line, it says that if you are not amazed with how it works, it means that you do not know it well. The point is that you mention that the main advantage of using this closest parent reference class is that, unlike referencing the parent class directly, it does an undirected lookup, which is supposed to be better. First I have to say that I do not speak English 100% which is partly to blame for this question. On the other hand, the question would finally be: why is it better to reference a parent class through super(), that is...

class persona:
    def __init__(self, nombre, apellido, edad, sexo):
        self.nombre = nombre
        self.apellido = apellido
        self.sexo = sexo
        self.edad = edad

class empleado(persona):
    def __init__(self, nombre, apellido, edad, sexo, salario):
        super().__init__(nombre, apellido,edad, sexo)
        self.salario = salario

-Instead of referencing the parent class through the reference itself...

class persona:
    def __init__(self, nombre, apellido, edad, sexo):
        self.nombre = nombre
        self.apellido = apellido
        self.sexo = sexo
        self.edad = edad

class empleado(persona):
    def __init__(self, nombre, apellido, edad, sexo, salario):
        persona.__init__(self,nombre, apellido,edad, sexo)
        self.salario = salario

PySanti

Asked: 2022-05-23 05:33:01 +0800 CST

How to split a relatively large program without stacking function calls?

0

-Although the question can apply to any language, I will set my examples in Python. Well, the question would be: how to prevent function calls from stacking and at the same time divide the program into parts, that is...

def hacer_algo():
    print('Acabas de hacer algo')
def hacer_otra_cosa():
    print('Acabas de hacer otra cosa')
def menu_inicial():
    print("""
    1) Hacer algo
    2) Hacer otra cosa
    3) Salir
    """) 
    eleccion = int(input('-> '))
    if eleccion == 1:
        hacer_algo()
        menu_inicial()
    elif eleccion == 2:
        hacer_otra_cosa()
        menu_inicial()
    elif eleccion == 3:
        quit()

menu_inicial()

-Well, we can quickly realize that if we use this script for a while, the calls to the function would be massively stacked, in fact, this can be seen if, after a while, we force the program to exit (cntrl + c )...

File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 21, in <module>
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 14, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 17, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 14, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 17, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 14, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 17, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 14, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 17, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 14, in menu_inicial
    menu_inicial()
  File "/home/santiago/Escritorio/Programacion/Bloque de estudio de Python/Sintaxis Basica/Practicas/Base de datos Buena/pruebas2.py", line 11, in menu_inicial
    eleccion = int(input('-> '))
KeyboardInterrupt

-What is happening here is that, when calling a function inside another, the first one never ends, causing the calls to the function to 'stack', well, this is obviously an optimization problem that I don't know how to fix , for example, it is usually of interest to me that, once an option is selected, the program returns to menu_inicial(), however, applying this methodology the calls to the function would be stacked, generating an optimization problem, but at the same time the use of gotoobviously does not is an option ... Any suggestion ?

PySanti

Asked: 2022-05-21 06:05:52 +0800 CST

How to symbolize arrows in (Python)

1

-I know that the title can be a bit confusing, therefore, to be able to establish my doubt, I leave this code...

windows...

import msvcrt
while True:
    print(msvcrt.getch())

Linux

import getch
while True:
    print(getch.getch())

-If you don't have the module, it doesn't matter, basically what the code does is print what the user enters on the screen (without the need for the user to press enter). When I discovered this, a sea of possibilities opened up for me (I'm still a novice), but to date, I have not been able to know if the user presses an arrow, based on this premise, the question would be: how to symbolize the arrows to be able to do something like this...

while True: 
    entrada = getch.getch()
    if entrada == flecha_derecha:
        print('Presionaste la flecha derecha')
    elif entrada == flecha_izquierda:
        print('Presionaste la flecha izquierda')
   ...

-I know this could be emulated if I just interpreted other keys as arrows (in fact, I made a pretty simple module to print 'interactive' menus, if you want to see it: https://github.com/PySanti/modulos-de -python , I would really appreciate an opinion on what could be improved ), however, it doesn't seem so comfortable to me, and the doubt is eating my soul

PySanti

Asked: 2022-05-18 13:30:01 +0800 CST

What are classes really (Python)?

14

-Until recently I believed that classes were 'molds' that were used to create objects; however, this question ( Why can't you delete methods in python? ) made me question a few things. What is said in the most voted answer is that, in short, you can delete methods since, just like anything else, methods (without parentheses) are basically pointers that store the reference ('point') to the method code that loads into RAM. In other words: they are attributes of all life except that, in this case, they point to code and not to normal data, therefore when using the reserved worddelwhat we do is eliminate the references that pointer saves, which translates into 'cutting' the 'link' that pointer has with the variable(s) to which it points (from what I also understand can save multiple references, it would be the same as what would happen with lists for example, at least that's how it works in Cand I guess it will be the same as what happens in python (if not, please comment) therefore we can no longer access nothing through it, since it no longer points anywhere...

So far so good, the question begins when it is mentioned that objects inherit from the classes from which they are instantiated, it is for the same reason that a method cannot be eliminated through an object, since that method is not yours but of your class , this makes a lot of sense, since (as you can see in the post) starting from that premise everything works.

-With which, the question would be the following: Are the classes really ' molds '? What actually happens when we create and instantiate an object from a class? (removing all the abstraction layers, which is what actually happens in RAM)

PLOT

-I understood the following...

class persona:
    def __init__(self, nombre, apellido, edad, sexo) -> None:
        self.nombre = nombre
        self.apellido = apellido
        self.edad = edad
        self.sexo = sexo

persona_nueva = persona('Jhon','Doe', 33, 'h')

-In this case, it persona_nuevawould then be a pointer that would store the reference to an object (in this case we can understand an object as a set of pointers), therefore, execute ...

print(persona_nueva.nombre)

-It would be like saying to persona_nueva(apart from the participation of _ _ str _ _): 'pass printthe value of the place where the pointer you are pointing to points to, that nombre' (this would be more or less the structure that is shape in my head)

                ____-nombre -> 'Jhon'
               /    -apellido -> 'Doe'
 persona_nueva      -edad -> 33
                    -sexo -> 'h'

already persona_nueva agreed to nombre...

persona_nueva.nombre -> print

It's for the same reason that it del persona_nueva.nombreworks (at least on my machine), as it would be equivalent to...

                ____-nombre -> 'Jhon'
               \    -apellido -> 'Doe'
 persona_nueva      -edad -> 33
                    -sexo -> 'h'

and therefore ...

                    -apellido -> 'Doe'
 persona_nueva      -edad -> 33
                    -sexo -> 'h'

-Well, the case is that if it were a method (that is, if the name, for example, were a method) and therefore...

                    -nombre -> nombre()
                    -apellido -> 'Doe'
 persona_nueva      -edad -> 33
                    -sexo -> 'h'

In this case, it could not be executed anymore del persona_nueva.nombre... This is basically what I asked in (Why can't you delete methods in python?), in response I was told that it is because technically, the attributes are not of persona_nueva(object ) but of its class persona, but if this is the case, why can I remove attributes (use del) from persona_nuevait and not methods, these having the same behavior. Most likely it's because I don't know what a class is, hence the question...

PySanti

Asked: 2022-05-18 08:14:32 +0800 CST

Why can't you remove methods in python?

3

-The question would be the following: why can't the methods be eliminated through the use of the keyworddel

-In the case of decorating them with a deleter, it would not be the same, since in such cases the objects to which the method decorated with is relative would be eliminated @property, not the method itself

-Let's remember that after all, functions are (just like everything in python) objects, pointers that point to variables, in this case, said variables would be the code block that loads into RAM, for example...

  def saludo():
      print('Hola como estamos por aca? ')

-In this case saludoitself, without the use of the dunder __call__(that is, without calling the parentheses), it is a pointer that points to saludo(), it is for the same reason as with these if we can use the keyword delwithout errors, since (if I'm not wrong, it's what my intuition tells me, if you have reasons to say that I'm wrong about something, please say so), what it does delis basically make saludo(as a pointer) point to None. And therein lies the question, because if functions and methods are basically the same, they cannot be removed as easily.

-Note that deleting a method given that it is decorated with a deletter, does not enter into my perception of deletion, since, as I mentioned at the beginning, in such cases the attributes to which that method is relative would be deleted, not the method itself.

PySanti

Asked: 2022-05-11 08:31:40 +0800 CST

Is there a way to create dunder methods in Python? [closed]

-1

-The dunder methods (special methods, magic methods, etc... methods of the form _ _ method _ _ ) are basically responsible for the huge amount of syntactic sugar that Python presents, which is largely what makes the language is so simple, because with the title I do not mean to use them and therefore overwrite them, but to create them from 0 no matter how difficult it may be, if this is not possible, I would like you to clarify why...

Why is the HTML document.getElementsByTagName() method not working as expected?

CSS position: absolute does not work as I expect

Destruction of automatic variables in C

Problem with buffer cleanup in C

Mutability vs Immutability (Python)

How is it that extremely large numbers are stored in memory?

Why is it that the property decorator creates a class attribute? (Python)

Why doesn't this code work in python? (delete)

What is indirection in multiple inheritance in Python?

How to split a relatively large program without stacking function calls?

How to symbolize arrows in (Python)

What are classes really (Python)?

Why can't you remove methods in python?

Is there a way to create dunder methods in Python? [closed]

HTML button that sends you to another page

Why do I get the error "Call to undefined function mysql_connect()"?

How to create an HTML button that works as a link?

How to separate a String in Java. How to use split()

Filter by dates in sql server

How to limit the number of decimal places in a double?

For each in JavaScript?

Position footer ALWAYS glued to the footer

Definitive Guide to Type Conversion in Java

How to properly compare Strings (and objects) in Java?

PySanti's questions