类命名空间与对象、实例的命名空间
创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性
而类有两种属性：静态属性和动态属性
- 静态属性就是直接在类中定义的变量
- 动态属性就是定义在类中的方法
属性：静态属性（直接和类名关联或者直接定义在class下的变量）
#对象属性 （在类内和self关联，在类外和对象名关联的变量）
#动态属性（函数）
# class Foo:
# country = 'China'
# country_lst = ['China']
# def __init__(self,name):
# self.name = name
# alex = Foo('alexander')
# xiao = Foo('jiangxiao')
# xiao.age = 20
# alex.country_lst =[]
# print(Foo.country_lst) #['China']
# Foo.role = 'Person'
# print(Foo.country) #China
# print(alex.name)
# print(xiao.name)
# alex.country = '印度'
# print(alex.country) #印度
# print(xiao.country) #China
# print(Foo.country)#China
# del alex.country
# print(alex.country)#China
# print(alex.country_lst)#[]
# alex.country_lst.append('印度')
# print(alex.country_lst) #['印度']
# print(xiao.country_lst)#['China']
# print(Foo.country_lst)#['China']
#类名操作变量 不管操作可变还是不可变数据类型 都是类中对应的变量发生变化
#对象名操作静态变量
#引用变量：现在自己的命名空间中查找，找不到就去类的命名空间找
#修改变量：
# 如果是对可变数据类型中的元素进行修改，那么全局生效
# 如果是对变量进行重新赋值，那么只是在对象自己的命名空间里增加了一个新的属性
# 结论：应该尽量用类名去使用静态变量
# 设计一个类，统计这个类被实例化的次数，且所有的对象共享这个属性
# class Foo:
# count = 0
# def __init__(self):
# Foo.count += 1
#
# f = Foo()
# f1 = Foo()
# f2 = Foo()
# print(f.count)#Foo.count
# print(f1.count)#Foo.count
# print(f2.count)#Foo.count
# 3
# 3
# 3
# 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,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('哈尼',23,'男',1994,3,28)
# print('%s %d岁 %s %d年 %d月 %d日'%(boss_gold.name,
# boss_gold.age,
# boss_gold.sex,
# boss_gold.birth.year,
# boss_gold.birth.month,
# boss_gold.birth.day))
#圆形类
# from math import pi
# class Circle:
# def __init__(self,r):
# self.randius = r
# def perimeter(self):
# return 2*pi*self.randius
# def area(self):
# return pi*(self.randius**2)
# #环形类
# class Ring:
# def __init__(self,outer_r,inner_r):
# self.outer_circle = Circle(outer_r)#大圆的周长
# self.inner_circle = Circle(inner_r)#小圆的周长2
# def perimeter(self):
# return self.outer_circle.perimeter()+self.inner_circle.perimeter()
# def area(self):
# return self.outer_circle.area() - self.inner_circle.area()
# ring1 = Ring(20,10)
# print(ring1.area())
#人狗大战
# 面向对象的三大特性之一 —— 继承
# 继承 ：至少两个类 ： 什么 是 什么 的关系,为了避免几个类之间有相同的代码
# 父类 ： 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 Animal:
def __init__(self,name,aggressivity,life_value,money):
self.name = name
self.aggressivity = aggressivity
self.life_value = life_value
self.money = money
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#金老板攻击增加了
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)
huang.bite(boss_gold)
print(boss_gold.life_value)
boss_gold.attack(huang)
print(huang.life_value)
#python 两种类：经典类 新式类
#python3 新式类 —— 都默认继承object class Animal(object): == class Animal:
#python2 经典类和新式类 并存
#class Animal: 经典类 —— 继承顺序 个别使用方法
#class Animal(object): 新式类
#两个类中有相同的代码，
# 继承：把相同的代码放在父类中，子类的对象在子类中没有找到方法的时候，使用父类的
# 单继承和多继承
# 父类 超类 基类
# 子类 派生类
# 抽象和继承