Python3 面向对象-类-实操 随记

直接上实操：

#!/usr/bin/python3

'''
私有参数(__private_attrs)：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法：类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。可以用this，但最好用约定的self。
私有方法（__private_method）：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
'''

class mysClass:
    str1="I love earth!"
    def cats(self):
        return "I like food!"

# 实例化类必须+()，不然不算实例化
# 如果是os1=mysclass，那么在调用类函数时，需得实例化，如：os1().cats()
os1=mysClass()
# 访问类的属性和方法
print("打印类中变量str1：",os1.str1)
print("打印类中函数cats返回内容：",os1.cats())


# （Object）表示该类从哪个类继承下来的，Object类是所有类都会继承的类。
class Student(object):
    # 内置方法__init__方法，认为必须绑定的属性强制填写进去，可以相当于类的构造函数，实例化时会自动调用
    # 这里self就是指类的实例本身，self.name就是Student类的属性变量，是Student类所有。而name、score是外部传来的参数，不是Student类所自带的。
    # 故，self.name = name的意思就是把外部传来的参数name的值赋值给Student类自己的属性变量self.name。
    def __init__(self, name, course, score):
        self.name = name
        self.score = score
        # 内置变量带两个下划线“__”，就变成了一个私有变量（private），不被外部访问
        # 双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的；
        self.__course=course
    def printScore(self):
        print("调用父类中方法")
        print("姓名：%s 课程：%s 成绩：%s" %(self.name,self.__course,self.score))
    def __prinName(self):    # 私有函数，不被外部允许调用
        print("调用私有函数，打印name：",self.name)
    def prinN(self):    # 共有函数，可被外部调用，调用私有函数
        self.__prinName()
    def get_course(self):    # 通过方法允许外部获取私有变量__course
        return self.__course
    def set_course(self,course):   # 通过方法允许外部修改私有变量
        self.__course=course
    # 判断程序是自身运行启动，还是其他模块导入运行
    if __name__ == '__main__':
        print('程序自身在运行')
    else:
        print('我来自另一模块')

    '''
    富比较方法包括__lt__、__gt__分别表示：小于、大于，对应的操作运算符为:“<”、“>”
    1、比较对象大小会用到__lt__()或__gt__()，前者小于，后者大于；二者无关联，建议lt和gt为互反
    2、当自定义类中定义了lt方法，未定义gt方法时，进行”>”比较也是调用lt方法，只是对调用值求反 
    '''
    # def __gt__(self, other):
    #     return self.score > other.score
    def __lt__(self, other):
        return self.score < other.score


'''
1、__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
2、有了__init__内置方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去：
'''
print("\n\n---------带内置变量实例化---------")
student=Student("zhangsan","math","98")
print("打印学生名称：",student.name," 分数：",student.score)
student.printScore()
student1=Student("lisi","yuwen","93")
student1.printScore()


'''类中的私有变量__course调用'''
print("\n\n---------类中的私有变量__course调用---------")
# print("打印课程名：",student.__course)   此处不能在外部获取到类的私有变量
print("获取私有变量课程名：",student.get_course())
student.set_course("yuwen")
print("先设置为“yuwen”，再获取私有变量课程名：",student.get_course())

student.printScore()

print("\n---------共有属性函数调用私有函数---------")
# student.__prinName()    # 外部异常调用私有函数，报错
student.prinN()  # 外部调用共有函数，共有函数调用类中私有函数

print()
print("----------对象比较----------")
# 实际比较的是score
print("student.__lt__(student1) : ",student.__lt__(student1))
# 在此实际上“<”操作符已经调用了__lt__()函数
print("student<student1 : ",student<student1)
# 在未定义“>”时，会自动将__lt__()函数结果取反
print("student>student1 : ",student>student1)
# 列表为对象进行排序
a=[student,student1]
print("对象列表a：",a[0].score,a[1].score)
# 实际还是根据__lt__():的score进行排序的
# a.sort() 也是排序，但是会修改列表a中的顺序
b=sorted(a)   #升序
print("sorted默认升序",b[0].score,b[1].score)
# reverse=1(True)降序排列；默认为0(False)，及升序排列
c=sorted(a,reverse=False)
d=sorted(a,reverse=True)
print('升序：',c[0].score,c[1].score)
print('降序：',d[0].score,d[1].score)


print()
print("----------------类的继承（派生类）----------------")
class jiCheng(Student,mysClass):
    age1=''
    course1=''
    def __init__(self, name, course, score,age):
        # 调用父类的构造函数
        Student.__init__(self, name, course, score)
        mysClass.__init__(self)
        self.age1=age
        # 私有变量需要传递获取，不然会报错的
        self.course1=self.get_course()
    # 重写父类方法
    def printScore(self):
        print("调用子类中重写方法")
        print("姓名：%s 年龄：%s 课程：%s 成绩：%s" %(self.name,self.age1,self.course1,self.score))

# 调用子类方法
s=jiCheng('tester','maths','89','18')
s.printScore()
print("调用myClass类的方法cats()：",s.cats())

# 用子类对象调用父类已被覆盖的方法
super(jiCheng,s).printScore()

运行结果：

打印类中变量str1： I love earth!
打印类中函数cats返回内容： I like food!
程序自身在运行


---------带内置变量实例化---------
打印学生名称： zhangsan  分数： 98
调用父类中方法
姓名：zhangsan 课程：math 成绩：98
调用父类中方法
姓名：lisi 课程：yuwen 成绩：93


---------类中的私有变量__course调用---------
获取私有变量课程名： math
先设置为“yuwen”，再获取私有变量课程名： yuwen
调用父类中方法
姓名：zhangsan 课程：yuwen 成绩：98

---------共有属性函数调用私有函数---------
调用私有函数，打印name： zhangsan

----------对象比较----------
student.__lt__(student1) :  False
student<student1 :  False
student>student1 :  True
对象列表a： 98 93
sorted默认升序 93 98
升序： 93 98
降序： 98 93

----------------类的继承（派生类）----------------
调用子类中重写方法
姓名：tester 年龄：18 课程：maths 成绩：89
调用myClass类的方法cats()： I like food!
调用父类中方法
姓名：tester 课程：maths 成绩：89