day15类与对象总结

day15类与对象总结

1.review

1.1数据持久化 - 将数据以文件的形式保存到硬盘中

# 2.文件操作    -   操作文件内容
# 打开文件  ->  操作文件    ->  关闭文件

"""
open(文件路径，打开方式，encoding=文件编码操作)

1)文件路径  -   绝对路径、相当路径
2）打开方式：r，w，a；b（二进制文件只能用b打开）、t

3）文件编码方式：utf-8、gbk
注意：以b的方式打开文件，encoding不能赋值


文件操作：文件对象.read()、文件对象.readline()、文件对象.readlines()
文件写操作：文件对象.write(数据)

关闭文件：文件对象.close()

with open(文件路径，打开方式，encoding=文件编码操作) as 文件对象：
    代码块

"""

2. 编程思想

# 根据面对问题不同人呈现出来的思维模式不同，可以将编程思维分为三种：
# 1.面向过程编程（穷人思想）    -   遇到问题马上想到是解决这个问题
# 2. 函数式编程(小资思想)    -   遇到问题马上想到有没有一个已经存在的函数可以解决这个问题，如果没有就造一个 （一个函数只具备一个功能） - 函数
# 3. 面向对象编程(富豪思想)   -   遇到问题马上想到有没有一个具有这个功能的对象，如果没有就造对象（一个对象可以同时具有多个功能）- 类和对象

3.classAndObject

3.1什么是类？什么是对象？

"""
类就是拥有相同功能或者相同属性的对象的集合。(类是抽象的概念)
对象就是类的实例。(对象是类具体的表现)

如果人是类，余婷是对象，骆昊是另一个对象
车是类，骆老师家的车就是对象

"""

3.2 定义类 - 创建类

"""
定义类：用代码来描述你的这个类是拥有哪些相同功能（用函数）和相同属性（用变量）的对象的集合
2)语法：
class 类名：
    类的说明文档
    类的内容（包含方法和属性）
    

3）说明：
a. class       -       关键字；固定写法
b. 类名         -       由程序员自己命名
                        两个要求：是标识符；不是关键字
                       规范：见名知义；不使用系统的函数名、类名和模块名; 猜用驼峰式命名(大驼峰)
c. 类的说明文档  -       本质就是一个多行注释
d. 类的内容     -       包含定义在类中的函数(方法)和定义在类中的变量(属性)
                       方法包括：对象方法、类方法、静态方法
                       属性包括：类属性、对象属性
"""

# user_name    -  PEP8
# userName  -   小驼峰
# UserName  -   大驼峰

3.3 创建对象

"""
对象是通过创建类来创建的。

语法：
类名()

"""

4.Method

4.1 什么是方法

# 定义在类中函数就是方法

4.2 不同方法的使用

"""
1)对象方法
a.怎么定义:直接定义在类中的函数就是对象方法
b.怎么调用:以'对象. xxx()'的形式来调用
c.特点:自带参数self,调用函数的时候seLf不需要传参，系统自动将当前对象传给self (谁调用seLf指向谁)

2)类方法
a.怎么定义:定义函数前添加装饰器@classmethod
b.怎么调用:以'类名. xxx()'的形式来调用
c.特点:自带参数cLs, 调用函数的时候cLs不需要传参，系统会自动将当前类传给cLs

3)静态方法
a.怎么定义:定义函数前添加装饰器@staticmethod
b.怎么调用:以'类名. xxx()'的形式来调用
c.特点:没有特点

"""

class A:
    # func1是对象方法
    def fuc1(self):
        print('对象方法')

    @classmethod
    def fuc3(cls):
        print('类方法')

    @staticmethod
    def fuc4():
        print('静态方法')

5.initMethod

5.1 魔法方法

"""
魔法方法的特点：
a.函数名以__开头，并且以__结尾
b.魔法方法不需要程序员自己调用，系统会在特定情况下自动调用

2)两个常见的魔法方法
a.__init__：
在在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它
创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

b.__repr__
如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回值作为打印结果打印
在类中添加__repr__方法的时候，这个方法的返回值必须是字符串。
"""

class A:
    def __init__(self):
        print('init方法被调用')

a1 = A()
a2 = A()

class B:
    def __init__(self,m,n):
        print(f'm:{m},n:{n}')

b1 = B(1,2)

class Student:
    def __init__(self, name, age=18, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

    def __repr__(self):
        # self = stu1
        return f'姓名:{self.name}, 年龄:{self.age}, 性别:{self.gender}'


stu1 = Student('小明')
stu2 = Student('小花', 17, '女')
print(stu1)
print(stu2)

6.attribute

# 类中的属性分为：类属性、对象属性

"""
1)类属性
a.怎么定义：直接在类中定义的变量就是类属性
b.怎么使用：以'类名.xxx'的方式使用
c.什么时候用:如果属性值不会因为对象不同而不一样，就定义成类属性

2)对象属性
a.怎么定义：以'self.属性名 = 属性值'的形式定义在__init__方法中
b.怎么使用:以'对象.xxx'的方式使用
c.什么时候用：属性值会因为对象不同而不一样，就定义成对象属性
"""

class A:
    # a、name是类属性
    a = 10
    name = '张三'

    # x 和n是对象属性
    def __init__(self):
        self.x = 10
        self.n = 'hello'

print(A.a)
print(A.name)

a1 = A()
print(a1.x)
print(a1.n)

class Circle:
    pi = 3.1415926

    def __init__(self,r = 0):
        self.r = r

    def area(self):
        return Circle.pi * self.r ** 2

c1 = Circle(10)
print(c1.area())

7.inherit

7.1 继承

"""
继承:让子类直接拥有父类的属性和方法

子类：继承者
父类：被继承者

"""

7.2 继承语法

"""
语法：
class 类名(父类1，父类2，父类2，...):
    类的说明文档
    类的内容
    

注意：定义类的时候没有写父类，那么这个类会默认继承object（基类）

"""

class A:
    m = 100

    def __init__(self):
        self.n = 200

    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        print('类方法')

    @staticmethod
    def func3():
        print('静态方法')

class B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新的对象属性
    def __init__(self):
        super().__init__()     # 调用当前类的父类的__init__
        # super(B, self).__init__()
        self.p = 1000

    # 添加新的方法
    def func11(self):
        print('对象方法2')

    @classmethod
    def func22(cls):
        print('类方法2')

    @staticmethod
    def func33():
        print('静态方法2')


b1 = B()

# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()
B.func3()

# 使用B中的内容
print(B.x)
b1.func11()
B.func22()
B.func33()
print(b1.p)