s21day21 python笔记

s21day21 python笔记

一、内容回顾及补充

• 内置函数补充

  • type()：查看数据类型

    class Foo:
        pass
    obj = Foo()
    if type(obj) == Foo:
        print('obj是Foo类的对象')

  • issubclass(类，类或其基类)：判断前一个类是否是后一个类或其基类的子类

    • 结果是布尔类型，是 -> True，否 -> False

    class Base:
        pass
    class Base1(Base):
        pass
    class Foo(Base1):
        pass
    class Bar:
        pass
    print(issubclass(Bar,Base))
    print(issubclass(Foo,Base))

  • isinstance(对象，类或其基类)：判断一个对象是否是一个类或其基类的实例(对象)

    • 结果是布尔类型，是 -> True，否 -> False
    • 注意：判断一个对象是否是一个类的实例(对象)，一定要用type，不要用isinstance

    class Base(object):
        pass
    class Foo(Base):
        pass
    obj = Foo()
    print(isinstance(obj,Foo))  # 判断obj是否是Foo类或其基类的实例（对象）
    print(isinstance(obj,Base)) # 判断obj是否是Foo类或其基类的实例（对象）

  • super().方法名()：根据self对象所属的类的继承关系，按照顺序依次找方法并执行(找到第一个为止)

    class Base(object):
        def func(self):
            super().func()  # 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个为止)
            print('base.func')
    class Bar(object):
        def func(self):
            print('bar.func')
    class Foo(Base,Bar): # Foo -> Base -> Bar
        pass
    obj = Foo()
    obj.func()

二、特殊成员

• 特殊成员：就是为了能够快速实现执行某些方法而生

2.1 __init__

• 初始化方法
• 用途：用于给对象中赋值

class Foo:
    def __init__(self,a1):
        self.a1 = a1
obj = Foo('alex')

2.2 __new__

• 构造方法
• 用于创建空对象

class Foo(object):
    def __init__(self):
        self.x = 123
    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)
obj = Foo()     # 先执行__new__方法，再执行__init__方法

2.3 __call__

• 对象后面加括号执行该方法

class Foo(object):
    def __call__(self, *args, **kwargs):
        print('执行call方法')
obj = Foo()
obj()        # 对象后面加括号，执行__call__方法
# 相当于Foo()()

• 网站示例：

from wsgiref.simple_server import make_server
def func(environ,start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    return ['你好'.encode("utf-8")  ]
class Foo(object):
    def __call__(self, environ,start_response):
        start_response("200 OK", [('Content-Type', 'text/html; charset=utf-8')])
        return ['你<h1 style="color:red;">不好</h1>'.encode("utf-8")]
# 作用：写一个网站，用户只要来方法，就自动找到第三个参数并执行。
server = make_server('127.0.0.1', 8000, Foo())
server.serve_forever()

2.4 __getitem__ __setitem__ __delitem__

class Foo(object):
    def __setitem__(self, key, value):
        pass
    def __getitem__(self, item):
        return 'uuu'
    def __delitem__(self, key):
        pass
obj1 = Foo()
obj1['k1'] = 123        # 内部会自动调用 __setitem__方法
val = obj1['xxx']       # 内部会自动调用 __getitem__方法，用val接受返回值
del obj1['ttt']         # 内部会自动调用 __delitem__ 方法

2.5 __str__

• 只有在打印对象时，会自动化调用此方法，并将其返回值在页面显示出来

class Foo(object):
    def __str__(self):
        return 'asdfasudfasdfsad'
obj = Foo()
print(obj)     # obj是一个对象，打印__str__方法的返回值

• 示例：

class User(object):
    def __init__(self,name,email):
        self.name = name
        self.email = email
    def __str__(self):
        return "%s %s" %(self.name,self.email,)
user_list = [User('二狗','2g@qq.com'),User('二蛋','2d@qq.com'),User('狗蛋','xx@qq.com')]
for item in user_list:
    print(item)

2.6 __dict__

• 去对象中找到所有变量并将其转换为字典

class Foo(object):
    def __init__(self,name,age,email):
        self.name = name
        self.age = age
obj = Foo('alex',19)
val = obj.__dict__     # 去对象中找到所有变量并将其转换为字典
print(val)

2.7 __enter__ __exit__

• 上下文管理

# 面试题
class Foo(object):
    def do_something(self):
        print('内部执行')      # 第三步
class Context:
    def __enter__(self):
        print('进入')           # 第一步
        return Foo()
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('推出')      # 第四步
with Context() as ctx:
    print('内部执行')      # 第二步
    ctx.do_something()

2.8 __add__

• 两个对象相加时用到此方法

class Foo(object):
    def __add__(self, other):    # self：obj1，other：obj2
        return 123      
obj1 = Foo()
obj2 = Foo()
val  = obj1 + obj2    # 内部会自动调用 __add__方法，并用val接受返回值
print(val)      # 123

三、异常处理

3.1 基本格式

# 示例一：
import requests
try:     # 尝试进行下面操作，如果可以执行，就执行下面代码
    ret = requests.get('http://www.google.com')
    print(ret.text)
except Exception as e:   # 如果不可以执行(平时会报错)，这时不会报错，执行下面代码
    print('请求异常')   
# 示例二：
try:
    v = []
    v[11111]          # IndexError类型的异常
except ValueError as e:   # ValueError是一个类，继承Exception，只能捕获到ValueError类型的异常
    pass
except IndexError as e:   # IndexError是一个类，继承Exception，只能捕获到IndexError类型的异常
    pass
except Exception as e:    # Exception是一个类，可以捕获到所有异常
    print(e)           # e是Exception类的对象，存储了一个错误信息

• finally

  try:
      int('asdf')
  except Exception as e:
      print(e)
  finally:
      print('最后无论对错都会执行')
  # 特殊情况:
  def func():
      try:
          int('asdf')
      except Exception as e:
          return 123
      finally:
          print('最后')   # 无论对错，函数中遇到return，也会执行，执行完后再return
  func()

• 建议：书写函数或功能时，建议用try包裹一下，避免报错

• 示例

  # 1. 写函数，函数接受一个列表，请将列表中的元素每个都 +100
  def func(arg):
      result = []
      for item in arg:
          if item.isdecimal():
              result.append(int(item) + 100)
    return result 
  # 2. 写函数去，接受一个列表。列表中都是url，请访问每个地址并获取结果
  import requests
  def func1(url_list):
      result = []
      try:
          for url in url_list:
              response = requests.get(url)
              result.append(response.text)
    except Exception as e:
          pass
    return result 
  def func2(url_list):
      result = []
      for url in url_list:
          try:
              response = requests.get(url)
              result.append(response.text)
          except Exception as e:
              pass
    return result 
  # 这两个函数执行结果是不一样的，是try所处的位置不同导致的
  func1(['http://www.baidu.com','http://www.google.com','http://www.bing.com'])
  func2(['http://www.baidu.com','http://www.google.com','http://www.bing.com'])

3.2 主动触发异常

try:
    int('123')
    raise Exception('XXX')     # 代码中主动抛出异常
except Exception as e:
    print(e)     # XXX

• 示例：

  def func():
      result = True
      try:
          with open('x.log',mode='r',encoding='utf-8') as f:
              data = f.read()
          if 'alex' not in data:
              raise Exception()
      except Exception as e:
          result = False
      return result

3.3 自定义异常

class MyException(Exception):    # 自定义异常，继承Exception
    pass
try:
    raise MyException('asdf')    # 主动触发自定义异常，只有自定义异常自己和Exception能捕获到
except MyException as e:
    print(e)