martes, 30 de mayo de 2017

Creando my Blog con Django VI: login y logout 馃挭

Hola a todos! Bienvenidos a la sexta parte de "Creando my Blog con Django" ☺.

Llegados a este punto, ya habr谩s creado las correspondientes urls, y las funciones y clases de las vistas de la aplicaci贸n d贸nde mayormente hab铆a que estar logado, para acceder a esas vistas del blog.

Por eso, ahora es un gran momento, para agregar las urls del proyecto. ¿Qu茅 urls? Las urls de login y de logout.

Com茅nzamos! 馃憤

C贸mo en la ruta url, vamos a linkear un template. As铆, a帽adimos en la ruta templates/registration un archivo html para el login:

        login.html



Dentro de la urls.py del proyecto importamos las vistas de la librer铆a referente a la autorizaci贸n
de contenido:

        from django.conf.urls import url, include
        from django.contrib.auth import views
        from django.contrib import admin



Y a帽adimos las urls, d贸nde kwargs es un dictionario que nos va a permitir manejar argumentos que no han sido todav铆a declaradas:

         url(r'^acounts/login/$', views.login, name='login'),
         url(r'^acounts/logout/$', views.logout, name='logout', kwargs = {'next-page':'/'}), 



Ahora creamos en el login.html , que extiende base.html, un jumbotron para destacarlo.
Jumbotron es propio de Bootstrap , qu茅 es un framework de JS, Html y Css. En su p谩gina
oficial acceder谩s a una formaci贸n muy completa de la misma.

As铆, nuestro login.html queda como lo siguiente:

  {% extends 'blog/base.html' %}
    {% block content %}
     <div class = "jumbotron">
         <h2>Por favor Login:</h2>
              <h3>Debes ser SuperUser, por favor compru茅balo con el administrador</h3>
             {% if form.errors %}
                   <p>Tu nombre de usuario y password no concuerdan! Int茅ntalo otra vez!</p>
              {% endif %}
        <form  action = "{% url 'login' %}" method = "POST"}
          {% csrf-token %}
          {% form.as_p %}
                <input type="submit" class='btn btn-primary' value="Login">
                <input type="hidden" name="next" value="<<next>>">
       </form>
    </div>

          

Y, objetivo cumplido!  Lo siguiente ser谩 empezar a trabajar con el template de la base. Es decir, base.html , base.css y base.js ☺.

Much铆simas gracias y nos vemos en la siguiente.
Hasta luego!




lunes, 29 de mayo de 2017

Creando my Blog con Django V: funciones con login requerido 馃挭

Hola a todos! Bienvenidos a la quinta parte de Creando my Blog con Django .

Si est谩s, en esta quinta parte, seguramente ya tienes a帽adidas vistas y urls que era el objetivo
del post anterior ☺. 

Aunque la anterior parte, era un gran avance en nuestro proyecto, no hemos terminado con los archivos views.py y urls.py. Es decir,  茅ste podr铆a ser la segunda parte de la creaci贸n de vistas y urls perfectamente, pero por comodidad para el lector para seguir el proyecto, se ha considerado no hacer subdivisiones. As铆, no se incluir谩n explicaciones que ya se hicier贸n en pasos anteriores.


Ahora bien, ¿Qu茅 nos queda por a帽adir en las views.py?

Nos quedan por a帽adir , las funcionalidades de publicar post, a帽adir  comentario del post y borrar
comentario del post. Todas estas funcionalidades podr谩n estar disponibles una vez que est茅s logado.


  


                      Creaci贸n de funciones en views.py con su respectiva url en urls.py

Comenzamos creando las funciones para las vistas 馃挭!

En views.py de la aplicaci贸n, debemos de importar dos elementos, uno de redireccionar, y otro
que levanta la excepci贸n Http404 si no encuentra el post o el comentario solicitado por la clave
primaria:

from django.shortcuts import render, get_object_or_404, redirect



Empezamos a definir nuestras funciones, que entre otras cosas, hacemos uso de los decorators, que en este caso, nos permite restringirlas para que accedas a ellas una vez que est谩s logado:



@login_required
def add_comment_to_post(request,pk):
    post = get_object_or_404(Post, pk = pk)
    if request.method == 'POST':
        form = CommentForm(request.POST)
        if form.is_valid():
            comment = form.save(commit = False)
            comment.post = post
            comment.save()
            return redirect('post_detail', pk = post.pk)
    else:
        form = CommentForm()
        return render(request,'blog/comment_form.html',{'form':form})

@login_required
def comment_remove(request,pk):
    comment = get_object_or_404(Comment, pk = pk)
    post_pk = comment.post.pk
    comment.delete()
    return redirect('post_detail', pk = post.pk)


@login_required
def post_publish(request,pk):
    post = get_object_or_404(Comment, pk = pk)
    post.publish
    return redirect('post_detail', pk = pk)
          

        
Ahora, creamos las urls para cada funci贸n. Es decir, definimos su ruta (incluye primary key) , ll谩mamos a la funci贸n definida en la vista, y el nombre de la misma:

url(r'^post/(?P<pk>\d+)/comment/$',
     views.add_comment_to_post, 
     name='add_comment_to_post'), 

url(r'^comment/(?P<pk>\d+)/remove/$',
     views.comment_remove, 
     name='comment_remove'), 

url(r'^post/(?P<pk>\d+)/publish/$', 
     views.post_publish, 
     name='post_publish'),


Y esto es todo por hoy ☺!  Muchas gracias por todo su tiempo y espero que est茅n disfrutando
mucho en la creaci贸n de su blog con Django.
Hasta luego!

viernes, 26 de mayo de 2017

Creando my Blog con Django IV: creando las vistas y las urls 馃挭

Muy bienvenidos a esta cuarta parte de c贸mo crear nuestro blog con Django!

Una vez llegados  a este punto, nuestros objetivos, por ahora, ser谩n  crear las vistas necesarias para nuestro blog, y definir una url para cada una de las vistas.


¿Pero, qu茅 har谩n nuestras vistas?
   
Nuestras vistas ser谩n m茅todos en python, que  devolver谩n la informaci贸n solicitada en nuestro blog.

Por ejemplo, si queremos incluir la opci贸n de ver un listado de los posts publicados hasta una fecha concreta, debemos crear una vista haciendo uso de su modelo de datos (en este caso el modelo Post creado) con una query que filtre por un rango de fecha.

As铆, como se puede apreciar en el ejemplo, haremos uso de posts y formularios entre otros elementos.

Comenzamos con la creaci贸n de vistas ☺.




                                                      Creando nuestras Vistas 


Para la creaci贸n de nuestras vistas, necesitaremos primero, crear los archivos base.html y
about.html (extensi贸n de base.html) dentro de la carpeta blog en templates.


Dentro de about.html, a帽adimos qu茅 茅ste, es una extensi贸n de base.html:

             {% extends 'blog/base.html' %}


Ahora estamos preparados para acceder a views.py dentro de la aplicaci贸n d贸nde
tenemos que ir a帽adiendo el siguiente c贸digo 馃挭:
 
from django.shortcuts import render 
from blog.models import Post, Comment   #A帽adiendo los modelos a utilizar
from django.views.generic import (TemplateView, #importar vista tipo para templates!
                                  ListView,
                                  DetailView,
                                  CreateView,
                                  UpdateView,
                                  DeleteView,
                                  )
from django.contrib.auth.mixins import LoginRequiredMixin  #referente a comprobar login馃憤
from django.contrib.auth.decorators import login_required
from blog.forms import PostForm, CommentForm  #A帽adiendo forms
from django.urls import reverse_lazy  #obtener url 馃憤


# Create your views here.
class AboutView(TemplateView):
    template_name = 'about.html'   #M茅todo para mostrar un template.


class PostListView(ListView):
    model = Post                       #Mostrar un listado filtrado y ordenado por fecha de publicaci贸n
    def get_queryset(self):        #accediendo al modelo de datos Post
        return Post.objects.filter(published_date_lte=timezone.now()).order_by('-published_date')


class PostDetailView(DetailView):
    model = Post  # Simplemente accede al modelo para mostrarlo


class CreatePostView(LoginRequiredMixin, CreateView):
    login_url ='/login/'   #Para crear un post, necesitamos el login, nuestro formulario
    redirect_field_name ='blog/post_detail.html/' #y acceder, a nuestro modelo Post.
    form_class = PostForm  #Y, debemos de ser capaces de redirigir a los detalles (datos).
    model = Post


class PostUpdateView(LoginRequiredMixin, UpdateView): #Igual que Crear
    login_url ='/login/'
    redirect_field_name ='blog/post_detail.html/'
    form_class = PostForm
    model = Post


class PostDeleteView(LoginRequiredMixin, DeleteView): #Acceder al modelo para borrar datos
    model = Post                                                                     #Acceder a su url a trav茅s del nombre
    success_url = reverse_lazy('post_list') #Para borrar, tienes que estar logado


class DraftListView(LoginRequiredMixin, ListView): #Filtrado por fecha de publicaci贸n nula
    login_url = '/login/'                                                 
    redirect_field_name = '/blog/post_list.html/'
    model = Post
    def get_queryset(self):
        return Post.objects.filter(published_date_isnull=True).order_by('created_date')

  


Bien! Ahora, vamos a crear nuestras urls, pero primero debemos de crear un archivo urls.py
dentro de nuestra aplicaci贸n.




Estableciendo las Urls 


Ahora, en el archivo urls.py de nuestro proyecto, vamos a incluir la urls.py de nuestra aplicaci贸n
(blog) , d贸nde vamos a establecer las urls de nuestras vistas:
       
              from django.conf.urls import url, include
              from django.contrib import admin

              urlpatterns = [
                    url(r'^admin/', admin.site.urls),
                    url(r' ',include('blog.urls')),  
                    ]
         
    
Ahora s铆! Vamos a crear nuestras urls en el urls.py de nuestra aplicaci贸n, y aqu铆 debemos de importar nuestras vistas:

             from django.conf.urls import url
             from blog import views




Y , para cada vista, una url d贸nde, primero definimos nuestra ruta, importamos nuestra vista,
y le asignamos un nombre 馃槈:

   urlpatterns = [
         url(r'^$', views.PostListView.as_view(), name='post_list'),
         url(r'^about/$', views.AboutView.as_view(), name = 'about'),
         url(r'^post/(?P<pk>\d+)$', views.PostDetailView.as_view(), name='post_detail'),
         url(r'^post/new/$',views.CreatePostView.as_view(), name='post_new'),
         url(r'^post/(?P<pk>\d+)/edit/$', views.PostUpdateView.as_view(), name='post_edit'),
         url(r'^post/(?P<pk>\d+)/remove/$', views.PostDeleteView.as_view(), name='post_remove'),
         url(r'^drafts/$', views.DraftListView.as_view(), name='post_draft_list'),
      ]





Pero, ¿Qu茅 es (?P<pk>\d+)?

Es una expresi贸n regular d贸nde basicamente se est谩 uniendo la primary key del objeto a la url.


Si est谩s interesada o interesado en expresiones regulares, la documentaci贸n de python 3 es id贸nea ☺

Bueno, comprueba que no hay ning煤n error en tu proyecto, y nos vemos en la parte V del proyecto.

Gracias y hasta pronto!

Creando my Blog con Django III: estableciendo paths en settings.py 馃挭

Hola a todos! 
Si ya creaste los modelos  en models.py y los formularios en forms. py, est谩s en el punto
adecuado para empezar a estar realmente motivado en avanzar en este proyecto.

Pero, antes de avanzar todo lo que deseamos, tenemos que crear carpetas y establecerlas en settings.py. Nuestra principal tarea constar谩 en establecer d贸nde est谩 el contenido est谩tico (Html, Css, Javascript) de nuestro proyecto 馃憤. Comenzamos!




Creaci贸n de Carpetas y Archivos
 
  • Crear dentro de tu aplicaci贸n, la carpeta static.
  • Crear dentro de la carpeta static las carpetas:
                            * css
                            * js

  • Crear dentro de la carpeta css el archivo  blog.css.
  • Crear una nueva carpeta en tu aplicaci贸n, que se llame templates.

  • Dentro de templates, crear las carpetas:
                          * blog
                          * registration 




Estableciendo en settings.py 


Una vez que hemos creado las carpetas correspondientes, tenemos que decirle a nuestro proyecto 
la ruta para acceder a ellas. As铆, se lo vamos a decir desde settings.py de nuestro proyecto 馃槈
 
  • Desde el archivo settings.py del proyecto, a帽adir debajo la direcci贸n de 
          la carpeta static que es la BASE_DIR unida con 'static' (nombre carpeta):                       
                         STATIC_ROOT = os.path.join(BASE_DIR,'static')
 


  •  Y definimos la direcci贸n de los templates debajo de BASE_DIR:

                 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
                 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

                 TEMPLATE_DIR = os.path.join(BASE_DIR, 'blog/templates/blog')


  •  En el array de TEMPLATES, vamos a a帽adir la direcci贸n establecida:
                         TEMPLATES = [
                       {
                              'BACKEND': 'django.template.backends.django.DjangoTemplates',
                               'DIRS': [TEMPLATE_DIR,],
                               'APP_DIRS': True,
                               'OPTIONS': {
                                 'context_processors': [
                                     'django.template.context_processors.debug',
                                     'django.template.context_processors.request',
                                     'django.contrib.auth.context_processors.auth',
                                     'django.contrib.messages.context_processors.messages',
                                   ],
                               },
                           },
                      ]



  • Por 煤ltimo, para redirigir a la ra铆z del blog, una vez que hemos accedido a 茅ste:
                       
                      LOGIN_REDIRECT_URL = '/' 



Well done!! Esta es la tarea que ten铆amos encomendado hasta ahora. 

Ya estamos preparados para crear vistas haciendo uso de nuestros formularios, e identificar 茅stas 
con una url. Esto lo trataremos en el IV post☺ .

Much铆simas gracias y hasta pronto! 


         

jueves, 25 de mayo de 2017

Creando my Blog con Django II: los forms o formularios 馃挭

Hola a todos! Tras desarrollar nuestros modelos Post y Comentario, en la primera parte de
Creando my Blog con Django, estamos listos para crear nuestros formularios☺.

Django te permite crearlos desde cero o con un modelForm.

En nuestro caso vamos a crear un formulario para Comentario , y otro para Post, con un modelForm,
haciendo uso de sus respectivos modelos.


As铆, el primer paso es crear dentro de tu aplicaci贸n, el archivo forms.py.

Una vez creado el archivo, dentro de 茅l, vamos a definir nuestros formularios, y para eso  necesitamos importar los forms desde Django, y las clases Post, Comment que se encuentran en el archivo models.py :

       from django import forms
       from blog.models import Post, Comment



Ahora estamos preparados para definir las clases PostForm y CommentForm:

      class PostForm(forms.ModelForm):

      class CommentForm(forms.ModelForm):






Dentro de cada clase, creamos la clase Meta() d贸nde definimos su modelo,
los campos que vamos a coger del modelo, y sus widgets (tipo y atributos):

    # Para class PostForm
    class Meta():
        model = Post
        fields =('author','title','text')
        Widgets = {
           'title': forms.TextInput(attrs = {'class':'textInputClass'}),
           'text' : forms.Textarea(attrs ={'class':'editable medium-editor-textarea postcontent'})
        }



    #Para class CommentForm
    class Meta():
        model = Comment
        fields =('author','text')
        Widgets = {
           'title': forms.TextInput(attrs = {'class':'textInputClass'}),
           'text' : forms.Textarea(attrs ={'class':'editable medium-editor-textarea'})
        }



Comprueba que no aparece ning煤n error al actualizar tu proyecto.  Si lo has conseguido,
enhorabuena!

Como ves, todav铆a no le hemos dado forma est茅tica al blog.
Habr谩 que ir empezando a crear contenido est谩tico, y para eso, te invito a seguir con la tercera parte 馃挭.
Nos vemos en el pr贸ximo post!


mi茅rcoles, 24 de mayo de 2017

Creando my Blog con Django I: los models o modelos 馃挭

Muy bienvenidos a todos a este post, que tratar谩 la creaci贸n de un blog con Django. 

En esta primera parte, vamos a explicar qu茅 es un modelo y c贸mo crearlos para nuestro proyecto ☺.

Pero, si todav铆a no has creado tu primer proyecto y no est谩s seguro de c贸mo hacerlo, te invito a 
pinchar en el siguiente link : instalaci贸n y creaci贸n de un proyecto Django


Bien. Si ya has creado tu proyecto y tu aplicaci贸n, es el momento id贸neo para crear contenido! 


¿Qu茅 ocurre con ese contenido? 
Que parte de este contenido, ser谩 en forma de datos, que  deben de ser guardados en alg煤n lugar de manera persistente, es decir, en nuestra base de datos.


 ¿C贸mo ser谩n guardados? 
C贸mo objetos , es decir, vamos a trabajar con programaci贸n orientada a objetos d贸nde definiremos los modelos a trav茅s de clases, d贸nde  a su vez, definiremos los campos de cada uno.


Para ello, abrimos el archivo model.py de nuestra aplicaci贸n (nuestro blog) :



Importamos las librer铆as que vamos a utilizar  para tomar nuestra zona horaria y la url :

     from django.utils import timezone
     from django.core.urlresolvers import reverse


Creamos el modelo Post (para nuestros Post) que incluye el autor, el t铆tulo, texto,
fecha de creaci贸n y la fecha de publicaci贸n del Post:

    class Post(models.Model):
       author = models.ForeignKey('auth.User')
       title = models. CharField(max_length = 200)
       text = models.TextField()
       create_date = models.DateTimeField(default = timezone.now())
       published_date = models.DateTimeField(blank = True, null = True)



Dentro del modelo Post, creamos la funci贸n publicar, que guarda la fecha de publicaci贸n cogiendo la zona horaria actual:

    def publish(self):
        self.published_date= timezone.now()
        self.save()

Otra  funci贸n que incluir es la que devuelve los comentarios filtrados por aprobados:

    def approve_comments(self):
        return self.comments.filter(approved_comments= True)



Mediante la funci贸n de obtener url para la clase Post, se devuelve la url requerida:

    def get_absolute_url(self):
        return reverse('post_date',kwags={'pk',self.pk})



La 煤ltima funci贸n de nuestra clase, es la que devuelve la cadena de caracteres del t铆tulo:

    def __str__(self):
        return self.title


Bien hecho! Ya hemos definido la clase Post馃憤.  

Referente a la creaci贸n de modelos, tan solo nos queda definir la clase que va a modelar los comentarios de nuestro blog con el post al que pertenece, el autor del comentario, el texto 
o  comentario, el d铆a de su creaci贸n y si el comentario es aprobado (por defecto False):

     class Comment(models.Model):
          post = models.ForeignKey('blog.Post', related_name = 'comments')
          author = models.CharField(max_length = 200)
          text = models.TextField()
          create_date = models.DateTimeField(default = timezone.now())
          approved_comment = models.BooleanField(default = False)


Funciones que incluir en nuestra clase y que son muy parecidas a las mencionadas anteriormente:

      def approved_comments(self):
        models.BooleanField(default=False)
   

      def approve(self):
        self.approved_comment = True
        self.save()

      def get_absolute_url(self):
        return reverse('post_list')

      def __str__(self):
        return self.text


Perfecto! Hemos creado nuestro modelos. ¿Pero lo hemos creado correctamente? Por ahora, 
el error que podemos depurar es de sintaxis.... si accedes a tu proyecto desde la l铆nea de
comandos y tecleas:

        python manage.py runserver 

Si has arrancado el servidor correctamente y ves algo parecido a la siguiente imagen, es decir, la misma que en la anterior vez que lo arrancaste para comprobar la creaci贸n del proyecto, objetivo cumplido chicos 馃槈!


Agradecerte mucho tu tiempo y nos vemos muy pronto en la segunda parte de "Creando my 
Blog con Django 馃挭".



  




martes, 16 de mayo de 2017

Si no tienes Python, instala directamente Anaconda!



Muy bienvenidos a todos a este nuevo post acerca de c贸mo proceder a instalar Python desde Anaconda.

Si os hab茅is animado a pinchar en la palabra "Python", habr茅is accedido a la p谩gina oficial d贸nde pod茅is descargar el paquete acorde a vuestra plataforma, para proceder a su instalaci贸n.

No obstante, os recomendamos que acced谩is al enlace de la palabra "Miniconda" qu茅 es d贸nde haremos nuestra descarga.

Muy importante: ¿Por qu茅 vamos a descargar Anaconda?

Si queremos trabajar con un proyecto d贸nde su Backend est谩 desarrollado con este lenguaje, tambi茅n  necesitaremos, un gestor de paquetes y un gestor de entornos. Anaconda incluye todo esto, adem谩s de los paquetes m谩s importantes (ampliables) que se utilizan en las ciencias de datos.


En nuestro caso particular, c贸mo m谩s tarde instalaremos Django y, andamos escaso de espacio en nuestro disco,  procedemos a instalar Miniconda (Peque帽a Anaconda) :

  1.  Descargamos el paquete comprimido de Miniconda.
  2.  Instalamos Miniconda de manera sencilla para Windows y damos al bot贸n de finalizar:

      3. Por 煤ltimo, comprobamos que funciona correctamente tecleando la palabra "Python"
          en la l铆nea  de comandos. Voil脿 !!





Si has llegado a este punto felicidades. Es momento de programar 馃憦 . A los que quieran trabajar con Django directamente, les queda algo m谩s que hacer que pueden ver en Instalaci贸n y Creaci贸n de un proyecto Django en Windows.

Muchas gracias por acompa帽arnos!! Nos vemos!!!

lunes, 15 de mayo de 2017

Instalaci贸n y Creaci贸n de un proyecto Django en Windows

 
 
Si ya posees, al menos, unos conocimientos b谩sicos de Python, 
quiz谩s quieras proceder a instalar Django para  desarrollar un 
proyecto web en tu sistema operativo Windows. 
 
 
Si has realizado la instalaci贸n de Python con Anaconda o Miniconda,
quiz谩s sepas que no incluye el framework que vamos a instalar.
 
 
Para ello, primero debemos instalar pip, que es un sistema de 
gesti贸n de paquetes escritos en Python. 


As铆 accedemos a la l铆nea de comandos de nuestro ordenador, y 
tecleamos:
 
   conda install pip 
 
 
Ahora creamos la carpeta que contendr谩 nuestro proyecto:
 
   mkdir nombre_carpeta 
 
 
Nos direccionamos hacia la carpeta creada:
 
   cd .../nombre_carpeta  
 
 
Para trabajar con diferentes versiones del mismo paquete, es 
necesarioinstalar virtualenv en la carpeta creada:
 
   conda create -n myenv python 
 
 
Ahora procedemos a su activaci贸n:
 
   activate myenv
 
  
 
Una vez activado, accedemos a  instalar Django.
   Si queremos la 煤ltima versi贸n:
        pip install django
 
 
   Si queremos una versi贸n en concreto, como la versi贸n 1.8.1: 
 
        pip install django==1.8.1
 
 
Una vez que has realizado todo estos pasos, ya puedes crear tu 
projecto!¿Qu茅 nombre quieres ponerle? Tendr谩s que teclear lo 
siguiente:
 
    django-admin startproject nombre_proyecto
 
As铆, se habr谩 creado un proyecto con el nombre elegido que tendr谩 
lossiguientes archivos:
 
 
 
M谩s adelante conoceremos las utilidades de cada archivo.
 
 
Es usual, que un proyecto web necesite una base de datos. 
 
Vamos a crearlo!Pero primero, tendremos que redirigirnos a nuestro
proyecto!
 
    cd nombre_proyecto 
 

Ahora s铆, ahora creamos nuestra base de datos:

    python manage.py migrate
  
 
Bien! Arrancamos el servidor:
  
   python manage.py runserver
 
 
 
Y voil脿!! Congratulations!!!! 馃榾
 
 
Ahora vamos a crear una aplicaci贸n dentro de nuestro proyecto:
 
   python manage.py startapp app_name  



En el archivo settings.py, tendr谩s que a帽adir el nombre de tu aplicaci贸n 
dentro de: 
 
    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app_name',
    ] 
 
Ahora solo queda arrancar el servidor y comprobar que vuelve a salir la 
imagen anterior.  
         
 
Muchas gracias a todos. Esperamos que os haya sido de utilidad.
 
Hasta la pr贸xima! 
  

mi茅rcoles, 10 de mayo de 2017

Un editor de texto bueno y free para mi c贸digo


A la hora de desarrollar nuestro c贸digo, adem谩s de que funcione, tiene que ser lo m谩s conciso, legible y limpio posible.

Todo estos requisitos se agilizan con la ayuda de un buen editor de texto.

¿Cu谩l es el mejor bajo nuestra experiencia, de todas las opciones gratuitas?       Atom 

Desarrollado por GitHub, es multiplataforma, nos permite instalar paquetes, autocompletado, control de versiones, y un largo etc茅tera.


Para ponerlo a punto en nuestro Windows, hemos realizado los siguientes pasos:
  1.  Creamos una carpeta de web development en nuestro escritorio.
  2.  Descargamos nuestro Atom en la carpeta creada en el punto 1.
  3.  Instalamos Atom  en la carpeta en el que fue descargado.
  4.  Abrimos Atom y nos encontraremos con una gu铆a de bienvenida, y un editor vac铆o entre otros elementos .



Ahora instalaremos nuestra terminal, para m谩s adelante, tambi茅n  instalar  todos los paquetes b谩sicos para trabajar con Python y Django, y poder lanzar los programas que editaremos:

  1.  Pinchamos la pesta帽a de instalar un paquete y abrimos el instalador:





       2.  A continuaci贸n instalamos el terminal. El paquete a instalar es una versi贸n de 
            platformio-ide-terminal:

         



      3.  Una vez instalado el paquete, nos encontraremos en la esquina izquierda
            inferior, el s铆mbolo "+" . 
            Este s铆mbolo nos permite abrir una ventana para la consola:



Y tach谩n! Ya podemos trabajar con nuestra terminal desde la consola de Atom 馃憤.

El siguiente paso, en el caso de que quieras trabajar con Python, instalar Python.
Esto lo trataremos en otro post, ya desde Atom.

Muchas gracias por leernos.

Hasta otra!!





Creando my Blog con Django VI: login y logout 馃挭

Hola a todos! Bienvenidos a la sexta parte de "Creando my Blog con Django" ☺. Llegados a este punto, ya habr谩s creado las cor...