为学爬虫而学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
  特殊属性