Day 023 面向对象命名空间:组合

01 今日内容大纲

面向对象相关
- 组合
- 命名空间和内存

02 昨日内容回顾

面向对象
- 类
  - 具有相同属性和相似功能的一类事物(一个大的范围,一个模子,抽象)
  - ..............................................
  - 你可以清楚的知道这一类事物有什么属性,有什么动作
  - 但是你不能知道这些属性具体的值
- 对象 == 实例
  - 给类中所有的属性,填上具体的值,就是一个对象或者实例
  - 只有一个类,但是可以有多个对象都是这个类的对象
- 实例/实例化(过程)
  - 实例 =类()
  - 首先开辟空间,调用init方法,将开辟的空间地址,传递给self参数
  - init方法中一般完成:把属性的值存储在self的空间里----对象的初始化
  - self这个地址会作为返回值,返回给实例
- 方法
  - 定义在类里的函数,并且还带有self参数
- 实例变量
  - self.名字

03 今日内容

类
- 这个类有什么属性,用什么方法,大致的样子
- 不能知道具体属性对应的值

对象

之前所有的属性值就都明确了

a = 10
b = 12.5
l = [1,2,3]
d = {'k':'v'}
#类型:int float str dict tuple set -- 类(内置的数据类型,内置的类)
#变量名 = xx数据类型的对象

o = 函数名
q = 迭代器
u = 生成器
c = 装饰器
i = 类名

python 中一切皆对象,对象的类型就是类
```
class A:pass
a = A()
print(type(a))
#<class '__main__.A'>

b = 1
print(type(b))
#b = 1
print(type(b))
```
- 所有对象都有一个类型,classA实例化出来的对象的类型就是A类
- 123的类型是int/float
- 'ajksdka'的类型是str
- {}的类型是dict
- alex = Person()的类型就是Person
- 小白 = Dog()的类型就是Dog

命名空间问题

类的成员和名称空间

类的成员和命名空间
class A:
    Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    def __init__(self,name,age):  # 绑定方法 存储在类的命名空间里的
        self.name = name
        self.age = age
    def func1(self):
        print(self)
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass
    def func5(self):pass

a = A('alex',83)
print(a.name)
print(a.Country)

print(A.Country)
a.func1() # == A.func1(a)

class A:
    Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
        self.name = name
        self.age = age
        self.Country = country
    def func1(self):
        print(self)
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass
    def func5(self):pass

a = A('alex',83,'印度')
print(a.name)
print(a.Country)
print(A.Country)

class A:
    Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
        self.name = name
        self.age = age
        self.country = country
    def func1(self):
        print(self)
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass
    def func5(self):pass

a = A('alex',83,'印度')
b = A('wusir',74,'泰国人')
a.Country = '日本人'
print(a.Country)
print(b.Country)
print(A.Country)

class A:
    Country = '中国'     # 静态变量/静态属性 存储在类的命名空间里的
    def __init__(self,name,age,country):  # 绑定方法 存储在类的命名空间里的
        self.name = name
        self.age = age
    def func1(self):
        print(self)
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass
    def func5(self):pass

a = A('alex',83,'印度')
b = A('wusir',74,'泰国人')
A.Country = '日本人'
print(a.Country)
print(b.Country)
print(A.Country)

类中的变量是静态变量
对象中的变量只属于对象本身,每个对象有属于自己的空间来存储对象的变量
当使用对象名去调用某一个属性的时候会优先在自己的空间中寻找,找不到再去对应的类中寻找
如果自己没有就引用类的,如果类也没有就报错
对于类来说,类中的变量所有的对象都是可以读取的,并且读取的是同一份变量

实现一个类,能够自动统计这个类实例化了多少个对象
class A:pass
A.Country = 123   # 属性的增加
print(A.Country)  # 查看或者引用

class A:
    count = 0
    def __init__(self):
        A.count += 1

a1 = A()
print(a1.count)
a2 = A()
print(A.count)
类中的静态变量的用处
如果一个变量 是所有的对象共享的值,那么这个变量应该被定义成静态变量
所有和静态变量相关的增删改查都应该使用类名来处理
而不应该使用对象名直接修改静态变量

组合

一个类的对象是另外一个类对象的组合(对象变成了一个属性)
学生类：姓名性别年龄学号班级手机号

添加班级信息

班级名字
开班时间
当前讲师

# class Student:
#     def __init__(self,name,sex,age,number,clas,phone):
#         self.name = name
#         self.sex = sex
#         self.age = age
#         self.number = number
#         self.clas = clas
#         self.phone = phone
# class Clas:
#     def __init__(self,cname,begint,teacher):
#         self.cname = cname
#         self.begint = begint
#         self.teacher = teacher

# 查看的是大壮的班级的开班日期是多少
# 查看的是雪飞的班级的开班日期是多少
# py22 = Clas('python全栈22期','2019-4-26','小白')
# py23 = Clas('python全栈23期','2019-5-28','宝元')
# 大壮 = Student('大壮','male',18,27,py23,13812012012)
# 雪飞 = Student('雪飞','male',18,17,py22,13812012013)
# print(大壮.clas,py23)
# print(py23.begint)
# print(大壮.clas.begint)



# 练习 :
# 对象变成了一个属性
# 班级类
    # 包含一个属性 - 课程
# 课程
    # 课程名称
    # 周期
    # 价格

# 创建两个班级 linux57
# 创建两个班级 python22
# 查看linux57期的班级所学课程的价格
# 查看python22期的班级所学课程的周期

class Clas:
    def __init__(self,cname,begint,teacher):
        self.cname = cname
        self.begint = begint
        self.teacher = teacher
class Course:
    def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price
py22 = Clas('python全栈22期','2019-4-26','小白')
linux57 = Clas('linux运维57期','2019-3-27','李导')
linux58 = Clas('linux运维58期','2019-6-27','李导')
python = Course('python','6 months',21800)
linux = Course('linux','5 months',19800)
py22.course = python
linux57.course = linux
linux58.course = linux
print(py22.course.period)
print(linux57.course.price)
linux.price = 21800
print(linux57.course.price)
print(linux58.course.price)

# class Clas:
#     def __init__(self,cname,begint,teacher,cprice,cperiod):
#         self.cname = cname
#         self.begint = begint
#         self.teacher = teacher
#         self.cprice = cprice    # 课程价格
#         self.cperiod = cperiod  # 课程周期
# linux57 = Clas('linux运维57期','2019-3-27','李导',19800,'5 months')
# linux58 = Clas('linux运维58期','2019-3-27','李导',19800,'5 months')
# linux59 = Clas('linux运维59期','2019-3-27','李导',19800,'5 months')
# linux60 = Clas('linux运维60期','2019-3-27','李导',19800,'5 months')
# linux61 = Clas('linux运维51期','2019-3-27','李导',19800,'5 months')
# linux57.cprice = 21800
# linux58.cprice = 21800

04 今日总结

命名空间
- 在类的命名空间里
  - 静态变量
  - 绑定方法
- 在对象的命名空间里
  - 类指针
  - 对象的属性(实例变量)
- 调用的习惯
  - 静态变量的调用习惯:
    - 类名.静态变量
    - 对象.静态变量(对象调用静态变量的时候不能对变量进行赋值操作对象.静态变量 = 123123jkfg)
  - 绑定方法
    - 对象.绑定方法() ===>类名.绑定方法(对象)
  - 实例变量
    - 对象.实例变量(类调用不到)

组合

一个类的对象是另一个类对象的属性

两个类之间有什么关系:班级有学生,学生有班级,班级有课程,图书有作者....

# # 第二大题:基于圆形类实现一个圆环类,要求接收参数 外圆半径和内圆半径
# # 完成方法 :计算环形面积和环形周长(公式自己上网查)
# # 要求,借助组合,要求组合圆形类的对象完成需求
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def s(self,):
        S = self.r*self.r*pi
        return S
    def l(self,):
        L = 2*pi*self.r
        return L

class Circle_ring:
    def __init__(self,wrapper_R,inner_R):
        wrapper_R, inner_R = (wrapper_R,inner_R) if wrapper_R > inner_R else (inner_R,wrapper_R)
        self.wrapper_circle = Circle(wrapper_R)
        self.inner_circle = Circle(inner_R)
    def s(self):
        S = self.wrapper_circle.s() - self.inner_circle.s()
        return S
    def l(self):
        L = self.inner_circle.l() + self.wrapper_circle.l()
        return L
r = Circle_ring(10,5)
print(r.s())
print(r.l())

05 预习内容

posted @ 2020-08-17 00:01 Redbean1231 阅读(76) 评论(0) 编辑收藏举报

刷新页面返回顶部

Day 023 面向对象命名空间:组合

01 今日内容大纲

02 昨日内容回顾

03 今日内容

04 今日总结

05 预习内容

公告