py一些笔记

定义空数组

a = ['']
b = list()
print(a)
print(b)
------------------------------
a = ['']
b = list()
print(a)
print(b)
print('----------------------------------------')
b.append('java')
b.append('c')
b.append('php')
print(b)
print('----------------------------------------')
b.pop(0)
print(b)
print('----------------------------------------')
b.remove('php')
print(b)
----------------------------------------------------
a = ['']
b = list()
print(a)
print(b)
print('----------------------------------------')
b.append('java')
b.append('c')
b.append('php')
print(b)
# boolean
print('python' in b)
for i in b:
    print('值是', i)

其他例子：

a = []
b = list()
print(a)
a.append('python')
print(b)
print('----------------------------------------')
b.append('java')
b.append('c')
b.append('php')
print(b)
a.extend(b)
print(a)
# boolean
print('python' in b)
for i in b:
    print('值是', i)

# count用于计算字符在列表里面出现的次数
print(a.count('python'))
print(a.index('php'))

c=['abc','def',';',['aaa'],{'name':'mike'}]
print(c)

字典的学习

# 定义一个字典
a = dict()
b = {}
a = {'name':'杰克','age':19,'address':'shanghai'}
# 添加key-value
a['job'] = 'IT'
a.setdefault('job1', 'edu')

print(a)
print('----------------------------------------------')
#取出key
try:
    print(a['job1'])
except KeyError:
    print('key error')
finally:
    print('一定会执行我这行代码')
print(a.get('job'))
#修改字典的值
a['name'] = '外壳'
print(a)
#修改字典的值不要用setdefault，setdefault是用来添加key-value值的。对于已存在的key，setdefault无法设置其值

字典学习

a = {}
b = {'name':'mike'}
print(a)
print(b)
# 把b的字典赋值给a
a.update(b)
print("现在的a字典是：",a)
# 把b的字典再次添加到a上面
b.setdefault('age', 14)
a.update(b)
print("现在的a字典是：",a)
# 生成可迭代的对象
print("打印所有的key")
for i in a.keys():
    print(i)
print("打印所有的values")
for i in a.values():
    print(i)

print("打印字典的key-value键值对,注意返回的是元祖类型")
for i in a.items():
    print(i)

# 返回数组类型
list = [i for i in a.keys()]
print(list)

# 删除元素
a.pop('age')
print("现在只有name这个key了",a)

set集合练习

a = set()
print("这是一个set集合：", a)
a.add(1)
print(a)
a.add(2)
print(a)
a.add(1)
print("集合增加重复的元素是加不进去的，比如a集合还是这些元素",a)
b = []
b.append(1)
b.append(2)
b.append(1)
print("列表对于重复的元素依然会增加，不会去重复值", b)
print("列表和集合的区别就是集合的元素是不可重复的，利用这个特性可以去重元素")
print("列表与集合的转化")
c = set(b)
print("现在的c集合是",c)
c = list(c)
print("现在的c列表是",c)
c = sorted(c,reverse=True)
print("现在的c列表反转一下", c)
# 在定义一个d，对d列表进行排序
d = [5,2,4,9,7,3]
print("原来的d列表是",d)
print("对d列表排序一下", sorted(d))
# 定义e列表
e = [5,2,4,9,8,3,6,2,4,9]
e = sorted(list(set(e)),reverse=True)
print("原来的e列表是",e)
print("去重后的e列表是",e)

变量a为空值的代码：

None = '' = 空元祖 = 空列表 = 空字典

while循环

import time
n = 0

while True:     # while 1也可以
    # 休息一秒钟
    time.sleep(1)
    print("hello world {}".format(n))
    if n == 10:
        break
    n += 1

一些函数使用

a = ['1',2,3,4,5]
b = [1,2,3,4,5]
c = (1,2,3,4,5)
#print("数据类型不统一会报错",sum(a))
print("列表的总数是：",sum(b))
print("元祖的总数是：",sum(c))

匿名函数

a = lambda x:x+1
print(a(10))
print(a(100))

b = lambda x:x*50
print(b(10))

c = lambda x,y:x*y
print(c(3,8))

实名函数

def print_name(name,address='beijing'):
    print("hello {}, wolcome to {}".format(name,address))

print_name('杰克')

def print_name(name,address='beijing'):
    print("hello {}, wolcome to {}".format(name,address))

print_name('杰克','Shanghai')                                    # 当我传参时，使用我传参的值。不传参时，直接使用默认值beijing

不定长函数

def print_name(name, *args):
    print(args[0],args[1])             # name已经传过去值了，现在还有后面两个参数

print_name('杰克','上海',25)      

关键字函数

def print_name(name, *args,**args1):             # **args是用来接受字典类型
    print(args, args1)

print_name('杰克','上海',25,job='python',age=20)

装饰器应用

def wrap(func):
    def inner(*args, **kwargs):
        m = args[0]
        n = args[1]
        if not (type(m) == int and type(n) == int):
            return "参数输入错误"
        res = func(*args, **kwargs)
        return res
    return inner

@wrap
def sum1(m, n):
    return m+n

value = sum1(10,70)
print(value)

类，例子一

# slef是当前实例本身
class Person:
    name = '杰克'

    # __init__初始化一些属性
    def __init__(self):
        self.score = 100

    def get_name(self):
        return 'Name is {}, score is {}'.format(self.name, self.score)


p = Person()
print(p.name)
print(p.get_name())

传入参数

# slef是当前实例本身
class Person:
    name = '杰克'

    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__
    def __init__(self, address):
        self.score = 100
        self.address = address

    # 对于其他的可以写个方法参数
    def get_name(self, project):
        return 'Name is {}, score is {}, project is {}, address is {}'.format(self.name, self.score, project, self.address)

# __init__里面写的初始化的参数可以在实例化对象的时候传进去
p = Person('BeiJing')
print(p.name)
print(p.get_name('python'))

子类继承父类

# slef是当前实例本身
class Person:
    name = '杰克'

    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__
    def __init__(self, address):
        self.score = 100
        self.address = address

    # 对于其他的可以写个方法参数
    def get_name(self, project):
        return 'Name is {}, score is {}, project is {}, address is {}'.format(self.name, self.score, project,
                                                                              self.address)


class SportPerson(Person):
    age = 25

    def get_age(self):
        return 'Name is {}, age is {}'.format(self.name, self.age)

# __init__里面写的初始化的参数可以在实例化对象的时候传进去
# 子类继承父类，子类也要写所有类中的__init__方法的参数
s = SportPerson('Shanghai')
print(s.get_name('python'))
print(s.get_age())

第二个例子：

# slef是当前实例本身
class Person:
    name = '杰克'

    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__
    def __init__(self, address):
        self.score = 100
        self.address = address

    # 对于其他的可以写个方法参数
    def get_name(self, project):
        return 'Name is {}, score is {}, project is {}, address is {}'.format(self.name, self.score, project,
                                                                              self.address)

class SportPerson(Person):
    age = 25
    def __init__(self):
        self.fruit = 'apple'

    def get_age(self):
        return 'Name is {}, age is {}'.format(self.name, self.age)

# __init__里面写的初始化的参数可以在实例化对象的时候传进去
# 子类继承父类，子类也要写所有类中的__init__方法的参数
s = SportPerson()
print(s.get_age())

多继承的话，如果多个父类含有同名的方法，则以第一个类为主。
实例化与类方法，静态方法，上面的方法都是实例化，下面这个是类方法

# slef是当前实例本身
class Person:
    name = '杰克'

    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__

    def __init__(slef, address):
        slef.score = 100
        slef.address = address

    # 注意下面的cls.score不能在__init__里面出现使用，也就是说除了上面的name属性可以使用，其他都不能使用
    @classmethod
    def get_name(cls, project):
        return 'this classmethod  score is {}, project is {}'.format(cls.name, project)

print(Person.get_name('python'))

下面这个是静态方法

# slef是当前实例本身
class Person:
    name = '杰克'
    # score = 99
    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__

    def __init__(slef, address):
        slef.score = 100
        slef.address = address

    # 静态方法的特点是调用属性使用类名来进行调用。不能使用cls与self，相反。classmethod会访问到cls，实例化访问self
    @staticmethod
    def get_name(project):
        return 'Name is {}  {}'.format(Person.name, project)

print(Person.get_name('python'))

getatter反射的用法

# slef是当前实例本身
class Person:
    name = '杰克'
    # score = 99
    # __init__初始化一些属性
    # 对于公共的参数可以直接写在__init__

    def __init__(self, address):
        self.score = 100
        self.address = address

    def get_name(self,project):
        return 'Name is {} ,project is {}'.format(self.name,project)


sp = Person('BeiJing')
# 反射
res = getattr(sp, 'get_name')

print(res('python'))

items()方法学习：
items()表示返回一个可迭代的元组数组。主要是用在字典上面。比如

>>> a = {'a':1,'b':2,'c':3,'d':4,'e':5,'f':6}
>>> b = sorted(a.items())
>>> b
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)]

对于items的返回对象可以使用切分，比如：
b[:5]表示截取前五个元组

python django

# urls.py文件内容如下所示：
from .views import hello
urlpatterns = [
    path('admin/', admin.site.urls),
    # name='hello'这个可以不用写，写了的话表示template可以直接引用的
    re_path(r'^hello/([a-zA-Z]+)/([0-9]+)/$', hello , name='hello')
]

# views.py文件内容如下所示：
from django.http import HttpResponse, JsonResponse

#
#
# # 这里的第一个参数必须是request
# def hello(request):
#     # httpresponse返回的是字符串，而jsonresponse返回的是json格式的文本
#     return HttpResponse('hello')
#
#
# # 尝试返回字典
def hello(request, *args):
    a = {
        'Name': args[0],
        'age': args[1]
    }
    return JsonResponse(a

)

在django中通过命令行给数据库传送数据
数据库里面分别是这几个字段

MariaDB [dja]> desc cmdb_idc;
+---------+-------------+------+-----+---------+----------------+
| Field   | Type        | Null | Key | Default | Extra          |
+---------+-------------+------+-----+---------+----------------+
| id      | int(11)     | NO   | PRI | NULL    | auto_increment |
| name    | varchar(32) | NO   |     | NULL    |                |
| address | varchar(64) | NO   |     | NULL    |                |
| remark  | longtext    | NO   |     | NULL    |                |
+---------+-------------+------+-----+---------+----------------+
4 rows in set (0.01 sec)

python manage.py shell
# 第一种方法
>>> from cmdb.models import Idc
>>> Idc.objects.create(name='昌平机房', address='北京市昌平区', remark='first computer')
<Idc: 昌平机房>
>>> Idc.objects.create(name='云泰机房',address= '内 古鄂尔多斯市', remark='second computer')
<Idc: 云泰机房>
>>> Idc.objects.create(name='天蝎机房', address='江西省抚州市',remark='third computer')
<Idc: 天蝎机房>
# 第二种方法
>>> data = {'name':'厦门一号机房','address':'福建省厦门市','remark':'fourth computer'}
>>> Idc.objects.create(**data)
<Idc: 厦门一号机房>

既然加入了数据那么就可以查询到数据

# 根据name来进行查找
>>> Idc.objects.get(name='昌平机房')
<Idc: 昌平机房>
>>> idc=Idc.objects.get(name='昌平机房')
>>> idc.name
'昌平机房'
>>> idc.id
1
>>> idc.address
'北京市昌平区'
>>> idc.remark
'first computer'

# 根据id号进行查找
>>> idc=Idc.objects.get(id=1)
>>> idc
<Idc: 昌平机房>
>>> idc.name
'昌平机房'
>>> idc.address
'北京市昌平区'

queryset与object的区别，object是通过modelname.objects.get方法得到，是一个数据对象，而queryset是通过modelname.objects.filter/all/exclude等方法得到，是一个查询集合。包含0个或多个的查询集合。
并且object只能获取一个数据，如果返回多个，就报错了。

>>> idc = Idc.objects.filter(id=1)
>>> idc
<QuerySet [<Idc: 昌平机房>]>                   # 看的出来是一个集合
>>> idc.get()
<Idc: 昌平机房>

>>> idc = Idc.objects.all()
>>> idc
<QuerySet [<Idc: 昌平机房>, <Idc: 云泰机房>, <Idc: 天蝎机房>, <Idc: 厦门一号机房>]>
>>> for i in idc:
...     print(i)
... 
昌平机房
云泰机房
天蝎机房
厦门一号机房

先查询，如果有则查询出来，如果没有则创建，也就是说对象不存在则创建，返回元祖（对象, 布尔值）

>>> Idc.objects.get_or_create(name='haha')
(<Idc: haha>, True)                                      # 这个True表示数据库没有从而执行了创建操作。

>>> res = Idc.objects.filter(name='昌平机房').first()
>>> res
<Idc: 昌平机房>

删除操作

# 删除一个
>>> Idc.objects.filter(id=1).delete()
(1, {'cmdb.Idc': 1})
>>> idc = Idc.objects.all()
>>> idc
<QuerySet [<Idc: 云泰机房>, <Idc: 天蝎机房>, <Idc: 厦门一号机房>]>
# 删除全部
>>> Idc.objects.all().delete()
(3, {'cmdb.Idc': 3})
>>> idc = Idc.objects.all()
>>> idc
<QuerySet []>                # 全部都删除了

# 对查询到的数据然后删除掉
Idc.objects.filter(name='aaa').delete()         # 所有name是aaa的数据删除掉

查询

# 对查询到的数据进行更新address地址
>>> Idc.objects.create(name='北京市')             # 只创建了name，但address为空
<Idc: 北京市>
>>> Idc.objects.create(name='天津市')
<Idc: 天津市>
>>> Idc.objects.create(name='北京市')
<Idc: 北京市>
>>> Idc.objects.all()
<QuerySet [<Idc: 北京市>, <Idc: 天津市>, <Idc: 北京市>]>
>>> Idc.objects.filter(name='北京市').all()
<QuerySet [<Idc: 北京市>, <Idc: 北京市>]>
>>> Idc.objects.filter(name='北京市').update(address='都在北京市里面')
2
>>> idc = Idc.objects.filter(name='北京市').all()
>>> for i in idc:
...     print(i.address)
... 
都在北京市里面
都在北京市里面

现在查看一下数据

MariaDB [dja]> select * from cmdb_idc;
+----+-----------+-----------------------+--------+
| id | name      | address               | remark |
+----+-----------+-----------------------+--------+
| 11 | 北京市    | 都在北京市里面        |        |
| 12 | 天津市    |                       |        |
| 13 | 北京市    | 都在北京市里面        |        |
+----+-----------+-----------------------+--------+
3 rows in set (0.00 sec)

更新所有字段的数据

Idc.objects.all().update(address='xxxxx')

异常捕获

>>> try:
...     idc = Idc.objects.get(id=100)
... except Idc.DoesNotExist:
...     idc = 'Not'
... 
>>> idc
'Not'

排序

Idc.objects.order_by('name')             # 从小到大排序
Idc.objects.order_by('-name')          # 从大到小排序

查最后一个元素

idcs = Idc.objects.all()
idcs[len(idcs)-1]

# 查询总数
idcs.count()

上面我们列出的filter表示等于= ，而不等于!=则使用exclude，返回的依然是queryset查询集合

>>> idc = Idc.objects.exclude(id=11)                # 这是id不等于11的查询结果
>>> idc
<QuerySet [<Idc: 天津市>, <Idc: 北京市>]>

django之聚合查询
__exact与__iexact区别

__exact相当于=
__iexact相当于like
事实上两者在django里面使用时结果都一样，有些资料写exact是精确匹配，iexact是精确匹配但忽略大小写，事实上两者都忽略了大小写，结果是一样的。
在mysql里面：select * from table where name binary = 'aaa'；才表示注意大小写，要加上binary才可以，而exact与iexact并没有资料说对应binary，所以两个结果一样。

__contains与__icontains区别

icontains不区分大小写的包含匹配
contains区分大小写的包含匹配

创建带有默认值sql语句

class Idc(models.Model):
    '''
    机房表
    '''
    name = models.CharField(max_length=32, null=True, black=True, default='用户没有填写')
    address = models.CharField(max_length=64)
    remark = models.TextField()

    # 下面可写可不写，主要是定义名字的
    def __str__(self):
        return self.name

批量创建

from cmdb.models import Idc
idc1 = Idc(name='aaa')
idc2 = Idc(name='bbb')
idc3 = Idc(name='ccc')
Idc.objects.bulk_create([idc1,idc2,idc3])
[<Idc: aaa>, <Idc: bbb>, <Idc: ccc>]

定义为抽象类

from django.db import models

class BasicModel(models.Model):
    name = models.CharField(max_length=32, null=True, default='render')
    remark = models.CharField(max_length=32)

    # 定义当前这个类是抽象类
    class Meta:
        abstract = True




class Idc(BasicModel):
    '''
    机房表
    '''
    address = models.CharField(max_length=64)

    # 下面可写可不写，主要是定义名字的
    # def __str__(self):
    #     return self.name

class Rack(BasicModel):
    number = models.CharField(max_length=32)

# 然后查看表
MariaDB [dja]> show tables;
+----------------------------+
| Tables_in_dja              |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| cmdb_idc                   |
| cmdb_rack                  |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
+----------------------------+
12 rows in set (0.01 sec)
发现并没有BasicModel表，是因为这个表定义为了抽象表，此时不会在数据库中进行创建

使用name_handler方法

class BasicModel(models.Model):
    name = models.CharField(max_length=32, null=True, default='render')
    remark = models.CharField(max_length=32)

    # 定义当前这个类是抽象类
    class Meta:
        abstract = True

class Idc(BasicModel):
    '''
    机房表
    '''
    address = models.CharField(max_length=64)

    def name_handle(self):
        return 'renderg-------' + self.name

# 然后测试一下
>>from cmdb.models import Idc
>>idc = Idc.objects.get(id=1)
>>idc.name_handle()
'renderg-------厦门一号机房'
>>idc.name
'厦门一号机房'
所以从这里可以看出来，使用name_handler的话可以对结果进行指定的输出，即可以加工数据。而单纯的name依然表示输出最原始的数据

model_to_dict的用法

>>> data = [model_to_dict(i,exclude=['id']) for i in Idc.objects.all()]
>>> data
[{'name': '厦门一号机房', 'remark': '合作一', 'address': '福建省厦门市'}]
>>> Idc.objects.create(name='抚州天蝎机房',address='江西省抚州市',remark='二次合作')
<Idc: Idc object (2)>
>>> data
[{'name': '厦门一号机房', 'remark': '合作一', 'address': '福建省厦门市'}]
>>> data = [model_to_dict(i,exclude=['id']) for i in Idc.objects.all()]
>>> data
[{'name': '厦门一号机房', 'remark': '合作一', 'address': '福建省厦门市'}, {'name': '抚州天蝎机房', 'remark': '二次合作', 'address': '江西省抚州市'}]
>>> data = [model_to_dict(i,exclude=['id','remark']) for i in Idc.objects.all()]
>>> data
[{'name': '厦门一号机房', 'address': '福建省厦门市'}, {'name': '抚州天蝎机房', 'address': '江西省抚州市'}]
看的出来需要排除哪个字段 ，就在exclude里面写哪个字段

排除错误经验之一：
今天遇到比较难缠的问题，写了个不合适的代码，导致python manage.py migrate出现错误，但是找不出来具体原因，只能归结到是代码的问题了。但是在解决的过程中比较诡异，我即便把代码注释，这个类都注释了，也依然报这个错误，看的出来是缓存的问题在搞鬼，所以就把项目cmdb下面的migrations目录下文件都给删除了，重新执行python manage.py makemigrations，但是很奇怪，执行这个语句一直报'No changes detected'，我明明改变了代码，肯定要打印出来我改变的文件的提示才对，因为我断定这个命令不太对，百度了一下最后这样子执行了python manage.py makemigrations cmdb，也就是针对cmdb项目生成migrations文件信息，这样子就成功了，最后再执行python manage.py migrate就OK了。
插播两条代码

Idc.objects.create(name='厦门一号机房',address='福建省厦门市',remark='renderg一起合作第一个机房')
<Idc: Idc object (1)>
data = {'name':'厦门二号机房','address':'福建省厦门市','remark':'renderg一起合作第二个机房'}

数据库一对多关系
先把实现的models类的代码贴出来，才能讲下面的python

from django.db import models

# Create your models here.
from django.db import models

class BasicModel(models.Model):
    name = models.CharField(max_length=32, null=True, default='render')
    remark = models.CharField(max_length=32)

    # 定义当前这个类是抽象类
    class Meta:
        abstract = True
class Idc(BasicModel):
    '''
    机房表
    '''
    address = models.CharField(max_length=64)

    def name_handle(self):
        return 'renderg-------' + self.name

    # 下面可写可不写，主要是定义名字的
    # def __str__(self):
    #     return self.nameidc

class Rack(BasicModel):

    idc = models.ForeignKey(Idc, on_delete=models.SET_NULL, null=True, default='')
    number = models.CharField(max_length=32)

上面的代码是提示，实现效果如下所示

# 两种给外键idc传值的方法，如下所示：
from cmdb.models import Rack
Rack.objects.create(name='A机柜',idc_id=1)
<Rack: Rack object (1)>
idc = Idc.objects.get(id=1)
Rack.objects.create(name='B机柜',idc = idc)          # 注意第二个idc是Idc类的实例化对象，可以直接赋值给Rack类中的idc(或者说是数据库的字段)
<Rack: Rack object (2)>

主键和外键关联表查询方式，实现的需求是根据机房查询出来这个机房的所有机柜，两种方法

# 第一种是先查询机柜的外键值(即机房)，然后根据这个外键值过滤出来这个符合条件的机柜。这种方法是站在机柜的角度来查询。这种称为反向查，通过子表查外键表
rack = Rack.objects.filter(idc_id = 1)
for i in rack:
    print(i.name)
    
A机柜
C机柜

# 第二种方法是站在机房的角度，过滤出来机房，然后查询这个机房的所有机柜。这种称为通过外键表查子表
idc = Idc.objects.get(id=1)
idc.rack_set.all()
<QuerySet [<Rack: Rack object (1)>, <Rack: Rack object (4)>]>
rack = idc.rack_set.all()                          # 这里的rack_set中的rack就是机柜类的小写而已，所有这个名字是会变化的，后面的_set是固定的。即 表名_set
for i in rack:
    print(i.name)
    
A机柜
C机柜

通过上面这个例子，我们看到可以通过 表名_set的方式来引用，这种名称或许不太好看，我们可以这样子来做

class Rack(BasicModel):

    idc = models.ForeignKey(Idc, on_delete=models.SET_NULL, null=True, default='',related_name='IDC_RACK')           # 这里定义了related_name
    number = models.CharField(max_length=32)

# 下面我们看一下
from cmdb.models import Idc,Rack
idc = Idc.objects.get(id=1)
idc.IDC_RACK.all()
<QuerySet [<Rack: Rack object (1)>, <Rack: Rack object (4)>]>
for i in idc.IDC_RACK.all():                           # 所以这里可以通过上面的定义的related_name来引用，这就是这个关键字的作用
    print(i.name)
    
A机柜
C机柜

接下来我们学习一下多对多的关系
同样的，多对多的关系我们得知道是谁和谁之间多对多，比如这里的，是服务器和用户之间，一个用户可以有多个机器，一个机器可以被多个用户同时使用。
先把代码实现写在这里

from django.contrib.auth.models import User

class Server(BasicModel):
    CPU = models.CharField(max_length=32)
    Memory = models.CharField(max_length=32)
    user = models.ManyToManyField(User,null=True, default='')

接下来我们看实现过程

from django.contrib.auth.models import User
User.objects.get(id=3)              # 这是u2用户（已提前在后台创建完）
<User: u2>
User.objects.get(id=2)               # 这是u1用户（已提前在后台创建完）
<User: u1>
User.objects.get(username='u1')
<User: u1>
u1 = User.objects.get(username='u1')
s1 = Server.objects.get(id=1)
s1.user.add(u1)                  # 这个是说把服务器1给用户u1使用
s1.user.all()                      # 这里可以看到服务器被哪个用户使用
<QuerySet [<User: u1>]>
u1.server_set.all()            # 这个可以看到用户u1使用了哪些机器
<QuerySet [<Server: Server object (1)>, <Server: Server object (2)>]>
u = u1.server_set.all()      # 循环打印出来
for i in u:
    print(i.name)
    
dell01
dell02
# 我们上面实现了根据服务器指定哪个用户使用，我们也可以换个思想，即用户指定使用哪个机器的方式
Server.objects.create(name='dell03',id=3)
<Server: Server object (3)>
s3 = Server.objects.get(id=3)
s3
<Server: Server object (3)>
u1.server_set.add(s3)               # 指定u1用户使用s3这个刚刚新创建的机器
for i in User.objects.get(id=2).server_set.all():           # 这里写了这么长也仅仅表示查询出来这个用户u2，然后打印出他使用的所有的机器。里面的server_set是固定写法，即表名_set
    print(i.name)
    
dell01
dell02
dell03

用户权限

接下来我们学习用户权限

from django.contrib.auth.models import Permission,User,Group
u = User.objects.get(username='u1')
u
<User: u1>
u.user_permissions.all()              # 初次使用，发现是没有任何权限的
<QuerySet []>
perm = Permission.objects.get(codename='add_idc')      # 我们获取一个add_idc的权限
u.user_permissions.add(perm)                     # 然后给u1这个用户
# 接下来是获取权限，有以下几种方式
# 第一个
u.user_permissions.all()
<QuerySet [<Permission: cmdb | idc | Can add idc>]>          # 可以看到现在u1用户有权限了
# 第二个
u.get_all_permissions()
{'cmdb.add_idc'}
# 第三个，根据true或false的方式来解决
u.has_perm('cmdb.add_idc')
True
u.has_perm('cmdb.delete_idc')
False

# 检查一个用户是否有这个权限也可以这样子操作
'cmdb.delete_idc' in u.get_all_permissions()
False
'cmdb.add_idc' in u.get_all_permissions()
True
perm
<Permission: cmdb | idc | Can add idc>
# 下面这种方式得先获取perm，所以较为麻烦，一般也不用这种方法，而且这种方法获取的只是用户本身的权限，一般我们说的用户的权限是用户自己的权限+用户所在组的权限的和，所以下面这个使用上有一定的误差
perm in u.user_permissions.all()
True

给组添加权限，当用户添加到这个组中时，自动集成这个组的权限

# 咱们先来给组添加权限
from django.contrib.auth.models import Permission,User,Group
perm = Permission.objects.get(codename='add_idc')
perm
<Permission: cmdb | idc | Can add idc>
Group.objects.all()
<QuerySet []>
Group.objects.all()                   # 刚刚在web上添加了一个用户g1，因此现在才查看到了。
<QuerySet [<Group: g1>]>
g1 = Group.objects.get(name='g1')
g1
<Group: g1>
g1.permissions.add(perm)            # 给这个组添加权限
g1.permissions.all()
<QuerySet [<Permission: cmdb | idc | Can add idc>]>

# 现在咱们把用户添加到组中
u2 = User.objects.get(username='u2')        # 找到u2用户
u2.get_all_permissions()                  # u2是新用户没有任何权限
set()
g1.user_set.add(u2)                        # 把u2用户添加到g1组里面
u2.groups.all()                               # 可以看到u2用户所在的组
<QuerySet [<Group: g1>]>
u2.get_all_permissions()                # 现在是看不到u2的权限的，还没生效，重新获取一下
set()
u2 = User.objects.get(username='u2')
u2
<User: u2>
u2.get_all_permissions()               # 可以看到u2用户现在已经集成了g1组的add_idc权限了
{'cmdb.add_idc'}

# 再来添加几个权限
p1 = Permission.objects.get(codename='delete_idc')
p2 = Permission.objects.get(codename='add_server')
u2.get_all_permissions()
{'cmdb.add_idc'}
g1.permissions.add(p1,p2)                  # 把新的p1和p2权限添加到这个组上面
g1.permissions.all()                            # 顺便查看查看g1组现在的权限
<QuerySet [<Permission: cmdb | idc | Can add idc>, <Permission: cmdb | idc | Can delete idc>, <Permission: cmdb | server | Can add server>]>
u2 = User.objects.get(username='u2')
u2.get_all_permissions()                     # 现在来看看g1组里面u2这个用户的权限
{'cmdb.add_idc', 'cmdb.delete_idc', 'cmdb.add_server'}

html

现在学习一下html

<body>
<p style="color: red;margin-left: 100px">新年好啊</p>
</body>

如下效果所示：

还可以用下面这个方法，都是一样的

<head>
   <meta charset="UTF-8">
   <title>Title</title>
   <style type="text/css">
   p {color: red;margin-left: 100px}          # 这里的p表示body里面的<p>标签都会生效
   </style>
</head>
<body>
<p>新年好啊</p>
</body>

使用容器div，容器主要是一个块，当对容器声明一些属性的时候，整个容器内容都会生效，比如这里，对这个div标签设置距离左侧100像素，距离顶部200像素

<body>
<div style="margin-left: 100px;margin-top: 200px">
    <p>新年好啊</p>
    <ul>
        <li>coffee</li>
        <li>Milk</li>
    </ul>
</div>
</body>

效果如下：

添加超链接

<body>
<div style="margin-left: 100px;margin-top: 200px">
    <p>新年好啊</p>
    <ul>
        <li>coffee</li>
        <li>Milk</li>
    </ul>
    <a href="http://www.baidu.com/" target="_blank">点击百度搜索</a>
</div>
</body>

效果如下：

上面的加上 target="_blank"意味着我们点击超链接之后会启动一个新的窗口并打开此页面

使用bootstrap实现，把超链接加在按钮上面

    <a href="http://www.baidu.com/" target="_blank">
        <button type="submit" class="btn btn-success">点击百度搜索</button>
    </a>

效果如下所示：

可以实现下拉菜单的操作:

<!-- Single button -->
    <div class="btn-group">
      <button type="button" class="btn btn-primary">动作</button>
      <button type="button" class="btn btn-primary dropdown-toggle" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
        <span class="caret"></span>
        <span class="sr-only">Toggle Dropdown</span>
      </button>
      <ul class="dropdown-menu">
        <li><a href="www.baidu.com">百度</a></li>
        <li><a href="www.qq.com">QQ</a></li>
        <li><a href="www.weixin.com">微信</a></li>
        <li role="separator" class="divider"></li>
        <li><a href="www.sohu.com">搜狐</a></li>
      </ul>
    </div>

使用div的class。并定义class类型

在写视图的时候，如果类集成的是ListView，那么有点需要注意的是，我们传递的上下文变量默认值是object_list作为上下文变量，当然可以自定义，使用context_object_name进行重命名，ListView里面有get_queryset方法，主要就是用来返回数据列表的
如果是列表页的话，首选ListView，其他的选择TemplateView。

输入框鼠标点击弹窗

<div>
	<input id='input1' style=' 100px'>
	<input id='input2' style=' 100px'>
</div>
<button id="btn1" type="button" class="btn btn-success" >百度</button>
<script type="text/javascript">
	$('#btn1').click(function(){
		n1=$('#input1').val()
		n2=$('#input2').val()
		//alert(parseInt(n1)+parseInt(n2));
		alert(n1+n2);
	})
  </script>