作业

#对象的耦合
class Circle:
   def __init__(self,r):
       self.r = r
   def area(self):
       return 3.14*self.r**2

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

   def r2(self):
       return self.r*2

class Square:
   def __init__(self,side):
       self.side = side

   def perimeter(self):
       return 4*self.side

   def area(self):
       return self.side*self.side

几十个函数

  1. 去查看和圆形相关的方法是需要一定时间找到对应方法的
  2. 不管求圆形周长还是面积,都需要传参数r
  3. 所有的函数都是求周长和面积,导致给函数起名字的时候总是要带着图形

面向对象

  1. 规划了代码中的函数处理的是哪一类问题
  2. 解决了传参数的问题
  3. 方便扩展
  4. 方便重用

类 :有相同特征的事物归为一类

对象、实例 :类的具体化

实例化 :通过类创造一个对象的过程

  • 对象 = 类名(参数,参数)

    1. 开辟一块内存空间,让self指向它
    2. 调用__init__方法,执行init
    3. 把self返回给调用者
  • 类当中有哪些成员
    1. 静态变量
    2. 动态变量,对象方法
  • 对象可以存哪些方法
    1. 所有的对象属性都在对象里
  • 类名能做什么
    1. 查看静态变量
    2. 实例化对象
  • 对象名能做什么
    1. 属性的增删改查
    2. 方法的调用

定义类

class 类名:
    静态变量 = 1000
    def __init__(self,arg1,arg2):
        if arg1<=arg2:
            self.arg1 = arg1
            self.arg2 = arg2
        else:
            self.arg1 = arg2
            self.arg2 = arg1
    def 其他方法(self):
        print('其他方法往往是类名对应的对象所做的动作、行为')
        print('往往还会用到self内部的一些变量')

对象1 = 类名(1,2)
对象2 = 类名(3,4)

类的加载顺序

class A:
    country = 'China'
    print(country)
    def __init__(self):
        print('执行我了')

A.country = 'English'······························
类的加载顺序
   # 1.类内部一个缩进的所有代码都是在py文件从上到下解释的时候就已经被执行了
   # 2.类中的代码永远是从上到下依次执行的
class A:
    country = 'China'
    def __init__(self):
        print('执行我了')

    def func(self):
        print('1111111')

    def func(self):
        print('2222222')
A.country = 'English'
a = A()
a.func()
class A:
    country = 'China'
    country = 'English'
    def __init__(self):
        print('执行我了')

    def func(self):
        print('1111111')

    def func(self):
        print('2222222')
A.country = 'English'
a = A()
a.func()
print(A.country)
class A:
    def __init__(self):
        print('执行我了')

    def func(self):
        print('1111111')

    def func(self):
        print('2222222',A.country)

    country = 'China'
    country = 'English'

a = A()
a.func()
A().func()

类的加载顺序

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

类和对象的命名空间

class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    a = 1
    b = 2
    def func(self):
        pass

yang = Student('杨鹏',20,'male')

类 和 对象 存储在两块命名空间里的

class Student:
    country = 'China'
    def __init__(self,name,country):
        self.name = name
        self.country = country

zhang = Student('张尧','日本人')
zou = Student('邹路','法国人')
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)
zhang.country = '日本人'   # 给一个对象添加了一个属性
print(zou.country)
print(zhang.country)

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

#人物
class Person:
    money = 0
    def __init__(self,name):
        self.name = name

    def salary_deliery(self):
        Person.money += 1000
#爸爸妈妈

练习 :写一个类,能够自动的统计这个类有多少个对象

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

a = A('alex')   # 创建了一个新对象
a2 = A('alex2')
print(A.Count)

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

a = A('alex')   # 创建了一个新对象
a2 = A('alex2')
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
print(b2.l[0])
b1.l = [123]
print(b2.l)
  1. 只要是对一个对象.名字直接赋值,那么就是在这个对象的空间内创建了新的属性
  2. 只要是对一个可变的数据类型内部的变化,那么仍然是所有的对象和类共享这个改变的成果
  3. 所有的静态变量都是用类名来操作,这样修改就能被所有的对象感知到
  4. 如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容,也可以使用对象来调用

组合

#圆形类
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*3.14*self.r

# 圆环类
class Ring:
    def __init__(self,r1,r2):
        if r1>=r2:
            self.outer = r1
            self.inner = r2
        else:
            self.inner = r1
            self.outer = r2

    def area(self):
        return 3.14 * self.outer ** 2 - 3.14 * self.inner ** 2

    def perimeter(self):
        return 2 * 3.14 * self.outer + 2 * 3.14 * self.inner

# 圆柱类
class C3d:
    def __init__(self,r,h):
        self.r = r
        self.h = h

    def area(self):
        c_area = 3.14 * self.r**2
        rec_area = 2 * 3.14 *self.r * self.h
        return c_area*2 + rec_area

    def vic(self):
        c_area = 3.14 * self.r ** 2
        return c_area*self.h

耦合

紧耦合

# 圆形面积的公式和类中方法

from math import pi
class Circle:
   def __init__(self,r):
       self.r = r

   def area(self):
       return pi*self.r**2

   def perimeter(self):
       return 2*pi*self.r

圆环类
class Ring:
   def __init__(self,r1,r2):
       c1 = Circle(r1)
       c2 = Circle(r2)
       if r1>=r2:
           self.outer = c1       # 组合
           # self.outer.area()   # c1.area()
           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()

#圆柱类
class C3d:
    def __init__(self,r,h):
        self.c = Circle(r)     # 组合
        self.h = h

    def area(self):
        c_area = self.c.area()
        rec_area = self.c.perimeter() * self.h
        return c_area*2 + rec_area

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

组合

  1. 一个类的对象是另一个类对象的属性
  2. 圆形类的对象 是圆环类对象的outer属性的值
  3. 计算圆形相关数据的公式只和Circle类在一起
  4. 其余的用到公式的地方都是通过circle类来使用的
  5. 公式与其他类之间的关系是一个“松耦合”关系

学生类

  1. 出生日期
  2. 入学日期
  3. 开学日期
    • 日期的粒度 精确到年月日
    • 一个日期可不可以是一个类
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     # 组合
        self.in_school = in_shcool # 组合
        self.start_day = start_day # 组合

d1 = Date(1999,10,27)
d2 = Date(2019,1,9)
d3 = Date(2019,2,9)
feng = Student('冯磊',10086,d1,d2,d3)
print(feng.birth.year)
print(feng.birth.month)
print(feng.birth.day)
print(feng.birth.date())

feng.start_day.month +=1
print(feng.start_day.date())

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__)
python.price = 30000
python.period = '7 months'

人狗大战

class Person:
   def  __init__(self,name,hp,ad,sex):
       self.name = name
       self.hp = hp
       self.ad = ad
       self.sex = sex
       self.money = 2000000.8
       self.beg = []

   def attack(self,dog):
       dog.hp -= 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 weap in self.beg:
           if weap.t == 'weapon':
               self.weapon = weap    # 组合
               self.hp += weap.hp
               self.ad += weap.ad
               break

class Dog:
   def  __init__(self,name,hp,ad,kind):
       self.name = name
       self.hp = hp
       self.ad = ad
       self.kind = kind

   def bite(self,person):
       person.hp -= self.ad
       print('%s咬了%s,%s掉了%s点血'%(self.name,person.name,person.name,self.ad))

回合制的游戏
alex = Person('alex',10,0.5,'待定')
hei = Dog('小黑',3000,20,'藏獒')
装备
   # 名字
   # 价格
   # 属性
   # 技能

class weapon:
   t = 'weapon'
   def __init__(self,name,price,ad,hp):
       self.name = name
       self.price = price
       self.ad = ad
       self.hp = hp

   def throw(self,dog):
       dog.hp -= 2000
       print('%s被搬砖扔中了,掉了2000点血,当前%s的血量为%s'%(dog.name,dog.name,dog.hp))

zhuan = weapon('搬砖',2000000,1000,100)
买装备
人的余额 > 商品的价格

绑定装备

alex.buy_weapon(zhuan)
print(alex.beg)
alex.use_weapon()
print(alex.weapon.name)
print(alex.__dict__)

alex.weapon.throw(hei)

一个对象 和 另外一个对象通过一个属性 关联在一起了
人有武器
人是一个类
武器也是一个类
人关联武器
人用武器使用招式

总结
类的加载顺序
类和对象的命名空间
组合
   # 两个类 一个类的对象是另一个类对象的属性
   # 图形 圆形和圆环和圆柱
   # 学生和日期
   # 学生和课程

默写 学生和课程
把课上的例子都过一遍
继续完成人狗大战
   # 注册 用户名
   # 充值
   # 买武器
   # 装备武器
   # 和狗开战

堆栈和递归

数据结构 栈
数据结构 队列

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()

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

三级菜单

menu = {
   '北京': {
       '海淀': {
           '五道口': {
               'soho': {},
               '网易': {},
               'google': {}
           },
           '中关村': {
               '爱奇艺': {},
               '汽车之家': {},
               'youku': {},
           },
           '上地': {
               '百度': {},
           },
       },
       '昌平': {
           '沙河': {
               '老男孩': {},
               '北航': {},
           },
           '天通苑': {},
           '回龙观': {},
       },
       '朝阳': {},
       '东城': {},
   },
   '上海': {
       '闵行': {
           "人民广场": {
               '炸鸡店': {}
           }
       },
       '闸北': {
           '火车战': {
               '携程': {}
           }
       },
       '浦东': {},
   },
   '山东': {},
}
l = [menu]
while l:
    for k in l[-1]:
        print(k)
    key = input('>>>')
    if key.upper() == 'B':
        l.pop()
    elif key.upper() == 'Q':
        l.clear()
    elif l[-1].get(key):
        l.append(l[-1][key])

计算文件夹大小的例子
D:\s20\
D:\s20\day16
D:\s20\day16\day16

import os
def get_size(path):
   size = 0
   l = [path]
   while l:
       path = l.pop()
       lst = os.listdir(path)
       for name in lst:
           son_path = os.path.join(path,name)
           if os.path.isfile(son_path):
               size += os.path.getsize(son_path)
           else:
               l.append(son_path)
   return size

size = get_size(r'D:\s14\算法')
print(size)

2019-03-26-day019-面向对象耦合与组合的更多相关文章

  1. zabbix学习笔记----安装----2019.03.26

    1.zabbix官方yum源地址:repo.zabbix.com 2.安装zabbix server zabbix server使用mysql作为数据库,在zabbix 3.X版本,安装zabbix- ...

  2. 2019.03.26 bzoj4448: [Scoi2015]情报传递(归并排序+树链剖分)

    传送门 题意简述: 给一棵nnn个点的树,树上每个点表示一个情报员,一共有mmm天,每天会派发以下两种任务中的一个任务: 1.搜集情报:指派T号情报员搜集情报 2.传递情报:将一条情报从X号情报员传递 ...

  3. 2019.03.26 bzoj4446: [Scoi2015]小凸玩密室(树形dp)

    传送门 题意简述: 给一棵完全二叉树,有点权aia_iai​和边权,每个点有一盏灯,现在要按一定要求点亮: 任意时刻点亮的灯泡必须连通 点亮一个灯泡后必须先点亮其子树 费用计算如下:点第一盏灯不要花费 ...

  4. 2019.03.26 bzoj4444: [Scoi2015]国旗计划(线段树+倍增)

    传送门 题意简述:现在给你一个长度为mmm的环,有nnn条互不包含的线段,问如果强制选第iii条线段至少需要用几条线段覆盖这个环,注意用来的覆盖的线段应该相交,即[1,3],[4,5][1,3],[4 ...

  5. 2019.03.26 bzoj4447: [Scoi2015]小凸解密码(线段树)

    传送门 题意简述:咕咕咕 思路:考虑预处理出bbb数组,然后每次改动aaa都只会对第iii和i+1i+1i+1这两个位置产生影响,于是可以用线段树来维护bbb数组. 现在求答案的方法是断环为链,倍增整 ...

  6. 2019.03.26 读书笔记 关于for与foreach

    for 是索引器,foreach是迭代器 foreach在movenext()中增加了对集合版本(一个整数,每次对集合修改都+1)的验证,另外反编译后的效果是使用了using(是try finally ...

  7. 2019.03.26 读书笔记 关于event

    event 主要是给委托加了一层保护,不能任意的 class.delegate=null,class.delegate=fun1,不能由调用者去任意支配,而是由class自己去增加或减少,用+=.-= ...

  8. 2019.03.26 读书笔记 关于 invoke与begininvoke

    invoke与begininvoke是同步委托和异步委托,但是有两种使用情况: 1. control中的invoke.begininvoke. 2. delegrate中的invoke.beginin ...

  9. [2019.03.25]Linux中的查找

    TMUX天下第一 全世界所有用CLI Linux的人都应该用TMUX,我爱它! ======================== 以下是正文 ======================== Linu ...

  10. 2019.03.03 - Linux搭建go语言交叉环境

    编译GO 1.6版本以上的需要依赖GO 1.4版本的二进制,并且需要把GOROOT_BOOTSTRAP的路径设置为1.4版本GO的根目录,这样它的bin目录就可以直接使用到1.4版本的GO 搭建go语 ...

随机推荐

  1. leetcode-algorithms-22 Generate Parentheses

    leetcode-algorithms-22 Generate Parentheses Given n pairs of parentheses, write a function to genera ...

  2. CF-877E-线段树+哈希

    http://codeforces.com/problemset/problem/877/E 给出一颗有根树,没个节点上有一个值0/1,有两种操作,一个是选中一个节点,对他所对应的那个子树上所有节点的 ...

  3. docker容器扫盲

    Centos 6.5 安装和使用docker 基于本人一贯的习惯,关于“某某某是什么”这样的问题,请百度吧,会有更专业的人士,会比我说的更详细更深,这里我只给出本人亲历的安装和使用过程. 1.安装 先 ...

  4. 最佳加法表达式(dp)

    题目描述: 有一个由1..9组成的数字串.问如果将m个加 号插入到这个数字串中,在各种可能形成的 表达式中,值最小的那个表达式的值是多少 (本题只能用于整数) 解题思路: 假定数字串长度是n,添完加号 ...

  5. POJ 2243 Knight Moves(BFS)

    POJ 2243 Knight Moves A friend of you is doing research on the Traveling Knight Problem (TKP) where ...

  6. ID基本操作(新建文档,页面编码)5.8

    “文件”“新建”“文档”选择页数,页面大小.页面方向,“边距和分栏”设置上下左右的边距,栏数,如三栏 还可以改变分栏距离·改变排版方向,如图,垂直 单击“页面”可以查看我们的页面情况 超过两页会可以看 ...

  7. 尚学堂java 参考答案 第七章

    本答案为本人个人编辑,仅供参考,如果读者发现,请私信本人或在下方评论,提醒本人修改 一.选择题 1.ACD 解析:B:java中左边不能直接直接指定长度,和C语言不一样 2.B 3.C 解析:B各行分 ...

  8. Uva LV 2995 Image Is Everything 模拟,坐标映射,视图映射 难度: 1

    题目 https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_pr ...

  9. 总结5条对学习Linux系统有帮助的经验心得

    作为国产手机中的代表厂商,OPPO一直走在国内的前沿.不仅手机出货量在国内遥遥领先,而且在国外也抢占不少的市场份额.前段时间,OPPO在台湾地区签下田馥甄和林宥嘉担任OPPO R9s的代言人外,在东南 ...

  10. ural1519

    题解: 插头dp 具体可以看看cdq论文 代码: #include<bits/stdc++.h> using namespace std; typedef long long ll; ; ...