初识面向对象 -类和对象命名空间、组合用法（学习笔记二）

类和对象命名空间

# 类里 可以定义两种属性
# 静态属性
# 动态属性
class Course:
language = [‘Chinese‘]
def __init__(self,teacher,course_name,period,price):
self.teacher = teacher
self.name = course_name
self.period = period
self.price = price
def func(self):
pass

# Course.language = ‘English‘
# Course.__dict__[‘language‘] = ‘Chinese‘
# print(Course.language)
python = Course(‘egon‘,‘python‘,‘6 months‘,20000)
linux = Course(‘oldboy‘,‘linux‘,‘6 months‘,20000)
#[‘chinese‘]
python.language = ‘‘
# print(python.language)
# print(linux.language)
# Course.language = ‘Chinese‘
# print(python.language)
# print(linux.language)

# del python.language
# print(python.language)
# print(python.__dict__)
# print(Course.language)
# print(linux.language)
# print(linux.__dict__)
# 类中的静态变量 可以被对象和类调用
# 对于不可变数据类型来说，类变量最好用类名操作
# 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

# 模拟人生
# class Person:
# money = 0
# def work(self):
# Person.money += 1000
#
# mother = Person()
# father = Person()
# Person.money += 1000
# Person.money += 1000
# print(Person.money)
# mother.work()
# father.work()

# 创建一个类，每实例化一个对象就计数
# 最终所有的对象共享这个数据
# 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)

# 认识绑定方法
# def func():pass
# print(func)
#
# 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>

# 包 —— __init__
# import package —— 类的实例化的过程
# import time
# time.time()

# 类里的名字有 类变量（静态属性量）+ 方法名（动态属性）
# 对象里的名字 对象属性
# 对象 —— > 类
# 对象找名字 ： 先找自己的 找类的 再找不到就报错
# 对象修改静态属性的值
# 对于不可变数据类型来说，类变量最好用类名操作
# 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

组合的用法

# 面向对象的三大特性 ： 继承 多态 封装
# 组合
# 人狗大战
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)

# 组合 ：一个对象的属性值是另外一个类的对象
# alex.weapon 是 Weapon类的对象

组合练习

# 圆形类
# 圆环类
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())

# 创建一个老师类
# 老师有生日
# 生日也可以是一个类
# 组合
class Birthday:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day

class Course:
def __init__(self,course_name,period,price):
self.name = course_name
self.period = period
self.price = price

class Teacher:
def __init__(self,name,age,sex,birthday):
self.name = name
self.age = age
self.sex = sex
self.birthday =birthday
self.course = Course(‘python‘,‘6 month‘,2000)

b = Birthday(2018,1,16)
egg = Teacher(‘egon‘,0,‘女‘,b)
print(egg.name)
print(egg.birthday.year)
print(egg.birthday.month)
print(egg.course.price)

初识面向对象 -类和对象命名空间、组合用法（学习笔记二）

原文：https://www.cnblogs.com/mys6/p/10588814.html