Python中Django框架Model基礎的示例分析

小編給大家分享一下Python中Django框架Model基礎的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

具體如下：

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

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

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

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

<3>如果想更改數據庫：

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

注意事項：

• NAME即數據庫的名字，在mysql連接前該數據庫必須已經創建，而上面的sqlite數據庫下的db.sqlite3則是項目自動創建

• USER和PASSWORD分別是數據庫的用戶名和密碼。

• 設置完后，再啟動我們的Django項目前，我們需要激活我們的mysql。

• 然后，啟動項目，會報錯：no module named MySQLdb

• 這是因為django默認你導入的驅動是MySQLdb，可是MySQLdb對于py3有很大問題，所以我們需要的驅動是PyMySQL

• 所以，我們只需要找到項目名文件下的__init__,在里面寫入：

import pymysql
pymysql.install_as_MySQLdb()

Model 字段

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

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

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

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

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

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

                該字段默認對應的表單控件是一個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.
            - 長整數，時間間隔，數據庫中按照bigint存儲，ORM中獲取的值為datetime.timedelta類型

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

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

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

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

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

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數據庫時，該字段類型對應的數據庫中的數據類型是uuid

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

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

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

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

Field.db_column 數據庫中用來表示該字段的名稱。如果未指定，那么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 定義模型的元數據

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

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

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

關系字段

關系數據庫的威力體現在表之間的相互關聯。

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

• 多對一關系

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

ForeignKey 需要一個位置參數：與該模型關聯的類。

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

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

        Q(caption='root')
        db_constraint=True          # 是否在數據庫中創建外鍵約束
        parent_link=False           # 在Admin中是否顯示關聯數據

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

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

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

db_constraint控制是否在數據庫中為這個外鍵創建約束。默認值為True

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

    CASCADE級聯刪除；默認值。

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

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

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

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

ManyToManyField一個多對多關聯。

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

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

id：關系的主鍵。

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

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

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

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

    to,                         # 要進行關聯的表名
    related_name=None,          # 反向操作時，使用的字段名，用于代替 【表名_set】 如： obj.表名_set.all()
    related_query_name=None,    # 反向操作時，使用的連接前綴，用于替換【表名】     如： models.UserGroup.objects.filter(表名__字段名=1).values('表名__字段名')
    limit_choices_to=None,      # 在Admin或ModelForm中顯示關聯數據時，提供的條件：
        # 如：
            - 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,# 僅用于多對多自關聯時，symmetrical用于指定內部是否創建反向操作的字段
                # 做如下操作時，不同的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,         # 是否在數據庫中創建外鍵約束
        db_table=None,              # 默認創建第三張表時，數據庫中表的名稱

OneToOneField

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

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

需要一個位置參數：與該模型關聯的類。 它的工作方式與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()能用，根據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 字段時,你會得到相關的數據模型對象。

>>> 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一樣,能實現數據過濾和分切,屬性名稱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>]>

以上是“Python中Django框架Model基礎的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！