python的类和异常捕获

python基础的终结

面向对象
面向对象知识补充
类的基本属性
类的应用
异常捕获

面向对象

基本概念

对象：

　　是可以存放数据和功能的容器，也是数据和功能的函数

类：

　　多个对象相同数据与功能的结合体，类的产生是为了减少代码冗余核心还在于对象

eg：
    对象1：
        gender='male'
        hobby='basketball'
        name ='jj'
    对象2：
        gender='male'
        hobby='basketball'
        name ='bb'
    对象3：
        gender='male'
        hobby='basketball'
        name ='kk'


# 代入类：
   对象1：
        name ='jj'
   对象2：
        name ='bb'
   对象3：
        name ='kk'
   类：
        gender='male'
        hobby='basketball'

**在程序中需要先定义类之后才能产生对象**

语法：
# class 定义类关键字
# 类名称为英语，首字母推荐大写
class 类名称：
    # 缩进
    # 对象的相同功能或数据
    数据
    def 函数名（self）：
　　　　　　pass
'''
在类中定义的数据和方法统称为属性
在类中定义的函数被称为：方法
'''

面对对象编程

eg：
class Student:
    # 相同的数据
    school = '北京大学'
    # 相同的功能
    def choose_course(self):
        pass

# 定义对象
# 每次定义都是一个新的对象
per1 = Student() 
print(id(per1))
per1 = Student()
print(id(per1))

per1 = Student() 
print(per1))
per1 = Student()
print(per1))

访问数据和功能

# 衔接上述代码
per2 = Student()
per3 = Student()

# 查看内部所有的属性和方法
print(Student.__dict__)
print(per1.__dict__)

# 调用属性和方法（句号）
print(per2.school)
print(per3.choose_course())
print(per2.choose_course())

1.形参self到底是谁

　　新参self用于指代使用该类的每一个对象

2.为什么对象调用类的时候，形参self不需要传值

　　对象在调用类里面定义的方法的时候，程序会自动将对象传入self位置

对象的独有数据

class Student:
    # 相同的数据
    school = '北京大学'
    def __init__(self,name,age,hobby):
        self.name = name
        self.age = age
        self.hobby = hobby
    # 相同的功能
    def choose_course(self):
        print('体育')

# 定义对象，给对象赋予独特属性
per1 = Student('jj',12,'girl')
per2 = Student('hh',23,'girls')
per3 = Student('oo',70,'porn')

# 调用属性和方法（句号）
print(per1.age)
print(per3.name)
print(per2.hobby)

面向对象知识补充：

父类

　　多个类相同的数据和功能的结合体

继承：

　　类可以拥有其父类的所有功能

# python与其他语言不同的一点，一个类可以有多个父类，

对象查找顺序：

　　先从自身开始找，再去产生对象对应的类里面找，再去父类找(就近原则)

1.自身找

eg：
# 父类
class Dad:
    age = 111

# 子类
class Son(Dad):
　　age = 23
　　def __init__(self,age):
　　　　self.age = age
# 对象
per1 = Son(12)

print(per1.age)
'''
输出为12
'''

2.对象对应的类

eg：
# 父类
class Dad:
   age = 111

# 子类
class Son(Dad):
    age = 23

# 对象
per1 = Son()
print(per1.age)
'''
输出为23
'''

3.在父类找

# 父类
class Dad:
    age = 111

# 子类
class Son(Dad):
    pass

# 对象
per1 = Son()
print(per1.age)
'''
输出为111
'''

类的封装

封装：用于提高程序的安全性

使用方法：在类内部的属性前加上“--”,表示类只能在内部使用，只有特殊应用可以使用

class car:
    def __init__(self,brand,chang):
        self.__chang=chang
        self.brand=brand
    def start(self):
        print(self.brand,self.__chang)

new=car('大众',3)
new.start()
print(new.brand)
print(new.__chang)

可以看见“__chang"无法在外部应用。

# 如果要成功输出3，需要执行改操作
print(new._car__chang)

类中str的运用

class car:
    def __init__(self,brand,chang):
        self.__chang=chang
        self.brand=brand
    def stu(self):
        return '我是啊{0},这是{1}'.format(self.brand,self.__chang)

new=car("学生",3)
print(new)

输出为存储的地址

class car:
    def __init__(self,brand,chang):
        self.__chang=chang
        self.brand=brand
# 将之前的进行替换
    def __str__(self):
        return '我是啊{0},这是{1}'.format(self.brand,self.__chang)

new=car("学生",3)
print(new)

类的一些基本性质

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
x=C('JACK',23)

dict

# 对象的属性字典
print(x.__dict__)

class

# 输出对象所属的类
print(x.__class__)

bases

# 输出C类的父类型的元素
print(C.__bases__)

mro

# 输出C类的层次结构
print(C.__mro__)

subclasses()

# A的子类列表
print(A.__subclasses__())

类的应用

add():

class car:
    def __init__(self,chang):
        self.__chang=chang
    # 创建方法将对象内容相加
    def __add__(self,A):
        return self.__chang+A.__chang

new=car("学生")
one=car("车子")
# 进行相加
s=new+one
print(s)

len():

class car:
    def __init__(self,name):
        self.name=name
    # 创建
    def __len__(self):
        return len(self.name)
new=car("学生")
s=new.__len__()
print(s)

new():

class Person(object):
    # 创建新对象
    def __new__(cls, *args, **kwargs):
        print("new：{0}".format(id(cls)))
        obj=super().__new__(cls)
        print('创建对象：{0}'.format(id(obj)))
        return obj
    # 调用对象
    def __init__(self,name,age):
        print("init的对象为%d"%id(self))
        self.name=name
        self.age=age
# 输出对象的存储位置
print("object:%d"%id(object))
print("Person:%d"%id(Person))
# 实行创建
pl=Person("张三",20)
print('pl这个Person：%d'%id(pl))

异常捕获

异常的分类

　　1.语法错误

　　　　不被允许的不应该出现，后果很严重，老板发现可能让你直接提桶跑路

　　2.逻辑错误

　　　　可以允许发生的(bug)

语法：
try：
    被检测的代码
except 错误类型 as 变量名:
        分支代码(变量名指代的就是错误的具体信息)
'''
万能错误类型Exception/BaseException
'''

　　万能错误类型Exception/BaseException

eg:
class Son():
    age = 23
    def __init__(self,age):
        self.age = age

try:
    per1 = Son()
except Exception as f:
    print('有错误')
'''
输出 有错误
'''

异常捕获的使用建议

异常捕获在程序中尽量少用
try检测的代码尽量少

其它关键字

else

　　在try被检测的代码没有异常的情况后执行

eg:
class Son():
    age = 23

try:
    per1 = Son()
except Exception as f:
    print('有错误')
else:
        print('没错')
'''
输出 没错
'''

finally

　　始终回执行不管有没有异常

class Son():
    age = 23
    def __init__(self,age):
        self.age = age

try:
    per1 = Son()
except Exception as f:
    print('有错误')
finally:
    print('执行')
'''
输出：
有错误
执行
'''

返回目录

posted @ 2021-08-31 16:35 微纯册阅读(80) 评论(0) 编辑收藏举报

刷新页面返回顶部