sudo pip install MySQL-python

>>> import MySQLdb

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "/Library/Python/2.7/site-packages/MySQLdb/__init__.py", line 19, in <module>

    import _mysql

ImportError: dlopen(/Library/Python/2.7/site-packages/_mysql.so, 2): Library not loaded: /usr/local/mysql/lib/libmysql.18.dylib

  Referenced from: /Library/Python/2.7/site-packages/_mysql.so

  Reason: image not found

sudo ln -s /usr/local/mysql/lib/libmysqlclient.18.dylib /usr/lib/libmysqlclient.18.dylib

sudo ln -s /usr/local/mysql/lib /usr/local/mysql/lib/mysql

csrutil disable

sudo pip uninstall MySQL-python

sudo pip install MySQL-python

>>> import MySQLdb

>>> 

csrutil enable

DEBUG = True

ALLOWED_HOSTS = [＊]    ＃允许任何主机访问

DATABASES = {

    'default': {

        #'ENGINE': 'django.db.backends.sqlite3',

        #'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

        'ENGINE': 'django.db.backends.mysql',

        'NAME':'authors',

        'HOST':'',

        'PORT':'',

        'USER':'root',

        'PASSWORD':''

    }

}

class Publisher(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
    def __unicode__(self):
      return self.name

class Author(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=40)
    email = models.EmailField()
    def __unicode__(self):
      return '<%s %s>' %(self.first_name,self.last_name)

class Book(models.Model):
    name = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)    #关联Author表，在后台添加book时，会有author和publisher的选项。
    publisher = models.ForeignKey(Publisher) 
    publication_date = models.DateField()
    def __unicode__(self):
      return self.name

localhost:apps ahaii$ sudo python manage.py makemigrations

Migrations for 'test1':

  0002_auto_20160729_0237.py:

    - Create model Author

    - Create model Book

    - Create model Publisher

    - Add field publisher to book

localhost:apps ahaii$ sudo python manage.py migrate

Operations to perform:

  Apply all migrations: admin, test1, contenttypes, auth, sessions

Running migrations:

  Rendering model states... DONE

  Applying contenttypes.0001_initial... OK

  Applying auth.0001_initial... OK

  Applying admin.0001_initial... OK

  Applying admin.0002_logentry_remove_auto_add... OK

  Applying contenttypes.0002_remove_content_type_name... OK

  Applying auth.0002_alter_permission_name_max_length... OK

  Applying auth.0003_alter_user_email_max_length... OK

  Applying auth.0004_alter_user_username_opts... OK

  Applying auth.0005_alter_user_last_login_null... OK

  Applying auth.0006_require_contenttypes_0002... OK

  Applying auth.0007_alter_validators_add_error_messages... OK

  Applying sessions.0001_initial... OK

  Applying test1.0001_initial... OK

  Applying test1.0002_auto_20160729_0237... OK

mysql> show databases;

+--------------------+

| Database           |

+--------------------+

| information_schema |

| authors            |

| mysql              |

| performance_schema |

+--------------------+

4 rows in set (0.01 sec)

mysql> show tables;

+----------------------------+

| Tables_in_authors          |

+----------------------------+

| auth_group                 |

| auth_group_permissions     |

| auth_permission            |

| auth_user                  |

| auth_user_groups           |

| auth_user_user_permissions |

| django_admin_log           |

| django_content_type        |

| django_migrations          |

| django_session             |

| test1_author               |

| test1_book                 |

| test1_book_authors         |

| test1_publisher            |

| test1_userinfo             |

+----------------------------+

15 rows in set (0.00 sec)

localhost:apps ahaii$ sudo python manage.py createsuperuser

Username (leave blank to use 'root'): ahaii

Email address:

Password:

Password (again):

Superuser created successfully.

import models

admin.site.register(models.Author)

admin.site.register(models.Publisher)

admin.site.register(models.Book)

class Meta:

    verbose_name_plural='中文'

#!_*_ coding:utf-8 _*_

from __future__ import unicode_literals

from django.db import models

class Author(models.Model):

    first_name = models.CharField(max_length=30)

    last_name = models.CharField(max_length=40)

    email = models.EmailField()

    def __unicode__(self):

      return '<%s %s>' %(self.first_name,self.last_name)

    class Meta:

        verbose_name_plural='作者'

class Book(models.Model):

    name = models.CharField(max_length=100)

    authors = models.ManyToManyField(Author)

    publisher = models.ForeignKey(Publisher)

    publication_date = models.DateField()

    def __unicode__(self):

      return self.name

    class Meta:

        verbose_name_plural='书籍名称'

sudo django-admin startapp blog

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'test1',

    'blog'

]

class Blog(models.Model):

    name = models.CharField(max_length=100)

    tagline = models.TextField()

    def __unicode__(self):

        return self.name

class Author(models.Model):

    name = models.CharField(max_length=50)

    email = models.EmailField()

    def __unicode__(self):

        return self.name

class Entry(models.Model):

    blog = models.ForeignKey(Blog)

    headline = models.CharField(max_length=255)

    body_text = models.TextField()

    pub_date = models.DateField()

    mod_date = models.DateField()

    authors = models.ManyToManyField(Author)

    n_comments = models.IntegerField()

    n_pingbacks = models.IntegerField()

    rating = models.IntegerField()

    def __unicode__(self):

        return self.headline

sudo python manage.py makemigrations blog

sudo python manage.py migrate

localhost:apps ahaii$ sudo python manage.py migrate

Operations to perform:

  Apply all migrations: test1, sessions, admin, auth, blog, contenttypes

Running migrations:

  No migrations to apply.

from django.contrib import admin

# Register your models here.

import models

admin.site.register(models.Author)

admin.site.register(models.Blog)

admin.site.register(models.Entry)

获取对象¶

通过模型中的管理器构造一个查询集，来从你的数据库中获取对象。

查询集表示从数据库中取出来的对象的集合。它可以含有零个、一个或者多个过滤器。过滤器基于所给的参数限制查询的结果。 从SQL 的角度，查询集和SELECT 语句等价，过滤器是像WHERE 和LIMIT 一样的限制子句。

你可以从模型的管理器那里取得查询集。每个模型都至少有一个管理器，它默认命名为objects。通过模型类来直接访问它，像这样：

>>> Blog.objects

<django.db.models.manager.Manager object at ...>

>>> b = Blog(name='Foo', tagline='Bar')

>>> b.objects

Traceback:

    ...

AttributeError: "Manager isn't accessible via Blog instances."

对于一个模型来说，管理器是查询集的主要来源。例如，Blog.objects.all() 返回包含数据库中所有Blog 对象的一个查询集。

>>> all_entries = Entry.objects.all()

Entry.objects.filter(pub_date__year=2006)

Entry.objects.all().filter(pub_date__year=2006)

>>> Entry.objects.filter(

...     headline__startswith='What'

... ).exclude(

...     pub_date__gte=datetime.date.today()

... ).filter(

...     pub_date__gte=datetime(2005, 1, 30)

... )

>>> q1 = Entry.objects.filter(headline__startswith="What")

>>> q2 = q1.exclude(pub_date__gte=datetime.date.today())

>>> q3 = q1.filter(pub_date__gte=datetime.date.today())

>>> q = Entry.objects.filter(headline__startswith="What")

>>> q = q.filter(pub_date__lte=datetime.date.today())

>>> q = q.exclude(body_text__icontains="food")

>>> print(q)

>>> one_entry = Entry.objects.get(pk=1)

>>> Entry.objects.all()[:5]

>>> Entry.objects.all()[5:10]

>>> Entry.objects.all()[:10:2]

>>> Entry.objects.order_by('headline')[0]

>>> Entry.objects.order_by('headline')[0:1].get()

>>> Entry.objects.filter(pub_date__lte='2006-01-01')

SELECT * FROM blog_entry WHERE pub_date <= '2006-01-01';

>>> Entry.objects.filter(blog_id=4)

>>> Entry.objects.filter(blog__name='Beatles Blog')

>>> Blog.objects.filter(entry__headline__contains='Lennon')

Blog.objects.filter(entry__authors__name='Lennon')

Blog.objects.filter(entry__authors__name__isnull=True)

Blog.objects.filter(entry__authors__isnull=False,

        entry__authors__name__isnull=True)

Blog.objects.filter(entry__headline__contains='Lennon',

        entry__pub_date__year=2008)

Blog.objects.filter(entry__headline__contains='Lennon').filter(

        entry__pub_date__year=2008)

Blog.objects.exclude(

    entry__headline__contains='Lennon',

    entry__pub_date__year=2008,

)

Blog.objects.exclude(

    entry=Entry.objects.filter(

        headline__contains='Lennon',

        pub_date__year=2008,

    ),

)

>>> from django.db.models import F

>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks'))

>>> Entry.objects.filter(n_comments__gt=F('n_pingbacks') * 2)

>>> Entry.objects.filter(rating__lt=F('n_comments') + F('n_pingbacks'))

>>> Entry.objects.filter(authors__name=F('blog__name'))

>>> from datetime import timedelta

>>> Entry.objects.filter(mod_date__gt=F('pub_date') + timedelta(days=3))

>>> F('somefield').bitand(16)

>>> Blog.objects.get(id__exact=14) # Explicit form

>>> Blog.objects.get(id=14) # __exact is implied

>>> Blog.objects.get(pk=14) # pk implies id__exact

# Get blogs entries with id 1, 4 and 7

>>> Blog.objects.filter(pk__in=[1,4,7])

# Get all blog entries with id > 14

>>> Blog.objects.filter(pk__gt=14)

>>> Entry.objects.filter(blog__id__exact=3) # Explicit form

>>> Entry.objects.filter(blog__id=3)        # __exact is implied

>>> Entry.objects.filter(blog__pk=3)        # __pk implies __id__exact

>>> Entry.objects.filter(headline__contains='%')    #包含％符号

SELECT ... WHERE headline LIKE '%\%%';

>>> print([e.headline for e in Entry.objects.all()])

>>> print([e.pub_date for e in Entry.objects.all()])

>>> queryset = Entry.objects.all()

>>> print([p.headline for p in queryset]) # Evaluate the query set.

>>> print([p.pub_date for p in queryset]) # Re-use the cache from the evaluation.

>>> queryset = Entry.objects.all()

>>> print queryset[5] # Queries the database

>>> print queryset[5] # Queries the database again

>>> queryset = Entry.objects.all()

>>> [entry for entry in queryset] # Queries the database

>>> print queryset[5] # Uses cache

>>> print queryset[5] # Uses cache

>>> [entry for entry in queryset]

>>> bool(queryset)

>>> entry in queryset

>>> list(queryset)

使用Q 对象进行复杂的查询¶

filter() 等方法中的关键字参数查询都是一起进行“AND” 的。 如果你需要执行更复杂的查询（例如OR 语句），你可以使用Q 对象。

Q 对象 (django.db.models.Q) 对象用于封装一组关键字参数。这些关键字参数就是上文“字段查询” 中所提及的那些。

例如，下面的Q 对象封装一个LIKE 查询：

from django.db.models import Q

Q(question__startswith='What')

Q 对象可以使用& 和| 操作符组合起来。当一个操作符在两个Q 对象上使用时，它产生一个新的Q 对象。

例如，下面的语句产生一个Q 对象，表示两个"question__startswith" 查询的“OR” ：

Q(question__startswith='Who') | Q(question__startswith='What')

它等同于下面的SQL WHERE 子句：

WHERE question LIKE 'Who%' OR question LIKE 'What%'

你可以组合& 和|  操作符以及使用括号进行分组来编写任意复杂的Q 对象。同时，Q 对象可以使用~ 操作符取反，这允许组合正常的查询和取反(NOT) 查询：

Q(question__startswith='Who') | ~Q(pub_date__year=2005)

每个接受关键字参数的查询函数（例如filter()、exclude()、get()）都可以传递一个或多个Q 对象作为位置（不带名的）参数。如果一个查询函数有多个Q 对象参数，这些参数的逻辑关系为“AND"。例如：

Poll.objects.get(

    Q(question__startswith='Who'),

    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))

)

... 大体上可以翻译成这个SQL：

SELECT * from polls WHERE question LIKE 'Who%'

    AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

查询函数可以混合使用Q 对象和关键字参数。所有提供给查询函数的参数（关键字参数或Q 对象）都将"AND”在一起。但是，如果出现Q 对象，它必须位于所有关键字参数的前面。例如：

Poll.objects.get(

    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),

    question__startswith='Who')

... 是一个合法的查询，等同于前面的例子；但是：

# INVALID QUERY

Poll.objects.get(

    question__startswith='Who',

    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))

... 是不合法的。

比较对象¶

为了比较两个模型实例，只需要使用标准的Python 比较操作符，即双等于符号：==。在后台，它会比较两个模型主键的值。

利用上面的Entry 示例，下面两个语句是等同的：

>>> some_entry == other_entry

>>> some_entry.id == other_entry.id

如果模型的主键不叫id，也没有问题。比较将始终使用主键，无论它叫什么。例如，如果模型的主键字段叫做name，下面的两条语句是等同的：

>>> some_obj == other_obj

>>> some_obj.name == other_obj.name

删除对象¶

删除方法，为了方便，就取名为delete()。这个方法将立即删除对象且没有返回值。例如：

e.delete()

你还可以批量删除对象。每个查询集 都有一个delete() 方法，它将删除该查询集中的所有成员。

例如，下面的语句删除pub_date 为2005 的所有Entry 对象：

Entry.objects.filter(pub_date__year=2005).delete()

记住，这将尽可能地使用纯SQL 执行，所以这个过程中不需要调用每个对象实例的delete()方法。如果你给模型类提供了一个自定义的delete() 方法并希望确保它被调用，你需要手工删除该模型的实例（例如，迭代查询集并调用每个对象的delete()）而不能使用查询集的批量delete() 方法。

当Django 删除一个对象时，它默认使用SQL ON DELETE CASCADE 约束 —— 换句话讲，任何有外键指向要删除对象的对象将一起删除。例如：

b = Blog.objects.get(pk=1)

# This will delete the Blog and all of its Entry objects.

b.delete()

这种级联的行为可以通过的ForeignKey 的on_delete 参数自定义。

注意，delete() 是唯一没有在管理器 上暴露出来的查询集方法。这是一个安全机制来防止你意外地请求Entry.objects.delete()，而删除所有 的条目。如果你确实想删除所有的对象，你必须明确地请求一个完全的查询集：

Entry.objects.all().delete()

拷贝模型实例¶

虽然没有内建的方法用于拷贝模型实例，但还是很容易创建一个新的实例并让它的所有字段都拷贝过来。最简单的方法是，只需要将pk 设置为None。利用我们的Blog 示例：

blog = Blog(name='My blog', tagline='Blogging is easy')

blog.save() # blog.pk == 1

blog.pk = None

blog.save() # blog.pk == 2

如果你用继承，那么会复杂一些。考虑下面Blog 的子类：

class ThemeBlog(Blog):

    theme = models.CharField(max_length=200)

django_blog = ThemeBlog(name='Django', tagline='Django is easy', theme='python')

django_blog.save() # django_blog.pk == 3

由于继承的工作方式，你必须设置pk 和 id 都为None：

django_blog.pk = None

django_blog.id = None

django_blog.save() # django_blog.pk == 4

这个过程不会拷贝关联的对象。如果你想拷贝关联关系，你必须编写一些更多的代码。在我们的例子中，Entry 有一个到Author 的多对多字段：

entry = Entry.objects.all()[0] # some previous entry

old_authors = entry.authors.all()

entry.pk = None

entry.save()

entry.authors = old_authors # saves new many2many relations

一次更新多个对象¶

有时你想为一个查询集中所有对象的某个字段都设置一个特定的值。这时你可以使用update() 方法。例如：

# Update all the headlines with pub_date in 2007.

Entry.objects.filter(pub_date__year=2007).update(headline='Everything is the same')

你只可以对非关联字段和ForeignKey 字段使用这个方法。若要更新一个非关联字段，只需提供一个新的常数值。若要更新ForeignKey 字段，需设置新的值为你想指向的新的模型实例。例如：

>>> b = Blog.objects.get(pk=1)

# Change every Entry so that it belongs to this Blog.

>>> Entry.objects.all().update(blog=b)

update() 方法会立即执行并返回查询匹配的行数（如果有些行已经具有新的值，返回的行数可能和被更新的行数不相等）。更新查询集 唯一的限制是它只能访问一个数据库表，也就是模型的主表。你可以根据关联的字段过滤，但是你只能更新模型主表中的列。例如：

>>> b = Blog.objects.get(pk=1)

# Update all the headlines belonging to this Blog.

>>> Entry.objects.select_related().filter(blog=b).update(headline='Everything is the same')

要注意update() 方法会直接转换成一个SQL 语句。它是一个批量的直接更新操作。它不会运行模型的save() 方法，或者发出pre_save 或 post_save信号（调用save()方法产生）或者查看auto_now 字段选项。如果你想保存查询集中的每个条目并确保每个实例的save() 方法都被调用，你不需要使用任何特殊的函数来处理。只需要迭代它们并调用save()：

for item in my_queryset:

    item.save()

对update 的调用也可以使用F 表达式 来根据模型中的一个字段更新另外一个字段。这对于在当前值的基础上加上一个值特别有用。例如，增加Blog 中每个Entry 的pingback 个数：

>>> Entry.objects.all().update(n_pingbacks=F('n_pingbacks') + 1)

然而，与filter 和exclude 子句中的F() 对象不同，在update 中你不可以使用F() 对象引入join —— 你只可以引用正在更新的模型的字段。如果你尝试使用F() 对象引入一个join，将引发一个FieldError：

# THIS WILL RAISE A FieldError

>>> Entry.objects.update(headline=F('blog__name'))

关联的对象¶

当你在一个模型中定义一个关联关系时（例如，ForeignKey、 OneToOneField 或ManyToManyField），该模型的实例将带有一个方便的API 来访问关联的对象。

利用本页顶部的模型，一个Entry 对象e 可以通过blog 属性e.blog 获取关联的Blog 对象。

（在幕后，这个功能是通过Python 的描述器实现的。这应该不会对你有什么真正的影响，但是这里我们指出它以满足你的好奇）。

Django 还会创建API 用于访问关联关系的另一头 —— 从关联的模型访问定义关联关系的模型。例如，Blog 对象b 可以通过entry_set 属性 b.entry_set.all()访问与它关联的所有Entry 对象。

这一节中的所有示例都将使用本页顶部定义的Blog、 Author 和Entry 模型。

>>> e = Entry.objects.get(id=2)

>>> e.blog # Returns the related Blog object.

>>> e = Entry.objects.get(id=2)

>>> e.blog = some_blog

>>> e.save()

>>> e = Entry.objects.get(id=2)

>>> e.blog = None

>>> e.save() # "UPDATE blog_entry SET blog_id = NULL ...;"

>>> e = Entry.objects.get(id=2)

>>> print(e.blog)  # Hits the database to retrieve the associated Blog.

>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> e = Entry.objects.select_related().get(id=2)

>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> print(e.blog)  # Doesn't hit the database; uses cached version.

>>> b = Blog.objects.get(id=1)

>>> b.entry_set.all() # Returns all Entry objects related to Blog.

# b.entry_set is a Manager that returns QuerySets.

>>> b.entry_set.filter(headline__contains='Lennon')

>>> b.entry_set.count()

>>> b = Blog.objects.get(id=1)

>>> b.entries.all() # Returns all Entry objects related to Blog.

# b.entries is a Manager that returns QuerySets.

>>> b.entries.filter(headline__contains='Lennon')

>>> b.entries.count()

from django.db import models

class Entry(models.Model):

    #...

    objects = models.Manager()  # Default Manager

    entries = EntryManager()    # Custom Manager

b = Blog.objects.get(id=1)

b.entry_set(manager='entries').all()

b.entry_set(manager='entries').is_published()

b = Blog.objects.get(id=1)

b.entry_set = [e1, e2]

e = Entry.objects.get(id=3)

e.authors.all() # Returns all Author objects for this Entry.

e.authors.count()

e.authors.filter(name__contains='John')

a = Author.objects.get(id=5)

a.entry_set.all() # Returns all Entry objects for this Author.

class EntryDetail(models.Model):

    entry = models.OneToOneField(Entry)

    details = models.TextField()

ed = EntryDetail.objects.get(id=2)

ed.entry # Returns the related Entry object.

e = Entry.objects.get(id=2)

e.entrydetail # returns the related EntryDetail object

e.entrydetail = ed

Entry.objects.filter(blog=b) # Query using object instance

Entry.objects.filter(blog=b.id) # Query using id from instance

Entry.objects.filter(blog=5) # Query using id directly

回归到原始的 SQL¶

如果你发现需要编写的SQL 查询对于Django 的数据库映射机制太复杂，你可以回归到手工编写SQL。Django 对于编写原始的SQL 查询有多个选项；参见执行原始的SQL 查询。

最后，值得注意的是Django 的数据库层只是数据库的一个接口。你可以利用其它工具、编程语言或数据库框架来访问数据库；对于数据库，Django 没有什么特别的地方。