python面向对象--学习笔记

异常处理

1，捕捉异常可以使用try/except语句用来检测try语句块中的错误，except语句捕获异常信息并处理

try:
<语句> #运行别的代码
except<名字>:
<语句> #如果在try部分引发了‘name’异常
except<名字>,<数据>:
<语句> #如果引发了‘name’遗传给你，获得附加的数据
else:
<语句> #如果没有发生异常

2,触发异常
可以使用raise语句来触发异常
语法：raise[Exception[,args[,traceback]]]
语句Exception是异常的类型，例如NameError是参数标准异常中任一种，args是自己提供的异常参数。最后一个参数是可选的，但在实践种很少使用。如果存在就是跟踪异常对象。

try:
    a = int(input("请输入数字:"))
    print(a)
except Exception as E:
    print("输入的数字有0或者其它非数字字符",E)
else:
    print("没有异常我就会执行")
finally:
    print("不管有没有异常我都会执行")

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except:
        # 如果在读取文件的过程中，产生了异常，那么就会捕获到
        # 比如 按下了 ctrl+c
        print('意外终止了读取数据')
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块能定义函数，类和变量，模块里也能包含可执行的代码

导入模块的方式

import 模块名
from 模块名 import 功能名
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名

# 第一种直接导入
import moudle1
print(moudle1.a)
moudle1.f()

# 第二种导入
from  moudle1 import a
print(a)

# 第三种导入
from moudle1 import *
# 当moudle1限制了模块的调用时，就不能使用moudle1里面定义的其它内容
# f()
print(a)

#第四种导入
from moudle1 import a as n
print(n)

# 引用模块之间的导入第五种导入
import  moudle1 as n

all

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素。

# 只针对from a import * 等格式的模块有效
__all__ = ['a']
a = 100
def f():
    print("第一个模块")

from moudle1 import *
# 当moudle1限制了模块的调用时，就不能使用moudle1里面定义的其它内容
# f()
print(a)

面向对象基础

1，定义:在大多数编程中我们都是根据操作数据的函数或语句块来设计程序的。该方法称为面向过程编程。而把数据和功能结合起来，用称为对象的东西包裹起来并组织程序的方法则称为面向对象的编程理念。
2,类和对象是面向对象编程的两个主要方面。类是指创建一个新类型，而对象则是这个类的实例
3，对象可以使用普通的属于对象的变量存储数据。而上属于一个对象或类的变量则被称为域。对象也可以使用属于类的函数时所具有的一些功能。这样的函数被称为类的方法
4，域和方法可以合称为类的属性。域有两种类型——属于每个实例/类的对象或属于类本身。他们分别被称为实例变量和类变量。类使用class关键字创建。类的域和方法是被列在一个缩进块中的

类和对象

类的定义：
类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物.
特征即是属性
行为即是方法
语法：
class 类名():
代码
1，使用class语句来创建一个新类的方法是：class之后为类的名称并以冒号结尾。
语法：
class 类名：
class_suite 类体
例:

class me:
    pass
p=me()
print(p)
#结果为：<__main__.me object at 0x0000023E54601C30>

2，self
类的方法与普通的函数只有一个**显著的区别——类的方法必须具有一个额外的第一个参数名称，但是在调用这个方法的时候并不为这个参数赋值，而python会提供这个值。**这个特别的变量指对象本身，按照惯例，其名称为self
②为何不需要给self赋值，举例：
假如有一个类称为MyClass和这个类的一个实例MyObject。当调用这个对象的方法MyObjectmethod(arg1,arg2)的时候，python会自动转换为MyClass.method(MyObject,arg1,arg2)。这就是self的原理。也正因如此，一个方法不需要参数时，仍然给该方法定义一个self参数
3，对象的方法
可以通过类名来调用类中的方法

class Person:
    def My(self):
        print("hello")
p=Person()
p.My()

4，__init__方法
__init__方法在类的一个对象被创建时，就会马上运行（相当于java中的构造函数），这个方法可以用来对对象做一些初始化。
注意这个名称开始和结尾都是双下划线

class Why:
    def __init__(self,name):
        self.name=name
        print("我最先执行")
    def sayHello(self):
        print("hello,my name is"+self.name)
p=Why('yfq')
p.sayHello()
#结果我最先执行
#hello,my name isyfq

5,实例属性和类属性
给实例绑定属性的方法是通过实例变量，或者通过self变量来实现的。
①实例属性是在方法中定义的变量
②类属性就是直接在类中直接给某个变量赋值
③在类和方法中定义变量时不要使用相同的名字，不然方法中的变量会屏蔽掉类中变量

class House(object):
    def __init__(self,address,name,totalArea):
        self.address = address
        self.name = name
        self.freeArea= totalArea
        self.funitures = []
        self.totalMoney = 0
    def addFuniture(self,ob):
        self.freeArea = self.freeArea-ob.area
        if self.freeArea>=20:
            self.funitures.append(ob.name)
            self.totalMoney+=ob.money
    def __str__(self):
        if len(self.funitures)>=1:
            return f'家住{self.address}旁边的{self.name}装了{self.funitures},剩余面积{self.freeArea}面积'
        else:
            return f'家住{self.address}旁边的{self.name},剩余面积{self.freeArea}面积'


class Funitures(object):
    def __init__(self,name,area,money):
        self.name = name
        self.area = area
        self.money = money
if __name__ == '__main__':
    house = House('白宫','白头哥大院',2000)
    print(house.__str__())
    bed = Funitures('床',15,20000)
    house.addFuniture(bed)
    print(house)

    sofa = Funitures('沙发',8,200000)
    house.addFuniture(sofa)
    print(house)

面向对象-继承

面向对象中的继承: 指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法.
面向对象中继承的作用: 提高代码的复用率, 减少重复代码的书写.该特点区别在于类中调用普通函数时并不需要带上self参数地特征

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类.
这样的好处也一目了然, 子类B拥有和子类A完全一样的功能, 但是却不用再写大量重复的代码.

单继承

class c3(object):
    def __init__(self,name,salary,title,course):
        self.name = name
        self.money = salary
        self.title =title
        self.course = course
    def __str__(self):
        # 使用时必须有返回值，返回的是对象所需要的属性
        return f'{self.name},{self.money},{self.title},P{self.course}'
    def ceshi(self):
        print(f"名字叫{self.name}的人，喜欢{self.title},每个月的薪水为{self.money}")
class c5(c3):
    def ceshi(self):
        print("我是子类的方法")
    # print(super(c3, self)).ceshi()
    print(super.__init__())

多继承

class Dog(object):
    def __init__(self):
        self.color = '白色'
        self.skill = '会叫'

    def bark(self):
        print("狗会叫")

    def skill2(self):
        print("狗会跳")
class God(object):
    def skill2(self):
        print("会飞")
#子类继承多个父类
class XTQ(God,Dog):
    def run(self):
        print("狗最喜欢到处跑")

子类重写父类同名方法和属性

class animal(object):
    def __init__(self):
        self.name = "小飞熊"
    def run(self):
        print("我会跑")
class dog(animal):
    def __init__(self):
        self.name = "狗蛋"
    def fei(self):
        animal.run(self)
        print("我会飞呀")
    def run(self):
        print('会飞')

子类调用父类的同名方法和属性

class animal(object):
    def __init__(self):
        self.name = "小飞熊"
    def run(self):
        print("我会跑")
class dog(animal):
    def __init__(self):
        self.name = "狗蛋"
    def fei(self):
        animal.run(self)
        print("我会飞呀")
    def run(self):
        # 直接使用父类的名字调用初始化方法和父类中的方法
        animal.__init__(self)
        animal.run(self)
        print(self.name)

super()调用父类方法

class dog(animal):
    def __init__(self):
        self.name = "狗蛋"
    def fei(self):
        animal.run(self)
        print("我会飞呀")
    def huirun(self):
        # 直接使用父类的名字调用初始化方法和父类中的方法
        animal.__init__(self)
        animal.run(self)
        print(self.name)
class tugou(dog):
    def __init__(self):
        self.name = "土狗"
    print("土狗的一切")
    def diaoyong(self):
        # 调用爸爸的方法和属性
        print(self.name)
        super().fei()
        super(dog,self).run()

获取和修改私有属性值

class privateChange():
    def __init__(self):
        self.__name="王"
    def getName(self):
        print(self.__name)
    def setName(self,newName):
        self.__name = newName

面向对象-多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
实现步骤：
定义父类，并提供公共方法
定义子类，并重写父类方法
传递子类对象给调用者，可以看到不同子类执行效果不同

class Animal(object):
    def run(self):
        print("会喵喵叫")
class dog(Animal):
    def run(self):
        print("会跑")

def duotai(ob):
    ob.run()

if __name__ == '__main__':
    d = dog()
    a = Animal()

    duotai(d)
    duotai(a)

类属性和实例属性

1，类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
类属性可以使用 类对象 或 实例对象 访问。
类属性的优点

记录的某项数据 始终保持一致时，则定义类属性。
实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有 ，仅占用一份内存，更加节省内存空间。
2，修改类属性
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。
3，实例属性

class Dog(object):
    def __init__(self):
        self.age = 5

    def info_print(self):
        print(self.age)


wangcai = Dog()
print(wangcai.age)  # 5
# print(Dog.age)  # 报错：实例属性不能通过类访问
wangcai.info_print()  # 5

类方法和静态方法

class methods(object):
    age = 18
    @classmethod
    def change(cls):
        age = 23
        print(age)
    def chan(self):
        self.age = 26
        print(self.age)
    @staticmethod
    def quiet():
        print("这是一个安静的方法，不需要被打扰")
if __name__ == '__main__':
    print(methods.age)
    print(id(methods.age))
    methods.change()
    # 类名不能调用实例方法
    # methods.chan()
    a = methods()
    # 实例化一个对象后就可以调用实例方法了
    a.chan()
    print(id(a.age))

    # 一个类中可以定义多个装饰器，一个装饰器只能被使用一次，名字相同也会被默认为参数
    a.quiet()
    methods.quiet()

总结：

# 1- 定义一个类，里面包含以下属性和方法
# 	私有类属性
# 	类属性
# 	初始化方法
# 	私有实例属性
# 	实例属性
# 	实例方法
# 	静态方法
# 	类方法

class classdemo():
    __property = "私有类属性"
    property = "类属性"
    def __init__(self):
        self.name = 'me'
        print("初始化方法")
    def fun(self):
        __pro="私有的实例属性"
        property2 = "实例属性"
        print(property2,__pro)
    @staticmethod
    def func():
        print("静态方法，我懒得动")
    @classmethod
    def f1(cls):
        print("类方法")


# 2- 用类和对象调用以上的属性和方法，总结哪些可以调用，哪些不能调用
print(classdemo.property,"可以调用")
# classdemo.__property 不能调用
# classdemo.__pro 不能调用私有属性
# classdemo.property2  不能调用方法中的属性
# classdemo.name 不能调用实例属性
print("可以调用",end='\t')
classdemo.__init__(classdemo)
print("可以调用类方法fun",end='\t')
classdemo.fun(classdemo)
print("可以调用静态方法func",end='\t')
classdemo.func()
print("可以调用类方法f1",end='\t')
classdemo.f1()


#类名调用总结：类名不能掉用实例方法中的属性和私有属性，也不能实例对象添加的属性，不能调用私有类属性，
#可以调用类属性,类方法，静态方法，初始化方法，实例属性

c = classdemo()
print("实例对象可以调用属性property",end='\t')
print(c.property)
# c.__property不能调用
c.fun()
c.f1()
c.func()
print(c.name)


dict1={'name':'me','value':2}
print(dict1.items())

# 实例对象调用总结：实例对象不能调用实例方法中的属性和私有属性，私有类属性
#可以调用类属性,类方法，静态方法，初始化方法，当前对象添加的实例属性
print(dict1)
print(dict1.keys())
print(dict1.values())


tu = tuple(dict1)
print(tu)