python 类和对象

类和对象

类

1.类的组成    数据和函数，二者是类的属性

2.两个作用： 实例化 属性引用　　

　　 属性引用：类名.属性(增删改查) 

　　 实例化: 类名加括号就是实例化，会自动出发__init__的运行，可以用它为每个实例创建自己的特征

1 2 3 4

类属性     特征(变量)           技能(函数)   对象属性：对象本身只有特征(变量)

 class Province:
     memo = "中国的23个省之一"                    #类的数据属性

     def __init__(self,name,capital,leader):
         self.Name = name
         self.Capital = capital
         self.Leadder = leader

     def sport_meet(self):
         print('%s 正在开运动会'% self.Name)

     def pao(self,pao):
         print('%s 正在放%s炮'% (self.Name,pao))

 -------------------类--------------------

 print(Province.__dict__)         #查看类属性字典

 print(Province.memo)             #查看类的数据属性
     中国的23个省之一
 print(Province.__dict__["memo"]) #查看类的数据属性
     中国的23个省之一

 Province.sport_meet("山西")               #查看类的函数属性
         正在开运动会
 Province.__dict__["sport_meet"]("山西")   #查看类的函数属性
         正在开运动会
 ---------------------------------------

 --------------类的其它属性------------------

 类名.__name__     # 类的名字(字符串)
 类名.__doc__      # 类的文档字符串
 类名.__base__     # 类的第一个父类(在讲继承时会讲)
 类名.__bases__    # 类所有父类构成的元组(在讲继承时会讲)
 类名.__dict__     # 类的字典属性
 类名.__module__   # 类定义所在的模块
 类名.__class__    # 实例对应的类(仅新式类中)

 ------------------------------------------

 # ----------------------对象--------------------

 hb = Province('河北','石家庄','李杨')            #创建实例
 print(hb.__dict__)
     {'Capital': '石家庄', 'Leadder': '李杨', 'Name': '河北'}

 print(hb.memo)          #实例调取类的数据属性
     中国的23个省之一

 hb.sport_meet()         #实例调取没有参数的函数
     河北 正在开运动会

 hb.pao("大")           #实例调取有参数的函数
     河北 正在放大炮

 类和对象分别调用 特征和函数

类和对象分别调用 特征和函数

 class Chinese:
     country="china"
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print("%s 正在打 %s" %(self.name,ball))

 p1=Chinese("alex")

 #对象执行类的数据属性
 # print(p1.country)
 #     china

 #对象改p1.country="日本"，相当于给对象的__dict__增加值，而不是改变类的数据属性
 print(p1.__dict__)
     # {'name': 'alex'}
 p1.country="日本"
 print(p1.__dict__)
     # {'name': 'alex', 'country': '日本'}
 print(p1.country)
     # 日本
 print(Chinese.country)
     #china

 #类里面的数据属性contry只会被Chinese.country和p1.country调用到
 country = "日本"

 class Chinese:
     country = "china"       #只会被类和对象调用到，带点的

     def __init__(self,name):
         self.name=name
         print(country)      #此时的country就是一个普通的变量

     def play_ball(self,ball):
         print("%s 正在打 %s" %(self.name,ball))

 p1=Chinese("alex")
     #日本

 #p1.l1 = [1,2,3]相当于给p1__dict__增加
 # p1.l1.append(5)相当于给原来的l1追加，相当于操作的是类
 class Chinese:
     l1 = ["alex","egon"]
     def __init__(self,name):
         self.name=name

     def play_ball(self,ball):
         print("%s 正在打 %s" %(self.name,ball))

 p1=Chinese("alex")

 p1.l1 = [1,2,3]
 print(Chinese.l1)
     #['alex', 'egon']

 #追加之后发现原来的l1也变了
 p1.l1.append(5)
 print(p1.l1)
     #['alex', 'egon', 5]
 print(Chinese.l1)
     #['alex', 'egon', 5]

静态方法　　staticmethod

 #静态方法，此时对象调类里面的函数不是绑定方法，而是普通的函数

 class Foo:
     @staticmethod
     def spam(x,y,z):    #没有self，即使有self，也会当成普通参数
         print(x,y,z)

 f2=Foo()
 f2.spam(1,2,3)

 Example 1 @staticmethod

Example 1 @staticmethod

 import time
 class Date:
     def __init__(self,year,month,day):
         self.year=year
         self.month=month
         self.day=day
     @staticmethod
     def now():                 #用Date.now()的形式去产生实例,该实例用的是当前时间
         t=time.localtime()     #获取结构化的时间格式
         obj=Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
         return obj

 #之前实例化
 # d1=Date(2017,1,13)
 # print(d1.year,d1.month,d1.day)
 #     2017 1 13

 #现在实例化,不需要传值
 # data_now = Date.now()
 # print(data_now.year,data_now.month,data_now.day)
 #     2017 4 22

 应用场景

应用场景

类方法　　classmethod

　　把一个方法绑定给类：类.绑定到类的方法(),会把类本身当做第一个参数自动传给绑定到类的方法

 class Foo:

     @classmethod #把一个方法绑定给类：类.绑定到类的方法(),会把类本身当做第一个参数自动传给绑定到类的方法
     def test(cls,x):
         print(cls,x) #拿掉一个类的内存地址后，就可以实例化或者引用类的属性了

 Foo.test(123)
     <class '__main__.Foo'> 123

 f = Foo()
 print(f.test)       # 发现现在对象调时候成了类的绑定方法
     <bound method Foo.test of <class '__main__.Foo'>>
 f.test(123)         #现在对象传值的时候第一个传的默认是类
     <class '__main__.Foo'> 123

 Example 1 @classmethod

Example 1 @classmethod

 #__str__定义在类内部，必须返回一个字符串类型，
 #什么时候会触发它的执行呢？打印由这个类产生的对象时，会触发执行

 class People:
     def __init__(self,name,age):
         self.name=name
         self.age=age
     def __str__(self):
         return 'name:%s,age:%s' %(self.name,self.age)

 p1=People('egon',18)
 print(p1)

 import time
 class Date:
     def __init__(self,year,month,day):
         self.year=year
         self.month=month
         self.day=day

     @classmethod
     def now(cls): #用Date.now()的形式去产生实例,该实例用的是当前时间
         t=time.localtime() #获取结构化的时间格式
         obj=cls(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
         return obj

 class EuroDate(Date):
     def __str__(self):
         return '年:%s,月:%s,日:%s' %(self.year,self.month,self.day)

 e1=EuroDate.now()
 print(e1)

 应用场景

应用场景

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

在类内部定义的函数无非三种用途 一：绑定到对象的方法     只要是在类内部定义的，并且没有被任何装饰器修饰过的方法，都是绑定到对象的           class Foo:         def test(self): #绑定到对象的方法             pass         def test1(): #也是绑定到对象的方法，只是对象.test1(),会把对象本身自动传给test1，因test1没有参数所以会抛出异常             pass           绑定到对象，指的是：就给对象去用，     使用方式：对象.对象的绑定方法()，不用为self传值     特性：调用时会把对象本身当做第一个参数传给对象的绑定方法               二：绑定到类的方法：classmethod     在类内部定义的，并且被装饰器@classmethod修饰过的方法，都是绑定到类的           class Foo:         def test(self): #绑定到对象的方法             pass         def test1(): #也是绑定到对象的方法，只是对象.test1(),会把对象本身自动传给test1，因test1没有参数所以会抛出异常             pass           绑定到对象，指的是：就给对象去用，     使用方式：对象.对象的绑定方法()     特性：调用时会把对象本身当做第一个参数传给对象的绑定方法             三：解除绑定的方法：staticmethod     既不与类绑定，也不与对象绑定，不与任何事物绑定     绑定的特性：自动传值（绑定到类的就是自动传类，绑定到对象的就自动传对象）     解除绑定的特性：不管是类还是对象来调用，都没有自动传值这么一说了           所以说staticmethod就是相当于一个普通的工具包             class Foo:     def test1(self):         pass     def test2():         pass                   @classmethod     def test3(cls):         pass     @classmethod     def test4():         pass                                   @staticmethod     def test5():         pass           test1与test2都是绑定到对象方法:调用时就是操作对象本身     <function Foo.test1 at 0x0000000000D8E488>     <function Foo.test2 at 0x0000000000D8E510> test3与test4都是绑定到类的方法：调用时就是操作类本身     <bound method Foo.test3 of <class '__main__.Foo'>>     <bound method Foo.test4 of <class '__main__.Foo'>> test5是不与任何事物绑定的:就是一个工具包，谁来都可以用，没说专门操作谁这么一说     <function Foo.test5 at 0x0000000000D8E6A8>

　　

面向对象的三大特性

一.继承

继承

　　继承是一种创建新的类的方式，在python中，新建的类可以继承自一个或者多个父类，原始类称为基类或超类，新建的类称为派生类或子类。 

　　python中类的继承分为：单继承和多继承

　　继承有两种用途：

　　1：继承基类的方法，并且做出自己的改变或者扩展（代码重用）

　　2：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，

　　　 并且实现接口中的功能

 class Animal:

     def eat(self):
         print "%s 吃 " %self.name

     def drink(self):
         print "%s 喝 " %self.name

     def shit(self):
         print "%s 拉 " %self.name

     def pee(self):
         print "%s 撒 " %self.name

 class Cat(Animal):

     def __init__(self, name):
         self.name = name
         self.breed ＝ '猫'

     def cry(self):
         print '喵喵叫'

 class Dog(Animal):

     def __init__(self, name):
         self.name = name
         self.breed ＝ '狗'

     def cry(self):
         print '汪汪叫'

 # ######### 执行 #########

 c1 = Cat('小白家的小黑猫')
 c1.eat()

 c2 = Cat('小黑的小白猫')
 c2.drink()

 d1 = Dog('胖子家的小瘦狗')
 d1.eat()

 继承

继承

组合

　　软件重用的重要方式除了继承之外还有另外一种方式，即：组合

　　组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

 class Teacher:
     def __init__(self,name,sex,course):
         self.name=name
         self.sex=sex
         self.course=course
 class Student:
     def __init__(self,name,sex,course):
         self.name=name
         self.sex=sex
         self.course=course
 class Course:
     def __init__(self,name,price,peroid):
         self.name=name
         self.price=price
         self.period=peroid
 python_obj=Course('python',15800,'7m')
 t1=Teacher('egon','male',python_obj)
 s1=Student('cobila','male',python_obj)

 print(s1.course.name)
 print(t1.course.name)

 学生老师和成绩组合

学生老师和成绩组合

组合与继承　　

　　组合对比继承来说，也是用来重用代码，但是组合描述的是一种“有”的关系

　　都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同　　

　　1.继承的方式

　　　　通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

　　　　当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师

　　2.组合的方式

　　　　用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程　　

 老师有课程
 学生有成绩
 学生有课程
 学校有老师
 学校有学生

 class Course:
     def __init__(self,name,price,period):
         self.name=name
         self.price=price
         self.period=period

 class Teacher:
     def __init__(name,course):
         self.name=name
         self.course=course

 class Student:
     def __init__(name,course):
         self.name=name
         self.course=course

 python=Course('python',15800,'7m')
 t1=Teacher('egon',python)
 s1=Student('alex',python)

 print(s1.course.name)
 print(s1.course.period)

 组合

组合

派生　

　　子类继承了父类的属性，然后衍生出自己新的属性，如果子类衍生出的新的属性与父类的某个属性名字相同，
　　那么再调用子类的这个属性，就以子类自己这里的为准了

 class People:
     def __init__(self,name,sex,age):
         self.name=name
         self.age=age
         self.sex=sex

     def walk(self):
         print('%s is walking' %self.name)

 class Chinese(People):
     country='China'
     def __init__(self,name,sex,age,language='Chinese'):
         People.__init__(self,name,sex,age)
         self.language=language

     def walk(self):
         People.walk(self)

 class North_korean(People):
     country='Korean'

 c=Chinese('egon','male',18)
 print(c.name,c.age,c.sex)
     egon 18 male
 print(c.__dict__)
     {'sex': 'male', 'age': 18, 'language': 'Chinese', 'name': 'egon'}
 print(c.country)
     China
 c.walk()
     egon is walking

 派生

派生

接口与归一化设计 

　　1.接口

　　为何要用接口:

　　　　接口提取了一群类共同的函数，可以把接口当做一个函数的集合。

　　　　然后让子类去实现接口中的函数。

　　　　这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。

　　　　归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

 class Interface:#定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
     def read(self): #定接口函数read
         pass

     def write(self): #定义接口函数write
         pass

 class Txt(Interface): #文本，具体实现read和write
     def read(self):
         print('文本数据的读取方法')

     def write(self):
         print('文本数据的读取方法')

 class Sata(Interface): #磁盘，具体实现read和write
     def read(self):
         print('硬盘数据的读取方法')

     def write(self):
         print('硬盘数据的读取方法')

 class Process(All_file):
     def read(self):
         print('进程数据的读取方法')

     def write(self):
         print('进程数据的读取方法')

 文件和程序的读写 接口设计

文件和程序的读写 接口设计　

　　2.抽象类

　　1 什么是抽象类

　　与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

　　2 为什么要有抽象类

　　 如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

 import abc
 #抽象类：本质还是类，与普通类额外的特点的是：加了装饰器的函数，子类必须实现他们
 class Animal(metaclass=abc.ABCMeta):
     tag=''
     @abc.abstractmethod
     def run(self):
         pass
     @abc.abstractmethod
     def speak(self):
         pass

 class People(Animal):
     def run(self):
         pass

     def speak(self):
         pass

 peo1=People()
 print(peo1.run)

 抽象类 import abc

抽象类 import abc

 #_*_coding:utf-8_*_
 __author__ = 'Linhaifeng'
 #一切皆文件
 import abc #利用abc模块实现抽象类

 class All_file(metaclass=abc.ABCMeta):
     all_type='file'
     @abc.abstractmethod #定义抽象方法，无需实现功能
     def read(self):
         '子类必须定义读功能'
         pass

     @abc.abstractmethod #定义抽象方法，无需实现功能
     def write(self):
         '子类必须定义写功能'
         pass

 # class Txt(All_file):
 #     pass
 #
 # t1=Txt() #报错,子类没有定义抽象方法

 class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('文本数据的读取方法')

     def write(self):
         print('文本数据的读取方法')

 class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('硬盘数据的读取方法')

     def write(self):
         print('硬盘数据的读取方法')

 class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('进程数据的读取方法')

     def write(self):
         print('进程数据的读取方法')

 wenbenwenjian=Txt()

 yingpanwenjian=Sata()

 jinchengwenjian=Process()

 #这样大家都是被归一化了,也就是一切皆文件的思想
 wenbenwenjian.read()
 yingpanwenjian.write()
 jinchengwenjian.read()

 print(wenbenwenjian.all_type)
 print(yingpanwenjian.all_type)
 print(jinchengwenjian.all_type)

 接口继承

接口继承

2 继承顺序原理（python如何实现的继承）

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:
1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类

 class A(object):
     def test(self):
         print('from A')

 class B(A):
     def test(self):
         print('from B')

 class C(A):
     def test(self):
         print('from C')

 class D(B):
     def test(self):
         print('from D')

 class E(C):
     def test(self):
         print('from E')

 class F(D,E):
     # def test(self):
     #     print('from F')
     pass
 f1=F()
 f1.test()
 print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

 #新式类继承顺序:F->D->B->E->C->A
 #经典类继承顺序:F->D->B->A->E->C
 #python3中统一都是新式类
 #pyhon2中才分新式类与经典类

 继承顺序

继承顺序

3.子类调用父类的方法

子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法

方法一：父类名.父类方法()

 class Vehicle: #定义交通工具类
      Country='China'
      def __init__(self,name,speed,load,power):
          self.name=name
          self.speed=speed
          self.load=load
          self.power=power

      def run(self):
          print('开动啦...')

 class Subway(Vehicle): #地铁
     def __init__(self,name,speed,load,power,line):
         Vehicle.__init__(self,name,speed,load,power)
         self.line=line

     def run(self):
         print('地铁%s号线欢迎您' %self.line)
         Vehicle.run(self)

 line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
 line13.run()

方法二：super()

 super在python2中的用法：
     1:super(自己的类,self).父类的函数名字
     2：super只能用于新式类
 class People(object):
     def __init__(self,name,sex,age):
         self.name=name
         self.age=age
         self.sex=sex
     def walk(self):
         print('%s is walking' %self.name)
 class Chinese(People):
     country='China'
     def __init__(self,name,sex,age,language='Chinese'):
         super(Chinese,self).__init__(name,sex,age)
         self.language=language
 c=Chinese('egon','male',18)
 print c.name,c.age,c.sex,c.language

 python2 supper

python2 supper

 class People:
     def __init__(self,name,sex,age):
         self.name=name
         self.age=age
         self.sex=sex
     def walk(self):
         print('%s is walking' %self.name)
 class Chinese(People):
     country='China'
     def __init__(self,name,sex,age,language='Chinese'):
         # self.name=name
         # self.sex=sex
         # self.age=age
         # People.__init__(self,name,sex,age)
         super(Chinese,self).__init__(name,sex,age)
         self.language=language
     def walk(self,x):
         super().walk()
         print('子类的x',x)
 c=Chinese('egon','male',18)
 print(c.name,c.age,c.sex,c.language)
 c.walk(123)

 python3 supper

python3 supper

二.多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）

　　1. 序列类型有多种形态：字符串，列表，元组。

　　2. 动物有多种形态：人，狗，猪

　　3. 文件有多种形态：文件文件，可执行文件

 import abc
 class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
     @abc.abstractmethod
     def talk(self):
         pass

 class People(Animal): #动物的形态之一:人
     def talk(self):
         print('say hello')

 class Dog(Animal): #动物的形态之二:狗
     def talk(self):
         print('say wangwang')

 class Pig(Animal): #动物的形态之三:猪
     def talk(self):
         print('say aoao')

 动物多态

动物多态

 import abc
 class File(metaclass=abc.ABCMeta): #同一类事物:文件
     @abc.abstractmethod
     def click(self):
         pass

 class Text(File): #文件的形态之一:文本文件
     def click(self):
         print('open file')

 class ExeFile(File): #文件的形态之二:可执行文件
     def click(self):
         print('execute file')

 文件有多种形态：文件文件，可执行文件

文件有多种形态：文件文件，可执行文件

多态性

同一种调用方式，不同的调用效果

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。

在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

综上我们也可以说，多态性是‘一个接口（函数func）

 class Animal:
     def run(self):
         raise AttributeError('子类必须实现这个方法')

 class People(Animal):
     def run(self):
         print('people is walking')

 class Pig(Animal):
     def run(self):
         print('pig is walking')

 class Dog(Animal):
     def run(self):
         print('dog is running')

 peo1=People()
 pig1=Pig()
 ------------------人和猪都有run方法---------
 peo1.run()
 pig1.run()
     people is walking
     pig is walking

 -----------------多态性，函数把run方法包装------------
 多态性：定义统一的接口，可以传入不同类型的值，但是调用的逻辑都一样，执行的结果却不一样
 def Run(name):
     name.run()

 Run(peo1)
 Run(pig1)
     people is walking
     pig is walking

 多态性

多态性

三.封装

　　为什么要封装

　　　　封装数据的主要原因是：保护隐私（作为男人的你，脸上就写着：我喜欢男人，你害怕么？）

　　　　封装方法的主要原因是：隔离复杂度（快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了

比如你不必知道你的鸟是怎出来的，你直接掏出自己的接口就能用尿这个功能）

　　封装的两个层面

　　　　1.第一个层面的封装：（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装　　

　　　　2.第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问

 class A:
     __x = 1             #转换为_A__x
     def __test(self):
         print("from A")

 print(A.__dict__)
     {   '_A__x': 1  }

 ------查看类的隐藏属性————

 obj = A()
 print(A._A__x)
 print(obj._A__x)
 A._A__test(123)
     from A
 obj._A__test()
     from A

 封装

封装

特性（property）

　　 property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

 import math
 class Circle:
     def __init__(self,radius): #圆的半径radius
         self.radius=radius

     @property
     def area(self):
         return math.pi * self.radius**2 #计算面积

     @property
     def perimeter(self):
         return 2*math.pi*self.radius #计算周长

 c=Circle(10)
 print(c.radius)
 print(c.area)         #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
 print(c.perimeter)
 -----------------------执行结果--------
 314.1592653589793
 62.83185307179586

 property

property

 class People:
     def __init__(self,name,age,height,weight):
         self.name=name
         self.age=age
         self.height=height
         self.weight=weight
     @property
     def bodyindex(self):
         return self.weight/(self.height**2)

 p1=People('cobila',38,1.65,74)
 print(p1.bodyindex)
 p1.weight=200
 print(p1.bodyindex)

 ------------------------结果---------

 27.180899908172638
 73.46189164370983

 BMI 指数

BMI 指数

 class People:
     def __init__(self,name):
         self.__name = name

     @property
     def name(self):
         return self.__name

 p1 = People("egon")
 print(p1.name)      #会找含有@property下name的函数

 -----------------------------
 egon

 @property 查找

@property 查找

 class People:
     def __init__(self,name,Sex):
         self.name = name
         self.__sex = Sex

     @property
     def sex(self):
         return self.__sex

     @sex.setter
     def sex(self,value):
         self.__sex = value

 p1 = People("egon","male")
 print(p1.sex)      #会找含有@property下name的函数

 p1.sex = "famale"  #修改会找@sex.setter下的函数
 print(p1.sex)

 ---------------------
 male
 famale

 #修改性别，判断性别如果不为字符串，就报错
 class People:
     def __init__(self,name,Sex):
         self.name = name
         self.__sex = Sex

     @property
     def sex(self):
         return self.__sex

     @sex.setter
     def sex(self,value):
         if not isinstance(value,str):      #如果性别不为字符串，就报错
             raise TypeError("性别必须为字符串")
         self.__sex = value

 p1 = People("egon","male")
 p1.sex = 123           #修改会找@sex.setter下的函数
 print(p1.sex)

 -----------------
 TypeError: 性别必须为字符串

 # 实例化时后，如果不是字符串，也报错
 class People:
     def __init__(self,name,Sex):
         self.name = name
         self.sex = Sex      #此时是self.sex，而不是self.__sex

     @property
     def sex(self):
         return self.sex

     @sex.setter
     def sex(self,value):
         if not isinstance(value,str):      #如果性别不为字符串，就报错
             raise TypeError("性别必须为字符串")
         self.__sex = value

 p1 = People("egon",111)     #执行报错

 ----------------
 TypeError: 性别必须为字符串

 @property 修改

@property 修改

 # 实例化时，删除性别
 class People:
     def __init__(self,name,Sex):
         self.name = name
         self.sex = Sex      #此时是self.sex，而不是self.__sex
                         #实例化self.sex时候，会执行下面的@sex.setter内容
     @property
     def sex(self):
         return self.__sex

     @sex.setter
     def sex(self,value):
         if not isinstance(value,str):      #如果性别不为字符串，就报错
             raise TypeError("性别必须为字符串")
         self.__sex = value

     @sex.deleter
     def sex(self):
         del self.__sex

 p1 = People("egon","male")
 print(p1.sex)
     male
 del p1.sex          #删除
 print(p1.sex)
     报错

 @property 删除

@property 删除