Python

Este curso creo que está bueno: https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3

https://www.linkedin.com/groups/25827/25827-6252617967876530180?midToken=AQGAer8k7UG2aA&trk=eml-b2_anet_digest_of_digests-hero-12-view%7Ediscussion&trkEmail=eml-b2_anet_digest_of_digests-hero-12-view%7Ediscussion-null-6adzns%7Ej11y530y%7Ebq&lipi=urn%3Ali%3Apage%3Aemail_b2_anet_digest_of_digests%3BG9uUYE5oSqCC6IiHvBuPAQ%3D%3D

https://www.udemy.com/the-python-mega-course/?utm_source=facebook&utm_medium=udemyads&utm_campaign=NEW-FB-PROS-TECH-Dev-Core-Python-EN-ENG_._ci_692188_._sl_ENG_._vi_TECH_._sd_All_._la_EN_.&utm_term=_._ag_Dev-Core-Python-Affinity-Secondary-Worldwide-_._ci_692188_._._pi_1500516769988382_._gi_all_._ai_18--65_._an_w2JZ7e&k_clickid=06af6ff1-3223-44a3-ac5a-faf35c3045d8_116713439&pmtag=730e4958-3f44-4290-b5bb-1fb0fb62b7d5

https://openclassrooms.com/courses/apprenez-a-programmer-en-python/les-structures-conditionnelles

http://www.enlistq.com/10-python-idioms-to-help-you-improve-your-code/

https://www.linkedin.com/groups/25827/25827-6226729936229666816?midToken=AQGAer8k7UG2aA&trk=eml-b2_anet_digest_of_digests-hero-11-discussion%7Esubject&trkEmail=eml-b2_anet_digest_of_digests-hero-11-discussion%7Esubject-null-6adzns%7Eiy47cgxw%7Eys

https://www.linkedin.com/pulse/python-top-10-programming-languages-year-2017-alok-kumar

Qu'est-ce que Python? - Pourquoi Python? - À quoi peut servir Python?

• Python est un langage de programmation interprété, à ne pas confondre avec un langage compilé.

• Il permet de créer toutes sortes de programmes, comme des jeux, des logiciels, des progiciels, etc.

• Il est possible d'associer des bibliothèques à Python afin d'étendre ses possibilités.

• Il est portable, c'est à dire qu'il peut fonctionner sous différents systèmes d'exploitation (Windows, Linux, Mac OS X,…).

Instalación

Python est pré-installé sur la plupart des distributions Linux. Sinon:

Versión instalada

Para ver la versión por defecto:

python --version

O simplemente entrando a la línea de comandos python a través de:

python

Ahora, en un SO pueden haber más de una versión instalada. Para ver que versiones de python se encuentran ya instaladas en nuestro sistema operativo podemos ir al directorio /usr/bin y ver que ejecutables de python se encuentran:

ls /usr/bin/python
python      python2     python2.7   python3     python3.5   python3.5m  python3m    pythontex   pythontex3

y para ver la versión exacta (Python 3.5.2) ejecutamos python3.5 y este nos muestra la versión exacta al entrar a la línea de comandos python:

python3.5
Python 3.5.2 (default, Nov 17 2016, 17:05:23) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Cambiar la versión por defecto

https://linuxconfig.org/how-to-change-from-default-to-alternative-python-version-on-debian-linux

Change python version on per user basis

To change a python version on per user basis you simply create an alias within user's home directory. Open ~/.bashrc file and add new alias to change your default python executable:

alias python='/usr/bin/python3.4'

Once you make the above change, re-login or source your .bashrc file:

. ~/.bashrc

Change python version system-wide

To change python version system-wide we can use update-alternatives command. Logged in as a root user, first list all available python alternatives:

# update-alternatives --list python
update-alternatives: error: no alternatives for python

The above error message means that no python alternatives has been recognized by update-alternatives command. For this reason we need to update our alternatives table and include both python2.7 and python3.5:

# update-alternatives --install /usr/bin/python python /usr/bin/python2.7 1
update-alternatives: using /usr/bin/python2.7 to provide /usr/bin/python (python) in auto mode
# update-alternatives --install /usr/bin/python python /usr/bin/python3.5 2
update-alternatives: using /usr/bin/python3.4 to provide /usr/bin/python (python) in auto mode

The --install option take multiple arguments from which it will be able to create a symbolic link. The last argument specified it priority means, if no manual alternative selection is made the alternative with the highest priority number will be set. In our case we have set a priority 2 for /usr/bin/python3.4 and as a result the /usr/bin/python3.5 was set as default python version automatically by update-alternatives command.

Ubuntu

apt-get install python3.x

Si se descarga:

• Décompressez l'archive en tapant : tar -xzf Python-3.4.0.tar.bz2 (cette commande est bien entendu à adapter suivant la version et le type de compression).
• Attendez quelques instants que la décompression se termine, puis rendez-vous dans le dossier qui vient d'être créé dans le répertoire courant (Python-3.4.0 dans mon cas).
• Exécutez le script configure en tapant ./configure dans la console.
• Une fois que la configuration s'est déroulée, il n'y a plus qu'à compiler en tapant make puis make install en tant que super-utilisateur.

Lancer Python

Lorsque vous l'avez installé sur votre système, Python a créé un lien vers l'interpréteur sous la forme python3.X (le X étant le numéro de la version installée).

Si, par exemple, vous avez installé Python 3.4, vous pouvez y accéder grâce à la commande

python3.4

Premiers pas avec l'interpréteur de commandes Python

Opérations courantes

>>> 3 + 4
7

>>> 9.5 + 2
11.5

>>> 3.11 + 2.08
5.1899999999999995

Les types de données

int: Les nombres entiers

Le type entier se nomme int en Python (qui correspond à l'anglais « integer », c'est-à-dire entier). La forme d'un entier est un nombre sans virgule.

float: Les nombres flottants

Les flottants sont les nombres à virgule. Ils se nomment float en Python (ce qui signifie « flottant » en anglais). La syntaxe d'un nombre flottant est celle d'un nombre à virgule (n'oubliez pas de remplacer la virgule par un point). Si ce nombre n'a pas de partie flottante mais que vous voulez qu'il soit considéré par le système comme un flottant, vous pouvez lui ajouter une partie flottante de 0 (exemple 52.0).

Les chaînes de caractères

On peut écrire une chaîne de caractères de différentes façons :

   entre guillemets ("ceci est une chaîne de caractères") ;

   entre apostrophes ('ceci est une chaîne de caractères') ;

   entre triples guillemets ("""ceci est une chaîne de caractères""").

   entre triples apostrophes (ceci est une chaîne de caractères).

Si vous utilisez les délimiteurs simples (le guillemet ou l'apostrophe) pour encadrer une chaîne de caractères, il faut échapper les apostrophes se trouvant au cœur de la chaîne. On insère ainsi un caractère anti-slash « \ » avant les apostrophes contenues dans le message.

chaine = 'J\'aime le Python!'

Le caractère d'échappement « \ » est utilisé pour créer d'autres signes très utiles. Ainsi, « \n » symbolise un saut de ligne ("essai\nsur\nplusieurs\nlignes"). Pour écrire un véritable anti-slash dans une chaîne, il faut l'échapper lui-même (et donc écrire « \\ »).

L'interpréteur affiche les sauts de lignes comme on les saisit, c'est-à-dire sous forme de « \n ». Nous verrons dans la partie suivante comment afficher réellement ces chaînes de caractères et pourquoi l'interpréteur ne les affiche pas comme il le devrait.

Utiliser les triples guillemets pour encadrer une chaîne de caractères dispense d'échapper les guillemets et apostrophes, et permet d'écrire plusieurs lignes sans symboliser les retours à la ligne au moyen de « \n ».

>>> chaine3 = """Ceci est un nouvel
... essai sur plusieurs
... lignes"""
>>>

Vous pouvez utiliser, à la place des trois guillemets, trois apostrophes qui jouent exactement le même rôle.

Les booléens

>>> a = 0
>>> a == 5
False
>>> a > -8
True
>>> a != 33.19
True
>>>

Les variables de ce type ne peuvent prendre comme valeur que True ou False.

>>> age = 21
>>> majeur = False
>>> if age >= 18:
>>>     majeur = True
>>>

Les mots-clés and, or et not

if a>=2 and a<=8:
    print("a est dans l'intervalle.")
else:
    print("a n'est pas dans l'intervalle.")

if a<2 or a>8:
    print("a n'est pas dans l'intervalle.")
else:
    print("a est dans l'intervalle.")

Enfin, il existe le mot clé not qui « inverse » un prédicat. Le prédicat not a==5 équivaut donc à a!=5.

not rend la syntaxe plus claire. Pour cet exemple, j'ajoute à la liste un nouveau mot clé, is, qui teste l'égalité non pas des valeurs de deux variables, mais de leurs références. Je ne vais pas rentrer dans le détail de ce mécanisme avant longtemps. Il vous suffit de savoir que pour les entiers, les flottants et les booléens, c'est strictement la même chose. Mais pour tester une égalité entre variables dont le type est plus complexe, préférez l'opérateur « == ». Revenons à cette démonstration :

>>> majeur = False
>>> if majeur is not True:
...     print("Vous n'êtes pas encore majeur.")
... 
Vous n'êtes pas encore majeur.
>>>

Les opérateurs

« + » « - » « / »

>>> 3 + 4
7

>>> -2 + 93
91

>>> 9.5 + 2
11.5

>>> 3.11 + 2.08
5.1899999999999995

>>> 10 / 5
2.0

>>> 10 / 3
3.3333333333333335

« // » permet d'obtenir la partie entière d'une division (cociente)

>>> 10 // 3
3
>>> 10 // 4
2

« % », que l'on appelle le « modulo », permet de connaître le reste de la division (resto)

>>> 10%3
1

« += » « -= » « *= » « /= »

variable = variable + 1 

La operación anterior puede resumirse utilizando el operador +=:

variable += 1

Les opérateurs -=, *= et /= existent également, bien qu'ils soient moins utilisés.

Potencia

>>> 9**(1/2)
3.0

>>> pow(3,2)
9

Valor absoluto

>>> abs(-3.0)
3.0

Complejos

>>> complex(2,3)
(2+3j)

>>> complex(2,3)*complex(3,4)
(-6+17j)

>>> a=complex(3,5)
>>> a.real
3.0
>>> a.imag
5.0

Maximo y minimo

>>> max(3,45,6,7)
45

>>> min(32,23,2,13,4.3)
2

Redondeo

>>> round(34.5)
35.0

>>> round(35.345,1)
35.3

La clase math

>>> import math

Raiz cuadrada

>>> math.sqrt(2)
1.4142135623730951

Factorial

>>> math.factorial(5)
120

PI

>>> math.pi
3.1415926535897931

Funciones trigonométricas

>>> math.sin(math.pi)
1.2246063538223773e-16

Logaritmos

>>> math.log(11)
2.3978952727983707

Permutation

Python propose un moyen simple de permuter deux variables (échanger leur valeur). Dans d'autres langages, il est nécessaire de passer par une troisième variable qui retient l'une des deux valeurs… ici c'est bien plus simple :

>>> a = 5
>>> b = 32
>>> a,b = b,a # permutation
>>> a
32
>>> b
5
>>>

Asignar un mismo valor a varias variables

On peut aussi affecter assez simplement une même valeur à plusieurs variables :

>>> x = y = 3
>>> x
3
>>> y
3

Couper une instruction Python, pour l'écrire sur deux lignes ou plus

>>> 1 + 4 - 3 * 19 + 33 - 45 * 2 + (8 - 3) \
... -6 + 23.5
-86.5
>>>

Les opérateurs de comparaison

< Strictement inférieur à
> Strictement supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à
== Égal à
!= Différent de

Funciones más utilizadas

Une fonction exécute un certain nombre d'instructions déjà enregistrées. En gros, c'est comme si vous enregistriez un groupe d'instructions pour faire une action précise et que vous lui donniez un nom. Vous n'avez plus ensuite qu'à appeler cette fonction par son nom autant de fois que nécessaire.

La plupart des fonctions ont besoin d'au moins un paramètre pour travailler sur une donnée ; ces paramètres sont des informations que vous passez à la fonction afin qu'elle travaille dessus.

Les fonctions s'utilisent en respectant la syntaxe suivante :

nom_de_la_fonction(parametre_1,parametre_2,…,parametre_n)

La fonction « type »

Une des grandes puissances de Python est qu'il comprend automatiquement de quel type est une variable et cela lors de son affectation. Mais il est pratique de pouvoir savoir de quel type est une variable.

La syntaxe de cette fonction est simple :

type(nom_de_la_variable)

La fonction renvoie le type de la variable passée en paramètre.

>>> type(3)
<class 'int'>

print - input

>>> a=3
>>> b=4
// Las variables int deben ser delimitadas entre comas:
>>> print("a =",a,"et b =",b)
a = 6 et b = 4

>>> a='3'
>>> b='4'
// Las variables str pueden ser delimitadas entre comas o entre +:
>>> print("a = "+a+" et b = "+b)
a = 6 et b = 4

>>> print("Hello World !")
Hello World !

input

name = input("What's your name? ")
print("Nice to meet you " + name + "!")
age = input("Your age? ")
print("So, you are already " + age + " years old, " + name + "!")

La función input asigna por defecto una variable de tipo str. Si queremos que la variable sea tipo int o list:

>>> population = int(input("Population of Toronto? "))
Population of Toronto? 2615069
>>> print(population, type(population))
2615069 <class 'int'>

>>> cities_canada = eval(input("Largest cities in Canada: "))
Largest cities in Canada: ["Toronto", "Montreal", "Calgara", "Ottawa"]
>>> print(cities_canada, type(cities_canada))
['Toronto', 'Montreal', 'Calgara', 'Ottawa'] <class 'list'>

Input and Output funtions

Esta página creo que no está actualizada para python 3, pero está bien organizada: https://en.wikibooks.org/wiki/Python_Programming/Input_and_Output#input.28.29

Les structures conditionnelles

IF / ELSE / ELIF

>>> a = 5
>>> if a > 0:
...     print("a est supérieur à 0.") # Si no se coloca la identation dentro del if, se genera un error: IndentationError: expected an indented block
... 
a est supérieur à 0.

>>> age = 21
>>> if age >= 18:
...    print("Vous êtes majeur.")
... else:
...    print("Vous êtes mineur.")
... 
Vous êtes majeur.

>>> a=5
>>> if a > 0: # Positif
...      print("a est positif.")
... elif a < 0:
...      print("a est négatif.")
... else:
...      print("a est nul.")
... 
>>> a est positif.

Definir una función

def hello():
    print("Hello")

def area(width, height):
    return width * height

def print_welcome(name):
    print("Welcome", name)

hello()
hello()

print_welcome("Fred")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

def factorial():
        n=int(input("Entrez un entier positif: "))
        fac=1
        for i in range(n,1,-1):
                fac=fac*i
        return(fac)

print(factorial())

Exceptions

while True:
     try:
         x = int(raw_input("Please enter a number: "))
         break
     except ValueError:
         print "Oops!  That was no valid number.  Try again..."

OOP with Python

https://python.swaroopch.com/oop.html

Object Oriented Programming

In all the programs we wrote till now, we have designed our program around functions i.e. blocks of statements which manipulate data. This is called the procedure-oriented way of programming. There is another way of organizing your program which is to combine data and functionality and wrap it inside something called an object. This is called the object oriented programming paradigm.

Classes and objects are the two main aspects of object oriented programming. A class creates a new type where objects are instances of the class. An analogy is that you can have variables of type int which translates to saying that variables that store integers are variables which are instances (objects) of the int class.

Note for Static Language Programmers:

Note that even integers are treated as objects (of the int class). This is unlike C++ and Java (before version 1.5) where integers are primitive native types.

See help(int) for more details on the class.

Fields:

Variables that belong to an object or class are referred to as fields.

Methods:

Objects can also have functionality by using functions that belong to a class. Such functions are called methods of the class.

Attributes:

the fields and methods can be referred to as the attributes of that class.

Instance variables and class variables:

Fields are of two types - they can belong to each instance/object of the class or they can belong to the class itself. They are called instance variables and class variables respectively.

The self

Class methods have only one specific difference from ordinary functions - they must have an extra first name that has to be added to the beginning of the parameter list, but you do not give a value for this parameter when you call the method, Python will provide it. This particular variable refers to the object itself, and by convention, it is given the name self.

Say you have a class called MyClass and an instance of this class called myobject. When you call a method of this object as myobject.method(arg1, arg2), this is automatically converted by Python into MyClass.method(myobject, arg1, arg2) - this is all the special self is about.

This also means that if you have a method which takes no arguments, then you still have to have one argument - the self.

class Person:
    def say_hi(self):
        print('Hello, how are you?')

p = Person()
p.say_hi()
# The previous 2 lines can also be written as
# Person().say_hi()

The __init__ method

There are many method names which have special significance in Python classes. We will see the significance of the __init__ method now.

The __init__ method is run as soon as an object of a class is instantiated. The method is useful to do any initialization you want to do with your object. Notice the double underscores both at the beginning and at the end of the name.

Example (save as oop_init.py):

class Person:
    def __init__(self, name):
        self.name = name

    def say_hi(self):
        print('Hello, my name is', self.name)

p = Person('Swaroop')
p.say_hi()
# The previous 2 lines can also be written as
# Person('Swaroop').say_hi()

Output:
$ python oop_init.py
Hello, my name is Swaroop

Class And Object Variables

We have already discussed the functionality part of classes and objects (i.e. methods), now let us learn about the data part. The data part, i.e. fields, are nothing but ordinary variables that are bound to the namespaces of the classes and objects. This means that these names are valid within the context of these classes and objects only. That's why they are called name spaces.

There are two types of fields - class variables and object variables which are classified depending on whether the class or the object owns the variables respectively.

Public or private members:

All class members are public. One exception: If you use data members with names using the double underscore prefix such as __privatevar, Python uses name-mangling to effectively make it a private variable.

Thus, the convention followed is that any variable that is to be used only within the class or object should begin with an underscore and all other names are public and can be used by other classes/objects. Remember that this is only a convention and is not enforced by Python (except for the double underscore prefix).

Class variables are shared, they can be accessed by all instances of that class. There is only one copy of the class variable and when any one object makes a change to a class variable, that change will be seen by all the other instances.

En el siguiente ejemplo, population belongs to the Robot class and hence is a class variable. The name variable belongs to the object (it is assigned using self) and hence is an object variable.

Thus, we refer to the population class variable as Robot.population and not as self.population. We refer to the object variable name using self.name notation in the methods of that object.

Instead of Robot.population, we could have also used self.__class__.population because every object refers to its class via the self.__class__ attribute

Object variables are owned by each individual object/instance of the class. In this case, each object has its own copy of the field i.e. they are not shared and are not related in any way to the field by the same name in a different instance. An example will make this easy to understand (save as oop_objvar.py):

Class methods

The how_many method difined in the next example is actually a method that belongs to the class and not to the object. This means we can define it as either a classmethod or a staticmethod depending on whether we need to know which class we are part of. Since we refer to a class variable, let's use classmethod.

We have marked the how_many method as a class method using the classmethod decorator.

Decorators can be imagined to be a shortcut to calling a wrapper function, so applying the @classmethod decorator is same as calling:

how_many = classmethod(how_many)

class Robot:
    """Represents a robot, with a name."""

    # A class variable, counting the number of robots
    population = 0

    def __init__(self, name):
        """Initializes the data."""
        self.name = name
        print("(Initializing {})".format(self.name))

        # When this person is created, the robot
        # adds to the population
        Robot.population += 1

    def die(self):
        """I am dying."""
        print("{} is being destroyed!".format(self.name))

        Robot.population -= 1

        if Robot.population == 0:
            print("{} was the last one.".format(self.name))
        else:
            print("There are still {:d} robots working.".format(
                Robot.population))

    def say_hi(self):
        """Greeting by the robot.

        Yeah, they can do that."""
        print("Greetings, my masters call me {}.".format(self.name))

    @classmethod
    def how_many(cls):
        """Prints the current population."""
        print("We have {:d} robots.".format(cls.population))


droid1 = Robot("R2-D2")
droid1.say_hi()
Robot.how_many()

droid2 = Robot("C-3PO")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")

print("Robots have finished their work. So let's destroy them.")
droid1.die()
droid2.die()

Robot.how_many()

Output:
$ python oop_objvar.py
(Initializing R2-D2)
Greetings, my masters call me R2-D2.
We have 1 robots.
(Initializing C-3PO)
Greetings, my masters call me C-3PO.
We have 2 robots.

Robots can do some work here.

Robots have finished their work. So let's destroy them.
R2-D2 is being destroyed!
There are still 1 robots working.
C-3PO is being destroyed!
C-3PO was the last one.
We have 0 robots.

Python Web Development

https://www.fullstackpython.com/web-development.html

Web Frameworks for Python:

https://wiki.python.org/moin/WebFrameworks

https://fr.wikipedia.org/wiki/Liste_de_frameworks_Python

Ejemplos de Web Applications in Python: https://wiki.python.org/moin/WebApplications

Complete Python Web Course (15€): https://www.udemy.com/the-complete-python-web-course-learn-by-building-8-apps/

Frameworks

Django

Página oficial: https://www.djangoproject.com/

Documentación: https://docs.djangoproject.com/en/1.11/

Instalación de django

Documentación oficial sobre la instalación: https://docs.djangoproject.com/en/1.11/topics/install/#installing-official-release

En este video se muestra la instalación dentro del virtual environement: https://www.youtube.com/watch?v=oRGK9klCn00#t=107.337193

Aquí se muestran distintas formas de instalar django: https://www.howtoforge.com/tutorial/how-to-install-django-on-ubuntu/

Prerequisitos

1. Install Python

Si ya está instalado. Setup python 3 as Default Python version: Ver Cambiar la versión por defecto

2. Install Apache and mod_wsgi

If you just want to experiment with Django, skip ahead to the next section; Django includes a lightweight web server you can use for testing, so you won’t need to set up Apache until you’re ready to deploy Django in production.

3. Get your database running

By default, the configuration uses SQLite. If you’re new to databases, or you’re just interested in trying Django, this is the easiest choice. SQLite is included in Python, so you won’t need to install anything else to support your database.

When starting your first real project, however, you may want to use a more scalable database like PostgreSQL, to avoid database-switching headaches down the road.

If you plan to use Django’s database API functionality, you’ll need to make sure a database server is running. Django supports many different database servers and is officially supported with PostgreSQL, MySQL, Oracle and SQLite.

4. Remove any old versions of Django

If you are upgrading your installation of Django from a previ