Python 常用基础语法 练习汇总-------四

目录

类的数据属性   实例属性

#旧式类，经典类

#新式类（和继承有关），object是父类  主要应用在pyhton3中

#一般行数比较多，不建议使用交互方式编辑

类定义练习

类属性之继承

    '''子类具有父类的所有属性和方法 '''

#类的多态 -*- coding: utf-8 -*-

回顾类的三大属性：

#类属性的 获取机制 -*- coding: utf-8 -*-

类属性保存于类中，实例化属性保存于相应的实例中

类方法定义与调用实例：

@classmethod

类的静态方法

    @staticmethod

类的方法  只访问 类属性

实例方法  即访问实例属性，也可以访问类属性

静态方法  两个属性均不访问

类方法的重写，针对父类的方法不能满足子类的需求

    '''子类具有父类的所有属性和方法 '''

        ''' 子类重写父类的方法，重新调用时会调用子类的方法，而不是父类的方法'''

1.  is 判断的是对象是不是同一个，标准是两个标识符所表示的

对象在内存中的空间是否一致  a is b 等同于 id(a)==id(b)

    注意，判断none时建议使用is进行判断

2. 私有属性

#私有属性不能够在外部被直接访问

#私有方法同样不能在外不被直接访问

父类私有属性和方法 子类不能直接调用，

类多继承：

__new__练习

类的数据属性   实例属性

class A:

    x=7  #l类属性,静态数据

    def __init__(self,a):

        self.x=a #实例化属性

aa=A()

print(A.x)  #实例属性更新了，类属性不会改变

print(aa.x)

aa.x=1

print(A.x)

print(aa.x)

‘’’

7

77

7

1

‘’’

#旧式类，经典类

class A:

    '''

    this is A

    '''

    pass

#实例化

a=A()

print(type(a))

print(type(A))

print(a.__class__) #显示类型

print(a.__doc__)#显示类文档

‘’’

<class '__main__.A'>

<class 'type'>

<class '__main__.A'>

    this is A

‘’’

#新式类（和继承有关），object是父类  主要应用在pyhton3中

class B(object):#约定俗称  类的首字母大写

    #构造函数，实现类初始化

    def __init__(self):

        pass

b=B()

print(type(b))

print(type(B))

#一般行数比较多，不建议使用交互方式编辑

class People(object):

    #构造函数，实现初始化

    #self 当前的类

    Name='CCTV' #赋值，为初始化则赋值，做了初始化就没有赋值了（不建议这么使用，放在初始化函数中职能分工会更加明确）

    #真正意义上的构造函数

    def __new__(cls, *args, **kwargs):

        return object.__new__(cls, *args, **kwargs)

    def __init__(self,Name,Sex,Age):

        #初始化函数

        self.Name='name'

        self.Sex='sex'

        self.Age='age'

        print(self)

        pass

fbb=People('fbb','female','32')

print(fbb)

print(fbb.Name)#就像是填表，表示一个类，通过填表的过程类进行了实例化，表格也从类变成了一个对象

类定义练习

            class 类名（大驼峰）：

                def 方法1(self,参数列表)：

                    pass

                def 方法2(self,参数列表)：

                    pass

            实例对象=类()

class Cat:

    def eat(self):

        print('%s爱吃鱼'%self.name)

    def drink(self):

        print('爱喝水')

lazy_cat=Cat()

lazy_cat.name='lazy_cat'

lazy_cat.eat()

lazy_cat.drink()

print(lazy_cat)

addr1=id(lazy_cat)

print(addr1)

lazy_cat2=lazy_cat   #内存中地址相同

print(lazy_cat2)

addr2=id(lazy_cat2)

print(addr2)

print(lazy_cat.name)

class Person:

    def __init__(self,name,weight):

        self.name=name

        self.weight=weight

        print('创建实例化对象',self.name)

    def run(self):

        self.weight=self.weight-0.5

        print(self.weight,'Kg')

    def eat(self):

        self.weight=self.weight+1

        print(self.weight,'Kg')     

    def __str__(self):

        return 'name=%s'%self.name+'   weight=%s Kg'%self.weight

    def __del__(self):

        print('实例化对象%s已被清除'%self.name)

xiaoming=Person('xiaoming',70)  

xiaomei=Person('xiaomei',45) 

xiaoming.run()

xiaoming.eat()    

print(xiaoming)

print(xiaomei)

#房屋面积

class House:

    def __init__(self,housetype,Total_Area,Free_Area=None,House_Item=[]):

        self.House_Type=housetype

        self.Total_Area=Total_Area

        self.Free_Area=Total_Area

        self.House_Item=House_Item

        print(self.House_Type,self.Total_Area,

              self.Free_Area,self.House_Item)

#    def __del__(self):

#        print('删除格式化对象',self)

    def __str__(self):

        print(self.House_Type,self.Total_Area,

              self.Free_Area,self.House_Item)

        return ' '

    def add_list(self,House_Item):

        self.House_Item.append(House_Item.HouseItem_type)

        self.Free_Area-=House_Item.HouseItem_Area

        print('add',House_Item.HouseItem_type,'free_area=',self.Free_Area)

#        Free_Area=Free_Area-????

class HouseItem:

    def __init__(self,HouseItem_type,HouseItem_Area):

        self.HouseItem_type=HouseItem_type

        self.HouseItem_Area=HouseItem_Area

        print(self.HouseItem_type,self.HouseItem_Area)

    def __del__(self):

        print('删除格式化对象',self)

    def __str__(self):

        print(self.HouseItem_type,self.HouseItem_Area)

XjHouse=House('三室一厅',100,100)

bed=HouseItem('席梦思bed',4)

chest=HouseItem('衣柜chest',2)

table=HouseItem('餐桌table',1.5)

XjHouse.add_list(bed)

XjHouse.add_list(chest)

XjHouse.add_list(table)

print(XjHouse)

类属性之继承

class Animal:

    def eat(self):

        print('吃东西喽')

    def drink(self):

        print('喝水水')

    def run(self):

        print('跑了跑了')

    def sleep(self):

        print('shuijiao睡觉')

class Dog(Animal):

    def bark(self):

        print('汪汪叫')

class Xiaotian(Dog):

    '''子类具有父类的所有属性和方法 '''

    def fly(self):

        print('我是一只可以飞的狗狗')

xiaohei=Dog()

xiaohei.eat()

xiaohei.drink()

xiaohei.run()

xiaohei.sleep()   

xiaohei.bark()

print('-------------------')

xt=Xiaotian()

xt.fly()

xt.eat()

xt.drink()

xt.run()

xt.bark()

#类的多态 -*- coding: utf-8 -*-

"""

Created on Wed Dec 27 15:30:13 2017

回顾类的三大属性：

1. 封装：将属性和方法封装到抽象的类中；

2. 继承：代码重用，减少代码编辑量；设计类的技巧，子类根据自己需求可以便携特定的代码

3. 多态：增加代码的灵活度；以继承和重写父类方法为前提，调用方法的技巧，不会影响类的内部设计

        不同的对象 调用同样的方法，会产生不同的结果；

@author: 康宁

"""

class Dog(object):

    def __init__(self,name):

        self.name=name

    def game(self):

        print('狗狗在玩耍')

    def __del__(self):

        pass   

class XiaoTianQuan(Dog):

    def __init__(self,name):

        self.name=name

    def game(self):

        print('神一般地玩耍。。。')

        '''

        super(XiaoTianQuan,self).game()

            #super(子类,self)作用是找到子类的父类并将其实例化，

            实例化之后调用方法不需用加self

        Dog.game(self)

            #如果是这样，Dog表示的是类，并不是实例，

            所以在括号中需要加上self

        '''

        super(XiaoTianQuan,self).game()

        Dog.game(self)

    def __del__(self):

        pass

class People(object):

    def __init__(self,name):

        self.name=name

    def play(self,dog):

        print(self.name,' and ',dog.name,' are playing')

        dog.game()

    def __del__(self):

        pass   

xt=XiaoTianQuan('xt')

xiaoming=People('xiaoming')

xiaoming.play(xt)

Dog.game(1)

XiaoTianQuan.game(xt)

#类属性的 获取机制 -*- coding: utf-8 -*-

类属性保存于类中，实例化属性保存于相应的实例中

class Tool(object):

    count=0

    @classmethod

    def showcount(cls):

        print('ccount=  ',cls.count)

    def __init__(self,name):

        self.name=name

        Tool.count+=1

        pass

tool1=Tool('锤子')

tool2=Tool('钉子')

tool3=Tool('枕头')

'''

1. 调用类属性可以使用 类名.属性 调用，

2. 也可以使用 实例.类属性名 调用 -----》》》不推荐，

       因为容易使用赋值语句，这样就会在相应的

       实例中创造一个新实例化属性

'''

print(Tool.count)

print(tool1.count)

Tool.showcount()

类方法定义与调用实例：

@classmethod

#修饰函数，表明下面定义的方法是类方法，不是实例化方法

def showcount(cls):

      #cls相当于实例化方法中的self，指代调用该类方法的对象，也就是类

      print('ccount=  ',cls.count)

class Tool(object):

    count=0

    @classmethod

    def showcount(cls):

        print('ccount=  ',cls.count)

    def __init__(self,name):

        self.name=name

        Tool.count+=1

        pass

tool1=Tool('锤子')

tool2=Tool('钉子')

tool3=Tool('枕头')

print(Tool.count)

print(tool1.count)

Tool.showcount()

'''类对象Tool调用showcount()类函数，此处不需用传入cls，因为此处Tool类就是该函数的对象

'''

类的静态方法

class Dog(object):

    def __init__(self,name):

        self.name=name

    @staticmethod

    def run():

        print('run run run ')

xiaohei=Dog('xiaohei')

xiaohei.run()

Dog.run()

类的方法  只访问 类属性

实例方法  即访问实例属性，也可以访问类属性

静态方法  两个属性均不访问

class Game(object):   

    top_score=0

    @classmethod

    def show_top_score(cls):

        print('top score is:',cls.top_score)

    @staticmethod

    def help_info():

        print('help信息')

    def __init__(self,player_name):

        self.player_name=player_name

    def start_game(self):

        print('game start, come on',self.player_name)

#1. 查看帮助信息

Game.help_info()      

#2. 差看历史最高分

Game.show_top_score()

#3. 开始游戏

ckn=Game('ckn')

ckn.start_game()

#4. 让僵尸进入大门

类方法的重写，针对父类的方法不能满足子类的需求

class Animal:

    def eat(self):

        print('吃东西喽')

    def drink(self):

        print('喝水水')

    def run(self):

        print('跑了跑了')

    def sleep(self):

        print('shuijiao睡觉')

class Dog(Animal):

    def bark(self):

        print('汪汪叫')

class Xiaotian(Dog):

    '''子类具有父类的所有属性和方法 '''

    def fly(self):

        print('我是一只可以飞的狗狗')

    def bark(self):

        ''' 子类重写父类的方法，重新调用时会调用子类的方法，而不是父类的方法'''

        print("神一般的汪汪叫")

        '''重写时  父类的同名的方法可以作为子类新方法的组成

        部分super().父类方法  or 父类.父类方法(self)  来实现调用'''

        super().bark()

        Dog.bark(self)#不建议使用，因为父类名称一旦改变，需要改动的部分比较多

            #此处若使用子类，会出现递归调用，没有出口形成死循环

xt=Xiaotian()

xt.bark()

'''

1.  is 判断的是对象是不是同一个，标准是两个标识符所表示的

对象在内存中的空间是否一致  a is b 等同于 id(a)==id(b)

    注意，判断none时建议使用is进行判断

#c=[1,2,3]

#d=[1,2]

#print(id(c),id(d))

#d.append(3)

#print(id(c),id(d))

#print(c==d)

#print(c is d)

#print(id(c)==id(d))

##对于none的匹配或者对比建议使用is

#print(a is None)

'''

result:

933776315592 933789882504
933776315592 933789882504
True
False
False
False

'''

'''

2. 私有属性

#私有属性不能够在外部被直接访问

#私有方法同样不能在外不被直接访问

'''

class Women:

    def __init__(self,name,age):

        self.name=name

        self.__age=age

    def secret(self):

        print('secret')

        print(self.name,self.__age)

    def __secret0(self):

        print('__secret0')

        print(self.name,self.__age)

xiaomei=Women('xiaomei',18)

''' 对象的外部不能直接访问对象的私有属性'''

print(xiaomei._Women__age)

''' 对象的内部方法可以访问对象的私有属性'''

xiaomei.secret()

''' 对象的内部私有方法不可以被直接访问'''

#xiaomei.__secret0()

''' 伪私有，访问方法：  _类名__私有属性/私有方法()'''

xiaomei._Women__secret0()     

父类私有属性和方法 子类不能直接调用，

1. 子类可以访问父类的公有属性和公有方法，不能直接访问父类的私有属性和私有方法

2. 子类可以通过访问父类的公有方法来间接访问父类的私有属性和私有方法

class A:

    pass

    def __init__(self):

        self.num1=100

        self.__num2=200

    def test(self):

        print('父类非私有方法',self.num1,self.__num2)

    def __test(self):

        print('父类私有方法',self.num1,self.__num2)

class B(A):

    def demo(self):

        print('子类的方法',self.num1)#,self.__num2) ''' 子类的方法中不能访问父类的私有属性'''

        super().test()  #子类的方法中中可以访问父类的非私有方法

        super().__test()

    pass

b=B()

print(b.num1)

#print(b.__num2)

'''父类的私有属性和私有方法不能在子使用子类直接访问 '''

b.test()

#b.__test()

b.demo()

类多继承：

        class 类名(父类1，父类2，。。。。)：:

            pass

    注意：

        1.如果多个父类之间存在同名的方法，应该避免多继承；

        2. 类名.__mro__指定的搜索顺讯进行执行       

class A(object):

    def test(self):

        print('A test-----')

        pass

    def demo(self):

        print('A demo-----')

        pass

class B(object):

    def test(self):

        print('B test-----')

        pass

    def demo(self):

        print('B demo-----')

        pass

class C(A,B):

    pass

c=C()

c.test()

c.demo()

print(C.__mro__)#注意，是类，不是实例

__new__练习

1. 只分配第一次创建对象时的内存空间

2.只做一次初始化操作，但是每次构建一个新对象都会调用初始化函数，

经过改造只有第一次调用初始化函数会会执行初始化操作

class MusicPlayer(object):

    instance=None

    init_flag=None

    def __new__(cls,*args,**kargs):#chognxie 重写__new__函数

        #1. 创建时会被自动调用，

        print('创建对象，分配空间')

        if MusicPlayer.instance is None:

            MusicPlayer.instance=super().__new__(cls)#???这里不明白为什么要加上cls--->super产生的是实例化对象，不是类对象，所以实例化对象调用类函数需要将类作为参量传入类函数，如果是类对象调用类函数就不需用传cls了

        return MusicPlayer.instance

    '''

        super(XiaoTianQuan,self).game()

            #super(子类,self)作用是找到子类的父类并将其实例化，

            实例化之后调用方法不需用加self

        Dog.game(self)

            #如果是这样，Dog表示的是类，并不是实例，

            所以在括号中需要加上self

        '''

    def __init__(self):

        if MusicPlayer.init_flag is None:

            print('播放器初始化')

            MusicPlayer.init_flag=1

        else:

            return

kuwo=MusicPlayer()

print(kuwo)

youku=MusicPlayer()

print(youku)