Django文档翻译：模型参考(Model Reference)

Django文档翻译：模型参考(Model Reference)
翻译者：	木野狐(Neil Chen)
Django 版本：	0.95.1
进度：	未完，持续更新中。
最后更新时间：	2007-2-22

 

---

body,table,td,p,.pre {font-size:9pt; font-family:Arial, Helvetica, sans-serif;} .pre{font-family:"Courier New", Courier, mono; color:navy;} .tran_cn{color:#FF9900; font-weight:bold;} .code{background-color:#CCCCCC; font-size:9pt; font-family:"Courier New", Courier, mono;} .comment{color:#009900;} /* :Author: David Goodger :Contact: goodger@python.org :Date: $Date: 2006-05-21 22:44:42 +0200 (Sun, 21 May 2006) $ :Revision: $Revision: 4564 $ :Copyright: This stylesheet has been placed in the public domain. Default cascading style sheet for the HTML output of Docutils. See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to customize this style sheet. */ /* used to remove borders from tables and images */ .borderless, table.borderless td, table.borderless th { border: 0 } table.borderless td, table.borderless th { /* Override padding for "table.docutils td" with "! important". The right padding separates the table cells. */ padding: 0 0.5em 0 0 ! important } .first { /* Override more specific margin styles with "! important". */ margin-top: 0 ! important } .last, .with-subtitle { margin-bottom: 0 ! important } .hidden { display: none } a.toc-backref { text-decoration: none ; color: black } blockquote.epigraph { margin: 2em 5em ; } dl.docutils dd { margin-bottom: 0.5em } /* Uncomment (and remove this text!) to get bold-faced definition list terms dl.docutils dt { font-weight: bold } */ div.abstract { margin: 2em 5em } div.abstract p.topic-title { font-weight: bold ; text-align: center } div.admonition, div.attention, div.caution, div.danger, div.error, div.hint, div.important, div.note, div.tip, div.warning { margin: 2em ; border: medium outset ; padding: 1em } div.admonition p.admonition-title, div.hint p.admonition-title, div.important p.admonition-title, div.note p.admonition-title, div.tip p.admonition-title { font-weight: bold ; font-family: sans-serif } div.attention p.admonition-title, div.caution p.admonition-title, div.danger p.admonition-title, div.error p.admonition-title, div.warning p.admonition-title { color: red ; font-weight: bold ; font-family: sans-serif } /* Uncomment (and remove this text!) to get reduced vertical space in compound paragraphs. div.compound .compound-first, div.compound .compound-middle { margin-bottom: 0.5em } div.compound .compound-last, div.compound .compound-middle { margin-top: 0.5em } */ div.dedication { margin: 2em 5em ; text-align: center ; font-style: italic } div.dedication p.topic-title { font-weight: bold ; font-style: normal } div.figure { margin-left: 2em ; margin-right: 2em } div.footer, div.header { clear: both; font-size: smaller } div.line-block { display: block ; margin-top: 1em ; margin-bottom: 1em } div.line-block div.line-block { margin-top: 0 ; margin-bottom: 0 ; margin-left: 1.5em } div.sidebar { margin-left: 1em ; border: medium outset ; padding: 1em ; background-color: #ffffee ; width: 40% ; float: right ; clear: right } div.sidebar p.rubric { font-family: sans-serif ; font-size: medium } div.system-messages { margin: 5em } div.system-messages h1 { color: red } div.system-message { border: medium outset ; padding: 1em } div.system-message p.system-message-title { color: red ; font-weight: bold } div.topic { margin: 2em } h1.section-subtitle, h2.section-subtitle, h3.section-subtitle, h4.section-subtitle, h5.section-subtitle, h6.section-subtitle { margin-top: 0.4em } h1.title { text-align: center } h2.subtitle { text-align: center } hr.docutils { width: 75% } img.align-left { clear: left } img.align-right { clear: right } ol.simple, ul.simple { margin-bottom: 1em } ol.arabic { list-style: decimal } ol.loweralpha { list-style: lower-alpha } ol.upperalpha { list-style: upper-alpha } ol.lowerroman { list-style: lower-roman } ol.upperroman { list-style: upper-roman } p.attribution { text-align: right ; margin-left: 50% } p.caption { font-style: italic } p.credits { font-style: italic ; font-size: smaller } p.label { white-space: nowrap } p.rubric { font-weight: bold ; font-size: larger ; color: maroon ; text-align: center } p.sidebar-title { font-family: sans-serif ; font-weight: bold ; font-size: larger } p.sidebar-subtitle { font-family: sans-serif ; font-weight: bold } p.topic-title { font-weight: bold } pre.address { margin-bottom: 0 ; margin-top: 0 ; font-family: serif ; font-size: 100% } pre.literal-block, pre.doctest-block { margin-left: 2em ; margin-right: 2em } span.classifier { font-family: sans-serif ; font-style: oblique } span.classifier-delimiter { font-family: sans-serif ; font-weight: bold } span.interpreted { font-family: sans-serif } span.option { white-space: nowrap } span.pre { white-space: pre } span.problematic { color: red } span.section-subtitle { /* font-size relative to parent (h1..h6 element) */ font-size: 80% } table.citation { border-left: solid 1px gray; margin-left: 1px } table.docinfo { margin: 2em 4em } table.docutils { margin-top: 0.5em ; margin-bottom: 0.5em } table.footnote { border-left: solid 1px black; margin-left: 1px } table.docutils td, table.docutils th, table.docinfo td, table.docinfo th { padding-left: 0.5em ; padding-right: 0.5em ; vertical-align: top } table.docutils th.field-name, table.docinfo th.docinfo-name { font-weight: bold ; text-align: left ; white-space: nowrap ; padding-left: 0 } h1 tt.docutils, h2 tt.docutils, h3 tt.docutils, h4 tt.docutils, h5 tt.docutils, h6 tt.docutils { font-size: 100% } ul.auto-toc { list-style-type: none }

Model reference
模型参考

A model is the single, definitive source of data about your data. It contains the essential fields and behaviors of the data you're storing. Generally, each model maps to a single database table.

The basics:

• Each model is a Python class that subclasses django.db.models.Model.
• Each attribute of the model represents a database field.
• Model metadata (non-field information) goes in an inner class named Meta.
• Metadata used for Django's admin site goes into an inner class named Admin.
• With all of this, Django gives you an automatically-generated database-access API, which is explained in the Database API reference.

A companion to this document is the official repository of model examples. (In the Django source distribution, these examples are in the tests/modeltests directory.)

Quick example

This example model defines a Person, which has a first_name and last_name:

from django.db import models

class Person(models.Model):
    first_name = models.CharField(maxlength=30)
    last_name = models.CharField(maxlength=30)

first_name and last_name are fields of the model. Each field is specified as a class attribute, and each attribute maps to a database column.

The above Person model would create a database table like this:

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

Some technical notes:

• The name of the table, myapp_person, is automatically derived from some model metadata but can be overridden. See Table names below.
  表名 myapp_person 从模型的元数据自动产生，但也可以被重写。
• An id field is added automatically, but this behavior can be overriden. See Automatic primary key fields below.
  id 字段是自动附加的，也可以被重写。
• The CREATE TABLE SQL in this example is formatted using PostgreSQL syntax, but it's worth noting Django uses SQL tailored to the database backend specified in your settings file.

Fields

The most important part of a model -- and the only required part of a model -- is the list of database fields it defines. Fields are specified by class attributes.

Example:

class Musician(models.Model):
    first_name = models.CharField(maxlength=50)
    last_name = models.CharField(maxlength=50)
    instrument = models.CharField(maxlength=100)

class Album(models.Model):
    artist = models.ForeignKey(Musician) # 定义外键
    name = models.CharField(maxlength=100)
    release_date = models.DateField() # 日期字段
    num_stars = models.IntegerField()

Field name restrictions

Django places only two restrictions on model field names:

1. A field name cannot be a Python reserved word, because that would result in a Python syntax error. For example:
   字段名不能是 Python 保留字。

   class Example(models.Model):
       pass = models.IntegerField() # 'pass' is a reserved word!
   

2. A field name cannot contain more than one underscore in a row, due to the way Django's query lookup syntax works. For example:
   字段名不能包含多于一个下划线。因为 Django 的 query 查找语法。

   class Example(models.Model):
       foo__bar = models.IntegerField() 'foo__bar' has two underscores!
   

These limitations can be worked around, though, because your field name doesn't necessarily have to match your database column name. See db_column below.

SQL reserved words, such as join, where or select, are allowed as model field names, because Django escapes all database table names and column names in every underlying SQL query. It uses the quoting syntax of your particular database engine.
SQL 保留字，如 join, where, select，可以被用作模型的字段名。

Field types

Each field in your model should be an instance of the appropriate Field class. Django uses the field class types to determine a few things:

• The database column type (e.g. INTEGER, VARCHAR).
• The widget to use in Django's admin interface, if you care to use it (e.g. type="text">, ).
  The minimal validation requirements, used in Django's admin and in manipulators.

  Here are all available field types:

  AutoField
  自增字段

  An IntegerField that automatically increments according to available IDs. You usually won't need to use this directly; a primary key field will automatically be added to your model if you don't specify otherwise. See Automatic primary key fields.
  是自增的 IntegerField. 一般不需要直接操作它。如果除此之外未指定其他的字段为主键，则自增字段会被设置为主键。

  BooleanField
  布尔型字段

  A true/false field.

  The admin represents this as a checkbox.

  CharField
  字符串型字段

  A string field, for small- to large-sized strings.

  For large amounts of text, use TextField.
  大文本用 TextField.

  The admin represents this as an type="text"> (a single-line input).

  CharField has an extra required argument, maxlength, the maximum length (in characters) of the field. The maxlength is enforced at the database level and in Django's validation.
  CharField 的构造器需要额外提供 maxlength 参数，这是必须的。

  CommaSeparatedIntegerField
  逗号分割的整数字段

  A field of integers separated by commas. As in CharField, the maxlength argument is required.
  和 CharField 一样，必须向其构造器传递 maxlength 参数。

  DateField
  日期字段

  A date field. Has a few extra optional arguments:

  Argument	Description
  auto_now	Automatically set the field to now every time the object is saved. Useful for "last-modified" timestamps. Note that the current date is always used; it's not just a default value that you can override. 当对象被保存时，自动设置为现在时间。可用于表示最后修改时间的时间戳。注意：当前日期总是会被使用，而不是仅仅一个默认值。
  auto_now_add	Automatically set the field to now when the object is first created. Useful for creation of timestamps. Note that the current date is always used; it's not just a default value that you can override. 当对象被初次创建的时候，自动设置为现在时间。可用于表示创建时间的时间戳。注意：当前日期总是被使用，而不仅仅是一个默认值。

  The admin represents this as an type="text"> with a JavaScript calendar and a shortcut for "Today."

  DateTimeField
  时间日期字段

  A date and time field. Takes the same extra options as DateField.
  拥有和 DateField 一样的两个额外选项(auto_now, auto_now_add).

  The admin represents this as two type="text"> fields, with JavaScript shortcuts.

  EmailField

  A CharField that checks that the value is a valid e-mail address. This doesn't accept maxlength.
  能够验证是合法的 email 的 CharField 字段。不接受 maxlength.

  FileField

  A file-upload field.
  文件上传字段

  Has an extra required argument, upload_to, a local filesystem path to which files should be upload. This path may contain strftime formatting, which will be replaced by the date/time of the file upload (so that uploaded files don't fill up the given directory).
  有一个额外的参数，upload_to, 表示一个本地文件路径，用于存放文件。此路径可以包含 strftime 格式化。

  The admin represents this as an type="file"> (a file-upload widget).

  Using a FileField or an ImageField (see below) in a model takes a few steps:
  在模型中使用 FileField 或 ImageField 需要下列步骤：

  1. In your settings file, you'll need to define MEDIA_ROOT as the full path to a directory where you'd like Django to store uploaded files. (For performance, these files are not stored in the database.) Define MEDIA_URL as the base public URL of that directory. Make sure that this directory is writable by the Web server's user account.
     在 settings 文件中，定义 MEDIA_ROOT 为保存上传文件的目录的全路径。
  2. Add the FileField or ImageField to your model, making sure to define the upload_to option to tell Django to which subdirectory of MEDIA_ROOT it should upload files.
     向模型中添加 FileField 或 ImageField 字段。设置 upload_to 选项，指示 Django 将文件上传到 MEDIA_ROOT 的哪个子目录中。
  3. All that will be stored in your database is a path to the file (relative to MEDIA_ROOT). You'll must likely want to use the convenience get__url function provided by Django. For example, if your ImageField is called mug_shot, you can get the absolute URL to your image in a template with {{ object.get_mug_shot_url }}.
     存储于数据库中的是文件的相对路径（相对于目录 MEDIA_ROOT). 可利用 get__url 函数。举例来说，如果 ImageField 字段名为 mug_shot, 则可以在模版中通过 {{ object.get_mug_shot_url }} 字段获取图片的绝对路径。

  FilePathField
  文件路径字段

  A field whose choices are limited to the filenames in a certain directory on the filesystem. Has three special arguments, of which the first is required:
  该字段的值被限制为某个目录下的文件名。它有3个特殊参数，其中第一个参数是必要的。

  Argument	Description
  path	Required. The absolute filesystem path to a directory from which this FilePathField should get its choices. Example: "/home/images". 必填。指向可选的文件名所在目录的名称。如："/home/images".
  match	Optional. A regular expression, as a string, that FilePathField will use to filter filenames. Note that the regex will be applied to the base filename, not the full path. Example: "foo.*/.txt^", which will match a file called foo23.txt but not bar.txt or foo23.gif. 可选。是一个正则表达式，FilePathField 用来过滤文件名。该正则表达式用于文件名的 base 部分，而不是全名。如："foo.*/.txt^", 能够匹配 foo23.txt 而不能匹配 bar.txt 或 foo23.gif.
  recursive	Optional. Either True or False. Default is False. Specifies whether all subdirectories of path should be included. 可选，默认值为 False. 表示 path 的子目录是否包括在内。

  Of course, these arguments can be used together.

  The one potential gotcha is that match applies to the base filename, not the full path. So, this example:
  注意：下列代码中

  FilePathField(path="/home/images", match="foo.*", recursive=True)
  

  ...will match /home/images/foo.gif but not /home/images/foo/bar.gif because the match applies to the base filename (foo.gif and bar.gif).
  能匹配 /home/images/foo.gif 但不匹配 /home/images/foo/bar.gif （因为匹配的是文件名的 base 部分）

  FloatField
  浮点数字段

  A floating-point number. Has two required arguments
  有两个必须的字段 :

  Argument	Description
  max_digits	The maximum number of digits allowed in the number. 数字长度
  decimal_places	The number of decimal places to store with the number. 十进制位的数目，即有效位数

  For example, to store numbers up to 999 with a resolution of 2 decimal places, you'd use:

  models.FloatField(..., max_digits=5, decimal_places=2)
  

  And to store numbers up to approximately one billion with a resolution of 10 decimal places:

  models.FloatField(..., max_digits=19, decimal_places=10)
  

  The admin represents this as an type="text"> (a single-line input).

  ImageField
  图片字段

  Like FileField, but validates that the uploaded object is a valid image. Has two extra optional arguments, height_field and width_field, which, if set, will be auto-populated with the height and width of the image each time a model instance is saved.
  类似于 FileField, 但会验证上传的对象是否为图片。 有两个额外的可选字段：height_field 和 width_field

  Requires the Python Imaging Library.

  IntegerField
  整数字段

  An integer.

  The admin represents this as an type="text"> (a single-line input).

  IPAddressField
  IP 地址字段

  An IP address, in string format (i.e. "24.124.1.30").

  The admin represents this as an type="text"> (a single-line input).

  NullBooleanField
  允许为空的布尔型字段

  Like a BooleanField, but allows NULL as one of the options. Use this instead of a BooleanField with null=True.
  可以用这个字段类型代替设置了 null=True 属性的 BooleanField.

  The admin represents this as a

  box with "Unknown", "Yes" and "No" choices.

PhoneNumberField
电话号码字段

A CharField that checks that the value is a valid U.S.A.-style phone number (in the format XXX-XXX-XXXX).
表示美国电话号码的格式的字段(xxx-xxx-xxxx)

PositiveIntegerField
正整数字段

Like an IntegerField, but must be positive.

PositiveSmallIntegerField
小的正整数字段

Like a PositiveIntegerField, but only allows values under a certain (database-dependent) point.
最大值取决于具体的数据库特性

SlugField

"Slug" is a newspaper term. A slug is a short label for something, containing only letters, numbers, underscores or hyphens. They're generally used in URLs.
"Slug" 是报纸的术语。表示一个短的标签，仅包含字母，数字，下划线或连字符。一般用于 URL 中。

In the Django development version, you can specify maxlength. If maxlength is not specified, Django will use a default length of 50. In previous Django versions, there's no way to override the length of 50.
在 Django 开发版中，可指定 maxlength. 默认的长度是 50. 在低版本的 Django 中，没有办法可以覆盖长度为 50 的限制。

Implies db_index=True.
隐含 db_index=True

Accepts an extra option, prepopulate_from, which is a list of fields from which to auto-populate the slug, via JavaScript, in the object's admin form:
接受一个额外选项 prepopulate_from，用于指示在 admin 表单中的可选值。

models.SlugField(prepopulate_from=("pre_name", "name"))

prepopulate_from doesn't accept DateTimeFields.
prepopulate_from 不接受 DateTimeField 字段

The admin represents SlugField as an type="text"> (a single-line input).

SmallIntegerField
小整数字段

Like an IntegerField, but only allows values under a certain (database-dependent) point.

TextField
大文本字段

A large text field.

The admin represents this as a </span></tt> (a multi-line input).</p> </div> <div id="timefield" class="section"> <h3><tt class="docutils literal"><span class="pre">TimeField</span></tt><br><span class="tran_cn">时间字段</span></h3> <p>A time. Accepts the same auto-population options as <tt class="docutils literal"><span class="pre">DateField</span></tt> and <tt class="docutils literal"><span class="pre">DateTimeField</span></tt>.<br><span class="tran_cn">和 DateField 以及 DateTimeField 一样也有两个时间戳字段。</span></p> <p>The admin represents this as an <tt class="docutils literal"><span class="pre"><input</span> <span class="pre">type="text"></span></tt> with some JavaScript shortcuts.</p> </div> <div id="urlfield" class="section"> <h3><tt class="docutils literal"><span class="pre">URLField</span></tt></h3> <p>A field for a URL. If the <tt class="docutils literal"><span class="pre">verify_exists</span></tt> option is <tt class="docutils literal"><span class="pre">True</span></tt> (default), the URL given will be checked for existence (i.e., the URL actually loads and doesn't give a 404 response).<br><span class="tran_cn">表示 URL 的字段。如果 verify_exists 选项为 True（默认），则会检查 URL 的可用性（比方说，URL 能够加载，并且反馈 404 错误）。</span></p> <p>The admin represents this as an <tt class="docutils literal"><span class="pre"><input</span> <span class="pre">type="text"></span></tt> (a single-line input).</p> </div> <div id="usstatefield" class="section"> <h3><tt class="docutils literal"><span class="pre">USStateField</span></tt><br><span class="tran_cn">两个字母表示的美国州名字段</span></h3> <p>A two-letter U.S. state abbreviation.</p> <p>The admin represents this as an <tt class="docutils literal"><span class="pre"><input</span> <span class="pre">type="text"></span></tt> (a single-line input).</p> </div> <div id="xmlfield" class="section"> <h3><tt class="docutils literal"><span class="pre">XMLField</span></tt><br><span class="tran_cn">XML 字段</span></h3> <p>A <tt class="docutils literal"><span class="pre">TextField</span></tt> that checks that the value is valid XML that matches a given schema. Takes one required argument, <tt class="docutils literal"><span class="pre">schema_path</span></tt>, which is the filesystem path to a RelaxNG schema against which to validate the field.<br><span class="tran_cn">表示 XML 文档的 TextField. 会针对指定的 schema 验证其有效性。接受一个必选参数 schema_path.</span></p> </div> </div> <div id="field-options" class="section"> <h2>Field options</h2> <p>The following arguments are available to all field types. All are optional.<br><span class="tran_cn">下面两个是对所有字段都有效的选项，两者都是可选值。</span></p> <div id="null" class="section"> <h3><tt class="docutils literal"><span class="pre">null</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">True</span></tt>, Django will store empty values as <tt class="docutils literal"><span class="pre">NULL</span></tt> in the database. Default is <tt class="docutils literal"><span class="pre">False</span></tt>.<br><span class="tran_cn">如果为 True, Django 会保存空字符串为 NULL 到数据库，默认是 False.</span> </p> <p>Note that empty string values will always get stored as empty strings, not as <tt class="docutils literal"><span class="pre">NULL</span></tt> -- so use <tt class="docutils literal"><span class="pre">null=True</span></tt> for non-string fields such as integers, booleans and dates.<br><span class="tran_cn">注意空字符串会保存为空字符串，而不是 NULL，所以对于非字符串类型的字段，比如整数，布尔值以及日期，需要设定 null=True.</span> </p> <p>Avoid using <tt class="docutils literal"><span class="pre">null</span></tt> on string-based fields such as <tt class="docutils literal"><span class="pre">CharField</span></tt> and <tt class="docutils literal"><span class="pre">TextField</span></tt> unless you have an excellent reason. If a string-based field has <tt class="docutils literal"><span class="pre">null=True</span></tt>, that means it has two possible values for "no data": <tt class="docutils literal"><span class="pre">NULL</span></tt>, and the empty string. In most cases, it's redundant to have two possible values for "no data;" Django convention is to use the empty string, not <tt class="docutils literal"><span class="pre">NULL</span></tt>.<br><span class="tran_cn">对于基于字符串类型的字段如 CharField, TextField 要避免使用 null. 除非有特别的理由。如果一个基于字符串的字段类型设置了 null=True, 这就意味着有两种可能的值用于表示“没有数据”：NULL 和空字符串。在大多数情况下，用两种值表示没有数据是冗余的，所以 Django 的惯例是使用空字符串，而不是 NULL.</span> </p> </div> <div id="blank" class="section"> <h3><tt class="docutils literal"><span class="pre">blank</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">True</span></tt>, the field is allowed to be blank.<br><span class="tran_cn">如果为 True, 该字段允许留空。</span></p> <p>Note that this is different than <tt class="docutils literal"><span class="pre">null</span></tt>. <tt class="docutils literal"><span class="pre">null</span></tt> is purely database-related, whereas <tt class="docutils literal"><span class="pre">blank</span></tt> is validation-related. If a field has <tt class="docutils literal"><span class="pre">blank=True</span></tt>, validation on Django's admin site will allow entry of an empty value. If a field has <tt class="docutils literal"><span class="pre">blank=False</span></tt>, the field will be required.<br><span class="tran_cn">和 null 的区别：null 是完全相对数据库的概念，而 blank 是对数据校验(validation)而言的。 如果 blank=True, 则 Django 的 admin 后台校验功能会允许空值，否则字段为必填。</span></p> </div> <div id="choices" class="section"> <h3><tt class="docutils literal"><span class="pre">choices</span></tt></h3> <p>An iterable (e.g., a list or tuple) of 2-tuples to use as choices for this field.<br><span class="tran_cn">由二元组的可枚举集合（list 或 tuple 或其他）所代表的字段可选值。</span></p> <p>If this is given, Django's admin will use a select box instead of the standard text field and will limit choices to the choices given.<br><span class="tran_cn">Django 的 admin 会使用下拉框代替文本框，限制可选值的范围。</span> </p> <p>A choices list looks like this:</p> <pre class="code">YEAR_IN_SCHOOL_CHOICES = (<br> ('FR', 'Freshman'),<br> ('SO', 'Sophomore'),<br> ('JR', 'Junior'),<br> ('SR', 'Senior'),<br> ('GR', 'Graduate'),<br>)<br></pre> <p>The first element in each tuple is the actual value to be stored. The second element is the human-readable name for the option.<br><span class="tran_cn">每个 tuple 的第一个元素是选项值，第二个是方便阅读的选项名称。</span> </p> <p>The choices list can be defined either as part of your model class:<br><span class="tran_cn">可选值的列表可以定义在模型类里面：</span></p> <pre class="code">class Foo(models.Model):<br> GENDER_CHOICES = (<br> ('M', 'Male'),<br> ('F', 'Female'),<br> )<br> gender = models.CharField(maxlength=1, choices=GENDER_CHOICES)<br></pre> <p>or outside your model class altogether:<br><span class="tran_cn">也可以定义在外部：</span></p> <pre class="code">GENDER_CHOICES = (<br> ('M', 'Male'),<br> ('F', 'Female'),<br>)<br>class Foo(models.Model):<br> gender = models.CharField(maxlength=1, choices=GENDER_CHOICES)<br></pre> <p>Finally, note that choices can be any iterable object -- not necessarily a list or tuple. This lets you construct choices dynamically. But if you find yourself hacking <tt class="docutils literal"><span class="pre">choices</span></tt> to be dynamic, you're probably better off using a proper database table with a <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>. <tt class="docutils literal"><span class="pre">choices</span></tt> is meant for static data that doesn't change much, if ever.<br><span class="tran_cn">最后一点，请注意可选值可以是任意可枚举的对象：不一定要是 list 或 tuple. 这使得我们可以动态的构建选项集合对象。但是，如果你发现你需要动态构建选项列表对象时，也许使用一个外键表会更好，搭配 ForeignKey 字段设定。choices 是为那些几乎从来不发生变化的静态选项集合而设定的。</span></p> </div> <div id="core" class="section"> <h3><tt class="docutils literal"><span class="pre">core</span></tt></h3> <p>For objects that are edited inline to a related object.<br><span class="tran_cn">为了以内联的方式编辑对象，设定到一个关联对象的需要而设定。</span></p> <p>In the Django admin, if all "core" fields in an inline-edited object are cleared, the object will be deleted.<br><span class="tran_cn">在 Django admin 中，如果某个内联编辑(inline-edited) 的对象的所有 "core" 字段都被清空，则该对象会被删除。</span></p> <p>It is an error to have an inline-editable relation without at least one <tt class="docutils literal"><span class="pre">core=True</span></tt> field.<br><span class="tran_cn">如果设定了内联编辑关系，却不设置至少一个 core=True 字段，这是做错误的。</span></p> <p>Please note that each field marked "core" is treated as a required field by the Django admin site. Essentially, this means you should put <tt class="docutils literal"><span class="pre">core=True</span></tt> on all required fields in your related object that is being edited inline.<br><span class="tran_cn">注意，所有被标注为 "core" 的字段都会被 Django Admin 当作必填字段。本质上，这就是说你需要对所有内联编辑的相关对象上加 core=True 字段</span>。</p> </div> <div id="db-column" class="section"> <h3><tt class="docutils literal"><span class="pre">db_column</span></tt></h3> <p>The name of the database column to use for this field. If this isn't given, Django will use the field's name.<br><span class="tran_cn">用于标注对应于字段属性的数据库列名称。如果不提供，则会直接使用字段属性的名称。</span></p> <p>If your database column name is an SQL reserved word, or contains characters that aren't allowed in Python variable names -- notably, the hyphen -- that's OK. Django quotes column and table names behind the scenes.<br><span class="tran_cn">一般可以用这个办法来应付数据库字段和 SQL 保留字冲突的情况，或者和 Python 变量名冲突的情况（比如连字符不允许出现在 Python 变量名中）。</span></p> </div> <div id="db-index" class="section"> <h3><tt class="docutils literal"><span class="pre">db_index</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">True</span></tt>, <tt class="docutils literal"><span class="pre">django-admin.py</span> <span class="pre">sqlindexes</span></tt> will output a <tt class="docutils literal"><span class="pre">CREATE</span> <span class="pre">INDEX</span></tt> statement for this field.<br><span class="tran_cn">如果为 True, django-admin.py sqlindexes 会为此语句输出一个 CREATE INDEX 语句。 </span></p> </div> <div id="default" class="section"> <h3><tt class="docutils literal"><span class="pre">default</span></tt></h3> <p>The default value for the field.<br><span class="tran_cn">字段的默认值</span></p> </div> <div id="editable" class="section"> <h3><tt class="docutils literal"><span class="pre">editable</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">False</span></tt>, the field will not be editable in the admin. Default is <tt class="docutils literal"><span class="pre">True</span></tt>.<br><span class="tran_cn">如果为 False, 该字段在 admin 中不能被编辑。默认是 True.</span> </p> </div> <div id="help-text" class="section"> <h3><tt class="docutils literal"><span class="pre">help_text</span></tt></h3> <p>Extra "help" text to be displayed under the field on the object's admin form. It's useful for documentation even if your object doesn't have an admin form.<br><span class="tran_cn">用于显示在 admin 表单中的额外的帮助信息。即使不使用 admin 表单，这个字段也非常适合与文档功能。</span></p> </div> <div id="primary-key" class="section"> <h3><tt class="docutils literal"><span class="pre">primary_key</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">True</span></tt>, this field is the primary key for the model.<br><span class="tran_cn">如果是 True, 该字段为主键。</span> </p> <p>If you don't specify <tt class="docutils literal"><span class="pre">primary_key=True</span></tt> for any fields in your model, Django will automatically add this field:<br><span class="tran_cn">如果在某个模型中没有设置任何字段为 primary_key=True, 则 Django 会自动生成一个 id 字段：</span> </p> <pre class="code">id = models.AutoField('ID', primary_key=True)<br></pre> <p>Thus, you don't need to set <tt class="docutils literal"><span class="pre">primary_key=True</span></tt> on any of your fields unless you want to override the default primary-key behavior.<br><span class="tran_cn">一般不需要在任何字段上设置 primary_key=True, 除非你要覆盖自动产生 id 的行为。</span> </p> <p><tt class="docutils literal"><span class="pre">primary_key=True</span></tt> implies <tt class="docutils literal"><span class="pre">blank=False</span></tt>, <tt class="docutils literal"><span class="pre">null=False</span></tt> and <tt class="docutils literal"><span class="pre">unique=True</span></tt>. Only one primary key is allowed on an object.<br><span class="tran_cn">primary_key=True 暗示着 blank=False, null=False 并且 unique=True. 一个对象只能有一个主键。</span></p> </div> <div id="radio-admin" class="section"> <h3><tt class="docutils literal"><span class="pre">radio_admin</span></tt></h3> <p>By default, Django's admin uses a select-box interface (<select>) for fields that are <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> or have <tt class="docutils literal"><span class="pre">choices</span></tt> set. If <tt class="docutils literal"><span class="pre">radio_admin</span></tt> is set to <tt class="docutils literal"><span class="pre">True</span></tt>, Django will use a radio-button interface instead.<br><span class="tran_cn">默认情况下，Django admin 用下拉框来选择 ForeignKey 或 choices. 如果设定 radio_admin=True, 则会用但旋钮代替。</span></p> <p>Don't use this for a field unless it's a <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> or has <tt class="docutils literal"><span class="pre">choices</span></tt> set.<br><span class="tran_cn">如果字段不是 ForeignKey 或 choices, 不要用这个属性。</span></p> </div> <div id="unique" class="section"> <h3><tt class="docutils literal"><span class="pre">unique</span></tt></h3> <p>If <tt class="docutils literal"><span class="pre">True</span></tt>, this field must be unique throughout the table.<br><span class="tran_cn">如果为 True, 则该字段值在表中是唯一的。 </span></p> <p>This is enforced at the database level and at the Django admin-form level.<br><span class="tran_cn">这个选项同时约束在数据库级别和 Django admin 表单中。</span><br></p> </div> <div id="unique-for-date" class="section"> <h3><tt class="docutils literal"><span class="pre">unique_for_date</span></tt></h3> <p>Set this to the name of a <tt class="docutils literal"><span class="pre">DateField</span></tt> or <tt class="docutils literal"><span class="pre">DateTimeField</span></tt> to require that this field be unique for the value of the date field.<br><span class="tran_cn">将这个属性值设定为某个 DateField 或 DateTimeField 字段的名称，使得此字段值相关的日期唯一。</span></p> <p>For example, if you have a field <tt class="docutils literal"><span class="pre">title</span></tt> that has <tt class="docutils literal"><span class="pre">unique_for_date="pub_date"</span></tt>, then Django wouldn't allow the entry of two records with the same <tt class="docutils literal"><span class="pre">title</span></tt> and <tt class="docutils literal"><span class="pre">pub_date</span></tt>.<br><span class="tran_cn">举例来说，如果你有个字段 title, 在其上设定了 unique_for_date="pub_date", 那么 Django 就不会允许产生两条 title 和 pub_date 都相同的记录。</span></p> <p>This is enforced at the Django admin-form level but not at the database level.<br><span class="tran_cn">这个限制仅在 Django admin-form 上起作用，而不约束数据库。 </span></p> </div> <div id="unique-for-month" class="section"> <h3><tt class="docutils literal"><span class="pre">unique_for_month</span></tt></h3> <p>Like <tt class="docutils literal"><span class="pre">unique_for_date</span></tt>, but requires the field to be unique with respect to the month.<br><span class="tran_cn">和 unique_for_date 类似，但要求字段相对月份是唯一的。</span></p> </div> <div id="unique-for-year" class="section"> <h3><tt class="docutils literal"><span class="pre">unique_for_year</span></tt></h3> <p>Like <tt class="docutils literal"><span class="pre">unique_for_date</span></tt> and <tt class="docutils literal"><span class="pre">unique_for_month</span></tt>.<br><span class="tran_cn">和 unique_for_date 以及 unique_for_month 类似。</span></p> </div> <div id="validator-list" class="section"> <h3><tt class="docutils literal"><span class="pre">validator_list</span></tt></h3> <p>A list of extra validators to apply to the field. Each should be a callable that takes the parameters <tt class="docutils literal"><span class="pre">field_data,</span> <span class="pre">all_data</span></tt> and raises <tt class="docutils literal"><span class="pre">django.core.validators.ValidationError</span></tt> for errors. (See the validator docs.)<br><span class="tran_cn">针对该字段的一系列额外的验证器的列表。其中每个验证器都应该是 callable, 其参数为 field_data, all_data，错误时抛出的异常为 django.core.validators.ValidationError.</span> </p> <p>Django comes with quite a few validators. They're in <tt class="docutils literal"><span class="pre">django.core.validators</span></tt>.<br><span class="tran_cn">Django 自带了很多验证器，都在 django.core.validators 下。</span> </p> </div> </div> <div id="verbose-field-names" class="section"> <h2>Verbose field names</h2> <p>Each field type, except for <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>, <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> and <tt class="docutils literal"><span class="pre">OneToOneField</span></tt>, takes an optional first positional argument -- a verbose name. If the verbose name isn't given, Django will automatically create it using the field's attribute name, converting underscores to spaces.<br><span class="tran_cn">每个字段，除了 ForeignKey, ManyToManyField 和 OneToOneField 之外，可以接受第一个可选参数：即此字段的描述名称。如果没有提供，Django 会根据属性名称自动创建一个，在此过程中，会把下划线转化为空格。</span></p> <p>In this example, the verbose name is <tt class="docutils literal"><span class="pre">"Person's</span> <span class="pre">first</span> <span class="pre">name"</span></tt>:</p> <pre class="code">first_name = models.CharField("Person's first name", maxlength=30)<br></pre> <p>In this example, the verbose name is <tt class="docutils literal"><span class="pre">"first</span> <span class="pre">name"</span></tt>:</p> <pre class="code">first_name = models.CharField(maxlength=30)<br></pre> <p><tt class="docutils literal"><span class="pre">ForeignKey</span></tt>, <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> and <tt class="docutils literal"><span class="pre">OneToOneField</span></tt> require the first argument to be a model class, so use the <tt class="docutils literal"><span class="pre">verbose_name</span></tt> keyword argument:<br><span class="tran_cn">ForeignKey, ManyToManyField 和 OneToOneField 要求第一个参数是一个 Model 类，因此需要用 verbose_name 这个关键字参数：</span></p> <pre class="code">poll = models.ForeignKey(Poll, verbose_name="the related poll")<br>sites = models.ManyToManyField(Site, verbose_name="list of sites")<br>place = models.OneToOneField(Place, verbose_name="related place")<br></pre> <p>Convention is not to capitalize the first letter of the <tt class="docutils literal"><span class="pre">verbose_name</span></tt>. Django will automatically capitalize the first letter where it needs to.<br><span class="tran_cn">惯例是 verbose_name 的首字母不需要大写。因为 Django 会在需要的时候把它自动转化为大写形式。</span> </p> </div> <div id="relationships" class="section"> <h2>Relationships<br><span class="tran_cn">关系</span></h2> <p>Clearly, the power of relational databases lies in relating tables to each other. Django offers ways to define the three most common types of database relationships: Many-to-one, many-to-many and one-to-one.<br><span class="tran_cn">很显然，关系型数据库的威力就在于表之间的相互关联。Django 提供了办法来定义最常见的三种表间关联的类型：多对一，多对多，一对一。</span></p> <div id="many-to-one-relationships" class="section"> <h3>Many-to-one relationships<br><span class="tran_cn">多对一关联</span></h3> <p>To define a many-to-one relationship, use <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>. You use it just like any other <tt class="docutils literal"><span class="pre">Field</span></tt> type: by including it as a class attribute of your model.<br><span class="tran_cn">要定义多对一关联，使用 ForeignKey. 只要像其他字段类型一样使用它即可：将它定义为 Model 类的一个属性。</span></p> <p><tt class="docutils literal"><span class="pre">ForeignKey</span></tt> requires a positional argument: The class to which the model is related.<br><span class="tran_cn">ForeignKey 需要一个位置确定的参数：和当前 Model 相关联的类。</span></p> <p>For example, if a <tt class="docutils literal"><span class="pre">Car</span></tt> model has a <tt class="docutils literal"><span class="pre">Manufacturer</span></tt> -- that is, a <tt class="docutils literal"><span class="pre">Manufacturer</span></tt> makes multiple cars but each <tt class="docutils literal"><span class="pre">Car</span></tt> only has one <tt class="docutils literal"><span class="pre">Manufacturer</span></tt> -- use the following definitions:<br><span class="tran_cn">举例来说，如果一个汽车（Car）模型对应一个制造商（Manufacturer），也就是说，一个制造商生产多个汽车，但一个汽车只有一个制造商。可以使用如下方式定义这种关系：</span></p> <pre class="code">class Manufacturer(models.Model):<br> # ...<br><br>class Car(models.Model):<br> manufacturer = models.ForeignKey(Manufacturer)<br> # ...<br></pre> <p>To create a recursive relationship -- an object that has a many-to-one relationship with itself -- use <tt class="docutils literal"><span class="pre">models.ForeignKey('self')</span></tt>.<br><span class="tran_cn">如果要创建递归的关系：即一个对象和它自身有多对一的关系，使用 models.ForeignKey('self')</span> </p> <p>If you need to create a relationship on a model that has not yet been defined, you can use the name of the model, rather than the model object itself:<br><span class="tran_cn">如果要创建一个关系，而它所依赖的模型还未被创建，你可以用模型的名称（字符串形式），而不是模型对象自身：</span></p> <pre class="code">class Car(models.Model):<br> manufacturer = models.ForeignKey('Manufacturer')<br> # ...<br><br>class Manufacturer(models.Model):<br> # ...<br></pre> <p>Note, however, that support for strings around model names in <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> is quite new, and it can be buggy in some cases.<br><span class="tran_cn">但是需要注意的是，这种用字符串形式的 ForeignKey 支持是比较新的特性，在某些情况下也许会产生 bug.</span> </p> <p>Behind the scenes, Django appends <tt class="docutils literal"><span class="pre">"_id"</span></tt> to the field name to create its database column name. In the above example, the database table for the <tt class="docutils literal"><span class="pre">Car</span></tt> model will have a <tt class="docutils literal"><span class="pre">manufacturer_id</span></tt> column. (You can change this explicitly by specifying <tt class="docutils literal"><span class="pre">db_column</span></tt>; see <tt class="docutils literal"><span class="pre">db_column</span></tt> below.) However, your code should never have to deal with the database column name, unless you write custom SQL. You'll always deal with the field names of your model object.<br><span class="tran_cn">在幕后，Django 向字段属性名称上附加 "_id" 来构成数据库的列名称。在上面的例子中，数据库中对应于 Car 模型的表会产生一个名为 manufacturer_id 的字段。（你也可以显式的指定它，通过 db_column）。但是，你的代码应该从来不直接处理数据库列名称，除非你要写自定义的 SQL. 你应该总是操作模型对象的字段属性名。</span></p> <p>It's suggested, but not required, that the name of a <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> field (<tt class="docutils literal"><span class="pre">manufacturer</span></tt> in the example above) be the name of the model, lowercase. You can, of course, call the field whatever you want. For example:<br><span class="tran_cn">有一个建议，但不是必须的：ForeignKey 字段的名称（上述例子中的 manufacturer）是对应模型类名称的小写。但你也可以将它取为任意的名称，比如：</span></p> <pre class="code">class Car(models.Model):<br> company_that_makes_it = models.ForeignKey(Manufacturer)<br> # ...<br></pre> <p>See the Many-to-one relationship model example for a full example.</p> <p><tt class="docutils literal"><span class="pre">ForeignKey</span></tt> fields take a number of extra arguments for defining how the relationship should work. All are optional:<br><span class="tran_cn">ForeignKey 字段有一些额外的参数可以定义关系的具体形式，它们都是可选的：</span></p> <blockquote> <table class="docutils" border="1"> <colgroup> <col width="27%"> <col width="73%"> </colgroup> <thead> <tr> <th class="head">Argument</th> <th class="head">Description</th> </tr> </thead> <tbody> <tr> <td><tt class="docutils literal"><span class="pre">edit_inline</span></tt></td> <td>If not <tt class="docutils literal"><span class="pre">False</span></tt>, this related object is edited "inline" on the related object's page. This means that the object will not have its own admin interface. Use either <tt class="docutils literal"><span class="pre">models.TABULAR</span></tt> or <tt class="docutils literal"><span class="pre">models.STACKED</span></tt>, which, respectively, designate whether the inline-editable objects are displayed as a table or as a "stack" of fieldsets.<br><span class="tran_cn">如果不是 False, 则此对象会用内联的形式在相关对象页面直接编辑。这表示此对象没有它自己独立的管理界面。使用 models.TABULAR 或 models.STACKED 来标注，分别表示内联编辑的对象显示为表格还是 fieldsets 的 stack. </span></td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">limit_choices_to</span></tt></td> <td> <p class="first">A dictionary of lookup arguments and values (see the Database API reference) that limit the available admin choices for this object. Use this with <tt class="docutils literal"><span class="pre">models.LazyDate</span></tt> to limit choices of objects by date. For example:<br><span class="tran_cn">一个包含查找参数及其值的字典，用于限制对象可用的 admin choices，和 models.LazyDate 联用，用于按日期限制不同的选项，如：</span></p> <pre class="code">limit_choices_to = {'pub_date__lte': models.LazyDate()}<br></pre> <p>only allows the choice of related objects with a <tt class="docutils literal"><span class="pre">pub_date</span></tt> before the current date/time to be chosen.<br><span class="tran_cn">这个语句使得仅允许选择 pub_date 字段值在当前时间之前的那些日期。</span></p> <p>Instead of a dictionary this can also be a <tt class="docutils literal"><span class="pre">Q</span></tt> object (an object with a <tt class="docutils literal"><span class="pre">get_sql()</span></tt> method) for more complex queries.<br><span class="tran_cn">和字典不同的是，在负责的查询中，这个也可以是一个 Q对象（含有 get_sql() 方法的对象）</span></p> <p class="last">Not compatible with <tt class="docutils literal"><span class="pre">edit_inline</span></tt>.<br><span class="tran_cn">和 edit_inline 不相容。</span></p> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">max_num_in_admin</span></tt></td> <td> <p class="first">For inline-edited objects, this is the maximum number of related objects to display in the admin. Thus, if a pizza could only have up to 10 toppings, <tt class="docutils literal"><span class="pre">max_num_in_admin=10</span></tt> would ensure that a user never enters more than 10 toppings.<br><span class="tran_cn">对于内联编辑的对象，这是显示在 admin 界面中相关对象的最大数目。</span></p> <p class="last">Note that this doesn't ensure more than 10 related toppings ever get created. It simply controls the admin interface; it doesn't enforce things at the Python API level or database level.<br><span class="tran_cn">仅控制 admin 界面，对 Python API 或数据库层次没有限制。</span> </p> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">min_num_in_admin</span></tt></td> <td>The minimum number of related objects displayed in the admin. Normally, at the creation stage, <tt class="docutils literal"><span class="pre">num_in_admin</span></tt> inline objects are shown, and at the edit stage <tt class="docutils literal"><span class="pre">num_extra_on_change</span></tt> blank objects are shown in addition to all pre-existing related objects. However, no fewer than <tt class="docutils literal"><span class="pre">min_num_in_admin</span></tt> related objects will ever be displayed.<span class="tran_cn"><br>在 admin 中显示的内联编辑对象的最少数目。通常，在创建阶段，会显示 num_in_admin 个内联对象，而在编辑阶段显示 num_extra_on_change 个额外的空对象。（排除已有的一些相关对象），然而，少于 min_num_in_admin 个相关对象的从来不被显示。</span> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">num_extra_on_change</span></tt></td> <td>The number of extra blank related-object fields to show at the change stage.<br><span class="tran_cn">对象在修改状态时，显示的额外的空白关联对象的数目。</span></td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">num_in_admin</span></tt></td> <td>The default number of inline objects to display on the object page at the add stage.<br><span class="tran_cn">对象在添加状态时，显示的内联编辑的相关对象数目。</span></td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">raw_id_admin</span></tt></td> <td> <p class="first">Only display a field for the integer to be entered instead of a drop-down menu. This is useful when related to an object type that will have too many rows to make a select box practical.<br><span class="tran_cn">仅显示一个可输入的整数值字段，而不是下拉列表。当关联对象在下拉框里显示会显得太多时，这很有用。</span></p> <p class="last">Not used with <tt class="docutils literal"><span class="pre">edit_inline</span></tt>.<br><span class="tran_cn">不能和 edit_inline 选项一起设定。</span></p> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">related_name</span></tt></td> <td>The name to use for the relation from the related object back to this one. See the related objects documentation for a full explanation and example.<br><span class="tran_cn">设定从关联对象到自身的关系名称。</span></td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">to_field</span></tt></td> <td>The field on the related object that the relation is to. By default, Django uses the primary key of the related object.<br><span class="tran_cn">关联到的对象的字段名称。默认情况下，Django 使用关联对象的主键字段。</span></td> </tr> </tbody> </table> </blockquote> </div> <div id="many-to-many-relationships" class="section"> <h3>Many-to-many relationships<br><span class="tran_cn">多对多关联</span></h3> <p>To define a many-to-many relationship, use <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt>. You use it just like any other <tt class="docutils literal"><span class="pre">Field</span></tt> type: by including it as a class attribute of your model.<br><span class="tran_cn">要定义多对多关联，用 ManyToManyField.</span></p> <p><tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> requires a positional argument: The class to which the model is related.<br><span class="tran_cn">ManyToManyField 需要一个位置确定的参数：关联的模型的类名称。</span></p> <p>For example, if a <tt class="docutils literal"><span class="pre">Pizza</span></tt> has multiple <tt class="docutils literal"><span class="pre">Topping</span></tt> objects -- that is, a <tt class="docutils literal"><span class="pre">Topping</span></tt> can be on multiple pizzas and each <tt class="docutils literal"><span class="pre">Pizza</span></tt> has multiple toppings -- here's how you'd represent that:<br><span class="tran_cn">举例来说，假如一个 Pizza 可以有多个 Topping 对象：也就是说，每个 Topping 可以在多个 pizza 上面，并且每个 Pizza 可以有多个 toppings. 那么你可以用如下的办法来定义模型：</span></p> <pre class="code">class Topping(models.Model):<br> # ...<br><br>class Pizza(models.Model):<br> # ...<br> toppings = models.ManyToManyField(Topping)<br></pre> <p>As with <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>, a relationship to self can be defined by using the string <tt class="docutils literal"><span class="pre">'self'</span></tt> instead of the model name, and you can refer to as-yet undefined models by using a string containing the model name.<br><span class="tran_cn">和 ForeignKey 的设置一样，指向自身的多对多关联，可以用 'self' 来代替模型名称；指向尚未定义的模型时，可以用字符串形式表示。</span> </p> <p>It's suggested, but not required, that the name of a <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> (<tt class="docutils literal"><span class="pre">toppings</span></tt> in the example above) be a plural describing the set of related model objects.<br><span class="tran_cn">建议将 ManyToManyField 设置为复数形式，但这不是必须的。</span></p> <p>Behind the scenes, Django creates an intermediary join table to represent the many-to-many relationship.<br><span class="tran_cn">在幕后，Django 会创建一个中间表来管理多对多关联。 </span></p> <p>It doesn't matter which model gets the <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt>, but you only need it in one of the models -- not in both.<br><span class="tran_cn">在多对多关联的哪一方模型中定义 ManyToManyField 并不重要，但你只需要定义一次，而不是两边都定义。</span></p> <p>Generally, <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> instances should go in the object that's going to be edited in the admin interface, if you're using Django's admin. In the above example, <tt class="docutils literal"><span class="pre">toppings</span></tt> is in <tt class="docutils literal"><span class="pre">Pizza</span></tt> (rather than <tt class="docutils literal"><span class="pre">Topping</span></tt> having a <tt class="docutils literal"><span class="pre">pizzas</span></tt> <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> ) because it's more natural to think about a <tt class="docutils literal"><span class="pre">Pizza</span></tt> having toppings than a topping being on multiple pizzas. The way it's set up above, the <tt class="docutils literal"><span class="pre">Pizza</span></tt> admin form would let users select the toppings.<br><span class="tran_cn">一般的，ManyToManyField 实例在 admin 界面中，会显示在其所属的对象的编辑界面，如果你使用 Django 的 admin 界面的话。在上述例子中，toppings 显示在 Pizza 中，因为，我们说“一个 Pizza 有多个 toppings" 要比 "一个 topping 在多个 pizzas 上面" 来的更自然。按照上面的设置，在 Pizza 的管理界面上将会让你选择 toppings 来编辑。</span></p> <p>See the Many-to-many relationship model example for a full example.</p> <p><tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> objects take a number of extra arguments for defining how the relationship should work. All are optional:<br><span class="tran_cn">ManyToManyField 的一些可选参数：</span> </p> <blockquote> <table class="docutils" border="1"> <colgroup> <col width="28%"> <col width="72%"> </colgroup> <thead> <tr> <th class="head">Argument</th> <th class="head">Description</th> </tr> </thead> <tbody> <tr> <td><tt class="docutils literal"><span class="pre">related_name</span></tt></td> <td>See the description under <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> above.<br><span class="tran_cn">同 ForeignKey 的情形</span> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">filter_interface</span></tt></td> <td>Use a nifty unobtrusive Javascript "filter" interface instead of the usability-challenged <tt class="docutils literal"><span class="pre"><select</span> <span class="pre">multiple></span></tt> in the admin form for this object. The value should be <tt class="docutils literal"><span class="pre">models.HORIZONTAL</span></tt> or <tt class="docutils literal"><span class="pre">models.VERTICAL</span></tt> (i.e. should the interface be stacked horizontally or vertically).<br><span class="tran_cn">在管理界面中，使用好看实用的 JavaScript "filter" 界面代替可用性受到挑战的 <select multiple>. 其值可以是 models.HORIZONTAL 或 models.VERTICAL (指界面排序的方向）。</span> </td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">limit_choices_to</span></tt></td> <td>See the description under <tt class="docutils literal"><span class="pre">ForeignKey</span></tt> above.<br><span class="tran_cn">同 ForeignKey 的情形</span></td> </tr> <tr> <td><tt class="docutils literal"><span class="pre">symmetrical</span></tt><br><span class="tran_cn">对称的</span></td> <td> <p class="first">Only used in the definition of ManyToManyFields on self. Consider the following model:<br><span class="tran_cn">仅在对自身有多对多关联时定义此选项。考虑下列模型：</span></p> <dl class="docutils"> <dt class="code"> class Person(models.Model): </dt> <dd class="code"> friends = models.ManyToManyField("self") </dd> </dl><p>When Django processes this model, it identifies that it has a <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> on itself, and as a result, it doesn't add a <tt class="docutils literal"><span class="pre">person_set</span></tt> attribute to the <tt class="docutils literal"><span class="pre">Person</span></tt> class. Instead, the <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> is assumed to be symmetrical -- that is, if I am your friend, then you are my friend.<br><span class="tran_cn">当 Django 处理这个模型时，它发现 Person 类有一个指向自身的 ManyToManyField 多对多关联，因此，它不会添加 person_set 属性到 Person 类中。相反的是，ManyToManyField 被假定是对称的：也就是说，如果我是你的朋友，则你一定是我的朋友。</span> </p> <p class="last">If you do not want symmetry in <tt class="docutils literal"><span class="pre">ManyToMany</span></tt> relationships with <tt class="docutils literal"><span class="pre">self</span></tt>, set <tt class="docutils literal"><span class="pre">symmetrical</span></tt> to <tt class="docutils literal"><span class="pre">False</span></tt>. This will force Django to add the descriptor for the reverse relationship, allowing <tt class="docutils literal"><span class="pre">ManyToMany</span></tt> relationships to be non-symmetrical.<br><span class="tran_cn">如果你不想把指向自身的多对多关联定义为对称的，设置 symmetrical=False 即可。这会让 Django 为反向关系添加 descriptor, 已实现不对称的多对多关系。</span> </p> </td> </tr> </tbody> </table> </blockquote> </div> <div id="one-to-one-relationships" class="section"> <h3>One-to-one relationships<br><span class="tran_cn">一对一关联</span></h3> <p>The semantics of one-to-one relationships will be changing soon, so we don't recommend you use them. If that doesn't scare you away, keep reading.<br><span class="tran_cn">在未来的 Django 版本中，一对一关联的语义即将发生变化，因此我们不建议使用一对一关联。如果这没把你吓坏，继续阅读吧。</span></p> <p>To define a one-to-one relationship, use <tt class="docutils literal"><span class="pre">OneToOneField</span></tt>. You use it just like any other <tt class="docutils literal"><span class="pre">Field</span></tt> type: by including it as a class attribute of your model.<br><span class="tran_cn">定义一对一关联使用 OneToOneField 字段即可。</span></p> <p>This is most useful on the primary key of an object when that object "extends" another object in some way.<br><span class="tran_cn">这对于通过和主键建立关联，扩展对象的属性为另一个对象的情形比较有用。</span></p> <p><tt class="docutils literal"><span class="pre">OneToOneField</span></tt> requires a positional argument: The class to which the model is related.<br><span class="tran_cn">一对一字段需要一个位置确定的参数：关联模型的类名称。</span></p> <p>For example, if you're building a database of "places", you would build pretty standard stuff such as address, phone number, etc. in the database. Then, if you wanted to build a database of restaurants on top of the places, instead of repeating yourself and replicating those fields in the <tt class="docutils literal"><span class="pre">Restaurant</span></tt> model, you could make <tt class="docutils literal"><span class="pre">Restaurant</span></tt> have a <tt class="docutils literal"><span class="pre">OneToOneField</span></tt> to <tt class="docutils literal"><span class="pre">Place</span></tt> (because a restaurant "is-a" place).<br><span class="tran_cn">举例来说，如果你在建立一个关于“地点”信息的数据库，那么，你一定会建立一些很标准的信息，比如地址，电话号码等。那么如果你要建立另一个餐馆信息的数据库，而这些餐馆是基于上述“地点”信息的，你不需要通过复制地点信息的相关字段到“餐馆”模型中，而只要让“餐馆“建立到“地点”的一对一关联即可(OneToOneField). （因此“餐馆”是“地点”的一种）。</span> </p> <p>As with <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>, a relationship to self can be defined by using the string <tt class="docutils literal"><span class="pre">"self"</span></tt> instead of the model name; references to as-yet undefined models can be made by using a string containing the model name.<br><span class="tran_cn">和 ForeignKey 的情形一样，指向自身的一对一关联也可以用 "self" 来设定指向的模型名称； 指向尚未定义的模型时，用字符串形式表示。</span></p> <p>This <tt class="docutils literal"><span class="pre">OneToOneField</span></tt> will actually replace the primary key <tt class="docutils literal"><span class="pre">id</span></tt> field (since one-to-one relations share the same primary key), and will be displayed as a read-only field when you edit an object in the admin interface:<br><span class="tran_cn">OneToOneField 会覆盖主键 id 字段（因此一对一关联共享一个主键），并且会在 admin 界面中会显示为一个只读字段。</span></p> <p>See the One-to-one relationship model example for a full example.</p> </div> </div> </div> <div id="meta-options" class="section"> <h1>Meta options</h1> <p>在模型类中添加内嵌的 class Meta 可以定义一些元数据信息：</p> <pre class="literal-block">class Foo(models.Model):<br> bar = models.CharField(maxlength=30)<br><br> class Meta:<br> # ...<br></pre> <p>模型的元数据是除了字段声明之外的其他一些信息，比如排序选项等。</p> <p>下面是所有 Meta 选项的列表，所有都不是必须的。</p> <div id="db-table" class="section"> <h2><tt class="docutils literal"><span class="pre">db_table</span></tt></h2> <p>对应于模型的数据库表的名字：</p> <pre class="literal-block">db_table = 'music_album'<br></pre> <p>如果不给出这个选项，Django 用下列格式自动生成一个表名： <tt class="docutils literal"><span class="pre">app_label</span> <span class="pre">+</span> <span class="pre">'_'</span> <span class="pre">+</span> <span class="pre">model_class_name</span></tt>. 详细的参见下面的 "Table names" 部分。</p> <p>如果你的表名是 SQL 保留字，或者包含 Python 中不允许出现在变量名中的字符（比如连字符），这不要紧。Django 会在背后自动处理表名和列名的转换。</p> </div> <div id="get-latest-by" class="section"> <h2><tt class="docutils literal"><span class="pre">get_latest_by</span></tt></h2> <p>是模型中某个 <tt class="docutils literal"><span class="pre">DateField</span></tt> 或 <tt class="docutils literal"><span class="pre">DateTimeField</span></tt> 字段的名称。用于指定在模型的管理器中 latest() 方法会使用的默认字段。</p> <p>例子：</p> <pre class="literal-block">get_latest_by = "order_date"<br></pre> <p>See the docs for latest() for more.</p> </div> <div id="order-with-respect-to" class="section"> <h2><tt class="docutils literal"><span class="pre">order_with_respect_to</span></tt></h2> <p>标注当前对象对给定的字段是可排序的。几乎总是被使用在允许按照某个父对象排序的关联对象中，比如，一个 Answer 对应于一个 Question 对象，而一个 Question 可以有多个 Answer，而我们关心答案的次序。你可以这样写：</p> <pre class="literal-block">class Answer(models.Model):<br> question = models.ForeignKey(Question)<br> # ...<br><br> class Meta:<br> order_with_respect_to = 'question'<br></pre> </div> <div id="ordering" class="section"> <h2><tt class="docutils literal"><span class="pre">ordering</span></tt></h2> <p>对象的默认排序规则。在获取对象列表时使用：</p> <pre class="literal-block">ordering = ['-order_date']<br></pre> <p>这是一个字符串的 list 或 tuple. 每个字符串是一个字段名，它们可以有一个可选的前缀 '-' 字符，表示倒序排列。如果要随机次序排序，可以用 "?" 前缀。</p> <p>例如，按 pub_date 字段升序排列：</p> <pre class="literal-block">ordering = ['pub_date']<br></pre> <p>倒序：</p> <pre class="literal-block">ordering = ['-pub_date']<br></pre> <p>先按 pub_date 降序，然后按 author 升序：</p> <pre class="literal-block">ordering = ['-pub_date', 'author']<br></pre> <p>See Specifying ordering for more examples.</p> <p>注意：不管在 ordering 中写了多少个字段，admin 后台只用第一个。</p> </div> <div id="permissions" class="section"> <h2><tt class="docutils literal"><span class="pre">permissions</span></tt></h2> <p>创建对象时需要写到权限表中的额外的权限。对每一个有 admin 设置的对象，添加、修改、删除权限会自动创建。下面的例子定义了一个额外的权限：<tt class="docutils literal"><span class="pre">can_deliver_pizzas：</span></tt></p> <pre class="literal-block">permissions = (("can_deliver_pizzas", "Can deliver pizzas"),)<br></pre> <p>This is a list or tuple of 2-tuples in the format <tt class="docutils literal"><span class="pre">(permission_code,</span> <span class="pre">human_readable_permission_name)</span></tt>.</p> </div> <div id="unique-together" class="section"> <h2><tt class="docutils literal"><span class="pre">unique_together</span></tt></h2> <p>（译注：类似于联合主键）定义哪些字段组合后是必须唯一的：</p> <pre class="literal-block">unique_together = (("driver", "restaurant"),)<br></pre> <p>这个被用在 Django admin 中，同时数据库中也会创建相关的约束。<br>This is a list of lists of fields that must be unique when considered together. It's used in the Django admin and is enforced at the database level (i.e., the appropriate <tt class="docutils literal"><span class="pre">UNIQUE</span></tt> statements are included in the <tt class="docutils literal"><span class="pre">CREATE</span> <span class="pre">TABLE</span></tt> statement).</p> </div> <div id="verbose-name" class="section"> <h2><tt class="docutils literal"><span class="pre">verbose_name</span></tt></h2> <p>A human-readable name for the object, singular:</p> <pre class="literal-block">verbose_name = "pizza"<br></pre> <p>If this isn't given, Django will use a munged version of the class name: <tt class="docutils literal"><span class="pre">CamelCase</span></tt> becomes <tt class="docutils literal"><span class="pre">camel</span> <span class="pre">case</span></tt>.</p> </div> <div id="verbose-name-plural" class="section"> <h2><tt class="docutils literal"><span class="pre">verbose_name_plural</span></tt></h2> <p>The plural name for the object:</p> <pre class="literal-block">verbose_name_plural = "stories"<br></pre> <p>If this isn't given, Django will use <tt class="docutils literal"><span class="pre">verbose_name</span> <span class="pre">+</span> <span class="pre">"s"</span></tt>.</p> </div> </div> <div id="id2" class="section"> <h1>Table names</h1> <p>To save you time, Django automatically derives the name of the database table from the name of your model class and the app that contains it. A model's database table name is constructed by joining the model's "app label" -- the name you used in <tt class="docutils literal"><span class="pre">manage.py</span> <span class="pre">startapp</span></tt> -- to the model's class name, with an underscore between them.</p> <p>For example, if you have an app <tt class="docutils literal"><span class="pre">bookstore</span></tt> (as created by <tt class="docutils literal"><span class="pre">manage.py</span> <span class="pre">startapp</span> <span class="pre">bookstore</span></tt>), a model defined as <tt class="docutils literal"><span class="pre">class</span> <span class="pre">Book</span></tt> will have a database table named <tt class="docutils literal"><span class="pre">bookstore_book</span></tt>.</p> <p>To override the database table name, use the <tt class="docutils literal"><span class="pre">db_table</span></tt> parameter in <tt class="docutils literal"><span class="pre">class</span> <span class="pre">Meta</span></tt>.</p> </div> <div id="automatic-primary-key-fields" class="section"> <h1>Automatic primary key fields</h1> <p>By default, Django gives each model the following field:</p> <pre class="literal-block">id = models.AutoField(primary_key=True)<br></pre> <p>This is an auto-incrementing primary key.</p> <p>If you'd like to specify a custom primary key, just specify <tt class="docutils literal"><span class="pre">primary_key=True</span></tt> on one of your fields. If Django sees you've explicitly set <tt class="docutils literal"><span class="pre">primary_key</span></tt>, it won't add the automatic <tt class="docutils literal"><span class="pre">id</span></tt> column.</p> <p>Each model requires exactly one field to have <tt class="docutils literal"><span class="pre">primary_key=True</span></tt>.</p> </div> <div id="admin-options" class="section"> <h1>Admin options</h1> <p>If you want your model to be visible to Django's admin site, give your model an inner <tt class="docutils literal"><span class="pre">"class</span> <span class="pre">Admin"</span></tt>, like so:</p> <pre class="literal-block">class Person(models.Model):<br> first_name = models.CharField(maxlength=30)<br> last_name = models.CharField(maxlength=30)<br><br> class Admin:<br> # Admin options go here<br> pass<br></pre> <p>The <tt class="docutils literal"><span class="pre">Admin</span></tt> class tells Django how to display the model in the admin site.</p> <p>Here's a list of all possible <tt class="docutils literal"><span class="pre">Admin</span></tt> options. None of these options are required. To use an admin interface without specifying any options, use <tt class="docutils literal"><span class="pre">pass</span></tt>, like so:</p> <pre class="literal-block">class Admin:<br> pass<br></pre> <p>Adding <tt class="docutils literal"><span class="pre">class</span> <span class="pre">Admin</span></tt> to a model is completely optional.</p> <div id="date-hierarchy" class="section"> <h2><tt class="docutils literal"><span class="pre">date_hierarchy</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">date_hierarchy</span></tt> to the name of a <tt class="docutils literal"><span class="pre">DateField</span></tt> or <tt class="docutils literal"><span class="pre">DateTimeField</span></tt> in your model, and the change list page will include a date-based drilldown navigation by that field.</p> <p>Example:</p> <pre class="literal-block">date_hierarchy = 'pub_date'<br></pre> </div> <div id="id3" class="section"> <h2><tt class="docutils literal"><span class="pre">fields</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">fields</span></tt> to control the layout of admin "add" and "change" pages.</p> <p><tt class="docutils literal"><span class="pre">fields</span></tt> is a list of two-tuples, in which each two-tuple represents a <tt class="docutils literal"><span class="pre"><fieldset></span></tt> on the admin form page. (A <tt class="docutils literal"><span class="pre"><fieldset></span></tt> is a "section" of the form.)</p> <p>The two-tuples are in the format <tt class="docutils literal"><span class="pre">(name,</span> <span class="pre">field_options)</span></tt>, where <tt class="docutils literal"><span class="pre">name</span></tt> is a string representing the title of the fieldset and <tt class="docutils literal"><span class="pre">field_options</span></tt> is a dictionary of information about the fieldset, including a list of fields to be displayed in it.</p> <p>A full example, taken from the <tt class="docutils literal"><span class="pre">django.contrib.flatpages.FlatPage</span></tt> model:</p> <pre class="literal-block">class Admin:<br> fields = (<br> (None, {<br> 'fields': ('url', 'title', 'content', 'sites')<br> }),<br> ('Advanced options', {<br> 'classes': 'collapse',<br> 'fields' : ('enable_comments', 'registration_required', 'template_name')<br> }),<br> )<br></pre> <p>This results in an admin page that looks like:</p> <blockquote> </blockquote> <p>If <tt class="docutils literal"><span class="pre">fields</span></tt> isn't given, Django will default to displaying each field that isn't an <tt class="docutils literal"><span class="pre">AutoField</span></tt> and has <tt class="docutils literal"><span class="pre">editable=True</span></tt>, in a single fieldset, in the same order as the fields are defined in the model.</p> <p>The <tt class="docutils literal"><span class="pre">field_options</span></tt> dictionary can have the following keys:</p> <div id="id4" class="section"> <h3><tt class="docutils literal"><span class="pre">fields</span></tt></h3> <p>A tuple of field names to display in this fieldset. This key is required.</p> <p>Example:</p> <pre class="literal-block">{<br>'fields': ('first_name', 'last_name', 'address', 'city', 'state'),<br>}<br></pre> <p>To display multiple fields on the same line, wrap those fields in their own tuple. In this example, the <tt class="docutils literal"><span class="pre">first_name</span></tt> and <tt class="docutils literal"><span class="pre">last_name</span></tt> fields will display on the same line:</p> <pre class="literal-block">{<br>'fields': (('first_name', 'last_name'), 'address', 'city', 'state'),<br>}<br></pre> </div> <div id="classes" class="section"> <h3><tt class="docutils literal"><span class="pre">classes</span></tt></h3> <p>A string containing extra CSS classes to apply to the fieldset.</p> <p>Example:</p> <pre class="literal-block">{<br>'classes': 'wide',<br>}<br></pre> <p>Apply multiple classes by separating them with spaces. Example:</p> <pre class="literal-block">{<br>'classes': 'wide extrapretty',<br>}<br></pre> <p>Two useful classes defined by the default admin-site stylesheet are <tt class="docutils literal"><span class="pre">collapse</span></tt> and <tt class="docutils literal"><span class="pre">wide</span></tt>. Fieldsets with the <tt class="docutils literal"><span class="pre">collapse</span></tt> style will be initially collapsed in the admin and replaced with a small "click to expand" link. Fieldsets with the <tt class="docutils literal"><span class="pre">wide</span></tt> style will be given extra horizontal space.</p> </div> <div id="description" class="section"> <h3><tt class="docutils literal"><span class="pre">description</span></tt></h3> <p>A string of optional extra text to be displayed at the top of each fieldset, under the heading of the fieldset. It's used verbatim, so you can use any HTML and you must escape any special HTML characters (such as ampersands) yourself.</p> </div> </div> <div id="js" class="section"> <h2><tt class="docutils literal"><span class="pre">js</span></tt></h2> <p>A list of strings representing URLs of JavaScript files to link into the admin screen via <tt class="docutils literal"><span class="pre"><script</span> <span class="pre">src=""></span></tt> tags. This can be used to tweak a given type of admin page in JavaScript or to provide "quick links" to fill in default values for certain fields.</p> </div> <div id="list-display" class="section"> <h2><tt class="docutils literal"><span class="pre">list_display</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">list_display</span></tt> to control which fields are displayed on the change list page of the admin.</p> <p>Example:</p> <pre class="literal-block">list_display = ('first_name', 'last_name')<br></pre> <p>If you don't set <tt class="docutils literal"><span class="pre">list_display</span></tt>, the admin site will display a single column that displays the <tt class="docutils literal"><span class="pre">__str__()</span></tt> representation of each object.</p> <p>A few special cases to note about <tt class="docutils literal"><span class="pre">list_display</span></tt>:</p> <blockquote> <ul> <li> <p class="first">If the field is a <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>, Django will display the <tt class="docutils literal"><span class="pre">__str__()</span></tt> of the related object.</p> </li> <li> <dl class="first docutils"> <dt> <tt class="docutils literal"><span class="pre">ManyToManyField</span></tt> fields aren't supported, because that would entail </dt> <dd> <p class="first last">executing a separate SQL statement for each row in the table.</p> </dd> </dl></li> <li> <p class="first">If the field is a <tt class="docutils literal"><span class="pre">BooleanField</span></tt>, Django will display a pretty "on" or "off" icon instead of <tt class="docutils literal"><span class="pre">True</span></tt> or <tt class="docutils literal"><span class="pre">False</span></tt>.</p> </li> <li> <p class="first">If the string given is a method of the model, Django will call it and display the output. This method should have a <tt class="docutils literal"><span class="pre">short_description</span></tt> function attribute, for use as the header for the field.</p> <p>Here's a full example model:</p> <pre class="literal-block">class Person(models.Model):<br> name = models.CharField(maxlength=50)<br> birthday = models.DateField()<br><br> class Admin:<br> list_display = ('name', 'decade_born_in')<br><br> def decade_born_in(self):<br> return self.birthday.strftime('%Y')[:3] + "0's"<br> decade_born_in.short_description = 'Birth decade'<br></pre> </li> <li> <p class="first">If the string given is a method of the model, Django will HTML-escape the output by default. If you'd rather not escape the output of the method, give the method an <tt class="docutils literal"><span class="pre">allow_tags</span></tt> attribute whose value is <tt class="docutils literal"><span class="pre">True</span></tt>.</p> <p>Here's a full example model:</p> <pre class="literal-block">class Person(models.Model):<br> first_name = models.CharField(maxlength=50)<br> last_name = models.CharField(maxlength=50)<br> color_code = models.CharField(maxlength=6)<br><br> class Admin:<br> list_display = ('first_name', 'last_name', 'colored_name')<br><br> def colored_name(self):<br> return '<span style="color: #%s;">%s %s</span>' % (self.color_code, self.first_name, self.last_name)<br> colored_name.allow_tags = True<br></pre> </li> </ul> </blockquote> </div> <div id="list-display-links" class="section"> <h2><tt class="docutils literal"><span class="pre">list_display_links</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">list_display_links</span></tt> to control which fields in <tt class="docutils literal"><span class="pre">list_display</span></tt> should be linked to the "change" page for an object.</p> <p>By default, the change list page will link the first column -- the first field specified in <tt class="docutils literal"><span class="pre">list_display</span></tt> -- to the change page for each item. But <tt class="docutils literal"><span class="pre">list_display_links</span></tt> lets you change which columns are linked. Set <tt class="docutils literal"><span class="pre">list_display_links</span></tt> to a list or tuple of field names (in the same format as <tt class="docutils literal"><span class="pre">list_display</span></tt>) to link.</p> <p><tt class="docutils literal"><span class="pre">list_display_links</span></tt> can specify one or many field names. As long as the field names appear in <tt class="docutils literal"><span class="pre">list_display</span></tt>, Django doesn't care how many (or how few) fields are linked. The only requirement is: If you want to use <tt class="docutils literal"><span class="pre">list_display_links</span></tt>, you must define <tt class="docutils literal"><span class="pre">list_display</span></tt>.</p> <p>In this example, the <tt class="docutils literal"><span class="pre">first_name</span></tt> and <tt class="docutils literal"><span class="pre">last_name</span></tt> fields will be linked on the change list page:</p> <pre class="literal-block">class Admin:<br> list_display = ('first_name', 'last_name', 'birthday')<br> list_display_links = ('first_name', 'last_name')<br></pre> <p>Finally, note that in order to use <tt class="docutils literal"><span class="pre">list_display_links</span></tt>, you must define <tt class="docutils literal"><span class="pre">list_display</span></tt>, too.</p> </div> <div id="list-filter" class="section"> <h2><tt class="docutils literal"><span class="pre">list_filter</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">list_filter</span></tt> to activate filters in the right sidebar of the change list page of the admin. This should be a list of field names, and each specified field should be either a <tt class="docutils literal"><span class="pre">BooleanField</span></tt>, <tt class="docutils literal"><span class="pre">DateField</span></tt>, <tt class="docutils literal"><span class="pre">DateTimeField</span></tt> or <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>.</p> <p>This example, taken from the <tt class="docutils literal"><span class="pre">django.contrib.auth.models.User</span></tt> model, shows how both <tt class="docutils literal"><span class="pre">list_display</span></tt> and <tt class="docutils literal"><span class="pre">list_filter</span></tt> work:</p> <pre class="literal-block">class Admin:<br> list_display = ('username', 'email', 'first_name', 'last_name', 'is_staff')<br> list_filter = ('is_staff', 'is_superuser')<br></pre> <p>The above code results in an admin change list page that looks like this:</p> <blockquote> </blockquote> <p>(This example also has <tt class="docutils literal"><span class="pre">search_fields</span></tt> defined. See below.)</p> </div> <div id="list-per-page" class="section"> <h2><tt class="docutils literal"><span class="pre">list_per_page</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">list_per_page</span></tt> to control how many items appear on each paginated admin change list page. By default, this is set to <tt class="docutils literal"><span class="pre">100</span></tt>.</p> </div> <div id="list-select-related" class="section"> <h2><tt class="docutils literal"><span class="pre">list_select_related</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">list_select_related</span></tt> to tell Django to use <tt class="docutils literal"><span class="pre">select_related()</span></tt> in retrieving the list of objects on the admin change list page. This can save you a bunch of database queries.</p> <p>The value should be either <tt class="docutils literal"><span class="pre">True</span></tt> or <tt class="docutils literal"><span class="pre">False</span></tt>. Default is <tt class="docutils literal"><span class="pre">False</span></tt>.</p> <p>Note that Django will use <tt class="docutils literal"><span class="pre">select_related()</span></tt>, regardless of this setting, if one of the <tt class="docutils literal"><span class="pre">list_display</span></tt> fields is a <tt class="docutils literal"><span class="pre">ForeignKey</span></tt>.</p> <p>For more on <tt class="docutils literal"><span class="pre">select_related()</span></tt>, see the select_related() docs.</p> </div> <div id="id5" class="section"> <h2><tt class="docutils literal"><span class="pre">ordering</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">ordering</span></tt> to specify how objects on the admin change list page should be ordered. This should be a list or tuple in the same format as a model's <tt class="docutils literal"><span class="pre">ordering</span></tt> parameter.</p> <p>If this isn't provided, the Django admin will use the model's default ordering.</p> </div> <div id="save-as" class="section"> <h2><tt class="docutils literal"><span class="pre">save_as</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">save_as</span></tt> to enable a "save as" feature on admin change forms.</p> <p>Normally, objects have three save options: "Save", "Save and continue editing" and "Save and add another". If <tt class="docutils literal"><span class="pre">save_as</span></tt> is <tt class="docutils literal"><span class="pre">True</span></tt>, "Save and add another" will be replaced by a "Save as" button.</p> <p>"Save as" means the object will be saved as a new object (with a new ID), rather than the old object.</p> <p>By default, <tt class="docutils literal"><span class="pre">save_as</span></tt> is set to <tt class="docutils literal"><span class="pre">False</span></tt>.</p> </div> <div id="save-on-top" class="section"> <h2><tt class="docutils literal"><span class="pre">save_on_top</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">save_on_top</span></tt> to add save buttons across the top of your admin change forms.</p> <p>Normally, the save buttons appear only at the bottom of the forms. If you set <tt class="docutils literal"><span class="pre">save_on_top</span></tt>, the buttons will appear both on the top and the bottom.</p> <p>By default, <tt class="docutils literal"><span class="pre">save_on_top</span></tt> is set to <tt class="docutils literal"><span class="pre">False</span></tt>.</p> </div> <div id="search-fields" class="section"> <h2><tt class="docutils literal"><span class="pre">search_fields</span></tt></h2> <p>Set <tt class="docutils literal"><span class="pre">search_fields</span></tt> to enable a search box on the admin change list page. This should be set to a list of field names that will be searched whenever somebody submits a search query in that text box.</p> <p>These fields should be some kind of text field, such as <tt class="docutils literal"><span class="pre">CharField</span></tt> or <tt class="docutils literal"><span class="pre">TextField</span></tt>.</p> <p>When somebody does a search in the admin search box, Django splits the search query into words and returns all objects that contain each of the words, case insensitive, where each word must be in at least one of <tt class="docutils literal"><span class="pre">search_fields</span></tt>. For example, if <tt class="docutils literal"><span class="pre">search_fields</span></tt> is set to <tt class="docutils literal"><span class="pre">['first_name',</span> <span class="pre">'last_name']</span></tt> and a user searches for <tt class="docutils literal"><span class="pre">john</span> <span class="pre">lennon</span></tt>, Django will do the equivalent of this SQL <tt class="docutils literal"><span class="pre">WHERE</span></tt> clause:</p> <pre class="literal-block">WHERE (first_name ILIKE '%john%' OR last_name ILIKE '%john%')<br>AND (first_name ILIKE '%lennon%' OR last_name ILIKE '%lennon%')<br></pre> </div> </div> <div id="managers" class="section"> <h1>Managers</h1> <p>A <tt class="docutils literal"><span class="pre">Manager</span></tt> is the interface through which database query operations are provided to Django models. At least one <tt class="docutils literal"><span class="pre">Manager</span></tt> exists for every model in a Django application.</p> <p>The way <tt class="docutils literal"><span class="pre">Manager</span></tt> classes work is documented in the Retrieving objects section of the database API docs, but this section specifically touches on model options that customize <tt class="docutils literal"><span class="pre">Manager</span></tt> behavior.</p> <div id="manager-names" class="section"> <h2>Manager names</h2> <p>By default, Django adds a <tt class="docutils literal"><span class="pre">Manager</span></tt> with the name <tt class="docutils literal"><span class="pre">objects</span></tt> to every Django model class. However, if you want to use <tt class="docutils literal"><span class="pre">objects</span></tt> as a field name, or if you want to use a name other than <tt class="docutils literal"><span class="pre">objects</span></tt> for the <tt class="docutils literal"><span class="pre">Manager</span></tt>, you can rename it on a per-model basis. To rename the <tt class="docutils literal"><span class="pre">Manager</span></tt> for a given class, define a class attribute of type <tt class="docutils literal"><span class="pre">models.Manager()</span></tt> on that model. For example:</p> <pre class="literal-block">from django.db import models<br><br>class Person(models.Model):<br> #...<br> people = models.Manager()<br></pre> <p>Using this example model, <tt class="docutils literal"><span class="pre">Person.objects</span></tt> will generate an <tt class="docutils literal"><span class="pre">AttributeError</span></tt> exception, but <tt class="docutils literal"><span class="pre">Person.people.all()</span></tt> will provide a list of all <tt class="docutils literal"><span class="pre">Person</span></tt> objects.</p> </div> <div id="custom-managers" class="section"> <h2>Custom Managers</h2> <p>You can use a custom <tt class="docutils literal"><span class="pre">Manager</span></tt> in a particular model by extending the base <tt class="docutils literal"><span class="pre">Manager</span></tt> class and instantiating your custom <tt class="docutils literal"><span class="pre">Manager</span></tt> in your model.</p> <p>There are two reasons you might want to customize a <tt class="docutils literal"><span class="pre">Manager</span></tt>: to add extra <tt class="docutils literal"><span class="pre">Manager</span></tt> methods, and/or to modify the initial <tt class="docutils literal"><span class="pre">QuerySet</span></tt> the <tt class="docutils literal"><span class="pre">Manager</span></tt> returns.</p> <div id="adding-extra-manager-methods" class="section"> <h3>Adding extra Manager methods</h3> <p>Adding extra <tt class="docutils literal"><span class="pre">Manager</span></tt> methods is the preferred way to add "table-level" functionality to your models. (For "row-level" functionality -- i.e., functions that act on a single instance of a model object -- use <span id="model-methods" class="target">Model methods</span>, not custom <tt class="docutils literal"><span class="pre">Manager</span></tt> methods.)</p> <p>A custom <tt class="docutils literal"><span class="pre">Manager</span></tt> method can return anything you want. It doesn't have to return a <tt class="docutils literal"><span class="pre">QuerySet</span></tt>.</p> <p>For example, this custom <tt class="docutils literal"><span class="pre">Manager</span></tt> offers a method <tt class="docutils literal"><span class="pre">with_counts()</span></tt>, which returns a list of all <tt class="docutils literal"><span class="pre">OpinionPoll</span></tt> objects, each with an extra <tt class="docutils literal"><span class="pre">num_responses</span></tt> attribute that is the result of an aggregate query:</p> <pre class="literal-block">class PollManager(models.Manager):<br> def with_counts(self):<br> from django.db import connection<br> cursor = connection.cursor()<br> cursor.execute("""<br> SELECT p.id, p.question, p.poll_date, COUNT(*)<br> FROM polls_opinionpoll p, polls_response r<br> WHERE p.id = r.poll_id<br> GROUP BY 1, 2, 3<br> ORDER BY 3 DESC""")<br> result_list = []<br> for row in cursor.fetchall():<br> p = self.model(id=row[0], question=row[1], poll_date=row[2])<br> p.num_responses = row[3]<br> result_list.append(p)<br> return result_list<br><br>class OpinionPoll(models.Model):<br> question = models.CharField(maxlength=200)<br> poll_date = models.DateField()<br> objects = PollManager()<br><br>class Response(models.Model):<br> poll = models.ForeignKey(Poll)<br> person_name = models.CharField(maxlength=50)<br> response = models.TextField()<br></pre> <p>With this example, you'd use <tt class="docutils literal"><span class="pre">OpinionPoll.objects.with_counts()</span></tt> to return that list of <tt class="docutils literal"><span class="pre">OpinionPoll</span></tt> objects with <tt class="docutils literal"><span class="pre">num_responses</span></tt> attributes.</p> <p>Another thing to note about this example is that <tt class="docutils literal"><span class="pre">Manager</span></tt> methods can access <tt class="docutils literal"><span class="pre">self.model</span></tt> to get the model class to which they're attached.</p> </div> <div id="modifying-initial-manager-querysets" class="section"> <h3>Modifying initial Manager QuerySets</h3> <p>A <tt class="docutils literal"><span class="pre">Manager</span></tt>'s base <tt class="docutils literal"><span class="pre">QuerySet</span></tt> returns all objects in the system. For example, using this model:</p> <pre class="literal-block">class Book(models.Model):<br> title = models.CharField(maxlength=100)<br> author = models.CharField(maxlength=50)<br></pre> <p>...the statement <tt class="docutils literal"><span class="pre">Book.objects.all()</span></tt> will return all books in the database.</p> <p>You can override a <tt class="docutils literal"><span class="pre">Manager</span></tt>'s base <tt class="docutils literal"><span class="pre">QuerySet</span></tt> by overriding the <tt class="docutils literal"><span class="pre">Manager.get_query_set()</span></tt> method. <tt class="docutils literal"><span class="pre">get_query_set()</span></tt> should return a <tt class="docutils literal"><span class="pre">QuerySet</span></tt> with the properties you require.</p> <p>For example, the following model has <em>two</em> <tt class="docutils literal"><span class="pre">Manager</span></tt>s -- one that returns all objects, and one that returns only the books by Roald Dahl:</p> <pre class="literal-block"># First, define the Manager subclass.<br>class DahlBookManager(models.Manager):<br> def get_query_set(self):<br> return super(DahlBookManager, self).get_query_set().filter(author='Roald Dahl')<br><br># Then hook it into the Book model explicitly.<br>class Book(models.Model):<br> title = models.CharField(maxlength=100)<br> author = models.CharField(maxlength=50)<br><br> objects = models.Manager() # The default manager.<br> dahl_objects = DahlBookManager() # The Dahl-specific manager.<br></pre> <p>With this sample model, <tt class="docutils literal"><span class="pre">Book.objects.all()</span></tt> will return all books in the database, but <tt class="docutils literal"><span class="pre">Book.dahl_objects.all()</span></tt> will only return the ones written by Roald Dahl.</p> <p>Of course, because <tt class="docutils literal"><span class="pre">get_query_set()</span></tt> returns a <tt class="docutils literal"><span class="pre">QuerySet</span></tt> object, you can use <tt class="docutils literal"><span class="pre">filter()</span></tt>, <tt class="docutils literal"><span class="pre">exclude()</span></tt> and all the other <tt class="docutils literal"><span class="pre">QuerySet</span></tt> methods on it. So these statements are all legal:</p> <pre class="literal-block">Book.dahl_objects.all()<br>Book.dahl_objects.filter(title='Matilda')<br>Book.dahl_objects.count()<br></pre> <p>This example also pointed out another interesting technique: using multiple managers on the same model. You can attach as many <tt class="docutils literal"><span class="pre">Manager()</span></tt> instances to a model as you'd like. This is an easy way to define common "filters" for your models.</p> <p>For example:</p> <pre class="literal-block">class MaleManager(models.Manager):<br> def get_query_set(self):<br> return super(MaleManager, self).get_query_set().filter(sex='M')<br><br>class FemaleManager(models.Manager):<br> def get_query_set(self):<br> return super(FemaleManager, self).get_query_set().filter(sex='F')<br><br>class Person(models.Model):<br> first_name = models.CharField(maxlength=50)<br> last_name = models.CharField(maxlength=50)<br> sex = models.CharField(maxlength=1, choices=(('M', 'Male'), ('F', 'Female')))<br> people = models.Manager()<br> men = MaleManager()<br> women = FemaleManager()<br></pre> <p>This example allows you to request <tt class="docutils literal"><span class="pre">Person.men.all()</span></tt>, <tt class="docutils literal"><span class="pre">Person.women.all()</span></tt>, and <tt class="docutils literal"><span class="pre">Person.people.all()</span></tt>, yielding predictable results.</p> <p>If you use custom <tt class="docutils literal"><span class="pre">Manager</span></tt> objects, take note that the first <tt class="docutils literal"><span class="pre">Manager</span></tt> Django encounters (in order by which they're defined in the model) has a special status. Django interprets the first <tt class="docutils literal"><span class="pre">Manager</span></tt> defined in a class as the "default" <tt class="docutils literal"><span class="pre">Manager</span></tt>. Certain operations -- such as Django's admin site -- use the default <tt class="docutils literal"><span class="pre">Manager</span></tt> to obtain lists of objects, so it's generally a good idea for the first <tt class="docutils literal"><span class="pre">Manager</span></tt> to be relatively unfiltered. In the last example, the <tt class="docutils literal"><span class="pre">people</span></tt> <tt class="docutils literal"><span class="pre">Manager</span></tt> is defined first -- so it's the default <tt class="docutils literal"><span class="pre">Manager</span></tt>.</p> </div> </div> </div> <div id="id6" class="section"> <h1>Model methods</h1> <p>Define custom methods on a model to add custom "row-level" functionality to your objects. Whereas <tt class="docutils literal"><span class="pre">Manager</span></tt> methods are intended to do "table-wide" things, model methods should act on a particular model instance.</p> <p>This is a valuable technique for keeping business logic in one place -- the model.</p> <p>For example, this model has a few custom methods:</p> <pre class="literal-block">class Person(models.Model):<br> first_name = models.CharField(maxlength=50)<br> last_name = models.CharField(maxlength=50)<br> birth_date = models.DateField()<br> address = models.CharField(maxlength=100)<br> city = models.CharField(maxlength=50)<br> state = models.USStateField() # Yes, this is America-centric...<br><br> def baby_boomer_status(self):<br> "Returns the person's baby-boomer status."<br> import datetime<br> if datetime.date(1945, 8, 1) <= self.birth_date <= datetime.date(1964, 12, 31):<br> return "Baby boomer"<br> if self.birth_date < datetime.date(1945, 8, 1):<br> return "Pre-boomer"<br> return "Post-boomer"<br><br> def is_midwestern(self):<br> "Returns True if this person is from the Midwest."<br> return self.state in ('IL', 'WI', 'MI', 'IN', 'OH', 'IA', 'MO')<br><br> def _get_full_name(self):<br> "Returns the person's full name."<br> return '%s %s' % (self.first_name, self.last_name)<br> full_name = property(_get_full_name)<br></pre> <p>The last method in this example is a <em>property</em>. Read more about properties.</p> <p>A few object methods have special meaning:</p> <div id="str" class="section"> <h2><tt class="docutils literal"><span class="pre">__str__</span></tt></h2> <p><tt class="docutils literal"><span class="pre">__str__()</span></tt> is a Python "magic method" that defines what should be returned if you call <tt class="docutils literal"><span class="pre">str()</span></tt> on the object. Django uses <tt class="docutils literal"><span class="pre">str(obj)</span></tt> in a number of places, most notably as the value displayed to render an object in the Django admin site and as the value inserted into a template when it displays an object. Thus, you should always return a nice, human-readable string for the object's <tt class="docutils literal"><span class="pre">__str__</span></tt>. Although this isn't required, it's strongly encouraged.</p> <p>For example:</p> <pre class="literal-block">class Person(models.Model):<br> first_name = models.CharField(maxlength=50)<br> last_name = models.CharField(maxlength=50)<br><br> def __str__(self):<br> return '%s %s' % (self.first_name, self.last_name)<br></pre> </div> <div id="get-absolute-url" class="section"> <h2><tt class="docutils literal"><span class="pre">get_absolute_url</span></tt></h2> <p>Define a <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt> method to tell Django how to calculate the URL for an object. For example:</p> <pre class="literal-block">def get_absolute_url(self):<br> return "/people/%i/" % self.id<br></pre> <p>Django uses this in its admin interface. If an object defines <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt>, the object-editing page will have a "View on site" link that will jump you directly to the object's public view, according to <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt>.</p> <p>Also, a couple of other bits of Django, such as the syndication-feed framework, use <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt> as a convenience to reward people who've defined the method.</p> <p>It's good practice to use <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt> in templates, instead of hard-coding your objects' URLs. For example, this template code is bad:</p> <pre class="literal-block"><a href="/people/{{ object.id }}/">{{ object.name }}</a><br></pre> <p>But this template code is good:</p> <pre class="literal-block"><a href="{{ object.get_absolute_url }}">{{ object.name }}</a><br></pre> <p>(Yes, we know <tt class="docutils literal"><span class="pre">get_absolute_url()</span></tt> couples URLs to models, which violates the DRY principle, because URLs are defined both in a URLconf and in the model. This is a rare case in which we've intentionally violated that principle for the sake of convenience. With that said, we're working on an even cleaner way of specifying URLs in a more DRY fashion.)</p> </div> <div id="executing-custom-sql" class="section"> <h2>Executing custom SQL</h2> <p>Feel free to write custom SQL statements in custom model methods and module-level methods. The object <tt class="docutils literal"><span class="pre">django.db.connection</span></tt> represents the current database connection. To use it, call <tt class="docutils literal"><span class="pre">connection.cursor()</span></tt> to get a cursor object. Then, call <tt class="docutils literal"><span class="pre">cursor.execute(sql,</span> <span class="pre">[params])</span></tt> to execute the SQL and <tt class="docutils literal"><span class="pre">cursor.fetchone()</span></tt> or <tt class="docutils literal"><span class="pre">cursor.fetchall()</span></tt> to return the resulting rows. Example:</p> <pre class="literal-block">def my_custom_sql(self):<br> from django.db import connection<br> cursor = connection.cursor()<br> cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])<br> row = cursor.fetchone()<br> return row<br></pre> <p><tt class="docutils literal"><span class="pre">connection</span></tt> and <tt class="docutils literal"><span class="pre">cursor</span></tt> simply use the standard Python DB-API. If you're not familiar with the Python DB-API, note that the SQL statement in <tt class="docutils literal"><span class="pre">cursor.execute()</span></tt> uses placeholders, <tt class="docutils literal"><span class="pre">"%s"</span></tt>, rather than adding parameters directly within the SQL. If you use this technique, the underlying database library will automatically add quotes and escaping to your parameter(s) as necessary. (Also note that Django expects the <tt class="docutils literal"><span class="pre">"%s"</span></tt> placeholder, <em>not</em> the <tt class="docutils literal"><span class="pre">"?"</span></tt> placeholder, which is used by the SQLite Python bindings. This is for the sake of consistency and sanity.)</p> <p>A final note: If all you want to do is a custom <tt class="docutils literal"><span class="pre">WHERE</span></tt> clause, you can just just the <tt class="docutils literal"><span class="pre">where</span></tt>, <tt class="docutils literal"><span class="pre">tables</span></tt> and <tt class="docutils literal"><span class="pre">params</span></tt> arguments to the standard lookup API. See Other lookup options.</p> </div> <div id="overriding-default-model-methods" class="section"> <h2>Overriding default model methods</h2> <p>As explained in the database API docs, each model gets a few methods automatically -- most notably, <tt class="docutils literal"><span class="pre">save()</span></tt> and <tt class="docutils literal"><span class="pre">delete()</span></tt>. You can override these methods to alter behavior.</p> <p>A classic use-case for overriding the built-in methods is if you want something to happen whenever you save an object. For example:</p> <pre class="literal-block">class Blog(models.Model):<br> name = models.CharField(maxlength=100)<br> tagline = models.TextField()<br><br> def save(self):<br> do_something()<br> super(Blog, self).save() # Call the "real" save() method.<br> do_something_else()<br></pre> <p>You can also prevent saving:</p> <pre class="literal-block">class Blog(models.Model):<br> name = models.CharField(maxlength=100)<br> tagline = models.TextField()<br><br> def save(self):<br> if self.name == "Yoko Ono's blog":<br> return # Yoko shall never have her own blog!<br> else:<br> super(Blog, self).save() # Call the "real" save() method.<br></pre> </div> </div> <div id="models-across-files" class="section"> <h1>Models across files</h1> <p>It's perfectly OK to relate a model to one from another app. To do this, just import the related model at the top of the model that holds your model. Then, just refer to the other model class wherever needed. For example:</p> <pre class="literal-block">from mysite.geography.models import ZipCode<br><br>class Restaurant(models.Model):<br> # ...<br> zip_code = models.ForeignKey(ZipCode)<br></pre> </div> <div id="using-models" class="section"> <h1>Using models</h1> <p>Once you have created your models, the final step is to tell Django you're going to <em>use</em> those models.</p> <p>Do this by editing your settings file and changing the <tt class="docutils literal"><span class="pre">INSTALLED_APPS</span></tt> setting to add the name of the module that contains your <tt class="docutils literal"><span class="pre">models.py</span></tt>.</p> <p>For example, if the models for your application live in the module <tt class="docutils literal"><span class="pre">mysite.myapp.models</span></tt> (the package structure that is created for an application by the <tt class="docutils literal"><span class="pre">manage.py</span> <span class="pre">startapp</span></tt> script), <tt class="docutils literal"><span class="pre">INSTALLED_APPS</span></tt> should read, in part:</p> <pre class="literal-block">INSTALLED_APPS = (<br> #...<br> 'mysite.myapp',<br> #...<br>)<br></pre> </div> <div id="providing-initial-sql-data" class="section"> <h1>Providing initial SQL data</h1> <p>Django provides a hook for passing the database arbitrary SQL that's executed just after the CREATE TABLE statements. Use this hook, for example, if you want to populate default records, or create SQL functions, automatically.</p> <p>The hook is simple: Django just looks for a file called <tt class="docutils literal"><span class="pre"><appname>/sql/<modelname>.sql</span></tt>, where <tt class="docutils literal"><span class="pre"><appname></span></tt> is your app directory and <tt class="docutils literal"><span class="pre"><modelname></span></tt> is the model's name in lowercase.</p> <p>In the <tt class="docutils literal"><span class="pre">Person</span></tt> example model at the top of this document, assuming it lives in an app called <tt class="docutils literal"><span class="pre">myapp</span></tt>, you could add arbitrary SQL to the file <tt class="docutils literal"><span class="pre">myapp/sql/person.sql</span></tt>. Here's an example of what the file might contain:</p> <pre class="literal-block">INSERT INTO myapp_person (first_name, last_name) VALUES ('John', 'Lennon');<br>INSERT INTO myapp_person (first_name, last_name) VALUES ('Paul', 'McCartney');<br></pre> <p>Each SQL file, if given, is expected to contain valid SQL. The SQL files are piped directly into the database after all of the models' table-creation statements have been executed.</p> <p>The SQL files are read by the <tt class="docutils literal"><span class="pre">sqlinitialdata</span></tt>, <tt class="docutils literal"><span class="pre">sqlreset</span></tt>, <tt class="docutils literal"><span class="pre">sqlall</span></tt> and <tt class="docutils literal"><span class="pre">reset</span></tt> commands in <tt class="docutils literal"><span class="pre">manage.py</span></tt>. Refer to the manage.py documentation for more information.</p> <p>Note that if you have multiple SQL data files, there's no guarantee of the order in which they're executed. The only thing you can assume is that, by the time your custom data files are executed, all the database tables already will have been created.</p> <div id="database-backend-specific-sql-data" class="section"> <h2>Database-backend-specific SQL data</h2> <p>There's also a hook for backend-specific SQL data. For example, you can have separate initial-data files for PostgreSQL and MySQL. For each app, Django looks for a file called <tt class="docutils literal"><span class="pre"><appname>/sql/<modelname>.<backend>.sql</span></tt>, where <tt class="docutils literal"><span class="pre"><appname></span></tt> is your app directory, <tt class="docutils literal"><span class="pre"><modelname></span></tt> is the model's name in lowercase and <tt class="docutils literal"><span class="pre"><backend></span></tt> is the value of <tt class="docutils literal"><span class="pre">DATABASE_ENGINE</span></tt> in your settings file (e.g., <tt class="docutils literal"><span class="pre">postgresql</span></tt>, <tt class="docutils literal"><span class="pre">mysql</span></tt>).</p> <p>Backend-specific SQL data is executed before non-backend-specific SQL data. For example, if your app contains the files <tt class="docutils literal"><span class="pre">sql/person.sql</span></tt> and <tt class="docutils literal"><span class="pre">sql/person.postgresql.sql</span></tt> and you're installing the app on PostgreSQL, Django will execute the contents of <tt class="docutils literal"><span class="pre">sql/person.postgresql.sql</span></tt> first, then <tt class="docutils literal"><span class="pre">sql/person.sql</span></tt>.</p> </div> </div> </div> </div> </div> </div> </div> </div> </div> <!--PC和WAP自适应版--> <div id="SOHUCS" sid="1290234492555960320"></div> <script type="text/javascript" src="/views/front/js/chanyan.js"></script> <!-- 文章页-底部 动态广告位 --> <div class="youdao-fixed-ad" id="detail_ad_bottom"></div> </div> <div class="col-md-3"> <div class="row" id="ad"> <!-- 文章页-右侧1 动态广告位 --> <div id="right-1" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad"> <div class="youdao-fixed-ad" id="detail_ad_1"> </div> </div> <!-- 文章页-右侧2 动态广告位 --> <div id="right-2" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad"> <div class="youdao-fixed-ad" id="detail_ad_2"></div> </div> <!-- 文章页-右侧3 动态广告位 --> <div id="right-3" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad"> <div class="youdao-fixed-ad" id="detail_ad_3"></div> </div> </div> </div> </div> </div> </div> <div class="container"> <h4 class="pt20 mb15 mt0 border-top">你可能感兴趣的:(Python)</h4> <div id="paradigm-article-related"> <div class="recommend-post mb30"> <ul class="widget-links"> <li><a href="/article/1835511912843014144.htm" title="理解Gunicorn：Python WSGI服务器的基石" target="_blank">理解Gunicorn：Python WSGI服务器的基石</a> <span class="text-muted">范范0825</span> <a class="tag" taget="_blank" href="/search/ipython/1.htm">ipython</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a> <div>理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico</div> </li> <li><a href="/article/1835506869838376960.htm" title="Python数据分析与可视化实战指南" target="_blank">Python数据分析与可视化实战指南</a> <span class="text-muted">William数据分析</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE/1.htm">数据</a> <div>在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学</div> </li> <li><a href="/article/1835505858939809792.htm" title="python os.environ" target="_blank">python os.environ</a> <span class="text-muted">江湖偌大</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/1.htm">深度学习</a> <div>os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='</div> </li> <li><a href="/article/1835505606245576704.htm" title="Python中os.environ基本介绍及使用方法" target="_blank">Python中os.environ基本介绍及使用方法</a> <span class="text-muted">鹤冲天Pro</span> <a class="tag" taget="_blank" href="/search/%23/1.htm">#</a><a class="tag" taget="_blank" href="/search/Python/1.htm">Python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi</div> </li> <li><a href="/article/1835505226933694464.htm" title="Pyecharts数据可视化大屏：打造沉浸式数据分析体验" target="_blank">Pyecharts数据可视化大屏：打造沉浸式数据分析体验</a> <span class="text-muted">我的运维人生</span> <a class="tag" taget="_blank" href="/search/%E4%BF%A1%E6%81%AF%E5%8F%AF%E8%A7%86%E5%8C%96/1.htm">信息可视化</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/1.htm">数据分析</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E6%8C%96%E6%8E%98/1.htm">数据挖掘</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4%E5%BC%80%E5%8F%91/1.htm">运维开发</a><a class="tag" taget="_blank" href="/search/%E6%8A%80%E6%9C%AF%E5%85%B1%E4%BA%AB/1.htm">技术共享</a> <div>Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例</div> </li> <li><a href="/article/1835504217729626112.htm" title="Python教程：一文了解使用Python处理XPath" target="_blank">Python教程：一文了解使用Python处理XPath</a> <span class="text-muted">旦莫</span> <a class="tag" taget="_blank" href="/search/Python%E8%BF%9B%E9%98%B6/1.htm">Python进阶</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代</div> </li> <li><a href="/article/1835503965563875328.htm" title="python os.environ_python os.environ 读取和设置环境变量" target="_blank">python os.environ_python os.environ 读取和设置环境变量</a> <span class="text-muted">weixin_39605414</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/os.environ/1.htm">os.environ</a> <div>>>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA</div> </li> <li><a href="/article/1835497664922349568.htm" title="使用Faiss进行高效相似度搜索" target="_blank">使用Faiss进行高效相似度搜索</a> <span class="text-muted">llzwxh888</span> <a class="tag" taget="_blank" href="/search/faiss/1.htm">faiss</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a> <div>在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss</div> </li> <li><a href="/article/1835497665853485056.htm" title="python是什么意思中文-在python中%是什么意思" target="_blank">python是什么意思中文-在python中%是什么意思</a> <span class="text-muted">编程大乐趣</span> <div>Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填</div> </li> <li><a href="/article/1835495644123459584.htm" title="Day1笔记-Python简介&标识符和关键字&输入输出" target="_blank">Day1笔记-Python简介&标识符和关键字&输入输出</a> <span class="text-muted">~在杰难逃~</span> <a class="tag" taget="_blank" href="/search/Python/1.htm">Python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/%E5%A4%A7%E6%95%B0%E6%8D%AE/1.htm">大数据</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/1.htm">数据分析</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E6%8C%96%E6%8E%98/1.htm">数据挖掘</a> <div>大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程</div> </li> <li><a href="/article/1835495517774245888.htm" title="python八股文面试题分享及解析(1)" target="_blank">python八股文面试题分享及解析(1)</a> <span class="text-muted">Shawn________</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a> <div>#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变</div> </li> <li><a href="/article/1835493753557708800.htm" title="每日算法&面试题，大厂特训二十八天——第二十天（树）" target="_blank">每日算法&面试题，大厂特训二十八天——第二十天（树）</a> <span class="text-muted">肥学</span> <a class="tag" taget="_blank" href="/search/%E2%9A%A1%E7%AE%97%E6%B3%95%E9%A2%98%E2%9A%A1%E9%9D%A2%E8%AF%95%E9%A2%98%E6%AF%8F%E6%97%A5%E7%B2%BE%E8%BF%9B/1.htm">⚡算法题⚡面试题每日精进</a><a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E7%AE%97%E6%B3%95/1.htm">算法</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/1.htm">数据结构</a> <div>目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章</div> </li> <li><a href="/article/1835493626688401408.htm" title="Python快速入门 —— 第三节：类与对象" target="_blank">Python快速入门 —— 第三节：类与对象</a> <span class="text-muted">孤华暗香</span> <a class="tag" taget="_blank" href="/search/Python%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8/1.htm">Python快速入门</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#</div> </li> <li><a href="/article/1835492869062881280.htm" title="pyecharts——绘制柱形图折线图" target="_blank">pyecharts——绘制柱形图折线图</a> <span class="text-muted">2224070247</span> <a class="tag" taget="_blank" href="/search/%E4%BF%A1%E6%81%AF%E5%8F%AF%E8%A7%86%E5%8C%96/1.htm">信息可视化</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%8F%AF%E8%A7%86%E5%8C%96/1.htm">数据可视化</a> <div>一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据</div> </li> <li><a href="/article/1835491859351302144.htm" title="Python 实现图片裁剪（附代码） | Python工具" target="_blank">Python 实现图片裁剪（附代码） | Python工具</a> <span class="text-muted">剑客阿良_ALiang</span> <div>前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码</div> </li> <li><a href="/article/1835491353451130880.htm" title="【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)" target="_blank">【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)</a> <span class="text-muted">算法大师</span> <a class="tag" taget="_blank" href="/search/%E5%8D%8E%E4%B8%BAod/1.htm">华为od</a><a class="tag" taget="_blank" href="/search/%E9%9D%A2%E8%AF%95/1.htm">面试</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a> <div>华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法</div> </li> <li><a href="/article/1835490974911000576.htm" title="python os 环境变量" target="_blank">python os 环境变量</a> <span class="text-muted">CV矿工</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/numpy/1.htm">numpy</a> <div>环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类</div> </li> <li><a href="/article/1835490218845761536.htm" title="Python爬虫解析工具之xpath使用详解" target="_blank">Python爬虫解析工具之xpath使用详解</a> <span class="text-muted">eqa11</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E7%88%AC%E8%99%AB/1.htm">爬虫</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门</div> </li> <li><a href="/article/1835483915071090688.htm" title="【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）" target="_blank">【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）</a> <span class="text-muted">算法大师</span> <a class="tag" taget="_blank" href="/search/%E5%8D%8E%E4%B8%BAod/1.htm">华为od</a><a class="tag" taget="_blank" href="/search/%E9%9D%A2%E8%AF%95/1.htm">面试</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a> <div>华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal</div> </li> <li><a href="/article/1835483159630802944.htm" title="nosql数据库技术与应用知识点" target="_blank">nosql数据库技术与应用知识点</a> <span class="text-muted">皆过客，揽星河</span> <a class="tag" taget="_blank" href="/search/NoSQL/1.htm">NoSQL</a><a class="tag" taget="_blank" href="/search/nosql/1.htm">nosql</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%BA%93/1.htm">数据库</a><a class="tag" taget="_blank" href="/search/%E5%A4%A7%E6%95%B0%E6%8D%AE/1.htm">大数据</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/1.htm">数据分析</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/1.htm">数据结构</a><a class="tag" taget="_blank" href="/search/%E9%9D%9E%E5%85%B3%E7%B3%BB%E5%9E%8B%E6%95%B0%E6%8D%AE%E5%BA%93/1.htm">非关系型数据库</a> <div>Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)</div> </li> <li><a href="/article/1835481269690003456.htm" title="《Python数据分析实战终极指南》" target="_blank">《Python数据分析实战终极指南》</a> <span class="text-muted">xjt921122</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/1.htm">数据分析</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥</div> </li> <li><a href="/article/1835477362700021760.htm" title="Python中深拷贝与浅拷贝的区别" target="_blank">Python中深拷贝与浅拷贝的区别</a> <span class="text-muted">yuxiaoyu.</span> <div>转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复</div> </li> <li><a href="/article/1835476983614631936.htm" title="Python开发常用的三方模块如下：" target="_blank">Python开发常用的三方模块如下：</a> <span class="text-muted">换个网名有点难</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机</div> </li> <li><a href="/article/1835473704432267264.htm" title="Python编译器" target="_blank">Python编译器</a> <span class="text-muted">鹿鹿~</span> <a class="tag" taget="_blank" href="/search/Python%E7%BC%96%E8%AF%91%E5%99%A8/1.htm">Python编译器</a><a class="tag" taget="_blank" href="/search/Python/1.htm">Python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/%E5%90%8E%E7%AB%AF/1.htm">后端</a> <div>嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt</div> </li> <li><a href="/article/1835471437754888192.htm" title="一文掌握python面向对象魔术方法（二）" target="_blank">一文掌握python面向对象魔术方法（二）</a> <span class="text-muted">程序员neil</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义</div> </li> <li><a href="/article/1835471185589137408.htm" title="一文掌握python常用的list（列表）操作" target="_blank">一文掌握python常用的list（列表）操作</a> <span class="text-muted">程序员neil</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a> <div>目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：</div> </li> <li><a href="/article/1835469798838988800.htm" title="Python实现简单的机器学习算法" target="_blank">Python实现简单的机器学习算法</a> <span class="text-muted">master_chenchengg</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%8A%9E%E5%85%AC%E6%95%88%E7%8E%87/1.htm">办公效率</a><a class="tag" taget="_blank" href="/search/python%E5%BC%80%E5%8F%91/1.htm">python开发</a><a class="tag" taget="_blank" href="/search/IT/1.htm">IT</a> <div>Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl</div> </li> <li><a href="/article/1835465134710026240.htm" title="python中的深拷贝与浅拷贝" target="_blank">python中的深拷贝与浅拷贝</a> <span class="text-muted">anshejd70787</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a> <div>深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis</div> </li> <li><a href="/article/1835463874560749568.htm" title="用Python实现简单的猜数字游戏" target="_blank">用Python实现简单的猜数字游戏</a> <span class="text-muted">程序媛了了</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%B8%B8%E6%88%8F/1.htm">游戏</a><a class="tag" taget="_blank" href="/search/java/1.htm">java</a> <div>猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn<a::如</div> </li> <li><a href="/article/1835463875160535040.htm" title="用Python实现读取统计单词个数" target="_blank">用Python实现读取统计单词个数</a> <span class="text-muted">程序媛了了</span> <a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%B8%B8%E6%88%8F/1.htm">游戏</a><a class="tag" taget="_blank" href="/search/java/1.htm">java</a> <div>完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=</div> </li> <li><a href="/article/81.htm" title="java短路运算符和逻辑运算符的区别" target="_blank">java短路运算符和逻辑运算符的区别</a> <span class="text-muted">3213213333332132</span> <a class="tag" taget="_blank" href="/search/java%E5%9F%BA%E7%A1%80/1.htm">java基础</a> <div> /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是</div> </li> <li><a href="/article/208.htm" title="Java异常那些不得不说的事" target="_blank">Java异常那些不得不说的事</a> <span class="text-muted">白糖_</span> <a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/exception/1.htm">exception</a> <div>一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close(); </div> </li> <li><a href="/article/335.htm" title="utf-8与utf-8(无BOM)的区别" target="_blank">utf-8与utf-8(无BOM)的区别</a> <span class="text-muted">dcj3sjt126com</span> <a class="tag" taget="_blank" href="/search/PHP/1.htm">PHP</a> <div>BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如</div> </li> <li><a href="/article/462.htm" title="JAVA Annotation之定义篇" target="_blank">JAVA Annotation之定义篇</a> <span class="text-muted">周凡杨</span> <a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E6%B3%A8%E8%A7%A3/1.htm">注解</a><a class="tag" taget="_blank" href="/search/annotation/1.htm">annotation</a><a class="tag" taget="_blank" href="/search/%E5%85%A5%E9%97%A8/1.htm">入门</a><a class="tag" taget="_blank" href="/search/%E6%B3%A8%E9%87%8A/1.htm">注释</a> <div>    Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa</div> </li> <li><a href="/article/589.htm" title="tomcat的多域名、虚拟主机配置" target="_blank">tomcat的多域名、虚拟主机配置</a> <span class="text-muted">g21121</span> <a class="tag" taget="_blank" href="/search/tomcat/1.htm">tomcat</a> <div>众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"</div> </li> <li><a href="/article/716.htm" title="Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ）" target="_blank">Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ）</a> <span class="text-muted">510888780</span> <a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/capistrano/1.htm">capistrano</a> <div> 1.ssh -v hdfs@192.168.18.133 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio</div> </li> <li><a href="/article/843.htm" title="log4j的用法" target="_blank">log4j的用法</a> <span class="text-muted">Harry642</span> <a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/log4j/1.htm">log4j</a> <div>一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中</div> </li> <li><a href="/article/970.htm" title="mysql、sqlserver、oracle分页，java分页统一接口实现" target="_blank">mysql、sqlserver、oracle分页，java分页统一接口实现</a> <span class="text-muted">aijuans</span> <a class="tag" taget="_blank" href="/search/oracle/1.htm">oracle</a><a class="tag" taget="_blank" href="/search/jave/1.htm">jave</a> <div> 定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  </div> </li> <li><a href="/article/1097.htm" title="Hessian 简单例子" target="_blank">Hessian 简单例子</a> <span class="text-muted">antlove</span> <a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/Web/1.htm">Web</a><a class="tag" taget="_blank" href="/search/service/1.htm">service</a><a class="tag" taget="_blank" href="/search/hessian/1.htm">hessian</a> <div>hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543</div> </li> <li><a href="/article/1224.htm" title="数据库对象的同义词和序列" target="_blank">数据库对象的同义词和序列</a> <span class="text-muted">百合不是茶</span> <a class="tag" taget="_blank" href="/search/sql/1.htm">sql</a><a class="tag" taget="_blank" href="/search/%E5%BA%8F%E5%88%97/1.htm">序列</a><a class="tag" taget="_blank" href="/search/%E5%90%8C%E4%B9%89%E8%AF%8D/1.htm">同义词</a><a class="tag" taget="_blank" href="/search/ORACLE%E6%9D%83%E9%99%90/1.htm">ORACLE权限</a> <div>回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to </div> </li> <li><a href="/article/1351.htm" title="使用Powermock和mockito测试静态方法" target="_blank">使用Powermock和mockito测试静态方法</a> <span class="text-muted">bijian1013</span> <a class="tag" taget="_blank" href="/search/%E6%8C%81%E7%BB%AD%E9%9B%86%E6%88%90/1.htm">持续集成</a><a class="tag" taget="_blank" href="/search/%E5%8D%95%E5%85%83%E6%B5%8B%E8%AF%95/1.htm">单元测试</a><a class="tag" taget="_blank" href="/search/mockito/1.htm">mockito</a><a class="tag" taget="_blank" href="/search/Powermock/1.htm">Powermock</a> <div>        实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or</div> </li> <li><a href="/article/1478.htm" title="精通Oracle10编程SQL(6)访问ORACLE" target="_blank">精通Oracle10编程SQL(6)访问ORACLE</a> <span class="text-muted">bijian1013</span> <a class="tag" taget="_blank" href="/search/oracle/1.htm">oracle</a><a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E5%BA%93/1.htm">数据库</a><a class="tag" taget="_blank" href="/search/plsql/1.htm">plsql</a> <div>/* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu</div> </li> <li><a href="/article/1605.htm" title="【Nginx四】Nginx作为HTTP负载均衡服务器" target="_blank">【Nginx四】Nginx作为HTTP负载均衡服务器</a> <span class="text-muted">bit1129</span> <a class="tag" taget="_blank" href="/search/nginx/1.htm">nginx</a> <div> Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l</div> </li> <li><a href="/article/1732.htm" title="jquery-validation备忘" target="_blank">jquery-validation备忘</a> <span class="text-muted">白糖_</span> <a class="tag" taget="_blank" href="/search/jquery/1.htm">jquery</a><a class="tag" taget="_blank" href="/search/css/1.htm">css</a><a class="tag" taget="_blank" href="/search/F%23/1.htm">F#</a><a class="tag" taget="_blank" href="/search/Firebug/1.htm">Firebug</a> <div>留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&</div> </li> <li><a href="/article/1859.htm" title="solr限制admin界面访问（端口限制和http授权限制）" target="_blank">solr限制admin界面访问（端口限制和http授权限制）</a> <span class="text-muted">ronin47</span> <a class="tag" taget="_blank" href="/search/%E9%99%90%E5%AE%9AIp%E8%AE%BF%E9%97%AE/1.htm">限定Ip访问</a> <div>solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad</div> </li> <li><a href="/article/1986.htm" title="多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1" target="_blank">多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1</a> <span class="text-muted">bylijinnan</span> <a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E5%A4%9A%E7%BA%BF%E7%A8%8B/1.htm">多线程</a> <div> public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static </div> </li> <li><a href="/article/2113.htm" title="买房历程" target="_blank">买房历程</a> <span class="text-muted">cfyme</span> <div>    2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-</div> </li> <li><a href="/article/2240.htm" title="[军事与科技]制造大型太空战舰的前奏" target="_blank">[军事与科技]制造大型太空战舰的前奏</a> <span class="text-muted">comsci</span> <a class="tag" taget="_blank" href="/search/%E5%88%B6%E9%80%A0/1.htm">制造</a> <div>        天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关</div> </li> <li><a href="/article/2367.htm" title="dateformat" target="_blank">dateformat</a> <span class="text-muted">dai_lm</span> <a class="tag" taget="_blank" href="/search/DateFormat/1.htm">DateFormat</a> <div> "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year</div> </li> <li><a href="/article/2494.htm" title="Hadoop如何实现关联计算" target="_blank">Hadoop如何实现关联计算</a> <span class="text-muted">datamachine</span> <a class="tag" taget="_blank" href="/search/mapreduce/1.htm">mapreduce</a><a class="tag" taget="_blank" href="/search/hadoop/1.htm">hadoop</a><a class="tag" taget="_blank" href="/search/%E5%85%B3%E8%81%94%E8%AE%A1%E7%AE%97/1.htm">关联计算</a> <div>    选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs</div> </li> <li><a href="/article/2621.htm" title="用户模型中修改用户信息时，密码是如何处理的" target="_blank">用户模型中修改用户信息时，密码是如何处理的</a> <span class="text-muted">dcj3sjt126com</span> <a class="tag" taget="_blank" href="/search/yii/1.htm">yii</a> <div>当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这</div> </li> <li><a href="/article/2748.htm" title="中文 iOS/Mac 开发博客列表" target="_blank">中文 iOS/Mac 开发博客列表</a> <span class="text-muted">dcj3sjt126com</span> <a class="tag" taget="_blank" href="/search/Blog/1.htm">Blog</a> <div>  本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。 </div> </li> <li><a href="/article/2875.htm" title="js去除空格，去除左右两端的空格" target="_blank">js去除空格，去除左右两端的空格</a> <span class="text-muted">蕃薯耀</span> <a class="tag" taget="_blank" href="/search/%E5%8E%BB%E9%99%A4%E5%B7%A6%E5%8F%B3%E4%B8%A4%E7%AB%AF%E7%9A%84%E7%A9%BA%E6%A0%BC/1.htm">去除左右两端的空格</a><a class="tag" taget="_blank" href="/search/js%E5%8E%BB%E6%8E%89%E6%89%80%E6%9C%89%E7%A9%BA%E6%A0%BC/1.htm">js去掉所有空格</a><a class="tag" taget="_blank" href="/search/js%E5%8E%BB%E9%99%A4%E7%A9%BA%E6%A0%BC/1.htm">js去除空格</a> <div>js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g</div> </li> <li><a href="/article/3002.htm" title="SpringMVC4零配置--web.xml" target="_blank">SpringMVC4零配置--web.xml</a> <span class="text-muted">hanqunfeng</span> <a class="tag" taget="_blank" href="/search/springmvc4/1.htm">springmvc4</a> <div>servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer</div> </li> <li><a href="/article/3129.htm" title="《开源框架那些事儿21》：巧借力与借巧力" target="_blank">《开源框架那些事儿21》：巧借力与借巧力</a> <span class="text-muted">j2eetop</span> <a class="tag" taget="_blank" href="/search/%E6%A1%86%E6%9E%B6/1.htm">框架</a><a class="tag" taget="_blank" href="/search/UI/1.htm">UI</a> <div>同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，</div> </li> <li><a href="/article/3256.htm" title="JQuery EasyUI 验证扩展" target="_blank">JQuery EasyUI 验证扩展</a> <span class="text-muted">可怜的猫</span> <a class="tag" taget="_blank" href="/search/jquery/1.htm">jquery</a><a class="tag" taget="_blank" href="/search/easyui/1.htm">easyui</a><a class="tag" taget="_blank" href="/search/%E9%AA%8C%E8%AF%81/1.htm">验证</a> <div>  最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&</div> </li> <li><a href="/article/3383.htm" title="架构师之httpurlconnection----------读取和发送(流读取效率通用类)" target="_blank">架构师之httpurlconnection----------读取和发送(流读取效率通用类)</a> <span class="text-muted">nannan408</span> <div>1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream</div> </li> <li><a href="/article/3510.htm" title="Jquery性能优化" target="_blank">Jquery性能优化</a> <span class="text-muted">r361251</span> <a class="tag" taget="_blank" href="/search/JavaScript/1.htm">JavaScript</a><a class="tag" taget="_blank" href="/search/jquery/1.htm">jquery</a> <div>一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page </div> </li> <li><a href="/article/3637.htm" title="在eclipse项目中使用maven管理依赖" target="_blank">在eclipse项目中使用maven管理依赖</a> <span class="text-muted">tjj006</span> <a class="tag" taget="_blank" href="/search/eclipse/1.htm">eclipse</a><a class="tag" taget="_blank" href="/search/maven/1.htm">maven</a> <div>概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把</div> </li> <li><a href="/article/3764.htm" title="中国天气网省市级联页面" target="_blank">中国天气网省市级联页面</a> <span class="text-muted">x125858805</span> <a class="tag" taget="_blank" href="/search/%E7%BA%A7%E8%81%94/1.htm">级联</a> <div>1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l</div> </li> </ul> </div> </div> </div> <div> <div class="container"> <div class="indexes"> <strong>按字母分类：</strong> <a href="/tags/A/1.htm" target="_blank">A</a><a href="/tags/B/1.htm" target="_blank">B</a><a href="/tags/C/1.htm" target="_blank">C</a><a href="/tags/D/1.htm" target="_blank">D</a><a href="/tags/E/1.htm" target="_blank">E</a><a href="/tags/F/1.htm" target="_blank">F</a><a href="/tags/G/1.htm" target="_blank">G</a><a href="/tags/H/1.htm" target="_blank">H</a><a href="/tags/I/1.htm" target="_blank">I</a><a href="/tags/J/1.htm" target="_blank">J</a><a href="/tags/K/1.htm" target="_blank">K</a><a href="/tags/L/1.htm" target="_blank">L</a><a href="/tags/M/1.htm" target="_blank">M</a><a href="/tags/N/1.htm" target="_blank">N</a><a href="/tags/O/1.htm" target="_blank">O</a><a href="/tags/P/1.htm" target="_blank">P</a><a href="/tags/Q/1.htm" target="_blank">Q</a><a href="/tags/R/1.htm" target="_blank">R</a><a href="/tags/S/1.htm" target="_blank">S</a><a href="/tags/T/1.htm" target="_blank">T</a><a href="/tags/U/1.htm" target="_blank">U</a><a href="/tags/V/1.htm" target="_blank">V</a><a href="/tags/W/1.htm" target="_blank">W</a><a href="/tags/X/1.htm" target="_blank">X</a><a href="/tags/Y/1.htm" target="_blank">Y</a><a href="/tags/Z/1.htm" target="_blank">Z</a><a href="/tags/0/1.htm" target="_blank">其他</a> </div> </div> </div> <footer id="footer" class="mb30 mt30"> <div class="container"> <div class="footBglm"> <a target="_blank" href="/">首页</a> - <a target="_blank" href="/custom/about.htm">关于我们</a> - <a target="_blank" href="/search/Java/1.htm">站内搜索</a> - <a target="_blank" href="/sitemap.txt">Sitemap</a> - <a target="_blank" href="/custom/delete.htm">侵权投诉</a> </div> <div class="copyright">版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved. <!-- <a href="https://beian.miit.gov.cn/" rel="nofollow" target="_blank">京ICP备09083238号</a><br>--> </div> </div> </footer> <!-- 代码高亮 --> <script type="text/javascript" src="/static/syntaxhighlighter/scripts/shCore.js"></script> <script type="text/javascript" src="/static/syntaxhighlighter/scripts/shLegacy.js"></script> <script type="text/javascript" src="/static/syntaxhighlighter/scripts/shAutoloader.js"></script> <link type="text/css" rel="stylesheet" href="/static/syntaxhighlighter/styles/shCoreDefault.css"/> <script type="text/javascript" src="/static/syntaxhighlighter/src/my_start_1.js"></script> </body> </html>