python学习笔记(七) 异常处理、面向对象、私有、继承、多继承

1.异常处理

#1.捕获指定异常（当你知道哪行代码会出现什么异常的时候可以这么写） 1

try:
    1/0
except ZeroDivisionError as e:
    print('异常内容：\n',e)
测试结果：

　　异常内容：
 division by zero

import traceback
# 2.捕获所有异常（当你不知道具体异常名称的时候可以这个写）
try:
    1/0
except Exception:
    print('异常内容：\n',traceback.format_exc())

测试结果：

# 3.捕获多个指定异常，写多个except即可
try:
    None.replace('w','*')#当该行代码出异常后，异常将被捕获，下面代码不会被执行
    n = 1/0#如果改行代码之前没有出异常，而代码运行到这的时候出异常了，那么except将会捕获该异常信息
except AttributeError as e:
    print(e)
except ZeroDivisionError as e:
    print(e)

测试结果：
'NoneType' object has no attribute 'replace

# 4.try里面再加try

try:
    ''.replace('w','r')
    try:
        1/0
    except ZeroDivisionError as e:
        print(e)
except AttributeError as e:
    print(e)

测试结果：
division by zero

# 5.try..except..else...
try:
    None.replace('w','r')
except AttributeError as e:
    print(e)
else:
    1/0 #如果try里头的代码没有出异常，最后将会执行这里

测试结果：
'NoneType' object has no attribute 'replace'

# 6.finally
try:
    ''.replace('w','r')
except AttributeError as e:
    print(e)
else:
    1/0 #如果try里头的代码没有出异常，最后将会执行这里
finally:
    print('真爱O(∩_∩)O哈哈~')#不管上面代码有没有出异常，这里都会执行（比如关闭文件，关闭数据库连接等可以在这里写）

测试结果：

2.面向对象

'''
类：
        一个模型，一个种类，一个蓝图。
    对象：
        根据模型造出来的东西。
    实例：
        就是对象。
    实例化：
        根据模型造实例的过程。

    类变量
        直接在类里面定义的变量，不需要实例化就可以使用，self.xxx
    实例变量
        如果变量前面加了self的话，在这个类里面，其他的函数都可以使用这个变量。
        必须得实例化之后才可以用。
    self
        本类对象。
    实例方法
        函数入参有self的，就是实例方法，必须实例化之后才可以使用。

    类方法
        @classmethod
        def shuoming(cls):
            cls代表的就是当前这个类
            pass
        1、不需要实例化就可以调用的，直接类名.xxx，
        self.shuoming()
        2、它调用不了实例方法和实例变量。

    静态方法
        只是写在类里面而已，它调用不了类方法、类变量、实例方法、实例变量，通过类名.XX使用
        类方法、实例方法可以调用它
            self.act()
            cls.act()
    属性方法
        看起来像变量的一个方法。

'''

class BuyCar:#类
    def shop(self):
        print('买车')

xiaowang = BuyCar()#BuyCar()实例化，xiaowang就是对象、实例
xiaowang.shop()

测试结果：
买车

class Person:

    clothes = 'dress'#类变量
    def __init__(self,name,sex='女'):#构造函数，对象实例化的时候执行 self:本类对象
        self.sex = sex#实例属性，带self的都必须实例化后带能使用
        self.name = name
        print('【__init__】我的名字叫[%s],我是一个[%s]孩子' % (self.name,self.sex))#内部使用

    def __del__(self):#析构方法，对象销毁的时候执行
        print('【__del__】明天见，[%s]！' % self.name )

    def eat(self):#实例化方法，带self的方法都叫实例方法，必须实例化后才可以使用
        print('【eat】[%s]说：我饿了，我想吃大馒头！' % self.name)

    def wear(self):#实例化方法调用类变量
        print('【wear】[%s]她是一位爱穿[%s]的[%s]孩子' % (self.name,self.clothes,self.sex))

    @classmethod #类方法
    def food_Clothing(cls):#类方法不可以直接调用实例方法和实例属性,但可以通过这种方法实例化后再调用
        print('【food_Clothing】她是一位爱穿[%s]的孩子' % (cls.clothes))
        cls.life()#类方法调用静态方法
    @staticmethod #静态方法
    def life():#静态方法不能调用别人，但是别人可以调用他（类方法，类变量，实例方法，实例变量等都不可以调用
        print('【life】固定财产：北京二环内6套房、带北京车牌的车10辆')
    def run(self):#实例方法调用静态方法
        print('【run】别跑了！我来告诉你,')
        self.life()#实例方法调用静态方法
    @property #属性方法
    def text(self):
        return '1234567890'

p = Person('wangxiaoyu')#实例化，p是实例、对象
p.eat()
p.wear()#调用实例方法
print(p.sex)#调用实例属性

测试结果：
【__init__】我的名字叫[wangxiaoyu],我是一个[女]孩子
【eat】[wangxiaoyu]说：我饿了，我想吃大馒头！
【wear】[wangxiaoyu]她是一位爱穿[dress]的[女]孩子
女
【__del__】明天见，[wangxiaoyu]！



Person.food_Clothing()#类方法直接调用
测试结果：
【food_Clothing】她是一位爱穿[dress]的孩子
【life】固定财产：北京二环内6套房、带北京车牌的车10辆


Person.life()#静态方法调用
测试结果:
【life】固定财产：北京二环内6套房、带北京车牌的车10辆

p = Person('lixiaokai')#调用静态方法的实例方法
p.run()

测试结果：
【__init__】我的名字叫[lixiaokai],我是一个[女]孩子
【run】别跑了！我来告诉你,
【life】固定财产：北京二环内6套房、带北京车牌的车10辆
【__del__】明天见，[lixiaokai]！

属性方法调用
p = Person('wangxiaoyu')
print(p.text)

测试结果：
【__init__】我的名字叫[wangxiaoyu],我是一个[女]孩子
1234567890
【__del__】明天见，[wangxiaoyu]！

3.私有（私有方法、私有变量）

class Person:

    def __init__(self,name):
        self.__love = '比心'#私有变量，只能再类里面调用
        self.name = name

    def __say_love(self):#私有方法
        print('l love you , %s' % self.__love)#私有变量调用

    def life(self):
        self.__say_love()#私有方法调用

p = Person('wangxiaoyu')
p.life()

测试结果：
l love you , 比心

4.继承

class Father:#父类

    def __init__(self,name):
        self.money = 500
        self.name = name

    def property(self):
        print('父亲对【%s】说：我给你 【%s】 万美元' % (self.name,self.money))

class Son(Father):#子类 子类继承父类（包含方法和变量）
    pass

son = Son('erzi')
print('儿子继承了父亲%s万美元' % son.money)#子类继承父类变量
son.property()

测试结果：
儿子继承了父亲500万美元
父亲对【erzi】说：我给你 【500】 万美元

class Son(Father):

    def __init__(self,name,sex):#方法重写
        super().__init__(name)#执行父类中的init方法，如子类中定义的属性有一部分或完全与父类中的属性相同，通过该方式调用节省代码
        super().property()#执行父类中的property方法
        self.sex = sex

    def property(self):#方法重写
        print('我叫【%s】,我是个【%s】孩子，父亲给了我【%s】万美元' % (self.name,self.sex,self.money))

son = Son('xilizi','男')
son.property()

测试结果：
父亲对【xilizi】说：我给你 【500】 万美元
我叫【xilizi】,我是个【男】孩子，父亲给了我【500】万美元

import pymysql
import redis

class BaseDB:#基类

    def __init__(self,host,password,db,port):
        self.host = host
        self.password = password
        self.db = db
        self.port = port

#继承，数据库链接的例子
class MySql(BaseDB):#连接mysql类

    def __init__(self,host,password,db,username,port): #方法重写
        super().__init__(host,password,db,port)
        self.username = username

    def conn(self):
        conn = pymysql.connect(host=self.host, port=self.port, user=self.username, password=self.password, db=self.db, charset='utf8', autocommit=True)
        return conn

class Redis(BaseDB):#连接redis类

    def conn(self):
        conn = redis.Redis(host=self.host, password=self.password, db=self.db, decode_responses=True)
        return conn


class Oracle(BaseDB):#连接数据库类
    pass

5.多继承

# 多继承
class Father:#父类1

    def __init__(self):
        self.money = 500
        print('父亲有%s万'% self.money)

    # def property(self):
    #     print('父亲说：我给你 【%s】 万美元' % self.money)

class Mother:#父类2

    def __init__(self):
        self.money = 5000
        print('母亲有%s万' % self.money)

    def property(self):
        print('母亲说：我给你 【%s】 万美元' % self.money)

class Son(Father,Mother):#多继承之间的关系，在python3中先在子类中找，子类没有再在父类中找，如第一个父类没找到再到第二个父类，以此类推
    def __init__(self):
        print('儿子现在没有钱')
        super().__init__()

son = Son()
son.property()

测试结果：
儿子现在小还没有钱
父亲有500万
母亲说：我给你 【500】 万美元

 

转载于:https://www.cnblogs.com/xyxts/p/11156154.html