第五章 模型
在第三章，我们讲述了用 Django 建造网站的基本途径： 建立视图和 URLConf 。 正如我们所阐述的，视图负责处理一些主观逻辑，然后返回响应结果。 作为例子之一，我们的主观逻辑是要计算当前的日期和时间。
写一个内容小结： 1. 讲了一下MVC和MTV模式的概念 2. 数据库如何进行设置 3. 如何创建用类的映射来创建数据库，和外键 4. unicode的使用 5. 插入，查询，过滤，排序，更新，删除等操作
在当代 Web 应用中，主观逻辑经常牵涉到与数据库的交互。 数据库驱动网站 在后台连接数据库服务器，从中取出一些数据，然后在 Web 页面用漂亮的格式展示这些数据。 这个网站也可能会向访问者提供修改数据库数据的方法。
许多复杂的网站都提供了以上两个功能的某种结合。 例如 Amazon.com 就是一个数据库驱动站点的良好范例。 本质上，每个产品页面都是数据库中数据以 HTML格式进行的展现，而当你发表客户评论时，该评论被插入评论数据库中。
由于先天具备 Python 简单而强大的数据库查询执行方法，Django 非常适合开发数据库驱动网站。 本章深入介绍了该功能： Django 数据库层。
（注意： 尽管对 Django 数据库层的使用中并不特别强调这点，但是我们还是强烈建议您掌握一些数据库和 SQL 原理。 对这些概念的介绍超越了本书的范围，但就算你是数据库方面的菜鸟，我们也建议你继续阅读。 你也许能够跟上进度，并在上下文学习过程中掌握一些概念。）
在视图中进行数据库查询的笨方法
正如第三章详细介绍的那个在视图中输出 HTML 的笨方法（通过在视图里对文本直接硬编码HTML），在视图中也有笨方法可以从数据库中获取数据。 很简单： 用现有的任何 Python 类库执行一条 SQL 查询并对结果进行一些处理。
在本例的视图中，我们使用了 MySQLdb 类库（可以从 http://www.djangoproject.com/r/python-mysql/ 获得）来连接 MySQL 数据库，取回一些记录，将它们提供给模板以显示一个网页：
win32 python2.6--Django-1.4.tar.gz--用的远程mysql,不想为了mysqldb本地装个mysql,所以用的 MySQL-python-1.2.2.win32-py2.6.exe。
下载支持python2.7的1.2.3 exe版本就ok 下载zip版本貌似需要先安装setuptools 在python setup.py install安装
如果在mac 上安装 有问题的话可以参考我的点点blog http://nooper.diandian.com/post/2012-09-03/40038746678 自己写的一个总结
安装MySQLdb 2.6出现的问题 (1).ImportError: DLL load failed: 找不到指定的模块。 >>> import MySQLdb Traceback (most recent call last): File "<stdin>", line 1, in <module> File "D:\ProgramTools\Python2.6\Lib\site-packages\MySQLdb\__init__.py", line 19, in <module> import _mysql ImportError: DLL load failed: 找不到指定的模块。 解决方法：下载libmmd.dll libguide40.dll libmysql.dll(必须) dll文件并复制System32 和python26\Lib\site-packages 目录之下; (2).ImportError: DLL load failed: 找不到指定的模块。 >>> import MySQLdb D:\ProgramTools\Python2.6\Lib\site-packages\MySQLdb\__init__.py:34: DeprecationWarning: the sets module is deprecated from sets import ImmutableSet 解决方法： 1) 在文件 "__init__.py"(文件位置位于错误提示位置,如上面提示错误为D:\ProgramTools\Python2.6\Lib\site-packages\MySQLdb\__init__.py,即为需修改文件路径), 注释掉: from sets import ImmutableSet class DBAPISet(ImmutableSet): 新增: class DBAPISet(frozenset) 2) 在文件中"converters.py", 注释掉 from sets import BaseSet, Set 这一句话。 3) 在文件中"converters.py", 修改 "Set" 成为 "set" ( 只有两个地方需要修改): 大概 line 48: return Set([ i for i in s.split(',') if i ]) ——> return set([ i for i in s.split(',') if i ]) 大概 line 128: Set: Set2Str, ——> set: Set2Str
mysql -u root -p <br> create database mydb; <注意分号> show databases; <br> quit <br> su <br> cd /var/lib/mysql/ <br> ls mydb <br>
OS X 或者有pip,easy_install的都可以用这个 easy_install mysql-python or pip install mysql-python
http://dev.mysql.com/downloads/connector/python/ 官网上支持Win64位Python3的，启动msi安装包之后根本没有反应~ 郁闷中……
windows下python2.7安装mysql 先检查自己是不是已经安装了这个模块 极其简单：在Python的命令行中输入import MySQLdb，如果没有报错，那就已经安装了。 如果未安装,那么 其实就是随便找个地方按下win+R，输入cmd回车——打开windows命令行，进行著名的pip安装大法： pip install mysql-python 按理来说，这一步足够了。但是我这出现了据说在windows环境下python安装模块的痛：命令行里返回了错误： error: Unable to find vcvarsall.bat 如果出现上述错误,那么根据python是32位还是64位,安装 ##Mysqlclient is a Python 3 compatible fork of MySQL-python. MySQL_python-1.2.5-cp27-none-win32.whl 或者 MySQL_python-1.2.5-cp27-none-win_amd64.whl 将文件放到指定目录下,cmd下进入该目录,运行命令即可. pip install MySQL_python-1.2.5-cp27-none-win32.whl 或者 pip install MySQL_python-1.2.5-cp27-none-win_amd64.whl
mac下确实坑，直接安装一直报EnvironmentError: mysql_config not found，度娘的方法似乎都不能解决，先把mysql装上试试
mac下建议这样做： 1. MySQL-python下载：https://pypi.python.org/pypi/MySQL-python/ 2.解压zip包 3.修改配置文件site.cfg中mysql配置文件的路径mysql_config = /usr/bin/mysql_config 4.安装python包：yum install python 5.安装python-devel包：yum install pythan-devel 6.安装MySQL-python：python setup.py install
参考这个地方，各个环境的都有解决方案，包括Ubuntu、mac、linux等，mac的这样安装是最方便的：sudo ARCHFLAGS=-Wno-error=unused-command-line-argument-hard-error-in-future pip install mysql-python
MySQLdb只支持Python2.*，还不支持3.*,安装PyMySQL替代，然后__int__.py添加两行： import pymysql pymysql.install_as_MySQLdb() 就可以使用了
from django.shortcuts import render_to_response
import MySQLdb
def book_list(request):
db = MySQLdb.connect(user='me', db='mydb', passwd='secret', host='localhost')
cursor = db.cursor()
cursor.execute('SELECT name FROM books ORDER BY name')
names = [row[0] for row in cursor.fetchall()]
db.close()
return render_to_response('book_list.html', {'names': names})可以加上 charset='utf8',对中文支持好一点 conn=MySQLdb.connect(host="localhost", user="me", passwd="secret", db="mydb", charset='utf8')
1 除了snowhilloldman 2011-03-06 08:50:58的 "可以加上 charset='utf8',对中文支持好一点 conn=MySQLdb.connect(host="localhost", user="me", passwd="secret", db="mydb", charset='utf8')" 2 在book_list.html中， 要加 <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> 不加这句的话，如果数据库中的数据有汉字，访问book_list.html时就会抛出大概是叫做UnicodeDecodeErroror的异常
book_list.html内容：<html> <head> <title>Book List</title> <body> <h1>My Book List</h1> <ul> {% for name in names %} <li>{{ name }}</li> {% endfor %} </ul> </body> </head>
刚学，好多不会的，看到楼上有个兄弟说'mydb'不会的，我也是刚学（django.python.mysql）。 简单说一下：(先表示已经安装好数据库mysql和python的mysqldb类库) 1、创建我们的数据库CREATE DATABASE mydb; 2、选中我们刚才创建的mydb数据库：USE mydb; 3、创建表，也就是我们的books：CREATE TABLE books(name VARCHAR(50)); 4、插入数据：INSERT INTO books VALUES ('css','jquery','javascript'); 这样，在我们的django里面配置好views.py应该没问题啦。
为什么我这段代码复制进去 就会 (2003, "Can't connect to MySQL server on 'localhost' (10061)") 但是把locaohost直接换成127.0.0.1 就可以正常运行 我的host文件里面127.0.0.1 localhost 也是正常的啊
ImportError: dlopen(/Library/Python/2.7/site-packages/_mysql.so, 2): no suitable image found. Did find: /Library/Python/2.7/site-packages/_mysql.so: mach-o, but wrong architecture 导入的时候报错这个，度娘孤狗了很久，各种方法试过了还是不行，求大神解决
百度到的方法都试过以后，加上这个ln -s /usr/local/mysql/bin/* /usr/local/bin 一下就OK了，中间重启过电脑
好像MySQL已经python3.x 已经不能用了，目前在用pymssql，但是需要在_int_.py里面添加import pymysql pymysql.install_as_MySQLdb() 提供给各位小伙伴，
Django2.0 +MySQL5.7 显示成功 用Navicat for MySQL 可视化界面创建mydb数据库，在其中再添加books表。 db = pymysql.connect(user='root', db='mydb', passwd='*****', host='127.0.0.1', port=3306) user 默认为root passwd 是你安装MySQL时的设置的密码
可以直接 使用 pymsql ，安装过pymysql包之后，在你Django项目下添加"import pymysql pymysql.install_as_MySQLdb()" 两句话，然后去setting.py 里把你的DATABASES 改了， 改成 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'user': 'PASSWORD': 'HOST': 'localhost', 'PORT': '3306' } } 省略的自己填上自己的就行了
复制代码，输入地址后报错2003, Can't connect to MySQL server on 'localhost' (10061)，找了半天，原来要到c://windows/system32/drivers/etc/hosts.txt文件，查看localhost是否指向本机IP地址127.0.0.1。 改了之后成功运行~~
这个方法可用，但很快一些问题将出现在你面前：
- 我们将数据库连接参数硬行编码于代码之中。 理想情况下，这些参数应当保存在 Django 配置中。
- 我们不得不重复同样的代码： 创建数据库连接、创建数据库游标、执行某个语句、然后关闭数据库。 理想情况下，我们所需要应该只是指定所需的结果。
- 它把我们栓死在 MySQL 之上。 如果过段时间，我们要从 MySQL 换到 PostgreSQL，就不得不使用不同的数据库适配器（例如
psycopg而不是MySQLdb），改变连接参数，根据 SQL 语句的类型可能还要修改SQL 。 理想情况下，应对所使用的数据库服务器进行抽象，这样一来只在一处修改即可变换数据库服务器。 （如果你正在建立一个开源的Django应用程序来尽可能让更多人使用的话，这个特性是非常适当的。）
楼上的感觉你说的不太对，我的感觉是，不管你用mysql还是sqlserver，django都已经把他们的代码，封装好了，你直接按照django的方法来调用就好了，这样的好处是，如果更换数据库，只需要更改配置文件就好了，但是我觉得这样不好，这样对数据库没有深入的了解了，离开了django就不会用数据库了，暂时的理解
正如你所期待的，Django数据库层正是致力于解决这些问题。 以下提前揭示了如何使用 Django 数据库 API 重写之前那个视图。
from django.shortcuts import render_to_response
from mysite.books.models import Book
def book_list(request):
books = Book.objects.order_by('name')
return render_to_response('book_list.html', {'books': books})我们将在本章稍后的地方解释这段代码。 目前而言，仅需对它有个大致的认识。
MTV 开发模式
MVC中的M就是MVT中的M（模型） MVC中的V就是MVT中的V（展示哪些数据）和T（如何展示数据） MVC中的C是由Django框架的URLconf来实现，并不存在与MVT中 应该是这么理解吧
在钻研更多代码之前，让我们先花点时间考虑下 Django 数据驱动 Web 应用的总体设计。
我们在前面章节提到过，Django 的设计鼓励松耦合及对应用程序中不同部分的严格分割。 遵循这个理念的话，要想修改应用的某部分而不影响其它部分就比较容易了。 在视图函数中，我们已经讨论了通过模板系统把业务逻辑和表现逻辑分隔开的重要性。 在数据库层中，我们对数据访问逻辑也应用了同样的理念。
把数据存取逻辑、业务逻辑和表现逻辑组合在一起的概念有时被称为软件架构的 Model-View-Controller (MVC)模式。 在这个模式中， Model 代表数据存取层，View 代表的是系统中选择显示什么和怎么显示的部分，Controller 指的是系统中根据用户输入并视需要访问模型，以决定使用哪个视图的那部分。
为什么用缩写？
像 MVC 这样的明确定义模式的主要用于改善开发人员之间的沟通。 比起告诉同事，“让我们采用抽象的数据存取方式，然后单独划分一层来显示数据，并且在中间加上一个控制它的层”，一个通用的说法会让你收益，你只需要说：“我们在这里使用MVC模式吧。”。
Django 紧紧地遵循这种 MVC 模式，可以称得上是一种 MVC 框架。 以下是 Django 中 M、V 和 C 各自的含义：
- M ，数据存取部分，由django数据库层处理，本章要讲述的内容。
- V ，选择显示哪些数据要显示以及怎样显示的部分，由视图和模板处理。
- C ，根据用户输入委派视图的部分，由 Django 框架根据 URLconf 设置，对给定 URL 调用适当的 Python 函数。
由于 C 由框架自行处理，而 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），Django 也被称为 MTV 框架 。在 MTV 开发模式中：
- M 代表模型（Model），即数据存取层。 该层处理与数据相关的所有事务： 如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等。
- T 代表模板(Template)，即表现层。 该层处理与表现相关的决定： 如何在页面或其他类型文档中进行显示。
- V 代表视图（View），即业务逻辑层。 该层包含存取模型及调取恰当模板的相关逻辑。 你可以把它看作模型与模板之间的桥梁。
如果你熟悉其它的 MVC Web开发框架，比方说 Ruby on Rails，你可能会认为 Django 视图是控制器，而 Django 模板是视图。 很不幸，这是对 MVC 不同诠释所引起的错误认识。 在 Django 对 MVC 的诠释中，视图用来描述要展现给用户的数据；不是数据 如何展现 ,而且展现 哪些 数据。 相比之下，Ruby on Rails 及一些同类框架提倡控制器负责决定向用户展现哪些数据，而视图则仅决定 如何 展现数据，而不是展现 哪些 数据。
在 Django 对 MVC 的诠释中，视图用来描述要展现给用户的数据；不是数据 如何展现 ,而且展现 哪些 数据。 -- 在 Django 对 MVC 的诠释中，视图用来描述要展现给用户的数据；不仅仅是数据“如何”展现，还包括“哪些”数据要展现。
关于MTV和MVC的异同比较是非常关键的一点，但这里并没有把“Django的View与MVC的Controller”、“Django的Template与MVC的View”进行比较，而是说明了“Django的View和MVC的View”的差别，无语了……
In Django’s interpretation of MVC, the “view” describes the data that gets presented to the user; it’s not necessarily just how the data looks, but which data is presented. 从Django对MVC的诠释看来："视图”用来描述呈现给用户的数据，并非专美用来描述这些数据外观看来怎样，而是哪些数据需要向用户呈现。
没感觉到和MVC有多大区别，虽然这里说C由django框架完成了，但是我还是感觉它的View就是MVC中的C，区别只是url映射配置写在urls.py里面而已。
两种诠释中没有哪个更加正确一些。 重要的是要理解底层概念。
数据库配置
django的数据库层配置需要先安装好「MySQL-python」（别的也行）和「mysql-server」。安装好这两个后，用命令「mysql -u root -p」进入mysql-server，再用命令「create database mydb」创建后面setting.py中NAME的设置「mydb」。配置「setting.py」时，要注意，「NAME」写成mysql中「已经创建的database」，「USER」写成mysql的「已经创建的user」（注：mysql-server会在安装时要求创建root账户，就是输入密码那一步），你可以自己创建自己的user而不是只用root。「PASSWORD」写成mysql-server的对应user的密码。至于「HOST」「PORT」空着也行，知道它是localhost和3306就可以了。配置完就到mysite下使用命令「python manage.py migrate」。成功，也就是没有ERROR出现后，就会给「mydb」这个database创建很多表。然后恭喜你，可以继续下一步创建app和view了！
感谢一楼吴某人的评论，我才发现没有装mysql server，导致一直出现 error2003 （1）在官网https://dev.mysql.com/downloads/installer/ 注册登录之后，我是64位windows系统，下载Windows (x86, 32-bit), MSI Installer，打开看一下窗口内Product这个地方自己的电脑有没有装mysql server，然后在这个右侧选add， 选mysql server 5.7 x64安装就好了， 32位的电脑安装x86的。安装的时候会要求给root设置一个密码，设置完了记住 （2）然后 用mysql -u root -p 还是不成功，就到系统环境变量里面path加入了C:\Program Files\MySQL\MySQL Server 5.7\bin，这个是你把mysql server安装在哪里就复制进系统环境变量里面，不一定和我的一样。重新打开cmd就好了。
感谢一楼吴某人的评论，我才发现没有装mysql server，导致一直出现 error2003 （1）在官网https://dev.mysql.com/downloads/installer/ 注册登录之后，我是64位windows系统，下载Windows (x86, 32-bit), MSI Installer，打开看一下窗口内Product这个地方自己的电脑有没有装mysql server，然后在这个右侧选add， 选mysql server 5.7 x64安装就好了， 32位的电脑安装x86的。安装的时候会要求给root设置一个密码，设置完了记住 （2）然后 用mysql -u root -p 还是不成功，就到系统环境变量里面path加入了C:\Program Files\MySQL\MySQL Server 5.7\bin，这个是你把mysql server安装在哪里就复制进系统环境变量里面，不一定和我的一样。重新打开cmd就好了。(3) 还有一点，在运行「mysql -u root -p」进入mysql-server之后建数据库用语句 create database mydb; （有个分号），已经把sql忘干净了，重新看一遍。
记住这些理念之后，让我们来开始 Django 数据库层的探索。 首先，我们需要做些初始配置；我们需要告诉Django使用什么数据库以及如何连接数据库。
我们假定你已经完成了数据库服务器的安装和激活，并且已经在其中创建了数据库（例如，用 CREATE DATABASE 语句）。 如果你使用SQLite，不需要这步安装，因为SQLite使用文件系统上的独立文件来存储数据。
象前面章节提到的 TEMPLATE_DIRS 一样，数据库配置也是在Django的配置文件里，缺省 是 settings.py 。 打开这个文件并查找数据库配置：
DATABASE_ENGINE = ''
DATABASE_NAME = ''
DATABASE_USER = ''
DATABASE_PASSWORD = ''
DATABASE_HOST = ''
DATABASE_PORT = ''配置：'ENGINE': 'django.db.backends.sqlite3','NAME': 'D:/djcode/mysite/db/mydata.db',
数据库设置： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': os.path.join(BASE_DIR, 'db.mysql'), 'NAME':'mydb', 'USER':'root', 'PASSWORD':'123456', 'HOST':'127.0.0.1', 'PORT':'3306', } }
这段代码推荐看看英文原版，这里暂时还没有更新. 原文地址：http://www.djangobook.com/en/2.0/chapter05.html
确实已经更新，最新的格式： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'. 'NAME': '', # Or path to database file if using sqlite3. 'USER': '', # Not used with sqlite3. 'PASSWORD': '', # Not used with sqlite3. 'HOST': '', # Set to empty string for localhost. Not used with sqlite3. 'PORT': '', # Set to empty string for default. Not used with sqlite3. } }
Django1.6中：setting DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'xxxx', 'USER': 'root', 'PASSWORD':'xxxx', 'HOST': 'localhost', 'PORT': '3306', } }
django 1.9 我的django默认使用sqlite（虽然我想用mysql来着）/n DATABASE = { </n> 'default': { </n> 'ENGINE': 'django.db.backends.sqlite3', </n> 'NAME': os.path.join(BASE_DIR, 'db.sqlite3'), </n> } </n> }
配置纲要如下。
DATABASE_ENGINE 告诉Django使用哪个数据库引擎。 如果你在 Django 中使用数据库， DATABASE_ENGINE 必须是 Table 5-1 中所列出的值。
要注意的是无论选择使用哪个数据库服务器，都必须下载和安装对应的数据库适配器。 访问表 5-1 中“所需适配器”一栏中的链接，可通过互联网免费获取这些适配器。 如果你使用Linux，你的发布包管理系统会提供合适的包。 比如说查找python-postgresql 或者python-psycopg 的软件包。
配置示例：
DATABASE_ENGINE = 'postgresql_psycopg2'在django1.3.1中，数据库engin中需要在前面加上django.db.backends".例如使用sqlite3，需要写成"django.db.backends.sqlite3"
Django version 1.4中， 'ENGINE': 'django.db.backends.', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'. 'NAME': 'wrb', # Or path to database file if using sqlite3. 'USER': 'root', # Not used with sqlite3. 'PASSWORD': 'root', # Not used with sqlite3. 'HOST': '', # Set to empty string for localhost. Not used with sqlite3. 'PORT': '/var/run/mysqld/mysqld.sock', # Set to empty string for default. Not used with sqlite3. } } 1.4里这样配置才对
if use poetgrepsql django.db.backends.postgresql_psycopg2 is ok postgresql_psycopg2 is error
错误：django.core.exceptions.ImproperlyConfigured: 'postgresql_psycopg2' isn't an available database backend. 原因：参数错误 解决方法： 'ENGINE': 'django.db.backends.postgresql_psycopg2'
DATABASE_NAME 将数据库名称告知 Django 。 例如：
DATABASE_NAME = 'mydb'DATABASE_NAME 不是数据库名; NAME才是！ 好坑人啊，在python manage.py sqlall books的时候报no database selected
此database数据库需要创建，具体如下： 1.mysql -u root -p 2.create database mydb; 如果不设置上面这个，下面再执行python manage.py sqlall books会提示如下错误：_mysql_exceptions.OperationalError: (1049, "Unknown database 'mydb'")
如果使用 SQLite，请对数据库文件指定完整的文件系统路径。 例如：
我在看1.3的官方文档时, 这里也说是 必须是完整的路径 但我在使用的时候并没有使用绝对路径仅仅写了 data.db 也是可行的 会自动在settings.py相同目录下生成data.db文件
用的SqlLite3，貌似不能自己随意选路径，后来实在不行，按照snyh说的，直接写文件名mydata.db,确实自动在mysite目录下生成了mydata.db文件。周一上班再试试别的方法
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'csvt', 'USER':'root', 'PASSWORD':'123456', 'HOST':'', 'PORT':'', } }
注意，python3.5 django1.8不再支持MySQLdb，而是使用pymysql，在站点的__init__.py文件中，我们添加如下代码： import pymysql pymysql.install_as_MySQLdb()即可
Py3+1.9版本的话配置引擎有两个方法：一.'ENGINE':'mysql.connector.django',；；；；；；二.try: import pymysql pymysql.install_as_MySQLdb() except ImportError: pass 然后再这么写：'ENGINE':'django.db.backends.mysql' 当然前者要装mysql.connector，后者需要安装PyMySQL
DATABASE_NAME = '/home/django/mydata.db'在这个例子中，我们将SQLite数据库放在/home/django目录下，你可以任意选用最合适你的目录。
DATABASE_USER 告诉 Django 用哪个用户连接数据库。 例如： 如果用SQLite，空白即可。
DATABASE_PASSWORD 告诉Django连接用户的密码。 SQLite 用空密码即可。
DATABASE_HOST 告诉 Django 连接哪一台主机的数据库服务器。 如果数据库与 Django 安装于同一台计算机（即本机），可将此项保留空白。 如果你使用SQLite，此项留空。
此处的 MySQL 是一个特例。 如果使用的是 MySQL 且该项设置值由斜杠（ '/' ）开头，MySQL 将通过 Unix socket 来连接指定的套接字，例如：
DATABASE_HOST = '/var/run/mysql'（django 1.4）host的值和my.cnf文件中bind-address设置有关，如果bind-address = localhost，则需要设置 host = "localhost"; 如果bind-address = 127.0.0.1, 则host = “127.0.0.1”。此外，ubuntu12.04下，可以在终端执行命令：sudo gksu gedit /etc/mysql/my.cnf 打开my.cnf文件进行编辑。
一旦在输入了那些设置并保存之后应当测试一下你的配置。 我们可以在mysite 项目目录下执行上章所提到的python manage.py shell 来进行测试。 （我们上一章提到过在，manager.py shell 命令是以正确Django配置启用Python交互解释器的一种方法。 这个方法在这里是很有必要的，因为Django需要知道加载哪个配置文件来获取数据库连接信息。）
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'. 'NAME': 'mydb', # Or path to database file if using sqlite3. 'USER': 'root', # Not used with sqlite3. 'PASSWORD': '197422', # Not used with sqlite3. 'HOST': '127.0.0.1', # Set to empty string for localhost. Not used with sqlite3. 'PORT':'3306', 先建一个mydb.才可以cursor = connection.cursor()不出错
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'. 'NAME': 'C:/Users/admin/djcode/test.db', # Or path to database file if using sqlite3. 'USER': '', # Not used with sqlite3. 'PASSWORD': '', # Not used with sqlite3. 'HOST': '', # Set to empty string for localhost. Not used with sqlite3. 'PORT': '', # Set to empty string for default. Not used with sqlite3. } } 默认sqlite3为什么报错呢
mysql可能会出现错误：no module named mysql.base。 在setting.py中数据库引擎那 'ENGINE' : 'django.db.backends.mysql'
这里使用mysql时候加载的py驱动不要用beta版本，django 1.4.5 + mysql5.5.27 + mysql_python_1.2.3(http://www.codegood.com/download/10/) 成功，其他错误。
用postgresql的话，setting里'HOST'值赋上'localhost'不然有OperationalError: FATAL: Peer authentication failed for user错误。
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.oracle', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'. 'NAME': 'STDBY', # Or path to database file if using sqlite3. # The following settings are not used with sqlite3: 'USER': 'scott', 'PASSWORD': 'XXX', 'HOST': '221.204.236.XXX', # Empty for localhost through domain sockets or '127.0.0.1' for localhost th rough TCP. 'PORT': '1521', # Set to empty string for default. } }
之前一直报错OperationalError:unable to open database file 各种改路径改文件夹权限都不行，后来发现要先在\mysite路径下运行下列语句：python manage.py syncdb
mysql 配置 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'cms', 'USER': 'root', 'PASSWORD': '123456', 'HOST': '127.0.0.1', 'PORT': '3306', } 一定是127.0.0.1? localhsot 不管用？？
Error loading MySQLdb module: No module named MySQLdb 可能是缺少connector,按照表5-1下载安装即可
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'XXXX', 'USER': 'YYY', 'PASSWORD': 'ZZZZZ', 'HOST': '', 'PORT': '', } }
报 Error loading MySQLdb module: No module named MySQLdb 的可以用 pip install mysql-python ubuntu下的可以用 sudo apt-get install python-mysqldb
之前适配器安的是pymysqld的童鞋，要在mysite目录下的_init_.py里加入： import pymysql pymysql.install_as_MySQLdb()
输入下面这些命令来测试你的数据库配置：
>>> from django.db import connection
>>> cursor = connection.cursor()windows下我版本是django1.6.1，mysql5.6.10.输入命令后，_mysql_exceptions.OperationalError: (2003, "Can't connect to MySQL server on 'localhost' (10061)") 报错，host换成'localhost'也不行,有谁知道嚒 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'mydb', 'USER': 'root', 'PASSWORD': 'root', 'HOST': '127.0.0.1', 'PORT': '3306', } }
一直报错啊… OperationalError: (2003, "Can't connect to MySQL server on '127.0.0.1' (10061)")
晕死啊，这里搞了一天终于连接上了，上面方法是对的，在mysql下的my.ini中（没有的话自己建个）加入这句:bind-address=127.0.0.1,然后重启mysql服务，应该就可以了…
OperationalError: (1045, "Access denied for user 'master'@'localhost' (using password: NO)") 什么原因啊
MySQL报错的可以按以下配置： DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'xxxx', 'USER': 'xxxx', 'PASSWORD': 'xxxxxx', 'HOST': '127.0.0.1', 'PORT': 'xxxx', } } 测试正确与否： python manage.py shell >>>from django.db import connection >>>cursor = connection.cursor()
OperationalError: (1045, "Access denied for user 'root'@'localhost' (using passw ord: YES)") 这个怎么解决啊？
agk-hp:~/$mysql ERROR 1045 (28000): Access denied for user 'greg'@'localhost' (using password: NO) agk-hp:~/$sudo cat /etc/mysql/debian.cnf|grep password password = t7753my3D2x4yfQm agk-hp:~/$mysql -u debian-sys-maint -p Enter password: {t7753my3D2x4yfQm} Welcome to the MySQL monitor. Commands end with ; or \g. mysql> use mysql; mysql> grant all privileges on *.* to 'root'@'localhost'; mysql> grant all privileges on *.* to 'greg'@'localhost'; agk-hp:~/$mysql mysql>
为什么我的 django 1.9.4 执行python manage.py migrate总是Access Denied？就是那个1045的错误。跟着楼上的设置走了一遍还是不行。。
在 setting.py DATABASE 里面这么配置 'default': { 'ENGINE': 'django.db.backends.mysql',# 这里是固定的 'NAME': 'mydb12' ,# 这里要写数据库的名字 'USER': 'root', # 这里是user 一般是root 'PASSWORD':'4683475', # 这里是你数据库密码 'HOST':'127.0.0.1', #这里一般是这个 'PORT':'3306', # 这里一般是这个 win10 64位 python 2.7.11 django 1.9.6
win下py3.6会报错mysqlclient版本应更新到1.3.3，然而并没有适合的包，最后去通过查找路径C:\Programs\Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql 这个路径里的文件把 if version < (1, 3, 3): raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__) 注释掉 就好了
这里的django是数据库的名字，是setting中的名字 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'django_test', #你的数据库名称 'USER': 'root', #你的数据库用户名 'PASSWORD': '123456', #你的数据库密码 'HOST': '', #你的数据库主机，留空默认为localhost 'PORT': '3306', #你的数据库端口 setting中设置为django_test,则就是from django_test.db
django 2.0.6 在执行python manage.py shell 之前需要在__init__.py 中 添加以下代码:import pymysql pymysql.install_as_MySQLdb() (注:我是Python3.5.3) 否则，它就会提示错误,以下是部分错误信息: ... 'Did you install mysqlclient or MySQL-python?' % e django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module: No module named 'MySQLdb'. Did you install mysqlclient or MySQL-python? 你安装了mysql客户端或者MySQL-python了吗?没有名为'MySQLdb'的模块,你要安装我刚刚说的哪个?
如果没有显示什么错误信息，那么你的数据库配置是正确的。 否则，你就得 查看错误信息来纠正错误。 表 5-2 是一些常见错误。
第一个应用程序
你现在已经确认数据库连接正常工作了，让我们来创建一个 Django app-一个包含模型，视图和Django代码，并且形式为独立Python包的完整Django应用。
在这里要先解释一些术语，初学者可能会混淆它们。 在第二章我们已经创建了 project , 那么 project 和 app 之间到底有什么不同呢？它们的区别就是一个是配置另一个是 代码：
project就是一个项目（或者说工程），这个项目包括了多个app和配置文件，而app就是一个单一的exe或其他后缀的文件，比如说腾讯QQ就是一个项目，而他下面的可执行文件，升级文件就是一个个的app 我一直是这么理解的
一个project包含很多个Django app以及对它们的配置。
技术上，project的作用是提供配置文件，比方说哪里定义数据库连接信息, 安装的app列表， TEMPLATE_DIRS ，等等。
一个app是一套Django功能的集合，通常包括模型和视图，按Python的包结构的方式存在。
例如，Django本身内建有一些app，例如注释系统和自动管理界面。 app的一个关键点是它们是很容易移植到其他project和被多个project复用。
对于如何架构Django代码并没有快速成套的规则。 如果你只是建造一个简单的Web站点，那么可能你只需要一个app就可以了； 但如果是一个包含许多不相关的模块的复杂的网站，例如电子商务和社区之类的站点，那么你可能需要把这些模块划分成不同的app，以便以后复用。
不错，你可以不用创建app，这一点应经被我们之前编写的视图函数的例子证明了 。 在那些例子中，我们只是简单的创建了一个称为views.py的文件，编写了一些函数并在URLconf中设置了各个函数的映射。 这些情况都不需要使用apps。
但是，系统对app有一个约定： 如果你使用了Django的数据库层（模型），你 必须创建一个Django app。 模型必须存放在apps中。 因此，为了开始建造 我们的模型，我们必须创建一个新的app。
在mysite 项目文件下输入下面的命令来创建books app：
python manage.py startapp booksubuntu下先要 sudo chmod 755 /usr/local/lib/python2.7/dist-packages/django/conf/app_template/* 才可以正常创建。
我的目录结构是：mysite/mysite/settings.py 那项目路径是mysite还是mysite/mysite ? manage.py在mysite路径下面 settings.py在mysite/mysite下面 这里好糊涂啊 求指点
应该是这样 mysite/mysite, mysite/books 这样的结构，books和最里面的mysite同级。我看1.6官方教程也是如此 https://docs.djangoproject.com/en/1.6/intro/tutorial01/
应该是在settings.py那级目录下用 python ../manage.py startapp * 要不的话settings里面配置INSTALLED_APP时会出错，因为本来mysite.*的文件是在setting那一级下的
这个命令并没有输出什么，它只在 mysite 的目录里创建了一个 books 目录。 让我们来看看这个目录的内容：
books/
__init__.py
models.py
tests.py
views.py在eclipse pydev中 右键工程->Django -> create application(manage.py startapp) ->输入app名称 可实现相同功能
现在的目录： books/ admin.py __init__.py migrations/ __init__.py models.py tests.py views.py
这个目录包含了这个app的模型和视图。
使用你最喜欢的文本编辑器查看一下 models.py 和 views.py 文件的内容。 它们都是空的，除了 models.py 里有一个 import。这就是你Django app的基础。
在Python代码里定义模型
我们早些时候谈到。MTV里的M代表模型。 Django模型是用Python代码形式表述的数据在数据库中的定义。 对数据层来说它等同于 CREATE TABLE 语句，只不过执行的是Python代码而不是 SQL，而且还包含了比数据库字段定义更多的含义。 Django用模型在后台执行SQL代码并把结果用Python的数据结构来描述。 Django也使用模型来呈现SQL无法处理的高级概念。
Django模型是用Python代码形式表述的数据在数据库中的定义。 这句话的意思是 Django 模型 是用python写的 就是模型类 Django会把模型类 翻译成数据库语言和相关操作 进而对数据库进行操作
如果你对数据库很熟悉，你可能马上就会想到，用Python 和 SQL来定义数据模型是不是有点多余？ Django这样做是有下面几个原因的：
自省（运行时自动识别数据库）会导致过载和有数据完整性问题。 为了提供方便的数据访问API， Django需要以 某种方式 知道数据库层内部信息，有两种实现方式。 第一种方式是用Python明确地定义数据模型，第二种方式是通过自省来自动侦测识别数据模型。
第二种方式看起来更清晰，因为数据表信息只存放在一个地方-数据库里，但是会带来一些问题。 首先，运行时扫描数据库会带来严重的系统过载。 如果每个请求都要扫描数据库的表结构，或者即便是 服务启动时做一次都是会带来不能接受的系统过载。 （有人认为这个程度的系统过载是可以接受的，而Django开发者的目标是尽可能地降低框架的系统过载）。第二，某些数据库，尤其是老版本的MySQL,并未完整存储那些精确的自省元数据。
编写Python代码是非常有趣的，保持用Python的方式思考会避免你的大脑在不同领域来回切换。 尽可能的保持在单一的编程环境/思想状态下可以帮助你提高生产率。 不得不去重复写SQL，再写Python代码，再写SQL，…，会让你头都要裂了。
近几年前端一词被用烂了 看到就头痛 自己其实也算个前端 但是感觉要学的东西很多 现在没有纯前端了 你要懂一两门后端语言吧 python c# 数据库要懂吧 sql 前端框架呢 vue angular 后端框架呢 django flask spring 。懂了还不行，要会用，会用还不行，要会改。写了这么多只是发个牢骚，大家安心学习，升职加薪！
把数据模型用代码的方式表述来让你可以容易对它们进行版本控制。 这样，你可以很容易了解数据层 的变动情况。
SQL只能描述特定类型的数据字段。 例如，大多数数据库都没有专用的字段类型来描述Email地址、URL。 而用Django的模型可以做到这一点。 好处就是高级的数据类型带来更高的效率和更好的代码复用。
SQL还有在不同数据库平台的兼容性问题。 发布Web应用的时候，使用Python模块描述数据库结构信息可以避免为MySQL, PostgreSQL, and SQLite编写不同的CREATE TABLE。
当然，这个方法也有一个缺点，就是Python代码和数据库表的同步问题。 如果你修改了一个Django模型， 你要自己来修改数据库来保证和模型同步。 我们将在稍后讲解解决这个问题的几种策略。
最后,我们要提醒你Django提供了实用工具来从现有的数据库表中自动扫描生成模型。 这对已有的数据库来说是非常快捷有用的。 我们将在第18章中对此进行讨论。
第一个模型
在本章和后续章节里，我们把注意力放在一个基本的 书籍/作者/出版商 数据库结构上。 我们这样做是因为 这是一个众所周知的例子，很多SQL有关的书籍也常用这个举例。 你现在看的这本书也是由作者 创作再由出版商出版的哦！
配置mysql的时候，用utf-8编码的话，会出现乱码？ db=MySQLdb.connect(user="root",db="python",passwd="mxr",host="localhost",use_unicode=True,charset="utf8") 通过此种方式不会，但是在settings.py中那里配置charset呢？
我们来假定下面的这些概念、字段和关系：
- 一个作者有姓，有名及email地址。
- 出版商有名称，地址，所在城市、省，国家，网站。
- 书籍有书名和出版日期。 它有一个或多个作者（和作者是多对多的关联关系[many-to-many]）， 只有一个出版商（和出版商是一对多的关联关系[one-to-many]，也被称作外键[foreign key]）
我的理解:这里更可能是想说“多对一”。一家出版商出版好多本书更合常理。我们可以先忽略一本书两个出版商的个例。因为“many-to-many”的例子已经在书和作者的关系中得到体现。
外键是这么理解的。 每本书只有一个出版社。 但是每个出版社可以发行有很多书。 这就是一对多。 生成数据库的时候，book表中，会有一个字段，显示的是对应的Publisher表中对应的出版社id值 这个就是外键了哦
参考这个博客,说得很清楚,还有实例http://logic0.blog.163.com/blog/static/18892814620137343447299/
第一步是用Python代码来描述它们。 打开由startapp 命令创建的models.py 并输入下面的内容：
from django.db import models
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()
class Author(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=40)
email = models.EmailField()
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()为什么我的总是提示出错“Settings cannot be imported, because environment variable DJANGO_SETTINGS_MODULE is undefined.” 按照网上设置from django.conf import settings。。。方法设置，还是出现错误，提示settings already configured,这到底怎么回事，怎么设置？
为啥运行了python manage.py sqlall books 却在数据库里看不到新生成的表？ 找到答案了，继续往下看了，真的生成数据库表还要运行: python manage.py syncdb
SQLite使用中发现：DateFile() 似乎在"python manager.py shell"命令中，会有"Runtime Warning",因为USE_TZ=True(默认)【settings.py】，而sqlite3中要求接受的是不包含tz的datetime。
Django2.0 ForeignKey 需要添加参数on_delete publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE)
让我们来快速讲解一下这些代码的含义。 首先要注意的事是每个数据模型都是 django.db.models.Model 的子类。它的父类 Model 包含了所有必要的和数据库交互的方法，并提供了一个简洁漂亮的定义数据库字段的语法。 信不信由你，这些就是我们需要编写的通过Django存取基本数据的所有代码。
Django 2.0 里面，需要写成： publisher = models.ForeignKey(Publisher, on_delete='CASCADE')
每个模型相当于单个数据库表，每个属性也是这个表中的一个字段。 属性名就是字段名，它的类型（例如 CharField ）相当于数据库的字段类型 （例如 varchar ）。例如， Publisher 模块等同于下面这张表（用PostgreSQL的 CREATE TABLE 语法描述）：
CREATE TABLE "books_publisher" (
"id" serial NOT NULL PRIMARY KEY,
"name" varchar(30) NOT NULL,
"address" varchar(50) NOT NULL,
"city" varchar(60) NOT NULL,
"state_province" varchar(30) NOT NULL,
"country" varchar(50) NOT NULL,
"website" varchar(200) NOT NULL
);mysql5.7版本 copy这个来建表一直报符号错误，把 “ 全都换成 ` 就可以了 CREATE TABLE `books_publisher` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'books ID', `name` varchar(30) NOT NULL, `address` varchar(50) NOT NULL, `city` varchar(60) NOT NULL, `state_province` varchar(30) NOT NULL, `country` varchar(50) NOT NULL, `website` varchar(200) NOT NULL, PRIMARY KEY (`id`) )ENGINE=InnoDB AUTO_INCREMENT=257 DEFAULT CHARSET=utf8;
@妖刀 @老马 因为Django在帮你创建表的时候自动加上了app的工程名,应该用意是为了区分那个app创建的吧,不过你可以尝试在创建model的类里创建一个内部类 Meta 用于指定model要创建的表名,比如我需要创建一个简单的User表: class User(models.Model): name = models.CharField(max_length=10, primary_key=True) #primary_key=True就是指定主键 pwd = models.CharField(max_length=16) def __str__(self): return self.name class Meta: db_table='user' #指定表名 ordering=['name'] #按照什么排序
事实上，正如过一会儿我们所要展示的，Django 可以自动生成这些 CREATE TABLE 语句。
“每个数据库表对应一个类”这条规则的例外情况是多对多关系。 在我们的范例模型中， Book 有一个 多对多字段 叫做 authors 。 该字段表明一本书籍有一个或多个作者，但 Book 数据库表却并没有 authors 字段。 相反，Django创建了一个额外的表（多对多连接表）来处理书籍和作者之间的映射关系。
我啰嗦一下:上面定义了Publisher，Author，Book三个类，按照“每个数据库表对应一个类”的“原则”，执行python manage.py syncdb 应该创建三个表，但你可以看到（创建的时候就有打印显示）数据库里多了一个表（四个表）名为：book_authors ，这就是那个“额外的表”，是因为“多对多”字段的原因创建的。
请查看附录 B 了解所有的字段类型和模型语法选项。
最后需要注意的是，我们并没有显式地为这些模型定义任何主键。 除非你单独指明，否则Django会自动为每个模型生成一个自增长的整数主键字段每个Django模型都要求有单独的主键。id
模型安装
完成这些代码之后，现在让我们来在数据库中创建这些表。 要完成该项工作，第一步是在 Django 项目中 激活 这些模型。 将 books app 添加到配置文件的已安装应用列表中即可完成此步骤。
再次编辑 settings.py 文件， 找到 INSTALLED_APPS 设置。 INSTALLED_APPS 告诉 Django 项目哪些 app 处于激活状态。 缺省情况下如下所示：
使用了django1.4.3，创建project的时候（例如名字叫test），test内自动生成了一个叫test的文件（与manage.py同级），其中包含settings.py。 我们创建了books这个app之后，里面没有settings.py，其实只要编辑test里面那个settings.py就好了。另外，添加到INSTALLED_APPS里面的是‘books’。本人曾画蛇添足地把settings.py复制到books里面修给这个settings，结果报错Error: App with label books could not be found. Are you sure your INSTALLED_APPS setting is correct?
INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
)弄清楚了目录是mysite/books 我把books放到了与mysite(或者manage.py)的同级目录里了settings.py在mysite目录里，books要创建在与settings.py的相同目录里 那这里创建books app的时候应该使用 python ../manage.py startapp books 不然mysite的项目里面没有manage.py
我的默认 INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.messages', 'django.contrib.staticfiles', # Uncomment the next line to enable the admin: # 'django.contrib.admin', # Uncomment the next line to enable admin documentation: # 'django.contrib.admindocs', )
Django 1.5中的默认配置： INSTALLED_APPS = ( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.sites', 'django.contrib.messages', 'django.contrib.staticfiles', # Uncomment the next line to enable the admin: # 'django.contrib.admin', # Uncomment the next line to enable admin documentation: # 'django.contrib.admindocs', )
django 1.6.5: INSTALLED_APPS = ( 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', )
把这四个设置前面加#临时注释起来。 （这四个app是经常使用到的，我们将在后续章节里讨论如何使用它们）。同时，注释掉MIDDLEWARE_CLASSES的默认设置条目，因为这些条目是依赖于刚才我们刚在INSTALLED_APPS注释掉的apps。 然后，添加‘mysite.books’ 到INSTALLED_APPS 的末尾，此时设置的内容看起来应该是这样的：
MIDDLEWARE_CLASSES = (
# 'django.middleware.common.CommonMiddleware',
# 'django.contrib.sessions.middleware.SessionMiddleware',
# 'django.contrib.auth.middleware.AuthenticationMiddleware',
)
INSTALLED_APPS = (
# 'django.contrib.auth',
# 'django.contrib.contenttypes',
# 'django.contrib.sessions',
# 'django.contrib.sites',
'mysite.books',
)In the SETTING_APP, The 'mystie.books' should be 'books'. otherwise will lead the ERROR 'NO MODULE NAMED BOOK'
INSTALLED_APPS里默认有6个app了。 此处添加的app应该是‘books’,'mysite.books'会报错‘Error: No module named books ’
django-admin.py startproject mysite, 1.4会在mysite下多一个mysite文件夹, mysite/mysite，startapp新建的app在第一个mysite下 所以直接boos app即可， 如果用mysite.books 则表示books app是在mysite/mysite/books
AttributeError: 'module' object has no attribute 'Modle' 为什么我的显示是这个，这里我知道是“books”，模块对象没有对象模型？？？？求解释！！！
教程中提到了以下4行： # 'django.contrib.auth', # 'django.contrib.contenttypes', # 'django.contrib.sessions', # 'django.contrib.sites', 另外INSTALLED_APPS还多出了以下3行： # 'django.contrib.admin', # 'django.contrib.messages', # 'django.contrib.staticfiles', 刚开始没有注释掉，结果报错，注释掉后就 0 errors 完整如下： INSTALLED_APPS = ( # 'django.contrib.auth', # 'django.contrib.contenttypes', # 'django.contrib.sessions', # 'django.contrib.sites', # 'django.contrib.admin', # 'django.contrib.messages', # 'django.contrib.staticfiles', 'books', ) MIDDLEWARE_CLASSES = ( # 'django.middleware.common.CommonMiddleware', # 'django.contrib.sessions.middleware.SessionMiddleware', # 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', )
我修改后 Put 'django.contrib.admin' in your INSTALLED_APPS setting in order to use the admin application.
过来人提醒： books文件夹应该在与manage.py同级的目录里面而不是在mysite/mysite/目录下面，后面的使用时候都是将books作为一个独立app，而不是在mysite/mysite/里面，这里引用的mysite.books也应该改成books，而这些，也跟官网上说的基本相符，可以参考一下这里：https://docs.djangoproject.com/en/1.6/intro/tutorial01/#creating-models
Your apps can live anywhere on your Python path. In this tutorial, we’ll create our poll app right next to your manage.py file so that it can be imported as its own top-level module, rather than a submodule of mysite. 注意这句
CommandError: App 'books' has migrations. Only the sqlmigrate and sqlflush comma nds can be used when an app has migrations. 我改成了<'books',>为啥会出现上述这个问题
Python2.7.11+ Django1.9.1 不需要再进行注释。如果注释的话，会报“App books could not be found”的错误。直接在INSTALLED_APP中添加books即可。
You should not comment settings in "INSTALLED_APPS" or the compiler will reject you with "RuntimeError: Model class django.contrib.contenttypes.models.ContentType doesn't declare an explicit app_label and isn't in an application in INSTALLED_APPS." Also, you should use python manage.py check instead of validate.
django3 只需往install_app 中添加'books.apps.PollsConfig'即可，其余都不用改，还有一点，在创建好app后，应当先运行python manage.py migrate来进行迁移
上面写错了，不是books.apps.PollsConfig，而是books.apps.booksConfig，这是因为，在django3中，当运行完python manage.py startapp books后，Django会自动在books文件夹下创建一个apps.py，里面只有一个类，类名为booksConfig
说说为什么是books.apps.BooksConfig？首先“books”是我们创建的app名字，“apps”就是books文件夹下的apps.py文件，而BooksConfig就是apps.py里面已经创建好的一个类
(就像我们在上一章设置TEMPLATE_DIRS所提到的逗号，同样在INSTALLED_APPS的末尾也需添加一个逗号，因为这是个单元素的元组。 另外，本书的作者喜欢在 每一个 tuple元素后面加一个逗号，不管它是不是 只有一个元素。 这是为了避免忘了加逗号，而且也没什么坏处。)
'mysite.books'指示我们正在编写的books app。 INSTALLED_APPS 中的每个app都使用 Python的路径描述，包的路径，用小数点“.”间隔。
现在我们可以创建数据库表了。 首先，用下面的命令验证模型的有效性：
python manage.py validate这里我运行validate之后，提示No module named adminmysite.books.我数据库是直接添加的一个空文件，是需要在xx.db中写入数据吗？
把上文中settings.py中的模型名‘mysite.books'改成'books'即可通过认证，因为你的模型文件夹实在当前目录下而不是mysite目录下
我定义了一个浮点型字段 V01000 =models.FloatField(max_digits=10,decimal_places=4) 报错TypeError: __init__() got an unexpected keyword argument 'max_digits' 希望能看一下附录，解释浮点型的定义规范，谢谢
我的提示： UnicodeDecodeError: 'ascii' codec can't decode byte 0xb2 in position 20: ordinal not in range(128)，请问是什么原因啊
no modul?我也出现了这个问题,看后面mysite.books再加上整个文件系统布局,我考虑应该把app创建在mysite里,即存在urls.py的同级目录下,而不是跟manage.py同级的目录;不知道理解对否
我也是这个提示： UnicodeDecodeError: 'ascii' codec can't decode byte 0xb2 in position 20: ordinal not in range(128)，谁知道是什么原因啊？
配置文件顶部少了编码格式声明 #coding:utf-8 UnicodeDecodeError: 'ascii' codec can't decode 然后运行时候出错了，今天把这个记录一下，为有可能出同样错误的coder提醒下下
1.7版本的，可能有人会出现下面的错误： System check identified some issues: WARNINGS: ?: (1_6.W001) Some project unittests may not execute as expected. HINT: Django 1.6 introduced a new default test runner. It looks like this project was generated using Django 1.5 or earlier. You should ensure your tests are all running & behaving as expected. See https://docs.djangoproject.com/en/dev/releases/1.6/#new-test-runner for more information. 在setting里面加入TEST_RUNNER = 'django.test.runner.DiscoverRunner'
django 版本1.6 这边显示"validate" has been deprecated in favor of "check". 貌似validate已经过时
django.db.utils.OperationalError: (1049, "Unknown database 'books'") 这个是什么情况，有人遇到吗
按上面的写会报错：RuntimeError: Model class django.contrib.contenttypes.models.ContentType doesn't declare an explicit app_label and isn't in an application in INSTALLED_APPS. 把INSTALLED_APPS 和 MIDDLEWARE_CLASSES取消注释解决
validate已经被弃用，改为check. RemovedInDjango19Warning: "validate" has been deprecated in favor of "check". ---------- >>>python manage.py check System check identified no issues (0 silenced).→出现这样的结果就是没有问题。
按上面的写会报错：RuntimeError: Model class django.contrib.contenttypes.models.ContentType doesn't declare an explicit app_label and isn't in an application in INSTALLED_APPS. 把INSTALLED_APPS 和 MIDDLEWARE_CLASSES取消注释解决 --------------------------------------------------------- 那他这样做与你这样做 会出现矛盾的吧？
按上面的写会报错：RuntimeError: Model class django.contrib.contenttypes.models.ContentType doesn't declare an explicit app_label and isn't in an application in INSTALLED_APPS. 把INSTALLED_APPS 和 MIDDLEWARE_CLASSES取消注释解决 --------------------------------------------------------- 这样做的话 会导致下面自动创建表时会出现很多其他表
python manage.py validate 会显示 unknown command ‘validate’ 要使用 python manage.py check 才行 评论区 真实帮了大忙了 感谢大家的分享讨论
按上面的写会报错：RuntimeError: Model class django.contrib.contenttypes.models.ContentType doesn't declare an explicit app_label and isn't in an application in INSTALLED_APPS. 把INSTALLED_APPS 和 MIDDLEWARE_CLASSES取消注释解决 --------------------------------------------------------- 1.9版本，INSTALLED_APPS里面的东西不注释会出现上面的错误，注释 了在后面会生成很多其他的表格，怎么解决？
1, 如果你用的Django 1.10， 那么不需要注释掉 APP 跟 MIDDLEWARE，直接在APP里加个 'books' 即可 2，不是 python manage.py validate，而是 python manage.py check
1、mysite.boos改为books否则报错。 2、settings设置中INSTALLED_APPS MIDDLEWARE的默认内容不要注销，否则也会报错。 3、validate改为check。
1.11版本django 不要添加MIDDLEWARE_CLASSES = (****)这个 在INSTALLED_APPS的最后一行添加'books',即可 执行python manage.py check
使用pycharm创建的django项目，并且在创建项目的时候，创建app，比如创建一个blog的app，会自动在app列表创建 'blog.apps.BlogConfig',，使用Python manage.py check 进行检查，其他的几个不要注释掉，就不会报错了， 这种学习方式太牛逼了，学成一定要做一个这样的，太牛逼了。直接搞一个完整的项目，来进行分析学习
使用django2的童鞋，外键那里应改为 publisher = models.ForeignKey(Publisher,on_delete=models.CASCADE,)
validate 命令检查你的模型的语法和逻辑是否正确。 如果一切正常，你会看到 0 errors found 消息。如果出错，请检查你输入的模型代码。 错误输出会给出非常有用的错误信息来帮助你修正你的模型。
new version Django,result is like this: python manage.py check System check identified no issues (0 silenced).
django1.11+py3.5========== python manage.py check 回复System check identified no issues (0 silenced).
一旦你觉得你的模型可能有问题，运行 python manage.py validate 。 它可以帮助你捕获一些常见的模型定义错误。
模型确认没问题了，运行下面的命令来生成 CREATE TABLE 语句（如果你使用的是Unix，那么可以启用语法高亮）：
python manage.py sqlall booksnew version django 1.4.2 use the new command to maked the sql python manage.py sql books
我的目录结构 E:\mysite\books （app） E:\mysite\manage.py E:\mysite\mysite (mysite下包含settings.py) books app和mysite的module是同一个层级 我在E:\mysite\mysite的settings.py里设置MIDDLEWARE_CLASSES = ( 'books', ) 运行python manage.py validate 没问题 运行python manage.py sqlall books 报错 错误信息：CommandError: App with label books could not be found. Are you sure your INSTALLED_APPS setting is correct? 参照了各位的评注，还是没解决，大家有没有比较详细的解决办法，谢谢了。
不好意思，上面的INSTALLED_APPS = ( # 'django.contrib.auth', # 'django.contrib.contenttypes', # 'django.contrib.sessions', # 'django.contrib.sites', # 'django.contrib.messages', # 'django.contrib.staticfiles', # Uncomment the next line to enable the admin: # 'django.contrib.admin', # Uncomment the next line to enable admin documentation: # 'django.contrib.admindocs', 'books', )应该设置在这里的，已经ok了。
CommandError: Django doesn't know which syntax to use for your SQL statements, because you haven't properly specified the ENGINE setting for the database. see: https://docs.djangoproject.com/en/dev/ref/settings/#databases 这是什么情况？我没安装数据库么。。。。
执行语句之后报错：django.db.utils.OperationError: unable to open database file 将setting中的DATABASE的name改成： 'NAME': './database.db3', 成功执行。 好奇怪的现象
需要新命令 python manage.py makemigrations books https://docs.djangoproject.com/en/dev/intro/tutorial01/
新版这里应该使用 python manage.py makemigrations books python manage.py sqlmigrate books 0001 python manage.py migrate
Django 1.7 要用python manage.py makemigrations books 和python manage.py sqlmigrate books 0001
完整的写法: 1 python manage.py sqlmigrate books 2 python manage.py sqlmigrate books 0001 3 python manage.py migrate
python manage.py sqlmigrate books 0001 这里的0001是怎么回事；而且我生成的表里面有一个django_migrations表 ？为什么
1.7后先用python manage.py makemigrations books 根据显示的编号比如（0001）python manage.py sqlmigrate 0001
django1.7 下方法有改变 1，在添加了新的 app 之后，我们需要运行下面命令告诉 Django 你的模型做了改变，需要迁移数据库： python manage.py makemigrations books 2，运行下面语句，你可以查看迁移的 sql 语句： python manage.py sqlmigrate polls 0001 3，你可以运行下面命令，来检查数据库是否有问题： python manage.py check 4，运行下面的命令，来创建新添加的模型 python manage.py migrate
求大神指点，在输入python manage.py sqlall books出错如下： django.db.utils.OperationalError: (1045, "Access denied for user 'root'@'localhost' (using password: YES)")。
CommandError: App 'books' has migrations. Only the sqlmigrate and sqlflush commands can be used when an app has migrations. 出现这个是什么情况？？输入的是： python manage.py sqlall books
django1.7 前两条命令 1 python manage.py sqlmigrate books 2 python manage.py sqlmigrate books 0001 都正常执行，第三条命令 python manage.py migrate 报错 django.db.utils.ProgrammingError:(1064,"You have an error in your SQL syntax check the manual that corresponds to your MySQL server version for the right syntax to near '%s, %s, %s)' at line 1" 语法错误？版本mysql5.1.73 求教
sqlall 语句貌似已经过期了 官方文档中有写需要其他指令来执行了 python manage.py makemigrations books 然后再执行下面的语句 python manage.py sqlmigrate books 0001 即可
[root@xzm-centos-2 mysite]# python manage.py sqlall books CommandError: App 'books' has migrations. Only the sqlmigrate and sqlflush commands can be used when an app has migrations. 解决输入 python manage.py sqlmigrate books 0001
sqlall指令已经过期，改为， 第一步，迁移数据库：python manage.py makemigrations books 第二步，创建数据库表： python manage.py sqlmigrate books 0001
然后就会自动生成下面五张表， CREATE TABLE "books_author" CREATE TABLE "books_book" CREATE TABLE "books_book_authors" CREATE TABLE "books_publisher" CREATE TABLE "books_book__new" CREATE INDEX "books_book_2604cbea" ON "books_book" ("publish er_id");
win10 64位 python2.7 django1.9 亲测有用 第一步 python manage.py makemigrations books 第二步 python mange.py sqlmigrate books 0001 第三步 python manage.py migrate 评论简直太有用了
CommandError: App 'books' has migrations. Only the sqlmigrate and sqlflush commands can be used when an app has migrations. 怎么解决
1.9.5版本 python manage.py makemigrations 用来检测数据库变更和生成数据库迁移文件 python manage.py sqlmigrate demo 0001_initial 用来把数据库迁移文件转换成数据库语言 python manage.py migrate 用于执行迁移动作
求大神指点一下，django1.5.12 执行python manage.py sqlall books 报错是：Django doesn't know which syntax to use for your SQL statements,bacause you haven't properly specified the ENGINE setting for the database.怎么办
关于自己manage.py到底支持那种写法，可以用【python manage.py help >>d:\a.txt】。【>>d:\a.txt】是复制到XX地方，该文档时manage可支持的所有写法。
python3 manage.py makemigrations books python3 manage.py migrate books 这两句可以生成之前定义好的table 如果不知道新版的命令可以这样查： python3 manage.py help
python manage.py sqlall books报错： 这是因为旧版本和新的版本命令已经不一样 的问题。 我用的是django =1.8.3, 写好自己的model以后可以换成这样的命令来生成数据库表： python manage.py makemigrations books搜索 然后：python manage.py sqlmigrate books 0001 这样就可以CREATE TABLE 了
看到上面的评论中有： 1 python manage.py sqlmigrate books 2 python manage.py sqlmigrate books 0001 3 python manage.py migrate 我只执行了1和3也能生成数据表，具体原因不明...
django1.9 亲测有用 第一步 python manage.py makemigrations books 第二步 python mange.py sqlmigrate books 0001 第三步 python manage.py migrate 评论简直太有用了 通过运行，这次代码中是要新建了三个表，分别是1：Publisher 出版商 2：Author作者 3：Book书名 ，但是实际中会创建4个表，因为在book里面有一个对应关系表
django 1.11， python manage.py validate改为python manage.py check;python manage.py sqlall books改为python manage.py makemigration books
django2.0 亲测有用 第一步 python manage.py makemigrations books 第二步 python mange.py sqlmigrate books 0001 第三步 python manage.py migrate
django2.2+Python3.6 运行 python manage.py makemigrations books 出现错误：AttributeError: 'str' object has no attribute 'decode'。此时需要将/django/db/backends/mysql/operations.py中的这句 query = query.decode(errors='replace')改为 query = query.encode(errors='replace')。也就是将decode改为encode！
报错无sqlall，看了ls们的解释，逐个运行以下可解 python manage.py makemigrations books python manage.py migrate python manage.py sqlmigrate 0001
Django2.0 数据库迁移的两大命令： python manage.py makemigrations & python manage.py migrate 前者是将model层转为迁移文件migration，后者将新版本的迁移文件执行，更新数据库。 这两中命令调用默认为全局，即对所有最新更改的model或迁移文件进行操作。如果想对部分app进行操作，就要在其后追加app name python manage.py makemigrations app_name python manage.py migrate app_name 如果想要精确到某个迁移文件(0004_xxx.py)： python manage.py migrate app_name 0004
python manage.py check 命令检查项目模型的语法和逻辑是否正确 0、查看manage.py的指令 python manage.py help 1，在添加了新的 app 之后，我们需要运行下面命令告诉 Django 你的模型做了改变，需要迁移数据库： python manage.py makemigrations books 2，运行下面语句，你可以查看迁移的 sql 语句： python manage.py sqlmigrate polls 0001 3，你可以运行下面命令，来检查数据库是否有问题： python manage.py check 4，运行下面的命令，来创建新添加的模型 python manage.py migrate
django3,python manage.py sqlmigrate books 0001 books 是你的应用名称 0001，在执行python manage.py makemigrations books后，books/migration文件夹下有个py文件0001.initial.py
django3：在python manage.py makemigrations books后必须执行 python manage.py migrate，不然无法创建数据库表
在这个命令行中， books 是app的名称。 和你运行 manage.py startapp 中的一样。执行之后，输出如下：
BEGIN;
CREATE TABLE "books_publisher" (
"id" serial NOT NULL PRIMARY KEY,
"name" varchar(30) NOT NULL,
"address" varchar(50) NOT NULL,
"city" varchar(60) NOT NULL,
"state_province" varchar(30) NOT NULL,
"country" varchar(50) NOT NULL,
"website" varchar(200) NOT NULL
)
;
CREATE TABLE "books_author" (
"id" serial NOT NULL PRIMARY KEY,
"first_name" varchar(30) NOT NULL,
"last_name" varchar(40) NOT NULL,
"email" varchar(75) NOT NULL
)
;
CREATE TABLE "books_book" (
"id" serial NOT NULL PRIMARY KEY,
"title" varchar(100) NOT NULL,
"publisher_id" integer NOT NULL REFERENCES "books_publisher" ("id") DEFERRABLE INITIALLY DEFERRED,
"publication_date" date NOT NULL
)
;
CREATE TABLE "books_book_authors" (
"id" serial NOT NULL PRIMARY KEY,
"book_id" integer NOT NULL REFERENCES "books_book" ("id") DEFERRABLE INITIALLY DEFERRED,
"author_id" integer NOT NULL REFERENCES "books_author" ("id") DEFERRABLE INITIALLY DEFERRED,
UNIQUE ("book_id", "author_id")
)
;
CREATE INDEX "books_book_publisher_id" ON "books_book" ("publisher_id");
COMMIT;为什么我生成的不一样,多了alter这块 BEGIN; CREATE TABLE `books_publisher` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` varchar(30) NOT NULL, `address` varchar(50) NOT NULL, `city` varchar(60) NOT NULL, `state_province` varchar(30) NOT NULL, `country` varchar(50) NOT NULL, `website` varchar(200) NOT NULL ) ; CREATE TABLE `books_author` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `first_name` varchar(30) NOT NULL, `last_name` varchar(40) NOT NULL, `email` varchar(75) NOT NULL ) ; CREATE TABLE `books_book_authors` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `book_id` integer NOT NULL, `author_id` integer NOT NULL, UNIQUE (`book_id`, `author_id`) ) ; ALTER TABLE `books_book_authors` ADD CONSTRAINT `author_id_refs_id_9e7e386` FORE IGN KEY (`author_id`) REFERENCES `books_author` (`id`); CREATE TABLE `books_book` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `title` varchar(100) NOT NULL, `pulisher_id` integer NOT NULL, `publication_date` date NOT NULL ) ; ALTER TABLE `books_book` ADD CONSTRAINT `pulisher_id_refs_id_3a4d8b45` FOREIGN K EY (`pulisher_id`) REFERENCES `books_publisher` (`id`); ALTER TABLE `books_book_authors` ADD CONSTRAINT `book_id_refs_id_30430d9e` FOREI GN KEY (`book_id`) REFERENCES `books_book` (`id`); CREATE INDEX `books_book_58db7374` ON `books_book` (`pulisher_id`); COMMIT;
我用的是sqlite3，执行此命令后返回的最后一行如下： self.connection = Database.connect(**kwargs) sqlite3.OperationalError: unable to open database file
#----------oracle------------- CREATE TABLE "BOOKS_PUBLISHER" ( "ID" NUMBER(11) NOT NULL PRIMARY KEY, "NAME" NVARCHAR2(30), "ADDRESS" NVARCHAR2(50), "CITY" NVARCHAR2(60), "STATE_PROVINCE" NVARCHAR2(30), "COUNTRY" NVARCHAR2(50), "WEBSITE" NVARCHAR2(100) ) ; DECLARE i INTEGER; BEGIN SELECT COUNT(*) INTO i FROM USER_CATALOG WHERE TABLE_NAME = 'BOOKS_PUBLISHER_SQ' AND TABLE_TYPE = 'SEQUENCE'; IF i = 0 THEN EXECUTE IMMEDIATE 'CREATE SEQUENCE "BOOKS_PUBLISHER_SQ"'; END IF; END; / CREATE OR REPLACE TRIGGER "BOOKS_PUBLISHER_TR" BEFORE INSERT ON "BOOKS_PUBLISHER" FOR EACH ROW WHEN (new."ID" IS NULL) BEGIN SELECT "BOOKS_PUBLISHER_SQ".nextval INTO :new."ID" FROM dual; END; / CREATE TABLE "BOOKS_AUTHOR" ( "ID" NUMBER(11) NOT NULL PRIMARY KEY, "FIRST_NAME" NVARCHAR2(30), "LAST_NAME" NVARCHAR2(40), "EMAIL" NVARCHAR2(100) ) ; DECLARE i INTEGER; BEGIN SELECT COUNT(*) INTO i FROM USER_CATALOG WHERE TABLE_NAME = 'BOOKS_AUTHOR_SQ' AND TABLE_TYPE = 'SEQUENCE'; IF i = 0 THEN EXECUTE IMMEDIATE 'CREATE SEQUENCE "BOOKS_AUTHOR_SQ"'; END IF; END; / CREATE OR REPLACE TRIGGER "BOOKS_AUTHOR_TR" BEFORE INSERT ON "BOOKS_AUTHOR" FOR EACH ROW WHEN (new."ID" IS NULL) BEGIN SELECT "BOOKS_AUTHOR_SQ".nextval INTO :new."ID" FROM dual; END; / CREATE TABLE "BOOKS_BOOK_AUTHORS" ( "ID" NUMBER(11) NOT NULL PRIMARY KEY, "BOOK_ID" NUMBER(11) NOT NULL, "AUTHOR_ID" NUMBER(11) NOT NULL REFERENCES "BOOKS_AUTHOR" ("ID") DEFERRABLE INITIALLY DEFERRED, UNIQUE ("BOOK_ID", "AUTHOR_ID") ) ; DECLARE i INTEGER; BEGIN SELECT COUNT(*) INTO i FROM USER_CATALOG WHERE TABLE_NAME = 'BOOKS_BOOK_AUTHORS_SQ' AND TABLE_TYPE = 'SEQUENCE'; IF i = 0 THEN EXECUTE IMMEDIATE 'CREATE SEQUENCE "BOOKS_BOOK_AUTHORS_SQ"'; END IF; END; / CREATE OR REPLACE TRIGGER "BOOKS_BOOK_AUTHORS_TR" BEFORE INSERT ON "BOOKS_BOOK_AUTHORS" FOR EACH ROW
我用的是mysql，django1.4 python manage.py allsql books，命令执行完成后没有在mysql数据库中生成相应的表。手动在mysql中创建books之后，并且将setting.py中讲name 改成books之后，执行也未生成相应的表。
执行之后没有代码生成的，如果前面的检测都通过的话，那可能是你们的models.py的代码没有保存。我就是这样的问题，保存后执行python.manage.py sqlall books.结果和一楼的一样多了内容。没有显示的祝你们好运！
基本一致，但倒数第二行有异CREATE INDEX "books_book_publisher_id" ON "books_book" ("publisher_id");我这里显示的却不是books_book_publisher_id而是books_book_81b79144......这个……
终于成功了(><) 在目录上结构纠结了半天。原来以为是app不应该在和manage.py同一目录，试着删了app。之后cd进mysite\mysite 在这个目录下startapp 结果报错打消了这个疑惑。最后查出反馈“Are you sure your INSTALLED_APPS setting is correct?”的原因——————models.py没有保存…………说多了都是泪
下文提到"sqlall命令并没有在数据库中真正创建数据表，只是把SQL语句段打印出来，这样你可以看到Django究竟会做些什么。 如果你想这么做的话，你可以把那些SQL语句复制到你的数据库客户端执行，或者通过Unix管道直接进行操作或者syncdb命令"。 请大家不要着急= =
books_book_authors这个表里的author_id字段被设置成int类型合适么？ 如果一本书有两个作者的话这个字段的内容会是什么? 我在后台给一本书设置两个作者的时候出现错误提示的应该是类型错误，不知道是不是这个地方的问题
python manage.py makemigrations,这个是生成sql代码，然后再用python manage.py migrate 就可以了，自动成生表。我的数据库是mariadb5.6
CommandError: App 'books' has migrations. Only the sqlmigrate and sqlflush commands can be used when an app has migrations. 我这里需要先把startapp时自动生成的migration目录删除了才能生成sql
@xiaowei 不要运行python manage.py sqlall books这个命令，我的Django 1.8，mysql5.5.结果出现了这个异常CommandError: APP'books' has migrations .Only the sqkmigrate and sqlflush commands can be used when an app has migrations，看之前的评论得到了解决，分别执行python manage.py makemigrations books python manage.py sqlmigrate books 0001 python manage.py migrate这三个命令之后就好了
mysql 5.7依次执行这三个命令，ok了，自动生成表 python manage.py makemigrations books python manage.py sqlmigrate books 0001 python manage.py migrate
这是因为旧版本和新的版本命令已经不一样 的问题。 我用的是django =1.8.3, 写好自己的model以后可以换成这样的命令来生成数据库表： python manage.py makemigrations books 然后：python manage.py sqlmigrate books 0001 这样就可以CREATE TABLE 了。
mysql会生成这些表: +----------------------------+ | Tables_in_mydb01 | +----------------------------+ | auth_group | | auth_group_permissions | | auth_permission | | auth_user | | auth_user_groups | | auth_user_user_permissions | | books_author | | books_book | | books_book_authors | | books_publisher | | django_admin_log | | django_content_type | | django_migrations | | django_session | | t_one | +----------------------------+ 15 rows in set (0.00 sec)
注意：
- 自动生成的表名是app名称（
books）和模型的小写名称 （publisher,book,author)的组合。你可以参考附录B重写这个规则。 - 我们前面已经提到，Django为每个表格自动添加加了一个
id主键， 你可以重新设置它。 - 按约定，Django添加
"_id"后缀到外键字段名。 你猜对了，这个同样是可以自定义的。 - 外键是用
REFERENCES语句明确定义的。 - 这些
CREATE TABLE语句会根据你的数据库而作调整，这样象数据库特定的一些字段例如：（MySQL），auto_increment（PostgreSQL）,serial（SQLite），都会自动生成。integer primary key同样的，字段名称也是自动处理（例如单引号还好是双引号）。 例子中的输出是基于PostgreSQL语法的。
(MySQL)，auto_increment(PostgreSQL),serial(SQLite)，都会自动生成。integer primary key 应为 auto_increment(MySQL),serial(PostgreSQL),integer primary key(SQLite)，都会自动生成
auto_increment (MySQL), serial (PostgreSQL), 或 integer primary key (SQLite) 這樣才是對的
class channel(models.Model): devid = models.ForeignKey(device,db_column='devid');# 设备id
sqlall 命令并没有在数据库中真正创建数据表，只是把SQL语句段打印出来，这样你可以看到Django究竟会做些什么。 如果你想这么做的话，你可以把那些SQL语句复制到你的数据库客户端执行，或者通过Unix管道直接进行操作（例如，python manager.py sqlall books | psql mydb ）。不过，Django提供了一种更为简易的提交SQL语句至数据库的方法： syncdb 命令
python manage.py syncdb报“Your models have changes that are not yet reflected in a migration, and so won't be applied.” 需要先执行“python manage.py makemigrations”
新版本使用 python manage.py migrate,详情请参见这里https://docs.djangoproject.com/en/dev/intro/tutorial01/
先 python manage.py makemigrations 再 python manage.py syncdb 不然下面运行p1.save（）报错 no such table:books_publisher (亲试，python 2.7 django 1.8.4)
1.7之後的版本指令有以下變動 先 python manage.py makemigrations (APP_NAME) #(APP_NAME)沒填則默認對所有APP進行makemigrations 再 python manage.py migrate
1.7版本以上会限制性 python manage.py makemigrations 查看模块的变化 然后在执行 python manage.py migrate 同步这些变化至数据库
1.11里面的用法： python manage.py makemigrations myproject python manage.py migrate myproject
执行这个命令后，将看到类似以下的内容：
Creating table books_publisher
Creating table books_author
Creating table books_book
Installing index for books.Book model顶LZ，books_book_authors也会产生的，是因为book类与Author类是多对多关系，我觉得这个是Django ORM和普通操作SQL数据库很明显的特点，希望能增加进去。
Creating tables ... Creating table books_publisher Creating table books_author Creating table books_book_authors Creating table books_book Installing custom SQL ... Installing indexes ... No fixtures found. ============================== 还没有搞懂 fixtures 是什么 我用的是 sqlite3
Creating tables... Installing custom SQL... Installing indexes... Installed 0 object(s)from no fixture(s) --------------------------------------------------不知道之前哪里出错了。执行syncdb的时候提示这个错误
这是完整的。 BEGIN; CREATE TABLE `books_publisher` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `name` varchar(30) NOT NULL, `address` varchar(50) NOT NULL, `city` varchar(60) NOT NULL, `state_province` varchar(30) NOT NULL, `country` varchar(50) NOT NULL, `website` varchar(200) NOT NULL ) ; CREATE TABLE `books_author` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `first_name` varchar(30) NOT NULL, `last_name` varchar(40) NOT NULL, `email` varchar(75) NOT NULL ) ; CREATE TABLE `books_book_authors` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `book_id` integer NOT NULL, `author_id` integer NOT NULL, UNIQUE (`book_id`, `author_id`) ) ; ALTER TABLE `books_book_authors` ADD CONSTRAINT `author_id_refs_id_9e7e386` FOREIGN KEY (`author_id`) REFERENCES `books_author` (`id`); CREATE TABLE `books_book` ( `id` integer AUTO_INCREMENT NOT NULL PRIMARY KEY, `title` varchar(100) NOT NULL, `publisher_id` integer NOT NULL, `publication_date` date NOT NULL ) ; ALTER TABLE `books_book` ADD CONSTRAINT `publisher_id_refs_id_3a4d8b45` FOREIGN KEY (`publisher_id`) REFERENCES `books_publisher` (`id`); ALTER TABLE `books_book_authors` ADD CONSTRAINT `book_id_refs_id_30430d9e` FOREIGN KEY (`book_id`) REFERENCES `books_book` (`id`); CREATE INDEX `books_book_22dd9c39` ON `books_book` (`publisher_id`); COMMIT;
运行python manage.py syncdb时，到创建索引的时候报错： Creating tables ... Creating table books_publisher Creating table books_author Creating table books_book_authors Creating table books_book Installing custom SQL ... Installing indexes ... Failed to install index for books.Book_authors model: (1, "Can't create/write to file '/tmp/ibEYvdfV' (Errcode: 2)") Failed to install index for books.Book model: (1, "Can't create/write to file '/ tmp/ibDVHHuY' (Errcode: 2)") Installed 0 object(s) from 0 fixture(s) Python版本：2.7.5；Django版本：1.5.2； 数据库：MySQL on a remote Linux server
使用的是PostgreSQL9.2.1，执行完后，最后提示Installed 0 object(s) from 0 fixture(s)。这个是正确还是错误呀？我切换到postgres用户下，psql进去查询了以下，select * from books_book_authors;是由这个表的。
Django1.5生成好多表： Creating tables ... Creating table auth_permission Creating table auth_group_permissions Creating table auth_group Creating table auth_user_groups Creating table auth_user_user_permissions Creating table auth_user Creating table django_content_type Creating table django_session Creating table django_site Creating table books_publisher Creating table books_author Creating table books_book_authors Creating table books_book You just installed Django's auth system, which means you don't have any superusers defined. Would you like to create one now? (yes/no): yes Username (leave blank to use 'administrator'): admin Email address: tyroger@163.com Password: Password (again): Superuser created successfully. Installing custom SQL ... Installing indexes ... Installed 0 object(s) from 0 fixture(s)
执行完 $ python manage.py syncdb 后，会出现以下内容： Creating tables ... Installing custom SQL ... Installing indexes ... Installed 0 object(s) from 0 fixture(s) 数据库是 sqlite3
我的出错。。。不知道原因，求解，感激。 D:\Dropbox\cyproject>python manage.py syncdb Creating tables ... Creating table django_admin_log Traceback (most recent call last): File "manage.py", line 10, in <module> execute_from_command_line(sys.argv) File "e:\python27\lib\site-packages\django\core\management\__init__.py", line 399, in execute_from_command_line utility.execute() File "e:\python27\lib\site-packages\django\core\management\__init__.py", line 392, in execute self.fetch_command(subcommand).run_from_argv(self.argv) File "e:\python27\lib\site-packages\django\core\management\base.py", line 242, in run_from_argv self.execute(*args, **options.__dict__) File "e:\python27\lib\site-packages\django\core\management\base.py", line 285, in execute output = self.handle(*args, **options) File "e:\python27\lib\site-packages\django\core\management\base.py", line 415, in handle return self.handle_noargs(**options) File "e:\python27\lib\site-packages\django\core\management\commands\syncdb.py" , line 107, in handle_noargs cursor.execute(statement) File "e:\python27\lib\site-packages\django\db\backends\util.py", line 69, in e xecute return super(CursorDebugWrapper, self).execute(sql, params) File "e:\python27\lib\site-packages\django\db\backends\util.py", line 53, in e xecute return self.cursor.execute(sql, params) File "e:\python27\lib\site-packages\django\db\utils.py", line 99, in __exit__ six.reraise(dj_exc_type, dj_exc_value, traceback) File "e:\python27\lib\site-packages\django\db\backends\util.py", line 51, in e xecute return self.cursor.execute(sql) File "e:\python27\lib\site-packages\django\db\backends\mysql\base.py", line 12 4, in execute return self.cursor.execute(query, args) File "e:\python27\lib\site-packages\MySQLdb\cursors.py", line 205, in execute self.errorhandler(self, exc, value) File "e:\python27\lib\site-packages\MySQLdb\connections.py", line 36, in defau lterrorhandler raise errorclass, erro
终于折腾好了，换了一个数据库，linux： 可是多了一些东西: D:\Dropbox\cyproject>python manage.py syncdb Creating tables ... Creating table django_admin_log Creating table auth_permission Creating table auth_group_permissions Creating table auth_group Creating table auth_user_groups Creating table auth_user_user_permissions Creating table auth_user Creating table django_content_type Creating table django_session Creating table booksapp_publisher Creating table booksapp_author Creating table booksapp_book_authors Creating table booksapp_book You just installed Django's auth system, which means you don't have any superuse rs defined. Would you like to create one now? (yes/no): y Please enter either "yes" or "no": yes Username (leave blank to use 'administrator'): Email address: xwing@qq.com Password: Password (again): Superuser created successfully. Installing custom SQL ... Installing indexes ... Installed 0 object(s) from 0 fixture(s) D:\Dropbox\cyproject>
MySQL :使用python manage.py syncdb 后出现 installed 0 objects from 0 fixtures。但是查看数据库，里面的表和字段都有了。
Operations to perform: Apply all migrations: books Running migrations: Applying books.0001_initial... OK
显示： /Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/Django-1.8-py3.5.egg/django/core/management/commands/syncdb.py:24: RemovedInDjango19Warning: The syncdb command will be removed in Django 1.9 warnings.warn("The syncdb command will be removed in Django 1.9", RemovedInDjango19Warning) Operations to perform: Apply all migrations: books Running migrations: No migrations to apply. 之后看了数据库确实所table都建好了
syncdb 命令是同步你的模型到数据库的一个简单方法。 它会根据 INSTALLED_APPS 里设置的app来检查数据库， 如果表不存在，它就会创建它。 需要注意的是， syncdb 并 不能将模型的修改或删除同步到数据库；如果你修改或删除了一个模型，并想把它提交到数据库，syncdb并不会做出任何处理。 （更多内容请查看本章最后的“修改数据库的架构”一段。）
在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容在本章的最后，并没有“修改数据库的架构”这部分内容
“修改数据库的架构”： http://django-notes.blogspot.com/2011/07/making-changes-to-database-schema.html
django 1.10.1版本 python manage.py makemigrations books python manage.py migrate 亲测有效。可以看到文件夹migrations里有了0002 里面有修改后的
HINT: MySQL's Strict Mode fixes many data integrity problems in MySQL, such as data truncation upon insertion, by escalating warnings into errors. It is strongly recommended you activate it. See: https://docs.djangoproject.com/en/1.10/ref/databases/#mysql-sql-mode setting中追加 'OPTIONS': { 'init_command' : "SET sql_mode='STRICT_TRANS_TABLES'", }
如果你再次运行 python manage.py syncdb ，什么也没发生，因为你没有添加新的模型或者 添加新的app。因此，运行python manage.py syncdb总是安全的，因为它不会重复执行SQL语句。
如果你有兴趣，花点时间用你的SQL客户端登录进数据库服务器看看刚才Django创建的数据表。 你可以手动启动命令行客户端（例如，执行PostgreSQL的psql 命令），也可以执行 python manage.py dbshell ，这个命令将依据DATABASE_SERVER 的里设置自动检测使用哪种命令行客户端。 常言说，后来者居上。
如果 python manage.py dbshell 运行时提示 sqlite3 不是有效的内部命令*** ， 解决方法是下载一个SQLite3的C语言类库. windows 下可以下载 Precompiled Binaries For Windows （sqlite-shell-win32-x86-3070500.zip）， 解压缩后是sqlite3.exe。 然后将sqlite3.exe所在的路径加到系统环境变量里面去（或者偷懒将sqlite3.exe 放到你安装的python的文件夹下）
db = sqlite3 运行 python manage.py dbshell 提示我没有安装sqlite3或者是没有添加到path。我连sqlite3安装在哪里都不知道，怎么添加sqlite3到path啊？
下面的“基本数据访问”，看不懂了，为什么我输入python manage.py shell进入python shell查看，却看不到Publisher类的name属性呢？
"python manager.py shell"后，查看sys.path中的值，发现path中将第一个mysite的添加了进去，而根据上面的步骤，books貌似是建立在mysite\mysite\中的，所以是否需要这里导入Publisher: from mysite.books.models import Publisher呢？
The latter is almost always more convenient. 是两种方法中，后者（manage.py dbshell）总是较为方便 后来者居上。。。汗-_-
基本数据访问
一旦你创建了模型，Django自动为这些模型提供了高级的Python API。 运行 python manage.py shell 并输入下面的内容试试看：
>>> from books.models import Publisher
>>> p1 = Publisher(name='Apress', address='2855 Telegraph Avenue',
... city='Berkeley', state_province='CA', country='U.S.A.',
... website='http://www.apress.com/')
>>> p1.save()
>>> p2 = Publisher(name="O'Reilly", address='10 Fawcett St.',
... city='Cambridge', state_province='MA', country='U.S.A.',
... website='http://www.oreilly.com/')
>>> p2.save()
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Publisher object>, <Publisher: Publisher object>]如果不想输入python manage.py shell而是直接双击某个文件（把这 段代码拷贝到该文件）中直接保存到数据库怎么执行呢 经测试在你的.py文件前面加上这两句即可（这两句代码拷贝自manage.py） import os,sys os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
>>> from books.models import Publisher Traceback (most recent call last): File "<console>", line 1, in <module> ImportError: cannot import name Publisher 请问此处应该怎么解决？ Mac OS10.9，数据库是 sqlite3 ，Python 2.7.5 ， Django 1.5.4
p1.save() 报错， File "<console>", line 4 ，p1.save()， SyntaxError: invalid syntax ，是什么情况？
为什么我会出现django.db.utils.ProgrammingError: (1146, 表不存在这样的错误呢。 已经用 python manage.py syncdb 创建表了呀
这里的books.models应该是mysite.books.models吧，否则导入不进去 === 看manage.py和books的具体路径了
这里import Publisher，这个Publisher类是从哪来地，没记得创建过这个类啊，数据里面创建地不是books_publisher吗，这个P是小写，要是import publisher（小写）就会报错，没这个类，最后我访问我地数据库，这确实是存在books_publisher里面的，就是不知道这个类从哪来地。
p1.save() 报错 django.db.utils.ProgrammingError:(1064,"You have an error in your SQL syntax;check the manual that corresponds to your MySQL server version for the right syntax to use near '%s,%s,%s,%s,%s,%s)' at line 1") 找了好久，没发现语法错误啊 python3.4.1 + Django1.7 + mysql5.1.73
分析应该是MySQLdb不兼容python3.x的缘故，更换了PyMySQL，问题解决 在 Django 站点的 __init__.py 文件中添加如下两行： importpymysql pymysql.install_as_MySQLdb() 这里也要改一下: DATABASES={ 'default':{ ...... 'PORT':'', 'OPTIONS':{ 'autocommit':True, }, } }
使用xxx.py脚本方式运行（不通过shell命令方式）,以下代码在Django 1.8.4版本下测试通过: # coding: UTF-8 # 在manage.py同级目录下建立一个XXX.py文件 import os import django os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings') # 设置环境变量，myproject为工程名 django.setup() # 导入数据 # 实例：在Publisher下插入一条记录 from books.models import Publisher p1 = Publisher(name='Test', address='address', city='beijing', state_province='Beijing', country='china.', website='http://www.apress.com/') p1.save()
django.core.exceptions.AppRegistryNotReady: Apps aren't loaded yet. import django django.setup()
使用xxx.py脚本方式运行（不通过shell命令方式）,以下代码在Django 1.8.4版本下测试通过: # coding: UTF-8 # 在manage.py同级目录下建立一个XXX.py文件 import os import django os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings') # 设置环境变量，myproject为工程名 django.setup() # 导入数据 # 实例：在Publisher下插入一条记录 from books.models import Publisher p1 = Publisher(name='Test', address='address', city='beijing', state_province='Beijing', country='china.', website='http://www.apress.com/') p1.save() 新来的注意，这个方式是正确的，测试通过
这短短几行代码干了不少的事。 这里简单的说一下：
- 首先，导入Publisher模型类， 通过这个类我们可以与包含 出版社 的数据表进行交互。
- 接着，创建一个
Publisher类的实例并设置了字段name, address等的值。 - 调用该对象的
save()方法，将对象保存到数据库中。 Django 会在后台执行一条INSERT语句。 - 最后，使用
Publisher.objects属性从数据库取出出版商的信息，这个属性可以认为是包含出版商的记录集。 这个属性有许多方法， 这里先介绍调用Publisher.objects.all()方法获取数据库中Publisher类的所有对象。这个操作的幕后，Django执行了一条SQLSELECT语句。
这里有一个值得注意的地方，在这个例子可能并未清晰地展示。 当你使用Django modle API创建对象时Django并未将对象保存至数据库内，除非你调用save() 方法：
p1 = Publisher(...)
# At this point, p1 is not saved to the database yet!
p1.save()
# Now it is.如果需要一步完成对象的创建与存储至数据库，就使用objects.create() 方法。 下面的例子与之前的例子等价：
>>> p1 = Publisher.objects.create(name='Apress',
... address='2855 Telegraph Avenue',
... city='Berkeley', state_province='CA', country='U.S.A.',
... website='http://www.apress.com/')
>>> p2 = Publisher.objects.create(name="O'Reilly",
... address='10 Fawcett St.', city='Cambridge',
... state_province='MA', country='U.S.A.',
... website='http://www.oreilly.com/')
>>> publisher_list = Publisher.objects.all()
>>> publisher_list当然，你肯定想执行更多的Django数据库API试试看，不过，还是让我们先解决一点烦人的小问题。
添加模块的字符串表现
Inline literal start-string without end-string.
Inline literal start-string without end-string.
When we printed out the list of publishers, all we got was this unhelpful display that makes it difficult to tell the Publisher objects apart: @Scar_L ```部分是Publisher，意思是打印出来的信息一样，没法区分两个实例
[<Publisher: Publisher object>, <Publisher: Publisher object>]now it is:<QuerySet [<Publisher: Publisher object>, <Publisher: Publisher object>]>
我们可以简单解决这个问题，只需要为Publisher 对象添加一个方法 __unicode__() 。 __unicode__() 方法告诉Python如何将对象以unicode的方式显示出来。 为以上三个模型添加__unicode__()方法后，就可以看到效果了：
我也发现我下的pdf英文版为__str__但是http://www.djangobook.com/en/2.0/chapter05.html依然为__unicode__
from django.db import models
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 u'%s %s' % (self.first_name, self.last_name)**
class Book(models.Model):
title = models.CharField(max_length=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()
**def __unicode__(self):**
**return self.title****def __unicode__(self):** **return self.name** 害我找半天啊, 干嘛不把 * 换成 + ,至少这个可以表示是增加的
很多RST标记用错了吧? **text** 用于强调的标记用在预编辑的代码块里不起作用的吧? 还有``text``标记, 很多地方搞成了 `` text``(里面多了个空格), 结果原样生成了.
楼上的真是的，人家好心翻译在这里没时间这么久了没维护能不能客气点理解下？你觉得代码有问题你自己去看英文版的代码啊。真不知道你指的是哪个作者，要是原作者，根本就没＊＊，要是指译者，你这G点也太低了。
这里错误有两个情况，第一个**其实是没有必要的，直接去掉，第二个是，如果按照习惯用TAB来缩进，那么在class里面所有的便面的缩进也得修改，直接复制到程序里面是4个空格符，因此这里会出错
1. 函数前面的，**def 的 “**”是多余的，请去掉。 2. 我意外google到了“python函数中定义参数的四种方式”，这个是我之前没有接触过的，分享一下。
星号是肯定要去掉的，大家在看的过程中要是有什么疑问大可以去原文那里对照一下，没必要对劳苦功高的译者吹毛求疵。原文只是加粗了这段代码而已http://www.djangobook.com/en/2.0/chapter05.html
有些网站内嵌的编辑器只支持标准html和markdown语法，但有些编辑器是支持非标准的语法的，比如typora，关闭标准语法后很多模糊的语法也能正确渲染，但是粘贴到网站就挂了
就象你看到的一样， __unicode__() 方法可以进行任何处理来返回对一个对象的字符串表示。 Publisher和Book对象的__unicode__()方法简单地返回各自的名称和标题，Author对象的__unicode__()方法则稍微复杂一些，它将first_name和last_name字段值以空格连接后再返回。
这段翻译为： 就象你看到的一样， __unicode__() 方法可以进行任何处理来返回对一个对象的表示。在这里，Publisher 和Book 的__unicode__() 方法分别返回对象的name和title属性值，而Authoer的__unicode__() 方法则稍微复杂一些，她将first_name 和last_name 字段值以空格连接后再返回。 翻译时，后台会出现500错误。
数据库里面存放了一条中文信息，在shell里面用Publisher.objects.all() 报：ERROR - failed to write data to stream: <open file '<stdout>', mode 'w' at 0x7f528649c1e0> 把这条信息删除了，再次输入 Publisher.objects.all()，就没问题了，中文问题如何解决？
对__unicode__()的唯一要求就是它要返回一个unicode对象 如果__unicode__() 方法未返回一个Unicode对象，而返回比如说一个整型数字，那么Python将抛出一个TypeError 错误，并提示：”coercing to Unicode: need string or buffer, int found” 。
Unicode对象
什么是Unicode对象呢？
你可以认为unicode对象就是一个Python字符串，它可以处理上百万不同类别的字符——从古老版本的Latin字符到非Latin字符，再到曲折的引用和艰涩的符号。
普通的python字符串是经过编码的，意思就是它们使用了某种编码方式（如ASCII，ISO-8859-1或者UTF-8）来编码。 如果你把奇特的字符（其它任何超出标准128个如0-9和A-Z之类的ASCII字符）保存在一个普通的Python字符串里，你一定要跟踪你的字符串是用什么编码的，否则这些奇特的字符可能会在显示或者打印的时候出现乱码。 当你尝试要将用某种编码保存的数据结合到另外一种编码的数据中，或者你想要把它显示在已经假定了某种编码的程序中的时候，问题就会发生。 我们都已经见到过网页和邮件被???弄得乱七八糟。 ?????? 或者其它出现在奇怪位置的字符：这一般来说就是存在编码问题了。
但是Unicode对象并没有编码。它们使用Unicode，一个一致的，通用的字符编码集。 当你在Python中处理Unicode对象的时候，你可以直接将它们混合使用和互相匹配而不必去考虑编码细节。
Django 在其内部的各个方面都使用到了 Unicode 对象。 模型 对象中，检索匹配方面的操作使用的是 Unicode 对象，视图 函数之间的交互使用的是 Unicode 对象，模板的渲染也是用的 Unicode 对象。 通常，我们不必担心编码是否正确，后台会处理的很好。
注意，我们这里只是对Unicode对象进行非常浅显的概述，若要深入了解你可能需要查阅相关的资料。 这是一个很好的起点：http://www.joelonsoftware.com/articles/Unicode.html。
为了让我们的修改生效，先退出Python Shell，然后再次运行 python manage.py shell 进入。（这是保证代码修改生效的最简单方法。）现在Publisher对象列表容易理解多了。
>>> from books.models import Publisher
>>> publisher_list = Publisher.objects.all()
>>> publisher_list
[<Publisher: Apress>, <Publisher: O'Reilly>]貌似我得到的结果依然还是,[<Publisher: Publisher object>, <Publisher: Publisher object>] 什么回事?
如果得不到这个结果。可以关闭python调试窗口。重新运行manage.py shell进行调试。因为先前的操作不会自动检测调整models.py的修改的。
https://docs.djangoproject.com/en/dev/topics/db/queries/#topics-db-queries 这里就有原因，不是_unicode_()而是__unicode__()
我发现了，如果在 py2.7 下面，还有这个 __unicode__ 方法，但是如果换了 py3.3，根本就跟没写一样，估计这个系统方法是被 deprecated 之列。 如果想要达到同样的效果，同样的方法重载一下 __str__ 方法即可（当然前提是在 py3.3 下面）
不是双下滑线的问题，双线单线的区别我了解，我用的是python 3.3，但是__unicode__()在这个版本里面不起作用，后来换了__str__()便可以正确输出了
请确保你的每一个模型里都包含 __unicode__() 方法，这不只是为了交互时方便，也是因为 Django会在其他一些地方用 __unicode__() 来显示对象。
最后， __unicode__() 也是一个很好的例子来演示我们怎么添加 行为 到模型里。 Django的模型不只是为对象定义了数据库表的结构，还定义了对象的行为。 __unicode__() 就是一个例子来演示模型知道怎么显示它们自己。
选择对象 SELECT id, name, address, city, state_province, country, website FROM book_publisher; 这一句SQL得到的结果肯定不是 >>> Publisher.objects.all() [<Publisher: Addison-Wesley>, <Publisher: O'Reilly>, <Publisher: Apress Publishing>]
To image72 ：因为在模型中添加了 __unicode__() ,所以得到的结果是 >>> Publisher.objects.all() [<Publisher: Addison-Wesley>, <Publisher: O'Reilly>, <Publisher: Apress Publishing>]
插入和更新数据
好吧，明白了，用publisher_list = Publisher.objects.all(), publisher_list[0].xxx或publisher_list[1].xxx来修改
你已经知道怎么做了： 先使用一些关键参数创建对象实例，如下：
>>> p = Publisher(name='Apress',
... address='2855 Telegraph Ave.',
... city='Berkeley',
... state_province='CA',
... country='U.S.A.',
... website='http://www.apress.com/')这个对象实例并 没有 对数据库做修改。 在调用save() 方法之前，记录并没有保存至数据库，像这样：
>>> p.save()在SQL里，这大致可以转换成这样：
INSERT INTO books_publisher
(name, address, city, state_province, country, website)
VALUES
('Apress', '2855 Telegraph Ave.', 'Berkeley', 'CA',
'U.S.A.', 'http://www.apress.com/');因为 Publisher 模型有一个自动增加的主键 id ，所以第一次调用 save() 还多做了一件事： 计算这个主键的值并把它赋值给这个对象实例：
>>> p.id
52 # this will differ based on your own data接下来再调用 save() 将不会创建新的记录，而只是修改记录内容（也就是 执行 UPDATE SQL语句，而不是 INSERT 语句）：
>>> p.name = 'Apress Publishing'
>>> p.save()前面执行的 save() 相当于下面的SQL语句：
UPDATE books_publisher SET
name = 'Apress Publishing',
address = '2855 Telegraph Ave.',
city = 'Berkeley',
state_province = 'CA',
country = 'U.S.A.',
website = 'http://www.apress.com'
WHERE id = 52;注意，并不是只更新修改过的那个字段，所有的字段都会被更新。 这个操作有可能引起竞态条件，这取决于你的应用程序。 请参阅后面的“更新多个对象”小节以了解如何实现这种轻量的修改（只修改对象的部分字段）。
竞态条件（race condition），从多进程间通信的角度来讲，是指两个或多个进程对共享的数据进行读或写的操作时，最终的结果取决于这些进程的执行顺序。--internet
竞态条件（race condition），从多进程间通信的角度来讲，是指两个或多个进程对共享的数据进行读或写的操作时，最终的结果取决于这些进程的执行顺序。--internet
UPDATE books_publisher SET
name = 'Apress Publishing'
WHERE id=52;选择对象
当然，创建新的数据库，并更新之中的数据是必要的，但是，对于 Web 应用程序来说，更多的时候是在检索查询数据库。 我们已经知道如何从一个给定的模型中取出所有记录：
>>> Publisher.objects.all()
[<Publisher: Apress>, <Publisher: O'Reilly>]>>> Publisher.objects.all() [<Publisher: Apress>, <Publisher: O'Reilly>, <Publisher: Apress Publishing>]
Publisher.objects.all() [<Publisher: Apress>, <Publisher: O'Reilly>, <Publisher: Apress Publishing>] 怎么不一样？
@guwb:我一开始也想这么更新，但是没成功，想了一下是不行，因为返回的是对象列表，并不是数据库中的数据，就是说publiser_list[0]相当于一个返回的对象，应该不是数据库中的第一项数据了。
@guwb 我用的是Django 1.4，如下： p = Publisher.objects.all() print p[0].name print p[0].website 这样是可以的。
Publisher.objects.all()获取的是所有属于Publisher类也就是模型的实例对象，所以publiser_list[0]应该是第一个实例对象，相当于数据库对象，publiser_list[0].name 就是查询对应表段的值
zsp, 如果是mysql 请确保server 和client 都是utf8 编码， [mysqld] character_set_server = utf8 client端例如phpmyadmin，建立数据库的时候选择utf8_general_ci
这相当于这个SQL语句：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher;注意
注意到Django在选择所有数据时并没有使用 SELECT* ，而是显式列出了所有字段。 设计的时候就是这样： SELECT* 会更慢，而且最重要的是列出所有字段遵循了Python 界的一个信条： 明言胜于暗示。
查了下原文"Notice that Django doesn’t use SELECT * when looking up data and instead lists all fields explicitly. " , "and instead lists all fields explicitly" 翻译成 “而是显式列出了所有字段”，并无不妥，楼上何来的“也没有”？
有关Python之禅(戒律) :-），在Python提示行输入 import this 试试看。
建议分算在评论里不知道网站建设者能看到吗 最好把建议统一收集一下，可以纠正不少错误呢～ 还有就是有疑问想得到解决通过评论的方便反馈很不及时呢，大家还是去论坛什么的吧。
The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those!
让我们来仔细看看 Publisher.objects.all() 这行的每个部分：
首先，我们有一个已定义的模型 Publisher 。没什么好奇怪的： 你想要查找数据， 你就用模型来获得数据。
然后，是objects属性。 它被称为管理器，我们将在第10章中详细讨论它。 目前，我们只需了解管理器管理着所有针对数据包含、还有最重要的数据查询的表格级操作。
最后，还有 all() 方法。这个方法返回返回数据库中所有的记录。 尽管这个对象 看起来 象一个列表（list），它实际是一个 QuerySet 对象， 这个对象是数据库中一些记录的集合。 附录C将详细描述QuerySet。 现在，我们就先当它是一个仿真列表对象好了。
为什么我的web返回的这样的结果： 代码： select_all = Publisher.objects.all() return render_to_response('books.html',{'select_all':select_all}) 结果： 示例 select_all：<QuerySet [<Publisher: Publisher object>, <Publisher: Publisher object>]>.
@Lionel.Shen 建议你去看一下前面的 # Python将对象以unicode的方式显示出来 def __unicode__(self): return self.name
所有的数据库查找都遵循一个通用模式：
e’ll call methods on the manager attached to the model we want to query against.
we’ll call methods on the manager attached to the model we want to query against.
Any database lookup is going to follow this general pattern - we'll call methods on the manager attached to the model we want to query against. 任何对数据库的查询操作都遵循这样的模式：即 调用绑定在该模型上的管理器(objects)的相应方法(如all)。
we’ll call methods on the manager attached to the model we want to query against. 我们将会调用附加在模型（model）管理器（objects）上的方法（methods）再次查询。
我们很少会一次性从数据库中取出所有的数据；通常都只针对一部分数据进行操作。 在Django API中，我们可以使用filter() 方法对数据进行过滤：
>>> Publisher.objects.filter(name='Apress')
[<Publisher: Apress>]这个filter的例子不是太好..... 如果举这个例子的话 应该把前面的__unicode__（）返回多一些数据 个人建议.... 类似select xxxx,xx,xx from books_publisher where name ='Apress' 吧
filter() 根据关键字参数来转换成 WHERE SQL语句。 前面这个例子 相当于这样：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE name = 'Apress';你可以传递多个参数到 filter() 来缩小选取范围：
>>> Publisher.objects.filter(country="U.S.A.", state_province="CA")
[<Publisher: Apress>]多个参数会被转换成 AND SQL从句， 因此上面的代码可以转化成这样：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE country = 'U.S.A.'
AND state_province = 'CA';注意，SQL缺省的 = 操作符是精确匹配的， 其他类型的查找也可以使用：
我用的1.3.1, DATABASE_ENGINE='mysql', 会报DeprecationWarning: Short names for ENGINE in database configurations are deprecated. Prepend default.ENGINE with 'django.db.backends.' 改成DATABASE_ENGINE='django.db.backends.mysql'就好了
>>> Publisher.objects.filter(name__contains="press")
[<Publisher: Apress>]在 name 和 contains 之间有双下划线。和Python一样，Django也使用双下划线来表明会进行一些魔术般的操作。这里，contains部分会被Django翻译成LIKE语句：
这里有一个错误: 如果是用Publisher.objects.filter(name__contains="press") 那么sql语句会是 SELECT id, name, address, city, state_province, country, website FROM books_publisher WHERE name LIKE BINARY '%press%'; 而用icontains就会忽略大小写：...WHERE name LIKE '%press%';
关于 icontains contains 尽在 https://docs.djangoproject.com/en/1.6/topics/db/queries/
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE name LIKE '%press%';其他的一些查找类型有：icontains(大小写无关的LIKE),startswith和endswith, 还有range(SQLBETWEEN查询）。 附录C详细描述了所有的查找类型。
获取单个对象
上面的例子中filter() 函数返回一个记录集，这个记录集是一个列表。 相对列表来说，有些时候我们更需要获取单个的对象， get() 方法就是在此时使用的：
>>> Publisher.objects.get(name="Apress")
<Publisher: Apress>这样，就返回了单个对象，而不是列表（更准确的说，QuerySet)。 所以，如果结果是多个对象，会导致抛出异常：
>>> Publisher.objects.get(country="U.S.A.")
Traceback (most recent call last):
...
MultipleObjectsReturned: get() returned more than one Publisher --
it returned 2! Lookup parameters were {'country': 'U.S.A.'}如果查询没有返回结果也会抛出异常：
>>> Publisher.objects.get(name="Penguin")
Traceback (most recent call last):
...
DoesNotExist: Publisher matching query does not exist.这个 DoesNotExist 异常 是 Publisher 这个 model 类的一个属性，即 Publisher.DoesNotExist。在你的应用中，你可以捕获并处理这个异常，像这样：
try:
p = Publisher.objects.get(name='Apress')
except Publisher.DoesNotExist:
print "Apress isn't in the database yet."
else:
print "Apress is in the database."很不明白，为什么不能直接在filter里面做是否为空的处理呢？django不是尽可能的让程序员少些代码吗？如果说每次都需要写异常捕获那不是多此一举了吗。反正错误肯定是不会需要的！
用异常的好处就是所有调用都不用检查返回值，功能代码部分，只写正常逻辑。不正常的处理全部写在异常捕获块里面，这样是很舒服的。 以前写Win桌面程序每次检查那些API的DWORD返回值都让我非常厌烦，用Java，Python后就从来不返回错误码，任何错误都抛异常。代码变得非常清晰，再也不用一行API调用配个if(0!=result){}
在运行前面的例子中，你可能已经注意到返回的结果是无序的。 我们还没有告诉数据库 怎样对结果进行排序，所以我们返回的结果是无序的。
在你的 Django 应用中，你或许希望根据某字段的值对检索结果排序，比如说，按字母顺序。 那么，使用 order_by() 这个方法就可以搞定了。
>>> Publisher.objects.order_by("name")
[<Publisher: Apress>, <Publisher: O'Reilly>]跟以前的 all() 例子差不多，SQL语句里多了指定排序的部分：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
ORDER BY name;我们可以对任意字段进行排序：
>>> Publisher.objects.order_by("address")
[<Publisher: O'Reilly>, <Publisher: Apress>]
>>> Publisher.objects.order_by("state_province")
[<Publisher: Apress>, <Publisher: O'Reilly>]>>> Publisher.objects.order_by("state_province", "address")
[<Publisher: Apress>, <Publisher: O'Reilly>]我们还可以指定逆向排序，在前面加一个减号 - 前缀：
>>> Publisher.objects.order_by("-name")
[<Publisher: O'Reilly>, <Publisher: Apress>]尽管很灵活，但是每次都要用 order_by() 显得有点啰嗦。 大多数时间你通常只会对某些 字段进行排序。 在这种情况下，Django让你可以指定模型的缺省排序方式：
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 Meta:**
**ordering = ['name']**很明显，排版用的是MarkDown。 正常情况下**xx**被渲染成加粗字体(Ctrl+B)的。但是如果是在代码区块中，**xx**不会被渲染，而是原样输出为**xx**。 已经用MarkdownPad测试。
很明显，排版用的是MarkDown。 正常情况下**xx**被渲染成加粗字体(Ctrl+B)的。但是如果是在代码区块中，**xx**不会被渲染，而是原样输出为**xx**。 已经用MarkdownPad测试。 而且，Markdown官方文档中也有明确说明： 代码区块中，一般的 Markdown 语法不会被转换，像是星号便只是星号，这表示你可以很容易地以 Markdown 语法撰写 Markdown 语法相关的文件。
现在，让我们来接触一个新的概念。 class Meta，内嵌于 Publisher 这个类的定义中（如果 class Publisher 是顶格的，那么 class Meta 在它之下要缩进4个空格－－按 Python 的传统 ）。你可以在任意一个 模型 类中使用 Meta 类，来设置一些与特定模型相关的选项。 在 附录B 中有 Meta 中所有可选项的完整参考，现在，我们关注 ordering 这个选项就够了。 如果你设置了这个选项，那么除非你检索时特意额外地使用了 order_by()，否则，当你使用 Django 的数据库 API 去检索时，Publisher对象的相关返回值默认地都会按 name 字段排序。
这里是排版错误还是? 我没有参考英文版, 但通过django源码和python经验 这里class Meta缩进多了2个吧. class Meta 应该和 def __unicode__(self）是同一缩进级别 虽然一般是4个空格, 但上面的代码默认是使用2个空格 所以文本叙述和代码有冲突
@snyh，没有错。 class Meta 和 def __unicode__(self）二者是同一缩进的，都是4个空格，**只是排版上表示新加的代码，实际录入时不要输入。
我们已经知道如何对数据进行过滤和排序。 当然，通常我们需要同时进行过滤和排序查询的操作。 因此，你可以简单地写成这种“链式”的形式：
>>> Publisher.objects.filter(country="U.S.A.").order_by("-name")
[<Publisher: O'Reilly>, <Publisher: Apress>]order_by查询出来的数据进行[0:20]切片之后就无法再次进行排序了…… 而使用reverse()方法之后得到的结果不是切片之后逆序，而是逆序查询之后再切片…… 这该怎么解决啊……
你应该没猜错，转换成SQL查询就是 WHERE 和 ORDER BY 的组合：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE country = 'U.S.A'
ORDER BY name DESC;mysql> SELECT id, name, address, city, state_province, country, website -> FROM books_publisher -> WHERE country = 'U.S.A' -> ORDER BY name DESC; Empty set (0.01 sec) 输出空集 改用下面的命令则输出正常:
mysql> SELECT id, name, address, city, state_province, country, website -> FROM books_publisher -> WHERE country = 'U.S.A' -> ORDER BY name DESC; Empty set (0.01 sec) 输出空集 改用下面的命令则输出正常: mysql> SELECT id, name, address, city, state_province, country, website -> FROM books_publisher -> WHERE country like '%U%' -> order by name desc; +----+-------------------+-----------------------+-----------+----------------+- --------+-------------------------+ | id | name | address | city | state_province | country | website | +----+-------------------+-----------------------+-----------+----------------+- --------+-------------------------+ | 2 | O'Reilly | 10 Fawcett St. | Cambridge | MA | U.S.A. | http://www.oreilly.com/ | | 3 | Apress Publishing | 2855 Telegraph Ave. | Berkeley | CA | U.S.A. | http://www.apress.com/ | | 1 | Apress | 2855 Telegraph Avenue | Berkeley | CA | U.S.A. | http://www.apress.com/ | +----+-------------------+-----------------------+-----------+----------------+- --------+-------------------------+ 3 rows in set (0.00 sec) 为何?请大师指示?
限制返回的数据
另一个常用的需求就是取出固定数目的记录。 想象一下你有成千上万的出版商在你的数据库里， 但是你只想显示第一个。 你可以使用标准的Python列表裁剪语句：
这里的slice操作应该是针对python的，而不是针对数据库的。也就是说从数据库取的还是一堆数据，只是在python端截取了一部分吧。不知道有没有理解错误？
Publisher.objects.order_by('name')[1] 如果是這樣呢，是否代表 SELECT id, name, address, city, state_province, country, website FROM books_publisher ORDER BY name OFFSET 2 LIMIT 1; 我看會跑，但是官方文件似乎沒有特別說明這點 還是有語法可以看這行執行的SQL?
>>> Publisher.objects.order_by('name')[0]
<Publisher: Apress>这相当于：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
ORDER BY name
LIMIT 1;>>> Publisher.objects.order_by('name')[0:2]这个例子返回两个对象，等同于以下的SQL语句：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
ORDER BY name
OFFSET 0 LIMIT 2;注意，不支持Python的负索引(negative slicing)：
>>> Publisher.objects.order_by('name')[-1]
Traceback (most recent call last):
...
AssertionError: Negative indexing is not supported.虽然不支持负索引，但是我们可以使用其他的方法。 比如，稍微修改 order_by() 语句来实现：
>>> Publisher.objects.order_by('-name')[0]更新多个对象
在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会更新一行里的所有列。 而某些情况下，我们只需要更新行里的某几列。
例如说我们现在想要将Apress Publisher的名称由原来的”Apress”更改为”Apress Publishing”。若使用save()方法，如：
>>> p = Publisher.objects.get(name='Apress')
>>> p.name = 'Apress Publishing'
>>> p.save()不能用Publisher.objects.get(name='Apress').name = 'Apress Publishing' Publisher.objects.get(name='Apress').save()更新对象。为什么？
@yaoxiao16 可以直接使用 Publisher.objects.filter(name="Apress").update(name="Apress publishing"). 这样就不用创建对象的引用了
这等同于如下SQL语句：
SELECT id, name, address, city, state_province, country, website
FROM books_publisher
WHERE name = 'Apress';
UPDATE books_publisher SET
name = 'Apress Publishing',
address = '2855 Telegraph Ave.',
city = 'Berkeley',
state_province = 'CA',
country = 'U.S.A.',
website = 'http://www.apress.com'
WHERE id = 52;（注意在这里我们假设Apress的ID为52）
在这个例子里我们可以看到Django的save()方法更新了不仅仅是name列的值，还有更新了所有的列。 若name以外的列有可能会被其他的进程所改动的情况下，只更改name列显然是更加明智的。 更改某一指定的列，我们可以调用结果集（QuerySet）对象的update()方法： 示例如下：
>>> Publisher.objects.filter(id=52).update(name='Apress Publishing')与之等同的SQL语句变得更高效，并且不会引起竞态条件。
UPDATE books_publisher
SET name = 'Apress Publishing'
WHERE id = 52;update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录。 以下示例演示如何将所有Publisher的country字段值由’U.S.A’更改为’USA’：
p.update(country='USA') AttributeError: 'Publisher' object has no attribute 'update'
@hLongQ 跟上面一样，用filter把country='U.S.A'的过滤出来，update一下。Publisher.objects.filter(country ='U.S.A').update(country ='USA')
只有结果集拥有update方法，单个对象则没有这个方法。比如Publisher.objects.get(name='Apress').update(country='USA')会报错。
>>> Publisher.objects.get(name='Apress').update(country='USA') Traceback (most recent call last): File "<console>", line 1, in <module> AttributeError: 'Publisher' object has no attribute 'update' 运行结果放下面
>>> Publisher.objects.all().update(country='USA')
2update()方法会返回一个整型数值，表示受影响的记录条数。 在上面的例子中，这个值是2。
删除对象
删除数据库中的对象只需调用该对象的delete()方法即可：
>>> p = Publisher.objects.get(name="O'Reilly")
>>> p.delete()
>>> Publisher.objects.all()
[<Publisher: Apress Publishing>]同样我们可以在结果集上调用delete()方法同时删除多条记录。这一点与我们上一小节提到的update()方法相似：
说法还是不要说单个，多个。本质是，如filter,all,这些，返回的类型是QuerySet >>> type(Publisher.objects.filter(name ='Crayon')) <class 'django.db.models.query.QuerySet'> 而get的话返回类型是Publisher,是个对象， >>> type(Publisher.objects.get(name ='Crayon')) <class 'books.models.Publisher'>
>>> Publisher.objects.filter(country='USA').delete()
>>> Publisher.objects.all().delete()
>>> Publisher.objects.all()
[]删除数据时要谨慎！ 为了预防误删除掉某一个表内的所有数据，Django要求在删除表内所有数据时显示使用all()。 比如，下面的操作将会出错：
>>> Publisher.objects.delete()
Traceback (most recent call last):
File "<console>", line 1, in <module>
AttributeError: 'Manager' object has no attribute 'delete'而一旦使用all()方法，所有数据将会被删除：
>>> Publisher.objects.all().delete()如果只需要删除部分的数据，就不需要调用all()方法。再看一下之前的例子：
>>> Publisher.objects.filter(country='USA').delete()下一章
通过本章的学习，你应该可以熟练地使用Django模型来编写一些简单的数据库应用程序。 在第十章我们将讨论Django数据库层的高级应用。
一旦你定义了你的模型，接下来就是要把数据导入数据库里了。 你可能已经有现成的数据了，请看第十八章以获得有关如何集成现有数据库的建议。 也可能数据是用户提供的，第七章中还会教你怎么处理用户提交的数据。
有时候，你和你的团队成员也需要手工输入数据，这时候如果有一个基于Web的数据输入和管理的界面就会很有帮助。 下一章将介绍解决手工录入问题的方法——Django管理界面。
the GNU Free Document License Hosting graciously provided by