django之注册验证码 和 python基础篇

摘要: django之注册验证码 和python基础篇

django验证码

参考文档

http://www.projectsedu.com

要引入django第三方库 django-simple-captcha

安装步骤

进入虚拟环境文件下：例如：(vir) F:\python-study\admin>

指定版本：pip install django-simple-captcha==0.4.6

在settings.py 注册到apps里，放到最后

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'users',
'course',
'operation',
'organization',
'captcha'
]

在项目的url里配置一下

# -*- coding: utf-8 -*-
from django.conf.urls import url, include
from django.views.generic import TemplateView
from django.contrib import admin
# one
from users.views import LoginView, RegisterView
# two
# from users.views import user_login
urlpatterns = [
url(r'^admin/', admin.site.urls),
url('^$', TemplateView.as_view(template_name="index.html"), name="index"),
# url('^login/$', user_login, name="login")
url('^login/$', LoginView.as_view(), name="login"),
url('^register/', RegisterView.as_view(), name="register"),
url('^captcha/', include('captcha.urls')),

]

运行python manage.py migrate 注册到数据库中

forms.py中

# -*- coding: utf-8 -*-
from django import forms
# 导入验证码方法
# from captcha.fields import CaptchaField

class RegisterForm(forms.Form):
email = forms.CharField(required=True)
password = forms.CharField(required=True, min_length=5)
# 引用验证码方法
# captcha = CaptchaField()

views.py

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.shortcuts import render
# 引用view 类
from django.views.generic.base import View
# 验证用户名和密码方法
from django.contrib.auth import authenticate, login
# django验证的方法
from django.contrib.auth.backends import ModelBackend
# 引用Q
from django.db.models import Q
from .models import UserProfile
# 表单的验证方法
from forms import LoginForms, RegisterForm

# 验证是不是邮箱登录
class CustomBackend(ModelBackend):
def authenticate(self, request, username=None, password=None, **kwargs):
try:
# Q, 并集和交集
user = UserProfile.objects.get(Q(username=username) | Q(email=username), Q(password=password))
if user.check_password(password):
return user
except Exception as ex:
return None

# Create your views here.

# 注册的方法
class RegisterView(View):
def get(self, request):
register_form = RegisterForm()
return render(request, "register.html", {"register_form":register_form})
def post(self, request):
pass

register.html

<div class="form-group marb8 captcha1 ">
<label>验 证 码</label>
{{ register_form.captcha }}
</div>

python 基础篇

学习网址https://www.cnblogs.com/linzenews/p/6956782.html

http://www.kuqin.com/abyteofpython_cn/

多行语句 (但是我们可以使用斜杠（ \）将一行的语句分为多行显示)

例如：

item_one = 1
item_two = 2
item_three = 3

total = item_one + \
item_two + \
item_three
print total

语句中包含[], {} 或 () 括号就不需要使用多行连接符

days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

python 引号

Python 使用单引号(' )，双引号(" )，三引号('''" """) 来表示字符串，引号的开始与结束必须是相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用语文档字符串，在文件的特定地点，被当做注释

例如：

word = 'word'
sentence = "这是一个句子"
paragraph = """这是一个段落
包含了多个语句"""

python 的注释

例如：

python中单行注释采用 # 开头。

Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

例如：

#!/usr/bin/python

import sys; x = 'w3cschool'; sys.stdout.write(x + '\n')

Python 变量类型

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

变量赋值

Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值

例如：

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

多个变量赋值

Python允许你同时为多个变量赋值

例如：

a = b = c = 1

可以为多个对象指定多个变量

例如：

a, b, c = 3, 4.5, 'hello word'

print a, b, c

python标准数据类型

Numbers（数字）包括（int(有符号整型)，long(长整型[也可以代表八进制和十六进制]),float（浮点型）,complex（复数）） 例如



String（字符串）

List（列表）

Tuple（元组）

Dictionary（字典）

python 字符串

字符串是由数字、字母、下划线组成的一串字符。

字符串格式 化

name = raw_input("Name:")
age = raw_input("Age:")
job = raw_input('Job:')
home_town =raw_input('HomeTown:')
# print ("-------------- info is , name ---------------")
# print("Name:",name)
# print("Age:",age)
# print("Job:",job)
# print("HomeTown:",home_town)
# print ("---------------end -------------")

info = """
--------- info is %s ----------
Name:    %s
Age:     %s
Job:     %s
HomeTown:%s
------------end---------------
""" % (name, name, age, job, home_town)
print(info)

python的字串列表有2种取值顺序:

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

例如：

s = 'Ilovepython'

print s[1:5] #love

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。

加号（+）是字符串连接运算符，星号（*）是重复操作

例如：

#coding=utf-8
#!/usr/bin/python

str = 'Hello World!'

print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第五个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串

#输出结果
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

python 列表(list)

例如：

# _*_ coding: utf-8 _*_

lists = ["a", "b", "c", "d", "e", "f"]
temp = ["g", "h"]
print lists #列出所有项 ['a', 'b', 'c', 'd', 'e', 'f']
print lists[0] #列出第一项 "a"
print lists[1:3] #['b', 'c']
print lists[2:] #['c', 'd', 'e', 'f']
print lists * 2 #['a', 'b', 'c', 'd', 'e', 'f', 'a', 'b', 'c', 'd', 'e', 'f']
print lists + temp #['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

list 常用的方法

添加一个元素到最后list.append() 访求

L = ['Adam', 'Lisa', 'Bart']
L.append('Paul')
print L
['Adam', 'Lisa', 'Bart', 'Paul']

指定元素添加某一个位置list.insert(0,'demp')

第一个参数是索引，第二个参数是新元素

L = ['Adam', 'Lisa', 'Bart']
L.insert(2,'paul')
print L

['Adam', 'Lisa', 'paul', 'Bart']

list删除一个元素pop()

例如

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L.pop()
'Paul'
print L
['Adam', 'Lisa', 'Bart']

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以执行 L.pop() 后，会打印出 'Paul'。

pop(2)还可以添加索引指定删除某一个元素

list中替换元素

list[索引]=‘替换元素’

L[-1] = 'Paul'

list切片方法

例如：

L = ['Adam', 'Lisa', 'Bart', 'Paul']
print L[0:3] 表示：从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
输出：'Adam', 'Lisa', 'Bart'

第一个索引是0，还可以省略 L[:3]

L = ['Adam', 'Lisa', 'Bart', 'Paul']
print L[:3] //'Adam', 'Lisa', 'Bart'

只用一个 : ，表示从头到尾：

L = ['Adam', 'Lisa', 'Bart', 'Paul']
print L[:] //'Adam', 'Lisa', 'Bart', 'Paul'

切片操作还可以指定第三个参数

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L[::2]表示:从索引0开始，每隔二个元素截取
//输出：['Adam', 'Bart']

-例如：

L = range(1, 101)//表示生成【1-100】list

print L[0:10]
print L[2::3]
print L[4:50:5] //表示：从索引4开始，到50之间，每隔5个截取

list切片倒序

倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L[-2:] 输出： 【'Bart', 'Paul】
L[:-2] 输出：['Adam', 'Lisa']
L[-3:-1]输出：【 'Lisa'，'Bart'】
L[-4:-1:2]输出：【''Adam','Bart'】

python 元组

无级是另一个数据类型，类似于List(列表)

元组用”()“标识，内部元素用逗号隔开。但是元素不能二次赋值上，相当于只读列表

例如：

tuples = (0, 1, 2, 3, 4, 5, 6)
temps = (7, 10)
print tuples  # (0, 1, 2, 3, 4, 5, 6)
print tuples[0]  # 0
print tuples[1:3]  # (1, 2)
print tuples[2:]    # (2, 3, 4, 5, 6)
print tuples * 2    # (0, 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5, 6)
print tuples + temps    # (0, 1, 2, 3, 4, 5, 6, 7, 10)

列表和元组的区别

tupless = ('abcd', 786, 2.23, 'john', 70.2)
listss = ['abcd', 786, 2.23, 'john', 70.2]
# tupless[2] = 1000  # 元组中是非法应用
listss[2] = 1000  # 列表中是合法应用
print listss[2]     # 1000

python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成

dicts = {}
dicts['one'] = 'this is one'
dicts['two'] = 'this is two'
print dicts     # {'two': 'this is two', 'one': 'this is one'}
print dicts.keys()      # ['two', 'one'] 输出所有的key值
print dicts.values()    # ['this is two', 'this is one'] 输出所有的value值

dict的特点

dict的第一个特点是查找速度快，但是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

dict的第二个特点就是存储的key-value序对是没有顺序的

dict的第三个特点是作为key的元素必须不可变

dict是一个集合，所以用**len()**函数表示集合的大小

例如：

d = {
'name':12,
'age':10
}
print len(d)//2

可以用d[key]来查找对应的value

例如：

d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
print  'Adam:', d.get('Adam')
print  'Lisa:', d['Lisa']
print  'Bart:', d['Bart']
print d['Paul']
报错：
Traceback (most recent call last):
File "index.py", line 9, in
print d['Paul']
KeyError: 'Paul'

避免KeyError发生，有两个办法

一是先判断一下 key 是否存在，用 in 操作符

if 'Paul' in d:
print d['Paul']

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

print d.get('Bart') //59
print d.get('Paul')//None

dict更新

dict中添加新的 key-value; d[key]=value

d = {
95: 'Adam',
85: 'Lisa',
59: 'Bart'
}
d[72]='Paul'
print d //{72: 'Paul', 59: 'Bart', 85: 'Lisa', 95: 'Adam'}

如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value

dict遍历for key in dict

d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
for key in d:
print "%s: %d"%(key,d[key])

python中set

set 持有一系列元素，但是set的元素没有重复，而且是无序的

print s //set(['A', 'C', 'B'])

访问set

由于set存储的是无序集合，所以没法通过索引来访问

可以通过 '查询名' in set 区分大小写

s = set(['adam','bart'])
print 'adam' in s //true
print 'Bart' in s // flase

set特点

set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

例如：

months = set(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
x1 = 'Feb'
x2 = 'Sun'
if x1 in months:
print 'x1: ok'
else:
print 'x1: error'
if x2 in months:
print 'x2: ok'
else:
print 'x2: error'

set的遍历for name in set

s = set(['Adam', 'Lisa', 'Bart'])
for name in s:
print name

set更新

**set的add()**方法

s = set([1,2,3])
s.add(5)
print s
//set([1, 2, 3, 5])

如果添加已存在的元素，add()不会报错，也不会添加进去

s = set([1,2,3])
s.add(3)
print s
// set([1,2,3])

删除set中的元素时，用set的remove()方法：

s = set([1,2,3])
s.remove(2)
print s
//set([1, 3])

如果删除的元素不存在set中，remove()会报错

s = set([1,2,3])
s.remove(5)
print s
//报错
Traceback (most recent call last):
File "index.py", line 2, in
s.remove(5)
KeyError: 5

python 运算符

算术运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

python 比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

python 赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

python 位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
a = 60    b = 13
运算符	描述	实例
&	按位与运算符	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符	(a | b) 输出结果 61 ，二进制解
3ff0
释： 0011 1101
^	按位异或运算符	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符	a >> 2 输出结果 15 ，二进制解释： 0000 1111

python 逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或"	- 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

python 成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回True，否则返回False。	x 在 y序列中 , 如果x在y序列中返回True。
not in	如果在指定的序列中没有找到值返回True，否则返回False。	x 不在 y序列中 , 如果x不在y序列中返回True。
- 例如：
a = 10
b = 20
lists = [1, 2, 3, 4, 5, 10]
if a in lists:
print a in lists    # True
else:
print a in lists
if b not in lists:
print b not in lists    # True
else:
print b not in lists

python 身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not	is not是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1
- 例如：
a = 10
b = 10
if a is b:
print '有相同标识'    # True
else:
print a is not b
b = 20
if a is b:
print "有相同标识"
if a is not b:
print '没有相同标识'

python 的优先级

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

python 条件语句

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块

if语句

if 判断条件：
执行语句……
else：
执行语句……

当判断条件为多个值是，可以使用以下形式

if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
print 'hello'
>>> hello		# 输出结果

num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
print 'hello'
else:
print 'undefine'
>>> undefine		# 输出结果

num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
print 'hello'
else:
print 'undefine'
>>> undefine		# 输出结果

python while 循环

while 判断条件：
执行语句……
当条件为假时，跳出循环

while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：

# continue 和 break 用法

i = 1
while i < 10:        i += 1     if i%2 > 0:     # 非双数时跳过输出
continue
print i         # 输出双数2、4、6、8、10

i = 1
while 1:            # 循环条件为1必定成立
print i         # 输出1~10
i += 1
if i > 10:     # 当i大于10时跳出循环
break

while --else

count = 0
while count < 5:
print count, " is  less than 5"
count = count + 1
else:
print count, " is not less than 5"

Python for 循环语句

Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

语法：
for循环的语法格式如下：

for iterating_var in sequence:
statements(s)

例如：

# -*- coding: UTF-8 -*-

for letter in 'Python':     # 第一个实例
print '当前字母 :', letter

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
print '当前字母 :', fruit

print "Good bye!"
输出结果：
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n
Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

通过序列索引迭代

# -*- coding: UTF-8 -*-

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
print '当前水果 :', fruits[index]

print "Good bye!"

输出结果：
当前水果 : banana
当前水果 : apple
当前水果 : mango
Good bye!

其中使用了内置涵数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数

for ---- else 在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完

# -*- coding: UTF-8 -*-

for num in range(10,20):  # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0:      # 确定第一个因子
j=num/i          # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break            # 跳出当前循环
else:                  # 循环的 else 部分
print num, '是一个质数'

Python pass 语句

Python pass是空语句，是为了保持程序结构的完整性

# -*- coding: UTF-8 -*-
#!/usr/bin/python

# 输出 Python 的每个字母
for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '当前字母 :', letter

print "Good bye!"