本文實例講述了Python Web框架之Django框架Model基礎。分享給大家供大家參考，具體如下：

model是關于你的數(shù)據(jù)的單一的，確定的信息來源。 它包含您正在存儲的數(shù)據(jù)的基本字段和行為。Django通過抽象化的模型層(models)為你的網(wǎng)絡應用提供對于數(shù)據(jù)的結構化處理和操作處理，數(shù)據(jù)庫相關的代碼一般寫在 models.py 中，Django 支持 sqlite3, MySQL, PostgreSQL等數(shù)據(jù)庫，使用數(shù)據(jù)庫API對數(shù)據(jù)庫進行增刪改查的操作。

使用哪種數(shù)據(jù)庫，只需要在settings.py中配置即可，如：

<1> sqlite： django默認使用sqlite的數(shù)據(jù)庫，默認自帶sqlite的數(shù)據(jù)庫驅動 , 引擎名稱：django.db.backends.sqlite3

<2> mysql：引擎名稱：django.db.backends.mysql

<3>如果想更改數(shù)據(jù)庫：

DATABASES = {
  'default': {
    'ENGINE': 'django.db.backends.mysql',
    'NAME': 'books',  #你的數(shù)據(jù)庫名稱
    'USER': 'root',  #你的數(shù)據(jù)庫用戶名
    'PASSWORD': '', #你的數(shù)據(jù)庫密碼
    'HOST': '', #你的數(shù)據(jù)庫主機，留空默認為localhost
    'PORT': '3306', #你的數(shù)據(jù)庫端口
  }
}

注意事項：

• NAME即數(shù)據(jù)庫的名字，在mysql連接前該數(shù)據(jù)庫必須已經(jīng)創(chuàng)建，而上面的sqlite數(shù)據(jù)庫下的db.sqlite3則是項目自動創(chuàng)建
• USER和PASSWORD分別是數(shù)據(jù)庫的用戶名和密碼。
• 設置完后，再啟動我們的Django項目前，我們需要激活我們的mysql。
• 然后，啟動項目，會報錯：no module named MySQLdb
• 這是因為django默認你導入的驅動是MySQLdb，可是MySQLdb對于py3有很大問題，所以我們需要的驅動是PyMySQL
• 所以，我們只需要找到項目名文件下的__init__,在里面寫入：

import pymysql
pymysql.install_as_MySQLdb()

Model 字段

AutoField        根據(jù)實際ID自動增長的IntegerField . 你通常不需要直接使用;
                如果不指定,一個主鍵字段將自動添加到你創(chuàng)建的
BigIntegerField    一個64位整數(shù), 類似于一個 IntegerField 這個字段默認的表單組件是一個TextInput.

IntegerField([**options])
一個整數(shù)。在Django所支持的所有數(shù)據(jù)庫中，從 -2147483648 到 2147483647 范圍內的值是合法的。默認的表單輸入工具是TextInput.

BinaryField        用來存儲原始二進制碼的Field. 只支持bytes 賦值，注意這個Field只有很有限的功能。
                例如，不大可能在一個BinaryField 值的數(shù)據(jù)上進行查詢
BooleanField    true/false 字段。默認表單掛件是一個CheckboxInput.
                如果你需要設置null 值，則使用NullBooleanField 來代替BooleanField。
                如果Field.default沒有指定的話， BooleanField 的默認值是 None。
CharField        一個用來存儲從小到很大各種長度的字符串的地方。
                如果是巨大的文本類型, 可以用 TextField.
                這個字段默認的表單樣式是 TextInput.
                CharField必須接收一個額外的參數(shù):
                CharField.max_length：字段的最大字符長度.max_length將在數(shù)據(jù)庫層和Django表單驗證中起作用, 用來限定字段的長度.

DateField        這是一個使用Python的datetime.date實例表示的日期. 有幾個額外的設置參數(shù):

                DateField.auto_now 每次保存對象時，自動設置該字段為當前時間。
                用于"最后一次修改"的時間戳。注意，它總是使用當前日期；它不只是一個默認值，你可以覆蓋。

                DateField.auto_now_add        當對象第一次被創(chuàng)建時自動設置當前時間。用于創(chuàng)建時間的時間戳.
                它總是使用當前日期；和你可以覆蓋的那種默認值不一樣。

                該字段默認對應的表單控件是一個TextInput. 在管理員站點添加了一個JavaScript寫的日歷控件，
                和一個“Today"的快捷按鈕.包含了一個額外的invalid_date錯誤消息鍵.

    DateTimeField(DateField)    - 日期+時間格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)    - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field) - 時間格式      HH:MM[:ss[.uuuuuu]]

DurationField(Field)用作存儲一段時間的字段類型 - 類似Python中的timedelta.
            - 長整數(shù)，時間間隔，數(shù)據(jù)庫中按照bigint存儲，ORM中獲取的值為datetime.timedelta類型

DecimalField(max_digits=None, decimal_places=None[, **options]) 表示十進制浮點數(shù)

EmailField([max_length=254, **options])一個 CharField 用來檢查輸入的email地址是否合法。它使用 EmailValidator 來驗證輸入合法性。

FileField([upload_to=None, max_length=100)一個上傳文件的字段。
FileField字段不支持primary_key 和unique參數(shù)，如果使用會生成 TypeError錯誤

FilePathField(path=None[, match=None, recursive=False, max_length=100])
一個 CharField ，內容只限于文件系統(tǒng)內特定目錄下的文件名。有三個參數(shù), 其中第一個是 必需的:

FloatField([**options])用Python的一個float 實例來表示一個浮點數(shù).

ImageField([upload_to=None, height_field=None, width_field=None, max_length=100, **options])
繼承了 FileField的所有屬性和方法, 但還對上傳的對象進行校驗，確保它是個有效的image.

TextField([**options])大文本字段。該模型默認的表單組件是Textarea。

TimeField([auto_now=False, auto_now_add=False, **options])
時間字段，和Python中 datetime.time 一樣。接受與DateField相同的自動填充選項。
表單默認為 TextInput.輸入框。

URLField([max_length=200, **options])一個CharField 類型的URL此字段的默認表單widget為TextInput。

UUIDField([**options])一個用來存儲UUID的字段。使用Python的UUID類。
當使用PostgreSQL數(shù)據(jù)庫時，該字段類型對應的數(shù)據(jù)庫中的數(shù)據(jù)類型是uuid

字段選項(Field options)——參數(shù)

Field.null 如果為True，Django將在數(shù)據(jù)庫中將空值存儲為NULL。默認值是 False。

Field.blank 如果為True，則該字段允許為空白。 默認值是 False。

Field.choices 它是一個可迭代的結構(比如，列表或是元組)，
由可迭代的二元組組成(比如[(A, B), (A, B) ...])，用來給這個字段提供選擇項。
如果設置了 choices ，默認表格樣式就會顯示選擇框，而不是標準的文本框，而且這個選擇框的選項就是 choices 中的元組。

Field.db_column 數(shù)據(jù)庫中用來表示該字段的名稱。如果未指定，那么Django將會使用Field名作為字段名.

Field.db_index 若值為 True, 則 django-admin sqlindexes 將會為此字段輸出 CREATE INDEX 語句。

Field.error_messages 能夠讓你重寫默認拋出的錯誤信息。通過指定 key 來確認你要重寫的錯誤信息。

Field.primary_key若為 True, 則該字段會成為模型的主鍵字段。
如果你沒有在模型的任何字段上指定 primary_key=True, Django會自動添加一個 AutoField 字段來充當主鍵。

Field.unique 如果為 True, 這個字段在表中必須有唯一值.

Field.unique_for_month 類似unique_for_date，只是要求字段對于月份是唯一的。

驗證器

Field.validators 該字段將要運行的一個Validator 的列表。

元信息Meta——使用內部的class Meta 定義模型的元數(shù)據(jù)

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

模型元數(shù)據(jù)是“任何不是字段的數(shù)據(jù)”，比如排序選項（ordering），數(shù)據(jù)表名（db_table）或者人類可讀的單復數(shù)名稱（verbose_name 和verbose_name_plural）。

在模型中添加class Meta是完全可選的，所有選項都不是必須的。

關系字段

關系數(shù)據(jù)庫的威力體現(xiàn)在表之間的相互關聯(lián)。

Django 提供了三種最常見的數(shù)據(jù)庫關系：多對一(manyto-one)，多對多(many-to-many)，一對一(one-to-one)。

• 多對一關系

Django 使用 django.db.models.ForeignKey 定義多對一關系。和使用其它字段類型一樣：在模型當中把它做為一個類屬性包含進來。

ForeignKey 需要一個位置參數(shù)：與該模型關聯(lián)的類。

limit_choices_to 當這個字段使用模型表單或者Admin 渲染時（默認情況下，查詢集中的所有對象都可以使用），

為這個字段設置一個可用的選項。它可以是一個字典、一個Q 對象或者一個返回字典或Q對象的可調用對象。

        Q(caption='root')
        db_constraint=True          # 是否在數(shù)據(jù)庫中創(chuàng)建外鍵約束
        parent_link=False           # 在Admin中是否顯示關聯(lián)數(shù)據(jù)

related_name    這個名稱用于讓關聯(lián)的對象反查到源對象。它還是related_query_name 的默認值（關聯(lián)的模型進行反向過濾時使用的名稱）。

related_query_name    這個名稱用于目標模型的反向過濾。如果設置了related_name，則默認為它的值，否則默認值為模型的名稱

to_field 關聯(lián)到的關聯(lián)對象的字段名稱。默認地，Django 使用關聯(lián)對象的主鍵。

db_constraint控制是否在數(shù)據(jù)庫中為這個外鍵創(chuàng)建約束。默認值為True

on_delete 當一個ForeignKey 引用的對象被刪除時，Django 默認模擬SQL 的ON DELETE CASCADE 的約束行為，并且刪除包含該ForeignKey的對象。這種行為可以通過設置on_delete 參數(shù)來改變。

    CASCADE級聯(lián)刪除；默認值。

    PROTECT拋出ProtectedError 以阻止被引用對象的刪除，它是django.db.IntegrityError 的一個子類。

    SET_NULL把ForeignKey 設置為null； null 參數(shù)為True 時才可以這樣做。

    SET_DEFAULT ForeignKey值設置成它的默認值；此時必須設置ForeignKey 的default 參數(shù)。

    SET() 設置ForeignKey 為傳遞給SET() 的值，如果傳遞的是一個可調用對象，則為調用后的結果。
    DO_NOTHING不采取任何動作。如果你的數(shù)據(jù)庫后端強制引用完整性，它將引發(fā)一個IntegrityError ，除非你手動添加一個ON DELETE 約束給數(shù)據(jù)庫自動

ManyToManyField一個多對多關聯(lián)。

要求一個關鍵字參數(shù)：與該模型關聯(lián)的類，與ForeignKey 的工作方式完全一樣，包括遞歸關系 和惰性關系。
關聯(lián)的對象可以通過字段的RelatedManager 添加、刪除和創(chuàng)建。

如果源模型和目標不同，則生成以下字段：

id：關系的主鍵。

<containing_model>_id：聲明ManyToManyField 字段的模型的id。
<other_model>_id：ManyToManyField 字段指向的模型的id。

如果ManyToManyField 的源模型和目標模型相同，則生成以下字段：

id：關系的主鍵。
from_<model>_id：源模型實例的id。
to_<model>_id：目標模型實例的id。

這個類可以讓一個給定的模型像普通的模型那樣查詢與之相關聯(lián)的記錄。

    to,                         # 要進行關聯(lián)的表名
    related_name=None,          # 反向操作時，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
    related_query_name=None,    # 反向操作時，使用的連接前綴，用于替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
    limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯(lián)數(shù)據(jù)時，提供的條件：
        # 如：
            - limit_choices_to={'nid__gt': 5}
            - limit_choices_to=lambda : {'nid__gt': 5}

            from django.db.models import Q
            - limit_choices_to=Q(nid__gt=10)
            - limit_choices_to=Q(nid=8) | Q(nid__gt=10)
            - limit_choices_to=lambda : Q(Q(nid=8) | Q(nid__gt=10)) & Q(caption='root')

   symmetrical=None,# 僅用于多對多自關聯(lián)時，symmetrical用于指定內部是否創(chuàng)建反向操作的字段
                # 做如下操作時，不同的symmetrical會有不同的可選字段
                    models.BB.objects.filter(...)
                    # 可選字段有：code, id, m1
                        class BB(models.Model):
                        code = models.CharField(max_length=12)
                        m1 = models.ManyToManyField('self',symmetrical=True)
                    # 可選字段有: bb, code, id, m1
                        class BB(models.Model):
                        code = models.CharField(max_length=12)
                        m1 = models.ManyToManyField('self',symmetrical=False)
        through=None,               # 自定義第三張表時，使用字段用于指定關系表
        through_fields=None,        # 自定義第三張表時，使用字段用于指定關系表中那些字段做多對多關系表
            from django.db import models
            class Person(models.Model):
                name = models.CharField(max_length=50)
            class Group(models.Model):
                name = models.CharField(max_length=128)
                members = models.ManyToManyField(
                    Person,
                    through='Membership',
                    through_fields=('group', 'person'),
                )
            class Membership(models.Model):
                group = models.ForeignKey(Group, on_delete=models.CASCADE)
                person = models.ForeignKey(Person, on_delete=models.CASCADE)
                inviter = models.ForeignKey(
                    Person,
                    on_delete=models.CASCADE,
                    related_name="membership_invites",
                )
                invite_reason = models.CharField(max_length=64)
        db_constraint=True,         # 是否在數(shù)據(jù)庫中創(chuàng)建外鍵約束
        db_table=None,              # 默認創(chuàng)建第三張表時，數(shù)據(jù)庫中表的名稱

OneToOneField

一對一關聯(lián)關系。概念上講，這個字段很像是ForeignKey 設置了unique=True，不同的是它會直接返回關系另一邊的單個對象。

它最主要的用途是作為擴展自另外一個模型的主鍵；例如，多表繼承就是通過對子模型添加一個隱式的一對一關聯(lián)關系到父模型實現(xiàn)的。

需要一個位置參數(shù)：與該模型關聯(lián)的類。 它的工作方式與ForeignKey 完全一致，包括所有與遞歸關系和惰性關系相關的選項。

以下內容個人理解筆記：

    class News(models.Model):
      title = models.CharField(max_length=10)
      favor = models.ManyToManyField('User',through="Favor",through_fields=("new_obj", 'user_obj'))
# obj = models.News.objects.get(id=1)
# v = obj.favor.all()
# print(v)
# obj.favor.add(1)不能用
# obj.favor.remove(1)不能用
# v = obj.favor.all()能用
# obj.favor.clear()能用，根據(jù)id刪，不用name這個字段
# v = models.User.objects.all()
# v = models.User.objects.all().select_related('user_type')class User(models.Model):
      name = models.CharField(max_length=10)
      email = models.EmailField(max_length=10)
      user_type = models.ForeignKey('UserType') # 一對多
      # user_profile = models.ForeignKey('UserDetail',unique=True)
      user_profile = models.OneToOneField('UserDetail')
    class UserDetail(models.Model):
      pwd = models.CharField(max_length=32)
    class Favor(models.Model):
      new_obj = models.ForeignKey('News',related_name="n")
      user_obj = models.ForeignKey('User',related_name='u')
      name = models.CharField(max_length=64,null=True,blank=True)
    class UserType(models.Model):
      name = models.CharField(max_length=10)

訪問外鍵(Foreign Key)值

python manage.py shell

當你獲取一個ForeignKey 字段時,你會得到相關的數(shù)據(jù)模型對象。

>>> from django.db import connection
>>> from app01.models import User
>>> u=User.objects.get(id=1)
>>> u
<User: User object>
>>> u.user_type
<UserType: UserType object>
>>> u.user_type.name
'type1'

對于用ForeignKey 來定義的關系來說，在關系的另一端也能反向的追溯回來，
通過一個UserType對象，直接獲取 user ，用 UserType.user_set.all() ，

實際上，user_set 只是一個 QuerySet（參考第5章的介紹），

所以它可以像QuerySet一樣,能實現(xiàn)數(shù)據(jù)過濾和分切,屬性名稱user_set是由模型名稱的小寫加_set組成的。

>>> from app01.models import UserType
>>> t=UserType.objects.get(name='type1')
>>> t.user_set.all()
<QuerySet [<User: User object>, <User: User object>]>

• 多對多

正向查找

>>> from app01.models import News
>>> n=News.objects.get(id=1)
>>> n.favor.all()
<QuerySet [<User: User object>, <User: User object>]>
>>> n.favor.filter(name='nu1')
<QuerySet [<User: User object>]>

反向查找

>>> u.news_set.all()
<QuerySet [<News: News object>]>

希望本文所述對大家基于Django框架的Python程序設計有所幫助。

最新評論