python面向对象--类与对象

一、类与对象概念

1.面向对象的两个重要概念

1）类：共性事物的抽象，是对某一类具有共性事物的描述，是概念上的定义。

2）对象：是共性事物的一个体现，是这类事物的每个个体，或者说是类的一个实例

   总结：类是对象的模板，对象是类的实例

2.类结构：里面包含属性和函数

3.数据是对象的状态-->成员变量（属性）

  方法是对象的行为-->函数（方法）

二、类的语法

class Math：

a = 4  #属性

b = 5

def add（self）： #方法

    c = self.a + self.b

    return c

注意：

       1）类名首字母大写比如 class User # class是关键字

       2）类里面包含属性与方法

       3）类函数自带self关键字，不能少

      4）如果类函数里面调用属性，方法：self.属性名

案例：

 

#定义类
class Person:

    #定义属性
    height = None
    weight = 50
    age = 28
    money = 2000000

    #内部定义属性值
    def setAge(self,age):
        print("默认的年龄为：",self.age)
        self.age = age  #重新赋值

    #定义方法，self代表Person这个类本身，必须有。self可以调用属性
    def cooking(self,flag):
        if flag is True:
            print("会做饭。。。。")
        else:
            print("不会做饭。。。。")

    def moneying(self):
        print("收入很可观。。。")


#实例化对象：类名()
person_1 = Person()
#改变对象的属性
person_1.setAge(26)
person_1.cooking(False)
print(person_1.age,person_1.money,person_1.height)

 

三、类的初始化

语法：def __ini__(self):

               pass

#定义类
class Person:

    def __init__(self,height,weight,age,money=2000000):
        #定义属性,不需要再外部单独声明
        self.height = height
        self.weight = weight
        self.age = age
        self.money = money

    #定义方法，self代表Person这个类本身，必须有。self可以调用属性
    def cooking(self,flag):
        if flag is True:
            print("会做饭。。。。")
        else:
            print("不会做饭。。。。")

    def moneying(self):
        print("收入很可观。。。")


#实例化对象：类名()
person_1 = Person(178,58,24)
person_1.cooking(False)
print(person_1.age,person_1.money,person_1.height)

四、类的封装

1.实现方式：遵循一定的属性和方法命名规约。不希望这些变量或者方法被外部使用

2.任何以单下划线_开头的名字都应该是内部实现。即不希望通过实例名称.变量名/方法名来调用。但python并不会真的阻止别人访问内部名称，只是一种约定。

3.以双线划线__开头的名字，仅类自己可访问。继承--这种属性通过继承是无法被覆盖的。其实也是可以访问的，只不过换成了__类名__变量名/函数名

4.两种不同的编码约定（单下划线和双下划线）来命名私有属性

   对于大多数而言，非公共名称以单下划线开头，但是，如果清楚代码会涉及到子类，并且有些内部属性应该在子类中隐藏起来，才考虑使用双下划线。

class MyClass:

    def __init__(self):
        #定义私有变量
        self.__private_data = "私有方式一"#子类也可以使用
        self._private_data = "私有方式二" #仅限于自己类内部用

    def _pri_add(self):
        print("私有方式——单下划线")

    #定义私有方法
    def __pri_func(self):
        print("私有方式--双下划线")

    #定义公共类
    def public_func(self):
        print("公共行为")
        #类内部可以访问自己的私有变量、私有方法
        self.__pri_func()

#定义子类，继承MyClass
class On(MyClass):

    def public_jicheng(self):
        print("aaaa")

mc = MyClass()
mc.public_func()
so = On()
so._pri_add()   ---子类可以直接调用

五、类的继承，支持多继承

1）语法：class 子类类名（父类类名）

2）子类拥有父类的所有属性和方法

3）子类可以扩展自己的属性和方法

4）父类的行为不够用，子类要升级和优化，子类可重写父类的方法--多态

5）子类和父类都有的行为：子类实例优先使用自己的，没有再去用父类的

6）继承父类的属性、方法--单继承

class Father:

    def __init__(self,id,name,sex,age):
        self.id = id
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,food):
        print("吃",food)

    def earnmoney(self,money):
        print("挣钱",money)

#继承父类
class Son(Father):

    def dance(self):
        print("跳舞")

huahua = Son(2,"花花","男",23)
huahua.eat("香蕉")

7）多继承--继承的不同父类之间的方法是不一样的。多继承注意继承顺序。

    1*。多继承语法：class 子类类名（父类1，父类2）

    2*。多级承中，如果继承的父类中都有相同的方法，则按照继承的先后顺序进行方法的调用。如下代码中先继承父类，在son调用earnmoney()方法时会调用父类的方法输出“father挣钱 2000”.

class Father:

    def __init__(self,id,name,sex,age):
        self.id = id
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,food):
        print("吃",food)

    def earnmoney(self,money):
        print("father挣钱",money)

class Mother:

    def __init__(self,b):
        self.b = b

    def singing(self,b):
        print("唱歌弹吉他",b)
   
    def earnmoney(self,money): 
        print("mother挣钱",money)

#继承父类
class Son(Father,Mother):

    def eat(self,food):
        print("吃",food,"但我更喜欢吃肉")

    def dance(self):
        print("跳舞")

huahua = Son(2,"花花","男",23)
huahua.eat("香蕉")
huahua.singing("aaa")

      3*。在子类的行为中，想调用父类的行为，然后再做额外扩展，可以使用super类。主要处理多继承当中的问题

             语法：super.行为（参数）

六、方法的重写（多态）

1）重写父类的方法、初始化参数。

  类名.__ini__()或者super.__ini__()

class Father:

    def __init__(self,id,name,sex,age):
        self.id = id
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,food):
        print("吃",food)

    def earnmoney(self,money):
        print("挣钱",money)

class Mother:

    def __init__(self,b):
        self.b = b

    def singing(self,b):
        print("唱歌弹吉他",b)

#继承父类
class Son(Father,Mother):

    def __init__(self,cls,id,name,sex,age,b):
        Father.__init__(self,id,name,sex,age)
        Mother.__init__(self,b)
        self.cls = cls
    def eat(self,food):
        print("吃",food,"但我更喜欢吃肉")

    def dance(self):
        print("跳舞")

huahua = Son("2班",2,"男","花花",23,"bbbb")
huahua.eat("香蕉")

七、实例

编写一个类：实现对文件的读、写、追加操作。要求有初始化函数。
实例化这个类，对你本地的某一个文件进行读、写、追加操作。
ps：与第三方资源交互，添加异常处理。  ---注意文件的存在与否的判断

import os
class FileOperate:

    #初始化
    def __init__(self,filePath):
        file_dir = os.path.dirname(filePath)
        #如果文件目录不存在，则创建它。也可以不创建，直接抛出异常都okay.
        if not os.path.exists(file_dir):
            os.makedirs(file_dir)
        self.file_path = filePath

    #读数据 - 从文件中读取
    def read_all(self):
        #如果文件存在则读取数据
        if os.path.exists(self.file_path) and os.path.isfile(self.file_path):
            with open(self.file_path,encoding="utf-8") as fs:
                return fs.read()
        else:
            print("！！！文件不存在，无法读取数据。请确保文件存在的情况下再读取！！")

    #写数据或者追加 - 直接覆盖
    def write_data(self,content):
        # 写数据时文件可以不存在。在初始化中已确保路径是存在的。
        with open(self.file_path,"w",encoding="utf-8") as fs:
            fs.write(content)

    #追加数据 - 在原来的基础上
    def add_data(self,content):
        #追加数据时文件可以不存在。在初始化中已确保路径是存在的。
        with open(self.file_path,"a",encoding="utf-8") as fs:
            fs.write(content)




fo = FileOperate("D:\类和对象\file_operate.txt")
print(fo.read_all())
fo.write_data("我写入数据啦---第一行数据--仅作测试
")
fo.add_data("我是追加的数据哟哟哟！！
")