Django笔记

Day 1:
2、创建APP
python manage.py startapp app01
__init__.py # 包
admin.py # 数据库后台
apps.py # django 把项目和APP 关联起来的文件
models.py # 数据库操作地方
test.py # 单元测试
views.py  # 业务逻辑代码 ****
migrations # 数据库相关

# 启动Django web服务器 python manage.py runserver 0.0.0.0:8000
# 404页面  由django 自己提供

3、第一次django请求
    1、匹配路由， 路由分发器查找用户请求的URL对应关系
        1、找到了业务函数，就调用
        2、找不到报404
    2、业务函数，执行业务逻辑
    3、返回数据给浏览器、

    test_views
        1、urls.py 编写路由
        2、在views.py 写一个业务函数
            2.1 编写业务代码
            2.2 通过HttpResponse 方法返回数据给浏览器
        3、通果 python manage.py runserver 0.0.0.0:8000 启动服务
4、请求方式
<form method = 'get'>
    method='get' # 从后台拿数据
    method='post' # 向后台提交数据
5、html文件的调用(模板初探)
    1、配置settings.py
    TEMPLATES = [ # 模板，处理html文件
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [os.path.join(BASE_DIR, 'templates'),os.path.join(BASE_DIR,'html')]  # html 文件夹的位置
            ,
            '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',
                ],
            },
        },
    ]
    2、views.py 调用render方法
        return render(request,'login.html')
6、mvc & mtv
    mvc 是一种使用MVC（Model View Controller 模型-视图-控制器）设计创建Web应用程序的模式
    Model(模型) 一般对应数据库操作，记录的存取
    View (视图) 决定着如何展示数据
    Controller(控制器) 负现处理用户交互的部分，控制器负责从视图读取数据，控制用户输入，并向模型发送数据。
    mtv
    django是一个mtv框架，其架构模板看上去与传统的MVC架构没有太大的区别
    django将MVC中的视图进一步分解为django视图和django模板两个部分，分别决定‘展现哪些数据’和‘如何展现’ ,使得django的模板可以根据需要随时替换，
    而不仅仅限制于内置的模板，至于mvc控制器部分，由django框架的URLconf来实现

    MVC Views 负责业务逻辑处理+数据展示
    MTV Views 负责业务逻辑处理
        Templates 负责数据展示



练习：
    1、wsgi 的web server 实现。并支持加载css,js文件
    2、用django开发完整用户登录程序（背景图，表单等）



Day 2
路由：
    1、静态路由
        re_path(r'articles/2003/$',views.special_case_2003) # r防止转义 $表示结尾，以 /artiicles/2003/ 结 尾，并没有定义开头
    2、动态路由
        re_path(r'^articles/(?P<year>[0-9]{4})/$',views.year_archive),  # ^ 定义开头，必须以articles开头，以atricles
        re_path(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$',views.month_archive)

Django2.0 URL路由：
    from django.urls import path
    from . import views
    urlpatterns = [
        path('articles/2003/',views.special_case_2003),
        path('articles/<int:year>/',views.year_archive),
        path('articles/<int:year>/<int:month>/',views.month_archive),
        path('articles/<int:year>/<int:month>/<slug:slug>',views.article_detail),
    ]
Django2.0 URL路由关键字(Path converters)：
str:匹配只要是不为空的字符串 不包含 '/'
uuid:匹配唯一编码,必须是UUID格式
path:匹配只要是不为空的字符串  包括 ‘/’
自写转换器（URL）
class FourDigitYearConverter:
    regex = '[0-9]{4}' # 正则
    def to_python(self,value): # 转换成python 的数据类型
        return int(value)

    def to_url(self,value):
        return '%04d' % value
调用转换器
register_converter(converters.FourDigitYearConverter,'yyyy') # 类似于将自己写的转换器命名为yyyy
urlpatters = [
    path('articles/2003/',views.special_case_2003),
    path('artivles/<yyy:year>/',views.year_archive),
]

2、URL的管理 include 子URL
当有多个APP时，每个APP可以有自己的urls.py,只需在顶级urls.py中include一下就可以
例子：
    from django.url import include,path
    urlpatterns = [
        path('community/',include('aggregator.urls')),
        paht('contact/',include('contact.urls')),
    ]
3、URL的聚合
    extra_patterns = [
        path('reports/',credit_views.report),
        path('reports/<int:id>/',credit_views.report)
        path('charge/',credit_views.charge),
    ]

    urlpatterns = [
        path('',main_views.homepage),
        path('help/',include('app.help.urls')),
        path('credit/',include(extra_patterns)),
    ]



Day3:
1、在views里操作数据库
import pymysql
def index(request):
    # 创建连接
    conn = pymysql.connect(host = '127.0.0.1',port = 3306,user = 'root', passwd = 'alex123', db = 'luffy_dev' )
    # 创建游标
    cursor = conn.cursor()

    cursor.execute("select username,email,mobile from web_account")
    data_set = cursor.fetchall()

    cursor.close()
    conn.close()

    return HttpResponse(data_set)
自己写的sql问题
    1、sql注入
    2、代码与sql写死在一起，导致解耦差
    3、开发人员的sql水平不一，导致性能不好
    4、开发效率低
ORM：对象关系映射
    实质就是将关系数据库中的业务数据用对象的形式表示出来，并通过面向对象的方式将这些对象组织起来，实现系统业务逻辑处理
    在ORM过程中最重要的概念是映射，通过这种映射可以使业务对象与数据库分离，从面向对象来说，数据库不应该和业务逻辑绑定在一起，ORM则起到这样的分离
    作用，使数据库层透明，开发人员真正的面向对象。

    优点：
        实现了代码与数据库操作的解耦合
        不需要自己写原生sql,提高开发效率
        防止sql注入

    缺点：
        牺牲性能
        复杂语句力不从心
   class Account(models.Model):
        username = models.CharField(max_length = 64,unique = True)  # 数据类型Char Field
        email = models.EmailField()
        password = models.CharField(max_length = 128)
        register_date = models.DateTimeField()
        signature = models.CharField(max_length = 128,blank = True,null = True)
    # 一个类对应数据库的一个表，类里的一个属性，对应数据库的一个字段
    class Article(models.Model):
        title = models.CharField(max_length = 255, unique = True) # unique = True 说明表内数据不能重复。唯一
        content = models.TextField()
        account = models.ForeignKey("Account",on_delete = models.CASCADE)
        pub_date = models.DateTimeField()
        read_count = models.IntegerField()

     创建数据:
        models.Account.objects.create(
            username = 'alex',
            email = 'alex@luffycity.com',
            password = 'abc123',
            register_date = datetime.datetime.now(),
            signature = 'chaos is a ladder.'
         )

         insert into app01_account (username,email,password,register_date,signature)
         values ('jack','jack@luffycity.com','abc123','2019-04-27 15:32','Talk is cheater')


      查找数据：
      select username,email from app01_account;
      models.Account.objects.values("username","email")

Django models:
    ORM 映射字段类型
        AutoField  # 自增
        BigAutoField # 大型自增
        BigIntegerField # 大型整数
        BinaryField # 存二进制字段 0，1
        BooleanField # 布尔类型 不允许为空
        CharField # 字符串
        DateField # 时间存到天
        DateTimeField # 时间存到秒
        DecimaField
        DurationField # 区间
        EmailField # 检测是否Email类型
        FileField # 存储文件
        FloatField # 存浮点类型
        ImageField # 存图片
        IntegerField # 整数
        GenericIPAddressField # IP地址 支持IPV4和IPV6
        NullBooleanField # 布尔类型，但是允许为空
        PositiveIntegerField # 正整数
        PositiveSmallIntegerField # 正小数
        SlugField # 标签
        SmallIntegerField # 小整数
        TextField # 大文本存储
        TimeField # 时间
        URLField # URL
        UUIDField # UUID
    外键关联：
        Foreignkey # 外键关联
        ManyToManyField # 多对多 多写一个关联表
        OneToOneField # 1对1
    多对多中，写好ManyToManyField类型，Django会自动创建多对多的表
    在python3中，Django默认连接数据库的插件是MysqlDB,但是python用于连接数据库的包是pymysql,所以在python使用Django模板连接数据库的时候
    需要在项目头中写入
    import pymysql
    pymysql.install_as_MySQLdb()
    备注：下载my_site下的__init__.py中

Django 数据同步工具
    migrations :将类装换成sql语句。
    1、生成同步文件
        python manage.py makemigrations

    2、同步
        python manage.py migrate

    migrations 在执行同步的时候，会检测settings.py文件中的配置，

    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app01',
]
    需要将自己的项目名称写进 INSTALLED_APPS中，只要该表中的项目数据结构发生变化，Django会自动同步。


数据库的配置写到settings中
    Blog系统表结构设计
    1、每个用户有自己的账户信息
    2、用户可以发文章
    3、文章可以打多个标签

ORM的增删改查
    创建数据库：
        1、直接创建
        2、先生成对象，再创建
        cmd
        python manage.py shell
        from app01 import models
     # 创建对象
     models.Account.objects.create(
        username = 'alex',
        email = 'alex@luffycity.com',
        password = 'abc123',
        register_date = datetime.datetime.now(),
        signature = 'chaos is a ladder.'
     )
     执行直接写入数据

     o = models.Account(
        username = 'alex',
        email = 'alex@luffycity.com',
        password = 'abc',
        signature = 'alex is so handsome.'
     )
      先准备好数据，后续再等命令实行写入数据  去掉create;
      o.save()
      提交
     new_user_obj = models.Account(
        username = 'elina',
        email = 'elina@luffycity.com',
        password = 'abc123',
        register_date = datetime.datetime.now()
        signature = 'time is money.'
     )
     new_user_obj.save()

跨表写入数据
1、主外键的填写
o = models.Article(
    title = 'ys今天很帅'，
    content = '今天特别帅，就是很帅，帅的掉渣。真牛'
    pub_date = '2018-12-03'
)
o.account_id = 1
o.save()

2、多对多
创建完对象再去关联
1、create object
2、通过创建成功的对象，添加多对多关联
o2 = models.Article(
    title = '路飞上市',
    content = '2050',
    account_id = 3,
    tags = [1,2,3],
    pub_date = '1999-01-01',
)
o2.tags.set([1,2,3]) # set赋值状态，会覆盖 要求列表
o2.tags.add(4,3)  # add 在原有的基础上添加。

总结（增）：
object 的创建方式
1、object.create  直接创建
2、先创建对象，在obj.save()

外键关联
1、obj.account_id = 2
2、obj.account = account对象

多对多
1、o2.tags.set([1,2,3,4,5]) # 赋值
2、o2.tags.add(6,7) # 在原有的基础上添加


ORM 查数据
models.Account(表名).objects.all(查询所有)() //select * from Account;
models.Account.objects.filter(id = 1)  //select * from Account where id = 1;
models.Account.objects.filter(id__gt = 1)  //select * from Account where id > 1;
models.Account.objects.filter(id__gte=1) //select * from Account where id >= 1;
models.Account.objects.filter(id__gt=1,password = '111')  //select * from Account where id >= 1 and password = '111';
models.Account.objects.filter(password__startswith = 'a') //select * from Account where password like "a%";

filter过滤条件：
1、contains 包含，相当于sql中的like条件
select * from app01_account where username like "%a%"; # 大小写不敏感
models.Account.objects.filter(username__contains'a') # 大小写敏感
models.Account.objects.filter(username__icontains'a') # 大小写不敏感

2、in
select * from app01_account where id in (1,2);
models.Account.objects.filter(id__in(1,2))
models.Account.objects.filter(id__in[1,2,3])

3、lt 小于
4、lte 小于等于
5、startswith 大小写敏感
6、istartswith 大小写不敏感
7、endswith  以什么结尾 大小写敏感
models.Account.objects.filter(username__endswith = 'k')
8、iendswith 大小写不敏感
9、range 区间过渡，可对数字、日期进行过滤
select * from app01_account where pub_date between '2005-01-01' and '2005-03-31';

import datetime
start_date = datetime.date(2005,1,1)
end_date = datetime.date(2005,3,31)
models.Account.objects.filter(pub_date__range(start_date,end_date))

models.Account.objects.filter(pub_date__range['2018-01-30','2018-03-31'])

10、date 差具体某一天
models.Account.objects.filter(pub_date__date = '2018-01-03')

11、year 具体查某一年
models.Account.objects.filter(pub_date__year = 2018)

12、month 只查月份
models.Account.objects.filter(pub_date__month = 5)

13、day 只查天
models.Account.objects.filter(pub_date__day = 6)

14、week 只查某个星期

15、week_day 只查某一天，例如 只查每周二  从周日开始
models.Account.objects.filter(pub_date__week_day = 3)

16、hour 只查某个小时的
models.Account.objects.filter(pub_date__hour = 23)
17、minute，second 对分钟和秒

18、isnull
models.Account.objects.filter(pub_date__isnull = True)

19、regex 正则表达式 大小写敏感
models.Account.objects.filter(title__regex = r'^(An?|The) +')
20、 iregex 正则，大小写不敏感


直接拿数据
values:
a = models.Account.objects.all()
a.values()
a.values('username')
a.values('username','password')

order_by() 排序
a.values('id','register_date').order_by(id)  默认升序
a.values('id','register_date').order_by(-id) 降序排列
a.values('id','register_date').order_by('register_date','id') 默认升序，根据register字段排序，register如果相等，则根据id字段默认升序
a.values('id','register_date').order_by('register_date','-id') 默认升序，根据register字段排序，register如果相等，则根据id字段降序

reverse() 翻转 reverse使用之前必须对其排列好，使用order_by
a.values('id','register_date').order_by('id').reverse()

精确查找 get 只能查一条，确保存在，而且不重复  没有或多个会报错
models.Account.objects.get(id = 1)
get 查到的就是对象本身了。
a = models.Account.object.get(id = 1)
a.username  #可以直接调用，不需要其他方法

exclude 排除符合条件的数据，把其他的数据返回
models.Account.objects.exclude(register_date__date = '2018-06-12')


总结查：
    get 返回一个对象，没有，或多个会报错
    filter 返回多个对象
    all 返回所有数据
    exclude 排除符合条件的数据，把其他的返回


改删：
批量修改
models.Account.objects.filter(username = 'elina').update(password = 'Luffy#21')
单条修改
obj = models.Account.objects.get(username = 'linux')
obj = username = 'python'
obj.save()

批量删除
models.User.objects.get(password = 'oldboy').delete()
单条删除
obj = models.User.objects.get(id = 3)
obj.delete()