爲學爬蟲而學python（三）

• 字典：‘鍵值對’的無序可變序列,鍵不可重複，值可以
• 字典的創建
  1.直接創建
  a={‘name’:‘oydq’,‘age’:18}
  2.dict創建
  a=dict([(“name”,“oydq”),(“age”,18)])
  3.zip創建
  k=[‘name’,‘age’]
  v=[‘oydq’,18]
  d=dict(zip(k,v))
  4.通過fromkeys創建值爲空的字典
  a=dict.fromkeys([‘name’,‘age’])
• 1.通過鍵獲得值,不存在拋出異常
  a[‘name’] ##‘oydq’
  2.get() 方法得到,不存在返回null
  a.get(‘name’)
  3.列出所有的鍵值對
  a.items()
  4.列出所有的鍵
  a.keys()
  5.列出所有的值
  a.values()
• len()鍵值對的個數
• 檢測一個鍵是否在字典中
  ‘name’ in a ##true
  字典元素添加
  a[‘address’]=‘湖南’(原來不存在)
  修改
  a[‘name’]=‘oydw’
  新字典鍵值對全部添加到舊字典上，如果鍵有重複，直接覆蓋
  a={‘name’=‘xm’,‘age’=18}
  b={‘name’=‘xh’,‘address’=‘江西’}
  a.update(b)
  a ##name=‘xh’,age=18,address=‘江西’
  字典元素刪除
  del()刪除指定鍵值對,clear()刪除所有鍵值對,pop()刪除指定鍵值對,返回對應值
  del(a.[‘name’])
  b=a.pop(‘age’)
  b ##18
  popitem()隨機刪除和返回鍵值對
  序列解包，可用於列表、字典，方便多個變量賦值
  x,y,z=(20,30,10)
  (a,b,c)=(20,30,10)
  [a,b,c]=[20,30,10]
  s={‘name’=‘xm’,‘age’=18}
  a,b=s
  a##‘name’
  b##‘age’
  c,d=s.values()
  c##‘xm’
  d##18
  e=s.items()
  e##(‘name’,‘xm’)
  e[0]##‘name’
  e[1]##‘xm’
  注意：
  1.不要在遍歷字典同時進行字典的修改
  2.字典空間換時間
  集合
  無序可變，元素不能重複
  集合底層是字典，集合的所有元素都是字典中的鍵對象，因此不能重複的且唯一
  使用{}創建集合對象，並用add()方法添加元素
  a={3,5,7}
  a.add(9)
  a ##{9,3,5,7}
  用set(),將列表、元組等可迭代的對象轉化成集合，如果數據存在重複數據，只保留一個
  a=[3,5,7]
  b=set(a)
  b##{3,5,7}
  remove()刪除指定元素，clear()清空
  a={3,5,7}
  a.remove(5)
  a##{3,7}
  交集，並集，差集
  a={3,5,7}
  b={3,6,8,9,5}
  a|b 或a.union(b)##並集{3,3,5,5,6,7,8,9}
  a&b 或a.intersection(b)##交集{3,5}
  a-b 或a.difference(b)##差集{7}
  if 語句中空的列表是false
  三元條件運算符
  條件爲真時的值 if （條件表達式）else 條件爲假的值
  if 條件表達式1：
  語句塊1
  elif 條件表達式2：
  語句塊2
  …
  for x in (20,10,33)
  循環代碼優化
  1.儘量減少循環內部不必要的計算。
  2.嵌套循環中，儘量減少內部循環計算，儘可能向外提。
  3.儘量使用局部變量。
  zip()並行迭代
  names=(‘xh’,‘xm’,‘xj’,‘xt’)
  ages=(18,25,16)
  jobs=(‘ls’,‘cxy’,‘gwy’)
  for name,age,job in zip(names,ages,jobs):
  print("{0}–{1}–{2}".format(name,age,job))
  #xh–18–ls xm–25–cxy xj–16–gwy
  或
  for i in range(3):
  print("{0}–{1}–{2}".format(names[i],ages[i],jobs[i]))
  #xh–18–ls xm–25–cxy xj–16–gwy
  推導式創建序列
  1.列表推導式
  [表達式 for item in 可迭代對象 if 條件判斷]
  [x for x in range(1,5)] -->[1,2,3,4]
  [a2 for x in range(1,20) if x%5==0] -->[10,20,30]
  a=[(m,n) for i in range(1,3) for j in range(1,3)]
  #(1,1),(1,2),(2,1),(2,2)
  2.字典推導式
  {key:value for 表達式 in 可迭代對象}
  t=“i love you,i love oydq,i love oudw”
  k={x:t.count(x) for x in t}
  #統計各字母出現的次數
  #{‘i’: 3, ’ ': 6, ‘l’: 3, ‘o’: 6, ‘v’: 3, ‘e’: 3, ‘y’: 2, ‘u’: 2, ‘,’: 2, ‘d’: 2, ‘q’: 1, ‘w’: 1}
  3.集合推導式
  {表達式 for item in 可迭代對象 if 條件判斷}
  {x for x in range(1,5)} -->{1,2,3,4}
  {a2 for x in range(1,20) if x%5==0} -->{10,20,30}
  a={(m,n) for i in range(1,3) for j in range(1,3)}
  4.生成器推導器（生成元組）
  元組沒有推導式
  a=(x2 for x in range(5)) -->0,2,4,6,8
  函數定義
  def 函數名 ([參數列表])
  ‘’‘註釋’’’
  函數體
  return 返回值
  函數調用
  函數名(參數);
  形參無需指明數據類型
  函數裏用’’‘註釋’’’
  函數參數不以值傳遞！
  傳遞可變對象（字典、列表、集合、自定義對象）的引用：在函數體中不創建新的對象拷貝，直接可以修改所傳遞的對象。
  傳遞不可變對象（元組、字符串、int、float、布爾值）的引用：由於不可對象不可修改，系統會創建一個新對象。
  淺拷貝copy()、深拷貝deepcopy() import copy
  可變參數：
  參數 將多個參數收集到一個“元組”裏
  **參數 將多個參數收集到一個“字典”裏
  lambda 表達式
  lambda 參數 : 表達式 -->生成匿名函數
  g=[lambda a:a2,lambda b:b-1]#定義lambda表達式
  g[0](6),g[1](5)#調用lambda表達式
  eval()函數
  將字符串str當成有效的表達式來求值並返回計算結果
  eval(print(“abc”)) #abc
  nonlocal 用來聲明外層局部變量
  global 用來聲明全局變量
  LEGB規則
  查找名稱順序，函數或類的方法內部->嵌套函數->模塊中的全局變量->Python爲自己保留的特殊名稱
  類的定義
  class 類名(首字母大寫):類體
  構造函數_init_()
  def init (self,參數列表):函數體#實例方法self參數必須位於第一個參數，類似於this的作用
  實例化
  a=類名(參數列表)
  a.實例屬性=值
  a.實例方法
  類方法定義
  @classmethod
  def 類方法名(cls,參數列表):#類方法cls參數必須位於第一個參數，類似於this的作用
  函數體
  類名.類方法名
  靜態方法定義
  @staticmethod
  def 靜態方法名(參數列表)：
  函數體
  靜態方法不可訪問實例屬性與方法
  與普通函數沒啥區別，只不過需要類調用
  類名.靜態方法名
  def del(self)析構函數，自動垃圾回收
  call_方法和可調用對象
  方法沒有重載
  Python的動態性
  class Person:
  def work(self):
  print(“努力上班”)
  def play_game(s):
  print("{0}在玩遊戲".format(s))
  Person.play=play_game
  p=Person()
  p.work()
  p.play()#Person.play§
  實例化屬性加__屬性名設置私有屬性（兩條下劃線）
  類的外部不可直接訪問，但可以用_類名__屬性名間接訪問
  實例化私有方法 def a(): （兩條下劃線）
  類的外部不可直接訪問，但可以用_類名__方法名()間接訪問
  類屬性，類方法私有同實例屬性和實例方法形式
  @property 裝飾器
  get(),set()方法訪問私有屬性
  繼承
  class 父類:pass
  class 子類(父類):pass
  def init (self,參數列表):函數體
  父類.init (self,參數列表)#調父類構造器
  方法重寫
  子類重寫父類方法，覆蓋父類方法
  支持多重繼承，儘量避免使用，
  class 父類1:pass
  class 父類2:pass
  class 子類(父類1，父類2):pass
  mro()方法解析順序
  super()獲取父類的定義
  class A:
  def ttt(self):
  print(“A”,self)
  class B(A):
  def ttt(self):
  super().ttt()
  print(“B”,self)
  B().ttt()
  ‘’‘A <main.B object at 0x031EB3A0>
  B <main.B object at 0x031EB3A0>’’’
  多態
  class 父類:pass
  class 子類1(父類):pass
  class 子類2(父類):pass
  class 子類3(父類):pass
  特殊方法
  重寫特殊方法可以實現運算符的重載
  打印的特殊方法__repr、str
  加號的特殊方法__add_
  class JIA:
  def add(self,a,b):
  self.sum=a+b2
  特殊屬性