República bolivariana de Venezuela

Ministerio del poder popular para la educación

Instituto universitario de tecnología
Dr José Gregorio Hernández
Valera Estado Trujillo

PYTHON

Integrante: Andreína Oliviar

C.I: V.-28.322.525
Docente: Jairo Viloria

Informática 5to trimestre

Python proporciona numerosas funciones integradas que están disponibles para
nosotros en la solicitud de Python.
Algunas de las funciones como y se utilizan ampliamente para operaciones
estándar de entrada y salida respectivamente. Veamos primero la sección de
salida. input() print()
La función input()
La función input() permite obtener texto escrito por teclado. Al llegar a la función, el
programa se detiene esperando que se escriba algo y se pulse la tecla Intro, como
muestra el siguiente ejemplo:
print("¿Cómo se llama?")
nombre = input()
print(f"Me alegro de conocerle, {nombre}"
el cual el siguiente código fuente mostrara en pantalla algo como esto:
¿Cómo se llama?
María
Me alegro de conocerle, María
Salida de Python mediante la función print()
Utilizamos la función para generar datos en el dispositivo de salida estándar
(pantalla). También podemos generar datos en un archivo,pero esto se discutirá
más adelante.print()
A continuación, se muestra un ejemplo de su uso.
print('This sentence is output to the screen')

Python tiene varios kits de herramientas de interfaz de usuario (o GUI) diferentes

que se pueden usar para crear formularios. Cuál elija dependerá de sus propias
preferencias, y todo puede funcionar en Excel con PyXLL.
Estas son algunas opciones que sabemos que se han utilizado con PyXLL.
PyQt5 - https://pypi.org/project/PyQt5
tkinter - https://docs.python.org/3/library/tkinter.html
wxWindows - https://wxpython.org
Si ya está familiarizado con VBA UserForms y prefiere seguir usándolos, entonces
puede hacerlo. Las funciones de Python decoradas con @xl_macro se pueden
llamar desde VBA mediante el método "Ejecutar" de VBA. Consulte Llamada de
macros desde Excel.
PyQt5 es una opción popular, ya que es fácil de usar y se puede utilizar para crear
interfaces de usuario de aspecto profesional complejo.
PyXLL 5 incluye compatibilidad con "Paneles de tareas personalizados". Esto le
permite incrustar ventanas de Python (o widgets) en Excel sin problemas.
Consulte Interfaces de usuario personalizadas en la guía del usuario para obtener
más información. A partir de PyXLL 5, esta es la forma recomendada de agregar
formularios a Excel con PyXLL.
A menos que esté planeando crear sitios web y aplicaciones que no hagan más
que publicar contenido y no acepten la opinión de sus visitantes, tendrá que
comprender y usar formularios.
Django proporciona una gama de herramientas y bibliotecas para ayudarle a crear
formularios para aceptar la entrada de los visitantes del sitio y, a continuación,
procesar y responder a la entrada.
Formularios HTML
En HTML, un formulario es una colección de elementos dentro que permiten a un
visitante hacer cosas como introducir texto, seleccionar opciones, manipular
objetos o controles, etc., y luego enviar esa información al
servidor.<form>...</form>
Algunos de estos elementos de interfaz de formulario - entrada de texto o casillas
de verificación - están integrados en html sí mismo. Otros son mucho más
complejos; una interfaz que aparece un selector de fechas o le permite mover un
control deslizante o manipular controles normalmente utilizará JavaScript y CSS,
así como elementos de formulario HTML para lograr estos efectos.<input>
Además de sus elementos, un formulario debe especificar dos cosas:<input>
donde: la DIRECCIÓN URL a la que deben devolverse los datos correspondientes
a la entrada del usuario
cómo: el método HTTP los datos deben ser devueltos por
Por ejemplo, el formulario de inicio de sesión para el administrador de Django
contiene varios elementos: uno para el nombre de usuario, uno para la contraseña
y otro para el botón "Iniciar sesión". También contiene algunos campos de texto
ocultos que el usuario no ve, que Django utiliza para determinar qué hacer a
continuación.<input>type="text"type="password"type="submit"
También indica al explorador que los datos del formulario deben enviarse a la
dirección URL especificada en el atributo 's - y que deben enviarse mediante el
mecanismo HTTP especificado por el atributo - .<form>action/admin/methodpost
Cuando se desencadena el elemento, los datos se devuelven a .<input
type="submit" value="Log in">/admin/
GET y POST
GET y son los únicos métodos HTTP para usar al tratar con formularios.POST
El formulario de inicio de sesión de Django se devuelve mediante el método, en el
que el explorador agrupa los datos del formulario, los codifica para su transmisión,
lo envía al servidor y, a continuación, recibe de nuevo su respuesta.POST
GET, por el contrario, agrupa los datos enviados en una cadena y los utiliza para
componer una dirección URL. La dirección URL contiene la dirección donde se
deben enviar los datos, así como las claves de datos y los valores. Puede ver esto
en acción si hace una búsqueda en la documentación de Django, que producirá
una dirección URL del formulario .https://docs.djangoproject.com/search/?
q=forms&release=1
GET y se utilizan normalmente para diferentes propósitos.POST
Cualquier solicitud que se pueda utilizar para cambiar el estado del sistema - por
ejemplo, una solicitud que realice cambios en la base de datos - debe usarse .
sólo se debe utilizar para solicitudes que no afectan al estado del
sistema.POSTGET
GET también sería inadecuado para un formulario de contraseña, porque la
contraseña aparecería en la DIRECCIÓN URL, y por lo tanto, también en el
historial del navegador y los registros del servidor, todo en texto sin formato.
Tampoco sería adecuado para grandes cantidades de datos, o para datos
binarios, como una imagen. Una aplicación web que utiliza solicitudes de
formularios de administración es un riesgo de seguridad: puede ser fácil para un
atacante imitar la solicitud de un formulario para obtener acceso a partes
confidenciales del sistema. , junto con otras protecciones como la protección
CSRF de Django ofrece más control sobre el acceso.GETPOST
Por otro lado, es adecuado para cosas como un formulario de búsqueda web, ya
que las direcciones URL que representan una solicitud se pueden marcar,
compartir o volver a enviar fácilmente.GETGET
El papel de Django en las formas
El manejo de formularios es un negocio complejo. Considere el administrador de
Django, donde es posible que deban prepararse numerosos elementos de datos
de varios tipos diferentes para su visualización en un formulario, representado
como HTML, editado mediante una interfaz conveniente, devuelto al servidor,
validado y limpiado y, a continuación, guardado o transmitido para su posterior
procesamiento.
La funcionalidad de formulario de Django puede simplificar y automatizar vastas
porciones de este trabajo, y también puede hacerlo de forma más segura de lo
que la mayoría de los programadores podrían hacer en el código que ellos mismos
escribieron.
Django maneja tres partes distintas del trabajo involucradas en las formas:
preparación y reestructuración de datos para que esté listo para
creación de formularios HTML para los datos
recepción y tratamiento de formularios y datos enviados del cliente
Es posible escribir código que hace todo esto manualmente, pero Django puede
encargarse de todo por usted.
Formularios en Django
Hemos descrito formularios HTML brevemente, pero un HTML es sólo una parte
de la maquinaria requerida.<form>
En el contexto de una aplicación web, 'form' puede hacer referencia a ese HTML ,
o al Formulario Django que lo produce, o a los datos estructurados devueltos
cuando se envían, o a la colección de trabajo de extremo a extremo de estos
elementos.<form>
La clase Django Form
En el corazón de este sistema de componentes está la clase Form de Django. De
la misma manera que un modelo Django describe la estructura lógica de un objeto,
su comportamiento y la forma en que sus partes se representan para nosotros,
una clase Form describe un formulario y determina cómo funciona y aparece.
De forma similar que los campos de una clase de modelo se asignan a campos de
base de datos, los campos de una clase de formulario se asignan a elementos de
formulario HTML. (Un ModelForm asigna los campos de una clase de modelo a
elementos de formulario HTML a través de un Formulario;esto es en lo que se
basa el administrador de Django.)<input><input>
Los campos de un formulario son clases en sí mismos; administran los datos del
formulario y realizan la validación cuando se envía un formulario. Un DateField y
un FileField manejan tipos muy diferentes de datos y tienen que hacer cosas
diferentes con él.

Un campo de formulario se representa a un usuario en el navegador como un

"widget" HTML - una pieza de maquinaria de interfaz de usuario. Cada tipo de
campo tiene una clase Widgetpredeterminada adecuada, pero se pueden invalidar
según sea necesario.
Creación de instancias, procesamiento y formularios de representación
Al representar un objeto en Django, generalmente:
obtener de ella en la vista (obtenerlo de la base de datos, por ejemplo)
pasarlo al contexto de la plantilla
expandirlo al marcado HTML utilizando variables de plantilla
Representar un formulario en una plantilla implica casi el mismo trabajo que
representar cualquier otro tipo de objeto, pero hay algunas diferencias clave.
En el caso de una instancia de modelo que no contenía datos, rara vez sería útil
hacer algo con ella en una plantilla. Por otro lado, tiene todo el sentido renderizar
una forma despoblada - eso es lo que hacemos cuando queremos que el usuario
lo llene.
Por lo tanto, cuando manejamos una instancia de modelo en una vista,
normalmente la recuperamos de la base de datos. Cuando estamos tratando con
un formulario normalmente lo creamos una instancia en la vista.
Cuando creamos una instancia de un formulario, podemos optar por dejarlo vacío
o rellenarlo previamente, por ejemplo con:
datos de una instancia de modelo guardada (como en el caso de formularios de
administrador para su edición)
datos que hemos recopilado de otras fuentes
datos recibidos de un envío de formulario HTML anterior
El último de estos casos es el más interesante, porque es lo que hace posible que
los usuarios no sólo lean un sitio web, sino que también le devuelvan información.
Construcción de un formulario
El trabajo que hay que hacer
Supongamos que desea crear un formulario simple en su sitio web, con el fin de
obtener el nombre del usuario. Necesitarías algo como esto en tu plantilla:

<form action="/your-name/" method="post">

<label for="your_name">Your name: </label>
<input id="your_name" type="text" name="your_name"
value="{{ current_name }}">
 <input type="submit" value="OK">
</form>
Esto indica al explorador que devuelva los datos del formulario a la dirección URL,
utilizando el método. Mostrará un campo de texto, con la etiqueta "Su nombre:", y
un botón marcado como "OK". Si el contexto de plantilla contiene una variable, se
usará para rellenar previamente el campo./your-
name/POSTcurrent_nameyour_name
Necesitará una vista que represente la plantilla que contiene el formulario HTML y
que pueda proporcionar el campo según corresponda.current_name
Cuando se envía el formulario, la solicitud que se envía al servidor contendrá los
datos del formulario.POST
Ahora también necesitará una vista correspondiente a esa dirección URL que
encontrará los pares clave/valor adecuados en la solicitud y, a continuación, los
procesará./your-name/
Esta es una forma muy simple. En la práctica, un formulario puede contener
docenas o cientos de campos, muchos de los cuales podrían necesitar ser
rellenados previamente, y es posible que esperemos que el usuario trabaje a
través del ciclo de edición-envío varias veces antes de concluir la operación.

Es posible que requieramos que se produzca alguna validación en el navegador,

incluso antes de que se envíe el formulario; es posible que deseemos utilizar
campos mucho más complejos, que permiten al usuario hacer cosas como elegir
fechas de un calendario y así sucesivamente.

En este punto es mucho más fácil conseguir que Django haga la mayor parte de
este trabajo por nosotros.

Construyendo un formulario en Django

La clase Form
Ya sabemos cómo queremos que sea nuestro formulario HTML. Nuestro punto de
partida en Django es el siguiente:
forms.py
from django import forms
class NameForm(forms.Form):
 your_name = forms.CharField(label='Your name', max_length=100)
Esto define una clase Form con un único campo (). Hemos aplicado una etiqueta
amigable con el ser humano al campo, que aparecerá en el momento en que se
represente (aunque en este caso, la etiqueta que especificamos es en realidad la
misma que se generaría automáticamente si lo hubiéramos
omitido).your_name<label>
La longitud máxima permitida del campo se define mediante max_length. Esto
hace dos cosas. Coloca un en el HTML (por lo que el navegador debe evitar que el
usuario ingrese más de ese número de caracteres en primer lugar). También
significa que cuando Django recibe el formulario de vuelta del navegador, validará
la longitud de los datos.maxlength="100"<input>
Una instancia de Form tiene un método is_valid(), que ejecuta rutinas de
validación para todos sus campos. Cuando se llama a este método, si todos los
campos contienen datos válidos, será:
devolución True
colocar los datos del formulario en su atributo cleaned_data.
Toda la forma, cuando se representa por primera vez, tendrá el siguiente aspecto:
<label for="your_name">Your name: </label>
<input id="your_name" type="text" name="your_name" maxlength="100" required>
Tenga en cuenta que no incluye las etiquetas ni un botón enviar. Tendremos que
proporcionarlos nosotros mismos en la plantilla.<form>
La vista
Los datos del formulario enviados a un sitio web de Django son procesados por
una vista, generalmente la misma vista que publicó el formulario. Esto nos permite
reutilizar parte de la misma lógica.
Para manejar el formulario necesitamos crear una instancia de él en la vista de la
URL donde queremos que se publique:
views.py
from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import NameForm

def get_name(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = NameForm(request.POST)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
# ...
# redirect to a new URL:
return HttpResponseRedirect('/thanks/')

# if a GET (or any other method) we'll create a blank form

else:
form = NameForm()

return render(request, 'name.html', {'form': form})

Si llegamos a esta vista con una solicitud, creará una instancia de formulario vacía
y la colocará en el contexto de plantilla que se va a representar. Esto es lo que
podemos esperar que suceda la primera vez que visitamos la URL.GET
Si el formulario se envía mediante una solicitud, la vista volverá a crear una
instancia de formulario y rellenarla con datos de la solicitud: se denomina "datos
de enlace al formulario" (ahora es un formulario enlazado).POSTform =
NameForm(request.POST)
Llamamos al método del formulario; si no lo es, volvemos a la plantilla con el
formulario. Esta vez el formulario ya no está vacío(sin enlazar),por lo que el
formulario HTML se rellenará con los datos enviados previamente, donde se
puede editar y corregir según sea necesario.is_valid()True

Si es así, ahora podremos encontrar todos los datos de formulario validados en su

atributo. Podemos usar estos datos para actualizar la base de datos o hacer otro
procesamiento antes de enviar una redirección HTTP al navegador diciéndole a
dónde ir a continuación.is_valid()Truecleaned_data

La plantilla
No necesitamos hacer mucho en nuestra plantilla:name.html

<form action="/your-name/" method="post">

{% csrf_token %}
{{ form }}
<input type="submit" value="Submit">
</form>
Todos los campos del formulario y sus atributos se desempaquetarán en marcado
HTML a partir del lenguaje de plantilla de Django.{{ form }}

Formularios y protección contra falsificación de solicitudes entre sitios

Django envía una protección fácil de usar contra falsificaciones de solicitudes de
sitio cruzado. Al enviar un formulario vía con la protección CSRF habilitada, debe
usar la etiqueta de plantilla csrf_token como en el ejemplo anterior. Sin embargo,
puesto que la protección CSRF no está vinculada directamente a los formularios
en las plantillas, esta etiqueta se omite de los siguientes ejemplos en este
documento.POST
Tipos de entrada HTML5 y validación del navegador
Si el formulario incluye un URLField, un EmailField o cualquier tipo de campo
entero, Django usará los tipos de entrada y HTML5. De forma predeterminada, los
navegadores pueden aplicar su propia validación en estos campos, que puede ser
más estricta que la validación de Django. Si desea deshabilitar este
comportamiento, establezca el atributo en la etiqueta o especifique un widget
diferente en el campo, como TextInput.urlemailnumbernovalidateform
Ahora tenemos un formulario web en funcionamiento, descrito por un
formularioDjango, procesado por una vista y representado como html .<form>

Eso es todo lo que necesita para empezar, pero el marco de formularios pone
mucho más a su alcance. Una vez que comprenda los conceptos básicos del
proceso descrito anteriormente, debe estar preparado para entender otras
características del sistema de formularios y listo para aprender un poco más sobre
la maquinaria subyacente.
Más información sobre las clases de Django Form
Todas las clases de formulario se crean como subclases de django.forms.Form o
django.forms.ModelForm. Usted puede pensar como una subclase de . y en
realidad heredan la funcionalidad común de una clase (privada), pero este detalle
de implementación rara vez es
importante.ModelFormFormFormModelFormBaseForm
Modelos y formularios
De hecho, si el formulario se va a usar para agregar o editar directamente un
modelo Django, un ModelForm puede ahorrarle mucho tiempo, esfuerzo y código,
ya que creará un formulario, junto con los campos adecuados y sus atributos, de
una clase.Model
Instancias de formulario enlazadas y sin enlazar
La distinción entre formularios enlazados y no consolidados es importante:
Un formulario sin enlazar no tiene datos asociados. Cuando se representa al
usuario, estará vacío o contendrá valores predeterminados.
Un formulario enlazado ha enviado datos y, por lo tanto, se puede usar para saber
si esos datos son válidos. Si se representa un formulario enlazado no válido,
puede incluir mensajes de error en línea que le dicen al usuario qué datos corregir.
El atributo is_bound del formulario le indicará si un formulario tiene datos
enlazados a él o no.
Más información sobre el campo
Considere una forma más útil que nuestro ejemplo mínimo anterior, que
podríamos usar para implementar la funcionalidad "contácteme" en un sitio web
personal:

forms.py
from django import forms
class ContactForm(forms.Form):
subject = forms.CharField(max_length=100)
message = forms.CharField(widget=forms.Textarea)
sender = forms.EmailField()
 cc_myself = forms.BooleanField(required=False)
Nuestro formulario anterior utilizaba un solo campo, un CharField. En este caso,
nuestro formulario tiene cuatro campos: , , y . CharField, EmailField y BooleanField
son solo tres de los tipos de campo disponibles; se puede encontrar una lista
completa en los campos Formulario.your_namesubjectmessagesendercc_myself

Widgets
Cada campo de formulario tiene una clase widgetcorrespondiente, que a su vez
corresponde a un widget de formulario HTML como .<input type="text">
En la mayoría de los casos, el campo tendrá un widget predeterminado sensato.
Por ejemplo, de forma predeterminada, un CharField tendrá un widget TextInput,
que genera un en el HTML. Si lo necesitara, especificaría el widget adecuado al
definir el campo de formulario, como hemos hecho con el campo.<input
type="text"><textarea>message
Datos de campo
Independientemente de los datos enviados con un formulario, una vez que se
hayan validado correctamente mediante una llamada (y se haya devuelto), los
datos del formulario validado estarán en el diccionario. Estos datos se habrán
convertido muy bien en tipos de Python para
usted.is_valid()is_valid()Trueform.cleaned_data
nota
Todavía puede tener acceso a los datos no validados directamente desde
este punto, pero los datos validados son mejores.request.POST

En el ejemplo de formulario de contacto anterior, será un valor booleano. Del

mismo modo, campos como IntegerField y FloatField convierten valores en una
Python y, respectivamente.cc_myselfintfloat
A continuación se muestra cómo se podrían procesar los datos del formulario en la
vista que controla este formulario:

views.py
from django.core.mail import send_mail

if form.is_valid():
 subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
sender = form.cleaned_data['sender']
cc_myself = form.cleaned_data['cc_myself']

recipients = ['info@example.com']
if cc_myself:
recipients.append(sender)

send_mail(subject, message, sender, recipients)

return HttpResponseRedirect('/thanks/')
Propina
Para obtener más información sobre el envío de correo electrónico desde Django,
consulte Envío de correo electrónico.
Algunos tipos de campo necesitan un poco de manejo adicional. Por ejemplo, los
archivos que se cargan mediante un formulario deben controlarse de forma
diferente (se pueden recuperar desde ) Para obtener más información sobre cómo
controlar las cargas de archivos con el formulario, consulte Enlace de archivos
cargados a un formulario.request.FILESrequest.POST
Trabajar con plantillas de formulario
Todo lo que necesita hacer para que el formulario entre en una plantilla es colocar
la instancia de formulario en el contexto de la plantilla. Por lo tanto, si se llama al
formulario en el contexto, representará su y los elementos
adecuadamente.form{{ form }}<label><input>
Opciones de renderizado de formularios
Muebles de plantilla de formulario adicionales

No olvide que la salida de un formulario no incluye las etiquetas circundantes ni el

control del formulario. Tendrás que proporcionar esto tú mismo.<form>submit

Sin embargo, hay otras opciones de salida para los pares / :<label><input>
{{ form.as_table }} los representará como celdas de mesa envueltas en
etiquetas<tr>
{{ form.as_p }} los hará envueltos en etiquetas<p>
{{ form.as_ul }} los hará envueltos en etiquetas<li>
Tenga en cuenta que tendrá que proporcionar los alrededores o los elementos
usted mismo.<table><ul>
Aquí está el resultado de nuestra instancia:{{ form.as_p }}ContactForm
<p><label for="id_subject">Subject:</label>
<input id="id_subject" type="text" name="subject" maxlength="100"
required></p>
<p><label for="id_message">Message:</label>
<textarea name="message" id="id_message" required></textarea></p>
<p><label for="id_sender">Sender:</label>
<input type="email" name="sender" id="id_sender" required></p>
<p><label for="id_cc_myself">Cc myself:</label>
<input type="checkbox" name="cc_myself" id="id_cc_myself"></p>
Tenga en cuenta que cada campo de formulario tiene un atributo ID establecido en
, al que hace referencia la etiqueta de etiqueta adjunta. Esto es importante para
garantizar que las formas sean accesibles para la tecnología de asistencia, como
el software de lector de pantalla. También puede personalizar la forma en que se
generan las etiquetas y los ids.id_<field-name>
Consulte Salida de formularios como HTML para obtener más información al
respecto.
Campos de renderizado manualmente
No tenemos que dejar que Django desempaquete los campos del formulario;
podemos hacerlo manualmente si nos gusta (lo que nos permite reordenar los
campos, por ejemplo). Cada campo está disponible como atributo del formulario
mediante , y en una plantilla de Django, se representará correctamente. por
ejemplo:{{ form.name_of_field }}

{{ form.non_field_errors }}
<div class="fieldWrapper">
{{ form.subject.errors }}
 <label for="{{ form.subject.id_for_label }}">Email subject:</label>
{{ form.subject }}
</div>
<div class="fieldWrapper">
{{ form.message.errors }}
<label for="{{ form.message.id_for_label }}">Your message:</label>
{{ form.message }}
</div>
<div class="fieldWrapper">
{{ form.sender.errors }}
<label for="{{ form.sender.id_for_label }}">Your email address:</label>
{{ form.sender }}
</div>
<div class="fieldWrapper">
{{ form.cc_myself.errors }}
<label for="{{ form.cc_myself.id_for_label }}">CC yourself?</label>
{{ form.cc_myself }}
</div>
Los elementos completos también se pueden generar utilizando el label_tag(). por
ejemplo:<label>
<div class="fieldWrapper">
{{ form.subject.errors }}
{{ form.subject.label_tag }}
{{ form.subject }}
</div>
Representación de mensajes de error de formulario
El precio de esta flexibilidad es un poco más de trabajo. Hasta ahora no hemos
tenido que preocuparnos por cómo mostrar errores de forma, porque eso se ha
cuidado de nosotros. En este ejemplo hemos tenido que asegurarnos de que nos
ocupamos de cualquier error para cada campo y cualquier error para el formulario
en su conjunto. Tenga en cuenta en la parte superior del formulario y la búsqueda
de errores de plantilla en cada campo.{{ form.non_field_errors }}
El uso muestra una lista de errores de formulario, representados como una lista
desordenada. Esto podría parecer:{{ form.name_of_field.errors }}
<ul class="errorlist">
<li>Sender is required.</li>
</ul>
La lista tiene una clase CSS de para permitirle aplicar estilo a su apariencia. Si
desea personalizar aún más la visualización de los errores, puede hacerlo en
bucle sobre ellos:errorlist

{% if form.subject.errors %}
<ol>
{% for error in form.subject.errors %}
<li><strong>{{ error|escape }}</strong></li>
{% endfor %}
</ol>
{% endif %}
Los errores que no sean de campo (y/o errores de campo ocultos que se
representan en la parte superior del formulario cuando se usan auxiliares como )
se representarán con una clase adicional de para ayudar a distinguirlos de errores
específicos del campo. Por ejemplo,
parecería:form.as_p()nonfield{{ form.non_field_errors }}

<ul class="errorlist nonfield">

<li>Generic validation error</li>
</ul>
Consulte la API de formularios para obtener más información sobre los errores, el
estilo y el trabajo con atributos de formulario en plantillas.

Bucle sobre los campos del formulario

Si usa el mismo CÓDIGO HTML para cada uno de los campos de formulario,
puede reducir el código duplicado recorriendo cada campo a su vez mediante un
bucle:{% for %}

{% for field in form %}

<div class="fieldWrapper">
{{ field.errors }}
{{ field.label_tag }} {{ field }}
{% if field.help_text %}
<p class="help">{{ field.help_text|safe }}</p>
{% endif %}
</div>
{% endfor %}
Los atributos útiles incluyen:{{ field }}

{{ field.label }}
La etiqueta del campo, por ejemplo. .Email address
{{ field.label_tag }}
La etiqueta del campo se ajusta en la etiqueta HTML adecuada. Esto incluye la
label_suffixdel formulario. Por ejemplo, el valor predeterminado es dos
puntos:<label>label_suffix

<label for="id_email">Email address:</label>

{{ field.id_for_label }}
El ID que se utilizará para este campo (en el ejemplo anterior). Si está
construyendo la etiqueta manualmente, es posible que desee utilizarla en lugar
de . También es útil, por ejemplo, si tiene javascript en línea y desea evitar la
codificación de la identificación del campo.id_emaillabel_tag
{{ field.value }}
El valor del campo. p. ej..someone@example.com
{{ field.html_name }}
El nombre del campo que se usará en el campo name del elemento de entrada.
Esto tiene en cuenta el prefijo de formulario, si se ha establecido.
{{ field.help_text }}
Cualquier texto de ayuda asociado al campo.
{{ field.errors }}
Genera un contenedor de errores de validación correspondientes a este campo.
Puede personalizar la presentación de los errores con un bucle. En este caso,
cada objeto del bucle es una cadena que contiene el mensaje de error.<ul
class="errorlist">{% for error in field.errors %}
{{ field.is_hidden }}
Este atributo es si el campo de formulario es un campo oculto y de otro modo. No
es particularmente útil como variable de plantilla, pero podría ser útil en pruebas
condicionales como:TrueFalse
{% if field.is_hidden %}
{# Do something special #}
{% endif %}
{{ field.field }}
La instancia field de la clase de formulario que este BoundField ajusta. Puede
utilizarlo para acceder a los atributos Field, por ejemplo. .
{{ char_field.field.max_length }}
Véase también

Para obtener una lista completa de atributos y métodos, vea BoundField.

Bucle sobre campos ocultos y visibles

Si va a diseñar manualmente un formulario en una plantilla, en lugar de confiar en
el diseño de formulario predeterminado de Django, es posible que desee tratar los
campos de forma diferente a los campos no ocultos. Por ejemplo, dado que los
campos ocultos no muestran nada, colocar mensajes de error "junto" al campo
podría causar confusión a los usuarios, por lo que los errores de esos campos
deben controlarse de forma diferente.<input type="hidden">
Django proporciona dos métodos en un formulario que le permiten recorrer los
campos ocultos y visibles de forma independiente: y . A continuación se muestra
una modificación de un ejemplo anterior que utiliza estos dos
métodos:hidden_fields()visible_fields()
{# Include the hidden fields #}
{% for hidden in form.hidden_fields %}
{{ hidden }}
{% endfor %}
{# Include the visible fields #}
{% for field in form.visible_fields %}
<div class="fieldWrapper">
{{ field.errors }}
{{ field.label_tag }} {{ field }}
</div>
{% endfor %}
Este ejemplo no controla ningún error en los campos ocultos. Por lo general, un
error en un campo oculto es un signo de manipulación de formularios, ya que la
interacción normal de la forma no los alterará. Sin embargo, también puede
insertar fácilmente algunas pantallas de error para esos errores de formulario.
Plantillas de formulario reutilizables¶
Si el sitio usa la misma lógica de representación para formularios en varios
lugares, puede reducir la duplicación guardando el bucle del formulario en una
plantilla independiente y usando la etiqueta include para reutilizarlo en otras
plantillas:

# In your form template:

{% include "form_snippet.html" %}
# In form_snippet.html:
{% for field in form %}
<div class="fieldWrapper">
{{ field.errors }}
{{ field.label_tag }} {{ field }}
 </div>
{% endfor %}
Si el objeto de formulario pasado a una plantilla tiene un nombre diferente dentro
del contexto, puede darle alias mediante el argumento de la etiqueta include: with
{% include "form_snippet.html" with form=comment_form %}
Si se encuentra haciendo esto a menudo, puede considerar la creación de una
etiqueta de inclusión personalizada

Importar a SMTP
El Protocolo simple de transferencia de correo (SMTP en inglés) maneja el envío y
el correo electrónico de enrutamiento entre los servidores de correo.
En Python, el módulo smtplib define un objeto de sesión de cliente SMTP que se
puede usar para enviar correo a cualquier máquina de Internet con un daemon de
escucha SMTP o ESMTP.
He aquí cómo crear un objeto SMTP.
import smtplib
 
server = smtplib.SMTP(host='host_address',port=your_port)

Crear y enviar un correo electrónico simple

La siguiente secuencia de comandos le permitirá enviar un correo electrónico a
través del servidor SMTP de Gmail. Sin embargo, Google no permitirá el inicio de
sesión a través de smtplib porque ha marcado este tipo de inicio de sesión como
"menos seguro". Para solucionar este problema, vaya a
https://www.google.com/settings/security/lesssecureapps mientras está conectado
a su cuenta de Google y a "Permitir aplicaciones menos seguras". Vea la captura
de pantalla a continuación.

Seguiremos los siguientes pasos para lograr este proceso:

Crear un objeto SMTP para la conexión al servidor.
Ingrese a su cuenta.
Defina los encabezados de sus mensajes y las credenciales de inicio de sesión.
Cree un objeto de mensaje MIMEMultipart y adjunte los encabezados
correspondientes, es decir, desde, hasta y Asunto.
Adjunte el mensaje al mensaje objeto MIMEMultipart.
Finalmente, envíe el mensaje.
Este proceso es tan simple como se muestra a continuación.
Codigo en Python:

# import necessary packages

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import smtplib
# create message object instance
msg = MIMEMultipart()

message = "Thank you"

# setup the parameters of the message
password = "your_password"
msg['From'] = "your_address"
msg['To'] = "to_address"
msg['Subject'] = "Subscription"

# add in the message body

msg.attach(MIMEText(message, 'plain'))

#create server
server = smtplib.SMTP('smtp.gmail.com: 587')
server.starttls()
# Login Credentials for sending the mail
server.login(msg['From'], password)
 # send the message via the server.
server.sendmail(msg['From'], msg['To'], msg.as_string())
server.quit()
print "successfully sent email to %s:" % (msg['To'])

Tenga en cuenta que las direcciones 'Para' y 'De' deben incluirse explícitamente
en los encabezados de los mensajes.
Crear y enviar un correo electrónico con un archivo adjunto
En este ejemplo, vamos a enviar un correo electrónico con un archivo adjunto de
imagen. El proceso es similar al envío de un correo electrónico de texto sin
formato.
Crea un objeto SMTP para la conexión al servidor.
Ingrese a su cuenta.
Defina los encabezados de sus mensajes y las credenciales de inicio de sesión.
Cree un objeto de mensaje MIMEMultipart y adjunte los encabezados
correspondientes, es decir, desde, hasta y Asunto.
Lea y adjunte la imagen al mensaje objeto MIMEMultipart.
Finalmente, envíe el mensaje.

Código fuente de Ejemplo en Python

# send_attachment.py
# import necessary packages
from email.mime.multipart import MIMEMultipart
from email.MIMEImage import MIMEImage
from email.mime.text import MIMEText
import smtplib

# create message object instance

msg = MIMEMultipart()
# setup the parameters of the message
password = "your_password"
msg['From'] = "your_address"
msg['To'] = "to_address"
msg['Subject'] = "Photos"
# attach image to message body
msg.attach(MIMEImage(file("google.jpg").read()))

# create server
server = smtplib.SMTP('smtp.gmail.com: 587')

server.starttls()
# Login Credentials for sending the mail
server.login(msg['From'], password)

# send the message via the server.

server.sendmail(msg['From'], msg['To'], msg.as_string())
server.quit()
print "successfully sent email to %s:" % (msg['To'])