Python

Python is a widely used programming language currently in Data Science and Big Data related environments

Its use in libraries created by Google and other tech giants has made it one of the most widely used languages

Within programming languages, its features are:

• Interpreted

  The compilation process is the translation process of the programming language that we are using (e.g. C++) to machine code that the computer can run

  In addition, this process creates an executable file that can be used on other computers

  There are programming languages that do not use a compiling process but an interpreter, which adds meaning to scheduled statements

  Python is an interpreted language

• Dynamic typing

  Typing a programming language is the language's way of managing variables and their types

  Usually, in a programming language you can create variables of different types (whole number, actual number, character, lists...)

  There are languages in which before we can use a variable we have to define it and assign it a specific type of variable

  In a non-formal language it would be something like: I want an entire variable called Brothers and Assigns the home variable the value 3

  However, in Python you don't need to make this mapping, because it's a dynamic typed language, and you generally don't need to define a variable before you can use it

  In Python we would write directly The variable brothers has a value of 2 and it would be the interpreter who would see that we want to use a variable that does not exist, with the name Brothers and assign the value 2

• Multi paradigm

  There are several ways to program; with object oriented programming as functional programming

  Python admits both types

• Multi platform

  There are Python interpreters for multiple platforms, such as MS Windows, Mac OS or Linux

Both the Python interpreter and its extensive standard library are freely available in the form of source code and executable file for major platforms from the Python

Behind Python there is a large community that provides extensive support while constantly developing and updating a centralized library array in a repository called Pypi

There is also a code of good programming practices in Python as well as a style guide, so that the code is easy to read and understand

Installing and using Python modes

Python can be installed on our computer from the Python page (recommended to install the latest version of Python)

However, it is more convenient to install using a distribution such as Anaconda, which downloads the interpreter, different editors and the most used packages and libraries

To install this distribution we would have to:

1. Go to the downloads page Anaconda and download the package that fits your desired operating system and Python version

   It is recommended to install the one corresponding to the most current version of Python

2. Run the package and let it install completely on the system

3. After installation it would be advisable to update the packages

   To do this open a terminal and run:

   conda update --all

   It will display a list of libraries to be updated

   If you agree, accept and start downloading and installing the libraries

4. In the case of wanting to install a specific library, in the terminal we will run:

   conda install <library_name>

   You will install the latest version of the library present in the Anaconda repository that corresponds to our operating system and our version of Python

In case it is not present in the repositories, we can optionally install the libraries with pip

To do this open a terminal and run:

python -m pip install --upgrade pip
python -m pip install anaconda

For more information, see the Anaconda documentation

The fastest way to use Python is by using command line

Once we have an interpreter installed on our computer, we would open a terminal and write

python

This opens a console on which we can write and run Python code

Each line we executed would perform the requested operation

It's a very quick way to test code but it's very impractical, as we lose the reuse of executed code

That is, if we wanted to run it again, we would have to write the code line by line again

The most common thing is to use an editor as a Spyder (installs next to Anaconda) the Jupyter notebooks, which is the one I'm going to use for the examples

Jupyter Notebook

Jupyter Notebook (formerly IPython Notebook) is an open source web application that lets you create and share documents that contain live code, equations, visualizations, and narrative text

In addition, it is a widely used application in the field of Data Science to create and share documents that include: data cleansing and transformation, numerical simulation, statistical modeling, data visualization, machine learning and much more

It allows you to edit and run notebook documents through any web browser of your choice; and can run on a local desktop that does not require Internet access or can be installed on a remote server and accessed over the Internet

We can also execute Jupyter Notebook without any installation from the project's website

Or install it using pip, open a terminal and run:

python -m pip install --upgrade pip
python -m pip install jupyterlab

Use Jupyter Notebook

Once we have it installed, we will open a terminal and run:

jupyter notebook

This will print some information about the notebook server in our terminal, including the web application URL (by default, http://localhost:8888)

In case you need to know the path where we have Jupyter installed, we can run in the terminal:

where jupyter

In case you need to know the version of Python that we have installed, we can run in the terminal:

python -V

Before running this one-line command, it is recommended that we verify that our Anaconda PATH directory has been successfully added to the Environment Variables, and if not, we should locate our Anaconda directory/file path and add it to the Environment Variables, or if you could not get an error:

jupyter is not recognized as an internal or external command

If the launch has worked properly, our default browser will open with the Notebook open on port 8888

Once inside the Notebook, we will see a button called New which, when clicked, allows us to select a Python kernel (the options depend on what is installed on our local server) from the drop-down menu

It is recommended to select the latest version of Python that appears in the drop-down, unless you need to use another version for compatibility reasons

Once selected and accepted, we will open our first notebook to write our programs in Python

Our first Python script

Let's write a small sample script to show how simple it is to run a Python script from Jupyter

Python has a defined storage system and variable management

In variables we can save information that we want to use later in the code with a name that is easy for us to remember

In our example, we want to calculate the area and volume of a sphere

The equations we need are:

• A = 4\pi \cdot r^2 for the area
• V = \frac{4}{3}\pi \cdot r^3 for the volume

Specifically, we want to calculate these values for a 7 radio sphere

Let's define three variables:

• r

  It contains the radius value, in this case 7

• A

  Contains the value of the calculated area

• V

  Contains the value of the calculated volume

What advantages do we get by defining variables?

If we change our minds and instead of a radio 7 we want it to be 6, we would have to change the number of two sites (which in the case of a program in production could be hundreds)

Or we want the user to indicate the value, so we can't know a priori

To write it in Python we will use a cell of the notebook to which we will assign it in the drop-down menu (we will see it to the left of the icon that looks like a keyboard) the Code value

Once inside the cell, we will use it as a text editor by typing:

import math

r = 6
A = 4 * math.pi * r ** 2
V = 4 / 3 * math.pi * r ** 3

To run it we can use the run button or by leaving the uppercase key and then pressing enter

The result of the variables will remain in memory, but we won't be able to see it

Now let's use the print function (similar to the C++ function) to be able to see the result of our Python script

In order to use the constant Pi, the math module has been imported with the statement import math and then we've used it with math.pi

As you can see, to define a variable we write the name with which we want to baptize it, the sign and the expression that we want to be assigned to that variable

import math

r = 6
A = 4 * math.pi * r ** 2
V = 4 / 3 * math.pi * r ** 3

print("The radius was %d" %(r) )
print("The area of the sphere was %f" %(A) )
print("The surface of the sphere was %f" %(V) )

Comments on Python

Python supports Unix Shell commentary

print("Test") #Unix Shell comment

Operators in Python

Python has arithmetic, relational, logical, bit by bit, assignment, membership, and identity operators

Arithmetic operators

Python supplies basic operations with the only additions of the remaining operators, whole quotient and exponentiation

Note In Python, using the + operator applied to strings concatenates both strings into a single

a = 5
b = 3

sum = a + b #addition example
print(sum) #will return 8

subt = a - b #subtraction example
print(subt) #will return 2

mult = a * b #multiplication example
print(mult) #will return 15

div = a / b #division example
print(div) #will return 1.6667
#Keep in mind that there is no data typing and it will return a float value by default

rest = a % b #rest of division example
print(rest) #will return 2

quot = a // b #integer quotient example
print(quot) #will return 1

expo = a ** b #exponentiation example
print(expo) #will return 125

Relational operators

Are used typically in the conditional expression

The relational operators return boolean values

The operands can be numerical or strings

Objects of different types, except numeric types, are never compared the same

The operator == it is always defined, but for some types of objects (for example, class objects) it is equivalent to is

Non identical instances of a class are typically compared as non equal unless the class defines the method __eq__()

Instances of a class cannot be sorted with respect to other instances of the same class or other object types, unless the class defines the methods __lt__() and __gt__()

a = 20
b = 30
c = '20'

if a > b:
   print("a is greater than b") #example of major, the types are not taken into account
#in this case it will not show the message for being false
if a > c:
   print("a is greater than c") #example of major, the types are taken into account
#in this case it will not show the message because it is false since it is of different types
if a < b:
   print("a is less than b") #example of minor, types are not taken into account
#in this case it will show the message for being true
if a < c:
   print("a is less than c") #example of minor, it takes into account the types
#in this case it will not show the message because it is false since it is of different types
if a >= b:
   print("a is greater than or equal to b") #example of greater than or equal, the types are not taken into account
#in this case it will not show the message for being false
if a >= c:
   print("a is greater than or equal to c") #example of greater than or equal, the types are taken into account
#in this case it will not show the message because it is false since it is of different types
if a <= b:
   print("a is less than or equal to b") #example of less than or equal, the types are not taken into account
#in this case it will not show the message for being false
if a <= c:
   print("a is less than or equal to c") #example of less than or equal, the types are taken into account
#in this case it will not show the message because it is false since it is of different types
if a != b:
   print("a is different from b") #different example, the types are not taken into account
#in this case it will show the message for being true
if a != c:
   print("a is different from c"); #different example, it takes into account the types
#in this case it will not show the message because it is false since it is of different types
if a == b:
   print("a is the same as b") #example of equal, the types are not taken into account
#in this case it will not show the message for being false
if a == c:
   print("a is the same as c") #example of equal, the types are taken into account
#in this case it will not show the message because it is false since it is of different types

Logical operators

The logical operands is related to the relational as they are normally the operands used are the result of expressions in relational

The resulting values are boolean

a = True
b = False

if a AND b:
    print("a and b are the two true")
else:
    print("a or b are false, or both are false")

if a OR b:
    print("a or b are true, or both are true")
else:
    print("They are both false")

if NOT a:
    print("It was false")
else:
    print("It was true")

Bitwise operators

The way of working of these operators is to convert to the binary operands and then operate with them bitwise

Note Propagation operators take two operands: the first is the variable to propagate and the second is the number of positions to propagate

a = 4 #in binary is 0100
b = 5 #in binary is 0101

c = a & b #AND example
print(c) #will return the value 4 in binary is  0100

c = a | b #OR example
print(c) #will return the value 5 in binary is 0101

c = a ^ b #XOR example
print(c) #will return the value 1 in binary is 0001

c = a << b #left spread example
print(c) #will return the value 128 in binary is ‭1000 0000‬

c = a >> b #right spread example
print(c) #will return the value 0 in binary is 0000

a = ~a #NOT example
print(a) #will return the value -5 in binary is -0101

c = a << b; #propagation to the left of a negative number example
print(c) #will return the value -160 in binary is -0101 0000

c = a >> b; #propagation to the right of a negative number example
print(c) #will return the value -1 in binary is -0001

Assignment operators

The assignment is also an operator that returns the variable modified

The mapping operator in Python is =

The assignment operators shown below are but abbreviations that make expressions more comfortable and simple, even if they are sometimes more unreadable

Membership operators

Membership operators are used to check whether a value or variable is in a sequence (list, tuple, dict, set or str)

lists = [1, 3, 2, 7, 9, 8, 6]

if 4 in lists:
    print("4 was on the list")
else:
    print("4 was not on the list")

if 5 not in lists:
    print("5 was not on the list")
else:
    print("5 was on the list")

Identity operators

These operators will be used to check whether or not two variables are the same object

x = 5
lists = [1, 5]

if x is lists:
    print("x same as list") #won't show it because x doesn't have the same reference as lists
else:
    print("x not the same as list") #will show it because x does not have the same reference as lists

if x is not lists[1]:
    print("x not the same as list") #will not display it because x has the same reference as the element contained in lists[1]
else:
    print("x same as list") #will display it because x has the same reference as the element contained in lists[1]

Preference

The operator precedence will determine the order in which they are running in a given expression

Using parentheses will check that the operations are carried out according to us we want to

In Python, the preference for operators from highest to lowest is as follows:

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

Control structures in Python

For control structures, Python possesses the control statements typical of high-level languages

Variable statement

Variables in Python are not assigned a predefined type

In Python the type of variables depends on the value they contain at all times

Therefore it performs an automatic conversion of types

Python recognizes the following types of values:

• Numbers
• Boolean values

  true and false

• Strings
• Lists

  data type that associates values with a numeric value by putting the contents of the list in square brackets, separating each of the elements by a comma

• Tuples

  data type that associates values with a numeric value by putting the contents of the list in parentheses, separating each of the elements by a comma

  They have the peculiarity of being immutable

• Dictionaries

  type of data that associates a value with a key and allows you to search for those keys

• Objects

  Created by the programmer or pre-defined by the language

As it is a language with dynamic typing, it is not necessary to tell the interpreter its type of variable, but it is he who decides the type that will assign

The names with which we can name variables in Python follow several rules:

• Names always start by letter
• Within the name you can use any letter or number within the utf-8 encoding

• Python reserved words, which are used in your code syntax, cannot be used

  For more information on these names, see the Python documentation

Note that Python is case sensitive, so two variables with the same name but containing an uppercase letter will be understood as two distinct variables

For example Variable is different of variable

There are also certain conventions to reduce errors and improve readability

To avoid errors it is recommended not to use certain characters:

• Do not use neither l (l lowercase) neither I (i uppercase), because depending on the type of font used they may be confused with each other or the number 1
• Do not use Or (o uppercase) because depending on the type of font used it may lead to confusion with the number 0

In order to promote readability, the following suggestions are made:

• variablename is unreadable, because it's all together and can make it difficult to read
• variableName is a little more readable, when applying uppercase letter when starting word
• variable_name is the one that brings the best readability, when applying underscore at word start, which is the most recommended way

The if sentence

The if sentence has the form:

if Condition:
    Instruction 1 or instruction block
[else:
    Instruction 2 or instruction block
]

If the condition is true, instruction 1 will be executed; otherwise it is executed if there is instructution 2

The use of the sentence else is optional, so brackets have been used in the definition

If omitted, the instruction block will only be considered when the condition is true

An instruction block is a set of tab statements after the statement if, when jumping from line after the symbol :

if Condition:
    Instruction 1
    Instruction 2
    ...
    Instruction N
}

They are mandatory as they tell the interpreter that the instruction block belongs to the sentence if

If omitted and the condition was true, the following instruction will be executed

Otherwise, the subsequent instruction will be executed, independent of the condition state

In this way, the omission of tabulations after the sentence if will allow us to write everything on a single line after the symbol :

if Condition: if instruction
Subsequent Instruction

The elif sentence

We can also use sentences if anities by sentencing elif

Sentences elif work just like a sentence if

But they will only be executed in case the condition of the sentence if was false

We can optionally add a statement else in the end but will only be executed if all the above conditions were false

if Condition:
    if statement block
[elif Condition:
    elif instruction block
]
[else:
    else instruction block
]

The while sentence

The while sentence has the form

while Condition:
    Instruction or instruction block

If the condition is met, the sentence or instruction block is executed and the process is repeated until the condition is no longer met

The for sentence

This loop has a syntax very similar to the for-each Java

Iterates a variable var over all the properties of an object obj that is passed to it

Thus, for each value of var is is executed, the judgments of the loop

Therefore, the loop will have as many iterations as the object's properties, and in each iteration the variable will have the value of the corresponding object's property with that iteration

Its syntax is:

for var in obj:
    Instruction or instruction block

Iterators

In Python there are different structures that are sets of elements, they are called collections

These types of structures are iterable, that is, they can be traversed element by element

Some variable types that are iterable are:

• Character string (str)
• List (list)
• Tuple (tuple)
• Dictionary (dict)

Its use is useful for traversing collection items such as lists, tuples, or objects

#character string traversal example
cad = "string"

for c in cad:
    print(c)
#show
#s
#t
#r
#i
#n
#g

#list tour example
lists = [10, 2, 3, 8, 9, 1]

for i in lists:
    if i > 5:
        print(i)
#show
#10
#8
#9

#tuple tour example
tupla = (10, 2, 3, 8, 9, 1)

for i in tupla:
    if i > 5:
        print(i)
#show
#10
#8
#9

#dictionary tour example
cities = {
    'Madrid': 3223334,
    'Valencia': 791413,
    'Zaragoza':666880,
    'Sevilla':688711,
    'Barcelona':1620343,
    'Test':1620343
}

for key in cities:
    print ('%s: %s' %(key, cities[key]) )
#show
#Madrid: 3223334
#Valencia: 791413
#Zaragoza: 666880
#Sevilla: 688711
#Barcelona: 1620343
#Test: 1620343

In addition, many times we want to repeat a loop a certain number of times

The function of this can be useful for this range(n)

This function generates an iterable ranging from 0 to n – 1

for i in range(3):
    print(i)
#show
#0
#1
#2

The break sentence

The break sentence can be placed within a loop or anities loops

When you execute the break sentence exits the loop more internal

To all effects, the break sentence acts as a jump to the sentence following the loop in which it runs

The continue sentence

The continue sentence does not leave the loop but causes the next iteration to run

In the loop while the execution of the continue causes the program flow to jump to the condition

In the for loop the continue execution causes the increment expression to run, and then continue normally with the condition

That is, running the continue prevents the rest of the loop body from running

Functions in Python

To define functions in Python we have the instruction def

After this reserved word goes the function name along with a list of arguments delimited by parentheses and separated by commas, ending with the symbol :

def name (param1, param2, ..., paramn):
     ["" "DOCSTRING_OF_FUNCTION" ""]
     instructions in python
     [return expression]

Defining a function does not execute the body of the function

It will only be executed when the function is called

Its execution binds the function name with the current local namespace to an objecto function (a wrapper around the executable code for the function)

This object function contains a reference to the global local namespace as the global namespace to be used when the function is called

Optionally you can add an expression that will be returned by the function

The expression can be a valid Python type preceded by the statement return

The DOCSTRING is a descriptive text of the function enclosed in three double quotes of opening and closing, before the first statement

It's optional, so if we don't want to add a description, we can omit it

But it is recommended to use it so that when we review after a while our code, we remember what our function did

Arguments

The argument step is optional and in some cases there may be functions that lack them

Type of arguments

Supports types str, int, float, complex,bool, list, tuple, dic and class

Arguments with value by position

When we send arguments to a function, they are received in order in the defined parameters

def rest(a, b):
     return a - b

rest(30, 10) #will show 20, no need to use print function

Value arguments by name

It is possible to evade the order of the parameters if we indicate during the call the value that each parameter has from its name

def rest(a, b):
     return a - b

rest(b=30, a=10) #will show -20, no need to use print function

No arguments

When calling a function which has a few parameters defined, if you do not pass the arguments correctly it will cause an exception TypeError

def rest(a, b):
     return a - b

rest() #throw an exception TypeError

Default value arguments

Sometimes we need an argument to have a value, to avoid an error (which would cause the exception to be thrown TypeError), even if the user of the function does not enter it

Note that default arguments become optional and that all arguments to the left of the first default value are required

def rest(a=None, b=None):
     if a == None or b == None:
         print("Error, you must send two numbers to the function")
         return
     return a - b

rest(30) #We have only passed one argument, shows: 'Error, you must send two numbers to the function'
rest() #Have not passed arguments, shows: 'Error, you must send two numbers to the function'

The example used the null value (None) to express that no arguments had been passed

But we could use any type we need as the default

Indeterminate arguments

Sometimes we won't know in advance how many elements we need to send to a function

For these cases we can use the indeterminate parameters by position or by name

Arguments by position

As an argument we will use a tuple type preceding it with the symbol *

In this way all the arguments will be received by position, being able to navigate them comfortably with a for

def ind_pos(*args):
     for arg in args:
         print( type(arg) )
         print(arg)

ind_pos(5, "Hello", [1,2,3,4,5] )

#return
#<class 'int'>
#5
#<class 'str'>
#Hello
#<class 'list'>
#[1, 2, 3, 4, 5]

Arguments by name

As an argument we will use a type to dictate it before the symbols **

In this way all the arguments will be received by the name of the dictionary key, being able to navigate them comfortably with a for

def ind_nom(**kwargs):
    print(kwargs)
    for kwarg in kwargs:
        print(kwarg, "=>", kwargs[kwarg])

ind_nom(n=5, c="Hello", l=[1,2,3,4,5])

#return
#{'n': 5, 'c': 'Hello', 'l': [1, 2, 3, 4, 5]}
#n => 5
#c => Hello
#l => [1, 2, 3, 4, 5]

Arguments by position and name

Sometimes you may need to use both types of parameters simultaneously in a function, so you must create both dynamic collections

First the indeterminate arguments by value and then by name

def pos_nom(*args,**kwargs):
     total = 0
     for arg in args:
         total += arg
     print("summation => ", total)
     for kwarg in kwargs:
         print(kwarg, "=>", kwargs[kwarg])

pos_nom(50, -1, 1.56, 10, 20, 300, name="Raúl", age=38)

#return
#summation =>  380.56
#name => Raúl
#age => 38

All examples have used the names args and kwargs but they're not mandatory

Many frameworks and libraries use them so it's a good practice to call them that, by convention

The pass statement

It's a null operation, when we execute it, nothing seems to happen

It is useful as a container when a statement is required syntactically, but you don't need to execute code

#a function that does nothing
def query(letter): 
    pass

type(query)

The return statement

The statement return it is the one that allows you to return the result of a function

Supports types str, int, float, complex,bool, list, tuple, dic and class

def sum(number1, number2):
    '''Sum two numbers'''
    print(number1 + number2)
    print("\n")

The statement return optional, but if omitted, by default it will return the null value (None)

Multiple return

An interesting feature of the functions in Python, is the possibility to return multiple values separated by commas

def test():
     return "Raúl", 20, [1,2,3]
cad, number, lists = test()
print (cad, type(cad) ) #return Raúl <class 'str'>
print (number, type(number) ) #return 20 <class 'int'>
print (lists, type(lists) ) #return [1, 2, 3] <class 'list'>

Functions are predefined by the language

Language defined functions are sorted by modules

A module is a set of classes and functions stored in a file that can be used later

We can create our own modules and import them into the new programs we make

However, it is advisable to reuse existing modules

To import a module we will use the statement import

In this way we will be driving a namespace, similar to how C++ does (using namespaces) or Java

It has the following syntax

import module_name [as alias]

To call a specific function of the module we will use number.funcion() or alias.funcion in case we've given the module an alias

If you don't want to use all the functions of the module but if you do, we'll use the statement from

It has the following syntax

from module_name import function_name

Sys module

This module is responsible for providing variables and functionalities related to the interpreter

The variables of the sys module are:

• sys.executable

  Returns the absolute directory of the Python interpreter executable binary file

• sys.platform

  Returns the platform on which the interpreter is running

• sys.version

  Return the Python version number with additional information

The most prominent methods of the sys module are as follows:

• sys.exit()

  Force the interpreter out

• sys.getdefaultencoding()

  Returns the default character encoding

• sys.getfilesystemencoding()

  Returns the character encoding used to convert unicode file names to system file names

• sys.getsizeof()

  Returns the size of the passed object as a parameter

import sys

cad = 'San Roque's dog has no tail'

print( sys.executable ) #return c:\python.exe, since i am using windows file system
print( sys.platform ) #return win32, since I am using a 32 bit Windows system
print( sys.version ) #return 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 21:26:53) [MSC v.1916 32 bit (Intel)]
print( sys.getdefaultencoding() ) #return utf-8
print( sys.getfilesystemencoding() ) #return utf-8
print( sys.getsizeof(cad) ) #return 60

os module

This module allows us to access OS dependent features

Above all, those that give us information about the environment of the same and allow us to manipulate the directory structure

Some of the most commonly used methods are:

• os.getcwd()

  It tells us what the current directory is

• os.chdir(route)

  Change working directory to last path as an argument

• os.chroot()

  Switch to the root directory

• os.mkdir(directory)

  Creates the passed directory as an argument

• os.rmdir(directory)

  Deletes the passed directory as an argument

• os.remove(file)

  Delete the file passed as an argument

• os.rename(current, new)

  Renames the current file by the name of the new file, passed as arguments

math module

This module provides us with mathematical functions and constants

We can find all the functions and attributes in your documentation

Some of the most commonly used variables are:

• math.pi

  Represents the value of the variable \pi (Pi number)

• math.e

  Represents the value of variable e (Euler number or Napier constant)

• math.tau

  Represents the value of the variable \tau = 2\cdot\pi (constant Tau, proposed by Bob Palais, Peter Harremoes, Hermann Laurent, Fred Hoyle, Michael Hartl, Nicolas Atanes, among others)

Some of the most commonly used methods are:

• math.ceil(x)

  Returns the integer less than or equal to x

• math.floor(x)

  Returns the largest integer less than or equal to x

• math.exp(x)

  Returns the number e raised to the power x

• math.log2(x)

  Returns the base 2 logarithm of x

• math.sin(x)

  Returns the sine of x radians

• math.cos(x)

  Returns the cosine of x radians

• math.tan(x)

  Returns the tangent of x radians

• math.degrees(x)

  Converts the x-angle of radians to degrees

import math

a = 4.5786
b = 2.873

print( math.ceil(a) ) #return 5
print( math.floor(a) ) #return 4
print( math.exp(a) ) #return 97.37796957468944
print( math.log2(a) ) #return 2.194906532422851
print( math.sin(a) ) #return -0.9910635960591139
print( math.cos(a) ) #return -0.133390211658793
print( math.tan(a) ) #return7.429807507871837
print( math.degrees(a) ) #return 262.3344560785987
print( math.pi ) #return 3.141592653589793
print( math.e ) #return 2.718281828459045
print( math.tau ) #return 6.283185307179586

Random module

The random module is used for everything related to random numbers

Some of the most commonly used methods are:

• shuffle(col)

  Randomly reorders items in a collection

• sample(col, k)

  Take n items without a collection replacement

• random()

  Generates a random number in the range [0, 1)

• uniform(a, b)

  Generates a random number in the range [a, b]

• randint(a, b)

  Generates an integer random number in the range [a, b]

• gauss(mean, sigma)

  Generates a random number following a gaussian distribution with given mean and sigma

import random

lists = [1, 2, 3]

print( random.shuffle(lists) ) #return None
print( random.sample(lists, 2) ) #return [1, 2]
print( random.random() ) #return 0.06298135634914415
print( random.uniform(0, 10) ) #return 3.304708273440835
print( random.randint(0, 10) ) #return 6
print( random.gauss(50, 1.28) ) #return 50.28864476388755

NumPy module

Numpy provides us with a lot of mathematical functions and the type of variable NumPy array

Usually the NumPy package is usually imported with the alias np

This module allows us to work with mathematical structures in a very comfortable way (product of matrices, random numbers, operations on matrices...)

It is a module that is not installed by default

To do this open a terminal and run:

python -m pip install numpy

We can find all the functions and attributes in your documentation

Some of the most commonly used methods are:

• random.rand()

  It returns random values to us with the desired shape

• empty()

  Creates an empty array with the right shape

• zeros()

  Creates an array of zeros with the right shape

• dot()

  Calculates the matrix product between two arrays

• sum()

  Calculates the sum of the elements of an array

import numpy as np

np.random.seed(3)
A = np.random.rand(3,3) * 2
B = np.random.rand(3,3) * 2
A = np.round(A, 2)
B = np.round(B, 2)

print("A = ", A)
#return
#A =  [[1.1  1.42 0.58]
# [1.02 1.79 1.79]
# [0.25 0.41 0.1 ]]

print("B = ", B)
#return
#B =  [[0.88 0.06 0.91]
# [1.3  0.56 1.35]
# [1.18 0.05 1.12]]

print("A * B = ", np.round(np.dot(A, B), 2) )
#return
#A * B =  [[3.5  0.89 3.57]
# [5.34 1.15 5.35]
# [0.87 0.25 0.89]]

print(Sum of A: ", np.sum(A) )
#return
#Suma de A:  8.459999999999999

print("Sum of A: ", np.sum(A, axis = 0) )
#return
#Suma de A:  [2.37 3.62 2.47]

C = A[A>1]
print(C) #return [1.1  1.42 1.02 1.79 1.79]

Pandas module

The package pandas is widely used in the Data Scientists

It's one of the packages we should focus on to learn about data analysis

Through pandas we can get acquainted with our data set by cleaning it, transforming and analyzing it

For example, with pandas we can read a CSV file from our computer, pass it to a DataFrame (a table, in essence) and do things like:

• Calculate statistics and answer questions about the data such as getting the maximum, minimum and average of each column, knowing how correlated columns A and B are, or knowing the statistical distribution of column C
• Clean up data doing things like removing missing values or filtering rows and columns according to some criteria
• Visualize the data with the help of matplotlib
• Save the data already cleaned back in a CSV or database

Pandas is based on NumPy, so we should have that module pre-installed

Jupyter Notebooks it's an app that complements very well with Pandas, since we can run the code by cells instead of completely, which is useful if we work with large datasets

The primary components of Pandas are series and DataFrame, the first type being a column and the second being a table

Usually the pandas package is usually imported with the alias np

It is a module that is not installed by default

To do this open a terminal and run:

python -m pip install pandas

We can find all the functions and attributes in your documentation

Now let's create a simple example to show the use of pandas using a series that will contain the members of the Spanish football team that won the 2010 World Cup

To create the series we use the method pd.Series you will receive a list of player names and a list with the number of players

Then we'll show it by screen

import pandas as pd

spanishPlayers = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7] )
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#dtype: object

Now we're not going to explicitly point indexes on it, then it will generate the indexes automatically starting from the zero value

import pandas as pd

spanishPlayers = pd.Series(
    ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez', 'Pedrito',
     'Iniesta', 'Villa'] )
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#0           Casillas
#1             Ramos
#2              Pique
#3              Puyol
#4         Capdevila
#5       Xabi Alonso
#6          Busquets
#7     Xavi Hernandez
#8           Pedrito
#9            Iniesta
#10              Villa
#dtype: object

Now let's introduce a dictionary into the series instead of a list and add one more player

import pandas as pd

spanishPlayers = pd.Series( {1: 'Casillas', 15: 'Ramos', 3: 'Pique', 5: 'Puyol', 11: 'Capdevila', 14: 'Xabi Alonso', 16: 'Busquets', 8: 'Xavi Hernandez', 18: 'Pedrito', 6: 'Iniesta', 7: 'Villa'} )
spanishPlayers[10] = 'Cesc' #add a player
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#1           Casillas
#15             Ramos
#3              Pique
#5              Puyol
#11         Capdevila
#14       Xabi Alonso
#16          Busquets
#8     Xavi Hernandez
#18           Pedrito
#6            Iniesta
#7              Villa
#10              Cesc
#dtype: object

Now let's create a simple example to show the use of pandas using a DataFrame that will contain the members of the Spanish football team that won the 2010 World Cup

To create the DataFrame we use the method pd.DataFrame you will receive a dictionary with player data, a list with the column name and a list with the number of players

We'll add one more player using the method loc dataFrame object

Then we'll show it by screen

import pandas as pd

spanishPlayers = pd.DataFrame(
    {
        'name': ['Casillas', 'Ramos', 'Pique', 'Puyol', 'Capdevila', 'Xabi Alonso', 'Busquets', 'Xavi Hernandez',
                 'Pedrito', 'Iniesta', 'Villa'],
        'demarcation': ['Goalkeeper', 'Right back', 'Centre-back', 'Centre-back', 'Left back', 'Defensive midfield', 'Defensive midfield', 'Midfielder', 'Left winger', 'Right winger', 'Centre forward'],
        'team': ['Real Madrid', 'Real Madrid', 'FC Barcelona', 'FC Barcelona', 'Villareal', 'Real Madrid',
                 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona', 'FC Barcelona']
    }, columns=['name', 'demarcation', 'team'], index=[1, 15, 3, 5, 11, 14, 16, 8, 18, 6, 7]
)
spanishPlayers.loc[10] = ['Cesc', 'Forward', 'Arsenal'] #add a player
print("Spanish Football Players: \n%s" %(spanishPlayers) )

#return
#Spanish Football Players: 
#              name         demarcation          team
#1         Casillas          Goalkeeper   Real Madrid
#15           Ramos          Right back   Real Madrid
#3            Pique         Centre-back  FC Barcelona
#5            Puyol         Centre-back  FC Barcelona
#11       Capdevila           Left back     Villareal
#14     Xabi Alonso  Defensive midfield   Real Madrid
#16        Busquets  Defensive midfield  FC Barcelona
#8   Xavi Hernandez          Midfielder  FC Barcelona
#18         Pedrito         Left winger  FC Barcelona
#6          Iniesta        Right winger  FC Barcelona
#7            Villa      Centre forward  FC Barcelona
#10            Cesc             Forward       Arsenal

Display functions

print

The function print serves to send the output of your arguments to the browser in a format

Operador %

The operator % can also be used for string format

Interprets the left argument much like a style format string of the function printf C++, which applies to the right argument

In Python, there is no function printf but it has been endowed with its functionality print

For this purpose, the operator % is overloaded for strings to show the format of the string

It is often called string module operator (or, sometimes, even, module)

It has the format:

print( formatted_text %(variable1 [, variable2, ..., variableN] )

To format a text you have to enter the following formatting characters preceded by the symbol %:

Format characters for text
Character	Description
c	The argument is treated as a string value and collects a single character
d	The argument is treated as a value of type int and presented as an integer
e	The argument is treated with scientific notation (for example 1.2e+2)
E	As %e but uses the uppercase letter (for example 1.2E+2)
f	The argument is treated as a float value and presented as a floating point number (considering the locale)
F	The argument is treated as a float value and presented as a floating point number (without considering the locale)
g	Like %e and %f
G	Like %E and %f
o	The argument is treated as an integer value and presented as an octal number
s	The argument is treated as a string value and collects a string
u	The argument is treated as a value of type int and presented as an unsigned decimal number
x	The argument is treated as an integer value and presented as a hexadecimal number
X	The argument is treated as an integer value and presented as a hexadecimal number in uppercase

n =  int (43951789) #cast so that the value of n is integer
u = int(-43951789) #cast so that the value of u is integer
c = str("A") #cast so that the value of c is a string

print("%c" %(c) ) # c for ASCII value of number, shows 'A'
print("%d" %(n) ) # d for integer, displays '43951789'
print("%+d" %(n) ) # +d for signed positive integer, shows '+43951789'
print("%+d" %(u) ) # +d for negative signed integer, shows '-43951789'
print("%e" %(n) ) # e for scientific notation of the integer, shows '4.39518e + 7'
print("%E" %(n) ) # E for scientific notation of the integer, shows '4.39518E + 7'
print("%f" %(n) ) # f for decimal number (considering locale), displays '43951789.000000'
print("%F" %(n) ) # F for decimal number (regardless of locale), displays '43951789.000000'
print("%g" %(n) ) # g same as e and f
print("%G" %(n) ) # G same as E and f
print("%o" %(n) ) # o for octal number, shows '247523255'
print("%s" %(n) ) # s as a string, displays '43951789'
print("%u" %(n) ) # u for positive integer, shows '43951789'
print("%u" %(u) ) # u for negative integer, shows '-43951789'
print("%x" %(u) ) # x for hexadecimal number, displays '-29ea6ad'
print("%X" %(n) ) # X for uppercase hexadecimal number, displays '29EA6AD'

Format method

The method format added to string types in Python 2.6

Allows the use of characters {} to mark where a variable will be replaced and uses detailed formatting policies used to format

This method allows us to concatenate elements within an output through the positional format

Brackets and characters within them (called format fields) are replaced with objects passed to the format method

text = "the square root of two"
value = 2 ** 0.5

print("the result of {} is {}".format(text, value) ) #returns 'the result of the square root of two is 1.4142135623730951'

A number can be used in parentheses to refer to the position of the argument passed to the format method

Keep in mind that the first argument starts at zero

text = "the square root of two"
value = 2 ** 0.5

print("the result of {0} es {1}".format(text, value) ) #returns 'the result of the square root of two is 1.4142135623730951'

A key identifier can also be used when the argument is passed by name

This option will be useful when working with dictionaries or when we want to reduce the code something

dic = dict(text="the square root of two",  value=2**0.5)

print("the result of {text} is {value}".format(**dic) ) #returns 'the result of the square root of two is 1.4142135623730951'
print("the result of {text} is {value}.format(text="the square root of two", value=2**0.5) ) #returns 'the result of the square root of two is 1.4142135623730951'

Optionally you can put the symbol : after the number or name, and specify the type of the object:

Format characters for text
Character	Description
s	The argument is treated as a string value and collects a string
d	The argument is treated as a value of type int and presented as a decimal number (signed)
f	The argument is treated as a float value and presented as a floating point number (considering the locale)

import math

text = "the square root of two"
value = 2 ** 0.5

print("the result of {} es {:4d}".format(text, math.ceil(value) ) ) #with 4 padding spaces returns 'the result of the square root of two is    2'
print("the result of {} es {:04d}".format(text, math.ceil(value) ) ) #with 4 padding spaces returns y putting 0 to its left returns 'the result of the square root of two is 0002'
print("the result of {} es {:.4f}".format(text, value) ) #with 4 decimal values it returns 'the result of the square root of two is 1.4142'
print("the result of de {} es {:7.3f}".format(text, value) ) #cwith 7 spaces and 3 decimal values it returns 'the result of the square root of two is   1.414'
print("the result of {} es {:07.3f}".format(text, value) ) #with 7 spaces, 3 decimal values and putting 0 to its left returns returns 'the result of the square root of two is 001.414'

Higher order functions

In mathematics and computer science, higher order functions are functions that meet at least one of the following conditions:

• Take one or more functions as input
• Return a function as output

def double_function(f): #the function will perform what in mathematics is called composition
    def outcome(x):
        return f( f(x) ) #the function calls itself, it's a recursive function
    return result #returns the final result of the composition

def square(x):
    return x * x #calculate the square of x

g = double_function(square) #The composition runs from the innermost function (square) to the outermost (double_function)
g(3) #return 81

Lambda functions

Lambda functions are anonymous functions, that is, unnamed functions

They are only used where they were created (although they can be named and used later)

They are usually used in conjunction with map, filter and reduced functions

They are usually used to create functions that are passed as arguments to other functions

In Python the syntax of a lamdba function is:

lambda variable1<, variable2, ..., variableN>: expression

Where the expression can be any operation we would do when making an assignment

multiply = lambda x, y: x * y

print( multiply(2, 3) ) #return 6

map function

It allows us to apply a function on each of the elements of an iterable

It returns a map object, which we can easily transform into a list

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
outcome = map(lambda x: x * x, lists)

print( outcome ) #return <map object at 0x04E889B0>
print( list(outcome) ) #return [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

filter function

Allows us to filter items in a collection (for example, a list)

It is a widely used function in the treatment of collections

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
outcome = map(lambda x:x*x, lists)
filtered = filter(lambda x:x>30, outcome)

print( list(filtered) ) #return [36, 49, 64, 81, 100]

reduce function

Take a function and a collection by reducing it to a single value

It would be equivalent to an aggregation function

It belongs to the module functools, so it must be imported before it can use reduce

from functools import reduce

The function we pass must take at least two parameters and an optional one

The first is the aggregate parameter that accumulates in each iteration over the items in the collection

The second element corresponds to the step of the iteration

The third is in case an initial value is needed

from functools import reduce

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

print( reduce(lambda accumulator, number: acumulador + number, lista) ) #return 55

Python exceptions

If an operation cannot be completed due to an error, the program must:

• return to a stable state and allow other operations

• try to save your work and finish

This task is difficult because usually the code that detects the error is not the one that can perform such tasks this is why you should inform that you can handle it

The most common solution are the error codes

Python offers another way to deal with errors under exceptional conditions: the exceptions

An exceptional condition is one that prevents the continuation of an operation

It's not known how to handle it, but you can't continue

In Python, an exception is thrown for someone who knows how to handle it to handle it in a higher context

f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
text = f.readlines()
f.close()

In the example the open function checks whether the file readme.txt existed in the system and if it doesn't exist the exception is thrown FileNotFoundError who is untreated at the moment

When the interpreter detects the throw of the exception, the current method ends and launches an object that provides information about the error that occurred

Normally each type of error will be handled individually

Handling of the exceptions

Once detected the error makes it necessary to indicate who is in charge of treating it

An exception handler has the following format:

try:
    operations that can raise exceptions
except:
    exception treatment
[else:
    operations executed when an exception has not been generated]
[finally:
    common operations executed whether or not exceptions occur]

try block

The block try delimits the group of operations that may produce exceptions

except block

The block except it is the place to which control is passed if any of the operations throws an exception

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    text = f.readlines()
    f.close()
except:
    print("I/O error") #will show I/O error when exception occurs

The example used a block try with his block except to handle the errors in the previous example

If any of the operations in the block throw an exception, the block is interrupted try and runs the except

At the end of this, it is normally continued

If no exception is thrown, the block except is ignored

Multiple exceptions

There is also the possibility to use an exception name to handle specific errors

Some of which are already recognized by the system, such as the exception FileNotFoundError, which is launched when a file does not exist in the system

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    text = f.readlines()
    f.close()
except FileNotFoundError as e:
    print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
except EOFError as e:
    print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs

The example used a block try with several blocks except to handle several exceptions

A block try can have several except associated

We've added the sentence as to the block except after naming it to make it the object of exception we've called and

As you can see, after turning it into an object, we can use it as if it were a class

When an exception does not correspond to any catch spreads backwards in the sequence of invocations until a catch adequate

def f1(action):
    try:
        if action == 1:
            raise FileNotFoundError
        elif action == 2:
            raise EOFError
    except FileNotFoundError as e:
        print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
    except EOFError as e:
        print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs
    
def f2(value):
    try:
        f1(value)
    except EOFError as e:
        print("Error corrected f2") #will show Error corrected f2, when the EOFError exception occurs
    else:
        print("Normal completion f2") #mostrará Normal completion f2, when there have been no mistakes

#simulation of errors
f2(1)
#show
#I/O Error FileNotFoundError
#Normal completion f2
f2(2)
#show
#End Of File error EOFError
#Normal completion f2

In the example is managed the exceptions of the methods f1 and f2 and if you don't find any, it continues the execution of the code in the normal way outside of the block try

The sentence has been used raise followed by the name of the type of exception to propagate it and treat it elsewhere

In this case we have treated it within the f1 function itself in its exception blocks

Although spreading it could have been treated outside of it elsewhere in the script

A block has also been used else that allows the code to continue execution in case there are no exceptions before continuing outside the block try

else block

Allows code execution to continue in case there are no exceptions before continuing outside the block try

The block else can be used to exit a loop if the statement is added at the end of a loop break

It is optional and if it is not used, it will continue the execution of the code in the block finally and finally outside the block try

while(True):
    try:
        n = float( input("Enter a number: ") )
        m = 4
        print("{}/{} = {}".format(n, m, n / m) )
    except:
        print("An error has occurred, enter the number correctly")
    else:
        print("Everything has worked correctly")
        break  #Important to break the iteration if everything went well

Finally block

There may be occasions in which you want to perform some operation if exceptions occur as if not

Such operations can be placed within a block finally

If there is no exception, the block will be executed try, then the block else and finally the finally

Like the block else, is optional and if it is not used, it will continue to execute the code outside the block try

try:
    f = open('readme.txt') #the file readme.txt does not exist in the system, it will throw an exception of type FileNotFoundError
    texto = f.readlines()
except FileNotFoundError as e:
    print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when FileNotFoundError exception occurs
except EOFError as e:
    print("End Of File error", type(e).__name__ ) #will show End Of File error EOFError, when the EOFError exception occurs
    finally:
        try:
            f.close() #the file is closed regardless of whether there have been exceptions or not
        except IOError as e:
            print("I/O error", type(e).__name__ ) #will show I/O Error FileNotFoundError, when it occurs you cannot close the file

Rules of use

1. Standard

   • If an exception can be handle should not be spread

   • It is more convenient to use methods that do not produce errors

2. Standard

   • Do not use exceptions to avoid a query

     • Not to abuse them

       class Heap:
           def pop():
               raise EmptyStackError

3. Standard

   • To separate the error handling logic

     All together
     cad = "test" for c in cad: try: obj1.mesg1() except NameError as a: Treatment of a try: obj2.mesg2() except NameError as b: Treatment of b

     Separate
     cad = "test" try: for c in cad: obj1.mesg1() obj2.mesg2() except NameError as a: Treatment of a except NameError as b: Treatment of b

4. Standard

   • Do not ignore an exception already that we leave the code with errors without control

     try:
        operations
     except EmptyStackError:
         pass #For the interpreter to shut up