model,單表操做

時間 2020-04-29

標籤 model 简体版

原文原文鏈接

一. modelpython

　　Django提供了一個抽象層（「Model」）來構建和管理Web應用程序的數據。mysql

　　django中遵循 Code Frist 的原則，即：根據代碼中定義的類來自動生成數據庫表。linux

　　關係對象映射（Object Relational Mapping，簡稱ORM), 它實現了數據模型與數據庫的解耦，即數據模型的設計不須要依賴於特定的數據庫，經過簡單的配置就能夠輕鬆更換數據庫，這極大的減輕了開發人員的工做量，不須要面對因數據庫變動而致使的無效勞動. git

二. 單表操做sql

　　<一>. 表的建立數據庫

　　1. 建立表django

　　建立模型session

　　建立名爲book的app，在book下的models.py中建立模型：app

from django.db import models # Create your models here.

class Book(models.Model): id=models.AutoField(primary_key=True) #若是表裏面沒有寫主鍵，表裏面會自動生成一個自增主鍵字段，叫作id字段，orm要求每一個表裏面必需要寫一個主鍵
     title=models.CharField(max_length=32)  #和varchar(32)是同樣的，32個字符
     state=models.BooleanField() pub_date=models.DateField() #必須存這種格式"2018-12-12"
     price=models.DecimalField(max_digits=8,decimal_places=2) #max_digits最大位數，decimal_places小數部分佔多少位
     publish=models.CharField(max_length=32)

View Code

　　接下來要建立對應的數據，鏈接上對應的數據庫，而後執行建立表的命令，翻譯成相應的sql，而後到數據庫裏面執行，從而建立對應的表。多了一步orm翻譯成sql的過程ide

　　2. 更多字段和參數

　　3. setting配置

DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME':'bms',     　　 　  # 要鏈接的數據庫，鏈接前須要建立好
        'USER':'root',　　　　　　  # 鏈接數據庫的用戶名
        'PASSWORD':'',　　　　　　  # 鏈接數據庫的密碼
        'HOST':'127.0.0.1',       # 鏈接主機，默認本級
        'PORT'：3306    　　　     # 端口 默認3306
 } }

View Code

　　注意1：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()

View Code

　　最後經過兩條數據庫遷移命令便可在指定的數據庫中建立表：

python manage.py makemigrations  #生成記錄，每次修改了models裏面的內容或者添加了新的app，新的app裏面寫了models裏面的內容，都要執行這兩條
python manage.py migrate         #執行上面這個語句的記錄來建立表，生成的表名字前面會自帶應用的名字，例如：你的book表在mysql裏面叫作app01_book表

View Code

　　注意2:確保配置文件中的INSTALLED_APPS中寫入咱們建立的app名稱

INSTALLED_APPS = [ 'django.contrib.admin',  #這是django給你提供的一些特殊功能的配置（應用，只是我們看不到），也在應用這裏給配置的，這些功能若是你註銷了，那麼咱們執行同步數據庫指令以後，就不會生成那些django自帶的表了。由於執行數據庫同步語句的時候，django會找這裏面全部的應用，找到他們的models來建立表
    'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', "book"  #直接寫app的名字也行，寫'app01.apps.App01Config'也行
]

View Code

　　注意3: 若是想打印orm轉換過程當中的sql，須要在settings中進行以下配置：

LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'console':{ 'level':'DEBUG', 'class':'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'propagate': True, 'level':'DEBUG', }, } }

View Code

　　4. 自定義字段

　　<二>. 添加表記錄

　　在python中orm的對應關係有三種：

　　　　類 ----------> 表

　　　　類對象 ----------> 行(記錄)

　　　　類屬性 ----------> 表的字段（重點）

　　方式1:

book_obj=Book(title="python葵花寶典",state=True,price=100,publish="蘋果出版社",pub_date="2012-12-12") #實例化一個對象表示一行記錄，時間日期若是隻寫日期的話，時間默認是00.00.00，注意日期寫法必須是2012-12-12這種格式
book_obj.save() #就是pymysql的那個commit提交

View Code

　　方式2:

# create方法的返回值book_obj就是插入book表中的python葵花寶典這本書籍紀錄對象
  book_obj=Book.objects.create(title="python葵花寶典",state=True,price=100,publish="蘋果出版社",pub_date="2012-12-12") #這個返回值就像是mysql裏面我們講的那個new對象，還記得嗎，他跟上面那種建立方式建立的那個對象是同樣的
  #這個Book.objects就像是一個Book表的管理器同樣，提供了增刪改查全部的方法
  print(book_obj.title) #能夠基於這個對象來取這個新添加的記錄對象的屬性值
  dic1 = {'title':'linux','state'=True,'price':100,'publish'='2018-12-12'} #這樣寫的時候，注意若是你用post提交過來的請求，有個csrf_token的鍵值對要刪除，而且request.POST是不能直接在request.POST裏面進行修改和刪除的，data = request.POST.dict()轉換成普通的字典-->Book.objects.create(**data)
  book.objects.create(**dic1)

View Code

　　<三>, 查詢表記錄

　　1. 查詢API

<1> all(): 查詢全部結果，結果是queryset類型 <2> filter(**kwargs): 它包含了與所給篩選條件相匹配的對象，結果也是queryset類型 Book.objects.filter(title='linux',price=100) #裏面的多個條件用逗號分開，而且這幾個條件必須都成立，是and的關係，or關係的咱們後面再學，直接在這裏寫是搞不定or的
  
<3> get(**kwargs): 返回與所給篩選條件相匹配的對象，不是queryset類型，是行記錄對象，返回結果有且只有一個， 若是符合篩選條件的對象超過一個或者沒有都會拋出錯誤。捕獲異常try。 Book.objects.get(id=1) <4> exclude(**kwargs): 排除的意思，它包含了與所給篩選條件不匹配的對象，沒有不等於的操做昂，用這個exclude，返回值是queryset類型 Book.objects.exclude(id=6)，返回id不等於6的全部的對象，或者在queryset基礎上調用，Book.objects.all().exclude(id=6) 　　　　　　　　　　　　　　　　 <5> order_by(*field): queryset類型的數據來調用，對查詢結果排序,默認是按照id來升序排列的，返回值仍是queryset類型 　　　　　　　　　　　　　　　　 models.Book.objects.all().order_by('price','id') #直接寫price，默認是按照price升序排列，按照字段降序排列，就寫個負號就好了order_by('-price'),order_by('price','id')是多條件排序，按照price進行升序，price相同的數據，按照id進行升序
        
<6> reverse(): queryset類型的數據來調用，對查詢結果反向排序，返回值仍是queryset類型 <7> count(): queryset類型的數據來調用，返回數據庫中匹配查詢(QuerySet)的對象數量。 <8> first(): queryset類型的數據來調用，返回第一條記錄 Book.objects.all()[0] = Book.objects.all().first()，獲得的都是model對象，不是queryset <9> last(): queryset類型的數據來調用，返回最後一條記錄 <10> exists(): queryset類型的數據來調用，若是QuerySet包含數據，就返回True，不然返回False空的queryset類型數據也有布爾值True和False，可是通常不用它來判斷數據庫裏面是否是有數據，若是有大量的數據，你用它來判斷，那麼就須要查詢出全部的數據，效率太差了，用count或者exits 　　　　　　　　　　　　　　　　 例：all_books = models.Book.objects.all().exists() #翻譯成的sql是SELECT (1) AS `a` FROM `app01_book` LIMIT 1，就是經過limit 1，取一條來看看是否是有數據

<11> values(*field): 用的比較多，queryset類型的數據來調用，返回一個ValueQuerySet——一個特殊的QuerySet，運行後獲得的並非一系列model的實例化對象，而是一個可迭代的字典序列,只要是返回的queryset類型，就能夠繼續鏈式調用queryset類型的其餘的查找方法，其餘方法也是同樣的。 <12> values_list(*field): 它與values()很是類似，它返回的是一個元組序列，values返回的是一個字典序列 <13> distinct(): values和values_list獲得的queryset類型的數據來調用，從返回結果中剔除重複紀錄

　　queryset方法大全：

################################################################## # PUBLIC METHODS THAT ALTER ATTRIBUTES AND RETURN A NEW QUERYSET # ##################################################################

def all(self) # 獲取全部的數據對象

def filter(self, *args, **kwargs) # 條件查詢
    # 條件能夠是：參數，字典，Q

def exclude(self, *args, **kwargs) # 條件查詢
    # 條件能夠是：參數，字典，Q

def select_related(self, *fields) 性能相關：表之間進行join連表操做，一次性獲取關聯的數據。 總結： 1. select_related主要針一對一和多對一關係進行優化。 2. select_related使用SQL的JOIN語句進行優化，經過減小SQL查詢的次數來進行優化、提升性能。 def prefetch_related(self, *lookups) 性能相關：多表連表操做時速度會慢，使用其執行屢次SQL查詢在Python代碼中實現連表操做。 總結： 1. 對於多對多字段（ManyToManyField）和一對多字段，可使用prefetch_related()來進行優化。 2. prefetch_related()的優化方式是分別查詢每一個表，而後用Python處理他們之間的關係。 def annotate(self, *args, **kwargs) # 用於實現聚合group by查詢

    from django.db.models import Count, Avg, Max, Min, Sum v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')) # SELECT u_id, COUNT(ui) AS `uid` FROM UserInfo GROUP BY u_id
 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id')).filter(uid__gt=1) # SELECT u_id, COUNT(ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1
 v = models.UserInfo.objects.values('u_id').annotate(uid=Count('u_id',distinct=True)).filter(uid__gt=1) # SELECT u_id, COUNT( DISTINCT ui_id) AS `uid` FROM UserInfo GROUP BY u_id having count(u_id) > 1

def distinct(self, *field_names) # 用於distinct去重
    models.UserInfo.objects.values('nid').distinct() # select distinct nid from userinfo
 注：只有在PostgreSQL中才能使用distinct進行去重 def order_by(self, *field_names) # 用於排序
    models.UserInfo.objects.all().order_by('-id','age') def extra(self, select=None, where=None, params=None, tables=None, order_by=None, select_params=None) # 構造額外的查詢條件或者映射，如：子查詢
 Entry.objects.extra(select={'new_id': "select col from sometable where othercol > %s"}, select_params=(1,)) Entry.objects.extra(where=['headline=%s'], params=['Lennon']) Entry.objects.extra(where=["foo='a' OR bar = 'a'", "baz = 'a'"]) Entry.objects.extra(select={'new_id': "select id from tb where id > %s"}, select_params=(1,), order_by=['-nid']) def reverse(self): # 倒序
    models.UserInfo.objects.all().order_by('-nid').reverse() # 注：若是存在order_by，reverse則是倒序，若是多個排序則一一倒序


 def defer(self, *fields): models.UserInfo.objects.defer('username','id') 或 models.UserInfo.objects.filter(...).defer('username','id') #映射中排除某列數據

 def only(self, *fields): #僅取某個表中的數據
     models.UserInfo.objects.only('username','id') 或 models.UserInfo.objects.filter(...).only('username','id') def using(self, alias): 指定使用的數據庫，參數爲別名（setting中的設置） ################################################## # PUBLIC METHODS THAT RETURN A QUERYSET SUBCLASS # ##################################################

def raw(self, raw_query, params=None, translations=None, using=None): # 執行原生SQL
    models.UserInfo.objects.raw('select * from userinfo') # 若是SQL是其餘表時，必須將名字設置爲當前UserInfo對象的主鍵列名
    models.UserInfo.objects.raw('select id as nid from 其餘表') # 爲原生SQL設置參數
    models.UserInfo.objects.raw('select id as nid from userinfo where nid>%s', params=[12,]) # 將獲取的到列名轉換爲指定列名
    name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'} Person.objects.raw('SELECT * FROM some_other_table', translations=name_map) # 指定數據庫
    models.UserInfo.objects.raw('select * from userinfo', using="default") ################### 原生SQL ###################
    from django.db import connection, connections cursor = connection.cursor()  # cursor = connections['default'].cursor()
    cursor.execute("""SELECT * from auth_user where id = %s""", [1]) row = cursor.fetchone() # fetchall()/fetchmany(..)


def values(self, *fields): # 獲取每行數據爲字典格式

def values_list(self, *fields, **kwargs): # 獲取每行數據爲元祖

def dates(self, field_name, kind, order='ASC'): # 根據時間進行某一部分進行去重查找並截取指定內容
    # kind只能是："year"（年）, "month"（年-月）, "day"（年-月-日）
    # order只能是："ASC" "DESC"
    # 並獲取轉換後的時間
        - year : 年-01-01
        - month: 年-月-01
        - day  : 年-月-日 models.DatePlus.objects.dates('ctime','day','DESC') def datetimes(self, field_name, kind, order='ASC', tzinfo=None): # 根據時間進行某一部分進行去重查找並截取指定內容，將時間轉換爲指定時區時間
    # kind只能是 "year", "month", "day", "hour", "minute", "second"
    # order只能是："ASC" "DESC"
    # tzinfo時區對象
    models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.UTC) models.DDD.objects.datetimes('ctime','hour',tzinfo=pytz.timezone('Asia/Shanghai')) """ pip3 install pytz import pytz pytz.all_timezones pytz.timezone(‘Asia/Shanghai’) """

def none(self): # 空QuerySet對象


#################################### # METHODS THAT DO DATABASE QUERIES # ####################################

def aggregate(self, *args, **kwargs): # 聚合函數，獲取字典類型聚合結果
   from django.db.models import Count, Avg, Max, Min, Sum result = models.UserInfo.objects.aggregate(k=Count('u_id', distinct=True), n=Count('nid')) ===> {'k': 3, 'n': 4} def count(self): # 獲取個數

def get(self, *args, **kwargs): # 獲取單個對象

def create(self, **kwargs): # 建立對象

def bulk_create(self, objs, batch_size=None): # 批量插入
    # batch_size表示一次插入的個數
    objs = [ models.DDD(name='r11'), models.DDD(name='r22') ] models.DDD.objects.bulk_create(objs, 10) def get_or_create(self, defaults=None, **kwargs): # 若是存在，則獲取，不然，建立
    # defaults 指定建立時，其餘字段的值
    obj, created = models.UserInfo.objects.get_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 2}) def update_or_create(self, defaults=None, **kwargs): # 若是存在，則更新，不然，建立
    # defaults 指定建立時或更新時的其餘字段
    obj, created = models.UserInfo.objects.update_or_create(username='root1', defaults={'email': '1111111','u_id': 2, 't_id': 1}) def first(self): # 獲取第一個

def last(self): # 獲取最後一個

def in_bulk(self, id_list=None): # 根據主鍵ID進行查找
   id_list = [11,21,31] models.DDD.objects.in_bulk(id_list) def delete(self): # 刪除

def update(self, **kwargs): # 更新

def exists(self): # 是否有結果
 方法

View Code

　　關於values和value_list的用法和返回結果舉例：

all_books = models.Book.objects.all().values('id','title') print(all_books) #<QuerySet [{'title': 'linux', 'id': 6}, {'title': '你好', 'id': 7}, {'title': 'linux', 'id': 8}, {'title': 'xxx', 'id': 9}, {'title': 'gogogo', 'id': 10}]>
    ''' values作的事情： ret = [] #queryset類型 for obj in Book.objects.all(): temp = { #元素是字典類型 'id':obj.id, 'title':obj.title } ret.append(temp) ''' all_books = models.Book.objects.all().values_list('id','title') print(all_books) #<QuerySet [(6, 'linux'), (7, '你好'), (8, 'linux'), (9, 'xxx'), (10, 'gogogo')]>
    ''' values作的事情： ret = [] #queryset類型 for obj in Book.objects.all(): temp = ( #元素是元祖類型 obj.id,obj.title ) ret.append(temp) '''

View Code

　　關於distinct的用法和返回結果舉例：

# all_books = models.Book.objects.all().distinct() #這樣寫是表示記錄中全部的字段重複才叫重複，可是咱們知道有主鍵的存在，因此不可能全部字段數據都重複
    # all_books = models.Book.objects.all().distinct('price') #報錯，不能在distinct裏面加字段名稱
    # all_books = models.Book.objects.all().values('price').distinct()#<QuerySet [(Decimal('11.00'),), (Decimal('111.00'),), (Decimal('120.00'),), (Decimal('11111.00'),)]>
    all_books = models.Book.objects.all().values_list('price').distinct()#<QuerySet [{'price': Decimal('11.00')}, {'price': Decimal('111.00')}, {'price': Decimal('120.00')}, {'price': Decimal('11111.00')}]> 只能用於valuse和values_list進行去重
　　all_books = models.Book.objects.all().values_list('title','price').distinct() #title和price兩個同時重複纔算一條重複的記錄

View Code

　　打印一個對象，讓他顯示一個可以看懂的值，__str__，models.py的數據表類裏面定義一個__str__方法就能夠了

　　models.py的__str__的寫法：

#__str__方法的使用
class MyClass: def __init__(self,name,age): self.name = name self.age = age def __str__(self): return self.name + '>>>' + str(self.age) a = MyClass('chao',18) b = MyClass('wc',20) print(a) print(b) from django.db import models # Create your models here.

class Book(models.Model): id = models.AutoField(primary_key=True) title = models.CharField(max_length=32) price = models.DecimalField(max_digits=8,decimal_places=2,) pub_date = models.DateTimeField() #必須存這種格式"2012-12-12"
    publish = models.CharField(max_length=32) def __str__(self): #後添加這個str方法，也不須要從新執行同步數據庫的指令
        return self.title #當咱們打印這個類的對象的時候，顯示title值

View Code

　　2. 基於雙下劃綫的模糊查詢

Book.objects.filter(price__in=[100,200,300]) #price值等於這三個裏面的任意一個的對象
Book.objects.filter(price__gt=100)  #大於，大於等因而price__gte=100，別寫price>100，這種參數不支持
Book.objects.filter(price__lt=100) Book.objects.filter(price__range=[100,200])  #sql的between and，大於等於100，小於等於200
Book.objects.filter(title__contains="python")  #title值中包含python的
Book.objects.filter(title__icontains="python") #不區分大小寫
Book.objects.filter(title__startswith="py") #以什麼開頭，istartswith 不區分大小寫
Book.objects.filter(pub_date__year=2012)

View Code

　　日期查詢示例:

# all_books = models.Book.objects.filter(pub_date__year=2012) #找2012年的全部書籍
    # all_books = models.Book.objects.filter(pub_date__year__gt=2012)#找大於2012年的全部書籍
    all_books = models.Book.objects.filter(pub_date__year=2019,pub_date__month=2)#找2019年月份的全部書籍，若是明明有結果，你卻查不出結果，是由於mysql數據庫的時區和我們django的時區不一樣致使的，瞭解一下就好了，你須要作的就是將django中的settings配置文件裏面的USE_TZ = True改成False，就能夠查到結果了，之後這個值就改成False，並且就是由於我們用的mysql數據庫纔會有這個問題，其餘數據庫沒有這個問題。

View Code

　　<四>. 刪除表記錄

　　delete()方法的調用者能夠是一個model對象，也能夠是一個queryset集合。

　　刪除方法就是 delete()。它運行時當即刪除對象而不返回任何值。

　　models_obj.delete()

　　也能夠一次性刪除多個對象。每一個 QuerySet 都有一個 delete() 方法，它一次性刪除 QuerySet 中全部的對象。

　　models.Book.objects.filter(pub_date__year=2016).delete()

　　在 Django 刪除對象時，會模仿 SQL 約束 ON DELETE CASCADE 的行爲，換句話說，刪除一個對象時也會刪除與它相關聯的外鍵對象

　　要注意的是： delete() 方法是 QuerySet 上的方法，但並不適用於 Manager 自己。這是一種保護機制，是爲了不意外地調用 Entry.objects.delete() 方法致使全部的記錄被誤刪除。若是你確認要刪除全部的對象，那麼你必須顯式地調用：

Entry.objects.all().delete()

　若是不想級聯刪除，能夠設置爲:

pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True))

　　<五>. 修改表記錄

　　update只能是querset類型才能調用，model對象不能直接調用更新方法，因此使用get方法獲取對象的時候是不能update的。

Book.objects.filter(title__startswith="py").update(price=120)  此外，update()方法對於任何結果集（QuerySet）均有效，這意味着你能夠同時更新多條記錄update()方法會返回一個整型數值，表示受影響的記錄條數。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。