Python和Django学习

文档链接：

• 官方文档
• 中文教程
• 刘江博客
• 博学谷项目
• Django零基础
• Python核心编程

编辑工具：

• iPython
• jupyter notebook
• sublime text
• Pycharm
• Pip

一，Python基础

1.1，Python特性

1. 优点：简单易学，开发速度快，明确优雅，开放源代码
2. 缺点：执行效率稍低，运行速度慢，代码无法加密，可选择的框架较多
3. 特点：跨平台（window可mac上用），可移植，可扩展，交互式，解释型，面向对象的动态语言
4. 应用：软件开发，科学计算，网络爬虫，自动化运维，web开发，云计算，数据分析，人工智能.
5. 帮助文档：https://docs.python.org/3/ 》》》print(a.doc) //查看成员对象的帮助文档

1.2，标识符

1. 注释：单行# ，多行(’’’…’’’，" " “…” " ")
2. 组成：由字母，数字和下划线组成，不能以数字开头，不包含关键字和内置函数名
3. 特点：大小写敏感，变量名全小写aa，常量名全大写II，函数方法名aa_bb小写+_，类名大写驼峰DumEa
4. 变量：a=b=c=1，a,b,c=1,2,3 //需声明后再使用，对象的引用
5. 其它：无“；“和” { “，不用声明类型，可随时变幻类型，print（‘idj’,‘djf’）遇到”,"会输出一个空格
6. 占位符：pass def fun(a,b) pass 或者是 …

1.3，输入&输出

4. 输入：num = int(input('num = ')) //可用于暂停程序input()， print:输入字符串 a换行 输出：刚刚输入的
5. 输出：print(a,“a”,b); //i lovw a es b print(sum(a,b)，end=") //20 逗号默认一空格，不换行
6. 输出格式化：print (“我叫 %s 今年 %d 岁!” % (‘小明’, 10)) //一条print语句一次换行

1.4，Python运算符

1. 算术运算符：+ ，-，*，/ (返回3.33，3.0），%，**（幂），//（整除）
2. 位运算符：&，|，^（异或，相同为0不同为1），~（按位取反），>>，<<（高丢低补） 1101 1111
3. 比较运算符：==，！=，<>，>，<，>=，<= 3>2>1-------> (3>2)&(2>1)
4. 赋值运算符：=，+=，-=，*=，/=，%=，**=，//= 从右往左
5. 身份运算符：is，is not //用于判断两个变量的引用是否为同一对象 id(a)查看a的内存地址
6. 成员运算符：in，not in //用于判断对象是否是某个集合
7. 逻辑运算符：and==&&，or，not 与或非，true，false
8. 以上优先级从大到小， Decimal(‘0.1’)+Decimal(‘0.1’) 存在精度问题
9. 备注： 在实际开发中，如果搞不清楚运算符的优先级，可以使用括号来确保运算的执行顺序

1.5，变量类型

1. 复数：a=3+4j
2. 整型：1，-8080，0，0xff00，0o12，0b110(空值：None ，不属于0，特殊值，不能调用)
3. 浮点数：1.23，15.1e-2
4. 字符串：‘aa’，“ab” //不区分单双引号
5. 布尔型：True（-1，“False”) False（0,空字符,’ '，0.0，{ }，[ ]，())
6. 类型检测：print(type(a))，所有数据类型都是对象，chr()–整数换成编码对应的字符串
7. 类型转换：int(x)，float(x)，complex(x)，complex(x,y) //转换成复数，str()//对象->字符串，ord()–字符串->对应的编码

1.6，计算math库

1. abs(x) 返回绝对值 matn.abs(-10)---->10
2. ceil(x) 返回上入整数 math.ceil(4.1)–>5
3. exp(x) 返回e的x幂
4. fabs(x) 返回数字的绝对值 matn.fabs(-10)---->10.0
5. floor(x) 返回数字的下舍整数 math.floor(4.9)---->4
6. log(x,y) 返回math.log(100,10)返回2.0
7. log10(x) 返回math.log10(100)返回 2.0
8. max(x1,x2,…) 返回给定参数的最大值
9. min(x1,x2,…) 返回给定参数的最小值，参数可以为序列
10. pow(x,y) 返回x**y 运算后的值
11. sqrt(x) 返回数字x的平方根
12. acos(x) 返回x的反余弦弧度值。
13. cos(x) 返回x的弧度的余弦值
14. hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)
15. degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
16. radians(x) 将角度转换为弧度
17. randint(1, 6) //产生1~6之中的一个随机数

二，字符串&常用数据结构

2.1，字符串-有序不可变

1. 组成：’ ’ " " "’ "’ 可单可双可三可空可嵌套（加’），索引从0开始，三个时字符串可折行
2. 原生：r’ a b \n ’ 输出：ab\n 加r，忽略转义字符效果
3. 特点：值不可变，判空if a=’’，化整，a=(int)a
4. 操作：a+b // HelloMe b*2 //MeMe b[1] //e a[0:1] //He “H” in a //true
5. 格式化：print(f’{a} * {b} = {a * b}’)

2.2，字符串方法

1. aa.strip()//删除两侧的空白，或指定字符
2. aa.l/rstrip()//删除开头/结尾的空白 永久删除结尾空白 a=a.rstrip()
3. aa.capitalize/title/upper/lower/isupper() 字母：所有单词首大，首大其小，全大，全小输出，判断是否全大
4. aa.isdigit/isalpha/isalnum()//判断aa是否是数字字符串/字母字符串/数字字母构成
5. str(aa) //非字符串数字变为字符串,数字应变成字符串才能被+连接
6. encode(encoding=‘UTF-8’, errors=‘strict’)
7. aa.start/endswith() 字符串是否以xxx开头
8. len(aa) 返回字符串长
9. aa.replace(str1，str2，num=string.count(str1)) //将aa中的str1替换成str2，替换不超过num次
10. aa.index(“a”) //查找aa字符串中a所在的位置，同find，但找不到时会发生异常
11. aa.find(str，beg=0，end=len(string)) //从字符串中查找字串所在的位置
12. aa.split(str=" "，num=string.count(str)) //以str为分隔符切片 string，如果 num有指定值，则仅分隔num个子字符串
13. aa.startswith/endswith(‘a’) //判断字符串aa是否以a开头/结尾
14. aa.center/rjust(50, ‘x’) //将字符串以指定的宽度居中并在两侧填充指定的字符，右部填充50个x

2.3，字符串编码

1. ASCII编码：8位二进制，不兼容汉字
2. Unicode编码：万国码，Python3使用
3. UTF-8编码：万国码的优化，兼容ASCII，最流行
4. GB2312：早期中文编码，不通用
5. GBK：汉字内码

2.4，列表List[ ]有序可变

1. 定义：有序可重复的元素集合，可迭代，嵌套，修改，分片，追加，删除，拼接
2. 举例：alist=[1，" a "，[ 11，22 ]，{ " k2 " : " k3 " } ] alist2=[ ]
3. 索引：len(alist)-1，alist.index(“a”) 从0开始，-1为最后一个，空时【-1】错
4. 删除：del alist[0] alist.remove(" a ") b=alist.pop()
5. 添加：alist.append(“a”) //末尾添加 alist.insert(9,‘df’) //8处添加 alist.extend(alist1)
6. 操作：[1,2]+[3,4] —>[1,2,3,4] [1] * 4—>[1,1,1,1] 3 in [1,2,3]
7. 排序：alist.sort(reverse=True) //从大到小，永久性 sorted暂时性 alist=sorted(blist)
8. 最大：max(alist) min(alist) //不能混合类型求最大最小
9. 反转：alist.reverse() == alist[ ：：-1]
10. 复制：alist.copy() == alist[ ：]
11. 清空：alist.clear() == del alist[ ：]
12. 转换：s = list((1, “a”, “b”, 2)) //s–>> [1, ‘a’, ‘b’, 2]
13. 复制：bb=aa[:] 而bb=aa则两个被关联，之后一个变化另一个也变化
14. 切片：list[start:end] ，alist[：-3]开始到倒数第三个，alist[1：：4]1到结尾,以4累加
15. 次数统计：alist.count(x) alist.reverse(aa)//反方向输出
16. 生成列表：print([x * x for x in range(1, 11)])
17. 遍历循环：for x in alist: print x if x in a; print(“True”) else: print(“False”)

2.5，元组Tuple（）有序不可变

1. 定义：不可变的列表，内有列表列表值可变，t = (‘骆昊’, 38, True, ‘四川成都’) print(t[3])
2. 单元组：tuple(1,) //防止被当成（）优先输出
3. 操作：不可增删改，可切片，访问，计数，拼接，*4，循环 count/index/max/len/tuple()

2.6，字典dict{ : }无序可变

1. 组成： 键-值对“：”，之间用“，”隔开，键不可变且不重复（list不能做键）
2. 举例： alien_0 = {‘color’: ‘green’, ‘points’: 5} items1 = dict(one=1, two=2, three=3, four=4)
3. 添加： alien_0[‘x_position’] ='dfjdl’
4. 修改： alien_0[‘color’]=‘yellow’
5. 删除： del alien_0[‘points’] del alien_0 alien_0.clear() a=alien_0.pop(‘points’,5)
6. 查找：不存在，会报错：用循环检查，在则输出/print aa.get(‘djj’)
7. 遍历： for key, value in user_0.items(): print("\nKey:"+key) print("Value: " + value)
8. …for key in alien_0 : print(key,alien_0[key])
9. …for key in alien_0.keys() : for value in alien_0.values() :
10. 方法：clear() //删除所有元素 copy() //浅复制 get(key) //返回键对应的值 items() //以列表形式返回键值对

2.7，集合set{}无序不重可变

1. 创建：s=set(t) set(‘a b c’) {‘a’,‘b’,‘c’,’ '} set([1,1,2]) {1,2} t 任意 //自动去重
2. 循环：for language in set(favorite_languages.values()): print(language.title())
3. 添加：s.add(‘djj’) //在末尾添加元素
4. 删除：s.remove(‘dhf’) //删除前需判断，删除不存在元素会造成错误
5. 删除：s.pop() //删除第一个元素，无序性，不知道第一个元素是？
6. 独有：交集&并集|差集- a=set([“a”,“b”]) b=set([“c”]) a&b-----“a” “b” “c” print(a&|-^b)
7. 都有：in not in != ==
8. 字典列表：列表中的每一个元素都是一个字典/字典里面：{a:列表} .items()

2.8，推导式

1. 列表推导式：list=[xx for x in range(1,10) if x%2==0 ] === for i in range(1,10) list.append(ii)
2. 字典推导式：dic = {x: x**2 for x in (2, 4, 6)}
3. 集合推导式：a = {x for x in ‘abracadabra’ if x not in ‘abc’}
4. 元组推导式：tup = tuple(x for x in range(9))
5. 其它举例：f = [x + y for x in ‘ABCDE’ for y in ‘1234567’]
   print(sys.getsizeof(f)) # 查看对象占用内存的字节数

result = [lambda x: x + i for i in range(10)]
print(result[0](10))  //0~9 都是19  因为函数具有调用时才查找变量的特性
result = [lambda x, i=i: x + i for i in range(10)]
print(result[0](10))  //0~9  10~19

//备注：100天此部分练习，少

三，流程控制&面向对象编程

3.1，流程控制—分支结构

1. if 表达式：执行语句
2. if 表达式：执行语句 else: 执行语句
3. if 表达式：执行语句 elif : 执行语句 else: 执行语句

3.2，流程控制—循环结构

1. while 表达式： 执行语句
2. while 表达式： 执行语句 else：执行语句
3. for 关键字 in 列表等： 执行语句 else： 执行语句
4. continue：跳出本次 break：结束所在循环 return：返回 上述可嵌套 if “jdf” in aa: print(“jd”) else …
5. range()：for i in range(10): print(i) //0~9 range(1,11) //1-10 range(1,10,2) //1 3 5 7 9 range(len(a)) //常用

3.3，函数

1. 作用：使代码可重用，能封装包含内部数据
2. 特点：没有重载，后覆盖前，多文件同函数 from 文件名 import 函数名 导入
   import a1 as 1 import a2 as 2 1.pop() 2.pop()
3. 类型：def aa_bb(形参)：" “ ” 说明文档“ ” “ 执行语句 return 【返回值】 aa_bb(实参）//调用
4. 举例：def func(j=3)；return 1,[2,3],“a” a,b,c=func() //返回多个值，没有调用默认j=3
5. 位置实参：aa_bb(1, 2) //一一对应，类型一致
6. 关键字参：aa_bb(a=1, n=2) / /顺序不重要 跳转
7. 默认参数：def aa_bb(a，n=2): return a*n aa_bb(10/a=10) //传参可少，默认参数须在后如n在a后
8. 动态参数：def aa_bb(a,n=2，*args，**kwargs) //放在最后，多个打包成元组，后多个键值对打包成字典
9. 匿名函数：lambda 参数：执行语句 //f=lambda x:x*x

def func(a=[]):
    print("函数内部a的地址为：%s" % id(a))   
    a.append("A")   
    return a
    
b = func()                                #函数内部a的地址为：39287880
print('此时b的值为：%s' % b)              #此时b的值为：['A']
print("函数外部b的地址为：%s" % id(b))    #函数外部b的地址为：39287880
print("-------------")

c = func()                                #函数内部a的地址为：39287880  
print('此时c的值为：%s' % c)              #此时c的值为：['A', 'A']
print("函数外部c的地址为：%s" % id(c))    #函数外部c的地址为：39287880
print("-------------")

def func(a=[]):
    a.append("A")
    return a
#我们导入的模块除了定义函数之外还中有可以执行代码，那么Python解释器在导入这个模块时就会执行这些代码
#事实上我们可能并不希望如此，因此如果我们在模块中编写了执行代码，最好是将这些执行代码放入如下所示的条件中
if __name__ == '__main__':
	print(func())  //["A"]
	print(func())  //["A","A"]
	print(func())  //["A","A","A"]

3.4，变量作用域

1. if不包括作用域，以函数为例，层层向上找，函数外不可调用函数内部变量
2. global a：将函数内部变量调用最外层变量 nonlocal：将函数内部变量调用上一层变量

a=1 b=1 c=1
print(a,b,c)  //1,1,1
def fun():
   a=2 b=2 c=2 
   def fun1():
      noniocal b  b=3 global c c=3
      print(a,b,c) //2,3,3
   print(a,b,c)  //2,3,2
print(a,b,c)  //1,1,3
   fun1()
fun()

a = 10
def test():
    a += 1
    print(a)
test()  //错误，函数内部要修改一个变量，这个变量必须是内部变量

3.5，类

1. class 类名(列表)：
2. 方法：类中的函数
3. 属性：通过实例访问的对象，私有属性，__属性名
4. 创建调用：a=Dog(‘we’,3) a.方法名()
5. 继承： class 子类名（父类名）： //多继承，可继承多个父类
6. 创建子类时，父类必须包含在当前文件中，且在子类前

class Test:
    def __init__(self, foo):
        self.__foo = foo
    def __bar(self):
        print(self.__foo)
        print('__bar')
def main():
    test = Test('hello')  #类调用
    test._Test__bar()
    print(test._Test__foo)
if __name__ == "__main__":
    main()

3.6，模块：

1. 包：包名小写，不用下划线，只有包含__init__.py的文件才会被认成包
2. 封装：代码快，函数，类，模块，包，层层封装调用
3. 模块：一个.py文件即一个模块，分为自定义/内置/第三方模块
4. 导入：【from xx】 import xx/os库名，，， 【as xx】
5. 调用：模块名.函数名
6. 导入特定的函数：from 模块名 import 函数名，函数名，函数名 as 别名
7. 别名：as //函数名冲突，或过长
8. print dir(模块名) //查看已引入的模块的所有属性
9. 导入模块时，先在当前目录查找，再到sys模块的path变量所指定的目录查找

3.7，面向对象基础

1. 特点：封装，继承，多态
2. 其它：类是对象的蓝图和模板，而对象是类的实例
3. 装饰器：@property #使类中的属性访问更加安全
4. 方法：静态方法（类中方法前+@staticmethod，判断三边能否构成三角形）
   类方法（类中方法前+@classmethod，def now(cls):方法参数固定cls）
5. 类之间关系：继承is-a（男人–人），关联has-a（部门–员工），依赖use-a（司机-驾驶->车子）
6. 重写： 子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本（override）
7. 多态： 重写让父类的同一个行为在子类中拥有不同的实现，调用重写方法，不同子类表现不同

class Person(object):
 
    __slots__ = ('_name', '_age', '_gender')  # 限定Person对象只能绑定_name, _age和_gender属性

    def __init__(self, name, age):
        self._name = name
        self._age = age
     
    @property   # 访问器 - getter方法
    def name(self):
        return self._name
   
    @property    # 访问器 - getter方法
    def age(self):
        return self._age
    
    @age.setter   # 修改器 - setter方法
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)

def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳'  # AttributeError: can't set attribute

if __name__ == '__main__':
    main()

四，

4.1，文件和异常

1. 定义：用于持久化场景中的数据保存 f=open(‘bb.txt’,‘r’)
2. 模式：‘r’ 读 ‘w’ 写 ‘x’ 写 ‘a’ 追加 ‘b’ 二进制 ‘t’ 文本 ‘+’ 更新（读+写）
3. read(): 读取文件，达到文件末尾时会返回一个空字符串，显示出来为空行
4. readline():读取一行 //PS具体写法json,二进制，参考100篇
5. 使用相对路径/绝对路径来编写： a=’/home/dd/erjl/a.txt’ with open(a) as bb:

def main(): 
    try:   #with则不用finally去关闭f文件
        with open('致橡树.txt', 'r', encoding='utf-8') as f: #一次性读取
             print(f.read())      
    	with open('致橡树.txt', mode='r') as f:   # 通过for-in循环逐行读取
	        for line in f:
	            print(line, end='')
	            time.sleep(0.5)
    except FileNotFoundError:
        print('无法打开指定的文件!')
    except LookupError:
        print('指定了未知的编码!')
    except UnicodeDecodeError:
        print('读取文件时解码错误!')
#    finally:                          #无论如何总执行
#        if f:
#            f.close()
            
if __name__ == '__main__':
    main()

4.2，正则表达式

1. 链接：https://deerchao.cn/tutorials/regex/regex.htm
2. 运用：\d 数字 \w数字字母下划线 \s字符 \b边界 ^开头 $结尾 [ab]==a|b * + ?
3. 其它：用的时候在查吧

4.3，进程和线程
4.4，数据结构和算法
4.5，
Pillow：图像操作

五，框架之Django

下载后新建项目，运行打开URL即，出现下图为正确。

5.1，库的安装

• CLI方法：打开prompt文件 conda list：显示已经安装的库 conda/pip install 库名 //回车
• Anaconda Navigator安装：点击绿色圈，选最左侧第二行environment，root，not installed 搜索对应包名，安装
• anaconda 一直 solving package specification：在 root 环境中执行 “conda upgrade --all”

5.2，命令行创建django

pip3 install django==1.8.2            #Django框架，若不指定，默认最新
pip3 install pymysql                  #连接mysql配置
django-admin --version                #查看安装的版本
pip show django  
+ import django  django.__file__      #查看django安装目录

• django-admin startproject 项目名 //创建项目，用管理员打开切换到合适的目录哦
• python manage.py startapp app //cd 项目名 ，建立app， Mac需python3
• python manage.py runserver//启动项目

5.3，资源目录

• static：放置css,js等文件
• templates： 放置html文件
• manage.py：与项目进行交互的命令行工具集的入口，相当于项目管理器，运行后会显示一些可供调用的子命令
• wsgi.py：python服务器网关接口，与web服务器之间的接口（通信关键，一般不要改动）
• urls.py：配置文件，即每个页面的地址，网站的目录
• settings.py：全局配置文件，包含数据库、web应用、时间等](https://img-blog.csdnimg.cn/20200411165205941.png)
• init.py：空文件，表明是一个python的包

5.4，app项目：

• init.py：一个空文件，告诉Python解释器这个目录应该被视为一个Python的包。
• admin.py：可以用来注册模型，用于在Django的管理界面管理模型。
• apps.py：当前应用的配置文件。
• migrations：存放与模型有关的数据库迁移信息。
• models.py：存放应用的数据模型，即实体类及其之间的关系（MVC/MTV中的M）。
• tests.py：包含测试应用各项功能的测试类和测试函数。
• views.py：处理请求并返回响应的函数（MVC中的C，MTV中的V）。

5.5，setting配置举例：

• LANGUAGE_CODE = ‘zh-hans’ //中文
• TIME_ZONE = ‘Asia/Shanghai’ //时区
• INSTALLED_APPS=【 添加app 】

• STATIC_URL=’/static1/’ //在Django 具体APP下建立的static目录，存放静态资源
• STATICFILES_DIRS=[os.path.join(BASE_DIR, ‘static\img’), // 无论目录是APP下 http:…/static1/1.jpg
• os.path.join(BASE_DIR, ‘static\js’), // 引入：link: /static/js/xx.js
• TEMPLATES={//第二行 ‘DIRS’: [os.path.join(BASE_DIR,‘templates’)], //模板配置，使用templates所需
• {%static%}：https://blog.csdn.net/xujin0/article/details/83421626

DATABASES = {  #默认数据库配置
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

DATABASES = {  #mysql数据库配置
    'default': {
        'ENGINE':'django.db.backends.mysql',
        'NAME': 'ttsx',          #数据库的名字
        'HOST':'localhost', #当前数据库的地址
        'PORT':'3306',   #端口
        'USER':'root',  #用户名
        'PASSWORD':'jycsq',  #密码
    }  #  model.py  文件中 from __future__ import unicode_literals 放最开始
}   #  mysql连接需要安装Pillow

net start mysql80  #管理员打开命令行  
show databases;     #MySQL命令行+输入密码 
create database ttsx charset=utf8;   #创建数据库
mysql -u root -p   #Mac上命令行输入+密码
mysql>exit;  #退出mysql

非app__init__()文件添加，MySQL所需

import pymysql     
pymysql.install_as_MySQLdb()

• PK：Primary Key, 主键
• NN：Not Null, 非空
• UQ：Unique, 唯一索引，具有unique属性的列确保所有的记录的值都不同。
• BIN：Binary
• ZF：Zero Fil，用0填充所有剩余空间，例如，int(4)，而值为1时，则内容显示为0001
• AI：Auto Increment，自动增长
• G：Generated Column，基于其它列的公式生成值的列
• Default：默认值

5.6，url.py配置举例：

• from app名 import views //app内常用功能配置文件views.py
• urlpatterns = [
• path(‘admin/’, admin.site.urls), #旧记录
• path(r’^index/’, views.Cal), #新增记录，记得导入，然后用view.函数名
• ] //r 取消转义 前面的为链接http:index
• alt+enter 报错，自动导入import

5.7，form表单举例

• < form method=“POST” action="/cal"> // POST加密提交，/cal为提交地址 not from
• {% csrf_token %} // 提高安全性，必要
• < input type=“number” name=“valueA”> //type属性，name只能写名字
• < input type=“submit” value=“计算”>
• < /form>
• 模板语言的for循环：{% for xx in xx %} …{{变量}}… {% endfor %} //对于页面的渲染，可以每次选择一部分，然后依次演示

5.8，views.py页面：

• from django.http import HttpResponse // def index(request): return HttpResponse(“Hello.”)
• from django.shortcuts import render // def regin(request): return render(request，“regin.html”,context={‘data’:data1})
• data1=models.cal.objects.all() //获取数据库的cal函数的所有数据
• value_a = request.POST[‘valueA’] //

models.cal.objects.create(value_a=value_a, value_b=value_b, result=result)
def index(request): return render(request，“result.html.”，,context={‘data’:result})
//数据传入模板，第三个参数：字典 HTML中显示传入数据{{result}} {{resullt.abc}}

• def DelData(request): //内容清空，列表页上面列表下面一个情况按钮
  models.cal.objects.all().delete()
  return HttpResponse(‘data Delete1’)

HTML： 可以有多个app，每个app中views函数中，返回的字典为对应页面需要调用的值

5.9，配置admin

• 运行系统：python manage.py runsever
• 创建用户：python manage.py createsuperuser //之后输入账号/邮箱/密码
• 访问系统：localhost:8080/admin //Admin入口，之前 python manage.py runsever
• 配置应用：from models import 数据库函数名 admin.site.register(数据库函数名) //admin.py
• 修改数据默认显示的名称： class … def str(self) ：return self.数据名 //model.py
• 希望显示所有数据信息：class 类名(admin.ModelAdmin)：list_display=[’’,'数据名‘…] admin.site.register(数据库函数名，类名)
• 限制分页：类中添加 list_per_page=10 //admin.py
• 页面动作不想要的化：actions_on_top=False //上 actions_on_top=True //下 //admin类中添加
• 页面中添加搜索框： search_fields=['数据名’，‘ ’，…] //admin类中添加
• 管理员页面数据名显示中文：goods_name=models.CharField(max_length=100,verbose_name=“商品姓名”) //models.py
• 页面显示添加一列： def aa(self):return self.数据名+”我很喜欢“ //models.py 在admin类的列表中添加’aa’
• 将上述数据显示名aa改为中文名：aa.short_description="好的描述”.
• admin页面修改：略

5.10，template中过滤器

• HTML中：form表单 {%if aa%}…{{a}}…{%else%}…{{a}}… 可用过滤器{{a|default：“0”}
• python manage.py shell //进入交互式页面进行编程
• 自定义过滤器：app下创建templatetags文件夹下创建myfilter.py文件
• from django.template import Library
• register=Library() @register.filter def mod(value,ll)：return value%ll //最多两个参数
• HTML中：{% load myfilter %} {{a|mod:3}}

六，Django的数据库配置

6.1，数据库编写

from django.db import models
# Create your models here.
class Goods(models.Model):
    name=models.CharField(40,unique=True,Blank=True)
    account=models.IntegerField(40,Blank=True)

6.2，数据库操作

• venv\Scripts\activate //底部terminal–开启虚拟环境
• python manage.py makemigrations 【appname】 //创建一个001文件
• python manage.py migrate 【文件夹名 001】 //查看生存情况
• python manage.py migrate 【appname 文件名】// 创建数据库表

6.3，model.py编写：

terminal cls清屏？
class 数据库名(models.Model):
属性名=models.Char/Field(max_length=11)
属性名=models.IntegerField(default=10) //主键不写默认生成id属性为主键
status=(
(1,‘待付款’),
(2,“代发货”),
(3,“待收货”),
(4,‘已完成’),
) //加入多个
属性名=models.IntegerField(default=1,choices=status)
goods_info=models.ForeignKey(‘goods.GoodsInfo’， on_delete=models.CASCADE) //外键，其它商品有

6.4，数据库的增加操作

• terminal下输入：python manage.py shell #进入编辑模式
• from app名.models import * #导入编辑模块
• categories=[(‘时令水果’,‘fruit’,1),(‘新鲜水产’,‘seafood’,2),(‘全品肉类’,‘meet’,3),(‘美味蛋品’,‘egg’,4),(‘新鲜蔬菜’,‘vegetable’,6),(‘低温奶制 品’,‘ice’,7)]
  for cag in categories:
  c=GoodCategory() #model中的函数名
  c.cag_name=cag[0] #c.属性名
  c.cag_css=cag[1]
  c.cag_img=‘images/banner0%d.jpg’%cag[2] #写的地方%d之后%
  goods.goods_cag_id=1 //这个是model中写的外键哦goods_cag=…（’a’,…）,1为主键的表中的位置是第一个
  c.save() #insert #回车两次哦

6.5，数据库的删改查

• c=函数名.objects.get(goods_name='离子‘） //get查询一条不可为空，all返回多条
• c=函数名.objects.all(goods_name='离子‘）[1:3] //切片
• c=函数名.objects.filter(goods_name=name） //条件
• c.goods_id=‘1’ c.save() //更新 c.delete() //删除
• print(c.goods_id,c.good_la)
• 在mysqlworkbench中查看，点击表名，右键，第一个是看前100列，第二个是看具体内容

7.1，中间件

• 定义：比如没有登陆就不能进行某些操作，crsf的验证等等
• 创建：app下创建middleware.py文件，setting.py文件中MIDDLEWARE_CLASSES中添加‘app名.middleware.MyMiddleware’
• 编写：middleware.py文件中

class MyMiddleware:  #类名可自定义
   def  __init__(self):
       print('__init__')   #定义操作  只会在第一次初始化时执行
  def  process_request(self,request):
       print('process_request')
  def  process_view(self,request,view_func,*view_args,**view_kwargs):
       print('process_view')
  def  process_response(self,request,response):
       print('process_response')
       return response
  def  process_exception(self,request,exception):
       print('exception')  #会打印异常的名字
#执行视图时，Pycharm中会打印上述内容

7.2，Cookie

• 存储在用户电脑中的数据，如一个页面登陆，点击购买物品到另一个页面，默认已经登陆
• 临时存储数据：如购物，将苹果一个收入购物车，几天后登陆苹果仍在购物车
• 可以设置有效期：如网站登陆后，几天后需重新登陆
• request.set_cookie(…) //设置，view.py函数中写，找怎么写
• request.delete_cookie(key,path=’/’,domain=None…) //删除
• request.COOKIES[key] request.COOKIES.get(key,’ ')

7.3，jQuery的Ajax技术

• 全称：Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）
• 作用：不用重新加载整个页面，也可以更新部分网页的技术
• $.ajax({
  url: ‘/facedetectDemo/’, //发送请求的地址，默认当前页，调用django服务器计算函数
  type: ‘POST’, //请求类型，默认GET
  data: formdata, //发送到服务器的数据，自动转换为字符串格式
  dataType: ‘json’, //服务器返回的数据类型，有xml/html/script/json/text/json几种
  processData: false, //默认true，当data的类型不为字符串时，设置为false
  contentType: false, //发送信息至服务器时内容编码类型
  success: ShowResult //在请求成功之后调用该回调函数输出结果
  }) //上述顺序可变
• 学习：https://www.w3school.com.cn/jquery/ajax_ajax.asp

小技巧：

• Ctrl+Esc可以在全屏模式下调用下部，选择截图
• alt+enter 报错，自动导入import
• 双击shift可以用来查找

八，前端知识

8.1，Ajax（异步js和xml)
定义：允许浏览器与服务器通信而无须刷新当前页面，局部更新用户数据
原因：网速慢，加载页面，重新挑战，等待时间长，表单提交内容不合格需重写
应用：页面上拉加载，分页，表单数据验证（邮箱地址唯一性），搜索框提示文字下拉列表

创建XMLHttpRequest对象,也就是创建一个异步调用对象.

创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息.

设置响应HTTP请求状态变化的函数.

发送HTTP请求.

获取异步调用返回的数据.

使用JavaScript和DOM实现局部刷新.