面向对象设计、编程的概念与类概念

三大编程范式：

1.面向过程编程

2.函数式编程

3.面向对象编程

编程进化论：

1.编程最开始就是无组织无结构，从简单控制流中按步写指令

2.从上述的指令中提取重复的代码块或逻辑，组织到一起(比方说，你定义了一个函数)，便实现了代码重用，且代码由无结构走向了结构化，创建程序的过程变得更具逻辑性

3.我们定义函数都是独立于函数外定义变量，然后作为参数传递给函数，这意味着：数据与动作是分离的

4.如果我们把数据和动作内嵌到一个结构(函数或类)里面，那么我们就有了一个‘对象系统’（对象就是数据与函数整合到一起的产物）。

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

'''
假设你是一条狗，我们用结构化的数据来描述你
1：数据与动作分离
2：数据与动作结合
导向：
1.面向对象设计
2.什么是类什么是对象
'''
#1、面向对象设计
def dog(name,gender,type):
    def jiao(dog):
        print('一只狗[%s]在叫，汪汪'%name)
    def chishi(dog):
        print('狗[%s]吃屎'%type)
    def init(name,gender,type):
        dog1={
            'name':name,
            'gender':gender,
            'type':type,
            'jiao':jiao,
            'chishi':chishi
        }
        return dog1
    return init(name,gender,type)

#2、创建一个基于dog函数的对象
dog2=dog('qwe','公','金毛')
# print(dog2)
dog2['jiao'](dog2)

实例1:

#_*_coding:utf-8_*_
dog1={
    'name':'alex',
    'gender':'female',
    'type':'京巴'
}
dog2={
    'name':'wupeiqi',
    'gender':'female',
    'type':'腊肠'
}
dog3={
    'name':'yuanhao',
    'gender':'female',
    'type':'藏獒'
}

def bark(dog):
    print('一条名字为[%s]的[%s],狂吠不止' %(dog['name'],dog['type']))

def yao_ren(dog):
    print('[%s]正在咬人' %(dog['name']))

def chi_shi(dog):
    print('[%s]正在吃屎' %(dog['type']))


bark(dog1)
yao_ren(dog2)
chi_shi(dog3)

#上面的例子就是基于面向对象设计的思想实现的
#我们用结构化的数据去实现了三个具体的对象,即dog1,dog2,dog3
#然后我们并没有实现数据与动作的融合
person={
    'name':'犀利哥',
    'gender':'male',
    'type':'person',
}
bark(person) #狗的对象没有跟自己的方法绑定,导致人也能用狗的方法

狗与人的故事

实例之面向对象：

#_*_coding:utf-8_*_

def Dog(name,gender,type):
    def init(name,gender,type):
        dog={
            'name':name,
            'gender':gender,
            'type':type,
            'bark':bark,
            'yao_ren':yao_ren,
            'chi_shi':chi_shi,
        }
        return dog
    def bark(dog):
        print('一条名字为[%s]的[%s],狂吠不止' %(dog['name'],dog['type']))

    def yao_ren(dog):
        print('[%s]正在咬人' %(dog['name']))

    def chi_shi(dog):
        print('[%s]正在吃屎' %(dog['type']))

    return init(name,gender,type)

dog1=Dog('alex','female','京巴')
dog2=Dog('wupeiqi','female','腊肠')
dog3=Dog('yuanhao','female','藏獒')


dog1['bark'](dog1)
dog2['yao_ren'](dog2)
dog3['chi_shi'](dog3)

真正的面向对象设计

面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计

#用面向对象编程独有的语法class去实现面向对象设计
class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type

    def bark(self):
        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))

    def yao_ren(self):
        print('[%s]正在咬人' %(self.name))

    def chi_shi(self):
        print('[%s]正在吃屎' %(self.type))

dog1=Dog('alex','female','京巴')
dog2=Dog('wupeiqi','female','腊肠')
dog3=Dog('yuanhao','female','藏獒')

dog1.bark()
dog2.yao_ren()
dog3.chi_shi()

面向对象编程

小结：用面向对象语言写程序，和一个程序的设计是面向对象的，两者是八杆子打不着的两码事。

---

类与对象：

1.什么是类：类是一种数据结构，就是把一类事物相同的特征和动作整合到一起就是类，类是一个抽象的概念，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。

2.什么叫对象：就是基于类而创建的一个具体的事物（具体存在的），也是特征和动作整合到一起；可以理解为：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)

3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人

4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

类的定义：

在python中声明函数与声明类很相似

声明函数

def functionName(args):
     '函数文档字符串'
      函数体 

声明类

类名规则首字母大写（小写也可以，但不推荐）

属性：⑴数据属性 ⑵函数属性

'''
class 类名:
    '类的文档字符串'
    类体
'''

#我们创建一个类
class Data:
    pass

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

经典类与新式类

大前提：
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
在python2中的区分
经典类：
class 类名:
    pass

经典类：
class 类名(父类):
    pass

在python3中，上述两种定义方式全都是新式类

类之属性：

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

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

1：数据属性：就是变量

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

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

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

类的数据属性

#定义一个中文人的类,然后在类中定义一个类的属性,政府是***,这样，只要是中文人他们的党永远都是***
#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。

class ChinesePeople:
    government='***'

print(ChinesePeople.government)

类的函数属性(又称为方法)

class ChinesePeople:
    government='***'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

ChinesePeople.sui_di_tu_tan()

person1_obj='alex'
ChinesePeople.cha_dui(person1_obj) #带参函数，所以调用时需要传入参数，将'alex'传给self

查看类属性
(1)、dir(类名)：查出的是一个名字列表

(2)、类名.__dict__:查出的是一个字典，key为属性名，value为属性值

class ChinesePeople:
    government='***'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)


print(dir(ChinesePeople)) #显示结果是一个列表,包含类(包含内建属性在内的)所有的属性名
print(ChinesePeople.__dict__) #显示结果是一个字典,包含类的所有属性:属性值

特殊的类属性

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='***'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

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

对象与实例化：对象是由类实例化而来，类实例化的结果称为一个实例或者称作一个对象

实例化：

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='***'
    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

person1=ChinesePeople() #类名加上括号就是实例化(可以理解为函数的运行,返回值就是一个实例)

#这就是实例化，只不过你得到的person1实例，没有做任何事情

构造函数：

上述的实例化过程，没有做任何事情，啥意思？

类是数据属性和函数属性的结合，描述的是一类事物

这类事物的一个具体表现就是一个实例/对象，比方说中国人是一个类，而你就是这个类的一个实例

你除了有中国人这个数据属性外，还应该有名字，年龄，性别等数据属性

如何为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='***'
    def __init__(self,name,age,gender): #实例化的过程可以简单理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    def cha_dui(self):
        print('一个中国人-->%s<--插到了前面' %self)

# person1=ChinesePeople() #会报错
                        #自动执行__init__方法,而这个方法需要参数,
                        # 这些参数应该写在类名后面的括号里,然后由类传
                        #给__init__函数,也就说,传给类的参数就是传给__init__的参数

person1=ChinesePeople('alex',1000,'female')
person2=ChinesePeople('wupeiqi',10000,'female')
person3=ChinesePeople('yuanhao',9000,'female')

print(person1.__dict__)

注意：在说实例化的时候说过，执行类()会自动返回一值，这个值就是实例，而类()会自动执行__init__，所以一定不要在该函数内定义返回值，会冲突

实例属性：

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

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='***'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    # def cha_dui(self):
    #     print('一个中国人-->%s<--插到了前面' %self)

    def cha_dui(self):
        print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

    def eat_food(self,food):
        print('%s 正在吃 %s' %(self.name,food))

person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(ChinesePeople.__dict__)#函数属性只存在于类中
ChinesePeople.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
ChinesePeople.eat_food(person1,'韭菜馅饼')


person1.cha_dui()#其实就是ChinesePeople.cha_dui(person1)
person1.eat_food('飞禽走兽') #本质就是ChinesePeople.eat_food(person1,'飞禽走兽')

查看实例属性

同样是dir和内置__dict__两种方式

特殊实例属性

__class__

__dict__

class ChinesePeople:
    '我们都是中国人,我们骄傲的活着,我们不服任何事和物'
    government='***'
    def __init__(self,name,age,gender):
        self.name=name
        self.age=age
        self.gender=gender

    def sui_di_tu_tan():
        print('90%的中国人都喜欢随地吐痰')

    # def cha_dui(self):
    #     print('一个中国人-->%s<--插到了前面' %self)

    def cha_dui(self):
        print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender))

    def eat_food(self,food):
        print('%s 正在吃 %s' %(self.name,food))

person1=ChinesePeople('alex',1000,'female')

print(person1.__class__)
print(ChinesePeople)

person2=person1.__class__('xiaobai',900,'male')
print(person2.name,person2.age,person2.gender)

具体用法

警告：类和对象虽然调用__dict__返回的是一个字典结构，但是千万不要直接修改该字典，会导致你的oop不稳定

类属性的增删改查：

#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。
class ChinesePeople:
    country='China'
    def __init__(self,name):
        self.name=name

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

def say_word(self,word):
    print('%s 说 %s' %(self.name,word))

#查看类属性
print(ChinesePeople.country)
#修改类属性
ChinesePeople.country='CHINA'
print(ChinesePeople.country)
#删除类属性
del ChinesePeople.country
#增加类属性
ChinesePeople.Country='China'
ChinesePeople.location='Asia'
print(ChinesePeople.__dict__)

#类的数据属性增删改查与函数属性是一样的
ChinesePeople.say_word=say_word
print(ChinesePeople.__dict__)
alex_obj=ChinesePeople('alex')
ChinesePeople.say_word(alex_obj,'我是一只来自北方的狼狗')

类属性使用

实例的增删改查

class ChinesePeople:
    country='China'
    def __init__(self,name):
        self.name=name


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


p1=ChinesePeople('alex')
print(p1.__dict__)

#查看实例属性
print(p1.name)
# print(p1.age)#不存在于p1的属性字典中,会报错

print(p1.country)#country也不存在于p1的属性字典中,为何可以取到呢?

#删除
# del p1.country #报错,因为p1的属性字典里根本就没有country属性
del p1.name
print(p1.__dict__)


#增加
p1.gender='man'
print(p1.__dict__)

#修改
p1.gender='woman'
print(p1.__dict__)

实例属性的使用

1.实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。

2.函数又作用域的概念，其实类也有作用域的概念，二者一样

3.你可以把class当做最外层的函数，是一个作用域

#定义一个类，只当一个作用域去用，类似于C语言中的结构体
class MyDate:
    pass

x=10    #   全局变量
y=10
MyDate.x=1      #相当于局部变量
MyDate.y=1
print(x,y)
print(MyDate.x,MyDate.y)
print(MyDate.x+MyDate.y)

4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里

5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域

6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错

7.在类中没有使用点的调用，代表调用全局变量啊

换个方法玩死你之答疑解惑：

ps1:

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)       #自己没有，找class的
p1.country = '岛国'     #相当于在自己的作用域又定义了一个country
print('实例：',p1.country)   #所以找到的是自己的
print('类:',Chinese.country) #class原有的

ps2:

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

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

p1 = Chinese('alex')
print(p1.country)       #直接报错，找不到country，在全局定义的变量，不能以class的方式访问
                        #AttributeError: 'Chinese' object has no attribute 'country'

ps3:

country = '中国'
class Chinese:
    def __init__(self,name):
        #name = input('>>>') #不能将功能分开，离被开不远了
        self.name=name

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

#可以这样修改
name = input('>>>')
p1 = Chinese('name')
print(p1.name)

ps4:

country = '中国'
class Chinese:
    def __init__(self,name):
        self.name=name
        print('---->',country)  #此时，country，只是变量，不是以类.或者实例.执行存在的，都是变量

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

p1 = Chinese('alex')

ps5:

country = '中国——————————'
class Chinese:
    country = '中国'
    def __init__(self,name):
        self.name=name
        print('---->',country)  #不是以.执行的，都是变量

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

print(Chinese.__dict__)
print(Chinese.country)
p1 = Chinese('alex')

ps6:

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

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

p1 = Chinese('alex')    #实例化一个对象
print(p1.li)
#p1.li_st=[1,2,3]       #相当于在__init__函数中定义了一个list列表，与class里的列表无关
p1.li.append('c')       #找到的是class里的列表，进行append操作
print(p1.__dict__)
print(Chinese.li)