python进阶_基础篇13（面向对象：类和对象）

面向对象

编程思想

1. 编程思想

面向过程编程(穷人) - 遇到问题首先想到是用什么样的逻辑和语法写什么代码能够实现这个功能(逻辑，语法)
函数式编程（小资） - 遇到问题首先想到的时候有没有一个已经存在的函数能够完成这个功能，如果有就直接调用这个函数，如果没有就定义一个能够实现这个功能的函数。(函数)
面向对象编程（富豪） - 遇到问题首先想到的时候有没有一个对象它有这个功能，没有就去创建这个对象。(类和对象)

# 10!
# 面向过程编程
sum1 = 1
for x in range(1, 11):
    sum1 *= x
print(sum1)


sum1 = 1
for x in range(1, 21):
    sum1 *= x
print(sum1)

# 函数式编程
# from math import factorial
# print(factorial(10))

def factorial(n):
    sum1 = 1
    for x in range(1, n+1):
        sum1 *= x
    return sum1


print(factorial(10))
print(factorial(20))

# 面向对象
class Math:
    @staticmethod
    def factorial(n):
        sum1 = 1
        for x in range(1, n + 1):
            sum1 *= x
        return sum1

    @staticmethod
    def abs(num):
        if num >= 0:
            return num
        return -num


print(Math.factorial(10))

类和对象

1. 什么是类什么是对象

类就是拥有相同功能和相同属性的对象的集合；（某一类事物的统称， 是抽象的概念）
对象就是类的实例 (类具体的表现)

如果人是类，余婷就是对象；我就是对象
如果车是类，我家的车就是对象，楼下那辆红色骚气的跑车就是对象

2.定义类（目的是表述清楚你是哪些相同功能，哪些相同属性的统称）

语法：

class 类名:
    类的说明文档
    类的内容(方法、属性)

说明：

1.class   -   关键字；固定写法
2.类名    -    程序员自己命名；
              要求：a.是标识符  b.不是关键字
              规范：a. 采用驼峰式命名，并且首字母大写
                   b. 见名知义（看到名字大概知道这个类是那种事物的统称）
                   c. 不能使用系统的函数名、类名或者模块名
3.类的说明文档  -  和函数说明文档的要求一样
4.类的内容   -  类的内容中主要包含类的方法(对象方法、类方法和静态方法)和属性(类属性、对象属性)

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

补充说明：

驼峰式命名： 学生的名字  -> studentName
类名：学生  -> Student
类名：管理系统  -> ManagerSystem

class Housekeeping:
    """
    家政类：拥有洗衣服、做饭、打扫的功能
    """
    def wash_the_clothes(self):
        print('洗衣服')

    def cooking(self):
        # self = h
        print('self:', self)
        print('做饭')

    def clean(self):
        print('打扫')

3.定义对象(创建对象)

"""
语法：
类()
"""
# h就是Housekeeping的对象
h = Housekeeping()

h.cooking()
print('h:', h)

类中的方法

1.类的方法

定义类就是描述清楚这个类是拥有哪些相同的功能和属性的集合。
类中的方法就是对类相同的功能的描述

1) 什么是方法
方法就是定义在类中的函数, 它分为三类：对象方法、类方法、静态方法

2. 三种方法
1)对象方法
怎么定义： 直接定义在类中的函数就是对象方法
特点： 自带参数self(如果使用对象去调用对象方法，对象方法中self不用传参，系统会自动将当前对象传给self，self指向当前对象
怎么调用： 对象.方法()

2)类方法
怎么定义： 在定义函数前加 @classmethod
特点： 自带参数cls(如果使用类去调用类方法，方法中的cls不用传参，系统会自动将当前类传给cls)，cls指向当前类
怎么调用： 类.方法()

3)静态方法
怎么定义： 在定义函数前加 @staticmethod
特点： 没有默认参数
怎么调用： 类.方法()

class Person:
    # ==============对象方法==============
    # eat就是对象方法
    def eat(self, food='米饭'):
        # self: 谁调用就指向谁
        print(f'self:{self}')
        print('人类吃', food)

    # sleep是对象方法
    def sleep(self):
        print('睡觉')

    # ==============类方法==============
    @classmethod
    def show_num(cls, num=61):
        print(f'cls:{cls}')
        print(f'人类的数量: {num}亿')

    # ==============静态方法==============
    @staticmethod
    def show_message():
        print('人类破坏环境!')


p1 = Person()
p2 = Person()

print(f'p1:{p1}')
print(f'p2:{p2}')

p2.eat()
p1.sleep()
p1.eat('面条')

Person.show_num()
Person.show_num(60)

Person.show_message()

# 注意: 从语法来角度来看，不管是对象方法、类方法还是静态方法都可以使用类和对象调用(但是实际开发不要这样做)
Person.eat('xx')    # 不合理
p1.show_num()
p1.show_message()

构造函数和init

1.什么是构造函数 - 函数名和类同名的用来创建的对象的函数/方法

a.函数名和类名同名 b.功能是用来创建对象的

python中，当我们在定义类的时候，系统会自动创建这个类的构造函数。在这个构造方法中会自动调用__new__方法来创建对象，并且用这个创建好的对象来调用__init__对对象进行初始化操作，最后才将对象返回。

2.__init__方法

__init__是每个类中都有一个特殊的对象方法， 是魔法方法（会被自动调用）;当创建类的对象的时候，这个类中的__init__方法会被自动调用。

在类中添加__init__方法，只需要保证方法名是__init__, 方法是对象方法。

class Dog:
    def __init__(self, x):   #此处相当于重写了函数，如果每次函数，也会自动调用基类的__init__方法进行初始化
        print('init方法')
        print(x)


"""
def Dog():
    dog = Dog.__new__()
    dog.__init__()
    return dog
"""

# 1）当调用构造方法创建对象的时候，系统自动调用这个类中 __init__ 方法
# 2）调用构造方法创建对象的时候，这个构造方法需不需要参数，需要几个参数，看类中的__init__方法除了self以外需不要参数，
# 需要几个参数
dog1 = Dog(10)
dog2 = Dog(x=100)

类中的属性

1.什么是属性

我们通过类中的属性来保存类相关的数据

2.属性的分类

类中的属性分为两种：类属性和对象属性
1)类属性(类的字段)
a.定义： 直接定义在类中的变量就是类属性
b.使用： 类.属性
c.什么时候用： 属性值不会因为对象不同而不一样的时候，就使用类属性

2)对象属性
a.定义： 在__init__方法中，以 self.属性=值 的形式进行定义 (属性自己命名,要求和规范和变量名一样)
b.使用： 对象.属性
c.什么时候用: 属性值会因为对象不同而不一样的时候，就使用对象属性

a = 100


class Student:
    # num就是类属性
    num = 30

    def __init__(self):
        # name和age, score就是对象属性
        self.name = '张三'
        self.age = 18
        self.score = 0


print(a)
print(Student.num)

stu = Student()
print(stu.name, stu.age, stu.score)

stu2 = Student()
print(stu.name, stu.age, stu.score)
print(stu2)   # <__main__.Student object at 0x104853510>

重写__repr__方法可以自定义对象的打印格式;这个方法的返回值就是对象的打印结果(返回值必须是字符串)

class Person:
    def __init__(self, name, gender='男'):
        self.name = name
        self.age = 0
        self.gender = gender

 # 重写__repr__方法可以自定义对象的打印格式;这个方法的返回值就是对象的打印结果(返回值必须是字符串)
    def __repr__(self):
        # 打印谁，self就是谁
        return f'name:{self.name} age:{self.age} gender:{self.gender}'


p1 = Person('小明')
print(p1)       # name:小明 age:0 gender:男

p2 = Person('小花', '女')
print(p2)        #name:小花 age:0 gender:女

对象属性的增删改查

1.对象属性

python类对象的属性是支持增、删、改、查

class Dog:
    def __init__(self, name, breed='土狗', sex='母狗', age=1):
        self.breed = breed
        self.sex = sex
        self.age = age
        self.name = name


dog1 = Dog('大黄', sex='公狗')
dog2 = Dog('宝贝', '哈士奇', age=3)

1）.查 - 获取属性值
对象.属性 - 获取对象指定属性的值
getattr(对象, 属性名) - 获取对象指定属性的值
getattr(对象, 属性名, 默认值) - 获取对象指定属性的值（如果属性不存在不会报错，返回默认值）

print(dog1.name)
print(getattr(dog1, 'name'))
print(getattr(dog1, 'name', '无名'))

# print(dog1.color)   # AttributeError: 'Dog' object has no attribute 'color'
# print(getattr(dog1, 'color'))   # AttributeError: 'Dog' object has no attribute 'color'
print(getattr(dog1, 'color', '白色'))   # 白色

getattr可以根据变量的值动态获取指定属性的值

value = input('属性名:')
print(getattr(dog1, value))

2）增、改
对象.属性 = 值 - 如果属性存在就是修改对象属性的值;如果属性本身不存在就是添加属性
setattr(对象, 属性名, 值) - 如果属性存在就是修改对象属性的值;如果属性本身不存在就是添加属性

dog1.name = '小黄'
print(dog1.name)  # 小黄

dog1.color = '黄色'
print(dog1.color)    # 黄色

setattr(dog1, 'name', '黄黄')
print(dog1.name)   # 黄黄

setattr(dog1, 'weight', 10)
print(dog1.weight)   # 10

3）删
del 对象.属性 - 删除对象的指定属性
delattr(对象, 属性名) - 删除对象的指定属性

del dog1.age
# print(dog1.age)   # AttributeError: 'Dog' object has no attribute 'age'

delattr(dog1, 'name')
# print(dog1.name)     # AttributeError: 'Dog' object has no attribute 'name'