Python基础（8）类和对象

2022-05-23 05:26 142阅读 0赞

#coding=gbk
    import math
    #类的练习
    class Person:
        country='china' #属性
        def __init__(self,name,age):    #构造函数,可以向__init__()方法传递参数
            self.name=name
            self.age=age
        def say_hello(self):    #定义函数方法
            print('名字是：',self.name+ ' 年龄为： ',self.age)
    p1=Person('张三',24)  #__init__
    p1.say_hello()#调用函数方法
    print(p1.age)
    print(p1.country)
    print(Person.country)#静态的属性

#类的私有属性
    class Person1():
        __name='hello world'  #两个下划线代表是私有属性，只有类内才能访问__
                                #Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问
        def get_name(self):
            print(Person1.__name)
    p2=Person1()
    p2.get_name()
    #p2.__name 不能访问
    
    #@property装饰器，来访问私有属性
    class Person11():
        def __init__(self,name):
            self.__name=name
        @property
        def name1(self):
            return self.__name
    p1=Person11('王五')
    print(p1.name1)
    
    #私有方法，外部不能直接调用，可在类中方法中调用，再输出
    class Book():
        def __init__(self,name,author,price):
            self.name=name
            self.price=price
            self.author=author
        def __check_book(self):
            if( self.name==' '):return False
            else: return True
        def get_book(self):
            if self.__check_book(): print(self.name + ' ',self.author)  #在__check_book前需要加上self
            else:print('no vallue')
           
    b=Book('数据结构','李四',14)
    b.get_book()    #通过公有的方法访问
    #b.__check_book() 不能访问

#方法的重载------本实例未成功
    class Person12():
        def __init__(self,name):
            self.name=name
        def say_hello(self,name):
            self.name=name
            print('您好呀：',self.name)
        def say_hello1(self,name,age):
            self.name=name
            self.age=age
            print('您好呀：',self.name+"年龄为：",self.age)
    p12=Person12('zhangsan ')
    p12.say_hello('张三')
    #p12.say_hello('李四',15)

#类的继承实例
    class Person():
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def say_hi(self):
            print('你好呀：',self.name+ '  我 ',self.age)
    class Student(Person):
        def __init__(self,name,age,stu_id):
            Person.__init__(self, name, age)
            self.stu_id=stu_id
        def say_hi(self):
            Person.say_hi(self)
            print('我的学号是：',self.stu_id)
    p22=Person('王五',15)
    p22.say_hi()
    s1=Student('张三',16,'13-24-56')
    s1.say_hi()
    #输出为你好呀： 王五  我  15
    # 你好呀： 张三  我  16
    # 我的学号是： 13-24-56

#类成员的继承和重写
    #dimension,circle,rectangle
    class Dimension():
        def __init__(self,x,y):  #构造函数
            self.x=x
            self.y=y
        def area(self):
            pass
    class Circle(Dimension):
        def __init__(self,r):
            Dimension.__init__(self, r, 0)  #派生类必须调用基类的构造函数
        def area(self):
            return self.x*math.pi*self.x
    class Rectangle(Dimension):
        def __init__(self,w,h):
            Dimension.__init__(self, w, h)
        def area(self):
            return self.x*self.y
    d1=Circle(2.0)
    d2=Rectangle(2.0,4.0)
    print(d1.area(), d2.area())

#此种方法比较好
    import math
    class Shape:
        def area(self):
            return 0
            
    class Circle(Shape):
        def __init__(self, r=0.0):
            self.r = r
     
        def area(self):
            return math.pi * self.r * self.r
     
    class Rectangle(Shape):
        def __init__(self, a, b):
            self.a, self.b = a, b
     
        def area(self):
            return self.a * self.b
    c=Circle(12)
    r=Rectangle(12.0,13)
    print(c.area())
    print(r.area())

有关于多态:

首先[Python][]不支持多态，也不用支持多态，[python][Python]是一种多态语言，崇尚鸭子类型。以下是维基百科中对鸭子类型得论述：

在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子[测试][Link 1]，“鸭子测试”可以这样表述：

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

*  在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，  
    
 *  在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。  
    
 *  在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

*  鸭子类型通常得益于不测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。从静态类型语言转向动态类型语言的用户通常试图添加一些静态的（在运行之前的）类型检查，从而影响了鸭子类型的益处和可伸缩性，并约束了语言的动态特性。

[Python]: http://lib.csdn.net/base/python
[Link 1]: http://lib.csdn.net/base/softwaretest