python学习笔记1

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类对象调用方法的顺序
#<class '__main__.E'>, <class '__main__.D'>, 
# <class '__main__.C'>, <class 'object'>)
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__方法