Questions[python]

Suppose I have the following string:

s = 'Pingüino: Málaga es una ciudad fantástica y en Logroño me pica el... moño'

For what it was, I want to remove all the tildes and umlauts so that it looks like:

s = 'Pinguino: Malaga es una ciudad fantastica y en Logroño me pica el... moño'
#        ^      ^                       ^

I have discovered the library unidecodethat does exactly this:

>>> unidecode.unidecode(s)
'Pinguino: Malaga es una ciudad fantastica y en Logrono me pica el... mono'

But unfortunately it also replaces the ñ with n ( Logroño → Logrono , moño → mono ).

Is there any other library that allows this substitution, changing only the accents and umlauts? Otherwise, I understand that what I have to do is a regular expression that does this modification.

It is common to find code with this form:

def hacer_algo():
    print("algo")

if __name__ == "__main__":
    hacer_algo()

Instead of, for example:

def hacer_algo():
    print("algo")

hacer_algo()

We also notice that the variable __name__is not initialized by us, but exists in the environment.

• What is the difference?
• Why prefer one over the other?
• What is it and how it works?

Playing around with Python, I have come across an error type takes 2 positional arguments but 3 were given. My method, which is inside a class, was of the form

def add(x, y):
    return x +y

I had just read the basic documentation on classes and was aware of the @classmethodand modifiers @staticmethod, which the documentation says are basically "syntactic sugar" . I also know that selfor clsare not reserved words, so it doesn't matter if my first parameter is called self, clsor x.

The error obtained makes me think that by default, the methods of a class are considered class methods (and the first argument is considered a reference to the class/instance) and if I want them to be static then I have to put the modifier, but not I've found nothing that explicitly states this in the documentation.

It may seem obvious, but for me it has been quite counterintuitive that if I declare

def saludar() :
   print("hola")

inside a class, the call will fail because the function has 0 parameters but we will try to pass one (implicit) with the call. Can someone confirm that methods are class defaults, as if they were annotated with @classmethod?

Imagine that for a game you have a class NaveEspacialin which players have the ability, among other things, to change the name of the ship after having created it:

class NaveEspacial:
    def __init__(self, nombre, capitan):
        self.nombre = nombre
        self.capitan = capitan

    def imprimir_datos(self):
        datos = {
            'nombre': self.nombre,
            'capitan': self.capitan
        }
        print datos

    def renombrar(self, nombre):
        self.nombre = nombre

nave = NaveEspacial('Death Star', 'Cesitar')
nave.renombrar('Millennium Falcon')
nave.imprimir_datos()

# Resultado
{'nombre': 'Death Star', 'capitan': 'Cesitar'}
{'nombre': 'Millennium Falcon', 'capitan': 'Cesitar'}

If you wanted to know how many times the ship's name has been changed, you could add a counter:

class NaveEspacial:
    def __init__(self, nombre, capitan):
        self.nombre = nombre
        self.capitan = capitan
        self.total_renombres = 0

    def imprimir_datos(self):
        datos = {
            'nombre': self.nombre,
            'capitan': self.capitan,
            'total_renombres': self.total_renombres
        }
        print datos

    def renombrar(self, nombre):
        self.nombre = nombre
        self.total_renombres += 1

nave = NaveEspacial('Death Star', 'Cesitar')
nave.imprimir_datos()
nave.renombrar('Millennium Falcon')
nave.imprimir_datos()

# Resultado
{'nombre': 'Death Star', 'capitan': 'Cesitar', 'total_renombres': 0}
{'nombre': 'Millennium Falcon', 'capitan': 'Cesitar', 'total_renombres': 1}

But the above would only help me know how many times each instance of the class, that is, each ship, has been renamed:

nave = NaveEspacial('Death Star', 'Cesitar')
nave.imprimir_datos()
nave.renombrar('Millennium Falcon')
nave.imprimir_datos()

nave = NaveEspacial('USS Enterprise', 'Fiorella')
nave.imprimir_datos()
nave.renombrar('USS Centaur')
nave.imprimir_datos()
nave.renombrar('USS Challenger')
nave.imprimir_datos()

# Resultado
{'nombre': 'Death Star', 'capitan': 'Cesitar', 'total_renombres': 0}
{'nombre': 'Millennium Falcon', 'capitan': 'Cesitar', 'total_renombres': 1}
{'nombre': 'USS Enterprise', 'capitan': 'Fiorella', 'total_renombres': 0}
{'nombre': 'USS Centaur', 'capitan': 'Fiorella', 'total_renombres': 1}
{'nombre': 'USS Challenger', 'capitan': 'Fiorella', 'total_renombres': 2}

What I need is to count the total calls to the class method and not the total for each instance . I know that one way could be to accumulate all the ships and add the attribute total_renombresof each one:

naves = [nave1, nave2, nave3]
total = sum([nave.total_renombres for nave in naves])

But I want to know if it's possible to do this at the class level, as some kind of persistent variable for the lifetime of the game. Is there a way to do it?

Note:

For now I want to keep it simple and avoid using Databases.

Update 1 (answer from @RuslanLópezCarro)

It is possible to get the total by creating a variable of the class, but that would mean having to manually increment the variable each time the method is called renombrar():

nave1 = NaveEspacial('Death Star', 'Cesitar')
nave1.renombrar('Millennium Falcon')
NaveEspacial.total_llamadas += 1 # Incrementar

nave2 = NaveEspacial('USS Enterprise', 'Fiorella')
nave2.renombrar('USS Centaur')
NaveEspacial.total_llamadas += 1 # Incrementar
nave2.renombrar('USS Challenger')
NaveEspacial.total_llamadas += 1 # Incrementar

nave3 = NaveEspacial('ABC', 'Tany')
nave3.renombrar('XYZ')
NaveEspacial.total_llamadas += 1 # Incrementar

print NaveEspacial.total_llamadas 

# Resultado 4

Which doesn't seem like an option to me, I want to do it automatically with each method call.

In some simple applications that I have had to write in C/C++ I have seen the ease with which certain tasks are solved using pointers . Now, more interested in another language: Python, I have noticed the absence of this concept. What is this absence due to? Being Python a very powerful and used language, then, what concept replaces it? Is it implicit in the data types, in the assignments, in the instantiation of a class?

An extremely simple example would be that in C we can code things like this:

#include <stdio.h>

int main(void) {
    // your code goes here
    int a = 5;
    int *b = &a;
    printf("a = %d; b = %d\n", a, *b); // (1)

    a = 6;
    printf("a = %d; b = %d\n", a, *b); // (2)
    return 0;
}

(1): a = 5; b = 5

(2): a = 6; b = 6

bpoints to the memory address of a, any modifications to acan be observed by dereference b. Any assignment by indirection will *b = <valor>;modify a.

But, in Python:

a = 5
b = a
print "a = {0:d}; b = {1:d}".format(a,b) # (1)
b is a # resultado: True

a = 6
print "a = {0:d}; b = {1:d}".format(a,b) # (2)
b is a # resultado: False

(1): a = 5; b = 5

(2): a = 6; b = 5

At the beginning aand brefer to the same object. Then when ait is modified a new object is created; so, both refer to different objects and of different values.

There isn't a way to do what C does in Python with this data type, but it is possible to do something similar with mutable data types; however, it is only possible when we make internal modifications of the mutable data, for example: changing the value of an element of a list.

a = [1, 2]
b = a

print b is a # resultado: True

b.append(3)

print b is a # resultado: True

a = [4, 5]

print b is a # resultado: False