面向对象1

1，类和对象

python中一切皆为对象，类型的本质就是类。

>>> dict #类型dict就是类dict
<class 'dict'>
>>> d=dict(name='eva') #实例化
>>> d.pop('name') #向d发一条消息，执行d的方法pop
'eva'

在python中,用变量表示特征，用函数表示技能（方法），因而具有相同特征和技能的一类事物就是'类',对象则是这一类事物中具体的一个。

1.1类

class 类名：

#创建一个类
class Preson：
    pass


class Preson：
    role =“peron”    #静态属性
    def walk（self）:     #方法，动态属性
        print（"person is walking..."）

类的两种作用：属性引用，实例化

# class Person:                 # 类名
#     country = 'China'         # 创造了一个只要是这个类就一定有的属性
#                                # 类属性 静态属性
#     def __init__(self,*args):  # 初始化方法，self是对象，是一个必须传的参数
#         # self就是一个可以存储很多属性的大字典
#         self.name = args[0]   # 往字典里添加属性的方式发生了一些变化
#         self.hp = args[1]
#         self.aggr = args[2]
#         self.sex = args[3]
#
#     def walk(self,n):         # 方法，一般情况下必须传self参数，且必须写在第一个
#                               # 后面还可以传其他参数，是自由的
#         print('%s走走走,走了%s步'%(self.name,n))
#
# # print(Person.country)        # 类名 可以查看类中的属性，不需要实例化就可以查看
# alex = Person('狗剩儿',100,1,'不详')  # 类名还可以实例化对象，alex对象   # 实例化
# # print(alex.__dict__) # 查看所有属性
# print(alex.name)  # 查看属性值
# # print(alex.hp)  # 查看属性值
# alex.walk(5)    # Person.walk(alex，5)  # 调用方法 类名.方法名(对象名)

关于self：在实例化是自动讲对象/实例本身传给__init__的第一个参数，可以换名字。

1.2对象

对象=类名（）

对象是关于类而实际存在的一个例子，对象/实例只有一种作用：属性引用

调用的固定模式：

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

1.3对象之间的交互

# class Dog:
#     def __init__(self,name,blood,aggr,kind):
#         self.name = name
#         self.hp = blood
#         self.aggr = aggr
#         self.kind = kind
#     def bite(self,person):
#         # 狗咬人，人掉血
#         person.blood -= self.aggr
# class Person:
#     def __init__(self,name,blood,aggr,sex):
#         self.name = name
#         self.blood = blood
#         self.aggr = aggr
#         self.sex = sex
#     def attack(self,dog):
#         dog.hp -= self.aggr
#         if dog.hp <= 0:
#             print('%s打了%s,%s被打死了，扑街~~~'%(self.name,dog.name,dog.name))
#         else:
#             print('%s打了%s,掉了%s血'%(self.name,dog.name,self.aggr))
# jin = Dog('金老板',100,20,'teddy')
# # print(jin.name)
# alex = Person('alex',999,998,'不详')
# jin.bite(alex)   # Dog.bite(jin,alex)
# print(alex.blood)
# # alex attack
# alex.attack(jin)  # Person.attack(alex,jin)
# print(jin.hp)

2，类和对象命名空间

类里可以定义两种属性：静态属性。动态属性

创建一个类就会创建一个类的名称空间，用来存储类中定义的名字，这些名字称为类的属性

创建一个对象就会创建一个对象的名称空间。存放对象/实例的名字，称为对象/实例的属性

类中的静态变量可以被对象和类调用

对于不可变数据类型来说，类变量最好用类名操作，

对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

# 类里的名字有 类变量（静态属性量）+ 方法名（动态属性）
# 对象里的名字 对象属性
# 对象 —— > 类
# 对象找名字 ： 先找自己的 找类的 再找不到就报错
# 对象修改静态属性的值
    # 对于不可变数据类型来说，类变量最好用类名操作
    # 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

class Course:
    language=["Chinese"]                                              #language="Chinese"
    def __init__(self,teacher,course_name,period,price):
        self.teacher=teacher
        self.course_name=course_name
        self.period=period
        self.price=price
    def func(self):
        pass
Course.language[0]="df"                                           #Course.language="df"  
linux=Course("egon","py","6 months",20000)            #print(linux.language)
print(linux.language)                                                   #print(Course.language)
print(Course.language)
linux.language[0]="hu"                                              #linux.language="hu"
print(linux.language)                                                  #print(linux.language)
print(Course.language)                                                #print(Course.language)   
#  ['df']                                                                     #df
['df']                                                                           df             
 ["hu"]                                                                         du             
 ["hu"]                                                                          df            
                                                                                                   

2.2绑定方法

# def func():pass
# print(func)
#
# class Foo:
#     def func(self):
#         print('func')
#     def fun1(self):
#         pass
# f1 = Foo()
# print(Foo.func)
# print(f1.func)
# print(f1.fun1)
#<bound method Foo.func of f1

# 包 —— __init__
# import package —— 类的实例化的过程
# import time
# time.time()

2.3组合

组合：一个对象的属性值是另外一个类的对象（在一个类中以另外一个类的对象作为数据属性，称为类的组合）

什么时候用：当类之间有显著不同，并且较小的类是较大类所需要的组件时，用组合。（什么是什么）

　

#圆环的面积
# from math import pi
# class Circle:
#     def __init__(self,r):
#         self.r=r
#     def area(self):
#         return self.r**2*pi
#     def perimeter(self):
#         return 2*pi*self.r
# class Ring:
#     def __init__(self,out_r,ins_r):
#         self.out_c=Circle(out_r)
#         self.ins_c=Circle(ins_r)
#     def area(self):
#         return self.out_c.area()-self.ins_c.area()
#     def perimerter(self):
#         return self.out_c.perimeter()+self.ins_c.perimeter()
# ring=Ring(20,10)
# print(ring.area())
# print(ring.perimerter())

# class Birthday:
#     def __init__(self,year,month,day):
#         self.year=year
#         self.month=month
#         self.day=day
# class Course:
#     def __init__(self,cou_name,period,piric):
#         self.name=cou_name
#         self.period=period
#         self.piric=piric
# class Teacher:
#     def __init__(self,name,age,sex,birthday):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         self.birthday=birthday
#         self.course = Course('python', '6 month', 2000)
# b=Birthday(2020,2,13)
# egg=Teacher("egon",0,"女",b)
# print(egg.name)
# print(egg.sex)
# print(egg.birthday.day)
# print(egg.course.piric)