python_13 面向对象

面向对象

 类：把一类事物的相同特征和动作整合到一起就是类，类是一个抽象的概念

对象：就是基于类出而创建的一个具体的事物或实例（具体存在），其特征和动作整合到一起

面向对象设计：将一类具体事物的数据和动作整合到一起，即面向对象设计

 

 

def dog(name,gender,type):


    def jiao():
        print('一条狗%s正在叫'%name)

    def chishi():
        print('%s正在吃fan'%name)

    def init(name,gender,type):
        doog={
            'name':name,
            'gender':gender,
            'type':type,
            'jiao':jiao,
            'chishi':chishi
        }
        return doog
    res=init(name,gender,type)
    return res


d1=dog('alex','母','藏獒')
print(d1)
d1['jiao']()
d1['chishi']()

 

面向对象编程：用定义类+实例/对象的方式去实现面向对象的设计

使用class独特的语法完成面向对象设计，使用class后无需return   init函数的结果，本质上是初始化函数并返回init函数的值

class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type
    def jiao(self):
        print('一条狗%s正在叫'%self.name)

    def chishi(self):
        print('%s正在吃fan'%self.name)


dog1=Dog('alex','female','京巴')
dog2=Dog('blex','male','藏獒')
dog3=Dog('clex','male','腊肠')

dog1.chishi()
dog2.jiao()
print(dog1.__dict__)

 

声明类：

class Chinese:
    '''
    这是中国人的类
    '''

    pass

print(Chinese)

#创建一个类
class Data:
    pass



#用类Data实例化出一个对象d1
d1=Data()

python2中class Chinese：为经典类，class Chinese（父类）：为新式类

pyhton3中上述两类都是新式类

 

属性

 类是用来描述一类事物，类的对象指的是这一类事物中的一个个体

是事物就要有属性，属性分为

1.数据属性：就是变量

2.函数属性：就是函数，在面向对象里通常称为方法

注意：类和对象均用点来访问自己的属性

class Chinese(object):
    '''
    这是一个中国人的类
    '''
    party='党'


print(Chinese.party)

class Chinese():
    '''
    这是一个中国人的类
    '''

    # def __init__(self, name):
    #     self.name=name
    party='党'
    def love_nation(self):
        print('中国人都爱国')
    def warm_heart(self):
        print('中国人%s热心'%self)

print(Chinese.party)
print(dir(Chinese))
Chinese.love_nation(1)
Chinese.warm_heart('asfasf')
print(Chinese.__dict__)
Chinese.__dict__['love_nation'](1)
Chinese.__dict__['warm_heart']('asfasf')

Chinese.love_nation(1)本质上是调用Chinese.__dict__['love_nation'](1)

 

特殊的类属性：

__name__      类名

__doc__         类的文档字符串

__base__   　类的第一个父类

__bases__　类的所有父类构成的元组

__dict__　　类的属性

__module__　　类定义所在的模块

__class__　　实例对应的类

 

类的属性

风湿理论：数据属性即变量，类的定义与函数极其类似，可以用函数的作用域来理解类的属性调用

 

对象相关知识

 

class Chinese():
    '''
    这是一个中国人的类
    '''

    def __init__(self, name,gender,age):
        print('我是初始化函数，我运行了')
        self.name=name
        self.gender=gender
        self.age=age
        print('我运行完了')
        #这个函数会自动返回一个None，不能返回其他值
    party='党'
    def love_nation(self):
        print('中国人都爱国')
    def warm_heart(self):
        print('中国人%s很热心'%self.name)

p1=Chinese('Alex','male',18)#实例化，触发__init__函数的运行，会将p1传给self位置参数
print(p1.__dict__)
print(p1.gender)
p1.warm_heart()
print(p1.party)

实例属性字典中没有函数属性，实例调用方法时会根据风湿理论在上一层类中找方法，没有则报错，有则调用，可以把class当作最外层的函数，是一个作用域

若类中方法没有self参数，实例调用类中方法时会将自己作为参数传给方法，会报错

 self代表实例本身，python会自动将实例本身传给self参数

实例化的过程实际就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一堆数据（变量），所以实例只用数据属性

 

 类属性

数据属性： 

查看类属性：Chinese.party

修改类属性：Chinese.party='我党'

 增加类属性：Chinese.city='北京'

删除类属性：del Chinese.party

 函数属性：

增加：

def play(self,ball):
    print('%s在玩%s'%(self.name,ball))

Chinese.play_ball=play
p1.play_ball('basketball') 

修改：

def test(self):
    print('test')
Chinese.play_ball=test
p1.play_ball()

 

作用域：

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

p1=Chinese('alex')
p1.country='Deutsch'
print('类的>>>',Chinese.country)
print('实例的>>>',p1.country)


>>>类的>>> china
实例的>>> Deutsch

报错：

country='china'
class Chinese:

    def __init__(self,name):
        self.name=name

p1=Chinese('alex')


print(p1.country)

 

Country='china'
class Chinese:

    def __init__(self,name):
        self.name=name
        print(Country)

p1=Chinese('alex')

>>>china

 

变量与属性的区别：

 只又通过.找到的是属性，作用域在类里

Country='china'
class Chinese:

    def __init__(self,name):
        self.name=name
        print(Country)#这里的Country是变量，不是类的属性也不是实例的属性

p1=Chinese('alex')

>>>china

 

country='China'
class Chinese:
    country='Deutsch'
    def __init__(self,name):
        self.name=name
        print(country)

p1=Chinese('alex')
print('这是实例的----->',p1.country)


>>>China
这是实例的-----> Deutsch

=号相当于给实例添加一个属性值

class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name


p1=Chinese('alex')
p1.country='Deutsch'
print(p1.country)
print(Chinese.country)
p1.l=[1,2,3]
print(Chinese.l)


>>>Deutsch
China
['a', 'b']

append本质上调用的是类的属性，而不是给实例赋一个新的值

class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name


p1=Chinese('alex')


p1.l.append('c')
print(p1.__dict__)
print(Chinese.l)


>>>{'name': 'alex'}
['a', 'b', 'c']

 

 __call__()的作用是使实例能够像函数一样被调用，同时不影响实例本身的生命周期（__call__()不影响一个实例的构造和析构）。但是__call__()可以用来改变实例的内部成员的值

 __call__()函数解释：https://blog.csdn.net/qq_18649781/article/details/89705611

 

 

 1