作业

#对象的耦合
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. 排座椅(洛谷P1056)

    题目描述 上课的时候总会有一些同学和前后左右的人交头接耳,这是令小学班主任十分头疼的一件事情.不过,班主任小雪发现了一些有趣的现象,当同学们的座次确定下来之后,只有有限的D对同学上课时会交头接耳. 同 ...

  2. python-flask-wtforms

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...

  3. Leetcode 5016. 删除最外层的括号

    5016. 删除最外层的括号  显示英文描述 我的提交返回竞赛   用户通过次数446 用户尝试次数469 通过次数456 提交次数577 题目难度Easy 有效括号字符串为空 ("&quo ...

  4. UI基础六:UI报弹窗确认

    数据检查部分: IF gv_zzzcustmodeno1 <> gv_zzzcustmodeno2 AND gv_plg_name NE 'YES'. lv_title = 'Confir ...

  5. hibernate建表默认为UTF-8编码

    一.问题: hibernate自动建表的编码应该是数据默认的编码格式,一般也不是utf-8.所以想要建表默认的编码是UTF-8,应该怎么做呢? 二.解决方法: 拿mysql举例: (一).修改hibe ...

  6. CAD插入块后坐标不匹配

    有两张图,将一张图复制(CTRL+V),再另一张图中粘贴到原坐标(pasteorig),两张图可以很好匹配,但将一张图以外部参照的方式插入另一张图却发现图形无法匹配.因为没有看到图纸,所以我也没法准确 ...

  7. MSSQL内存架构及管理

    1.  MSSQL内存架构 相比较Oracle,MSSQL的内存区域并没那么清晰,但和Oracle类似,MSSQL内存区域大体也可以分为三个部分:buffer pool,query/workspace ...

  8. 把旧系统迁移到.Net Core 2.0 日记(1) - Startup.cs 解析

    因为自己到开发电脑转到Mac Air,之前的Webform/MVC应用在Mac 跑不起来,而且.Net Core 2.0 已经比较稳定了. 1. 为什么会有跨平台的.Net Core  近年来,我们已 ...

  9. vue cli搭建的vue项目 不小心开了eslint 一直报黄色的警告

    报错必须处理,警告也忍不了,发现在bulid -webpack.base.config.js 里找到 const createLintingRule = () => ({ /*test: /\. ...

  10. Spring Boot整合@Scheduled定时计划

    原文地址:https://blog.csdn.net/justry_deng/article/details/80666508 修改部分: SpringBoot集成了@Scheduled的相关依赖(o ...