深谙：非常透彻地了解；熟悉内中情形。谙，读作‘ān’ 熟悉。
1.面向对象作用：
规划了代码中的函数处理的是哪一类问题 解决了传参的问题 方便扩展 方便重用
2.类的定义和使用
类当中有哪些成员 ''' 静态变量 动态变量，对象方法 '''
类： 有相同特征的事物归为一类 对象、实例： 类的具体化 实例化： 通过类创造一个对象的过程 对象 = 类名（参数，对象） '''
1， 开辟一块内存空间，让self指向他 2，调用__init__方法，执行init
3，把self 返回给调用者 '''
''' 对象可以存哪些方法 #所有的对象属性都在对象里 类名能做什么 #查看静态变量 #实例化对象 对象名能做什么 #属性的增删改查 #方法的调用 '''
3类的加载顺序
#1. 类内部一个缩进的所有代码 都是在py文件从上到下开始解释的时候就已经被执行了
#2. 类中的代码 永远是 从上到下依次执行的
class A: print(123) def __init__(self): print('执行我啦！') def func(self): print('adjia') def func(self): print('adj',A.country) country = 'China' country = 'Chi' ''' 执行第一层缩进 #123 a = A() #执行我啦！ a.func() #adj Chi 从上往下执行 和变量一样 '''
4.类的命名空间
类和对象中的内容是分两片存储的
对象 里的指针可以用 类里的函数 正常使用静态的变量
class Student: country = 'China' def __init__(self,name,country): self.name = name self.country = country zhang = Student('刘大','中国') zou = Student('王二','China') 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) zou.country = '日本人' print(zou.country)
所以，在操作 静态变量的时候 应该尽量使用类名来操作而不是使用对象名
比如：用类 和 用self 的区别是什么？
class Person: money = 0 def __init__(self,name): self.name = name def salary_deliery(self): Person.money += 1000 return Person.money a = Person('刘大').salary_deliery() print(a)
练习：
class A: Count = 0 def __init__(self,name,age,sex): self.name = name A.Count += 1 self.age = age A.Count += 1 self.sex = sex A.Count += 1 a = A('刘大','王二','张三') print(A.Count)
赋值和使用变量
class A: Count = 0 def __init__(self,name,age,sex): self.name = name A.Count += 1 self.age = age A.Count += 1 self.sex = sex A.Count += 1 a = A('刘大','王二','张三') 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 #赋值 1 print(b2.l[0]) b1.l = [123] print(b2.l[0]) #1 print(b1.l[0]) #123
# 只要是对一个对象 ，名字直接赋值，那么就是在这个对象的空间内创建了新的属性 # 只要是对一个可变的数据类型内部的变化，那么仍然是所有的对象和类共享这个改变的成果 #所有的静态变量都是用类名来操作 ，这样修改就能被所有的对象感知到 #如果是对于可变数据类型的静态变量 操作的是这个数据内部的内容，也可以使用对象来调用 #对象 和 类名 是一样的 静态变量最好是可变的
区别在哪？
class Person: money = 0 def __init__(self,name): self.name = name def salary_deliery(self): Person.money += 1000 return Person.money a = Person('刘大').salary_deliery() print(a) #1000 class Person: money = 0 def __init__(self,name): self.name = name def salary_deliery(self): self.money += 1000 return self.money a = Person('刘大').salary_deliery() print(a) #1000
5.组合
圆类
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*self.r*3.14 #圆环类 class Ring: def __init__(self,r1,r2): # 属性 和 对象 相对应了 c1 = Circle(r1) c2 = Circle(r2) if c1.r > c2.r: self.outer = c1 # 组合 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() # 圆柱类 # a = Circle(2) # print(a.area()) a = Ring(12,3) print(a.area()) print(a.perimeter()) class C3d: def __init__(self,r,h): self.r = r self.h = h c1 = Circle(r) self.area = c1 def area(self): c_area = self.area.area() rec_area = self.area.perimeter() *self.h return c_area*2 + rec_area def vic(self): c_area = self.area.area() return c_area*self.h
''' #耦合 # 紧耦合 #圆形面积的公式 和 类中方法 #组合： #一个类的对象是另一个类对象的属性 #圆形类的对象 是圆环类对象的outer 属性的值 # 计算圆形 相关数据的公式 只和Circle 类在一起 #其余的 用到 公式的地方都是通过Circle 类来使用的 # 公式与 其他类之间的关系 是一个“松耦合”关系 '''
学生类
利用的Date 的类 作为参数 传给另一个类的对象
#学生类 # 入学日期 # 开学日期 #日期的粒度 精确到年月日 # "2019-9-12" # 年 # 月 # 日 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 #组合 开始 后面都是 组合 用的class date self.in_school = in_shcool self.start_day= start_day d1 = Date(2000,1,1) d2 = Date(2018,12,1) d3 = Date(2019,2,1) liu = Student('刘大',10086,d1,d2,d3) print(liu.birth.year) print(liu.birth.month)
这种不行 只是单纯的赋值 没有改变 具体课程的元素
class Student: def __init__(self,name,num,course): self.name = name self.num = num self.course_name = course.name #没有把python 耦合在一起 只把 课程弄在一起
类似例子
写两个类 一个是 课程类 : （写上变量） name , price ,period
一个是学生类 name , num , 课程（传过来）
课程= Course（三个变量）
学生 = Student（两个变量，课程）
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__) print(s1.course.price) python.price = 30000 python.period = '7 months' s3 = Student('董鹏',10083,python) print(s3.__dict__.values()) # 就学生的那三个属性 print(s1.course.__dict__) # 课程的三个属性
6. 人狗大战
#__author : 'liuyang' #date : 2019/3/26 0026 下午 12:03 class Dog: a = 1000 def __init__(self,name,hp,ad,sex): self.name = name self.blood = hp self.ad = ad self.type = sex def bite(self,person): person.blood -= self.ad print('%s 咬了 %s,%s 掉了 %s血'%(self.name,person.name,person.name,self.ad)) class Person: a = 1000 def __init__(self,name,hp,ad,sex,money): print('执行了') print(name,hp,ad,sex) self.name = name self.hp = hp self.ad = ad self.type = sex self.money = money self.beg = [] def jian23(self,dog): dog.hp -= 2000 #想怎么设计就怎么设计 print("%s 被 %s 击中了，掉了2000，当前%s的血量为%s"%(self.name,dog.name,dog.name,dog.hp)) def fight(self,dog): #定义在类的内部的 动态变量 方法 dog.blood -= 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 wea in self.beg: # print(wea) return self.beg # if wea == 'weapon': # self.weapon = wea #组合 # self.hp += wea.hp # self.ad += wea.ad # break #level 1 # 回合制的游戏 class weapon: # 装备 # 名字 # 价格 # 属性 # 技能 def __init__(self,name,price,ad,hp): self.name = name self.price = price self.ad = ad self.hp = hp # 买装备 #人的余额 >= 商品的价格 #能否命中 暴击 liuda = Person('liuda',100,1,'男',20000000) huang = Dog('huang',1000,10,'公') zhuan = weapon('绝世好剑',2000000,1000,1000) liuda.buy_weapon(zhuan) print(liuda.use_weapon()) # print(liuda.beg) # liuda.use_weapon() # print(liuda.use_weapon()) # print(liuda.weapon.name) # 一个对象 和另一个对象 通过另一个属性 关联在一起了 #人有 武器 #人是 一个 类 #武器 也是 类 #人 关联 武器 #人用武器招式 #总结 #类的加载顺序 #类的对象的命名空间
7.堆栈
# 数据结构 栈 # 数据结构 队列 # 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() # 栈 在底层的数据结构 再很多算法中 解决问题的时候必须用到这种数据结构
老师说： 8k 10k 15k靠技术 25k 靠态度