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

原创
2017/06/24 16:16
阅读数 227

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>验&nbsp;证&nbsp;码</label>
                            {{ register_form.captcha }}
                        </div>

python 基础篇

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

  • 例如:
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 ,二进制解释: 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!"
展开阅读全文
加载中

作者的其它热门文章

打赏
0
0 收藏
分享
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部