python 数据结构零 之 python类

python 数据结构教程第零课
首先展示一些基本类的源码，供对python语言还不是很熟悉的同学学习了解，这里提供 Time类、Date类、Rational类、Student类、Person类、staff类源码
1.时间类

#时间值错误提示
class TimevalueError(ValueError):
    pass

#24小时 时间类
class Time:
    #类初始化
    def __init__(self,hours = 0,minutes = 0,seconds = 0):

 if hours > 24 or hours < 0 or type(hours) is not int:
     raise TimevalueError('Hours is wrong',hours)
 if minutes > 60 or minutes < 0 or type(minutes) is not int:
     raise TimevalueError('minutes is wrong',minutes)
 if seconds > 60 or seconds <0 or type(seconds) is not int:
     raise TimevalueError('seconds is wrong',seconds)
 self.__hours = hours
 self.__minutes = minutes
 self.__seconds = seconds

    #将时间转化为秒
    def __absolutevalue(self):
 return self.__hours * 3600 + self.__minutes * 60 + self.__seconds

    #返回小时
    def hours(self):
 return self.__hours

    #返回分钟
    def minutes(self):
 return self.__minutes

    #返回秒
    def seconds(self):
 return self.__seconds

    #支持两个时间相加
    def __add__(self,other):
 time = Time()
 time.__seconds = (self.__seconds + other.__seconds)%60
 s_add = (self.__seconds + other.__seconds)//60
 if s_add == 1:
     time.__minutes = (self.__minutes + other.__minutes + 1)%60  
 else:
     time.__minutes = (self.__minutes + other.__minutes)%60
 m_add = (self.__minutes + other.__minutes)//60
 if m_add == 1: 
     time.__hours = (self.__hours + other.__hours + 1)%24 
 else: time.__hours = (self.__hours + other.__hours)%24
 return time

    #支持两个时间相减
    def __sub__(self,other):
 time = Time()
 Error = self.__absolutevalue() - other.__absolutevalue()
 if Error < 0:
     raise TimevalueError('sub is wrong')
 time.__hours = Error // 3600
 time.__minutes = (Error - time.__hours * 3600) // 60
 time.__seconds = (Error - time.__hours * 3600 - time.__minutes * 60)
 return time

    #时间 == 符号的支持函数
    def __eq__(self,other):
 return self.__absolutevalue() == other.__absolutevalue()

    #时间 < 符号的支持函数
    def __lt__(self,other):
 return self.__absolutevalue() < other.__absolutevalue()

    #输出时间
    def showTime(self):
 print(str(self.__hours) + ':' + str(self.__minutes) + ':' + str(self.__seconds))

2.日期类

#时间值错误提示
class TimevalueError(ValueError):
    pass

#日期类
class Date:

    #类方法 判断某一年是否是闰年
    @classmethod
    def RY(cls,year):
 if (year % 4 == 0 or year % 400 == 0) and year % 100 != 0:
     return True
 else:
     return False

    #日期初始化    
    def __init__(self,year = 1,month = 1,day = 1):
 if year < 0 or type(year) is not int:
     raise TimevalueError('year is wrong',year)
 if month > 12 or month <= 0 or type(month) is not int:
     raise TimevalueError('month is wrong',month)
 if Date.RY(year) and month == 2:
     if day > 29 or day < 0 or type(day) is not int:
  raise TimevalueError('day is wrong',day)
 else:
     if day > 28 or day < 0 or type(day) is not int:
  raise TimevalueError('day is wrong',day)
 self.__year = year
 self.__month = month
 self.__day = day 

    #返回年
    def year(self):
 return self.__year

    #返回月
    def month(self):
 return self.__month

    #返回日
    def day(self):
 return self.__day

    #将日期转化为天
    def date_To_day(self):
 count = 0
 loop = int(self.__year)
 for i in range(loop):
     if Date.RY(i):
  count += 1
 if Date.RY(self.__year) and self.__month > 2:
     count += 1
 if self.__month == 1:
     return (self.__year - 1) * 365 + self.__day + count
 elif self.__month == 2:
     return (self.__year - 1) * 365 + self.__day + 31 + count
 elif self.__month == 3:
     return (self.__year - 1) * 365 + self.__day + 31 + 28 + count
 elif self.__month == 4:
     return (self.__year - 1) * 365 + self.__day + 31 * 2 + 28 + count
 elif self.__month == 5:
     return (self.__year - 1) * 365 + self.__day + 31 * 2 + 30 +28 + count
 elif self.__month == 6:
     return (self.__year - 1) * 365 + self.__day + 31 * 3 + 30 +28 + count 
 elif self.__month == 7:
     return (self.__year - 1) * 365 + self.__day + 31 * 3 + 30 * 2 +28 + count
 elif self.__month == 8:
     return (self.__year - 1) * 365 + self.__day + 31 * 4 + 30 * 2 +28 + count    
 elif self.__month == 9:
     return (self.__year - 1) * 365 + self.__day + 31 * 5 + 30 * 2 +28 + count
 elif self.__month == 10:
     return (self.__year - 1) * 365 + self.__day + 31 * 5 + 30 * 3 +28 + count     
 elif self.__month == 11:
     return (self.__year - 1) * 365 + self.__day + 31 * 6 + 30 * 3 +28 + count
 elif self.__month == 12:
     return (self.__year - 1) * 365 + self.__day + 31 * 6 + 30 * 4 +28 + count     
 else:
     return (self.__year - 1) * 365

    #类方法，将天转化为日期
    @classmethod
    def day_To_date(cls,day):
 Hundredsy_day = 365 * 400 + (400 / 4 - 400 / 100)
 Hundredy_day = 365 * 100 + (100 / 4 - 1)
 Foury_day = 365 * 4 + 1
 Y_day = 365
 y_400 = day // Hundredsy_day
 y_100 = (day - y_400 * Hundredsy_day) // Hundredy_day
 y_4 = (day - y_400 * Hundredsy_day - y_100 * Hundredy_day) // Foury_day
 if (day - y_400 * Hundredsy_day - y_100 * Hundredy_day - Foury_day * y_4) < 1460:
     Y_1 = (day - y_400 * Hundredsy_day - y_100 * Hundredy_day - Foury_day * y_4) // Y_day
 elif (day - y_400 * Hundredsy_day - y_100 * Hundredy_day - Foury_day * y_4) == 1460:
     Y_1 = (day - y_400 * Hundredsy_day - y_100 * Hundredy_day - Foury_day * y_4) // Y_day - 1
 day_remain = day - y_400 * Hundredsy_day  - y_100 * Hundredy_day - Foury_day * y_4  - Y_day * Y_1 
 date = Date()
 date.__year = y_400 * 400 + y_100 * 100 + y_4 * 4 + Y_1 + 1

 if Date.RY(date.__year):
     if day_remain <= 31:
  date.__month = 1
  date.__day = day_remain
     elif day_remain <= 60:
  date.__month = 2
  date.__day = day_remain - 31
     elif day_remain <= 91:
  date.__month = 3
  date.__day = day_remain - 60
     elif day_remain <= 121:
  date.__month = 4
  date.__day = day_remain - 91
     elif day_remain <= 152:
  date.__month = 5
  date.__day = day_remain - 121
     elif day_remain <= 182:
  date.__month = 6
  date.__day = day_remain - 152
     elif day_remain <= 213:
  date.__month = 7
  date.__day = day_remain - 182
     elif day_remain <= 244:
  date.__month = 8
  date.__day = day_remain - 213
     elif day_remain <= 274:
  date.__month = 9
  date.__day = day_remain - 244
     elif day_remain <= 305:
  date.__month = 10
  date.__day = day_remain - 374
     elif day_remain <= 335:
  date.__month = 11
  date.__day = day_remian - 305
     elif day_remain < 366:
  date.__month = 12
  date.__day = day_remain - 335
     else:
  print(day_remain)
 elif not Date.RY(date.__year):
     if day_remain <= 31:
  date.__month = 1
  date.__day = day_remain
     elif day_remain <= 59:
  date.__month = 2
  date.__day = day_remain - 31
     elif day_remain <= 90:
  date.__month = 3
  date.__day = day_remain - 59
     elif day_remain <= 120:
  date.__month = 4
  date.__day = day_remain - 90
     elif day_remain <= 151:
  date.__month = 5
  date.__day = day_remain - 120
     elif day_remain <= 181:
  date.__month = 6
  date.__day = day_remain - 151
     elif day_remain <= 212:
  date.__month = 7
  date.__day = day_remain - 181
     elif day_remain <= 243:
  date.__month = 8
  date.__day = day_remain - 212
     elif day_remain <= 273:
  date.__month = 9
  date.__day = day_remain - 243
     elif day_remain <= 304:
  date.__month = 10
  date.__day = day_remain - 373
     elif day_remain <= 334:
  date.__month = 11
  date.__day = day_remian - 304
     elif day_remain < 365:
  date.__month = 12
  date.__day = day_remain - 334
     else:
  print(day_remain)
 if day_remain == 0:
     date.__year -= 1
     date.__month = 12
     date.__day = 31
 return date

    #日期相减，返回天数
    def __sub__(self,other):
return abs(self.date_To_day() - other.date_To_day())

    #日期相加，返回日期      
    def plus(self,day):
 day = self.date_To_day() + day
 return Date.day_To_date(day) 

    #类方法，某一年的第n天日期 
    @classmethod  
    def num_date(cls,year,n):
 date = Date()
 date.__year = year
 day = date.date_To_day() + n -1
 a = Date.day_To_date(day)
 return a

    #类方法 ，某一日期，n天（可正可负）后日期
    @classmethod
    def adjust(cls,d,n):
 print('aaaa')
 day = d.date_To_day() + n
 print('bbbbb')
 return Date.day_To_date(day)

    #显示日期
    def show(self):
 print(str(int(self.__year))+'/'+str(int(self.__month))+'/'+str(int(self.__day)))

3.有理数类

#有理数类
class Rational(object):
    #计算两者的最大公约数
    @staticmethod
    def _gcd(m,n):
 if n == 0:
     m,n = n,m
 while m != 0:
     m,n = n % m,m
 return n

    #有理数初始化，分数形式
    def __init__(self,num,den = 1):
 if isinstance(num,float):
     (self._num,self._den) = num.as_integer_ratio()
 else:    
     sign = 1
     if num < 0:
  num,sign = -num,-sign
     if den < 0:
  den, sign = -den,-sign
     g = Rational._gcd(num,den)
     self._num = sign * (num // g)
     self._den = den // g

    静态方法，new用于实例化之前判断参数是否合理
    @staticmethod
    def __new__(cls,num,den = 1):
 if (not isinstance(num,float) and not isinstance(num,int)) or not isinstance(den,int):
     raise TypeError
 if den == 0:
     raise ZeroDivisionError
 return object.__new__(cls)

     返回分子   
    def num(self):
 return self._num
    返回坟墓
    def den(self):
 return self._den

    #有理数相加
    def __add__(self,another):
 den = self._den * another.den()
 num = (self._num * another.den + self._den * another.num())
 return Rational(num,den)

    #有理数相乘
    def __mul__(self,another):
 return Rational(self._num * another.num(),self._den * another.den())

    #有理数相除
    def __floordiv__(self,another):
 if another.num() == 0:
     raise ZeroDivisionError
 return Rational(self._num * another.den(),self._den * another.num())

    #有理数相减
    def __sub__(self,another):
 num = self._num * another.den() - another.num() * self._den
 den = self._den * another.den()
 return Rational(num,den)

    #有理数除法，返回float
    def __truediv__(self,another):
 if another.num() == 0:
     raise ZeroDivisionError
 if not isinstance(another,Rational):
     raise TypeError
 return (self._num * another.den())/(self._den * another.num())

    #取有理数余数
    def __mod__(self,another):
 if another.num() == 0:
     raise ZeroDivisionError
 if not isinstance(another,Rational):
     raise TypeError
 a = int(self / another)
 b = another * Rational(a)
 return (self - b)

    #转化为int
    def int(self):
 return int(self._num / self._den)

    #转化为float
    def float(self):
 return float(self._num / self._den)

    #以下是各种比较符号支持函数
    def __eq__(self,another):
 return self._num * another.den() == self._den * another.num()

    def __lt__(self,another):
 return self._num * another.den() < self._den * another.num()

    def __ne__(self,another):
 return self._num * another.den() != self._den * another.num()

    def __le__(self,another):
 return self._num * another.den() <= self._den * another.num()

    def __gt__(self,another):
 return self._num * another.den() > self._den * another.num()

    def __ge__(self,another):
 return self._num * another.den() >= self._den * another.num()

    #转化为字符串
    def __str__(self):
 return str(self._num) + '/' +str(self._den)

    #输出有理数
    def print(self):
 print(self._num,'/',self._den)

4.’人 ‘类

import datetime

class PersonTypeError(TypeError):
    pass

class PersonValueError(ValueError):
    pass

# ’人‘类
class Person:
    #产生与类相关的一个编号，每次实例化加1
    __num = 0

    #初始化
    def __init__(self,name,sex,birthday,ident):
 if not (isinstance(name,str) and sex in ('女','男')):
     raise PersonValueError(name,sex)
 try:
     birth = datetime.date(*birthday)
 except:
     raise PersonValueError('Wrong date',birthday)
 self._name = name
 self._sex = sex
 self._birthday = birth
 self._id = ident
 Person.__num += 1

    #返回基本信息
    def id(self):
 return self._id

    def name(self):
 return self._name

    def sex(self):
 return self._sex

    def birthday(self):
 return self._birthday

    def age(self):
 return datetime.date.today().year - self._birthday.year

    #设置名称
    def set_name(self,name):
 if not isinstance(name,str):
     raise PersonValueError('set_name',name)
 self._name = name

    # <符号支持
    def __lt__(self,another):
 if not isinstance(another,Person):
     raise PersonTypeError(another)
 return self._id < another._id

    #类方法，返回编号
    @classmethod
    def num(cls):
 return Person.__num

    #字符串化
    def __str__(self):
 return  ' '.join((self._id,self._name,self._sex,str(self._birthday)))

    #显示信息
    def details(self):
 return ','.join(('编号：' + self._id,'姓名：' + self._name,'性别：' + self._sex,'出生日期:' +str(self._birthday)))

5.学生类

import datetime

class PersonTypeError(TypeError):
    pass

class PersonValueError(ValueError):
    pass

 #学生类，继承与‘人’类
class Student(Person):
    _id_num = 0

    #类方法，产生学生ID
    @classmethod
    def _id_gen(cls):
 cls._id_num += 1
 year = datetime.date.today().year
 return '1{:04}{:05}'.format(year,cls._id_num)

    #初始化
    def __init__(self,name,sex,birthday,department):
 Person.__init__(self,name,sex,birthday,Student._id_gen())
 self._department = department
 self._enroll_date = datetime.date.today()
 self._courses = {}

    #给学生加课函数     
    def set_course(self,course_name):
 self._courses[course_name] = None

    #设置课程分数
    def set_score(self,course_name,score):
 if course_name not in self._courses:
     raise PersonValueError('No this course selected:',course_name)

 self._courses[course_name] = score

    #返回分数
    def scores(self):
 return [(cname,self._courses[cname]) for cname in self._courses]

    #返回学生信息
    def details(self):
 return ','.join((Person.details(self),'入学日期：' + str(self._enroll_date),'院系：' + self._department,'课程日期：' + str(self.scores())))

6.员工类

#员工类
class Staff(Person):
    _id_num = 0
    #获得ID
    @classmethod
    def _id_gen(cls,birthday):
 cls._id_num += 1
 birth_year = datetime.date(*birthday).year
 return '0{:04}{:05}'.format(birth_year,cls._id_num)

    #初始化
    def __init__(self,name,sex,birthday,entry_date = None):

 super().__init__(name,sex,birthday,Staff._id_gen(birthday))

 if entry_date:
     try:
  self._entry_date = datetime.date(*entry_date)
     except:
  raise PersonValueError('Wrong date',entry_date)

 else:
     self._entry_date = datetime.date.today()
 self._salary = 1720
 self._department = '未定'
 self._position  = '未定'

    #设置工资    
    def set_salary(self,amount):
 if not type(amount) is int:
     raise TypeError
 self._salary = amount

    #设置职位
    def set_position(self,amount):
 self._position = amount

    #显示信息    
    def details(self):
 return ','.join((super().details(),'入职日前：' + str(self._entry_date),'院系：' + self._department,'职位：' + self._position,'工资：' + str(self._salary)))
    #设置部门
    def set_department(self,apart):
 self._department = apart