黑马python基础班---day07

梦里梦外; 2023-02-27 15:52 3阅读 0赞

# 1:类属性：在类里面和方法外面定义的属性称为类属性，类属性属于当前类。
    # 实例属性：（对象属性）:在init方法里面定义的属性称为实例对象，实例属性属于某个对象。
    class Person(object):
        """定义类属性和实例属性"""
        # 类属性
        __country = "中国"
        skin_color = "yellow"
    
        def __init__(self, name, age):
            # 实例属性
            self.name = name
            self.age = age
    
    
    p = Person("王昭君", 20)
    # 访问实例属性
    print(p.name)
    # 修改实例属性
    p.name = "李四"
    
    Person.name = "王五"
    # 查看类中的所有类属性和方法
    print(Person.__dict__)
    #{'__module__': '__main__', '__doc__': '定义类属性和实例属性', '_Person__country': '中国', 'skin_color': 'yellow', '__init__': <function Person.__init__ at 0x00BCE738>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, 'name': '王五'}
    
    
    # 查看类中的实例属性和方法
    print(p.__dict__)
    #{'name': '李四', 'age': 20}
    
    # 对象可以访问类属性，但是不能够修改类属性
    p = Person("李四", 20)
    print(p.skin_color)
    
    # 如果对象想要修改类属性怎么做？？？
    # 定义类方法，进行调用
    
    
    # 2:多肽：，调用相同的方法，出现的不同的表现形式。
    # 场景：不同的对象，想要完成相同的操作。
    
    def fly(obj):
        obj.fly()
    
    class Duck(object):
        def fly(self):
            print("鸭子飞.......")
    
    duck = Duck()
    fly(duck)
    
    class Swan(object):
        def fly(self):
            print("天鹅飞......")
    
    swan = Swan()
    fly(swan)
    
    # 3:方法的种类：
    # 实例方法：方法第一个参数是self
    # 类方法：方法第一个参数是cls  ,方法上有@classmethod关键字
    # 静态方法：无self和cls关键字 ，方法上用@staticmethod关键字
    
    
    #实例方法使用的场景：对私有实例属性的操作可以通过实例方法来完成
    class Tercher(object):
        def __init__(self, name, age):
            self.name = name
            self.__age = age
    
        def get_age(self):
            return self.__age
    
    # 实例方法可以通过实例，也可以通过类来完成。
    t1 = Tercher("王老师", 30)
    age = t1.get_age()
    print(age)
    
    age = Tercher.get_age(t1)
    print(age)
    
    
    # 类方法：
    class Teacher2(object):
    
        __country = "韩国"
    
        @classmethod
        def get_country(cls):
            print("当前的类是：", cls)
            #对于私有类属性的操作可以使用类方法
            return cls.__country
    
    
    country = Teacher2.get_country()
    print(country)
    
    # 类方法也可以使用对象来调用，但不推荐，因为不方便，还要创建一个对象
    t2 = Teacher2()
    country = t2.get_country()
    print(country)
    
    
    # 静态方法：
    class Tercher3(object):
        def __init__(self, name, age):
            self.name = name
            self.__age = age
    
        def get_age(self):
            return self.__age
    
        @staticmethod
        def sum(num1, num2):
            return num1 + num2
    
    # 静态方法：实例和类均可以调用，但是推荐使用类，因为简单。
    result = Tercher3.sum(1, 2)
    print(result)

异常捕获机制：

# 1：异常捕获机制
    # 格式：
    
    # try:
    #     运行代码
    # except:
    #     捕获的异常
    
    # 案例1：数组下标越界
    try:
        my_lsit = [1, 3, 5]
        my_lsit[10]
    except IndexError as e:
        print("异常信息为：", e)
    
    # 运行结果：
    # 异常信息为： list index out of range
    
    
    # 案例2：键错误
    try:
        my_dict = {
        "name": "李四", "age": 23}
        sex = my_dict["sex"]
    except KeyError as e:
        print("异常信息为：", e, type(e))
    # 输出结果是：
    # 异常信息为： 'sex' <class 'KeyError'>
    
    # 注意：异常信息一般指定Exception即可，因为大多数的异常类继承这个类。
    # 扩展：如果想要捕获任何的异常信息，则可以指定BaseException(异常类的根类)
    
    # 2：捕获异常的完整语句：
    # try:
    #     可能出现异常的语句
    # except Exception as e:
    #     代码出现的异常
    # else:
    #     代码执行时无异常则执行的语句
    # finally:
    #     必须执行的代码
    #
    
    # 3:异常的传递：
    # 当执行代码是如果遇到了错误，异常会从代码内部往外一层层的进行传递
    # 如果遇到最外层也没有捕获，那么程序崩溃。
    
    # 4：自定义异常：
    # 注：自定义异常必须继承BaseException  或 Exception
    
    class MyException(Exception):
        def __init__(self, error_msg):
            self.error_msg = error_msg
    
        def __str__(self):
            return self.error_msg
    
    
    passworld = input("请输入您的密码：")
    
    try:
        if len(passworld) < 6:
            raise MyException("密码不够6位！！！")
        
    except Exception as e:
        print("出现异常了：", e, type(e))