1.在做登录验证或者注册的时候，用内置的User类会方便许多，但是其中也有一些不同，特此记录
先导入user类，然后创建一个类做一对一关联
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User,unique=True)
    birth = models.DateField(blank=True,null=True)
    phone = models.CharField(max_length=20,null=True)

    def __str__(self):
        return 'user {}'.format(self.user.username)
这时候，如果你在交互模式下查看该类或与之关联的该该类，那么，输出的QuerySet中会带有 [User: t3]，   t3是User中的username的值
User.objects.all().filter(id=6)
Out[8]: 
<QuerySet [<User: t3>]>

UserProfile.objects.all().filter(id=2)
Out[36]: 
<QuerySet [<UserProfile: user t3>]>
而正常的QuerySet如下，并没有显示外键关联对应的相关值

9-11 导入Admin 类 ： 以为完成练习9-8而做的工作为基础， 将User 、 Privileges 和Admin 类存储在一个模块中， 再创建一个文件， 在其中创建一个Admin 实例

并对其调用方法show_privileges() ， 以确认一切都能正确地运行。
#a9_11.py
class User():
    """Represent a simple user profile."""

    def __init__(self, first_name, last_name, username, email, location):
        """Initialize the user."""
        self.first_name = first_name.title()
        self.last_name = last_name.title()
        self.username = username
        self.email = email
        self.location = location.title()
        self.login_attempts = 0

    def describe_user(self):
        """Display a summary of the user's information."""
        print("\n" + self.first_name + " " + self.last_name)
        print("  Username: " + self.username)
        print("  Email: " + self.email)
        print("  Location: " + self.location)

    def greet_user(self):
        """Display a personalized greeting to the user."""
        print("\nWelcome back, " + self.username + "!")

    def increment_login_attempts(self):
        """Increment the value of login_attempts."""
        self.login_attempts += 1

    def reset_login_attempts(self):
        """Reset login_attempts to 0."""
        self.login_attempts = 0


class Admin(User):
    """A user with administrative privileges."""

    def __init__(self, first_name, last_name, username, email, location):
        """Initialize the admin."""
        super().__init__(first_name, last_name, username, email, location)

        # Initialize an empty set of privileges.
        self.privileges = Privileges()

class Privileges():
    """A class to store an admin's privileges."""

    def __init__(self, privileges=[]):
        self.privileges = privileges

    def show_privileges(self):

        for privilege in self.privileges:
            print("- " + privilege)



#9-11test
from a9_11 import Admin, Privileges
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric_privileges = [
    'can reset passwords',
    'can moderate discussions',
    'can suspend accounts',
    ]
eric.privileges.privileges = eric_privileges
eric.privileges.show_privileges()
#注意，eric.privileges.show_privileges()而不是其他

Python入门习题大全——索引
以为完成练习“权限”而做的工作为基础，将User、Privileges和Admin类存储在一个模块中，再创建一个文件，在其中创建一个Admin 实例并对其调用方法show_privileges()，以确认一切都能正确地运行。

文件 usr.py 内容如下：
class Privileges():
    def __init__(self):
        self.privileges = ['a', 'b', 'c']

    def show_privileges(self):
        print(self.privileges)

class User():
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

class Admin(User):
    def __init__(self, first_name, last_name):
        super().__init__(first_name, last_name)
        self.privileges = 'can add post'
        self.message = Privileges()

调用上述文件：
# 导入 Admin 类
from usr import Privileges, User, Admin

my = Admin('ling', 'hiuhe')
my.message.show_privileges()

输出为：
['a', 'b', 'c']

随着我们不断地在一个文件中添加新的功能， 就会使得文件变得很长。 即便使用了继承，也抑制不住类的成长。为了解决这一问题，我们可以将类存储在模块中， 然后在主程序中导入所需的模块，这样可以让文件尽可能保持整洁，从而实现更好的管理。

导入类是一种很有效的编程方式。 这样我们就可以把大部分逻辑存储在独立的文件中，然后在主程序编写高级逻辑咯O(∩_∩)O哈哈~

1 导入一个类

假设有一个 User 类，文件名为 User.py，这个待导入的文件，一般称为模块：

class User():
    '''账号信息'''

    def __init__(self, name, pwd):
        '''初始化'''
        self.name = name
        self.pwd = pwd
        # 登陆次数
        self.login_count = 0

    def print_login_count(self):
        '''打印登陆次数'''
        print('登陆次数=' + str(self.login_count))

    def update_login_count(self, num):
        '''更新登陆次数'''
        self.login_count = num

    def valid(self):
        '''是否验证通过'''
        print(self.name + ' 验证通过')

我们再定义一个名为 deniro.py 的文件，来导入刚刚定义的 User 类：

from User import User


deniro = User('deniro', '1')
print('账号名：' + deniro.name)

运行结果：

账号名：deniro

2 导入一个模块多个类

可以根据需要，在同一个模块中定义任意数量的类，不过这些在同一个模块中的类最好是相关的。

我们在 User.py 中定义了一个 Privilege 类，并作为 User 类的属性：

class User():
    '''账号信息'''

    def __init__(self, name, pwd):
        '''初始化'''
        self.name = name
        self.pwd = pwd
        # 登陆次数
        self.login_count = 0
        # 拥有的权限
        self.privileges = Privilege(['修改某某账号密码', '禁用某某账号'])

    def print_privileges(self):
        '''打印拥有的权限'''
        print(self.privileges.contents)

...






class Privilege():
    '''权限'''

    def __init__(self, contents):
        self.contents = contents

然后在新的文件中调用它：

# 导入一个类
from User import User


deniro = User('deniro', '1')
print('拥有的权限：' + str(deniro.privileges.contents))

运行结果：

拥有的权限：['修改某某账号密码', '禁用某某账号']

3 导入多个类

可以在一个模块中导入多个类， 用逗号分隔这些需要导入类。 导入后， 就可以根据应用场景，来创建任意数量的类实例。

from User import User,Privilege

p=Privilege(["删除账号权限"])
print('权限内容：'+str(p.contents))

运行结果：

权限内容：['删除账号权限']

4 导入模块

我们还可以一次性导入整个模块， 这需要使用句点表示法来调用相应的类：

import User

...

p=User.Privilege(["删除账号权限"])
...

4 导入所有类

from User import *

非必要，不使用这种导入方式，因为：

通过文件开头定义良好的 import 语句， 我们就可以清楚地知道使用了哪些类。但这种导入方式没有提供这种好处。
	
如果不小心导入了一个与本程序文件中同名的类， 就会引发难以诊断的错误。
如果确实需要从一个模块中导入很多类，那么建议导入整个模块， 然后使用 module_name.class_name 语法来调用它们。

5 在模块中导入另一个模块

为了避免模块太大或者保证模块中的类都是相关的， 这时就需要将类分散到多个模块中。这样， 可能一个模块中的类会依赖另一个模块中的类。这种场景下， 我们就会在一个模块中导入另一个模块。因为导入语法相同，所以在此就不赘述啦O(∩_∩)O~

建议一开始让代码结构尽可能简单。 即先尽可能在一个文件中完成所有的工作， 确定一切都能满足业务要求正确执行后，再将类移到独立的模块中。