Using django Models 批注

原文：https://docs.djangoproject.com/en/1.6/topics/db/models/

★ 一个 widget 对应一个 HTML 表单输入元素。 widget 负责HTML的渲染，从 GET/POST 字典里抽出和此 widget 相符的数据。

Models

A model is the single, definitive source of information 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.

★ model 代表用户数据，包含数据其必要的域和行为。一般来说，一个模型映射到一个对应的表。

The basics:

• Each model is a Python class that subclasses django.db.models.Model. ★ model 是一个 Python 类，继承 django.db.models.Model
• Each attribute of the model represents a database field.  ★ model 里的属性代表 database field
• With all of this, Django gives you an automatically-generated database-access API; see Making queries. ★ Django 提供了访问数据库的 API 

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(max_length=30)
    last_name = models.CharField(max_length=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 for more details.★ 在内置类Meta里，用db_table改变默认的表名
• An id field is added automatically, but this behavior can be overridden. See Automatic primary key fields. ★ 若未指定主键 Django 提供默认的 id = models.AutoField(primary_key=True) 
• 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. ★ TODO

Using models

Once you have defined your models, you need to tell Django you’re going to use those models. Do this by editing your settings file and changing the INSTALLED_APPS setting to add the name of the module that contains your models.py.

★ 在 settings 文件的 INSTALLED_APPS 里设置 Django 应用，告诉Django你要使用这个应用下面的模型。

For example, if the models for your application live in the module myapp.models (the package structure that is created for an application by the manage.py startapp script), INSTALLED_APPS should read, in part:

INSTALLED_APPS = (
    #...
    'myapp',
    #...
)

When you add new apps to INSTALLED_APPS, be sure to run manage.py syncdb.

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. Be careful not to choose field names that conflict with the models API like clean, save, or delete.

★ Fields 定义了db table fields。不要和 models API 里的名字冲突。

Example:

from django.db import models

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

class Album(models.Model):
    artist = models.ForeignKey(Musician)
    name = models.CharField(max_length=100)
    release_date = models.DateField()
    num_stars = models.IntegerField()

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:  ★ 讲了 Field 类都做了哪些事 

• The database column type (e.g. INTEGER, VARCHAR). ★ model field 代表了db的字段
• The default HTML widget to use when rendering a form field (e.g.  type="text">, ). ★ 默认的 HTML widget 会渲染form field  
  The minimal validation requirements, used in Django’s admin and in automatically-generated forms. ★ 最小限度的 validation，用于 admin和自动生成的forms 

  Django ships with dozens of built-in field types; you can find the complete list in the model field reference. You can easily write your own fields if Django’s built-in ones don’t do the trick; see Writing custom model fields.

  Field options  ★ Field 参数

  Each field takes a certain set of field-specific arguments (documented in the model field reference). For example, CharField (and its subclasses) require a max_length argument which specifies the size of the VARCHAR database field used to store the data.

  There’s also a set of common arguments available to all field types. All are optional. They’re fully explained in the reference, but here’s a quick summary of the most often-used ones:

  null

  If  True, Django will store empty values as  NULL in the database. Default is  False.  ★ 默认为 False，设置为 True 时，Django 在db里会存把空值存为NULL   TODO

  blank

  If True, the field is allowed to be blank. Default is False.  ★ 为 True 时，field 允许为 blank。默认为 False 

  Note that this is different than null. null is purely database-related, whereas blank is validation-related. If a field hasblank=True, form validation will allow entry of an empty value. If a field has blank=False, the field will be required.

  choices

  An iterable (e.g., a list or tuple) of 2-tuples to use as choices for this field. If this is given, the default form widget will be a select box instead of the standard text field and will limit choices to the choices given.

  A choices list looks like this:

  YEAR_IN_SCHOOL_CHOICES = (
      ('FR', 'Freshman'),
      ('SO', 'Sophomore'),
      ('JR', 'Junior'),
      ('SR', 'Senior'),
      ('GR', 'Graduate'),
  )
  

  The first element in each tuple is the value that will be stored in the database, the second element will be displayed by the default form widget or in a ModelChoiceField. Given an instance of a model object, the display value for a choices field can be accessed using the get_FOO_display method. For example:

  from django.db import models
  
  class Person(models.Model):
      SHIRT_SIZES = (
          ('S', 'Small'),
          ('M', 'Medium'),
          ('L', 'Large'),
      )
      name = models.CharField(max_length=60)
      shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)
  

  >>> p = Person(name="Fred Flintstone", shirt_size="L")
  >>> p.save()
  >>> p.shirt_size
  u'L'
  >>> p.get_shirt_size_display()
  u'Large'
  

  default

  The default value for the field. This can be a value or a callable object. If callable it will be called every time a new object is created.

  help_text

  Extra “help” text to be displayed with the form widget. It’s useful for documentation even if your field isn’t used on a form.

  primary_key

  If True, this field is the primary key for the model.

  If you don’t specify primary_key=True for any fields in your model, Django will automatically add an IntegerField to hold the primary key, so you don’t need to set primary_key=True on any of your fields unless you want to override the default primary-key behavior. For more, see Automatic primary key fields.

  unique

  If  True, this field must be unique throughout the table.

  Again, these are just short descriptions of the most common field options. Full details can be found in the common model field option reference.

  Automatic primary key fields

  By default, Django gives each model the following field:

  id = models.AutoField(primary_key=True)
  

  This is an auto-incrementing primary key.

  If you’d like to specify a custom primary key, just specify primary_key=True on one of your fields. If Django sees you’ve explicitly set Field.primary_key, it won’t add the automatic id column.

  Each model requires exactly one field to have primary_key=True (either explicitly declared or automatically added).

  Verbose field names

  Each field type, except for ForeignKey, ManyToManyField and OneToOneField, 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.

  In this example, the verbose name is "person's first name":

  first_name = models.CharField("person's first name", max_length=30)
  

  In this example, the verbose name is "first name":

  first_name = models.CharField(max_length=30)
  

  ForeignKey, ManyToManyField and OneToOneField require the first argument to be a model class, so use the verbose_namekeyword argument:

  poll = models.ForeignKey(Poll, verbose_name="the related poll")
  sites = models.ManyToManyField(Site, verbose_name="list of sites")
  place = models.OneToOneField(Place, verbose_name="related place")
  

  The convention is not to capitalize the first letter of the verbose_name. Django will automatically capitalize the first letter where it needs to.

  Relationships

  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.

  Many-to-one relationships  ★ 如何定义外键 

  To define a many-to-one relationship, use django.db.models.ForeignKey. You use it just like any other Field type: by including it as a class attribute of your model.

  ForeignKey requires a positional argument: the class to which the model is related.

  For example, if a Car model has a Manufacturer – that is, a Manufacturer makes multiple cars but each Car only has oneManufacturer – use the following definitions:

  from django.db import models
  
  class Manufacturer(models.Model):
      # ...
      pass
  
  class Car(models.Model):
      manufacturer = models.ForeignKey(Manufacturer)
      # ...
  

  You can also create recursive relationships (an object with a many-to-one relationship to itself) and relationships to models not yet defined; see the model field reference for details.

  It’s suggested, but not required, that the name of a ForeignKey field (manufacturer in the example above) be the name of the model, lowercase. You can, of course, call the field whatever you want. For example:

  class Car(models.Model):
      company_that_makes_it = models.ForeignKey(Manufacturer)
      # ...
  

  See also

  ForeignKey fields accept a number of extra arguments which are explained in the model field reference. These options help define how the relationship should work; all are optional.

  For details on accessing backwards-related objects, see the Following relationships backward example.

  For sample code, see the Many-to-one relationship model example.

  Many-to-many relationships

  To define a many-to-many relationship, use ManyToManyField. You use it just like any other Field type: by including it as a class attribute of your model.  ★ 两个 model 之间多对多的关系 

  ManyToManyField requires a positional argument: the class to which the model is related.

  For example, if a Pizza has multiple Topping objects – that is, a Topping can be on multiple pizzas and each Pizza has multiple toppings – here’s how you’d represent that:

  from django.db import models
  
  class Topping(models.Model):
      # ...
      pass
  
  class Pizza(models.Model):
      # ...
      toppings = models.ManyToManyField(Topping)
  

  As with ForeignKey, you can also create recursive relationships (an object with a many-to-many relationship to itself) andrelationships to models not yet defined; see the model field reference for details.  ★ 有可选的参数可供使用 

  It’s suggested, but not required, that the name of a ManyToManyField (toppings in the example above) be a plural describing the set of related model objects.

  It doesn’t matter which model has the ManyToManyField, but you should only put it in one of the models – not both.

  Generally, ManyToManyField instances should go in the object that’s going to be edited on a form. In the above example,toppings is in Pizza (rather than Topping having a pizzas ManyToManyField ) because it’s more natural to think about a pizza having toppings than a topping being on multiple pizzas. The way it’s set up above, the Pizza form would let users select the toppings. ★ 要根据实际情况来决定 ManyToManyField 应该放在哪里 

  See also

  See the Many-to-many relationship model example for a full example.

  ManyToManyField fields also accept a number of extra arguments which are explained in the model field reference. These options help define how the relationship should work; all are optional.

  Extra fields on many-to-many relationships

  When you’re only dealing with simple many-to-many relationships such as mixing and matching pizzas and toppings, a standard ManyToManyField is all you need. However, sometimes you may need to associate data with the relationship between two models.

  For example, consider the case of an application tracking the musical groups which musicians belong to. There is a many-to-many relationship between a person and the groups of which they are a member, so you could use a ManyToManyField to represent this relationship. However, there is a lot of detail about the membership that you might want to collect, such as the date at which the person joined the group.

  For these situations, Django allows you to specify the model that will be used to govern the many-to-many relationship. You can then put extra fields on the intermediate model. The intermediate model is associated with the ManyToManyField using the through argument to point to the model that will act as an intermediary. For our musician example, the code would look something like this:

  ★ 想在 many-to-many 关系保存额外信息，用 through 参数，例子如下。

  from django.db import models
  
  class Person(models.Model):
      name = models.CharField(max_length=128)
  
      # On Python 3: def __str__(self):
      def __unicode__(self):
          return self.name
  
  class Group(models.Model):
      name = models.CharField(max_length=128)
      members = models.ManyToManyField(Person, through='Membership')
  
      # On Python 3: def __str__(self):
      def __unicode__(self):
          return self.name
  
  class Membership(models.Model):
      person = models.ForeignKey(Person)
      group = models.ForeignKey(Group)
      date_joined = models.DateField()
      invite_reason = models.CharField(max_length=64)
  

  When you set up the intermediary model, you explicitly specify foreign keys to the models that are involved in the ManyToMany relation. This explicit declaration defines how the two models are related.  ★ 中介 model，需要特别指定外键。

  There are a few restrictions on the intermediate model:

  • Your intermediate model must contain one - and only one - foreign key to the target model (this would be Person in our example). If you have more than one foreign key, a validation error will be raised.   ★ 中介 model 必须且只包含一个 target model 的外键。
  • Your intermediate model must contain one - and only one - foreign key to the source model (this would be Group in our example). If you have more than one foreign key, a validation error will be raised.  ★  中介 model 必须且只包含一个 source model 的外键。
  • The only exception to this is a model which has a many-to-many relationship to itself, through an intermediary model. In this case, two foreign keys to the same model are permitted, but they will be treated as the two (different) sides of the many-to-many relation. ★ 只有一个例外，当多对多关系出现在自我包含时。
  • When defining a many-to-many relationship from a model to itself, using an intermediary model, you must use symmetrical=False (see the model field reference). ★ 当自我包含多对多关系时，必须指定 symmetrical=False 

  Now that you have set up your ManyToManyField to use your intermediary model (Membership, in this case), you’re ready to start creating some many-to-many relationships. You do this by creating instances of the intermediate model:

  >>> ringo = Person.objects.create(name="Ringo Starr")
  >>> paul = Person.objects.create(name="Paul McCartney")
  >>> beatles = Group.objects.create(name="The Beatles")
  >>> m1 = Membership(person=ringo, group=beatles,
  ...     date_joined=date(1962, 8, 16),
  ...     invite_reason="Needed a new drummer.")
  >>> m1.save()
  >>> beatles.members.all()
  []
  >>> ringo.group_set.all()
  []
  >>> m2 = Membership.objects.create(person=paul, group=beatles,
  ...     date_joined=date(1960, 8, 1),
  ...     invite_reason="Wanted to form a band.")
  >>> beatles.members.all()
  [, ]
  

  ★ 这个实例展示了如何设置中介 model 
  

  Unlike normal many-to-many fields, you can’t use add, create, or assignment (i.e., beatles.members = [...]) to create relationships:

  # THIS WILL NOT WORK
  >>> beatles.members.add(john)
  # NEITHER WILL THIS
  >>> beatles.members.create(name="George Harrison")
  # AND NEITHER WILL THIS
  >>> beatles.members = [john, paul, ringo, george]

  ★ 不像普通的多对多field，不能使用 add, create 或 签名方法来创建关系
  

  Why? You can’t just create a relationship between a Person and a Group - you need to specify all the detail for the relationship required by the Membership model. The simple add, create and assignment calls don’t provide a way to specify this extra detail. As a result, they are disabled for many-to-many relationships that use an intermediate model. The only way to create this type of relationship is to create instances of the intermediate model.

  ★ 唯一的解决之道在于创建实例，然后完善细节
  

  The remove() method is disabled for similar reasons. However, the clear() method can be used to remove all many-to-many relationships for an instance:

  >>> # Beatles have broken up
  >>> beatles.members.clear()
  >>> # Note that this deletes the intermediate model instances
  >>> Membership.objects.all()
  []
  

  ★ remove() 方法也无法使用，只能使用 clear() 方法 
  

  Once you have established the many-to-many relationships by creating instances of your intermediate model, you can issue queries. Just as with normal many-to-many relationships, you can query using the attributes of the many-to-many-related model:

  # Find all the groups with a member whose name starts with 'Paul'
  >>> Group.objects.filter(members__name__startswith='Paul')
  []

  ★ 中介 model 和普通的多对多 model 的query 方法是一样的
  

  As you are using an intermediate model, you can also query on its attributes:

  # Find all the members of the Beatles that joined after 1 Jan 1961
  >>> Person.objects.filter(
  ...     group__name='The Beatles',
  ...     membership__date_joined__gt=date(1961,1,1))
  [ 
       

  ★ 可以用中介 model 的属性来 query 数据 

  If you need to access a membership’s information you may do so by directly querying the Membership model:

  >>> ringos_membership = Membership.objects.get(group=beatles, person=ringo)
  >>> ringos_membership.date_joined
  datetime.date(1962, 8, 16)
  >>> ringos_membership.invite_reason
  u'Needed a new drummer.'
  

  ★ 需要访问中介 model 信息时，可以直接 query 中介 model 
  

  Another way to access the same information is by querying the many-to-many reverse relationship from a Person object:

  >>> ringos_membership = ringo.membership_set.get(group=beatles)
  >>> ringos_membership.date_joined
  datetime.date(1962, 8, 16)
  >>> ringos_membership.invite_reason
  u'Needed a new drummer.'
  

  ★ 需要反向查找数据时，用 _set 

  One-to-one relationships

  To define a one-to-one relationship, use OneToOneField. You use it just like any other Field type: by including it as a class attribute of your model. ★ 使用 OneToOneField 来定义一对一关系

  This is most useful on the primary key of an object when that object “extends” another object in some way.

  OneToOneField requires a positional argument: the class to which the model is related.

  For example, if you were 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 Restaurant model, you could make Restaurant have a OneToOneField to Place (because a restaurant “is a” place; in fact, to handle this you’d typically use inheritance, which involves an implicit one-to-one relation).

  ★ 例如，当需要创建一个 places 的db表时，已经创建了“地址”，“电话号”等字段。然后，你需要创建一个餐馆的db表。简便的做法是在 Restaurant 里包含一个一对一的关系（因为餐馆也是一个place，你可能会使用“继承”）。
  

  As with ForeignKey, a recursive relationship can be defined and references to as-yet undefined models can be made; see the model field reference for details.

  See also

  See the One-to-one relationship model example for a full example.  ★ 一对一关系的例子 

  OneToOneField fields also accept one specific, optional parent_link argument described in the model field reference.

  OneToOneField classes used to automatically become the primary key on a model. This is no longer true (although you can manually pass in the primary_key argument if you like). Thus, it’s now possible to have multiple fields of type OneToOneField on a single model.  ★ OneToOneField 不再自动的成为 model 的主键，所以现在可以在一个 model 里添加多个 OneToOneField 了。

  Models across files

  It’s perfectly OK to relate a model to one from another app. To do this, import the related model at the top of the file where your model is defined. Then, just refer to the other model class wherever needed. For example: ★ 讲了如何引用其它应用里的 model

  from django.db import models
  from geography.models import ZipCode
  
  class Restaurant(models.Model):
      # ...
      zip_code = models.ForeignKey(ZipCode)
  

  Field name restrictions

  Django places only two restrictions on model field names:  ★ model field name 有两点限制，第一，不能使用 Python 关键字；第二，不能包含双下划线。

  1. A field name cannot be a Python reserved word, because that would result in a Python syntax error. For example:

     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:

     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 the db_column option.

  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.

  Custom field types

  If one of the existing model fields cannot be used to fit your purposes, or if you wish to take advantage of some less common database column types, you can create your own field class. Full coverage of creating your own fields is provided in Writing custom model fields.

  ★ 定制 field types
  

  Meta options

  Give your model metadata by using an inner class Meta, like so: ★ 在 model 类里的内置 Meta Python 类，包含了除 field 的一切信息。非常有用！！

  from django.db import models
  
  class Ox(models.Model):
      horn_length = models.IntegerField()
  
      class Meta:
          ordering = ["horn_length"]
          verbose_name_plural = "oxen"
  

  Model metadata is “anything that’s not a field”, such as ordering options (ordering), database table name (db_table), or human-readable singular and plural names (verbose_name and verbose_name_plural). None are required, and addingclass Meta to a model is completely optional.

  A complete list of all possible Meta options can be found in the model option reference.

  Model methods

  Define custom methods on a model to add custom “row-level” functionality to your objects. Whereas Manager methods are intended to do “table-wide” things, model methods should act on a particular model instance.

  This is a valuable technique for keeping business logic in one place – the model.

  ★ 在 model 里定制一些方法，实现一些方便实用的功能 
  

  For example, this model has a few custom methods:

  from django.db import models
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
      birth_date = models.DateField()
      address = models.CharField(max_length=100)
      city = models.CharField(max_length=50)
      state = models.CharField(max_length=2)      # yes, this is America-centric
  
      def baby_boomer_status(self):
          "Returns the person's baby-boomer status."
          import datetime
          if self.birth_date < datetime.date(1945, 8, 1):
              return "Pre-boomer"
          elif self.birth_date < datetime.date(1965, 1, 1):
              return "Baby boomer"
          else:
              return "Post-boomer"
  
      def is_midwestern(self):
          "Returns True if this person is from the Midwest."
          return self.state in ('IL', 'WI', 'MI', 'IN', 'OH', 'IA', 'MO')
  
      def _get_full_name(self):
          "Returns the person's full name."
          return '%s %s' % (self.first_name, self.last_name)
      full_name = property(_get_full_name)
  

  The last method in this example is a property.

  The model instance reference has a complete list of methods automatically given to each model. You can override most of these – see overriding predefined model methods, below – but there are a couple that you’ll almost always want to define:

  __str__() (Python 3)

  Python 3 equivalent of  __unicode__().

  __unicode__() (Python 2)

  A Python “magic method” that returns a unicode “representation” of any object. This is what Python and Django will use whenever a model instance needs to be coerced and displayed as a plain string. Most notably, this happens when you display an object in an interactive console or in the admin.

  You’ll always want to define this method; the default isn’t very helpful at all.

  get_absolute_url()

  This tells Django how to calculate the URL for an object. Django uses this in its admin interface, and any time it needs to figure out a URL for an object.

  Any object that has a URL that uniquely identifies it should define this method.

  ★ 实用的方法！（我还不太清楚怎么用）
  

  Overriding predefined model methods

  There’s another set of model methods that encapsulate a bunch of database behavior that you’ll want to customize. In particular you’ll often want to change the way save() and delete() work.  ★ 覆盖 model 的方法，可以添加一些额外的功能。

  You’re free to override these methods (and any other model method) to alter behavior.

  A classic use-case for overriding the built-in methods is if you want something to happen whenever you save an object. For example (see save() for documentation of the parameters it accepts):

  from django.db import models
  
  class Blog(models.Model):
      name = models.CharField(max_length=100)
      tagline = models.TextField()
  
      def save(self, *args, **kwargs):
          do_something()
          super(Blog, self).save(*args, **kwargs) # Call the "real" save() method.
          do_something_else()
  

  You can also prevent saving:

  from django.db import models
  
  class Blog(models.Model):
      name = models.CharField(max_length=100)
      tagline = models.TextField()
  
      def save(self, *args, **kwargs):
          if self.name == "Yoko Ono's blog":
              return # Yoko shall never have her own blog!
          else:
              super(Blog, self).save(*args, **kwargs) # Call the "real" save() method.
  

  It’s important to remember to call the superclass method – that’s that super(Blog, self).save(*args, **kwargs) business – to ensure that the object still gets saved into the database. If you forget to call the superclass method, the default behavior won’t happen and the database won’t get touched.  ★ 一定别忘了调用父类的方法，例如 super(Blog, self).save(*args, **kwargs)

  It’s also important that you pass through the arguments that can be passed to the model method – that’s what the *args, **kwargs bit does. Django will, from time to time, extend the capabilities of built-in model methods, adding new arguments. If you use *args, **kwargs in your method definitions, you are guaranteed that your code will automatically support those arguments when they are added.

  Overridden model methods are not called on bulk operations

  Note that the delete() method for an object is not necessarily called when deleting objects in bulk using a QuerySet. To ensure customized delete logic gets executed, you can use pre_delete and/or post_delete signals.

  Unfortunately, there isn’t a workaround when creating or updating objects in bulk, since none of save(),pre_save, and post_save are called.

  Executing custom SQL

  Another common pattern is writing custom SQL statements in model methods and module-level methods. For more details on using raw SQL, see the documentation on using raw SQL.

  Model inheritance

  Model inheritance in Django works almost identically to the way normal class inheritance works in Python. The only decision you have to make is whether you want the parent models to be models in their own right (with their own database tables), or if the parents are just holders of common information that will only be visible through the child models.

  There are three styles of inheritance that are possible in Django.

  1. Often, you will just want to use the parent class to hold information that you don’t want to have to type out for each child model. This class isn’t going to ever be used in isolation, so Abstract base classes are what you’re after.  ★ 有时，仅仅想用父类存放数据而不想在子类重复定义model。使用 Abstract base classes 
  2. If you’re subclassing an existing model (perhaps something from another application entirely) and want each model to have its own database table, Multi-table inheritance is the way to go.  ★ 如果继承自一个 model（从其它的应用）想让每个model拥有它自己的db表，使用 Muti-table inheritance。
  3. Finally, if you only want to modify the Python-level behavior of a model, without changing the models fields in any way, you can use Proxy models.  ★ 仅仅想改变一个 model 的 Python-level 的行为，而不想修改 models fields，可以使用 Proxy models 

  Abstract base classes

  Abstract base classes are useful when you want to put some common information into a number of other models. You write your base class and put abstract=True in the Meta class. This model will then not be used to create any database table. Instead, when it is used as a base class for other models, its fields will be added to those of the child class. It is an error to have fields in the abstract base class with the same name as those in the child (and Django will raise an exception).  ★ 抽象基类十分有用，当你想让其它models使用一些共通的fields。你只需要实现基类，把 abstract=True放在Meta类里。抽象类不该也不会创建db表。抽象类是为了其它 models 而存在，它的 fields 会被加入子类里。当子类和父类有同样的fields时会抛出 error 

  An example:

  from django.db import models
  
  class CommonInfo(models.Model):
      name = models.CharField(max_length=100)
      age = models.PositiveIntegerField()
  
      class Meta:
          abstract = True
  
  class Student(CommonInfo):
      home_group = models.CharField(max_length=5)
  

  The Student model will have three fields: name, age and home_group. The CommonInfo model cannot be used as a normal Django model, since it is an abstract base class. It does not generate a database table or have a manager, and cannot be instantiated or saved directly.

  For many uses, this type of model inheritance will be exactly what you want. It provides a way to factor out common information at the Python level, whilst still only creating one database table per child model at the database level.

  Meta inheritance

  When an abstract base class is created, Django makes any Meta inner class you declared in the base class available as an attribute. If a child class does not declare its own Meta class, it will inherit the parent’s Meta. If the child wants to extend the parent’s Meta class, it can subclass it. For example: ★ 当抽象类被创建，Django 会让抽象类的 Meta 作为一个属性。如果子类没有声明自己的 Meta 内部类，子类会继承父类的 Meta。如果子类想扩展父类的 Meta 类，子类的Meta可以继承父类的 Meta 类，例子如下。

  from django.db import models
  
  class CommonInfo(models.Model):
      # ...
      class Meta:
          abstract = True
          ordering = ['name']
  
  class Student(CommonInfo):
      # ...
      class Meta(CommonInfo.Meta):
          db_table = 'student_info'
  

  Django does make one adjustment to the Meta class of an abstract base class: before installing the Meta attribute, it sets abstract=False. This means that children of abstract base classes don’t automatically become abstract classes themselves. Of course, you can make an abstract base class that inherits from another abstract base class. You just need to remember to explicitly set abstract=True each time. ★ 继承抽象类的子类不会成为抽象类

  Some attributes won’t make sense to include in the Meta class of an abstract base class. For example, including db_table would mean that all the child classes (the ones that don’t specify their own Meta) would use the same database table, which is almost certainly not what you want.  ★ 继承时，db_table 不在继承范围之列。

  ★ 最典型的应用：Django 自带的 AbstractBaseUser 和 AbstractUser 方法，它们在 django.contrib.auth.models 里，感兴趣的童靴可以看看 

  Be careful with related_name  ★ TODO

  If you are using the related_name attribute on a ForeignKey or ManyToManyField, you must always specify a unique reverse name for the field. This would normally cause a problem in abstract base classes, since the fields on this class are included into each of the child classes, with exactly the same values for the attributes (including related_name) each time.

  To work around this problem, when you are using related_name in an abstract base class (only), part of the name should contain '%(app_label)s' and '%(class)s'.

  • '%(class)s' is replaced by the lower-cased name of the child class that the field is used in.
  • '%(app_label)s' is replaced by the lower-cased name of the app the child class is contained within. Each installed application name must be unique and the model class names within each app must also be unique, therefore the resulting name will end up being different.

  For example, given an app common/models.py:

  from django.db import models
  
  class Base(models.Model):
      m2m = models.ManyToManyField(OtherModel, related_name="%(app_label)s_%(class)s_related")
  
      class Meta:
          abstract = True
  
  class ChildA(Base):
      pass
  
  class ChildB(Base):
      pass
  

  Along with another app rare/models.py:

  from common.models import Base
  
  class ChildB(Base):
      pass
  

  The reverse name of the common.ChildA.m2m field will be common_childa_related, whilst the reverse name of thecommon.ChildB.m2m field will be common_childb_related, and finally the reverse name of the rare.ChildB.m2m field will berare_childb_related. It is up to you how you use the '%(class)s' and '%(app_label)s portion to construct your related name, but if you forget to use it, Django will raise errors when you validate your models (or run syncdb).

  If you don’t specify a related_name attribute for a field in an abstract base class, the default reverse name will be the name of the child class followed by '_set', just as it normally would be if you’d declared the field directly on the child class. For example, in the above code, if the related_name attribute was omitted, the reverse name for the m2m field would bechilda_set in the ChildA case and childb_set for the ChildB field.

  Multi-table inheritance

  The second type of model inheritance supported by Django is when each model in the hierarchy is a model all by itself. Each model corresponds to its own database table and can be queried and created individually. The inheritance relationship introduces links between the child model and each of its parents (via an automatically-created OneToOneField). For example:  ★ 第二种被Django支持的是直接继承 model。每个 model 都对应一个db，且能被独立的查询和创建。

  from django.db import models
  
  class Place(models.Model):
      name = models.CharField(max_length=50)
      address = models.CharField(max_length=80)
  
  class Restaurant(Place):
      serves_hot_dogs = models.BooleanField()
      serves_pizza = models.BooleanField()
  

  All of the fields of Place will also be available in Restaurant, although the data will reside in a different database table. So these are both possible:

  >>> Place.objects.filter(name="Bob's Cafe")
  >>> Restaurant.objects.filter(name="Bob's Cafe")
  

  If you have a Place that is also a Restaurant, you can get from the Place object to the Restaurant object by using the lower-case version of the model name: ★ 可以通过 Place 查找 Restaurant 

  >>> p = Place.objects.get(id=12)
  # If p is a Restaurant object, this will give the child class:
  >>> p.restaurant
  
  

  However, if p in the above example was not a Restaurant (it had been created directly as a Place object or was the parent of some other class), referring to p.restaurant would raise a Restaurant.DoesNotExist exception.

  Meta and multi-table inheritance

  In the multi-table inheritance situation, it doesn’t make sense for a child class to inherit from its parent’s Meta class. All theMeta options have already been applied to the parent class and applying them again would normally only lead to contradictory behavior (this is in contrast with the abstract base class case, where the base class doesn’t exist in its own right). ★ 不支持子类从父类继承 Meta 类。

  So a child model does not have access to its parent’s Meta class. However, there are a few limited cases where the child inherits behavior from the parent: if the child does not specify an ordering attribute or a get_latest_by attribute, it will inherit these from its parent. ★ 但是当子类不包含 ordering 和 get_latest_by 时，这两个属性会从父类继承 

  If the parent has an ordering and you don’t want the child to have any natural ordering, you can explicitly disable it:

  class ChildModel(ParentModel):
      # ...
      class Meta:
          # Remove parent's ordering effect
          ordering = []
  

  Inheritance and reverse relations

  Because multi-table inheritance uses an implicit OneToOneField to link the child and the parent, it’s possible to move from the parent down to the child, as in the above example. However, this uses up the name that is the default related_name value for ForeignKey and ManyToManyField relations. If you are putting those types of relations on a subclass of another model, you must specify the related_name attribute on each such field. If you forget, Django will raise an error when you run validate or syncdb.  ★ 当另一个子类有 ForeignKey 和 ManyToManyField 时，必须在这两个 field type 里指定 related_name 

  For example, using the above Place class again, let’s create another subclass with a ManyToManyField:

  class Supplier(Place):
      # Must specify related_name on all relations.
      customers = models.ManyToManyField(Restaurant, related_name='provider')
  

  Specifying the parent link field

  As mentioned, Django will automatically create a OneToOneField linking your child class back any non-abstract parent models. If you want to control the name of the attribute linking back to the parent, you can create your own OneToOneField and set parent_link=True to indicate that your field is the link back to the parent class. ★ Django 会在SQL语句里给子类和父类创建 OneToOneField 的关系。如果想定制链接回父类的那个field的名字，可以创建自己的 OneToOneField 并 设置 parent_link=True 

  Proxy models

  When using multi-table inheritance, a new database table is created for each subclass of a model. This is usually the desired behavior, since the subclass needs a place to store any additional data fields that are not present on the base class. Sometimes, however, you only want to change the Python behavior of a model – perhaps to change the default manager, or add a new method.

  ★ 当使用继承时，会为每个子类创建一个新的db表，这通常是需求性很大的：需要一个地方存放额外的不在父类里存在的数据fields，例如前面举的Place和餐馆的例子。然而有时，仅仅要改变 model 的方法 -- 例如，改变默认的 manager或添加一个新方法。

  This is what proxy model inheritance is for: creating a  proxy  for the original model. You can create, delete and update instances of the proxy model and all the data will be saved as if you were using the original (non-proxied) model. The difference is that you can change things like the default model ordering or the default manager in the proxy, without having to alter the original.

  ★ 代理一个model类，不能包含任何fields，在代理类里添加新的方法，不必改变父类。
  

  Proxy models are declared like normal models. You tell Django that it’s a proxy model by setting the proxy attribute of the Meta class to True.

  ★ 代理 model 和普通的继承类一样声明，只需在 Meta 里把 proxy 设置为 True 
  

  For example, suppose you want to add a method to the Person model. You can do it like this:

  from django.db import models
  
  class Person(models.Model):
      first_name = models.CharField(max_length=30)
      last_name = models.CharField(max_length=30)
  
  class MyPerson(Person):
      class Meta:
          proxy = True
  
      def do_something(self):
          # ...
          pass
  

  The MyPerson class operates on the same database table as its parent Person class. In particular, any new instances of Person will also be accessible through MyPerson, and vice-versa:  ★ MyPerson 类操作父类 Person 对应的表。

  >>> p = Person.objects.create(first_name="foobar")
  >>> MyPerson.objects.get(first_name="foobar")
  
  

  You could also use a proxy model to define a different default ordering on a model. You might not always want to order the Person model, but regularly order by the last_name attribute when you use the proxy. This is easy:  ★ 具体应用：可以用代理 model 定义一个不同的排序

  class OrderedPerson(Person):
      class Meta:
          ordering = ["last_name"]
          proxy = True
  

  Now normal Person queries will be unordered and OrderedPerson queries will be ordered by last_name.

  QuerySets still return the model that was requested

  There is no way to have Django return, say, a MyPerson object whenever you query for Person objects. A queryset forPerson objects will return those types of objects. The whole point of proxy objects is that code relying on the original Personwill use those and your own code can use the extensions you included (that no other code is relying on anyway). It is not a way to replace the Person (or any other) model everywhere with something of your own creation.

  Base class restrictions

  A proxy model must inherit from exactly one non-abstract model class. You can’t inherit from multiple non-abstract models as the proxy model doesn’t provide any connection between the rows in the different database tables. A proxy model can inherit from any number of abstract model classes, providing they do not define any model fields.  ★ 代理 model 必须继承自一个非抽象类。不支持代理类的多继承。代理类若继承自多个抽象 model 类，只能提供一个没有定义任何 model fields 的实例。  TODO 有待验证

  Proxy models inherit any Meta options that they don’t define from their non-abstract model parent (the model they are proxying for).

  Proxy model managers

  If you don’t specify any model managers on a proxy model, it inherits the managers from its model parents. If you define a manager on the proxy model, it will become the default, although any managers defined on the parent classes will still be available.  ★ 如果在代理类里指定任何的 managers，它会继承父类的。如果在代理类里定义了一个 manager，定义的 manager 会成为默认的，父类的 managers 也可以获得。

  Continuing our example from above, you could change the default manager used when you query the Person model like this:

  from django.db import models
  
  class NewManager(models.Manager):
      # ...
      pass
  
  class MyPerson(Person):
      objects = NewManager()
  
      class Meta:
          proxy = True
  

  If you wanted to add a new manager to the Proxy, without replacing the existing default, you can use the techniques described in the custom manager documentation: create a base class containing the new managers and inherit that after the primary base class:  ★ 若在代理类里新添加的 manager 不想覆盖父类的，可以创建一个包含新managers的基类，然后继承，顺序要在主要的父类之后，例子如下。

  # Create an abstract class for the new manager.
  class ExtraManagers(models.Model):
      secondary = NewManager()
  
      class Meta:
          abstract = True
  
  class MyPerson(Person, ExtraManagers):
      class Meta:
          proxy = True
  

  You probably won’t need to do this very often, but, when you do, it’s possible.

  Differences between proxy inheritance and unmanaged models

  Proxy model inheritance might look fairly similar to creating an unmanaged model, using the managed attribute on a model’s Meta class. The two alternatives are not quite the same and it’s worth considering which one you should use.

  One difference is that you can (and, in fact, must unless you want an empty model) specify model fields on models withMeta.managed=False. You could, with careful setting of Meta.db_table create an unmanaged model that shadowed an existing model and add Python methods to it. However, that would be very repetitive and fragile as you need to keep both copies synchronized if you make any changes.

  The other difference that is more important for proxy models, is how model managers are handled. Proxy models are intended to behave exactly like the model they are proxying for. So they inherit the parent model’s managers, including the default manager. In the normal multi-table model inheritance case, children do not inherit managers from their parents as the custom managers aren’t always appropriate when extra fields are involved. The manager documentation has more details about this latter case.

  When these two features were implemented, attempts were made to squash them into a single option. It turned out that interactions with inheritance, in general, and managers, in particular, made the API very complicated and potentially difficult to understand and use. It turned out that two options were needed in any case, so the current separation arose.

  So, the general rules are:

  1. If you are mirroring an existing model or database table and don’t want all the original database table columns, use Meta.managed=False. That option is normally useful for modeling database views and tables not under the control of Django.  ★ 当需要一个已存在的model或db表的“镜子”，并且不想要所有的源表字段时，使用 Meta.managed=False 。
  2. If you are wanting to change the Python-only behavior of a model, but keep all the same fields as in the original, use Meta.proxy=True. This sets things up so that the proxy model is an exact copy of the storage structure of the original model when data is saved.  ★ 当想改变一个 model 的行为时（Python-level behavior），代理类拥有父类的同样的 fields，使用 Meta.proxy = True 

  Multiple inheritance

  Just as with Python’s subclassing, it’s possible for a Django model to inherit from multiple parent models. Keep in mind that normal Python name resolution rules apply. The first base class that a particular name (e.g. Meta) appears in will be the one that is used; for example, this means that if multiple parents contain a Meta class, only the first one is going to be used, and all others will be ignored.

  Generally, you won’t need to inherit from multiple parents. The main use-case where this is useful is for “mix-in” classes: adding a particular extra field or method to every class that inherits the mix-in. Try to keep your inheritance hierarchies as simple and straightforward as possible so that you won’t have to struggle to work out where a particular piece of information is coming from.  ★ 一般来说，不会使用多继承。一旦使用要避免一些问题，以便保持代码的整洁。

  Field name “hiding” is not permitted

  In normal Python class inheritance, it is permissible for a child class to override any attribute from the parent class. In Django, this is not permitted for attributes that are Field instances (at least, not at the moment). If a base class has a field called author, you cannot create another model field called author in any class that inherits from that base class.

  Overriding fields in a parent model leads to difficulties in areas such as initializing new instances (specifying which field is being initialized in Model.__init__) and serialization. These are features which normal Python class inheritance doesn’t have to deal with in quite the same way, so the difference between Django model inheritance and Python class inheritance isn’t arbitrary.

  This restriction only applies to attributes which are Field instances. Normal Python attributes can be overridden if you wish. It also only applies to the name of the attribute as Python sees it: if you are manually specifying the database column name, you can have the same column name appearing in both a child and an ancestor model for multi-table inheritance (they are columns in two different database tables).

  Django will raise a FieldError if you override any model field in any ancestor model.

  ★ Python 类继承支持子类覆盖父类的任何属性，然而在 Django 里，不允许覆盖 Field 实例。意味着，若父类里有一个名为 author 的 field，不允许子类覆盖之。
  

  
  

  
  

  你可能感兴趣的:(django)

  • Ubuntu18.04 Docker部署Kinship(Django)项目过程 Dante617
    1Docker的安装https://blog.csdn.net/weixin_41735055/article/details/1003551792下载镜像dockerpullprogramize/python3.6.8-dlib下载的镜像里包含python3.6.8和dlib19.17.03启动镜像dockerrun-it--namekinship-p7777:80-p3307:3306-p55
  • 软件测试/测试开发/全日制 |利用Django REST framework构建微服务 霍格沃兹-慕漓 django微服务sqlite
    霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
  • 锋哥写一套前后端分离Python权限系统 基于Django5+DRF+Vue3.2+Element Plus+Jwt 视频教程 ，帅呆了~~ java1234_小锋 Python权限系统django权限系统pythonweb权限系统djangoDRFVUE权限python
    大家好，我是java1234_小锋老师，最近写了一套【前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt】视频教程，持续更新中，计划月底更新完，感谢支持。视频在线地址：打造前后端分离Python权限系统基于Django5+DRF+Vue3.2+ElementPlus+Jwt视频教程（火爆连载更新中..）_哔哩哔哩_bilibili项目介绍本课程采
  • 2.8.5Django --8.2 单表操作 寒暄_HX
    Django目录：https://www.jianshu.com/p/dc36f62b3dc5Yuan先生-Django模型层（1）Django与SQLAlchemy的ORM操作本质上是一样的，但是语法略有不同，如果是用Django进行开发最好使用原生的ORM或者直接使用原生SQL。创建表app06创建模型在app06中的models.py文件内，新建一个模板。one_exa.app06.mode
  • 关于django中几个重要的gunicorn worker的配置 给我起把狙 djangogunicorn
    关于django中几个重要的gunicornworker的配置一、worker_classworker_class是Gunicorn的配置参数之一，它指定了工作进程（worker）的类型。不同的worker_class提供了不同的并发模型，适合不同类型的应用场景。sync和gevent是两种常见的worker_class，它们的作用和区别如下：1.sync（同步worker）默认值：如果没有指定w
  • gunicorn未重启，导致代码没拉到最新问题。 给我起把狙 gunicornlinux运维
    问题描述：我的测试环境的django项目是用gunicorn启动的，然后我本地使用pythonmanagy.py启动的，新写了个接口，在本地测试没问题，在测试环境报404。我发现发了最新代码到远端，然后我在测试环境pull下来的时候出问题了，代码不是最新的，后来我的经理告诉我说要重启gunicorn的主进程给了我一条指令"kill-HUPgunicorn_pid(最小的)”，针对这个问题我大致做了
  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 pythondjangoflaskjavaspringboot数据分析
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
  • Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 javaspringboot数据分析pythondjangovue.jsflask
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
  • 分布式框架Celery七(Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警) yjjpp2301 Celery分布式djangopython后端
    Django中集成方式安装模块pipinstallDjango==3.2.22pipinstallcelerypipinstallredispipinstalleventlet#在windows环境下需要安装eventlet包-----------pipinstalldjango-celery-beatpipinstalldjango-celery-resultspipinstalldjango-
  • 基于django+vue代驾管理系统【开题报告+程序+论文】-计算机毕设 zhjie102 djangovue.js课程设计
    本系统（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。系统程序文件列表开题报告内容研究背景随着城市化进程的加速和人们生活水平的提高，私家车数量急剧增加，但随之而来的酒驾问题也日益严峻，严重威胁着道路交通安全与公众生命财产安全。为了有效遏制酒驾行为，代驾服务应运而生并迅速普及。然而，当前市场上的代驾服务大多依赖于电话预约、人工调度等传统方式，存在效率低下
  • Python+Django毕业设计校园易购二手交易平台（程序+LW+部署） Python、JAVA毕设程序源码 课程设计javamysql
    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
  • python毕业设计作品：python闲置物品二手交易平台系统设计与实现毕业设计源代码（Django框架） 黄菊华老师 毕设资料python二手交易平台系统
    博主介绍：黄菊华老师《Vue.js入门与商城开发实战》《微信小程序商城开发》图书作者，CSDN博客专家，在线教育专家，CSDN钻石讲师；专注大学生毕业设计教育和辅导。所有项目都配有从入门到精通的基础知识视频课程，学习后应对毕业设计答辩。项目配有对应开发文档、开题报告、任务书、PPT、论文模版等项目都录了发布和功能操作演示视频；项目的界面和功能都可以定制，包安装运行！！！如果需要联系我，可以在CSD
  • 由于篇幅和复杂性限制，我无法在这里直接为你提供一个完整的、用多种编程语言实现的购物商城代码。但是，我可以为你概述如何使用几种流行的编程语言（如Python, JavaScript/Node.js, J NewmanEdwarda2 pythonjavascriptnode.js
    Python（后端，使用Flask或Django）Flask示例（后端API）gjijg.compythonfromflaskimportFlask,request,jsonifyapp=Flask(name)假设的数据库商品列表products=[{“id”:1,“name”:“苹果”,“price”:10.0},{“id”:2,“name”:“香蕉”,“price”:5.0},]@app.ro
  • Django 安装指南 lly202406 开发语言
    Django安装指南Django是一个高级的PythonWeb框架，它鼓励快速开发和干净、实用的设计。本指南将详细介绍如何在不同的操作系统上安装Django，包括Windows、macOS和Linux。在Windows上安装Django先决条件Python:Django要求Python3.8或更高版本。可以从Python官网下载适用于Windows的Python安装程序。pip:Python的包管
  • 基于Python爬虫四川成都二手房数据可视化系统设计与实现(Django框架) 研究背景与意义、国内外研究现状_django商品房数据分析论文(1) 莫莫Android开发 信息可视化python爬虫
    3.国外研究现状在国外，二手房数据可视化也是一个热门的研究领域。以美国为例，有很多公司和网站提供了专门的二手房数据可视化工具，如Zillow、Redfin等。这些工具通常提供房价趋势图、房价分布图、房源信息等功能，帮助用户更好地了解房市动态。综上所述，虽然国内外在二手房数据可视化方面已经有了一些研究成果，但对于四川成都地区的二手房市场还没有相关的研究和可视化系统。因此，本研究旨在设计并实现一个基于
  • django中F()和Q()的用法 给我起把狙 django数据库python
    django中F()和Q()的用法一、F()表达式的详细介绍1.基本概念：F()表达式用于引用模型中的字段，允许你直接在数据库层面进行计算、比较或更新操作，而不需要将数据加载到Python内存中进行操作。这样可以提高性能，避免racecondition（数据竞争）。2.常见用法：1.字段间运算：你可以使用F()对同一记录中的不同字段进行运算。比如，你有一个模型Product，其中包含price和d
  • Django 开发实战 2-2 模型 -创建模型类 爱之泪伤 python项目实战linuxubuntu网络
    python开发实战-创建模型类一、介绍：二、根据迁移文件生成映射书库据表。三、查看数据库是否根据牵引文件的需求生成数据库，因此返回终端去连接`filmdatabase`数据库。四、最后，了解一些数据库的知识说明。一、介绍：  模型类被创建在"应用目录/models.py"文件中。模型类必须继承自Model类，位于包dango.db.models中。接下来首先以"影片-人物"管理为例进行演示。1定
  • Vue + Django的人脸识别系统 DXSsssss pythonDRFtensorflow人脸识别
    最近在研究机器学习，刚好最近看了vue+Djangodrf的一些课程，学以致用，做了一个人脸识别系统。项目前端使用Vue框架，用到了elementui组件，写起来真是方便。比之前传统的dtl方便了太多。后端使用了drf，识别知识刚开始打算使用opencv+tensorflow,但是发现吧识别以后的结果返回到浏览器当中时使用opencv比较麻烦（主要是我太菜，想不到比较好的方法），因此最终使用了tf
  • Django 创建好的模块怎么在后台显示 u010373106 pythonDjangodjango数据库sqlite
    1、配置模型及其需要显示的数据刚才创建好的tests的增删改查，在后台是不显示的，所以需要进行配置,在刚才创建好的模块里找到admin.py文件，在里面进行如下配置fromdjango.contribimportadminfrom.importmodelsfrom.modelsimportTests#Registeryourmodelshere.classTestsAdmin(admin.Mode
  • 【django】创建模型类(已更新) 敲代码敲到头发茂密 Django#ORM框架djangopython后端
    ORM框架一、创建模型类二、字段类型说明三、字段选项说明四、外键五、迁移六、添加测试数据a、数据库：需要提前手动创建数据库b、数据表：与ORM框架中的模型类一一对应c、字段：模型类中的类属性（Field子类）d、记录：类似于模型类的多个实例一、创建模型类模型类创建在应用目录/models.py文件中。模型类必须继承Model类，位于包django.db.models中。接下来首先以“影片-人物”管
  • Django+Vue基于OpenCV的人脸识别系统的设计与实现 赵广陆 projectdjangovue.jsopencv
    目录1项目介绍2项目截图3核心代码3.1需要的环境3.2Django接口层3.3实体类3.4config.ini3.5启动类3.5Vue4数据库表设计5文档参考6计算机毕设选题推荐7源码获取1项目介绍博主个人介绍：CSDN认证博客专家，CSDN平台Java领域优质创作者，全网30w+粉丝，超300w访问量，专注于大学生项目实战开发、讲解和答疑辅导，对于专业性数据证明一切！主要项目：javaweb、
  • Django核心面试题 闲人编程 程序员面试djangopython面试
    Django核心面试题Django核心面试题Django核心面试题1.Django的MVT架构是什么？2.如何创建Django项目和应用？3.DjangoORM是什么？4.什么是Django的middleware？举例说明。5.Django中的静态文件如何处理？6.如何定义Django模型？7.什么是Django的QuerySet？如何使用？8.如何进行Django的数据库迁移？9.Django中
  • Django——多apps目录情况下的app注册 叫我DPT Django框架知识点djangopython
    文章目录多apps目录下的app注册方式1-添加python导包路径方式2-修改AppConfig类名多apps目录下的app注册方式1-添加python导包路径importsyssys.path.insert(0,str(BASE_DIR/"apps"))print(sys.path)INSTALLED_APPS=['django.contrib.admin','django.contrib.a
  • Django项目中log日志的配置 叫我DPT Django项目中常用组件脚本功能djangologging
    文章目录日志配置模板日志处理器Handlers日志配置模板#日志LOGGING={'version':1,#使用的日志模块的版本，目前官方提供的只有版本1，但是官方有可能会升级，为了避免升级出现的版本问题，所以这里固定为1'disable_existing_loggers':False,#是否禁用其他的已经存在的日志功能？肯定不能，有可能有些第三方模块在调用，所以禁用了以后，第三方模块无法捕获自身
  • Django：Python高级Web框架详解及参数设置 零 度° pythonpythondjango前端
    Django是一个高级的PythonWeb框架，它鼓励快速开发和简洁实用的设计。Django遵循MVC设计模式，提供了一套完整的解决方案，用于构建复杂的、数据库驱动的网站。Django的主要特点自动管理数据库：通过ORM（对象关系映射）自动管理数据库。自动生成站点地图：支持搜索引擎优化（SEO）。用户身份认证：内置用户认证系统。中间件支持：强大的中间件支持，可以处理请求和响应。跨站请求伪造（CSR
  • Python轻量级ORM框架——peewee 半生浮名只是虚妄 Pythonpython
    这里写目录标题Python中常用的ORM框架peewee使用经验从数据库中导出模型查询统计类查询优化子查询参考文章Python中常用的ORM框架SQLALchemy：重量级框架，适合企业级开发，容易与任意Web框架集成，学习成本更高DjangoORM：Django框架中内嵌的ORM模块，易学易用，只适合Django项目使用peewee：轻量级框架，适合个人开发，容易与任意Web框架集成，API类似
  • Ubuntu系统nginx和uwsgi常用命令(部署网站相关命令) 我不是大佬zvj ubuntulinux运维
    以下是我自己在学习使用Ubuntu操作系统部署pythonflask和django网站时常用的命令，作为学习笔记，记录一下，写的比较简单，还有啥需要补充的话欢迎留言。路径相关#进入项目路径cd /var/www/html/Podcaster#nginx配置文件路径‏/etc/nginx/sites-enabled/‌‍default防火墙#查看已经开放的端口sudoufwstatus#打开端口su
  • 2025毕业设计指南：如何用Hadoop构建超市进货推荐系统？大数据分析助力精准采购 计算机编程指导师 Java实战集Python实战集大数据实战集课程设计hadoop数据分析springbootjava进货python
    ✍✍计算机编程指导师⭐⭐个人介绍：自己非常喜欢研究技术问题！专业做Java、Python、小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。⛽⛽实战项目：有源码或者技术上的问题欢迎在评论区一起讨论交流！⚡⚡Java实战|SpringBoot/SSMPython实战项目|Django微信小程序/安卓实战项目大数据实战项目⚡⚡文末获取源码文章目录⚡⚡文末获取源码基于hadoop的超市进货推荐系
  • Python Web 框架篇：Flask、Django、FastAPI介绍及其核心技术 Switch616 PythonWebpython前端flaskfastapidjango开发语言后端
    PythonWeb框架篇：Flask、Django、FastAPI介绍及其核心技术目录FlaskFlask核心概念（路由、视图函数、模板渲染）FlaskBlueprint模块化应用Flask扩展（Flask-SQLAlchemy、Flask-WTF、Flask-Migrate等）DjangoDjango项目架构DjangoORM及模型定义Django中间件Django信号机制DjangoForm和
  • python selenium post,是否可以在Selenium中捕获POST数据？ weixin_39600328 pythonseleniumpost
    I'mworkingwiththeSeleniumWebDriverToolandamwonderingifthistoolprovidesameansforcapturingthePOSTdatageneratedwhensubmittingaform.I'musingthedjangotestframeworktotestthatmydataisprocessedcorrectlyontheb
  • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIPHPandroidlinux
    ╔-----------------------------------╗┆                           
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 bozch .net.net mvc
    在.net mvc5中，在执行某一操作的时候，出现了如下错误：       各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  &
  • Java 对象大小的计算 e200702084 java
                              Java对象的大小 如何计算一个对象的大小呢？    
  • Mybatis Spring 171815164 mybatis
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerService userService = (CustomerService) ac.getBean("customerService"); Customer cust
  • JVM 不稳定参数 g21121 jvm
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
  • 用户自动登录网站 永夜-极光 用户
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 2.思路:将用户的信息保存为cookie            每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
  • centos7 安装后失去win7的引导记录 程序员是怎么炼成的 操作系统
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载 aijuans oracle
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
  • JavaEE开源快速开发平台G4Studio_V3.2发布了 無為子 AOPoraclemysqljavaeeG4Studio
      我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。   访问G4Studio网站 http://www.g4it.org   G4Studio_V3.2版本变更日志 功能新增 (1).新增了系统右下角滑出提示窗口功能。 (2).新增了文件资源的Zip压缩和解压缩
  • Oracle常用的单行函数应用技巧总结 百合不是茶 日期函数转换函数(核心)数字函数通用函数(核心)字符函数
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 一:字符函数: .UPPER(字符串) 将字符串转为大写 .LOWER (字符串) 将字符串转为小写 .INITCAP(字符串) 将首字母大写 .LENGTH (字符串) 字符串的长度 .REPLACE(字符串,'A','_') 将字符串字符A转换成_
  • Mockito异常测试实例 bijian1013 java单元测试mockito
    Mockito异常测试实例： package com.bijian.study; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Assert; import org.junit.Test; import org.mockito.
  • GA与量子恒道统计 Bill_chen JavaScript浏览器百度Google防火墙
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：   为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
  • 【Linux命令三】Top命令 bit1129 linux命令
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果：     top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99 Tasks: 202 total, 4 running, 198 sl
  • spring四种依赖注入方式 白糖_ spring
      平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
  • angular.injector boyitech AngularJSAngularJS API
    angular.injector   描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.   使用方法: angular.injector(modules, [strictDi])   参数详解: Param Type Details mod
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待 bylijinnan Integer
    public class PC { /** * 题目：生产者-消费者。 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。 */ private static final Integer[] val=new Integer[10]; private static
  • 使用Struts2.2.1配置 Chen.H apachespringWebxmlstruts
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar struts2-core-2.2.1.jar struts2-sp
  • [职业与教育]青春之歌 comsci 教育
           每个人都有自己的青春之歌............但是我要说的却不是青春...        大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的....   &nbs
  • oracle连接(join)中使用using关键字 daizj JOINoraclesqlusing
    在oracle连接(join)中使用using关键字 34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. Evaluate the following SQL statement: SELECT oi.order_id, product_id, order_date FRO
  • NIO示例 daysinsun nio
    NIO服务端代码： public class NIOServer { private Selector selector; public void startServer(int port) throws IOException { ServerSocketChannel serverChannel = ServerSocketChannel.open(
  • C语言学习homework1 dcj3sjt126com chomework
    0、 课堂练习做完 1、使用sizeof计算出你所知道的所有的类型占用的空间。 int x; sizeof(x);   sizeof(int);   # include <stdio.h> int main(void) { int x1; char x2; double x3; float x4; printf(&quo
  • select in order by , mysql排序 dcj3sjt126com mysql
    If i select like this: SELECT id FROM users WHERE id IN(3,4,8,1); This by default will select users in this order 1,3,4,8, I would like to select them in the same order that i put IN() values so:
  • 页面校验-新建项目 fanxiaolong 页面校验
    $(document).ready( function() { var flag = true; $('#changeform').submit(function() { var projectScValNull = true; var s =""; var parent_id = $("#parent_id").v
  • Ehcache（02）——ehcache.xml简介 234390216 ehcacheehcache.xml简介
    ehcache.xml简介          ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
  • junit 4.11中三个新功能 jackyrong java
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 import static org.junit.Assert.assertEquals; import java.util.Arrays; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runn
  • 国外程序员爱用苹果Mac电脑的10大理由 php教程分享 windowsPHPunixMicrosoftperl
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 1、Mac OS X 是基于 Unix 的 这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
  • 位运算、异或的实际应用 wenjinglian 位运算
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。       二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。       三． 位操作与空间压缩，针对筛素数进行空间压缩。    &n
  • weblogic部署项目出现的一些问题（持续补充中……） Everyday都不同 weblogic部署失败
    好吧，weblogic的问题确实……   问题一： org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
  • tomcat7性能调优（01） toknowme tomcat7
        Tomcat优化： 1、最大连接数最大线程等设置 <Connector port="8082" protocol="HTTP/1.1"                useBodyEncodingForURI="t
  • PO VO DAO DTO BO TO概念与区别 xp9802 javaDAO设计模式bean领域模型
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.