面向过程 和 面向对象
面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤
优点：极大降低写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。
缺点是：一套代码解决一个问题，牵一发而动全身。
应用：一旦完成基本很少改变的场景，Linux內核，git等。
面向对象的程序设计的核心是对象（上帝式思维）。
优点：对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：可控性差，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等。
类和对象
python中一切皆为对象，类型的本质就是类。
>>> dict #类型dict就是类dict <class 'dict'> >>> d={name：'eva'} #实例化 >>> d.pop('name') #向d发一条消息，执行d的方法pop 'eva'
在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。
def functionName(args): '函数文档字符串' 函数体 ''' class 类名: '类的文档字符串' 类体 ''' #我们创建一个类 class Data: pass class Person: #定义一个人类 role = 'person' #人的角色属性都是人 def walk(self): #人都可以走路，也就是有一个走路方法，也叫动态属性 print("person is walking...")
对象 = 类名() 过程： 类名() 首先 会创造出一个对象，创建了一个self变量 调用init方法，类名括号里的参数会被这里接收 执行init方法 返回self 对象能做的事： 查看属性 调用方法 __dict__ 对于对象的增删改查操作都可以通过字典的语法进行 类名能做的事： 实例化 调用方法 : 只不过要自己传递self参数 调用类中的属性,也就是调用静态属性 __dict__ 对于类中的名字只能看 不能操作
实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
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) # 调用方法 类名.方法名(对象名)
一：我们定义的类的属性到底存到哪里了？有两种方式查看 dir(类名)：查出的是一个名字列表 类名.__dict__:查出的是一个字典，key为属性名，value为属性值 二：特殊的类属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中)
面向对象小结——定义及调用的固定模式
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 #查看对象的属性，直接用 对象名.属性名 即可 对象名.方法名() #调用类中的方法，直接用 对象名.方法名() 即可
练习一：在终端输出如下信息 小明，10岁，男，上山去砍柴 小明，10岁，男，开车去东北 小明，10岁，男，最爱大保健 老李，90岁，男，上山去砍柴 老李，90岁，男，开车去东北 老李，90岁，男，最爱大保健 class Person: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def ss(self): print('%s,%s岁，%s,%s'%(self.name,self.age,self.sex,'上山去砍柴')) def kc(self): print('%s,%s岁，%s,%s'%(self.name, self.age, self.sex, '开车去东北')) def maj(self): print('%s,%s岁，%s,%s'%(self.name, self.age, self.sex, '最爱大保健')) p1 = Person('小明',10,'男') p2 = Person('老李',90,'男') print(p1.__dict__) p1.ss() p1.kc() p1.maj() p2.ss() p2.kc() p2.maj()
包 —— __init__ import package —— 类的实例化的过程 import time time.time()
对象之间的交互
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') alex = Person('alex',999,998,'不详') jin.bite(alex) # Dog.bite(jin,alex) print(alex.blood) alex.attack(jin) # Person.attack(alex,jin) print(jin.hp)
from math import pi class Circle: ''' 定义了一个圆形类； 提供计算面积(area)和周长(perimeter)的方法 ''' def __init__(self,radius): self.radius = radius def area(self): return pi * self.radius * self.radius def perimeter(self): return 2 * pi *self.radius circle = Circle(10) #实例化一个圆 area1 = circle.area() #计算圆面积 per1 = circle.perimeter() #计算圆周长 print(area1,per1) #打印圆面积和周长
类命名空间与对象、实例的命名空间
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
而类有两种属性：静态属性和动态属性
静态属性就是直接在类中定义的变量，类的数据属性是共享给所有对象的
动态属性就是定义在类中的方法，类的动态属性是绑定到所有对象的
类里的名字有 类变量（静态属性量）+ 方法名（动态属性） 对象里的名字 对象属性 对象 —— > 类 对象找名字 ： 先找自己的 找类的 再找不到就报错 对象修改静态属性的值 对于不可变数据类型来说，类变量最好用类名操作 (类可对其直接更改，对象对其直接更改则类中不变，在对象自己的空间中生成一个新属性) 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的 (对列表之类，对象不可改变列表，但对列表内元素可以修改）
创建一个类，每实例化一个对象就计数 最终所有的对象共享这个数据 class Foo: count = 0 def __init__(self): Foo.count += 1 f1 = Foo() f2 = Foo() print(f1.count) print(f2.count) f3 = Foo() print(f1.count)
认识绑定关系
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> f1.func 时，形成绑定关系，f1成为Foo里面的self，操作才能进行。
面向对象的组合用法
软件重用的重要方式除了继承之外还有另外一种方式，即：组合
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
（什么时候用组合：什么有什么的时候）当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好
class Dog: def __init__(self,name,aggr,hp,kind): self.name = name self.aggr = aggr self.hp = hp self.kind = kind def bite(self,person): person.hp -= self.aggr class Person: def __init__(self,name,aggr,hp,sex): self.name = name self.aggr = aggr self.hp = hp self.sex = sex self.money = 0 def attack(self,dog): dog.hp -= self.aggr def get_weapon(self,weapon): if self.money >= weapon.price: self.money -= weapon.price self.weapon = weapon self.aggr += weapon.aggr else: print("余额不足，请先充值") class Weapon: def __init__(self,name,aggr,njd,price): self.name = name self.aggr = aggr self.njd = njd self.price = price def hand18(self,person): if self.njd > 0: person.hp -= self.aggr * 2 self.njd -= 1 alex = Person('alex',0.5,100,'不详') jin = Dog('金老板',100,500,'teddy') w = Weapon('打狗棒',100,3,998) # alex装备打狗棒 alex.money += 1000 alex.get_weapon(w) print(alex.weapon) print(alex.aggr) alex.attack(jin) print(jin.hp) alex.weapon.hand18(jin) print(jin.hp)
圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用。
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,outside_r,inside_r): self.outside_c = Circle(outside_r) self.inside_c = Circle(inside_r) def area(self): return self.outside_c.area() - self.inside_c.area() def perimeter(self): return self.outside_c.perimeter()+self.inside_c.perimeter() # ring = Ring(20,10) # print(ring.area()) # print(ring.perimeter())
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程
class BirthDate: def __init__(self,year,month,day): self.year=year self.month=month self.day=day class Couse: def __init__(self,name,price,period): self.name=name self.price=price self.period=period class Teacher: def __init__(self,name,gender,birth,course): self.name=name self.gender=gender self.birth=birth self.course=course def teach(self): print('teaching') p1=Teacher('egon','male', BirthDate('1995','1','27'), Couse('python','28000','4 months') ) print(p1.birth.year,p1.birth.month,p1.birth.day) print(p1.course.name,p1.course.price,p1.course.period) ''' 运行结果: 27 python 28000 4 months '''
总结： 当类的对象作为 值 存在时，就是 组合。