day15类和对象

1.面向对象编程

1.编程思想

程序员面对问题的时候，采用的解决方式就决定编程思想

• 面向过程编程(穷人思想) - 逻辑+算法
• 函数式编程(小资思想) - 逻辑+算法+函数
• 面向对象编程(富豪思想) - 逻辑+算法+函数+类+对象

# 问题：写程序计算1+2+3+..100的和
# 面向过程解决方法：
s = 0
for x in range(1, 101):
    s += x
print(s)

# 函数式编程：
print(sum(range(1, 101)))

2.类和对象

1.什么是类、什么是对象

• 类 - 类就是永远相同功能相同属性的对象的集合(抽象的概念)

• 对象 - 类的实例(具体的表现)

• 人是类，余老师是对象，骆老师是对象

• 车是类，我的车是对象，楼下那辆车是对象

2.定义类(创建类)

用代码来描述清楚你要创建的这个类是拥有哪些相同功能和哪些相同属性的对象的集合

"""
语法：
class 类名:
    类的说明文档
    类的内容
    
说明：
class      -  关键字，固定写法
类名        -  由程序员自己命名：
               要求：是标识符;不能是关键字
               规范：见名知义;不使用系统函数名、类名和模块名;首字母大写，才有驼峰式命名
类的说明文档  - 本质就是多行注释
类的内容     -  描述这个类共同的功能(函数 - 方法)和属性(变量 - 属性)

"""
# python PEP8命名规范
dog_name = '柴柴'

# 驼峰式命名
dogName = '柴柴'

# 类的驼峰式命名
DogName = '柴柴'


class Person:
    """人类："""
    pass

3.创建对象

"""
语法:
对象 = 类名()  - 创建指定类的对象并且返回

"""
p1 = Person()   # <__main__.Person object at 0x000001DA92535B10>
p2 = Person()   # <__main__.Person object at 0x000001DA92007C70>
print(p1)
print(p2)

if __name__ == '__main__':  # __main__:模块名
    pass

3.方法

# 1.方法  -  定义在类中的函数就是方法，它是用来描述类的对象拥有的共同的功能
"""
类中的方法有三种：对象方法、类方法、静态方法

1)对象方法
a.怎么定义：直接定义在类中的函数就是对象方法
b.怎么调用：以'对象.xxx()'的方式来调用(通过对象来调用)
c.特点：通过对象调用对象方法的时候，默认参数self不用传参，系统会自动将当前对象传给self(self是谁调用的就指向谁)


2)类方法
a.怎么定义：定义函数前加装饰器：@classmethod
b.怎么调用：以'类名.xxx()'的方式来调用(通过类来调用)
c.特点：通过类来调用类方法的时候，默认参数cls不需要传参，系统会自动将当前类传给cls(cls指向当前类)


3)静态方法
a.怎么定义：定义函数前加装饰器：@staticmethod
b.怎么调用：以'类名.xxx()'的方式来调用(通过类来调用)
c.特点：通过类来调用静态方法的时候
"""


class A:
    """无意义的类"""
    def func1(self):  # self:当前对象，不需要传参
        # self = a1
        print('这是一个对象方法',self)

    def func11(self, a, c):
        # self = a2, a = 10, b = 20
        print('这是对象方法2',self)

    @classmethod
    def func2(cls):   # cls:当前类，不需要传参
        print('这是一个类方法', cls)

    @classmethod
    def func22(cls,x=10):
        print('这是类方法2')

    @staticmethod
    def func3():
        print('这是一个静态方法')


a1 = A()
a2 = A()
print(f'a1:{a1}, a2:{a2}')

# 通过对象调用对象方法
a1.func1()
a2.func11(10,20)

# 通过类调用类方法
print(f'A:{A}')
A.func2()

A.func22()
A.func22(100)


# 通过类调用静态方法
A.func3()


# 通过对象调用类方法和静态方法(不建议使用)
a1.func2()
a1.func3()

d = {'a':10}
d.clear()
print(d)


a = 10
print(a.bit_length())
print(a.as_integer_ratio())

4.属性

# 1.属性  - 定义在类中的变量就是属性
"""
类中的属性有两种：对象属性、类属性

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

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

"""
# 补充：魔法方法 - 类自带的方法，名字以__开头并且以__结尾的方法就是魔法方法
"""
所有的魔法方法不需要程序员手动调用，系统会在待定的情况下自带调用特定的魔法方法，例如：
__init__ - 创建类的对象的时候会自动调用
__repr__ - 打印对象的时候会自动调用(在自动的类中添加__repr__的时候，这个方法必须字符串类型的返回值)
"""


class A:
    # x是类属性
    x = 10

    def __init__(self):
        # a是对象属性
        self.a = 10  # (self 默认值)
        print('init')

    def __repr__(self):
        print('======')
        return 'abc'



a1 = A()
a2 = A()

print(a1)

# 通过类使用类属性
print(A.x)

A.x = 100
print(A.x)

# 通过对象来使用对象属性
a1.a = 100
a2.a = 200
print(a1.a, a2.a)


# 案例：定义圆类
class Circle:
    pi = 3.1415926

    def __init__(self):
        self.r = 0

    def area(self):
        # self = c1; self = c2
        # 在实现对象方法的功能的时候如果需要兑现属性，通过self来提供
        return Circle.pi * self.r ** 2


c1 = Circle()
c1.r = 10

c2 = Circle()
c2.r = 5

print(c1.area())
print(c2.area())


class Person:
    def __init__(self, name, sex):
        self.name = name
        self.gender = sex


p1 = Person('小明', '男')
print(p1.name, p1.gender)