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())