From Sinfronteras
Jump to: navigation, search


Online Python Interpreters

These ones supports many languages:


Installing python on Ubuntu

Python est pré-installé sur la plupart des distributions Linux. Sinon, or if you want to install the last version using apt:

Installing Anaconda

Display the installed version

Para ver la versión por defecto:

python --version

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


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:

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.

Change the default version

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 we can list all available python alternatives:

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

El comando anterio debería mostrar las alternativas (por ejemplo python2.7 , python3.5) que ya han sido incluidas a través del comando update-alternatives --install. 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:

Debemos entonces contruir la tabla de alternativas de la siguiente forma:

# 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.

Es decir, si queremos que python2.7 sea la versión por defecto podemos ejecutar el comando update-alternatives --intall de la forma mostrada arriba y ajustar el último argumento de forma tal que el mayor valor sea asociado a la versión que queremos por defecto.

IDE for Python


This is not an IDE but an extension that can be installed in many IDEs.

Kite is the autocomplete developers trust to improve their productivity. Fully local and powered by machine learning.



Visual Studio Code

Python in Visual Studio Code


Sublime Text

Sublime Text is a proprietary cross-platform source code editor with a Python application programming interface (API). It natively supports many programming languages and markup languages, and functions can be added by users with plugins.


wget -qO - | sudo apt-key add -
sudo apt-add-repository "deb apt/stable/"
sudo apt install sublime-text

Keyboard shortcut to comment lines in Sublime Text 3

As a workaround, go to Preferences->Key Bindings - User and add these keybindings (if you're using Linux):

{ "keys": ["ctrl+7"], "command": "toggle_comment", "args": { "block": false } },
{ "keys": ["ctrl+shift+7"], "command": "toggle_comment", "args": { "block": true } }


If you want it for all files, go to Preferences -> Settings - Default/User. But as several comments below indicate, Syntax Specific settings can limit it to just the languages you choose.

To limit this configuration to Ruby files, first open up a Ruby file in the editor, and then go to Preferences -> Settings -> More -> Syntax Specific -> User. This should open a settings window named Ruby.sublime-settings

Save these settings:

  "tab_size": 2,
  "translate_tabs_to_spaces": true,
  "detect_indentation": false

Crear un proyecto en Sublime Text

  1. Abrimos una nueva ventana: File > New Window
  2. Add folder to project
  3. Save project as: es apropiado guardarlo en el mismo directorio en donde fue creado el proyecto.

Esto creará dos archivos:

  • nombre-111.sublime-project
  • nombre-111.sublime-workspace : Este es el que debemos abrir para ingresar al proyecto.



Using umake

De esta forma lo instalé correctamente:

sudo add-apt-repository ppa:ubuntu-desktop/ubuntu-make
sudo apt-get update
sudo apt-get install ubuntu-make

Once you have umake, use the command below to install PyCharm Community Edition in Ubuntu:

umake ide pycharm

Se instaló en la siguiente ruta:


Using Snap

De esta forma lo instalé correctamente:

sudo snap install pycharm-community --classic

Sin embargo, luego de instalarlo de esta manera, cuando iniciaba pycharm, se creaba automáticamente el directorio /home/adelo/snap. Traté de cambiar la ubicación de este directorio y no di con la solución.

Python on eclipse

Para utilizar Python en Eclipse debemos instalar PyDev:

Help > Eclipse Marketplace Find: PyDev

Using Python

Python Shell

From the terminal, you can start the Python Shell/Interpreter (Also know as Python Interactive Shell) using the command:


Premiers pas avec l interpreteur de commandes Python

Operations courantes
>>> 3 + 4
>>> 9.5 + 2
>>> 3.11 + 2.08

Writing and Running a Python code

You can use your favorite Text Editor or IDE to write your Python code:

c=input("Ingrese un caracter: ")
e=int(input("Entrez un entier: "))

for i in range(1,e+1):
	for j in range(1,i+1):

  • If we use the line #!/usr/bin/python3.6 to indicate the path to the Python Interpreter, then we can then run our code as a Executable file this way:

  • However, the most common way is not including #!/usr/bin/python3.6 and calling the Python Interpreter through the python command:

  • Of course, you can also run a Python program through a button on a IDE Graphical Interface.

Data types


In this source you can find a very good documentation about Python Data Types and the most important Operations and Methods for each Data Type:

Numbers Integers Plain integers
Long integers
Floating point numbers
Complex numbers
Sequences Immutable sequences Strings
Mutable sequences Lists
Mappings Dictionaries
Callable types User-defined functions
User-defined methods
Built-in functions
Built-in methods
Class instances
Class instances
Internal types Code objects
Frame objects
Traceback objects
Slice objects

Getting the Data Type: You can get the data type of any object by using the type() function:

Type/Class Description Example Setting the Specific Data Type Operations/Functions/Methods
Numeric Types int Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length. x = 20 x = int(20)
float Float, or "floating point number" is a number, positive or negative, containing one or more decimals. x = 20.5 x = float(20.5)
complex Complex numbers are written with a "j" as the imaginary part x = 1j x = complex(1j)
Text Type str Strings are Arrays: Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters. However, Python does not have a character data type, a single character is simply a string with a length of 1. x = "Hello World" x = str("Hello World")
Boolean Type bool Booleans represent one of two values: True or False. x = True x = bool(5)
Binary Types bytes x = b"Hello" x = bytes(5)
bytearray x = bytearray(5) x = bytearray(5)
memoryview x = memoryview(bytes(5)) x = memoryview(bytes(5))
Python Collections (Arrays) Sequence Types list A list is a collection which is ordered and changeable. x = ["apple", "banana", "cherry"] x = list(("apple", "banana", "cherry"))

Nice way to create a list:
lista = [x**2 for x in range(12) if x%3 == 0]
# Output:
[0, 9, 36, 81]

tuple A tuple is a collection which is ordered and unchangeable. x = ("apple", "banana", "cherry") x = tuple(("apple", "banana", "cherry"))
Array Python does not have built-in support for Arrays. You have to import it from a Library:

from numpy import array

x = array([3, 6, 9, 12])

There are some differences between Array and List:

Lists are containers for elements having differing data types but arrays are used as containers for elements of the same data type.

Arrays are specially optimised for arithmetic computations, Ex:

x = array([3, 6, 9, 12])

divided_x = x/2 # This would return an error if using List


[1.5 3. 4.5 6. ]

range x = range(6) x = range(6)
Mapping Type dict A dictionary is a collection which is unordered, changeable and indexed. In Python dictionaries are written with curly brackets, and they have keys and values. x = {"name" : "John", "age" : 36} x = dict(name="John", age=36)
Set Types set A set is a collection which is unordered and unindexed. x = {"apple", "banana", "cherry"} x = set(("apple", "banana", "cherry"))
frozenset x = frozenset({"apple", "banana", "cherry"}) x = frozenset(("apple", "banana", "cherry"))


Operator Name/Description Example Same as


Java JS R Python Java F R
Arithmetic Operators + + Addition x + y
- - Subtraction x - y
* * Multiplication x * y
/ / Division x / y
% % Modulus x % y
** java.util.Math Exponentiation x ** y import java.util.Math

Double result = Math.pow(number, exponent);

// Floor division x // y
++ Increment: Increases the value of a variable by 1 ++x
-- Decrement: Decreases the value of a variable by 1 --x
Assignment Operators = = x = 5
+= += x+= 3 x = x + 3
-= -= x -= 3 x = x - 3
*= *= x *= 3 x = x * 3
/= /= x /= 3 x = x / 3
%= %= x %= 3 x = x % 3
//= x //= 3 x = x // 3
**= x **= 3 x = x ** 3
&= &= x &= 3 x = x & 3
|= |= x |= 3 x = x | 3
^= ^= x ^= 3 x = x ^ 3
>>= >>= x >>= 3 x = x >> 3
<<= <<= x <<= 3 x = x << 3
Comparison Operators == == Equal x == y
!= != Not equal x != y
> > Greater than x > y
< < Less than x < y
>= >= Greater than or equal to x >= y
<= <= Less than or equal to x <= y
Logical Operators and && Logical and: Returns True if both statements are true x < 5 and x < 10 x < 5 && x < 10
or || Logical or: Returns True if one of the statements is true x < 5 or x < 4 x < 5 || x < 4
not ! Logical not: Reverse the result, returns False if the result is true not(x < 5 and x < 10) !(x < 5 && x < 10)
Identity Operators is Returns true if both variables are the same object x is y
is not Returns true if both variables are not the same object x is not y
Membership Operators in Returns True if a sequence with the specified value is present in the object x in y
not in Returns True if a sequence with the specified value is not present in the object x not in y
Bitwise Operators &

Sets each bit to 1 if both bits are 1

| OR

Sets each bit to 1 if one of two bits is 1


Sets each bit to 1 if only one of two bits is 1


Inverts all the bits

<< Zero fill left shift

Shift left by pushing zeros in from the right and let the leftmost bits fall off

>> Signed right shift

Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off

Added by myself
String concatenation +
"Coucou ' + 'c\'est ' + 'nous !";
'Coucou '.concat('c\'est ', 'nous !');
['Coucou ', 'c\'est ', 'nous !'].join();

Control flow statements

If statements

a = 200
b = 33
if b > a:
     print("b is greater than a")
elif a == b:
     print("a and b are equal")
     print("a is greater than b")

Short Hand If:

 if a > b: print("a is greater than b")

One line if else statement, with 3 conditions:

print("A") if a > b else print("=") if a == b else print("B")

For Loops

Print each fruit in a fruit list:

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:

# Output:

fruits = ["apple", "banana", "cherry"]
for fruit_no, fruit in enumerate(fruits):
     print(fruit_no, fruit)

# Output:
0 apple
1 banana
2 cherry

Looping Through a String:

for x in "banana":

The break Statement:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
     if x == "banana":

The continue Statement: With the continue statement we can stop the current iteration of the loop, and continue with the next:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
     if x == "banana":

The range() Function: The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.

for x in range(6):

Note that range(6) is not the values of 0 to 6, but the values 0 to 5.

The range() Function: The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.

for x in range(2, 30, 3):

While Loops

i = 1
while i < 6:
     i += 1

The break Statement:

i = 1
while i < 6:
     if i == 3:
     i += 1

The continue Statement: With the continue statement we can stop the current iteration, and continue with the next:

i = 0
while i < 6:
     i += 1
     if i == 3:

The else Statement: With the else statement we can run a block of code once when the condition no longer is true:

i = 1
while i < 6:
  i += 1
  print("i is no longer less than 6")

Input and Output

Input and Output funtions: Esta página creo que no está actualizada para python 3, pero está bien organizada:


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'>



The print() function prints the specified message to the screen, or other standard output device:

print("Hello World")

The full syntax of print() is:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Print more than one object:

a = 5
b = a

print('a =', a, '= b')

print() with separator and end parameters:

a = 5
print("a =", a, sep='00000', end='\n\n\n')
print("a =", a, sep='0', end='')

Print a tuple:

x = ("apple", "banana", "cherry")

The String format() Method

Basic usage of the str.format() method looks like this:

print('{0} and {1}'.format('spam', 'eggs'))

Positional and keyword arguments can be arbitrarily combined. It is better to use keyword arguments because it is less likely to make mistake because of the position of the arguments.

print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred', other='Georg'))

Functions and Methods

How to define a Function

def hello():

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

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


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

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


Some important Functions and Methods


type()returns the type of these objects:

a = ('apple', 'banana', 'cherry')
b = "Hello World"
c = 33

x = type(a)
y = type(b)
z = type(c)

List of Functions and Methods

What’s the difference between Python functions and methods?:

After reading this far in the article, I bet you have this question: “Why on Earth do we have both functions and methods, when they practically do the same thing?”

I remember that when I started learning Python, I had a hard time answering this question. This is still the most confusing topic for newcomers in the Python-world.

The official answer is that there is a small difference between them. Namely: a method always belongs to an object (e.g. in the dog.append(4) method .append() needed the dog object to be applicable), while a function doesn’t necessarily. To make this answer even more twisted: a method is in fact nothing else but a specific function. Got it? All methods are functions, but not all functions are methods! Function/Method Description Example
Built-in functions

abs() Returns the absolute value of a numeric value abs(-4/3)
round() Returns the rounded value of a numeric value. round(-4/3)
min() Returns the smallest item of a list or of the typed-in arguments. It can even be a string. min(3,2,5)


sorted() It sorts a list into ascending order. The list can contain strings or numbers. a = [3, 2, 1]sorted(a)
sum() It sums a list. a = [3, 2, 1]sum(a)
len() Returns the number of elements in a list or the number of characters in a string. len('Hello!')
String methods

a.lower() Returns the lowercase version of a string. a = 'MuG'a.lower()
a.strip() If the string has whitespaces at the beginning or at the end, it removes them. a = ' Mug 'a.strip()
a.replace('old', 'new') Replaces a given string with another string. Note that it’s case sensitive. a = 'muh'a.replace('h','g')
a.split('delimiter') Splits your string into a list. Your argument specifies the delimiter. a = 'Hello World'a.split(' ')
'delimiter'.join(a) It joins elements of a list into one string. You can specify the delimiter again. a = ['Hello', 'World']

' '.join(a)

List methods

a.append(arg) Adds an element to the end of our list. dog = ['Freddie', 9, True, 1.1, 2001, ['bone', 'little ball']]


a.remove(arg) We have to specify the element that we want to remove and Python will remove the first item with that value from the list. dog.remove(2001)
a.count(arg) Returns the number of the specified value in a list. dog.count('Freddie')
a.clear() removes all elements of the list. It will basically delete Freddie. No worries, we will get him back. dog.clear()
Dictionaries methods

a.keys() It returns all the keys from your dictionary.
dog_dict.values() It returns all the values from your dictionary.
dog_dict.clear() It deletes everything from your dictionary.
Tuple methods

Set methods

File methods


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

OOP with Python

The self

Class methods have only one specific difference from ordinary functions - they must have an extra first parameter 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()
# 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

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

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

p = Person('Swaroop')
# The previous 2 lines can also be written as
# Person('Swaroop').say_hi()
$ python
Hello, my name is Swaroop

Class And Object Variables

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 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

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)


In this program, we also see the use of docstrings for classes as well as methods. We can access the class docstring at runtime using Robot.__doc__ and the method docstring as Robot.say_hi.__doc__


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

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

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

        # 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(

        Robot.population -= 1

        if Robot.population == 0:
            print("{} was the last one.".format(
            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(

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

droid1 = Robot("R2-D2")

droid2 = Robot("C-3PO")

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

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


$ python
(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.


The SchoolMember class in this situation is known as the base class or the superclass. The Teacher and Student classes are called the derived classes or subclasses.

We will now see this example as a program (save as

class SchoolMember:
    '''Represents any school member.'''
    def __init__(self, name, age): = name
        self.age = age
        print('(Initialized SchoolMember: {})'.format(

    def tell(self):
        '''Tell my details.'''
        print('Name:"{}" Age:"{}"'.format(, self.age), end=" ")

class Teacher(SchoolMember):
    '''Represents a teacher.'''
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print('(Initialized Teacher: {})'.format(

    def tell(self):
        print('Salary: "{:d}"'.format(self.salary))

class Student(SchoolMember):
    '''Represents a student.'''
    def __init__(self, name, age, marks):
        SchoolMember.__init__(self, name, age)
        self.marks = marks
        print('(Initialized Student: {})'.format(

    def tell(self):
        print('Marks: "{:d}"'.format(self.marks))

t = Teacher('Mrs. Shrividya', 40, 30000)
s = Student('Swaroop', 25, 75)

# prints a blank line

members = [t, s]
for member in members:
    # Works for both Teachers and Students

$ python
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"25" Marks: "75"

Some example codes

Factorial function using recursion

A VERY VERY NICE example of recursion is the factorial function:

4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1
Replacing the calculated values gives us the following expression
4! = 4 * 3 * 2 * 1

def factorial(n):
    if n == 1:
        return 1
        return n * factorial(n-1)

Python for Data Science

Python Web Development

Web Frameworks for Python:

Ejemplos de Web Applications in Python:

Complete Python Web Course (15€):



Página oficial:


Instalación de django

Documentación oficial sobre la instalación:

En este video se muestra la instalación dentro del virtual environement:

Aquí se muestran distintas formas de instalar django:


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 previous version, you will need to uninstall the old Django version before installing the new version.

If you installed Django using pip or easy_install previously, installing with pip or easy_install again will automatically take care of the old version, so you don’t need to do it yourself.

If you previously installed Django using python install, uninstalling is as simple as deleting the django directory from your Python site-packages. To find the directory you need to remove, you can run the following at your shell prompt (not the interactive Python prompt):

$ python -c "import django; print(django.__path__)"

Install the Django code

1- Installing an official release with pip

1. Install pip.

The easiest is to use the standalone pip installer. If your distribution already has pip installed, you might need to update it if it’s outdated. If it’s outdated, you’ll know because installation won’t work.

Pip is a package management system for python. Python has a central package repository from which we can download the python package. It's called Python Package Index (PyPI).

In this tutorial, we will use python 3 for django as recommended by the django website. Next, we will install pip for python 3 from the ubuntu repository with this apt command:

apt-get install python3-pip

The installation will add a new binary file called 'pip3'. To make it easier to use pip, I will create a symlink for pip3 to pip:

Para saber donde se encuentra el ejecutable pip3:
which pip3
Luego creamos el symlink:
ln -s /usr/bin/pip3 /usr/bin/pip

Now check the version :

pip -V

Para actualizar pip a su más reciente versión:

pip install --upgrade pip

2. Installer virtualenv avec pip

Este programa permite crear un python virtual environment.

Take a look at virtualenv and virtualenvwrapper. These tools provide isolated Python environments, which are more practical than installing packages systemwide. They also allow installing packages without administrator privileges. The contributing tutorial walks through how to create a virtualenv on Python 3.

virtualenv is a tool to create isolated Python environments. Virtualenv creates a folder which contains all the necessary executables to use the packages that a Python project would need.

Install virtualenv via pip:

$ pip install virtualenv

Test your installation

$ virtualenv --version

Create a virtual environment for a project:

$ cd my_project_folder
$ virtualenv my_project
O si estamos dentro del directorio donde queremos crear el virtual environment:
$ virtualenv .

You can also use the Python interpreter of your choice (like python2.7).

$ virtualenv -p /usr/bin/python2.7 my_project

Then, to begin using the virtual environment, it needs to be activated:

$ source my_project/bin/activate

The name of the current virtual environment will now appear on the left of the prompt (e.g. (my_project)Your-Computer:your_project UserName$) to let you know that it’s active. From now on, any package that you install using pip will be placed in the my_project folder, isolated from the global Python installation.

Install packages as usual, for example:

pip install django==1.11

If you are done working in the virtual environment for the moment, you can deactivate it:

$ deactivate

This puts you back to the system’s default Python interpreter with all its installed libraries.

To delete a virtual environment, just delete its folder. (In this case, it would be rm -rf my_project.)

In order to keep your environment consistent, it’s a good idea to “freeze” the current state of the environment packages. To do this, run

$ pip freeze > requirements.txt

This will create a requirements.txt file, which contains a simple list of all the packages in the current environment, and their respective versions. You can see the list of installed packages without the requirements format using “pip list”. Later it will be easier for a different developer (or you, if you need to re-create the environment) to install the same packages using the same versions:

$ pip install -r requirements.txt

3. Install Django with Pip

After you’ve created and activated a virtual environment, enter the command:

pip install django==1.11 (ejecutarlo dentro del virtual environment)

Para ver la versión de django:

import django
o a través de:
django-admin --version

2- Installing a distribution-specific package

Check the distribution specific notes to see if your platform/distribution provides official Django packages/installers. Distribution-provided packages will typically allow for automatic installation of dependencies and easy upgrade paths; however, these packages will rarely contain the latest release of Django.

En Ubuntu:

sudo apt-get install python3-django

Crear un proyecto django

Primero es apropiado crear un nuevo proyecto Sublime Text que contenga el directorio correspondiente a nuestro virtual environment. Ver Crear un proyecto en Sublime Text

Si hemos instalado django en un virtual envirnment, vamos al virtual environment (si no está activado el virtual environment, debemos hacerlo a través de "source bin/activate") (Ver Instalación de django) y ejecutamos el comando: startproject nombre_proyecto

Si lo hemos instalado de forma global a través de un distribution-specific package, go into any directory where you’d like to store your code, then run the following command:

django-admin startproject nombre_proyecto

Vemos que la diferencia entre la instalación global y la instalación en el virtual environment es que en esta última el comando contiene la extensión .py.

Esto creará un directorio llamado "nombre_proyecto" dentro del cual se encuentra otro directorio con el mismo nombre. Se recomienda renombrar el directorio padre como, por ejemplo, "src".

mv nombre_proyecto src


cd src
python makemigrations
python migrate

By running makemigrations, you’re telling Django that you’ve made some changes to your models (in this case, you’ve made new ones) and that you’d like the changes to be stored as a migration.

The migrate command looks at the INSTALLED_APPS setting and creates any necessary database tables according to the database settings in your mysite/ file and the database migrations shipped with the app (we’ll cover those later).

Creación del superusuario:

Dentro del directorio src:

python createsuperuser

Luego podemos comprobar que nuestro proyecto django está corriendo correctamente ejecutando:

 python runserver

Lo cual debe imprimir una línea como la siguiente:

Starting development server at

Si copiamos en nuestro navegador internet, se abrirá una página que dice:

It worked!
Congratulations on your first Django-powered page

Podemos también ingresar a:

Lo cual nos lleva hacia la página de administración de django. De hecho, esta aplicación corresponde con la orden:


que se encuentra en Si queremos ver el código fuente de django.contrib.admin podemos simplemente ir a google y colocar: django.contrib.admin code. Lo cual nos llevará a esta página: en donde podemos ver todos los archivos que conforman la aplicación django.contrib.admin

Viendo estos códigos podemos entender y aprender a construir aplicaciones de este tipo.

Luego de detener la ejecución del comando runserver ya no podremos ingresar a:

Como se mencionó, django.contrib.admin es un ejemplo de una aplicación django. Ahora, queremos crear nuestra propia aplicación. Para ello ejecutamos (en src):

python startapp nombre_app shortener
Vamos a crear una aplicación llamada shortener:
python startapp shortener



A model is the single, definitive source of truth about your data. It contains the essential fields and behaviors of the data you’re storing. Django follows the DRY Principle. The goal is to define your data model in one place and automatically derive things from it.

En django se utiliza Models to map to the database. Es decir, debemos escribir un código en los Models to make a place to store our data.

Podríamos decir que un Modèle Django est un type particulier d'objet que nos permite interactuar con la base de datos.

Crear un Model

Para crear un model nos vamos al archivo que ha sido creado dentro del directorio correspondiente a nuestra App (shorterner).

Este archivo luce así:

from django.db import models

# Create your models here.
class KirrURL(models.Model): # Creamos la clase KirrURL(cualquier nombre) that inherits(que proviene, que hereda) from models.Model
    url = models.CharFied(max_length=220, ) # Creamos el campo
    def __str__(self): # Definimos una función str
         return str(self.url)

Luego tenemos que adicionar este modelo que hemos creado a Para ello, nos vamos a dicho archivo:

from django.contrib import admin
# Register your models here.
from .models import KirrURL

Luego tenemos que colocar neustra App (shortener) en INSTALLET_APPS del archivo

    # Mis Apps:

Luego debemos correr:

python makemigrations
python migrate