整理Python（面向对象编程）

面向对象编程的基本思想：类和实例

1.数据封装

class Person(object):                             #类名以大写字母开头,紧接着（object），表示该类是从哪个类继承下来的
    def __init__(self.name): 
        self.name=name

P1=Person('wang')
P2=Person('zhang')
P3=Person('zhao')

不同的实例，有相同的数据类型，有不同的属性

2.创建实例属性

#创建包含两个Person类的实例的list
#并给两个实例的name赋值，按照name排序
#sorted（）+比较函数

class Person(object):
    pass
p1=Person()
p1.name='zhang'

p2=Person()
p2.name='li'

p3=Person()
p3.name='sun'

L1=[p1,p2,p3]
L2=sorted(L1,key=lambda p:p.name.upper())

print(L2[0].name)
print(L2[1].name)
print(L2[2].name)

3.初始化实例属性

__init__()方法的第一个参数必须是self，后续参数可以自由指定，和定义函数没有任何区别

def Person(object):
    def __init__(selg,name,gender,birth,**kw):
        self.name=name
        self.gender=gender
        self.birth=birth
        for k,v in kw.iteritems():
            setattr(self.k,v)          #把k设为self对象的属性，v就是k属性的值
                                       #setatter( object,name,vales) 给对象 的属性 赋值，若属性不存在，先创建哉赋值
zhang=Person('tian','male','1990-10-25',job='student')

4.python中访问限制

如果一个属性由双下划线开头（__）,该属性无法被外部访问

__init__形式定义的属性成为特殊属性，不要随便__xxx__以此形式定义

#score 不能被外部访问
class Person(object):
    def __init__(self,name,score):
        self.name=name
        self.__score=score

p=Person('li',5)
print(p.name)
print(p.__score)

5.创建类属性

实例属性每个实例各自拥有，互相独立，而类属性有且只有一份

如果类上绑定一个属性，则所有实例都可以访问类的属性

class Person(object):
    address = 'Earth'
    def __init__(self,name):
        self.name=name

当类的属性修改时，所有实例的属性也都改变

#练习
#给Person添加一个类属性count
#每创建一个实例，count的属性+1

class Person(object):
    count=0
    def __init__(self,name):
        Person.count=Person.count +1      #创建实例必定会调用__init__()方法，所以在这里修改count属性
        self.name=name

p1=Person('zhao'
print(Person.count)

p2...

实例修改类属性，优先查找并返回实例属性，如果没有实例属性，再查找并返回类属性

实例属性优先

一个实例的私有属性就是以__开头的属性，无法被外部访问，但可以从内部访问

6.定义实例的方法

实例的方法就是在类中定义的函数，它的第一个参数永远是self，指向调用该方法的实例本身，其他参数和普通函数一样

class Person(object):
    
    def __init__(self,name):
        self.__name=name
   
    def get_name(self):
        retrun self.__name      #通过调用实例方法就可以从内部访问实例的私有属性

p1=Person('li')
print(p1.get_name())

在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得

这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度

7.实例方法也是一种属性，是一个函数对象

print(p1,get_name)     #返回的是函数对象
print(p1.get_name())   #返回的是函数值， 这个才是方法调用，调用函数对象，返回一个值

因为方法也是一种属性，所以就可以把它动态的添加到实例上，但是需要用 types/MethodType() 把一个函数变为方法      就是说这部分内容不用在Person里面嵌套住了，而是像实例一样在外面

p1.get_name=types.MethodType(get_name,p1,Person)

print(p1.get_name())

8.定义类方法

通过一个标记@classmethod，将该方法绑定到Person类上，而非实例上

类方法的第一个参数导入本身，通常将参数命名为cls，cls.count实际上相当于Person.count

类方法无法获得任何实际变量，只能获得类的引用

class Person(object):
    count=0              #类属性可以访问
    @classmethod         #添加类的方法
    def how_many(cls):
        return cls.count

    def __init__(self,name):
        self.name=name
        Person.count=Person.count+1

print(Person.how_many())
p1=Person('li')
print(Person.how_many())

如果类属性count改为私有属性__count,则外部无法获取__score,可以通过类方法获取

class Person(object):
    __count=0            #类属性不能访问

    @classmethod         #添加类的方法
    def how_many(cls):
        return cls.__count
    def __init__(self,name):
        self.name=name
        Person.__count=Person.__count+1
print(Person.how_many())