作业

#对象的耦合
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

几十个函数

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

面向对象

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

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

对象、实例：类的具体化

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

对象 = 类名(参数，参数)
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()

类的加载顺序

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

类和对象的命名空间

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)

只要是对一个对象.名字直接赋值，那么就是在这个对象的空间内创建了新的属性
只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果
所有的静态变量都是用类名来操作，这样修改就能被所有的对象感知到
如果是对于可变数据类型的静态变量操作的是这个数据内部的内容，也可以使用对象来调用

组合

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

组合

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

学生类

出生日期
入学日期
开学日期
- 日期的粒度精确到年月日
- 一个日期可不可以是一个类

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-面向对象耦合与组合

作业

几十个函数

面向对象

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

对象、实例：类的具体化

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

定义类

类的加载顺序

类的加载顺序

类和对象的命名空间

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

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

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

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

组合

耦合

紧耦合

组合

学生类

人狗大战

堆栈和递归

三级菜单

相关文章

2019-03-26-day019-面向对象耦合与组合

作业

几十个函数

面向对象

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

对象、实例 ：类的具体化

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

定义类

类的加载顺序

类的加载顺序

类和对象的命名空间

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

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

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

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

组合

耦合

紧耦合

组合

学生类

人狗大战

堆栈和递归

三级菜单

相关文章

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

对象、实例：类的具体化

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

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

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