import os
print("start......")
#不同的函数中定义相同的变量互不影响
##全局变量
num =10
def func():
#希望修改全局变量的值
#不允许直接修改全局变量的值
#globa告诉编译器 变量为全局变量
#global num #全局变量的修改 修改全局变量需要使用global关键字进行声明一下
num =99#在函数内部使用赋值语句 只会直接修改全局变量的值
print(num) #输出99 首先在函数内部查找有没有num变量，再在外面找全局变量
def func1():
print(num) #输出10
func()
func1()
#全局变量 大多数不推荐
#不允许直接修改全局变量的引用 --使用赋值语句修改全局变量的值
num1=10
def demo():
print(num1)
print(title)
title = "aaaaa"
demo() ##也可以正常运行
#全局变量取名规则
#g_ gl_
####389
'''
在实际开发中，对象的某些属性或方法可能只希望在
对象的内部被使用，而不希望在被外部访问到
私有属性就是对象不希望公开的属性
私有方法就是对象不希望公开的方法
定义的方式：在定义属性或方法时，在其前面增加两个下划线即可
'''
class women:
def __init__(self,name):
self.name=name
self.age=18
#私有的变量 不可以直接访问 xf.__secret_age
self.__secret_age=18
##私有方法同样在外界不可以访问
##def __secret(self):
def __secret1(self):
print("%s的年龄是%d"%(self.name,self.__secret_age))
def secret(self):
print("%s的年龄是%d"%(self.name,self.__secret_age))
xf =women("消防")
print(xf._women__secret_age)
print(xf.age)
######390
#伪私有属性和私有方法
xf.secret()
#私有属性也可以访问 在python中没有真正的私有变量和方法
#访问私有的方式 在名词的前面加上_类名=>_类名__名称
#不建议这样访问
xf._women__secret1()
####391
class animal:
def eat(self):
print("eat")
def drink(self):
print("drink")
def run(self):
print("run")
def sleep(self):
print("sleep")
#狗对象
####392
class dog (animal):
def bark(self):
print("bark")
class dog_xt (dog):
def fly(self):
print("fly")
wangcai =animal()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
gou =dog()
gou.eat()
gou.drink()
gou.run()
gou.sleep()
gou.bark()
##子类拥有父类的所有属性和方法
gou_xtq =dog_xt()
gou_xtq.eat()
gou_xtq.drink()
gou_xtq.run()
gou_xtq.sleep()
gou_xtq.bark()
gou_xtq.fly()
####393
####394
#继承的传递性与术语
####395
# 继承类的传递性
####396
# 方法的重写--重写父类的方法
# 重写 override
# 具体的实现方法 定义一个与父类同名的方法 重新实现
class override_method (dog):
def bark(self):
print("bark overide")
##父类重写时 子类的对象调用子类的方法
overide = override_method ()
overide.bark()
####397
#1、子类对父类方法的扩展
#2、在需要的位置使用super().父类方法，来调用父类方法的执行
#3、代码其他的位置针对子类的需求 编写子类特有的代码实现
#关于super
#在python中super是一个特殊的类
#super()就是使用super类创建出来的对象
#最常使用的场景就是在重写父类方法时 编写在父类中封装的方法实现
class super_method (dog):
def bark(self):
#1、针对子类特有的需求 编写代码
print("super_method")
#2、使用super(). 调用原本在父类中封装的方法
#super().bark() ##python3
# 398
#2.1或者不使用super的方法
#父类名.方法(self)
dog.bark(self) #必须要有self
#如果采用子类调用 则会递归调用
#super_method.bark(self) #必须要有self
#在开发时 父类名和super()两种方式不要混用
#如果
#3、增加其他子类的代码
print("@#$%!")
superway = super_method ()
superway.bark()
#399
#父类的私有属性和方法子类不能直接访问
class A:
def __init__(self):
self.num1=100
self.__num2=200
def __test(self):
print(self.num1," ",self.__num2)
class B(A):
def demo(self):
#1、访问父类的私有属性
#不可以
print(self.num1)
#2、调用父类的私有方法
#不可以
objb= B()
#400
#通过父类方法间接访问
#子类对象不能在自己的方法内部 直接访问父类的私有属性或私有方法
#类似于套娃
#子类对象可以通过父类的公有方法间接访问私有属性或者私有方法
#401
####多继承 方法如下
#class 子类名（父类名1,父类名2，...）
#402
####多继承时 父类中具有相同的方法 应避免这样
class C:
def demo(self):
print("C----demo")
def test(self):
print("C----test")
class D:
def demo(self):
print("C----demo")
def test(self):
print("C----test")
class E (D,C):
pass
obj_e= E()
obj_e.demo()
obj_e.test()
#403
##确定C类对象调用方法的顺序
#, ,
# , )
print(E.__mro__)
#404
# 新式类与经典类 object为基类的类为新式类
#如果没有父类 建议统一继承object
#405多态
####封装继承多态 面向对象的三大特性
#封装 根据职责将属性和方法封装到一个类中
#继承 实现代码的重用 设计类的技巧 针对自己的需求 编写特点的代码
#多态 不同的子类对象调用相同的父类方法 产生不同的执行效果
#多态可以增加代码的灵活度 前提1、以继承和重写父类方法为前提
#子类中重写父类的方法 是调用方法的技巧 不会影响到类的内部设计
#406多态的案例演练
class dog(object):
def __init__(self,name):
self.name = name
def game(self):
print("%s 蹦蹦跳跳的玩耍.."%self.name)
class xioatianquan(dog):
def game(self):
print("%s 飞到天上的玩耍.."%self.name)
class person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print("%s和%s 快乐的玩耍.."%(self.name,dog.name))
##让狗玩耍
dog.game()
#创建一个狗对象
#wangcai =dog("wangcai")
wangcai =xioatianquan("feitian wangcai")
xiaoming =person("xiaoming")
xiaoming.game_with_dog(wangcai)
#407
####类属性 --创建对的过程及象实例的概念
#实例 由类创建出来的对象
#每一个对象 都有自己的独立内存空间 保存各自不同的属性
#408
#类同样会被加载到内存中
#在python中类是一个特殊的对象
#409类属性的定义与应用
'''
类属性就是给类对象中定义的属性
通常用来记录与这个类相关的特征
类属性不会用于记录具体对象的特征
'''
class tools(object):
count =0 ##相当于c++的静态变量
def __init__(self,name):
self.name =name
tools.count +=1 ##可以知道有多少个对象被创建
tools1= tools("斧头")
print(tools1.count," ",tools1.name)
tools2= tools("langtou")
print(tools1.count," ",tools2.name)
#410
#属性获取机制
#类属性 属性查找机制 向上查找
#类名.类属性
#对象.类属性 无论哪个对象 不推荐
#411
#类属性赋值
tools2.count=20
print(tools2.count) ##20 类名.类属性 的方式
print(tools.count) #2
#412
# 类方法
#类方法需要用修饰器@classmethod来标识 告诉解释器这是一个方法
#类方法的第一个参数为cls
#由哪一个类调用的方法 方法内的cls就是哪一个类的引用
#这个参数和实例方法的第一个参数是self类似
#使用其他的名词也可以 不过习惯使用cls
#通过类名.调用类方法 调用方法时 不需要传递cls参数
##可以通过cls.访问类的属性
##也可以通过cls.调用其他类的方法
class test:
@classmethod
def classway(cls):
pass
##可以使用 类名直接调用
##也可以使用类对象调用
#413
#类方法的演练
class test1(object):
count =0
@classmethod
def show_tool_count(cls):
print("工具对象的数量 %d" % cls.count)
def __init__(self,name):
test1.count +=1
self.name =name
obj1=test1("111")
obj2=test1("111")
#调用类的方法
test1.show_tool_count() #类名. 的方法
#414
# 静态方法
# 既不需要访问类的属性 或类方法
# 也不需要访问实例的属性 或实例方法
# 这个时候 可以封装成一个静态方法 @staticmethod
class test2(object):
@staticmethod
def run():
#不访问实例属性和类属性可以定义为静态的方法
print("小狗在跑")
#通过类名.调用静态方法 --不需要创建对象
test2.run()
#415
#416
#417
#综合案例
#属性
#定义一个类属性 记录历史最高分
#定义一个实例属性 记录当前游戏玩家姓名
#方法
#静态方法 show_help 显示游戏帮助信息
#类方法show_top_score 显示历史最高分
#实例方法 start_game 开始当前玩家游戏
#主程序步骤
#1查看帮助信息
#2查看历史最高分
#3创建游戏对象 开始游戏
class game(object):
#历史最高分
top_score =0
def __init__(self,player_name):
self.player_name=player_name
@staticmethod
#静态方法
def show_help():
print("帮助信息：让僵尸进入大门")
@classmethod
#类方法
def show_top_score(cls):
print("历史记录%d" %cls.top_score)
#实例方法
def start_game(self):
print("%s开始游戏啦....."%self.player_name)
#1 查看游戏的帮助信息
game.show_help() #类名. 的方法进行调用
#2 查看历史最高分
game.show_top_score()
#3 创建游戏对象
gameobj=game("小明")
'''
实例方法 --方法内部需要访问 实例属性
（实例方法内部可以使用类名.访问类属性）
类方法 --方法内部只需要访问类属性
静态方法 --方法内部 不需要访问实例属性和类属性
'''
#418
#单例设计模式
#目的 让类创建对象，在系统中只有唯一一个实例
#每一次执行类名()返回的对象，内存地址是相同的
#音乐播放器
#回收站
#打印机
#设计模式
#使用设计模式是为了可重用代码 让代码更容易被他人理解、保证代码的可靠性
#设计模式是前人工作总结和提炼 设计模式为针对某一特定问题的成熟解决方案
#419
#__new__方法
