面向对象的命名空间：
#属性：静态属性 （直接和类名关联或者直接定义在class下的变量）
# 对象属性 （在类内和self关联，在类外和对象名关联的变量）
# 动态属性（函数）
class Foo:
country = ‘China‘
country_lst = [‘China‘]
def __init__(self,name):
self.name = name
alex = Foo(‘alexander‘)
egg = Foo(‘egon‘)
alex.age = 90
alex.country_lst = []
alex.country_lst.append(‘印度‘)
# print(Foo.country_lst)
# Foo.role = ‘Person‘
# print(Foo.country)
# print(alex.name)
# print(egg.name)
# Foo.country
# alex.country = ‘印度‘
# print(alex.country)
# print(egg.country)
# print(Foo.country)
# del alex.country
# print(alex.country)
# print(alex.country_lst)
# alex.country_lst.append(‘印度‘)
# print(alex.country_lst)
# print(egg.country_lst)
# print(Foo.country_lst)
#类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量
# 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性
# class Foo:
# count = 0
# def __init__(self):
# Foo.count += 1
#
# f = Foo()
# f2 = Foo()
# f3 = Foo()
# print(f.count) #Foo.count
# print(f2.count) #Foo.count
# print(f3.count) #Foo.count
class Person:
def __init__(self):pass
#给一个什么属性都没有的对象赋一些初识的属性
def eat(self):
print(‘吃猪食‘)
alex = Person() #裸着
print(alex.__dict__)
alex.name = ‘alexander‘
# alex.eat = ‘泔水‘ #对象使用名字的顺序：先用自己的，再用类的
# alex.eat()
#对象可以使用类的
#而类无法使用对象的
# print(Person.eat)
# print(alex.eat) #类对象指针的东西 alex = {‘eat‘:eat}
组合：
#函数
#定义 调用 返回值 参数、命名空间和作用域
#面向对象
#定义 、命名空间
#三大特性：封装继承和多态（组合）
#组合 ： 什么 有 什么 的关系
#一个对象的属性是另外一个类的对象
#老师有生日
# class Teacher:
# def __init__(self,name,age,sex):
# self.name = name
# self.age = age
# self.sex = sex
# # self.birth_year = year
# class Birthday:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
# birthay1 = Birthday(1968,12,31)
# boss_gold = Teacher(‘太亮‘,40,‘不详‘)
# boss_gold.birth = birthay1
# boss_gold.birth.year #boss_gold.bith.year
#老师有生日 ： 年月日
#将一个类的对象拥有的属性 再将其定义成一个类以提高代码的复用
# class Teacher:
# def __init__(self,name,age,sex,year,month,day):
# self.name = name
# self.age = age
# self.sex = sex
# self.birth = Birthday(year,month,day)
# class Birthday:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
# boss_gold = Teacher(‘太亮‘,40,‘不详‘,1968,12,31)
# print(boss_gold.birth)
#圆形类
from math import pi
class Circle:
def __init__(self,r):
self.radius = r
def perimeter(self):
return 2*pi*self.radius
def area(self):
return pi*(self.radius**2)
#环形类
class Ring:
def __init__(self,outer_r,inner_r):
self.outer_circle = Circle(outer_r)
self.inner_circle = Circle(inner_r)
def perimeter(self):
return self.outer_circle.perimeter()+self.inner_circle.perimeter()
def area(self):
return self.outer_circle.area() - self.inner_circle.area()
r1 = Circle(5)
print(r1.perimeter())
print(r1.area())
r = Ring(10,8)
print(r.perimeter())
print(r.area())
# 既能hold住圆形的问题
# 又能解决环形的问题
#10,20
# def func(arg1,arg2):
# outer_circle = Circle(20)
# inner_circle = Circle(10)
# print(outer_circle.area() - inner_circle.area())
#
# def func2(arg1,arg2):
# outer_circle = Circle(20)
# inner_circle = Circle(10)
# print(outer_circle.perimeter() + inner_circle.perimeter())
# # 500个环
# ring1 = Ring(20,10)
# ring1.area()
#思想 —— 技术
#面向对象 命名空间
#组合 ： 老师有生日，环中有圆
#游戏 ：组合
组合例题：
#狗
class Dog: # 定义一个狗类
def __init__(self, name, breed, aggressivity, life_value):
self.name = name # 每一只狗都有自己的昵称;
self.breed = breed # 每一只狗都有自己的品种;
self.aggressivity = aggressivity # 每一只狗都有自己的攻击力;
self.life_value = life_value # 每一只狗都有自己的生命值;
def bite(self,people):
people.life_value -= self.aggressivity
#人
class Person: # 定义一个人类
def __init__(self, name, aggressivity, life_value, money):
self.name = name # 每一个角色都有自己的昵称;
self.aggressivity = aggressivity # 每一个角色都有自己的攻击力;
self.life_value = life_value # 每一个角色都有自己的生命值;
self.money = money
def attack(self,dog):
dog.life_value -= self.aggressivity
def get_weapon(self,weapon_obj):
if self.money > weapon_obj.price:
self.money -= weapon_obj.price # 金老板花钱买武器
self.weapon = weapon_obj # 金老板装备打狗棒
self.aggressivity += weapon_obj.aggr # 金老板的攻击力增加了
# boss_gold = Person(‘金老板‘,5,250,100)
# huang = Dog(‘大黄‘,‘藏獒‘,100,3000)
# huang.bite(boss_gold)
# print(boss_gold.life_value)
# boss_gold.attack(huang)
# print(huang.life_value)
#不公平
#武器装备
#人 有 武器 —— 组合
#武器：攻击力，名字，价格
class Weapon:
def __init__(self,name,price,aggr):
self.name = name
self.price = price
self.aggr = aggr
dgb = Weapon(‘打狗棒‘,99.8,100)
boss_gold = Person(‘金老板‘,5,250,100)
huang = Dog(‘大黄‘,‘藏獒‘,100,3000)
boss_gold.get_weapon(dgb)
boss_gold.attack(huang)
print(huang.life_value)
#游戏的组合
#人可以有装备 ——
#狗 ——
#组合和命名空间
#继承的一点知识
初识继承：
# 面向对象的三大特性之一 —— 继承
# 继承 ：至少两个类 ： 什么 是 什么 的关系,为了避免几个类之间有相同的代码
# 父类 ： Animal
# 子类 ： Dog、Person
#动物
class Animal:
def __init__(self,name,aggressivity,life_value):
self.name = name
self.aggressivity = aggressivity
self.life_value = life_value
#狗
class Dog(Animal): # 定义一个狗类
def bite(self,people):
people.life_value -= self.aggressivity
#人
class Person(Animal): # 定义一个人类
def attack(self,dog):
dog.life_value -= self.aggressivity
def get_weapon(self,weapon_obj):
if self.money > weapon_obj.price:
self.money -= weapon_obj.price # 金老板花钱买武器
self.weapon = weapon_obj # 金老板装备打狗棒
self.aggressivity += weapon_obj.aggr # 金老板的攻击力增加了
huang = Dog(‘大黄‘,100,3000) #__init__ 找父类
print(huang.life_value)
boss_gold = Person(‘金老板‘,5,250) #__init__ 自己没有 找父类
print(boss_gold.life_value)
# Dog.bite(Person)
print(Dog.__bases__)
print(Animal.__bases__)
#python 两种类：经典类 新式类
#python3 新式类 —— 都默认继承object class Animal(object): == class Animal:
#python2 经典类和新式类 并存
#class Animal: 经典类 —— 继承顺序 个别使用方法
#class Animal(object): 新式类
#两个类中有相同的代码，
# 继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的
# 单继承和多继承
# 父类 超类 基类
# 子类 派生类
# 抽象和继承
时间： 2024-08-29 02:44:18