Pthon面向对象之基础

一: 类的定义

# 语法
class 类名:
    pass
对象=类名()

# 范例
class  Person:
    contry = '中国'

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print('%s正在吃饭'%self.name)

wangys=Person('wangys',18,'男')
print(wangys.name)
print(wangys.age)
print(wangys.sex)

二  类成员

• 变量(字段)
• 方法
• 属性

2.1  变量

变量又可以称之为字段,有实例变量(字段),类变量(静态字段)两大类,同时每大类又有私有变量

2.1.1 实例变量

class Persion:

    def __init__(self,name,age):
        self.name = name # 实例变量
        self.age = age      # 实例变量

    def info(self):
        print(self.name,self.age) 

wangys = Persion('wangys',18) 
print(wangys.name,wangys.age) #对象在外部调用实例变量
wangys.info() # 对象通过方法在内部调用实例变量

2.1.2 实例的私有变量

class Persion:

    def __init__(self,name,age):
        self.name = name # 实例变量
        self.__age = age   # 实例的私有变量

    def info(self):
        print(self.name,self.__age)

wangys = Persion('wangys',18)
print(wangys.name,wangys.__age) # 在外部直接调用会报错
wangys.info()  # 可以在类内部通过方法调用私有变量

2.1.3 类变量

class Persion:
    country = 'China'    # 类变量(静态字段)

    def __init__(self,name,age):
        self.name = name  # 实例变量
        self.age = age        # 实例变量

wangys = Persion('wangys',18)  
print(wangys.name,wangys.age)  # 实例变量由实例进行调用
print(Persion.country)    # 类变量(静态字段)推荐使用类直接调用

2.1.4 类私有变量

class Persion:
    __country = 'China'   # 类私有变量

    def __init__(self,name,age):
        self.name = name # 实例变量
        self.age = age      # 实例变量
    def info(self):
        print(Persion.__country)

wangys = Persion('wangys',18)
print(wangys.name,wangys.age) # 实例调用实例变量
print(Persion.__country)  # 外部调用类私有变量报错
print(wangys.info())  # 内部调用类的私有变量可以正常调用

2.3 方法

2.3.1  实例方法

class Persion:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def info(self):  # 实例方法,调用了封装的实例变量
        print(self.name,self.age)

wangys = Persion('wangys',18)
wangys.info()

2.3.2   静态方法

class Person:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def info(self): # 实例方法
        print(self.name,self.age)

    @staticmethod
    def func(a,b):  # 静态方法(没有调用封装在对象种的字段)
        return a+b

wangys = Person('wangys',18)
Person.func(1,2) # 静态方法通过类调用即可
print(ret)

2.3.3  类方法

class Persion:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def info(self): # 实例方法
        print(self.name,self.age)

    @staticmethod
    def func(a,b): # 静态方法
        return  a + b

    @classmethod
    def func1(cls,c,d): # 类方法
        return  c + d

ret = Persion.func1(1,2)
print(ret)

2.4 属性

当一个方法只需要封装在self的参数,并且功能更像一个属性,而非方法,例如圆的面积,这个面积更像是园的属性

class  Circle:
    def __init__(self,r):
        self.r = r
        
    def area(self):  # 定义一个求面积的方法
        return 3.14*self.r*self.r

c1 = Circle(1)
print(c1.area()) # 查看面积时需要加上小括号,像方法,而不是这个园的属性


class  Circle:
    def __init__(self,r):
        self.r = r
    @property
    def area(self): # 定义属性
        return 3.14*self.r*self.r

c1 = Circle(1)
print(c1.area)  # 直接用点调用即可,更像时园的属性,而非方法

 

 

 

 

命名空间

class Course:
    language = 'Chinese'
    def __init__(self,teacher,name,period,price):
        self.teacher = teacher
        self.name = name
        self.period = period
        self.price = price

print(Course.language)
python = Course('wangys','python','6 months',20000)
print(python.language)

静态属性

• 类的属性和方法可以被类调用，也可以被对象调用
• 类的静态属性当使用类进行修改时，使用字典的方式修改时不允许的，但可以通过 类名.属性=。。。 进行修改
• 通过

类的静态属性可以被类调用，也可以被对象调用

class Course:  
    language = 'Chinese'
    def __init__(self,teacher,name,period,price):
        self.teacher = teacher
        self.name = name
        self.period = period
        self.price = price

print(Course.language) # 类调用
python = Course('wangys','python','6 months',20000)
print(python.language) # 对象调用

# 不论是类调用还是对象调用，都是可以的

类的静态属性当通过类进行修改的时候，只能通过 类命.属性的方式进行修改

class Course:    # 定义了一个课程类
    language = 'chinese'   # 有一个语言静态属性
    def __init__(self,teacher,name,period,price):  # ————init__方法有老师，课程名称，周期，价格等
        self.teacher = teacher
        self.name = name
        self.period = period
        self.price = price

Course.language = 'EN'  # 通过类名.属性方式修改
print(Course.language)
# EN

Course.__dict__['language'] = 'chinese' # 通过字典的方式修改不允许
print(Course.language)
# TypeError: 'mappingproxy' object does not support item assignment

类可以直接修改静态属性，修改后，对象与类都共享修改

class Course:
    language = 'Chinese'
    def __init__(self,teacher,name,period,price):
        self.teacher = teacher
        self.name = name
        self.period = period
        self.price = price

python  = Course('wangys','python','6 months',20000)
linux  = Course('wc','linux','6 months',20000)
print(Course.language)  # 类可以调用
print(python.language)  # 对象可以调用
print(linux.language)     # 对象可以调用
Course.language = 'english'  # 类修改静态属性
print(Course.language)  # 可以看到已经修改
print(python.language)  # 对象共享修改
print(linux.language)     # 对象共享修改


Chinese
Chinese
Chinese
english
english
english

通过对象进行静态属性修改，实际上是在对象的 命名空间里增加了一个变量，并没有改变类命名空间的静态属性，当然其他对象对该静态属性也没有改变、、

class Course:
    language = 'chinese'
    def __init__(self,teacher,name,period,price):
        self.teacher = teacher
        self.name = name
        self.period = period
        self.price = price
    def func(self):
        return self.price

python = Course('eval','python','6 months',20000)
linux = Course('wangys','linux','7 months',10000)
print(Course.language)
print(python.language)
print(linux.language)

python.language = 'english' # 对象修改静态属性
print(python.language)  # 对象的命名空间里有了该名称
print(linux.language) # 其他对象并没有改变
print(Course.language) # 类也一样

# 结论 对于类的不可变的数据类型静态属性，使用类进行操作

# 对于类的可变数据类型静态属性，修改时共享的，重新赋值是独立的

class Course:
    language = ['chinese']
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price

    def func(self):
        pass

python = Course('python','6 months',20000)
linux = Course('linux','6 months',20000)

python.language[0] = 'English'  # 对象对可变数据类型进行修改
print(python.language)  # 对象读取的是修改后的值
print(Course.language) # 类读取的是修改后的值
print(linux.language)  # 其他对象读取的也是修改后的值
python.language=['Chinses']  # 对象重新赋值
print(python.language) # 读取的是修改后的值
print(Course.language)  # 读取的原来的值
print(linux.language)  # 读取的是原来的值


['English']
['English']
['English']
['Chinses']
['English']
['English']

# 如果是修改，会先找到该列表，然后做修改，因为是类静态属性，所以找到的是类的静态属性，然后做的是对类列表的修改，都生效，如果是赋值，会在对象的命名空间重新生成一个对象属性，故该的是对象属性，而不是类的属性，所以类和其他对象没有影响

例子：记录实例化次数

class  Foo:
    count = 0

    def __init__(self):
        Foo.count +=1


f1 = Foo()
print(f1.count)

f2 = Foo()
print(f1.count)

# 1
# 2

绑定方法

def  func():
    pass

class Foo:
    def func(self):
        pass
f1 = Foo()
print(func)
print(Foo.func)
print(f1.func)

<function func at 0x000001A9AEA37048>
<function Foo.func at 0x000001A9B071E1E0>
<bound method Foo.func of <__main__.Foo object at 0x000001A9B071D1D0>> # 绑定方法

# 对象在调用类的方法是，实际上是将self的值传递给方法，两者发生了绑定关系

 

 

 

 

 

类的组合

• 组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合
• 当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好

人狗大战（人使用武器攻击）

# 定义了一个Dog类，有名字，攻击力，血量，种类，并且有咬的技能（方法）
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 # 给人类加了一个weapon属性
            self.aggr += weapon.aggr # 人的攻击力加上武器的攻击力
        else:
            print('余额不足') # 如果钱不够，则报错


# 定义了一个武器类，有名称，攻击力，耐久度，价钱，还有大招hand18
class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price

    def hand18(self,dog):
        if self.njd >0: # 使用大招有限度
            dog.hp -= self.aggr *2 # 血量直接减去武器攻击力的两倍
            self.njd -=1 # 耐久度减去1




w = Weapon('打狗棒',100,3,998) # 实例化一个打狗棒武器
alex = Person('alex',0.5,100,'male') # 实例化一个alex人对象
jin = Dog('金老板',100,500,'teddy') # 实例化一个狗对象
alex.money =1000 # 人的金钱增加，可以买武器
alex.get_weapon(w) # alex获得武器
alex.attack(jin)  # 攻击狗对象
alex.weapon.hand18(jin)  # 使用武器大招攻击
print(jin.hp)

圆环周长及面积

class Circle:

    role = '圆形'

    def __init__(self,radius):
        self.radius = radius

    def perimeter(self):
        return 3.14*2*self.radius

    def area(self):
        return 3.14*(self.radius**2)

c1 = Circle(1)
c2 = Circle(2)
print(c1.perimeter() + c2.perimeter())
print(c2.area() - c1.area())

class Ring():

    name = '圆环'

    def __init__(self,inner_circle_radius,outer_circle_radius):
        self.inner_circle_radius = inner_circle_radius
        self.outer_circle_radius = outer_circle_radius
        self.inner_circle = Circle(inner_circle_radius)
        self.outer_circle = Circle(outer_circle_radius)

    def perimeter(self):
        return  self.inner_circle.perimeter() + self.outer_circle.perimeter()

    def area(self):
        return self.outer_circle.area() - self.inner_circle.area()


r1 = Ring(1,2)
print(r1.perimeter())
print(r1.area())

教授有生日，有教授课程

教授一个类，生日一个类，课程一个类，教授可以有生日，可以教授课程

class Brith_date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day


class Course:
    def __init__(self,course_name,course_period,course_price):
        self.course_name = course_name
        self.course_period = course_period
        self.course_price = course_price

class Teacher:
    def __init__(self,name,age,brith,course):
        self.name = name
        self.age = age
        self.brith = brith
        self.course = course
    def teaching(self):
        print('teaching')

t1 = Teacher('wangys',18,Brith_date('2000','10','19'),Course('Python','6 months',20000))
print(t1.course.course_name)
print(t1.brith.year)