其他
类 : 这个类有什么属性 有什么方法 大致的样子
不能知道具体的属性对应的值
对象 :之前所有的属性值就都明确了
类型 :int float str dict list tuple set -- 类（内置的数据类型，内置的类） 通过type()查看类型
举例：
变量名 = xx数据类型对象
a = 10
b = 12.5
l = [1,2,3]
d = {'k':'v'}
o = 函数
q = 迭代器
u = 生成器
i = 类名
python中一切皆对象,对象的类型就是类。
所有的对象都有一个类型,class A实例化出来的对象的类型就是A类
123的类型是int
'ajksfk'的类型是str
{}的类型是dict
alex = Person()的类型是Person
小白 = Dog()的类型是Dog
def abc():pass
print(type(abc))#<class 'function'>命名空间和内存
类命名空间与对象、实例的命名空间：
1.建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性。
类有两种属性：静态属性和动态属性
静态属性就是直接在类中定义的变量。类的数据属性是共享给所有对象的
动态属性就是定义在类中的方法。类的动态属性是绑定到所有对象的
类中的变量是静态变量。对于类来说,类中的变量所有的对象都是可以读取的,并且读取的是同一份变量。
类中的静态变量的用处：
如果一个变量 是所有的对象共享的值,那么这个变量应该被定义成静态变量。
所有和静态变量相关的增删改查都应该使用 类名 来处理，而不应该使用对象名直接修改静态变量。
2.创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性。
对象中的变量只属于对象本身,每个对象有属于自己的空间来存储对象的变量。
当使用对象名去调用某一个属性的时候会优先在自己的空间中寻找,找不到再去对应的类中寻找。如果自己没有就引用类的,如果类也没有就报错。例如：在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
类指针：在对象名称空间中存储了类所在的内存地址，对象总是能单向找到类，类不能找到对象。对象a的名称空间找不到，就去类A的名称空间去找。
####1：
class A: #class A一个缩进内的内容，不用调用就会执行。在一个缩进内不能使用A.的方式调用，因为A是最后才指向命名空间的
Country = '中国' # 静态变量/静态属性 存储在类的命名空间里的
def __init__(self,name,age): # 类内部的函数叫绑定方法 存储在类的命名空间里的
self.name = name
self.age = age
def func1(self): #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)#<__main__.A object at 0x00000239DE64FB70>
print(a.name)#alex
print(a.Country)#中国 #类指针：存储了类所在的内存地址，对象总是能单向找到类，类不能找到对象。对象a的名称空间找不到，就去类A的名称空间去找。
print(A.Country)#中国 类名.静态变量
a.func1() # 等价于# A.func1(a) #一般不用不用类名调用方法，用对象去调用方法
# <__main__.A object at 0x00000239DE64FB70>
###：2
class A: #class A一个缩进内的内容，不用调用就会执行。在一个缩进内不能使用A.的方式调用，因为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
Country = '印度'
print(A.Country)#印度 #注意同上面的区别
print(A.__dict__)
###3：
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)#alex
print(a.Country)#印度 对象a的名称空间可以找到，就不去类A的名称空间取值。
print(A.Country)#中国
###4：
class A:
Country = '中国' # 静态变量/静态属性 存储在类的命名空间里的
def __init__(self,name,age,country): # 绑定方法 存储在类的命名空间里的
self.name = name
self.age = age
self.Country = country #注意大写，如果写成小写，又去找大写print(b.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)#中国
###5：
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)#日本 #a = A('alex',83,'印度')虽然传入了参数，但是在对象a的名称空间中没有定义变量，没有此句self.Country = country
print(b.Country)#日本
print(A.Country)#日本
####6：
class A:pass
A.Country = 123 # 属性的增加
print(A.Country) #123 查看或者引用
# 实现一个类,能够自动统计这个类实例化了多少个对象
class A:
count = 0 #静态变量
def __init__(self):
A.count += 1 #每次实例化对象就+1 注意在一个缩进内不能使用 A.方式
a1 = A()
print(a1.count)#1 对象a1的名称空间找不到，就去类A的名称空间取值。
a2 = A()
print(A.count)#2 #静态变量的查看，通过类名来处理组合
面向对象的组合用法：
软件重用的重要方式除了继承之外还有另外一种方式，即：组合。
组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合。一个类的对象是另外一个类对象的属性。
用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系。两个类之间 有 "什么有什么"的关系 : 如 班级有学生 学生有班级 班级有课程 图书有作者 学生有成绩
当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好。
作用：方便代码修改，让代码更加灵活
学生类
姓名 性别 年龄 学号 班级 手机号
班级信息
班级名字
开班时间
当前讲师
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期','2017-4-26','小白')
py23 = Clas('python全栈23期','2017-5-28','宝元')
大壮 = Student('大壮','male',18,27,py23,13812012012)
雪飞 = Student('雪飞','不详',18,17,py22,13812012013)
print(大壮.clas,py23)#二者是同一个<__main__.Clas object at 0x000002749D66FA20> <__main__.Clas object at 0x000002749D66FA20>
print(py23.begint)#2017-5-28
print(大壮.clas.begint)#2017-5-28
print(py22.begint)#2017-4-26
print(雪飞.clas.begint)#2017-4-26
练习 :
对象变成了一个属性
班级类
包含一个属性 - 课程
课程
课程名称
周期
价格
###1：
class Clas: #班级
def __init__(self,cname,begint,teacher,course):
self.cname = cname
self.begint = begint
self.teacher = teacher
self.course = course #课程
class Course: #课程
def __init__(self,name,period,price):
self.name = name
self.period = period
self.price = price
python = Course('python22','6个月',21800)
py22 = Clas('python全栈22期','2017-4-26','小白',python)
print(py22.course.price)#21800
print(python.price)#21800
##2：
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
python = Course('python22','6个月',21800)
py22 = Clas('python全栈22期','2017-4-26','小白')
py22.clas = python #属性的增加 注意同上面的区别
print(py22.clas.price)#21800
print(python.price)#21800
##3：
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)
linux57.course = linux
linux58.course = linux
print(linux57.course.price)#19800
print(linux58.course.price)#19800
py22.course = python
print(py22.course.period)#6 months
linux.price = 21800
print(linux57.course.price)#21800
print(linux58.course.price)#21800
##4:
自（测试）：
class Clas:
def __init__(self,cname,begint,teacher,cperiod,cprice):
self.cname = cname
self.begint = begint
self.teacher = teacher
self.cprice = cprice # 课程价格
self.cperiod = cperiod # 课程周期
class Course:
def __init__(self,name,period,price):
self.name = name
self.period = period # 课程周期
self.price = price #课程价格
linux = Course('linux', '5 months', 19800)
linux.price = 21800 #修改此处，所有课程价格统一修改
linux57 = Clas('linux运维57期','2017-3-27','李导',linux.period,linux.price)
linux58 = Clas('linux运维58期','2017-4-27','王导',linux.period,linux.price)
linux59 = Clas('linux运维59期','2017-5-27','张导',linux.period,linux.price)
linux60 = Clas('linux运维60期','2017-6-27','马导',linux.period,linux.price)
linux61 = Clas('linux运维61期','2017-7-27','赵导',linux.period,linux.price)
print(linux57.cprice)#21800
print(linux58.cprice)#21800
print(linux59.cprice)#21800总结：
1.命名空间:
在类的命名空间里 : 静态变量 绑定方法
在对象的命名空间里 : 类指针 对象的属性(实例变量)
调用的习惯
【1】静态变量：
类名.静态变量
对象.静态变量 (对象调用静态变量的时候,不能对变量进行赋值操作 例如：对象.静态变量 = 1UI27 这样会成为属性的增加)
【2】绑定方法：
对象.绑定方法() ==> 类名.绑定方法(对象)
【3】实例变量：
对象.实例变量
2.组合:
一个类的对象是另一个类对象的属性。
两个类之间 有 "什么有什么"的关系 : 如 班级有学生 学生有班级 班级有课程 图书有作者 学生有成绩
学生 和 课程
班级 和 课程
圆形 和 圆环