python入门17 类和对象

类：一类事物的抽象化。概念：

类的变量（属于类的变量，定义在类的开始处）  成员变量（self.变量） 

类的方法（ @classmethod,cls参数)   成员方法( self参数 )  静态方法(@staticmethod )

私有变量 私有方法 (__打头的变量或方法，外部不可调用。类定义内部可调用）

 

对象：类的实例化，调用构造函数__init__()

 

#coding:utf-8
#/usr/bin/python
"""
2018-11-17
dinghanhua
类与对象实例化
"""
import datetime

\'\'\'类定义\'\'\'
class student:

    school = \'大树幼儿园\' #类变量
    __lastchangetime = \'\' #私有变量
    \'\'\'类变量，属于类自己的变量。实例化对象时拷贝副本给对象。
    可通过类名或对象访问，但对象.类对象改变只对当前对象生效，通过类名改变对才对类生效\'\'\'

    def __init__(self,name,grade,id,phone=\'\'): #构造函数
        self.name = name  #成员变量
        self.grade = grade
        self.id = id
        self.__phone = phone #成员私有变量
        self.__score = 0

    def print_info(self): #对象方法 self指对象本身
        print(\'学号 is %s,姓名 is %s,年级 is %s,电话 is %s\'%(self.id,self.name,self.grade,self.__phone))

    def get_score(self):
        return self.__score

    def set_score(self,sc):
        self.__score = sc

    @classmethod  #类方法
    def change_schoolname(cls,schoolname):
        cls.school = schoolname
        cls.__changetime() #私有方法，内部可调用
        print(\'学校名修改成功：%s，修改时间：%s\'%(cls.school,cls.__lastchangetime))

    @classmethod
    def __changetime(cls):
        cls.__lastchangetime = datetime.datetime.now() #私有变量内部可调用

    @staticmethod #静态方法
    def print_schoolname():
        print(\'学校：\',student.school,student.__lastchangetime)

    def __str__(self): #__xx__()方法为内部的特殊方法 __str__表示可用str()函数
        return self.name+self.school

 

\'\'\'实例化对象，调用对象方法\'\'\'
xiaoming = student(\'小明\',\'小班\',\'201800001\',13500000000)
xiaohua = student(\'小花\',\'小班\',\'201800002\')

xiaoming.print_info()
xiaohua.print_info()

print(xiaoming.name)
#print(xiaoming.__phone) #调用对象的私有变量，报错 \'student\' object has no attribute \'__phone\'

xiaoming.set_score(100)
print(xiaoming.get_score())

 

\'\'\'单个对象改变类变量\'\'\'
print(\'对象调用类变量：\',xiaoming.school)
print(\'类调用类变量：\',student.school)

xiaoming.school = \'大树小学\' #仅改变自己的那一份拷贝，不影响其他对象
print(\'小明修改了xiaoming.school，小明的学校：\',xiaoming.school) #大树小学
print(\'小明修改了xiaoming.school，小花的学校不变：\',xiaohua.school) #不变
print(\'小明修改了xiaoming.school,student类的school：\',student.school) #不变

\'\'\'调用类方法改变类变量\'\'\'
student.change_schoolname(\'大树幼儿园东部校区\')
print(\'修改了student.school:类对象\',student.school) #变了
print(\'修改了student.school:小明的学校 \',xiaoming.school) #还是大树小学
print(\'修改了student.school:小花的学校\',xiaohua.school) #变了

xiaoming.change_schoolname(\'我的母校\')
print(\'小明通过类方法修改了学校名 类对象：\',student.school) #变了
print(\'小明通过类方法修改了学校名 小明的学校：\',xiaoming.school) #还是大树小学
print(\'小明通过类方法修改了学校名 小花的学校：\',xiaohua.school) #变了

 

\'\'\'调用私有变量报错\'\'\'
#print(\'对象调用类变量：\',xiaoming.__lastchangetime) # \'student\' object has no attribute \'__address\'
#print(\'类调用类变量：\',student.__lastchangetime)# \'student\' object has no attribute \'__address\'
\'\'\'python私有变量机制：变量名重整 _classname__私有变量名\'\'\'
print(student._student__lastchangetime)

\'\'\'调用私有方法报错\'\'\'
#student.__changetime()
#xiaoming.__changetime()
#student._student__changetime() #私有方法机制：方法名重整

\'\'\'静态方法\'\'\'
student.print_schoolname()
xiaoming.print_schoolname()

\'\'\'定义了__str__()方法后可用str()\'\'\'
print(str(xiaoming))

 

 

封装：属性私有化，提供对外访问的方法

利用列表实现类似栈的结构，栈不能直接访问
初始化函数传入栈的极限大小，封装获取是否为空及是否到达极限大小的私有方法。
对外提供弹栈和压栈，获取极限大小的方法

\'\'\'利用列表实现类似栈的结构
初始化函数传入栈的极限大小，栈不能直接访问
封装获取是否为空及是否到达极限大小的私有方法
对外提供弹栈和压栈，获取极限大小的方法\'\'\'
class stack:

    def __init__(self,maxlength): #构造函数
        if type(maxlength) == type(1) and maxlength > 0: #正整数
            self.__maxlength = maxlength
            self.__stack = []
        else:
            raise ValueError(\'栈大小必须是正整数\')

    def __ismaxlength(self): #是否到达极限长度
        if len(self.__stack) == self.__maxlength:
            return True
        return False

    def __isNone(self): #是否为空
        if len(self.__stack) == 0:
            return True
        return False

    def getmaxlength(self): #获取极限大小
        return self.__maxlength

    def pop(self): #弹栈
        if not self.__isNone(): #非空弹出最后一个
            return self.__stack.pop()
        raise IndexError(\'pop from empty stack\') #空，报错

    def push(self,data): #压栈
        if not self.__ismaxlength(): #未到极限大小追加
            self.__stack.append(data)
        else:
            raise OverflowError(\'stack is full,insert fail\') #达到极限大小报错

    def __len__(self): #可使用len()获取栈大小
        return len(self.__stack)

测试一下：

if __name__ == \'__main__\':
    #栈实例化
    newstack = stack(10)
    print(\'栈的极限大小：%s\' % newstack.getmaxlength())
    newstack.push(\'a\')
    newstack.push(\'b\')
    newstack.push(\'c\')
    newstack.push(\'d\')
    newstack.push(\'e\')
    newstack.push(\'f\')
    print(\'栈实际大小:%s\' % len(newstack))
    print(newstack.pop())
    print(newstack.pop())
    print(newstack.pop())
    print(\'栈的极限大小：%s\' % newstack.getmaxlength())
    print(\'栈实际大小:%s\' % len(newstack))

    print(newstack.pop())
    print(newstack.pop())
    print(newstack.pop())
    print(newstack.pop()) #报错 IndexError: pop from empty stack

    newstack = stack(1)
    print(\'栈的极限大小：%s\' % newstack.getmaxlength())
    newstack.push(\'a\')
    newstack.push(\'b\') #报错 OverflowError: stack is full,insert fail

the end