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