<del id="nnjnj"></del><track id="nnjnj"></track>

<p id="nnjnj"></p>

<address id="nnjnj"></address>

    <pre id="nnjnj"><pre id="nnjnj"></pre></pre>

      <noframes id="nnjnj"><ruby id="nnjnj"><ruby id="nnjnj"></ruby></ruby>

      • 自動秒收錄
      • 軟件:1973
      • 資訊:57811|
      • 收錄網站:279872|

      IT精英團

      你見過的最全面的Python關鍵知識總結

      你見過的最全面的Python關鍵知識總結

      瀏覽次數:
      評論次數:
      編輯: 澤洋
      信息來源: ITPUB
      更新日期: 2022-04-24 21:20:53
      摘要

      這是一份來自于SegmentFault上的開發者@二十一總結的Python重點。由于總結了太多的東西,所以篇幅有點長,這也是作者"縫縫補補"總結了好久的東西,強烈建議收藏再慢慢看~Py2

      • 正文開始
      • 相關閱讀
      • 推薦作品

      這是developer @ 21關于SegmentFault的Python總結。我總結的東西太多了,所以篇幅有點長。這也是筆者長期以來總結出來的。強烈建議收藏起來慢慢看~

      Py2對Py3

      Py2和Py3的區別

      打印成為一個功能,python2是關鍵詞。

      沒有unicode對象,默認的str是unicode。

      Python3除數返回浮點數

      沒有長型

      Xrange不存在,range替換了xrange。

      可以用中文定義函數名和變量名。

      高級拆包和*拆包

      關鍵字參數*后的變量必須添加name=value。

      從.升起

      Iteritems移除成為items()

      來自鏈路生成器的產量

      Asyncio,async/await本機進程支持異步編程。

      添加enum,mock,ipaddress,concurrent.futures,asyncio urllib,選擇器。

      無法比較不同的枚舉類。

      在相同的枚舉類之間只能進行相等的比較。

      使用枚舉(默認情況下從1開始計數)

      為了避免在枚舉類中出現相同的枚舉值,可以用@unique修飾枚舉類。

      #列舉說明

      fromenumimportEnum

      classCOLOR(枚舉):

      黃色=1

      #黃色=2#將報告錯誤。

      綠色=1#不會報告錯誤。綠色可以看作是黃色的別名。

      黑色=3

      紅色=4

      打印(顏色.綠色)#顏色。黃色,否則黃色將被打印。

      FornCOLOR 3360 #遍歷顏色,不會有綠色。

      打印(一)

      # color . yellow \ n color . black \ n color . red \ n如何遍歷別名?

      foriinCOLOR。__成員_ _。物品():

      打印(一)

      #output:('黃色',彩色。黃色:1)\n('綠色',顏色。黃色:1)\n('黑色',彩色。黑色:3)\n('紅色',彩色。RED:4)

      foriinCOLOR。__成員__:

      打印(一)

      # output:YELLOW黃色\ n綠色\ n黑色\ n紅色

      #枚舉轉換

      #在數據庫訪問中最好使用枚舉值而不是標記名字符串。

      #在代碼中使用枚舉類

      a=1

      print(彩色(a))#output:COLOR。黃色

      Py2/3轉換工具

      六個模塊:與pyton2和pyton3兼容的模塊

      2to3工具:更改代碼語法版本

      __future__:使用下一版本的功能

      類庫相關性

      公共圖書館

      必須知道的集合

      https://segmentfault.com/a/1190000017385799

      Python排序操作和heapq模塊

      https://segmentfault.com/a/1190000017383322

      itertools模塊的超實用方法

      https://segmentfault.com/a/1190000017416590

      未使用但重要的庫

      代碼字節代碼分析

      檢查(發電機狀態)

      性能分析

      平分(維護有序列表)

      【數學】函數

      match
    1. fnmatch(string,"*.txt") # win下不區分大小寫
    2. fnmatch 根據系統決定
    3. fnmatchcase 完全區分大小寫
    4. timeit(代碼執行時間)
    5. def isLen(strString):
          #還是應該使用三元表達式,更快
          return True if len(strString)>6 else False

      def isLen1(strString):
          #這里注意false和true的位置
          return [False,True][len(strString)>6]
      import timeit
      print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))

      print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))
      • contextlib
        • @contextlib.contextmanager 使生成器函數變成一個上下文管理器
      • types(包含了標準解釋器定義的所有類型的類型對象,可以將生成器函數修飾為異步模式)
      import types
      types.coroutine #相當于實現了__await__
      • html(實現對html的轉義)
      import html
      html.escape("<h1>I'm Jim</h1>") # output:'&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;'
      html.unescape('&lt;h1&gt;I&#x27;m Jim&lt;/h1&gt;') # <h1>I'm Jim</h1>
      • mock(解決測試依賴)
      • concurrent(創建進程池和線程池)
      from concurrent.futures import ThreadPoolExecutor

      pool = ThreadPoolExecutor()
      task = pool.submit(函數名,(參數)) #此方法不會阻塞,會立即返回
      task.done()#查看任務執行是否完成
      task.result()#阻塞的方法,查看任務返回值
      task.cancel()#取消未執行的任務,返回True或False,取消成功返回True
      task.add_done_callback()#回調函數
      task.running()#是否正在執行     task就是一個Future對象

      for data in pool.map(函數,參數列表):#返回已經完成的任務結果列表,根據參數順序執行
          print(返回任務完成得執行結果data)

      from concurrent.futures import as_completed
      as_completed(任務列表)#返回已經完成的任務列表,完成一個執行一個

      wait(任務列表,return_when=條件)#根據條件進行阻塞主線程,有四個條件
      • selector(封裝select,用戶多路復用io編程)
      • asyncio
      future=asyncio.ensure_future(協程)  等于后面的方式  future=loop.create_task(協程)
      future.add_done_callback()添加一個完成后的回調函數
      loop.run_until_complete(future)
      future.result()查看寫成返回結果

      asyncio.wait()接受一個可迭代的協程對象
      asynicio.gather(*可迭代對象,*可迭代對象)    兩者結果相同,但gather可以批量取消,gather對象.cancel()

      一個線程中只有一個loop

      在loop.stop時一定要loop.run_forever()否則會報錯
      loop.run_forever()可以執行非協程
      最后執行finally模塊中 loop.close()

      asyncio.Task.all_tasks()拿到所有任務 然后依次迭代并使用任務.cancel()取消

      偏函數partial(函數,參數)把函數包裝成另一個函數名  其參數必須放在定義函數的前面

      loop.call_soon(函數,參數)
      call_soon_threadsafe()線程安全    
      loop.call_later(時間,函數,參數)
      在同一代碼塊中call_soon優先執行,然后多個later根據時間的升序進行執行

      如果非要運行有阻塞的代碼
      使用loop.run_in_executor(executor,函數,參數)包裝成一個多線程,然后放入到一個task列表中,通過wait(task列表)來運行

      通過asyncio實現http
      reader,writer=await asyncio.open_connection(host,port)
      writer.writer()發送請求
      async for data in reader:
          data=data.decode("utf-8")
          list.append(data)
      然后list中存儲的就是html

      as_completed(tasks)完成一個返回一個,返回的是一個可迭代對象    

      協程鎖
      async with Lock():

      Python 進階


      • 進程間通信:
        • Manager(內置了好多數據結構,可以實現多進程間內存共享)
      from multiprocessing import Manager,Process
      def add_data(p_dict, key, value):
          p_dict[key] = value

      if __name__ == "__main__":
          progress_dict = Manager().dict()
          from queue import PriorityQueue

          first_progress = Process(target=add_data, args=(progress_dict, "bobby1", 22))
          second_progress = Process(target=add_data, args=(progress_dict, "bobby2", 23))

          first_progress.start()
          second_progress.start()
          first_progress.join()
          second_progress.join()

          print(progress_dict)
      • Pipe(適用于兩個進程)
      from multiprocessing import Pipe,Process
      #pipe的性能高于queue
      def producer(pipe):
          pipe.send("bobby")

      def consumer(pipe):
          print(pipe.recv())

      if __name__ == "__main__":
          recevie_pipe, send_pipe = Pipe()
          #pipe只能適用于兩個進程
          my_producer= Process(target=producer, args=(send_pipe, ))
          my_consumer = Process(target=consumer, args=(recevie_pipe,))

          my_producer.start()
          my_consumer.start()
          my_producer.join()
          my_consumer.join()
      • Queue(不能用于進程池,進程池間通信需要使用Manager().Queue())
      from multiprocessing import Queue,Process
      def producer(queue):
          queue.put("a")
          time.sleep(2)

      def consumer(queue):
          time.sleep(2)
          data = queue.get()
          print(data)

      if __name__ == "__main__":
          queue = Queue(10)
          my_producer = Process(target=producer, args=(queue,))
          my_consumer = Process(target=consumer, args=(queue,))
          my_producer.start()
          my_consumer.start()
          my_producer.join()
          my_consumer.join()
      • 進程池
      def producer(queue):
          queue.put("a")
          time.sleep(2)

      def consumer(queue):
          time.sleep(2)
          data = queue.get()
          print(data)

      if __name__ == "__main__":
          queue = Manager().Queue(10)
          pool = Pool(2)

          pool.apply_async(producer, args=(queue,))
          pool.apply_async(consumer, args=(queue,))

          pool.close()
          pool.join()
      • sys 模塊幾個常用方法

        • argv 命令行參數list,第一個是程序本身的路徑
        • path 返回模塊的搜索路徑
        • modules.keys() 返回已經導入的所有模塊的列表
        • exit(0) 退出程序
      • a in s or b in s or c in s簡寫

        • 采用any方式:all() 對于任何可迭代對象為空都會返回 True
      # 方法一
      True in [i in s for i in [a,b,c]]
      # 方法二
      any(i in s for i in [a,b,c])
      # 方法三
      list(filter(lambda x:x in s,[a,b,c]))
      • set集合運用

        • {1,2}.issubset({1,2,3})#判斷是否是其子集
        • {1,2,3}.issuperset({1,2})
        • {}.isdisjoint({})#判斷兩個set交集是否為空,是空集則為True
      • 代碼中中文匹配

        • [u4E00-u9FA5]匹配中文文字區間[一到龥]
      • 查看系統默認編碼格式

      import sys
      sys.getdefaultencoding()    # setdefaultencodeing()設置系統編碼方式
      • getattr VS getattribute
      class A(dict):
          def __getattr__(self,value):#當訪問屬性不存在的時候返回
              return 2
          def __getattribute__(self,item):#屏蔽所有的元素訪問
              return item
      • 類變量是不會存入實例__dict__中的,只會存在于類的__dict__中

      • globals/locals(可以變相操作代碼)

        • globals中保存了當前模塊中所有的變量屬性與值
        • locals中保存了當前環境中的所有變量屬性與值
      • python變量名的解析機制(LEGB)

        • 本地作用域(Local)
        • 當前作用域被嵌入的本地作用域(Enclosing locals)
        • 全局/模塊作用域(Global)
        • 內置作用域(Built-in)
      • 實現從1-100每三個為一組分組

      print([[x for x in range(1,101)][i:i+3] for i in range(,100,3)])
      • 什么是元類?
        • 即創建類的類,創建類的時候只需要將metaclass=元類,元類需要繼承type而不是object,因為type就是元類
      type.__bases__  #(<class 'object'>,)
      object.__bases__    #()
      type(object)    #<class 'type'>
      class Yuan(type):
              def __new__(cls,name,base,attr,*args,**kwargs):
                  return type(name,base,attr,*args,**kwargs)
          class MyClass(metaclass=Yuan):
              pass
      • 什么是鴨子類型(即:多態)?

        • Python在使用傳入參數的過程中不會默認判斷參數類型,只要參數具備執行條件就可以執行
      • 深拷貝和淺拷貝

        • 深拷貝拷貝內容,淺拷貝拷貝地址(增加引用計數)
        • copy模塊實現神拷貝
      • 單元測試

        • 一般測試類繼承模塊unittest下的TestCase
        • pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭,并且不能帶有 init 方法)
        • coverage統計測試覆蓋率
      class MyTest(unittest.TestCase):
          def tearDown(self):# 每個測試用例執行前執行
              print('本方法開始測試了')

          def setUp(self):# 每個測試用例執行之前做操作
              print('本方法測試結束')

          @classmethod
          def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運行完后運行一次
              print('開始測試')
          @classmethod
          def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運行前運行一次
              print('結束測試')

          def test_a_run(self):
              self.assertEqual(1, 1)  # 測試用例
      • gil 會根據執行的字節碼行數以及時間片釋放 gil,gil 在遇到 io 的操作時候主動釋放

      • 什么是 monkey patch?

        • 猴子補丁,在運行的時候替換掉會阻塞的語法修改為非阻塞的方法
      • 什么是自省(Introspection)?

        • 運行時判斷一個對象的類型的能力,id,type,isinstance
      • python 是值傳遞還是引用傳遞?

        • 都不是,python是共享傳參,默認參數在執行時只會執行一次
      • try-except-else-finally中 else 和 finally 的區別

        • else在不發生異常的時候執行,finally無論是否發生異常都會執行
        • except一次可以捕獲多個異常,但一般為了對不同異常進行不同處理,我們分次捕獲處理
      • GIL 全局解釋器鎖

        • 同一時間只能有一個線程執行,CPython(IPython)的特點,其他解釋器不存在
        • cpu 密集型:多進程+進程池
        • io 密集型:多線程/協程
      • 什么是 Cython

        • 將 python 解釋 成 C 代碼工具
      • 生成器和迭代器

        • 實現__next__和__iter__方法的對象就是迭代器
        • 可迭代對象只需要實現__iter__方法
        • 使用生成器表達式或者yield的生成器函數(生成器是一種特殊的迭代器)
      • 什么是協程

        • 比線程更輕量的多任務方式
        • 實現方式
        • yield
        • async-awiat
      • dict 底層結構

        • 為了支持快速查找使用了哈希表作為底層結構
        • 哈希表平均查找時間復雜度為o(1)
        • CPython 解釋器使用二次探查解決哈希沖突問題
      • Hash擴容和Hash沖突解決方案

        • 循環復制到新空間實現擴容
        • 沖突解決:
        • 鏈接法
        • 二次探查(開放尋址法):python使用
      for gevent import monkey
      monkey.patch_all()  #將代碼中所有的阻塞方法都進行修改,可以指定具體要修改的方法
      • 判斷是否為生成器或者協程
      co_flags = func.__code__.co_flags

      # 檢查是否是協程
      if co_flags & 0x180:
          return func

      # 檢查是否是生成器
      if co_flags & 0x20:
          return func
      • 斐波那契解決的問題及變形
      #一只青蛙一次可以跳上1級臺階,也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
      #請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形,總共有多少種方法?
      #方式一:
      fib = lambda n: n if n <= 2 else fib(n - 1) + fib(n - 2)
      #方式二:
      def fib(n):
          a, b = , 1
          for _ in range(n):
              a, b = b, a + b
          return b

      #一只青蛙一次可以跳上1級臺階,也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
      fib = lambda n: n if n < 2 else 2 * fib(n - 1)
      • 獲取電腦設置的環境變量
      import os
      os.getenv(env_name,None)#獲取環境變量如果不存在為None
      • 垃圾回收機制
        • 引用計數
        • 標記清除
        • 分代回收
      #查看分代回收觸發
      import gc
      gc.get_threshold()  #output:(700, 10, 10)
      • True 和 False 在代碼中完全等價于1和0,可以直接和數字進行計算,inf 表示無窮大

      • C10M/C10K

        • C10M:8核心cpu,64G內存,在10gbps的網絡上保持1000萬并發連接
        • C10K:1GHz CPU,2G內存,1gbps網絡環境下保持1萬個客戶端提供FTP服務
      • yield from 與 yield 的區別:

        • yield from 跟的是一個可迭代對象,而 yield 后面沒有限制
        • GeneratorExit 生成器停止時觸發
      • 單下劃線的幾種使用

        • 在定義變量時,表示為私有變量
        • 在解包時,表示舍棄無用的數據
        • 在交互模式中表示上一次代碼執行結果
        • 可以做數字的拼接(111_222_333)
      • 使用 brea k就不會執行 else

      • 10進制轉2進制

      def conver_bin(num):
          if num == :
              return num
          re = []
          while num:
              num, rem = divmod(num,2)
              re.append(str(rem))
          return "".join(reversed(re))
        conver_bin(10)
      • list1 = ['A', 'B', 'C', 'D'] 如何才能得到以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢
      list1 = ['A', 'B', 'C', 'D']

      # 方法一
      for i in list1:
          globals()[i] = []   # 可以用于實現python版反射

      # 方法二
      for i in list1:
          exec(f'{i} = []')   # exec執行字符串語句
      • memoryview與bytearray,
      # bytearray是可變的,bytes是不可變的,memoryview不會產生新切片和對象
      a = 'aaaaaa'
      ma = memoryview(a)
      ma.readonly  # 只讀的memoryview
      mb = ma[:2]  # 不會產生新的字符串

      a = bytearray('aaaaaa')
      ma = memoryview(a)
      ma.readonly  # 可寫的memoryview
      mb = ma[:2]      # 不會會產生新的bytearray
      mb[:2] = 'bb'    # 對mb的改動就是對ma的改動
      • Ellipsis類型
      # 代碼中出現...省略號的現象就是一個Ellipsis對象
      L = [1,2,3]
      L.append(L)
      print(L)    # output:[1,2,3,[…]]
      • lazy惰性計算
      class lazy(object):
          def __init__(self, func):
              self.func = func

          def __get__(self, instance, cls):
              val = self.func(instance)    #其相當于執行的area(c),c為下面的Circle對象
              setattr(instance, self.func.__name__, val)
              return val`

      class Circle(object):
          def __init__(self, radius):
              self.radius = radius

          @lazy
          def area(self):
              print('evalute')
              return 3.14 * self.radius ** 2
      • 遍歷文件,傳入一個文件夾,將里面所有文件的路徑打印出來(遞歸)
      all_files = []    
      def getAllFiles(directory_path):
          import os                                       
          for sChild in os.listdir(directory_path):                
              sChildPath = os.path.join(directory_path,sChild)
              if os.path.isdir(sChildPath):
                  getAllFiles(sChildPath)
              else:
                  all_files.append(sChildPath)
          return all_files
      • 文件存儲時,文件名的處理
      #secure_filename將字符串轉化為安全的文件名
      from werkzeug import secure_filename
      secure_filename("My cool movie.mov") # output:My_cool_movie.mov
      secure_filename("../../../etc/passwd") # output:etc_passwd
      secure_filename(u'i contain cool \xfcml\xe4uts.txt') # output:i_contain_cool_umlauts.txt
      • 日期格式化
      from datetime import datetime

      datetime.now().strftime("%Y-%m-%d")

      import time
      #這里只有localtime可以被格式化,time是不能格式化的
      time.strftime("%Y-%m-%d",time.localtime())
      • tuple使用+=奇怪的問題
      # 會報錯,但是tuple的值會改變,因為t[1]id沒有發生變化
      t=(1,[2,3])
      t[1]+=[4,5]
      # t[1]使用append\extend方法并不會報錯,并可以成功執行
      • __missing__你應該知道
      class Mydict(dict):
          def __missing__(self,key): # 當Mydict使用切片訪問屬性不存在的時候返回的值
              return key
      • +與+=
      # +不能用來連接列表和元祖,而+=可以(通過iadd實現,內部實現方式為extends(),所以可以增加元組),+會創建新對象
      #不可變對象沒有__iadd__方法,所以直接使用的是__add__方法,因此元祖可以使用+=進行元祖之間的相加
      • 如何將一個可迭代對象的每個元素變成一個字典的所有鍵?
      dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}


      網絡知識

      • 什么是 HTTPS?

        • 安全的 HTTP 協議,https 需要 cs 證書,數據加密,端口為443,安全,同一網站 https seo 排名會更高
      • 常見響應狀態碼

      204 No Content //請求成功處理,沒有實體的主體返回,一般用來表示刪除成功
      206 Partial Content //Get范圍請求已成功處理
      303 See Other //臨時重定向,期望使用get定向獲取
      304 Not Modified //請求緩存資源
      307 Temporary Redirect //臨時重定向,Post不會變成Get
      401 Unauthorized //認證失敗
      403 Forbidden //資源請求被拒絕
      400 //請求參數錯誤
      201 //添加或更改成功
      503 //服務器維護或者超負載
      • http 請求方法的冪等性及安全性

      • WSGI

      # environ:一個包含所有HTTP請求信息的dict對象
      # start_response:一個發送HTTP響應的函數
      def application(environ, start_response):
          start_response('200 OK', [('Content-Type', 'text/html')])
          return '<h1>Hello, web!</h1>'
      • RPC

      • CDN

      • SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全(Transport Layer Security,TLS)是為網絡通信提供安全及數據完整性的一種安全協議。

      • SSH(安全外殼協議) 為 Secure Shell 的縮寫,由 IETF 的網絡小組(Network Working Group)所制定;SSH 為建立在應用層基礎上的安全協議。SSH 是目前較可靠,專為遠程登錄會話和其他網絡服務提供安全性的協議。利用 SSH 協議可以有效防止遠程管理過程中的信息泄露問題。SSH最初是UNIX系統上的一個程序,后來又迅速擴展到其他操作平臺。SSH在正確使用時可彌補網絡中的漏洞。SSH客戶端適用于多種平臺。幾乎所有UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix,以及其他平臺,都可運行SSH。

      • TCP/IP

        • 雖然按道理,四個報文都發送完畢,我們可以直接進入CLOSE狀態了,但是我們必須假象網絡是不可靠的,有可以最后一個ACK丟失。所以TIME_WAIT狀態就是用來重發可能丟失的ACK報文。
        • 因為當Server端收到Client端的SYN連接請求報文后,可以直接發送SYN+ACK報文。其中ACK報文是用來應答的,SYN報文是用來同步的。但是關閉連接時,當Server端收到FIN報文時,很可能并不會立即關閉SOCKET,所以只能先回復一個ACK報文,告訴Client端,"你發的FIN報文我收到了"。只有等到我Server端所有的報文都發送完了,我才能發送FIN報文,因此不能一起發送。故需要四步握手。
        • 三次握手(SYN/SYN+ACK/ACK)
        • 四次揮手(FIN/ACK/FIN/ACK)
        • TCP:面向連接/可靠/基于字節流
        • UDP:無連接/不可靠/面向報文
        • 三次握手四次揮手
        • 為什么連接的時候是三次握手,關閉的時候卻是四次握手?
        • 為什么TIME_WAIT狀態需要經過2MSL(最大報文段生存時間)才能返回到CLOSE狀態?
      • XSS/CSRF

      • HttpOnly 禁止 js 腳本訪問和操作 Cookie,可以有效防止 XSS

      Mysql

      • 索引改進過程

        • 線性結構->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)
      • Mysql面試總結基礎篇

      • https://segmentfault.com/a/1190000018371218

      • Mysql面試總結進階篇

        • https://segmentfault.com/a/1190000018380324
      • 深入淺出Mysql

        • http://ningning.today/2017/02/13/database/深入淺出mysql/
      • 清空整個表時,InnoDB是一行一行的刪除,而MyISAM則會從新刪除建表

      • text/blob數據類型不能有默認值,查詢時不存在大小寫轉換

      • 什么時候索引失效

        • 應盡量避免在 where 子句中使用 != 或 <> 操作符,否則引擎將放棄使用索引而進行全表掃描
        • 盡量避免在 where 子句中使用 or 來連接條件,否則將導致引擎放棄使用索引而進行全表掃描,即使其中有條件帶索引也不會使用,這也是為什么盡量少用 or 的原因
        • 如果列類型是字符串,那一定要在條件中將數據使用引號引用起來,否則不會使用索引
        • 應盡量避免在 where 子句中對字段進行函數操作,這將導致引擎放棄使用索引而進行全表掃描
        • 對于多列索引,不是使用的第一部分,則不會使用索引
        • 以%開頭的like模糊查詢
        • 出現隱式類型轉換
        • 沒有滿足最左前綴原則
        • 失效場景:
      例如:
      select id from t where substring(name,1,3) = 'abc' – name;
      以abc開頭的,應改成:
      select id from t where name like 'abc%'
      例如:
      select id from t where datediff(day, createdate, '2005-11-30') = – '2005-11-30';
      應改為:

      不要在 where 子句中的 “=” 左邊進行函數、算術運算或其他表達式運算,否則系統將可能無法正確使用索引

      應盡量避免在 where 子句中對字段進行表達式操作,這將導致引擎放棄使用索引而進行全表掃描

      如:
      select id from t where num/2 = 100
      應改為:
      select id from t where num = 100*2;

      不適合鍵值較少的列(重復數據較多的列)比如:set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似,但只可以添加64個值)

      如果MySQL估計使用全表掃描要比使用索引快,則不使用索引

      • 什么是聚集索引
        • B+Tree葉子節點保存的是數據還是指針
        • MyISAM索引和數據分離,使用非聚集
        • InnoDB數據文件就是索引文件,主鍵索引就是聚集索引

      Redis 命令總結

      • 為什么這么快?

        • 因為Redis是基于內存的操作,CPU不是Redis的瓶頸,Redis的瓶頸最有可能是機器內存的大小或者網絡帶寬。既然單線程容易實現,而且CPU不會成為瓶頸,那就順理成章地采用單線程的方案了(畢竟采用多線程會有很多麻煩?。?。
        • 基于內存,由 C 語言編寫
        • 使用多路I/O復用模型,非阻塞 IO
        • 使用單線程減少線程間切換
        • 數據結構簡單
        • 自己構建了 VM 機制,減少調用系統函數的時間
      • 優勢

        • 性能高 – Redis 能讀的速度是110000次/s,寫的速度是81000次/s
        • 豐富的數據類型
        • 原子 – Redis 的所有操作都是原子性的,同時 Redis 還支持對幾個操作全并后的原子性執行
        • 豐富的特性 – Redis 還支持 publish/subscribe(發布/訂閱), 通知, key 過期等等特性
      • 什么是 redis 事務?

        • 將多個請求打包,一次性、按序執行多個命令的機制
        • 通過 multi,exec,watch 等命令實現事務功能
        • Python redis-py pipeline=conn.pipeline(transaction=True)
      • 持久化方式

        • save(同步,可以保證數據一致性)
        • bgsave(異步,shutdown時,無AOF則默認使用)
        • RDB(快照)
        • AOF(追加日志)
      • 怎么實現隊列

        • push
        • rpop
      • 常用的數據類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)

        • skiplist(跳躍表)
        • intset或hashtable
        • ziplist(連續內存塊,每個entry節點頭部保存前后節點長度信息實現雙向鏈表功能)或double linked list
        • 整數或sds(Simple Dynamic String)
        • String(字符串):計數器
        • List(列表):用戶的關注,粉絲列表
        • Hash(哈希):
        • Set(集合):用戶的關注者
        • Zset(有序集合):實時信息排行榜
      • 與 Memcached 區別

        • Memcached只能存儲字符串鍵
        • Memcached用戶只能通過APPEND的方式將數據添加到已有的字符串的末尾,并將這個字符串當做列表來使用。但是在刪除這些元素的時候,Memcached采用的是通過黑名單的方式來隱藏列表里的元素,從而避免了對元素的讀取、更新、刪除等操作
        • Redis和Memcached都是將數據存放在內存中,都是內存數據庫。不過Memcached還可用于緩存其他東西,例如圖片、視頻等等
        • 虛擬內存–Redis當物理內存用完時,可以將一些很久沒用到的Value 交換到磁盤
        • 存儲數據安全–Memcached掛掉后,數據沒了;Redis可以定期保存到磁盤(持久化)
        • 應用場景不一樣:Redis出來作為NoSQL數據庫使用外,還能用做消息隊列、數據堆棧和數據緩存等;Memcached適合于緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和Session等
      • Redis實現分布式鎖

        • 使用setnx實現加鎖,可以同時通過expire添加超時時間
        • 鎖的value值可以是一個隨機的uuid或者特定的命名
        • 釋放鎖的時候,通過uuid判斷是否是該鎖,是則執行delete釋放鎖
      • 常見問題

        • 當訪問量劇增、服務出現問題(如響應時間慢或不響應)或非核心服務影響到核心流程的性能時,仍然需要保證服務還是可用的,即使是有損服務。系統可以根據一些關鍵數據進行自動降級,也可以配置開關實現人工降級
        • 數據過期,進行更新緩存數據
        • 初始化項目,將部分常用數據加入緩存
        • 請求訪問數據時,查詢緩存中不存在,數據庫中也不存在
        • 短時間內緩存數據過期,大量請求訪問數據庫
        • 緩存雪崩
        • 緩存穿透
        • 緩存預熱
        • 緩存更新
        • 緩存降級
      • 一致性Hash算法

        • 使用集群的時候保證數據的一致性
      • 基于redis實現一個分布式鎖,要求一個超時的參數

        • setnx
      • 虛擬內存

      • 內存抖動

      Linux


      • Unix五種i/o模型

        • select
        • poll
        • epoll
        • 并發不高,連接數很活躍的情況下
        • 比select提高的并不多
        • 適用于連接數量較多,但活動鏈接數少的情況
        • 阻塞io
        • 非阻塞io
        • 多路復用io(Python下使用selectot實現io多路復用)
        • 信號驅動io
        • 異步io(Gevent/Asyncio實現異步)
      • 比 man 更好使用的命令手冊

        • tldr:一個有命令示例的手冊
      • kill -9和-15的區別

        • -15:程序立刻停止/當程序釋放相應資源后再停止/程序可能仍然繼續運行
        • -9:由于-15的不確定性,所以直接使用-9立即殺死進程
      • 分頁機制(邏輯地址和物理地址分離的內存分配管理方案):

        • 操作系統為了高效管理內存,減少碎片
        • 程序的邏輯地址劃分為固定大小的頁
        • 物理地址劃分為同樣大小的幀
        • 通過頁表對應邏輯地址和物理地址
      • 分段機制

        • 為了滿足代碼的一些邏輯需求
        • 數據共享/數據保護/動態鏈接
        • 每個段內部連續內存分配,段和段之間是離散分配的
      • 查看 cpu 內存使用情況?

        • top
        • free 查看可用內存,排查內存泄漏問題

      設計模式


      單例模式

      # 方式一
      def Single(cls,*args,**kwargs):
          instances = {}
          def get_instance (*args, **kwargs):
              if cls not in instances:
                  instances[cls] = cls(*args, **kwargs)
              return instances[cls]
          return get_instance
      @Single
      class B:
          pass
      # 方式二
      class Single:
          def __init__(self):
              print("單例模式實現方式二。。。")

      single = Single()
      del Single  # 每次調用single就可以了
      # 方式三(最常用的方式)
      class Single:
          def __new__(cls,*args,**kwargs):
              if not hasattr(cls,'_instance'):
                  cls._instance = super().__new__(cls,*args,**kwargs)
              return cls._instance

      工廠模式

      class Dog:
          def __init__(self):
              print("Wang Wang Wang")
      class Cat:
          def __init__(self):
              print("Miao Miao Miao")


      def fac(animal):
          if animal.lower() == "dog":
              return Dog()
          if animal.lower() == "cat":
              return Cat()
          print("對不起,必須是:dog,cat")

      構造模式

      class Computer:
          def __init__(self,serial_number):
              self.serial_number = serial_number
              self.memory = None
              self.hadd = None
              self.gpu = None
          def __str__(self):
              info = (f'Memory:{self.memoryGB}',
              'Hard Disk:{self.hadd}GB',
              'Graphics Card:{self.gpu}')
              return ''.join(info)
      class ComputerBuilder:
          def __init__(self):
              self.computer = Computer('Jim1996')
          def configure_memory(self,amount):
              self.computer.memory = amount
              return self #為了方便鏈式調用
          def configure_hdd(self,amount):
              pass
          def configure_gpu(self,gpu_model):
              pass
      class HardwareEngineer:
          def __init__(self):
              self.builder = None
          def construct_computer(self,memory,hdd,gpu)
              self.builder = ComputerBuilder()
              self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
          @property
          def computer(self):
              return self.builder.computer

      數據結構和算法

      python實現各種數據結構

      快速排序

      def quick_sort(_list):
          if len(_list) < 2:
              return _list
          pivot_index = 
          pivot = _list(pivot_index)
          left_list = [i for i in _list[:pivot_index] if i < pivot]
          right_list = [i for i in _list[pivot_index:] if i > pivot]
          return quick_sort(left) + [pivot] + quick_sort(right)

      選擇排序

      def select_sort(seq):
          n = len(seq)
          for i in range(n-1)
          min_idx = i
              for j in range(i+1,n):
                  if seq[j] < seq[min_inx]:
                      min_idx = j
              if min_idx != i:
                  seq[i], seq[min_idx] = seq[min_idx],seq[i]

      插入排序

      def insertion_sort(_list):
          n = len(_list)
          for i in range(1,n):
              value = _list[i]
              pos = i
              while pos >  and value < _list[pos - 1]
                  _list[pos] = _list[pos - 1]
                  pos -= 1
              _list[pos] = value
              print(sql)

      歸并排序

      def merge_sorted_list(_list1,_list2):   #合并有序列表
          len_a, len_b = len(_list1),len(_list2)
          a = b = 
          sort = []
          while len_a > a and len_b > b:
              if _list1[a] > _list2[b]:
                  sort.append(_list2[b])
                  b += 1
              else:
                  sort.append(_list1[a])
                  a += 1
          if len_a > a:
              sort.append(_list1[a:])
          if len_b > b:
              sort.append(_list2[b:])
          return sort

      def merge_sort(_list):
          if len(list1)<2:
              return list1
          else:
              mid = int(len(list1)/2)
              left = mergesort(list1[:mid])
              right = mergesort(list1[mid:])
              return merge_sorted_list(left,right)

      堆排序heapq模塊

      from heapq import nsmallest
      def heap_sort(_list):
          return nsmallest(len(_list),_list)

      from collections import deque
      class Stack:
          def __init__(self):
              self.s = deque()
          def peek(self):
              p = self.pop()
              self.push(p)
              return p
          def push(self, el):
              self.s.append(el)
          def pop(self):
              return self.pop()

      隊列

      from collections import deque
      class Queue:
          def __init__(self):
              self.s = deque()
          def push(self, el):
              self.s.append(el)
          def pop(self):
              return self.popleft()

      二分查找

      def binary_search(_list,num):
          mid = len(_list)//2
          if len(_list) < 1:
              return Flase
          if num > _list[mid]:
              BinarySearch(_list[mid:],num)
          elif num < _list[mid]:
              BinarySearch(_list[:mid],num)
          else:
              return _list.index(num)


      面試加強題

      • 關于數據庫優化及設計
        • 使用hash一致算法
        • setnx
        • setnx + expire
        • 使用redis
        • 如果InnoDB表的數據寫入順序能和B+樹索引的葉子節點順序一致的話,這時候存取效率是最高的。為了存儲和查詢性能應該使用自增長id做主鍵。
        • 對于InnoDB的主索引,數據會按照主鍵進行排序,由于UUID的無序性,InnoDB會產生巨大的IO壓力,此時不適合使用UUID做物理主鍵,可以把它作為邏輯主鍵,物理主鍵依然使用自增ID。為了全局的唯一性,應該用uuid做索引關聯其他表或做外鍵
        • https://segmentfault.com/a/1190000018426586
        • 如何使用兩個棧實現一個隊列
        • 反轉鏈表
        • 合并兩個有序鏈表
        • 刪除鏈表節點
        • 反轉二叉樹
        • 設計短網址服務?62進制實現
        • 設計一個秒殺系統(feed流)?
        • https://www.jianshu.com/p/ea0259d109f9
        • 為什么mysql數據庫的主鍵使用自增的整數比較好?使用uuid可以嗎?為什么?
        • 如果是分布式系統下我們怎么生成數據庫的自增id呢?
        • 基于redis實現一個分布式鎖,要求一個超時的參數如果redis單個節點宕機了,如何處理?還有其他業界的方案實現分布式鎖碼?

      緩存算法


      • LRU(least-recently-used):替換最近最少使用的對象

      • LFU(Least frequently used):最不經常使用,如果一個數據在最近一段時間內使用次數很少,那么在將來一段時間內被使用的可能性也很小

      服務端性能優化方向

      • 使用數據結構和算法

      • 數據庫

        • slow_query_log_file開啟并且查詢慢查詢日志
        • 通過explain排查索引問題
        • 調整數據修改索引
        • 索引優化
        • 慢查詢消除
        • 批量操作,從而減少io操作
        • 使用NoSQL:比如Redis
      • 網絡io

        • 批量操作
        • pipeline
      • 緩存

        • Redis
      • 異步

        • Asyncio實現異步操作
        • 使用Celery減少io阻塞
      • 并發

      • 多線程

      • Gevent

      標簽:數據 索引 函數
      如何執行超過100M的SQL腳本?
      ? 上一篇 2022-04-24
      微服務架構下基于Prometheus構建綜合監控平臺的最佳實踐
      下一篇 ? 2022-04-24
      • 如何在Ubuntu中保留文件系統并備份當前開發板鏡像
        0閱讀 0條評論 個贊
        在Ubuntu保留文件系統或者說備份當前開發板鏡像的需求在不斷增加。比如Ubuntu文件系統需要安裝庫文件的話直接使用apt-get工具就可以下載,但由于需要下載的核心板較多,比較費時間,這時需要將安……
      • 國產核心板全志T507助力消防系統升級
        0閱讀 0條評論 個贊
        9月16日下午,位于湖南長沙市區內的中國電信大樓發生火災,建筑高度218米,現場濃煙滾滾,數十層樓體燃燒劇烈。消防救援人員趕到現場后很快將火勢控制住,目前大樓火勢已被撲滅,所幸未發現人員傷亡。湖南電信……
      • 教大家如何處理Spring Boot易流中的用戶和群體!
        0閱讀 0條評論 個贊
        1.準備工作2.用戶操作2.1添加用戶2.2修改用戶2.3刪除用戶2.4查詢用戶3.組操作3.1添加組3.2修改組3.3刪除組3.4查詢組4.查看表詳情雖然說我們在實際開發中,……
      • 從PG15開始WAL壓縮優化
        0閱讀 0條評論 個贊
        PG15傳聞中的超級令人激動的功能大多數跳票了,年初我也寫過一個關于PG15新功能跳票的文章。PG15BETA已經發出幾個月了,似乎PG15里令人激動人心的功能不多,不過從長長的新功能列表里,……
      • 深入了解美團葉子發射器開源方案
        0閱讀 0條評論 個贊
        大家好,我是樹哥。之前我們有聊過「如何設計一個分布式ID發號器」,其中有講過4種解決方案,分別是:UUID類雪花算法數據庫自增主鍵Redis原子自增美團以第2、3種解決方案為基礎,開發出……
      發表評論 共有條評論
      用戶名: 密碼:
      驗證碼: 匿名發表
      • 關于這個能見度的例子 網上95%的文章都是錯的!
        0閱讀 0條評論 個贊
        你好,我是坤哥上周我在查閱資料時無意中搜到一篇解釋volatile用法的博文,這篇博文排得很靠前,不過很遺憾,雖然結論是對的,但分析過程完全錯誤,而且我發現網上很多文章都用這個例子來解釋vola……
      • 卡夫卡數據丟失問題優化總結及重復消費原因分析(一)
        0閱讀 0條評論 個贊
        .css-1yuhvjn{margin-top:16px;}.css-3jt6os.FileLinkCard{-webkit-align-items:center;-webkit-box-align……
      • Python自學教程7:字典類型有什么用
        0閱讀 0條評論 個贊
        字典是Python中的一個重要操作,如果字典玩得順,很多其他的數據類型就可以一通百通。Python字典的定義字典使用一對大括號進行定義,鍵值對之間使用逗號隔開,鍵和值使用冒號分隔。鍵必須是不可變類型,……
      • 數據庫發展史1-傳統數據庫
        0閱讀 0條評論 個贊
        1946年,美國賓夕法尼亞大學誕生了人類第一臺電子計算機--ENIAC(ElectronicNumericalIntegratorAndComputer,即電子數字積分計算機),這個占地170……
      • 長文解讀春季交易!隔離?傳播性?網被消滅了!
        9閱讀 0條評論 個贊
        1.什么是事務2.Spring中的事務2.1兩種用法2.2三大基礎設施3.編程式事務4.聲明式事務4.1XML配置4.2Java配置4.3混合配置5.事務屬性5.1隔離性5……
      • 數據庫發展史II-數據倉庫
        6閱讀 0條評論 個贊
        回顧數據倉庫的發展歷程,大致可以將其分為幾個階段:萌芽探索到全企業集成時代、企業數據集成時代、混亂時代--"數據倉庫之父"間的論戰、理論模型確認時代以及數據倉庫產品百家爭鳴時代。數據倉庫理論發展歷程上……
      • 用戶自定義注釋 AOP實現的日志保存(數據庫) 所有代碼都可以粘貼復制
        0閱讀 0條評論 個贊
        前言1,在一些特定的場景我們往往需要看一下接口的入參,特別是跨系統的接口調用(下發,推送),這個時候的接口入參就很重要,我們保存入參入庫,如果出問題就可以馬上定位是上游還是下游的問題(方便扯皮)2,還……
      • 人人都能讀懂的源代碼——那些關于DOM的常見鉤子包(二)
        0閱讀 0條評論 個贊
        本文是深入淺出ahooks源碼系列文章的第十五篇,該系列已整理成文檔-地址。覺得還不錯,給個star支持一下哈,Thanks。本篇接著針對關于DOM的各個Hook封裝進行解讀。useFul……
      • 教大家如何處理Spring Boot易流中的用戶和群體!
        0閱讀 0條評論 個贊
        1.準備工作2.用戶操作2.1添加用戶2.2修改用戶2.3刪除用戶2.4查詢用戶3.組操作3.1添加組3.2修改組3.3刪除組3.4查詢組4.查看表詳情雖然說我們在實際開發中,……
      • 計算機網絡-了解-DNS和HTTPDNS
        0閱讀 0條評論 個贊
        DNS和HTTPDNSDNS域名解析的過程傳統DNS存在的問題1、域名緩存問題2、域名轉發問題3、出口NAT問題4、DNS域名更新問題5、解析延遲問題6、運營商劫持HTTPDNSHTTP……
      • Oracle服務器遷移的一些經驗
        3閱讀 0條評論 個贊
        前言通過此文章來分享一下Oracle服務器遷移過程中的一些經驗,希望對大家有些許幫助。本文旨在幫助更多的同學,會提及一些基本命令或技巧,但不贅述,后續有機會再進一步分享各個細節。背景之前因機房遷移……
      • Python入門系列(七)開發常說的"累"與"對象"
        0閱讀 0條評論 個贊
        類與對象Python是一種面向對象的編程語言。要創建類,請使用關鍵字classclassMyClass:x=5創建一個名為p1的對象,并打印x的值p1=MyClass()print(p1……
      • 當我們在并行學習的時候 我們到底在學習什么?
        0閱讀 0條評論 個贊
        大家好,我是鲏。前段時間,星球里一位朋友問我:魚皮,高并發項目牽扯的知識有哪些?之前看到的一個回答:既要解決性能的問題又要考慮業務完整性,還有網絡資源、服務器資源等,我不太能理解,希望魚皮細說。我就簡……
      • 人工智能OPS的莫拉維克悖論
        3閱讀 0條評論 個贊
        莫拉維克的悖論是人工智能和機器人研究人員觀察到,與傳統假設相反,推理需要很少的計算,但感覺運動和感知技能需要大量的計算資源。該原則由HansMoravec、RodneyBrooks、Marvin……
      • 開發者如何在應用后臺直接控制用戶的運動狀態?
        18閱讀 0條評論 個贊
        酷暑終于過去,很多人伴著涼爽的秋風開啟了新一輪的健身計劃。當用戶進行戶外運動或使用跑步機、橢圓機等器械時,他們會希望在運動健康類App里點擊即可開啟運動并記錄運動數據。而對于開發者自己開發的應用來說,……
      • 深入理解Redis數據結構-字典
        0閱讀 0條評論 個贊
        字典,又稱為符號表、關聯數組或映射,是一種用于保存鍵值對的抽象數據結構。在字典中,一個鍵可以和一個值進行關聯,這些關聯的鍵和值稱為鍵值對。鍵值對中鍵是唯一的,我們可以根據鍵key通過映射查找或者更新對……
      • SQL Server:觸發器的詳細說明
        0閱讀 0條評論 個贊
        1.概述2.觸發器的分類3.Inserted和Deleted表4.觸發器的執行過程5.創建觸發器6.修改觸發器:7.刪除觸發器:8.查看數據庫中已有觸發器:9.“Insteadof……
      • 面試官:為什么系統不推薦雙寫?
        0閱讀 0條評論 個贊
        某日,阿雄跑去面試!于是有如下情形面試官:"阿雄是吧,做做自我介紹!"阿雄:"我叫阿雄,來自某a國際電商公司!"面試官:"我看你項目里用了elasticsearch,你是怎么同步數據的呢?"阿……
      • Linux環境程序如何運行?
        0閱讀 0條評論 個贊
        .css-1yuhvjn{margin-top:16px;}.css-3jt6os.FileLinkCard{-webkit-align-items:center;-webkit-box-align……
      • Go語言知識|基本數據類型
        0閱讀 0條評論 個贊
        前言學習Go半年之后,我決定重新開始閱讀《TheGoProgramingLanguage》,對書中涉及重點進行全面講解,這是Go語言知識查漏補缺系列的文章第二篇,前一篇文章則對應書中一二兩章。我……
      最近發布資訊
      更多
      警花高潮嗷嗷叫
      <del id="nnjnj"></del><track id="nnjnj"></track>

      <p id="nnjnj"></p>

      <address id="nnjnj"></address>

        <pre id="nnjnj"><pre id="nnjnj"></pre></pre>

          <noframes id="nnjnj"><ruby id="nnjnj"><ruby id="nnjnj"></ruby></ruby>