day22:初识面向对象

1，类可以理解为是一个模子，可以是代码精简，方便增加实例，方便修改，更加规范，能知道具体的属性，方法，但是不知道具体的值

2，对象有具体的值，属性和技能都是根据类规范的

3， 先有类才有对象

4，面向程序，面向函数，面向对象编程

5，面向对象优点:解决了程序的扩展性,维护和扩展变得简单，大大提高程序的开发效率，缺点，可控性比较差，应用场景：需求经常变化的软件

6，Python中一切皆对象，好比Linux中一切结尾文件

class Person:
    def __init__(self,*args):
        # self是一个可以存储很多属性的大字典
        self.name = args[0] # 王子点里添加属性的方式发生了变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
    def walk(self):
        print('走走走')

lisa = Person('lisa',100,200,'female')  # 实例化过程，想象序列化
print(lisa.__dict__)
print(Person.__dict__)

# {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
# {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10d412840>, 'walk': <function Person.walk at 0x10d4127b8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

7,双下init函数会在实例化的时候自动调用，然后传参，并且会自动返回一个self对象

# 对象 = 类名()
# 过程:
#  类名() 首先会创造出一个对象，创建了一个self变量，创建的过程我们不需要关心，系统自检给创建
# 自动调用init方法，类名括号里的参数会被这里接收 
# 执行init方法，
# 返回sel

8，帮助理解面向对象的一段代码

def Person(*args,**kwargs):
    self = {}
    def attack(self,dog):
        dog['life_value'] -= self['aggressivity']

    def __init__(name,aggressivity,life_value):
        self['name'] = name
        self['aggressivity'] = aggressivity
        self['life_value'] = life_value
        self['attack'] = attack

    __init__(*args,**kwargs)
    return self

egg = Person('lisa',78,10)
print(egg['name'])

9，类里面，我只要已创建一个class的时候，我就拥有了一个self，self等于空字典这个事不需要你去做，别人替你做了，只是你直接拿着这个就可以用了。以点的方式操作然后最后把self返回给对象，新创建的对象，就是self。self里面存储的就是一个字典的关系

class Person:
    def __init__(self,*args):
        # self是一个可以存储很多属性的大字典
        print(self.__dict__)  # {}

        self.name = args[0] # 王子点里添加属性的方式发生了变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

        print(self.__dict__)  # {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}

lisa = Person('lisa',100,200,'female')

10，新实例化的对象就是self

class Person:
    def __init__(self,*args):
        # self是一个可以存储很多属性的大字典，
        print(self.__dict__)  # {}

        self.name = args[0] # 只不过往字典里添加属性的方式发生了变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        print(id(self))
        print(self.__dict__)  # {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}

lisa = Person('lisa',100,200,'female')
print(id(lisa))
print(lisa.__dict__) # ID一样，内存地址一样，所以两个就是一样的

运行结果：
{}
4417958464
{'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
4417958464
{'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}

11，调用方法

class Person:
    def __init__(self,*args): # 一般双下init都放在最上面

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
    def walk(self):  # 这个参数是必须有的，只要是类的方法就得有，这个名字不用self也可以，但是我们不成文的规定都叫self
        print('hello')

lisa = Person('lisa',100,200,'female')
print(lisa.__dict__)
print(Person.__dict__) # 类的字典里面有个walk，所以我们可以用类来调用试试
# {'name': 'lisa', 'hp': 100, 'aggr': 200, 'sex': 'female'}
# {'__module__': '__main__', '__init__': <function Person.__init__ at 0x1007b17b8>, 'walk': <function Person.walk at 0x1007b16a8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}

# Person.walk()  # 提示错误 TypeError: walk() missing 1 required positional argument: 'self'
Person.walk(lisa) # 因为Lisa就是self，所以我们传入Lisa
# hello
# 这种调用有一种简写的方法就是
lisa.walk() # 这个和Person.walk(lisa)效果是一样的

12，总结

# 对象能做的事：
    # 查看属性
    # 调用方法
# 类名能做的事：
    # 实例化
    # 调用方法：只不过要自己调用self参数

13，静态属性

class Person:
    country = 'China'  # 创造了一个只要是这个类就一定有的属性
                       # 类属性，静态属性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")

print(Person.country) # China
print(Person.__dict__['country'])   # China
print(lisa.__dict__['name']) # lisa
# 类名不可以调用对象的属性，可以查看静态属性，不需要实例化就可以查看

13,修改对象属性，可以通过属性或者字典来修改

    country = 'China'  # 创造了一个只要是这个类就一定有的属性
                       # 类属性，静态属性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")

print(Person.country) # China
print(Person.__dict__['country'])   # China
print(lisa.__dict__['name']) # lisa
# 类名不可以调用对象的属性，可以查看静态属性，不需要实例化就可以查看

lisa.__dict__['name'] = 'lucy' # 修改成功
print(lisa.__dict__['name'])  # lucy
# __dict__对于对象的属性增删改查都可以通过字典的语法进行，但是正产情况下我们不太这样用，我们一般这样用
lisa.name = 'jack' # 通过属性改，但是不通过字典改
print(lisa.__dict__['name']) # jack
# 这两种修改方式本质上是一样的

14，类属性也就是静态属性的修改不可以通过字典来修改，只能通过属性来修改

class Person:
    country = 'China'  # 创造了一个只要是这个类就一定有的属性
                       # 类属性，静态属性

    def __init__(self,*args):

        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.gender = args[3]

    def walk(self):
        print('hello')

lisa = Person('lisa',100,200,"female")

print(Person.country) # China
print(Person.__dict__['country'])   # China
# Person.__dict__['country'] ='USA'
# TypeError: 'mappingproxy' object does not support item assignment
Person.country = 'USA' # 修改成功

15，大写开头的名字，一般都是给类名用

16，实例，计算圆的面积和周长

from math import pi
class Circle:
    def __index__(self,r):
        self.r = r

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

    def perimeter(self):
        return 2*pi*self.r

c1 = Circle(6)
print(c1.area())
print(c1.perimeter())