python学习 day19 (3月26日)----(对象组合）

深谙：非常透彻地了解；熟悉内中情形。谙，读作‘ān’ 熟悉。

1.面向对象作用：
规划了代码中的函数处理的是哪一类问题
解决了传参的问题
方便扩展
方便重用

2.类的定义和使用
类当中有哪些成员
 '''
 静态变量
 动态变量，对象方法
'''

类： 有相同特征的事物归为一类
对象、实例： 类的具体化
实例化： 通过类创造一个对象的过程
    对象 = 类名（参数，对象）
'''
1， 开辟一块内存空间，让self指向他
2，调用__init__方法，执行init
3，把self 返回给调用者 
'''

'''
对象可以存哪些方法
    #所有的对象属性都在对象里
类名能做什么
    #查看静态变量
    #实例化对象
对象名能做什么
    #属性的增删改查
    #方法的调用
'''

3类的加载顺序
    #1. 类内部一个缩进的所有代码 都是在py文件从上到下开始解释的时候就已经被执行了
    #2. 类中的代码 永远是 从上到下依次执行的

class A:
    print(123)
    def __init__(self):
        print('执行我啦！')
    def func(self):
        print('adjia')
    def func(self):
        print('adj',A.country)
    country = 'China'
    country = 'Chi'
'''
执行第一层缩进       #123
a = A() #执行我啦！
a.func()    #adj Chi  从上往下执行 和变量一样
'''

4.类的命名空间
类和对象中的内容是分两片存储的
 　　对象 里的指针可以用 类里的函数  正常使用静态的变量

class Student:
    country = 'China'
    def __init__(self,name,country):
        self.name = name
        self.country = country
zhang = Student('刘大','中国')
zou = Student('王二','China')
print(Student.country)
print(zou.country)
print(zhang.country)

　　对象去找类空间中的名字  的前提：在自己的空间中没有这个名字

class Student:
    country = 'China'
    def __init__(self,name):
        self.name = name
zhang = Student('刘大')
zou = Student('王二')
print(zhang.country)
Student.country = '法国人'
print(zhang.country)
zou.country = '日本人'
print(zou.country)

　　所以，在操作 静态变量的时候 应该尽量使用类名来操作而不是使用对象名

　　比如：用类 和 用self 的区别是什么？

class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        Person.money += 1000
        return Person.money
a = Person('刘大').salary_deliery()
print(a)

练习：

class A:
    Count = 0
    def __init__(self,name,age,sex):
        self.name = name
        A.Count += 1
        self.age = age
        A.Count += 1
        self.sex = sex
        A.Count += 1

a = A('刘大','王二','张三')
print(A.Count)

赋值和使用变量

class A:
    Count = 0
    def __init__(self,name,age,sex):
        self.name = name
        A.Count += 1
        self.age = age
        A.Count += 1
        self.sex = sex
        A.Count += 1
a = A('刘大','王二','张三')
print(A.Count)
class B:
    l = [0]
    def __init__(self,name):
        self.name = name
b1 = B('刘大')
b2 = B('王二')
print(B.l)
print(b1.l)
print(b2.l)
b1.l[0]+=1  #赋值  1
print(b2.l[0])
b1.l = [123]
print(b2.l[0])  #1
print(b1.l[0])  #123

# 只要是对一个对象 ，名字直接赋值，那么就是在这个对象的空间内创建了新的属性
# 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果

#所有的静态变量都是用类名来操作 ，这样修改就能被所有的对象感知到
#如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用
#对象 和 类名 是一样的  静态变量最好是可变的

区别在哪？

class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        Person.money += 1000
        return Person.money
a = Person('刘大').salary_deliery()
print(a) #1000
class Person:
    money = 0
    def __init__(self,name):
        self.name = name
    def salary_deliery(self):
        self.money += 1000
        return self.money
a = Person('刘大').salary_deliery()
print(a) #1000

 5.组合

　　圆类

from math import pi
#圆类
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return 3.14*self.r**2
    def perimeter(self):
        return 2*self.r*3.14
#圆环类
class Ring:
    def __init__(self,r1,r2):  # 属性 和 对象 相对应了
        c1 = Circle(r1)
        c2 = Circle(r2)
        if c1.r > c2.r:
           self.outer = c1      # 组合
           self.inner = c2
        else:
            self.inner = c1
            self.outer = c2
    def area(self):
        return self.outer.area() - self.inner.area()
    def perimeter(self):
        return self.outer.perimeter() + self.inner.perimeter()
# 圆柱类
# a = Circle(2)
# print(a.area())
a = Ring(12,3)
print(a.area())
print(a.perimeter())
class C3d:
    def __init__(self,r,h):
        self.r = r
        self.h = h
        c1 = Circle(r)
        self.area = c1
    def area(self):
        c_area = self.area.area()
        rec_area = self.area.perimeter() *self.h
        return c_area*2 + rec_area

    def vic(self):
        c_area = self.area.area()
        return c_area*self.h

''' 
#耦合
# 紧耦合
    #圆形面积的公式 和 类中方法
#组合：
    #一个类的对象是另一个类对象的属性
    #圆形类的对象  是圆环类对象的outer 属性的值

# 计算圆形 相关数据的公式 只和Circle 类在一起
#其余的 用到 公式的地方都是通过Circle 类来使用的
# 公式与 其他类之间的关系 是一个“松耦合”关系
'''

学生类

　　　　利用的Date 的类 　　作为参数　　传给另一个类的对象

#学生类
# 入学日期
# 开学日期
    #日期的粒度  精确到年月日

# "2019-9-12"
# 年
# 月
# 日
class Date:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
    def date(self):
        return '%s-%s-%s'%(self.year,self.month,self.day)
class Student:
    def __init__(self,name,num,birth,in_shcool,start_day):
        self.name = name
        self.num = num
        self.birth = birth           #组合  开始 后面都是  组合 用的class date
        self.in_school = in_shcool   
        self.start_day= start_day
d1 = Date(2000,1,1)
d2 = Date(2018,12,1)
d3 = Date(2019,2,1)
liu = Student('刘大',10086,d1,d2,d3)
print(liu.birth.year)
print(liu.birth.month)

这种不行 只是单纯的赋值 没有改变 具体课程的元素

class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course_name = course.name #没有把python 耦合在一起 只把 课程弄在一起

类似例子

　　　　写两个类 一个是 课程类 : （写上变量）  name , price ,period

　　　　 一个是学生类     name , num  , 课程（传过来）   

　　　　课程= Course（三个变量）    

　　　　学生 = Student（两个变量，课程）

class Student:
    def __init__(self,name,num,course):
        self.name = name
        self.num = num
        self.course = course
class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
python = Course('python',25000,'6 months')
s1 = Student('任世龙',10085,python)
s2 = Student('任希同',10084,python)
s3 = Student('董鹏',10083,python)
print(s1.__dict__)
print(s1.course.price)
python.price = 30000
python.period = '7 months'

s3 = Student('董鹏',10083,python)
print(s3.__dict__.values())  # 就学生的那三个属性
print(s1.course.__dict__)   # 课程的三个属性

6. 人狗大战

#__author : 'liuyang' 
#date : 2019/3/26 0026 下午 12:03
class Dog:
    a = 1000
    def __init__(self,name,hp,ad,sex):
        self.name = name
        self.blood = hp
        self.ad = ad
        self.type = sex
    def bite(self,person):
        person.blood -= self.ad
        print('%s 咬了 %s,%s 掉了 %s血'%(self.name,person.name,person.name,self.ad))
class Person:
    a = 1000
    def __init__(self,name,hp,ad,sex,money):
        print('执行了')
        print(name,hp,ad,sex)
        self.name = name
        self.hp = hp
        self.ad = ad
        self.type = sex
        self.money = money
        self.beg = []
    def jian23(self,dog):
        dog.hp  -= 2000
        #想怎么设计就怎么设计
        print("%s 被 %s 击中了，掉了2000，当前%s的血量为%s"%(self.name,dog.name,dog.name,dog.hp))
    def fight(self,dog): #定义在类的内部的 动态变量 方法
        dog.blood -= self.ad
        print('%s 打了 %s , %s 掉了 %s血'%(self.name,dog.name,dog.name,self.ad))
    def buy_weapon(self,weapon):
        #武器列表    #死亡之舞
        if weapon.price < self.money:
            self.money -= weapon.price
            self.money = round(self.money, 2)
            self.beg.append(weapon)
            print('购买%s成功,您当前的余额是%s'%(weapon.name, self.money))
        else:
            print('您的余额不足，请重置后恢复')
    def use_weapon(self):
        # for wea in self.beg:
        #     print(wea)
        return self.beg
            # if wea == 'weapon':
            #     self.weapon = wea   #组合
            #     self.hp += wea.hp
            #     self.ad += wea.ad
            #     break
    #level 1
# 回合制的游戏
class weapon:
# 装备
    # 名字
    # 价格
    # 属性
    # 技能
    def __init__(self,name,price,ad,hp):
        self.name = name
        self.price = price
        self.ad = ad
        self.hp = hp
# 买装备
#人的余额 >= 商品的价格
    #能否命中 暴击
liuda = Person('liuda',100,1,'男',20000000)
huang = Dog('huang',1000,10,'公')
zhuan = weapon('绝世好剑',2000000,1000,1000)
liuda.buy_weapon(zhuan)
print(liuda.use_weapon())
# print(liuda.beg)
# liuda.use_weapon()
# print(liuda.use_weapon())
# print(liuda.weapon.name)
# 一个对象 和另一个对象 通过另一个属性 关联在一起了
#人有 武器
#人是 一个 类
#武器 也是 类
#人 关联 武器
#人用武器招式
#总结
#类的加载顺序
#类的对象的命名空间

7.堆栈

# 数据结构 栈
# 数据结构 队列

# list dict tuple set str
# c ：数组 链表 结构体
# 树 堆 栈 队列
# 树
    # 平衡树 二叉树 红黑树
# 堆
    # 最大值堆 最小值堆
    # 堆排序
# 栈
    # 后进先出 LIFO
# 队列
    # 先进先出 FIFO

import queue
# q = queue.Queue(3)
# print(q.qsize())
# print(q.empty())
# print(q.full())
# q.put(1)
# q.put('ancdf')
# q.put([1,2,3])
# print('已经放了3个')
# q.put([1,2,3])
# print('已经放了4个')
# print(q)
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())

# 有一个服务
# 火车票购票服务

# 后进先出
# import queue
# lifoq = queue.LifoQueue()
# lifoq.put(1)
# lifoq.put(2)
# lifoq.put(3)
# lifoq.put(4)
# lifoq.put(5)
# print(lifoq.get())
# print(lifoq.get())

# def func2():
#     print('345')
#
# def func1():
#     func2()
#     print('234')
#
# def main():
#     func1()
#     print('123')
#
# main()

# 栈 在底层的数据结构 再很多算法中 解决问题的时候必须用到这种数据结构

老师说： 8k  10k  15k靠技术  25k 靠态度