Content

1 Data types in Python

Data types in Python

Types in Python are a representation of data because it does not require variables to declare their type, because all types are automatically converted

We can use the function type to know the type of a variable

Type boolean

The Boolean type simply distinguishes between two states, a success or enabled state, true value, True, and a failure or deactivated state, false value, False

Both states are not case sensitive

foo = True #assigns the value True to the variable foo

Typically, the result of operators that return a Boolean value are passed to the control structures

show_separators = True #declare the variable with a boolean

#this is not necessary...
if show_separators == True:
    print("<hr>\n")

#... because we can save code by writing:
if show_separators:
    print("<hr>\n")

print( type(show_separators) ) #will return <class 'bool'>

Numeric types

In Python there are 4 different types of numeric variables:

int
integer with fixed precision
long
integer if the size of an int is exceeded
float
double precision floating point number
complex
complex number (real part + j imaginary part)

integer = 1
print( type(integer) ) #will return <class 'int'> 

real = 1.23
print( type(real) ) #will return <class 'float'> 

complexn = 1 + 2j
print( type(complexn) ) #will return <class 'complex'>

It is the interpreter who decides the type of variable according to what we define

However, we may want to force it ourselves through a cast

integer = int(1)
print( type(integer) ) #will return <class 'int'> 

real = float(1.23)
print( type(real) ) #will return <class 'float'> 

complexn = complex(1 + 2j)
print( type(complexn) ) #will return <class 'complex'>

Type string

A string is a string of characters delimited by quotation marks

A string literal can be specified in two different ways:

single quote
are specified between the characters ‘ opening and ‘ closing

To specify a literal single quotation mark, you must escape with a backslash (\). To specify a literal backslash, it is duplicated (\\)

All other instances of backslashes will be treated as a literal backslash: this means that other escape sequences that could be used, such as \r o \n, will be displayed literally as specified, instead of having any other special meaning
```
print('This is a simple string')

#Result: Arnold once said: "I'll be back"
print('Arnold once said: "I'll be back"')

#Result: Has erased C:\*.*?
print('Has erased C:\\*.*?')

#Result: Has erased C\:*.*?
print('Has erased C:\*.*?')

#Result:
#This will expand:
#a new line
print('This will expand:\na new line')
```

double quotes

are specified between the characters " opening and " closing

Python will interpret the following escape sequences as special characters:

Code	Description
\n	line feed (LF or 0x0A (10) in ASCII)
\r	carriage return (CR or 0x0D (13) in ASCII)
\t	horizontal tab (HT or 0x09 (9) in ASCII)
\\	backslash
\"	double quotes

print("This is a simple string")

#Result: Arnold once said: "I'll be back"
print("Arnold once said: \"I'll be back"")

#Result: Has erased C:\*.*?
print("Has erased C:\\*.*?")

#Result: Has erased C\:*.*?
print("Has erased C:\*.*?")

#Result:
#This will expand:
#a new line
print("This will expand:\na new line")

Methods

Let's look at some of the most everyday methods for strings

Formatting methods

They affect the formatting of the text contained in the string

capitalize()
Make a copy of the string with the first letter in uppercase
lower()
Returns a copy of the string in lowercase
upper()
Returns a copy of the string in uppercase
swapcase()
Returns a copy of the string in which they are case-sensitive and vice versa
title()
Returns a copy of the string in which the first letter of each word is uppercase and the other lowercase letters
center(length, 'fill character')
Returns a copy of the input string centered on the specified length and between the specified fill character
ljust(length, 'fill character'): Returns a copy of the left aligned string
rjust(length, 'fill character')
Returns a copy of the left/right aligned string
zfill(length)
Returns a copy of the string filled with zeros to the left until it reaches the indicated length

invoice_number = 892
cad = 'i HavE A BLue hOUSE'

print( cad.capitalize() ) #return 'I have a blue house'
print( cad.lower() ) #return 'i have a blue house'
print( cad.upper() ) #return 'I HAVE A BLUE HOUSE'
print( cad.swapcase() ) #return 'I hAVe a blUE House'
print( cad.title() ) #return 'I Have A Blue House'
print( cad.center(40, '=') ) #return '==========i HavE A BLue hOUSE==========='
print( cad.capitalize().center(40, '=') ) #return '==========I have a blue house==========='
print( cad.rjust(40, '=') ) #return '=====================i HavE A BLue hOUSE'
print( str(invoice_number).zfill(12) ) #return '000000000892'

Search methods

They allow us to search within a certain string to check whether a substring is contained in the string or how many times a substring appears

count (‘substring’)
Returns an integer representing the number of occurrences of the substring within the string
find(‘substring’)
Returns an integer representing the position at which the substring begins within the string

cad = 'the general electIONS FOR THE presidenCY of the government are ON APRIL 28'

print( cad.count('the') ) #return 2
print( cad.lower().count('the') ) #return 3
print( cad.lower().find('elections') ) #return 13
print( cad.lower()[13:] ) #return 'elections for the presidency of the government are on april 28'
print( cad.lower()[cad.lower().find('elections'):] ) #return 'elections for the presidency of the government are on april 28'

Validation methods

They always give us back a boolean, that is, True or False

They serve to check if a chain meets a certain condition

startswith(‘substring’)
It tells us if a string starts with a certain string
endswith(‘substring’)
It tells us if a string ends up by a certain string
isalnum()
It tells us if a substring is alphanumeric
isalpha()
It tells us if a string is alphabetical
isdigit()
It tells us if a string is numeric
islower()
It tells us if a string contains only lowercase
isupper()
It tells us if a string contains only capital letters
isspace()
It tells us if a string contains only blanks
istitle()
It tells us if a string is formatted as a title

cad = 'the general electIONS FOR THE presidenCY of the government are ON APRIL 28'

print( cad.startswith('the') ) #return True
print( cad.endswith('the') ) #return False
print( cad.isalnum() ) #return False
print( cad.isalpha() ) #return False
print( cad.isdigit() ) #return False
print( cad.islower() ) #return False
print( cad.isupper() ) #return False
print( cad.isspace() ) #return False
print( cad.istitle() ) #return False

Substitution methods

They allow us to replace text to unify the format of different strings that have come to us in different ways

format(arguments)
We may have a chain that is prepared to receive a certain amount of arguments

Calling this function and entering the necessary arguments returns a copy of the already formatted string
replace('searched substring', 'substring to put')
Searches within the string for a substring and replaces it with the indicated string
strip()
Removes the character we specify from the right and left of the string

By default it looks for the space character
lstrip()
Removes characters to the left of a string

If we enter a substring as an argument, look for that substring and the combinations of the substring characters from the left until it finds no more
rstrip()
Removes characters to the right of a string

If we enter a substring as an argument, look for that substring and the combinations of the substring characters from the right until it finds no more

user = " pedro"
domain = "proveedor.net "
mail = user + "@" + domain

print( mail.replace("pedro", "juan") ) #shows ' juan@proveedor.net '
print( mail.strip() ) #shows 'pedro@proveedor.net'
print( mail.lstrip(user) ) #shows '@proveedor.net '
print( mail.rstrip(domain) ) #shows ' pedro@

Methods of union and division

They allow us to replace text to unify different strings that have come to us by different ways or to separate a string into several

join(iterable)
It receives as an argument an iterable and returns as a result the elements of the iterable joined by the character of the string on which it is applied
partition('separator')
Returns a 3 elements tuple

The first element is to the left of the 'separator', the second element is the separator, and the third element is to the right of the separator
split('separator')
Returns a list of all items found when splitting the string by the separator
splitlines()
Returns a list where each item is a fraction of the string divided into lines

character = ", "
lists =  ['bread', 'lettuce', 'tomatoes', 'pears', 'apples']
user = "pedro"
domain = "proveedor.net"
separator = "@"
mail = user + separator + domain
purchase = "bread, lettuce, tomatoes, pears, apples"

print( character.join(lists) ) #return "bread, lettuce, tomatoes, pears, apples"
print( mail.partition(separator) ) #return "('pedro', '@', 'proveedor.net')"
print( mail.partition(separator)[0] ) #return "pedro"
print( mail.partition(separator)[2] ) #return "proveedor.net"
print( purchase.split(character) ) #return "['bread', 'lettuce', 'tomatoes', 'pears', 'apples']"
print( purchase.splitlines() ) #return "['bread', 'lettuce', 'tomatoes', 'pears', 'apples']"

Lists

They are defined by putting the contents of the list in square brackets, separating each of the elements by a comma

Each item in the list can contain items of different types

The lists are mutable, that is, their elements can be modified

In Python, items in a list are numbered from 0 to length – 1

To access the item in a list, the name of the list is put and then the index that we want to access (if we put the index with a negative sign will start at the end of the list)

To access a range within a list we have different options:

Take items from the start: lista[:a]
Take items from position to (included) to end: lista[a:]
Take items from a to b (not including b): lista[a:b]

The start of the range always includes the element in that position, but not the end of the range

lists = [1, 2, 3, 4, 5, 6]

print( len(lists) ) #return 6, which is the length of the list
print( lists[0] ) #return 1
print( lists[-1] ) #return 6
print( lists[:2] ) #return [1, 2]
print( lists[2:] ) #return [3, 4, 5, 6]
print( lists[1:4] ) #return [2, 3, 4]

Methods

Let's look at some of the methods for most everyday lists

append()
adds an item to the bottom of the list
insert()
is used to insert an item into the assigned index
pop()
deletes and returns the value at the position of the assigned index
reverse()
reorders the list in reverse
sort()
rearrange the list in ascending order

my_list = [1, 3, 5, 4, 2]

print(my_list) #return [1, 3, 5, 4, 2]
my_list.append(6)
print(my_list) #return [1, 3, 5, 4, 2, 6]
my_list.insert(0, 8)
print(my_list) #return [8, 1, 3, 5, 4, 2, 6]
value = my_list.pop(0)
print(my_list, valor) #return [1, 3, 5, 4, 2, 6] 8
my_list.reverse()
print(my_list) #return [6, 2, 4, 5, 3, 1]
my_list.sort()
print(my_list) #return [1, 2, 3, 4, 5, 6]

We can find all the methods in your documentation

Tuples

Tuples are similar to lists, defined with parentheses instead of brackets

They have the peculiarity of being immutable

my_tuple = (1, 2, 3, 4, 5, 6)

print( len(my_tuple) ) #return 6, which is the length of the tuple
print( my_tuple[0] ) #return 1
print( my_tuple[-1] ) #return 6
print( my_tuple[:2] ) #return [1, 2]
print( my_tuple[2:] ) #return [3, 4, 5, 6]
print( my_tuple[1:4] ) #return [2, 3, 4]

As you can see, items are accessed in the same way as with lists

Dictionaries

Dictionaries define a one to one relationship between key value between {} and they're mutable

They are defined by placing a comma separated list of pairs key:value

Once defined, we can access the value associated with a key by searching by key

In addition, we can search whether or not a certain key exists in our dictionary

Dictionaries are a type of collection in Python that, unlike lists, are indexed by words and not by numbers

Values can be of any type

We can think of a dictionary as an unordered set of pairs key:value with the requirement that the keys have to be unique

dict = {
    'int':'Integer number',
    'float':'Real number',
    'complex':'Complex number'    
}

print( type(dict) ) #return <class 'dict'>
print( dict['int'] ) #return Integer number
print( 'int' in dict) #check if the key 'int' exists in the dictionary, return True
print( 'long' in dict) #check if the key 'long' exists in the dictionary, it return False

Methods

Let's look at some of the methods for more everyday dictionaries

keys()
returns us an iterable containing the dictionary keys
values()
returns us an iterable containing the dictionary values
items()
returns us an iterable with the pairs key:value of the dictionary

dict = {
    'int':'Integer number',
    'float':'Real number',
    'complex':'Complex number'    
}

print( dict.keys() ) #return dict_keys(['int', 'float', 'complex'])
print( dict.values() ) #return dict_values(['Integer number', 'Real number', 'Complex number'])
print( dict.items() ) #return dict_items([('int', 'Integer number'), ('float', 'Real number'), ('complex', 'Complex number')])

Objects

Objects consist of a set of values, properties, and a set of methods applied to those values

It is these methods that allow us to modify the state of that object, that is, the value of its properties

In Python, objects have the following characteristics:

Everything is an object, including types and classes
Allows multiple inheritance
There are no private methods or attributes
Attributes can be modified directly
Allows monkey patching

Classes are created at run time but can be modified after they are created
Allows duck typing

The dynamic typing style of data in which the current set of methods and properties determines the semantic validity, rather than inheritance of a class
Allows operator overload
Allows the creation of new data types

Let's create a academic sample object where you have the properties: Name, Surname, Age and Identity card

We'll create the object instance by mapping it to a variable as follows:

class Univers ():
     nom = ""
     surname = ""
     age = ""
     dni = ""

student = Univers () #The object instance

It is possible to query the class of an object with the function type, but you can also query through its special attribute __class__

print(student) #return <__ main __. Univers object at 0x054A01B0> which is a reference to the object
print( type(student) ) #return <class '__main __. Univers'>
print(student.__ class__) #return <class '__main __. Univers'>

[/tp”]

A su vez las clases tienen un atributo especial __name__ que nos devuelve su nombre en forma de cadena sin adornos:

print(Univers.__name__) #return Univers
print( type(student).__name__ ) #return Univers
print(student.__class__.__name__) #return Univers

You can initialize all variables to have the kind we want, we will use the class constructor passing the arguments we need

The constructor is a method that is called automatically when you create an object and is defined with the name __init__ and through the reserved word self we can reference to the current object

class Univers():
     nom = ""
     surname = ""
     age = ""
     dni = ""
    def __init__(self, nom, surname, age, dni):
        self.nom = nom
        self.surname = surname
        self.age =age
        self.dni = dni

student = Univers("Juan", "Delgado", 12, 44565789) #The object instance

If a constructor exists, there must also be a destructor that is called when deleting the object to handle cleanup tasks such as emptying the memory

All objects are automatically deleted from memory at the end of the program, although to remove them automatically we have the special method __del__

It is not advisable to overwrite this method because it is handled automatically, but it is interesting to know that it is possible

class Univers():
     nom = ""
     surname = ""
     age = ""
     dni = ""
    def __init__(self, nom, surname, age, dni):
        self.nom = nom
        self.surname = surname
        self.age =age
        self.dni = dni
    def __del__(self):
        print("Student %s is being erased from memory" %(self.nom) )

student = Univers("Juan", "Delgado", 12, 44565789) #The object instance
del(student) #erase the student from memory

The method __str__ is the one that returns the representation of an object in the form of a string

It is called automatically is when we print a variable per screen with the function print

By default the objects print their class and a memory address, but we can change it by overwriting their behavior

For example, for the university object we overwrite the method __str__ to show us the name, age, surname and dni

class Univers():
     nom = ""
     surname = ""
     age = ""
     dni = ""
    def __init__(self, nom, surname, age, dni):
        self.nom = nom
        self.surname = surname
        self.age =age
        self.dni = dni
    def __del__(self):
        print("Student %s is being erased from memory" %(self.nom) )
    def __str__(self):
       return f "Student: {self.nom} Surname: {self.surname} Age: {self.age} ID: {self.dni}"

student = Univers("Juan", "Delgado", 12, 44565789) #The object instance
print( str(student) ) #show Student: Juan Surname: Delgado Age: 12 ID: 44565789

An interesting special method is the one that returns the length

It is usually linked to collections, but nothing prevents it from defining it in a class and not redefining it, because by default it does not exist in objects even if it is the one that is executed when passed to the function __len__

In our example of the university object it doesn't make much sense to count its length, but I include it to show its use

class Univers():
     nom = ""
     surname = ""
     age = ""
     dni = ""
    def __init__(self, nom, surname, age, dni):
        self.nom = nom
        self.surname = surname
        self.age =age
        self.dni = dni
    def __del__(self):
        print("Student %s is being erased from memory" %(self.nom) )
    def __str__(self):
       return f "Student: {self.nom} Surname: {self.surname} Age: {self.age} ID: {self.dni}"
    def __len__(self):
       return 1

student = Univers("Juan", "Delgado", 12, 44565789) #The object instance
print( len(student) ) #show 1

The properties of an object can be described by other objects or even collections of them

class Note_M():
    course1 = 0.00
    course2 = 0.00
    course3 = 0.00
    final = 0.00
    def __init__(self,  course1, course2, course3, final):
        self.course1 = course1
        self.course2 = course2
        self.course3 = course3
        self.final = final

class Univers():
    nom = ""
    surname = ""
    age = ""
    dni = ""
    expedient = Note_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, surname, age, dni, expedient):
        self.nom = nom
        self.surname = surname
        self.age = age
        self.dni = dni
        self.expedient = expedient
    def __del__(self):
        print("Student %s is being erased from memory" %(self.nom) )
    def __str__(self):
       return f "Student: {self.nom} Surname: {self.surname} Age: {self.age} ID: {self.dni}"
    def __len__(self):
       return 1

note_mean = Note_M(6.5, 7.95, 8.12, 7.23) #The object instance
student = Univers("Juan", "Delgado", 12, 44565789, note_mean) #The object instance

The definition of methods associated with an object can be specified in the object definition

For example, for the university object we overwrite the method __str__ to show the student's first name, age, surname, dni and mean student's notes

To access the properties or methods we will use the operator .

class Note_M():
    course1 = 0.00
    course2 = 0.00
    course3 = 0.00
    final = 0.00
    def __init__(self,  course1, course2, course3, final):
        self.course1 = course1
        self.course2 = course2
        self.course3 = course3
        self.final = final

class Univers():
    nom = ""
    surname = ""
    age = ""
    dni = ""
    expedient = Note_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, surname, age, dni, expedient):
        self.nom = nom
        self.surname = surname
        self.age = age
        self.dni = dni
        self.expedient = expedient
    def __del__(self):
        print("Student %s is being erased from memory" %(self.nom) )
    def __str__(self):
       return f "Student: {self.nom} Surname: {self.surname} Age: {self.age} ID: {self.dni} Course1: {self.expedient.course1} Course2: {self.expedient.course2} Course3 : {self.expedient.course3} End: {self.expedient.final}"
    def __len__(self):
       return 1

note_mean = Note_M(6.5, 7.95, 8.12, 7.23) #The object instance
student = Univers("Juan", "Delgado", 12, 44565789, note_mean) #The object instance
print( str(student) ) #show Student: Juan Surname: Delgado Age: 12 DNI: 44565789 Course1: 6.5 Course2: 7.95 Course3: 8.12 End: 7.23

Inheritance

Inheritance is the ability of one class to inherit attributes and methods from another, something that allows us to reuse code

To see its usefulness, let's develop an example by modifying the university object

We will start from a base class that will be the father (superclass) of other daughters who inherited from it (subclasses)

We start from a class Person that will contain all the common attributes and two child classes Student and Teacher who inherit from it and have their own attributes or methods

To inherit the attributes and methods of one class in another, you just have to pass it in parentheses during its definition

It is possible to use the behavior of a superclass without defining anything in the subclass, although in our example we will give them behavior

class Person():
    nom = ""
    surname = ""
    age = ""
    dni = ""
    def __init__(self, surname, age, dni):
        self.nom = nom
        self.surname = surname
        self.age = age
        self.dni = dni
    def __str__(self):
       return f "Person: {self.nom} Surname: {self.surname} Age: {self.age} DNI: {self.dni}"

class Note_M():
    course1 = 0.00
    course2 = 0.00
    course3 = 0.00
    final = 0.00
    def __init__(self,  course1, course2, course3, final):
        self.course1 = course1
        self.course2 = course2
        self.course3 = course3
        self.final = final
    def __str__(self):
       return f "Course1: {self.course1} Course2: {self.course2} Course3: {self.course3} End: {self.final}"
        
class Student(Person):
    expedient = Note_M(0.00, 0.00, 0.00, 0.00)
    def __init__(self, nom, surname, age, dni, expedient):
        self.nom = nom
        self.surname = surname
        self.age = age
        self.dni = dni       
        self.expedient = expedient
    def __str__(self):
        return f "Student: {self.nom} Surname: {self.surname} Age: {self.age} DNI: {self.dni} str(self.expedient)}"

class Teacher(Person):
    subject = ""
    def __init__(self, nom, surname, age, dni, subject):
        self.nom = nom
        self.surname= surname
        self.age = age
        self.dni = dni       
        self.subject= subject
    def __str__(self):
        return f"Teacher: {self.nom} Surname: {self.apell} Age: {self.edad} DNI: {self.dni} Subject: {self.subject}"

note_mean = Note_M(6.5, 7.95, 8.12, 7.23) #The object instance
student = Student("Juan", "Delgado", 12, 44565789, note_mean) #The object instance
teacher = Teacher("Pedro", "Del Río", 38, 19587426, "Natural Sciences") #The object instance
print( str(student) ) #show Student: Juan Surname: Delgado Age: 12 DNI: 44565789 Course1: 6.5 Course2: 7.95 Course3: 8.12 Final: 7.23
print( str(teacher) ) #show Teacher: Pedro Surname: Del Río Age: 38 DNI: 19587426 Subject: Natural Sciences

Thanks to the flexibility of Python we can handle objects of different classes massively in a very simple way

Let's start by creating a list with our two People from different subclasses

persons = [student, teacher]
#Tour all the elements of the list with a for loop
for person in persons:
    print(person, "\n")
#Can also access attributes, as long as they are shared among all objects
for person in persons:
    print(person.nom, "\n")
#If an object does not have the attribute we want to access it will give us an error
for person in persons:
    #Using the isinstance () function we can check whether or not the attribute belongs to a specific object and avoid the error
    if( isinstance(person, Teacher) ):
        print(person.subject, "\n")

One of the few flaws in Python is that if we modify the values within an object, these changes will be reflected outside the same

Just as in collections, objects are passed to functions by reference

It affects when making copies, creating instead an access to the object instead of a new one with its previous values

To make a copy from its values we can use the function copy of the module with the same name

student = Student ("Juan", "Delgado", 12, 44565789, note_mean) #The instance of the original object
student2 = alumn
student2.nom = "Test"
print(astudent2 == student)  #Are they the same object? Yes, because it gives us True, the attribute nom should be the same in both objects

try:
    print(alumn.nom) #return 'Test'
    print(alumn2.nom) #return'Test'
except Exception as e:
    print(e)
    
student = Student ("Juan", "Delgado", 12, 44565789, note_mean) #reload the instance of the original object

from copy import copy

student2 = copy(student)
student2.nom = "Test"
print(student2 == student) #Are they the same object? No, because it return False, the attribute nom should be different in both objects

try:
     print(student.nom) #return 'Juan'
     print(student2.nom) #return 'Test'
except Exception as e:
     print (e)

The function copy can also be used to copy collections

from copy import copy

list1 = [1,2,3]
list2 = copy(list1)
list1 = None

print(list1) #return None
print(list2) #return [1, 2, 3]

Multiple inheritance allows a subclass to inherit from multiple superclasses

This involves a problem, which is that if multiple superclasses have the same attributes or methods, the subclass can only inherit from one of them

In addition to superclasses you can also inherit multiple subclasses

In these cases Python will prioritize the leftmost classes at the time of subclass declaration

class Teacher_Student(Teacher, Student):
    pass

note_mean = Note_M(6.5, 7.95, 8.12, 7.23) #The object instance
student = Student("Juan", "Delgado", 12, 44565789, note_mean) #The object instance
teacher = Teacher("Pedro", "Del Río", 38, 19587426, "Natural Sciences") #The object instance
teacher_student = Teacher_Student("Pedro", "Del Río", 38, 19587426, "Natural Sciences") #Will use Teacher as superclass
print(teacher_student) #show Teacher: Pedro Surname: Del Río Age: 38 DNI: 19587426 Subject: Natural Sciences
teacher_student = Teacher_Student("Pedro", "Del Río", 38, 19587426, note_mean) #Will use as superclass Student
print(teacher_student) #show Student: Juan Surname: Delgado Age: 12 DNI: 44565789 Course1: 6.5 Course2: 7.95 Course3: 8.12 Final: 7.23

We've used the reserved word pass to instruct the interpreter to ignore the body code and use the one in the class object or the superclasses (subclases) we tell you to

Null value

In Python variables can be assigned a value that indicates the empty value, this value is the value NULL

A variable is considered None if:

has been assigned the constant None
has not passed an attribute to a function

The constant None is insensitive to case sensitive

var = None

print(var) #return None

Cookie	Duration	Description
CookieLawInfoConsent	Until the end of the browser session	Controla la visualización del consentimiento de Cookies, su gestión y visualización en la página web por parte del usuario
qtrans_admin_language	Until the end of the browser session	Permite al administrador gestionar la traducción de la página web a varios idiomas
qtrans_edit_language	Until the end of the browser session	Permite al administrador editar la traducción de la página web a varios idiomas
viewed_cookie_policy	Until the end of the browser session	Controla si la visualización del consentimiento de Cookies es visible actualmente en la página web para el usuario o por el contrario está oculta

Secarcam's Computer Science Web

Data types in Python

Data types in Python

Type boolean

Numeric types

Type string

Methods

Formatting methods

Search methods

Validation methods

Substitution methods

Methods of union and division

Lists

Methods

Tuples

Dictionaries

Methods

Objects

Inheritance

Null value

Web page of Sergio Cárcamo Garcia dedicated to the computing and related topics such as programming languages, statistics, mathematics, etc

Data types in Python

Type boolean

Numeric types

Type string

Methods

Formatting methods

Search methods

Validation methods

Substitution methods

Methods of union and division

Lists

Methods

Tuples

Dictionaries

Methods

Objects

Inheritance

Null value

Web page of Sergio Cárcamo Garcia dedicated to the computing and related topics such as programming languages, statistics, mathematics, etc

Cookie policy