正文
python：面向对象初级
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
面向对象编程
类的概念 ： 具有相同属性和技能的一类事物
人类 抽象
对象 ： 就是对一个类的具体的描述
具体的人 具体使用面向对象的好处：
使得代码之间的角色关系更加明确
增强了代码的可扩展性
规范了对象的属性和技能
面向对象的特点：结局的不确定性
self = {'name': name, 'sex':sex, 'hp': hp, 'ad': ad}
def attack(dog): # 闭包
# 人攻击狗
print('%s攻击%s' % (self['name'], dog['name']))
# 狗掉血，狗的血量-人的攻击力
dog['hp'] -= self['ad']
self['attack'] = attack
return selfdef Dog(name,kind,hp,ad):
# 狗模子
self = {'name': name, 'kind':kind, 'hp': hp, 'ad': ad}
def bite(person):
print('%s咬了%s' % (self['name'], person['name']))
# 人掉血，人的血量-狗的攻击力
person['hp'] -= self['ad']
if person['hp'] <= 0: print('game over,%s win' % self['name'])
def bite2():pass
self['bite'] = bite
self['bite2
创建一个类
class Person:
role = 'person' # 静态属性
def f1(self): # 动态属性 方法（函数） 默认带一个参数self
查看静态变量的第一种方式
print(Person.__dict__) # 内置的双下方法
print(Person.__dict__['role'])
Person.__dict__['role'] = 456 # 报错
print(Person.__dict__['role'])
查看静态变量的第二种方式
print(Person.静态变量) # 123 值
print(Person.role)
Person.静态变量 = 456
Person.role = 456
print(Person.静态变量)#456del Person.静态变量
print(Person.__dict__)
类名
引用静态变量
1.类名.__dict__['静态变量名'] 可以查看，但是不能删改
2.类名.静态变量名 直接就可以访问,可以删改
删除一个静态变量 del 类名.静态变量名
引用动态变量
1.类名.方法名 查看这个方法的内存地址
1.类名.方法名(实参) 调用了这个方法，必须传一个实参，这个实参传给了self
创造一个对象 - 实例化
产生一个实例（对象）的过程
对象 = 类名()
alex = Person() # 创造一个对象
alex 是对象、实例
Person是类
对象 = 类名()
class Person:
role = 'person' # 静态属性
def __init__(self,name,sex,hp,ad):
self.name = name # 对象属性 属性
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self):
print('%s发起了一次攻击'%self.name)alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',20,50)alex.attack() # Person.attack(alex)
boss_jin.attack() # Person.attack(boss_jin)
实例化：创造一个对象的过程：实例化
实例化的过程：
1.创造一个实例,将会作为一个实际参数 # python
2.自动触发一个__init__的方法，并且把实例以参数的形式传递给__init__方法中的self形参
3.执行完__init__方法之后，会将self自动返回给alex
__init__方法 ：初始化方法，给一个对象添加一些基础属性的方法，一般情况下是针对self的赋值
对象
在类的内部 self是本类的一个对象
在类的外部，每一个对象都对应着一个名字，这个对象指向一个对象的内存空间
属性的调用：
对象名.属性名 第一种调用方法
对象名.__dict__['属性名'] 第二种调用方法
方法的调用 ：
类名.方法名(对象名) # 那么方法中的self参数就指向这个对象
对象名.方法名() # 这样写 相当于 方法中的self参数直接指向这个对象
面向对象：交互
class Person:
role = 'person' # 静态属性
def __init__(self,name,sex,hp,ad):
self.name = name # 对象属性 属性
self.sex = sex
self.hp = hp #血量
self.ad = ad #攻击力
def attack(self,d):
d.hp -= self.ad
print('%s攻击了%s，%s掉了%s点血'%(self.name,d.name,d.name,self.ad))class Dog:
def __init__(self,name,kind,hp,ad):
self.name = name
self.kind = kind
self.hp = hp
self.ad = ad
def bite(self,p):
p.hp -= self.ad
print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad))alex = Person('a_sb','不详',1,5)
boss_jin = Person('金老板','女',20,50)
teddy = Dog('笨笨','teddy',50,10)
teddy.bite(alex)
print(alex.hp)
boss_jin.attack(teddy)
print(teddy.hp)
命名空间和作用域
class Person:
role = 'person' # 静态属性
def __init__(self,name,sex,hp,ad):
self.name = name # 对象属性 属性
self.sex = sex
self.hp = hp
self.ad = ad
def attack(self):
self.hobby = 'girl'
print('%s发起了一次攻击'%self.name)alex = Person('a_sb','不详',1,5)
alex.attack() # Person.attack(alex)
alex.age = 81
# alex --> Person
# Person实例化了alex
print(alex.__dict__)
alex.name #alex 指向我自己的内存空间 在自己的内存空间里找到name
alex.attack #alex 先找自己的内存空间 再找到类对象指针 再根据类对象指针找到类 再通过类找到attack
对象的内存空间里: 只存储对象的属性，而不存储方法和静态属性
方法和静态属性都存储在类的内存空间中
为了节省内存，让多个对象去共享类中的资源
命名空间和作用域
写一个类 完成一个功能 ： 可以统计这个类有几个对象
class Foo:
count = 0
def __init__(self):
Foo.count += 1
f1 = Foo()
f2 = Foo()
f3 = Foo()
f4 = Foo()
f5 = Foo()
print(Foo.count) #
1.
class Life:
money = 10
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作，赚了1000块钱')
# print(self.__dict__)
# print(Life.money)
# print(self.money)
self.money += 1000
father = Life('father')#father 工作，赚了1000块钱/
father.work()
print(father.money)
mother = Life('mother')
mother.work()
print(mother.money)
print(father.money)
# father.money = 10
print(father.__dict__)#{'money': 1010, 'name': 'father'}
print(Life.money)#在对象的空间中新创建了一个字典self.money += 1000
2.
class Live:
money = [1]
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作赚了1000块钱')
# print(self.money)
self.money[0] +=1000
father2 = Live('father2')
mother2 = Live('mother2')
father2.work()
mother2.work()
print(mother2.__dict__)#{'name': 'mother2'}
print(father2.money)
print(mother2.money)#[2001]
print(Live.money)#[2001]
print(Live.__dict__['money'])由于传递的是可变类型的元素的改变，所以导致live.money的元素也发生改变
3.
class Live2:
money= [0]
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作赚了1000块钱')
Live2.money = [Live2.money[0]+1000]father3 = Live2('father3')
mother3 = Live2('mother3')
mother3.work()
father3.work()
print(father3.__dict__)
print(Live2.money)
兑现属性是独有的，静态属性和方法是共享的
对象使用名字，先找自己内存空间中的，再找类的内存空间的
类名.静态变量;对于静态属性的修改，应该使用类名直接修改面向对象实例
# 圆
# 计算圆的周长 2 pi r
# 计算圆的面积 pi r**2
# 5个圆
# 1,3,5,7,9
from math import pi
class Circle:
def __init__(self,r):
self.r = r
def cal_area(self):
'''
计算圆面积的方法
:return:返回值是float数据类型的面积
'''
return pi*self.r**2
def cal_perimeter(self):
'''
计算圆周长的方法
:return:返回值是float数据类型的周长
'''
return pi * self.r * 2
for i in range(1,10,2):
c1 = Circle(i)
print(c1.cal_area())
print(c1.cal_perimeter())
