面向对象编程

面向对象编程

一：类和实例

1.1：类的定义

class ClassName(object): 、
	pass
# class 后紧接着类名、类名是大写字母开头的单词，紧接着是object，表示该类是从哪个类继承下来的
  如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

1.2：实例的定义

exampleName = className()

1.3:类的初始化

class Student():
	def __init__(self,name,score):
		self.name = name # 将各种属性绑定到self
		self.score = score
通过__init__ 这个特殊方法来进行类的初始化
# self参数表示创建类的实例本身，相当于C语言中的this
# 有了__init__这个参数，在创建实例的时候就不能传入空的参数，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去。
# 和普通函数不同，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数，

1.4：方法--用来分装数据

class Student():
def __init__(self,name,age):
    self.name = name
    self.age = age
def eat(self): ## 与普通方法的区别就是在
    return self.name
stu = Student('zhangsan',10)
print(stu.eat()) --> zhangsan		

二：访问和限制

class Student():
def __init__(self,name,age,addre):
    self.name = name
    self.age = age
    # 实例的变量名如果以__开头，那么就变成了一个私有变量，只有内部可以访问，外部不可以进行访问
    self.__addre = addre
'''
 如果外部代码需要获取addre，可以给类增加get_name,get_score这样的方法。
 如果外部代码需要改变addre，可以给类增加set_name,set_score这样的方法
'''
def get_addre(self):
    return self.__addre
def set_addre(self,addre):
    return self.__addre == addre
def eat(self):
    return self.name,self.age,self.__addre
def __eat1(self):
    return self.name, self.age, self.__addre
stu = Student('zhangsan',19,2324)
stu.name = 'wangwu'
stu.age = 20
stu.addre = '2325' # 类的私有变量外部无法修改
# stu.__addre = 2323  # 外部对象无法直接访问以__开头的属性。AttributeError: type object 'str' has no attribute 'get_addre'
stu.set_addre('2325')
print(stu.eat())   # -->('wangwu', 20) 实例可以修改类内部的属性和方法
print(str.get_addre)

三：继承和多态

3.1：判断某个变量是某个类型

判断某个变量是某个类型可以用 isistance()
eg:
# 判断某个变量是某个类型
	list1 = [1,2]
	list2 = (1,2)
	list3 = {'list':'e','erw':'e'}
	print(isinstance(list1,list)) #  True
	print(isinstance(list2,set))  #  False
	print(isinstance(list2,tuple))  #  true
	print(isinstance(list3,dict)) # true
	print(isinstance(list1,set))  #false

3.2:继承

# 定义一个父类
class Aniamal():
    def run(self):
        return 'this is run'
# 定义二个子类其继承父类
class Dog(Aniamal):
    def eat(self,shucai):
        return 'my eat is%s'%shucai
    pass
class Pig(Aniamal):
    # 当子类存在和父类相同的方法时，子类方法会覆盖父类的方法
    def run(self):
        return 'this is a pig run'
    pass
dog1 = Dog()
print(isinstance(dog1,Dog))  # True
print(isinstance(dog1,Aniamal)) # True
pig1 = Pig()
# 因为Dog类继承了Aniamal类，所以也继承了此类下的所有方法
# 若子类继承父类，则会继承父类的全部功能
print(dog1.run())  # -->this is run
print(pig1.run())  # -->this is a pig run
print(dog1.eat('mifan')) # --> my eat ismifan

3.3：多态

class Aniamal():
def run(self):
    return 'this is run'
animal = Aniamal()
# 定义二个子类其继承父类
class Dog(Aniamal):
    def eat(self,shucai):
        return 'my eat is%s'%shucai
    pass
class Pig(Aniamal):
    # 当子类存在和父类相同的方法时，子类方法会覆盖父类的方法
    def run(self):
        return 'this is a pig run'
	# 在此方法中传入Animala实例对象
    def he(self,animal):
        return 'this is a %s'%animal
dog1 = Dog()
pig1 = Pig()
# 当pig实例对象调用不公的Animal实例时，会显示不同的内容
#多态的好处就是，当我们需要传入Dog、Cat、Tortoise……时，我们只需要接收Animal类型就可以了，因为Dog、Cat、Tortoise……都是Animal类型，
然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思
print(pig1.he(Aniamal()))
print(pig1.he(Pig()))

3.4：静态语言 vs 动态语言

对于静态语言（例如Java）来说，如果需要传入Animal类型，
则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。
我们只需要保证传入的对象有一个run()方法就可以了
class Timer(object):
def run(self):
    print('Start...')
这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，
走起路来像鸭子”，那它就可以被看做是鸭子。

四：获取对象信息

4.1:使用type（）方法来获取对象类型

a1 = 5
print(type(a1))  # --> <class 'int'>
class A():
    pass
a = A()
print(type(a)) # --> <class '__main__.A'>

4.2：使用isinstance()方法判断某个变量是某个类型

	list1 = [1,2]
	list2 = (1,2)
	list3 = {'list':'e','erw':'e'}
	print(isinstance(list1,list)) #  True
	print(isinstance(list2,set))  #  False
	print(isinstance(list2,tuple))  #  true
	print(isinstance(list3,dict)) # true
	print(isinstance(list1,set))  #false

4.3：使用dir()方法获取某个对象的所有属性和方法

class A():
def __init__(self):
    self.name = 'zhangsan'
    self.age = '20'
    self.addr = 'addr'
def run(self):
    return ''
def eat(self):
    return ''
pass
print(dir(A()))

五：实例属性和类属性

由于Python是动态语言，根据类创建的实例可以任意绑定属性。

5.1:给实例绑定属性的方法是通过实例变量，或者通过self变量：

class Student():
def __init__(self,name):
	# 通过self绑定实例属性
    self.name = name
stu = Student('zhansan')
# 通过实例变量绑定实例属性
stu.age = '20'
print(hasattr(stu, 'age'))  # -->True    

属性屏蔽

class Student():
name = 'zhansan'
stu = Student()
stu.age = '20'
print(stu.name)  # --> zhansan
stu.name = 'lisi'
# 不要对类属性和实例属性使用相同的名字，否则实例属性会屏蔽掉类属性
print(stu.name)  # --> lisi
print(Student().name)  # --> zhangsan