python面向对象

python面向对象

面向对象编程思想

1.描述人和狗

dog1 = {
    'name': '狗1',
    'gender': '公',
    'type': '田园犬'
}
dog2 = {
    'name': '狗2',
    'gender': '公',
    'type': '舔狗'
}

person1 ={
    'name': 'jason',
    'gender': '男',
    'type': '帅哥'
}

person2 = {
    'name': 'kevin',
    'gender': '女',
    'type': '美女'
}

def jiao(dog):
     print('%s正在叫'%dog['name'])
 def kanmen(dog):
     print('%s正在看书'%dog['name'])
 jiao(dog1) 	# 狗1正在叫

 kanmen(dog2)	# 狗2正在看书
'''狗调用了人的动作'''

2.发现问题

#人调用了狗的动作 
def dog(name,gender,type):
    def jiao(dog):
		print('%s正在叫'%dog['name'])
    dog1 = {
    'name': '狗1',
    'gender': '公',
    'type': '田园犬',
    'jiao':jiao,
}
'需要把狗的属性和动作捆绑在一起，只有具有狗的属性才能调用狗的动作'  

d1 = dog('1','公','天狗')
print(d1)
#{'name': '狗1', 'gender': '公', 'type': '田园犬', 'jiao': <function dog.<locals>.jiao at 0x000001979B45DBF8>}

d1['jiao'](d1)	# 狗1正在叫

3.代码进行优化

def dog(name,gender,type):
    def init(name,gender,type):
        #  定义了狗的属性和动作，实际上就是初始化一只狗
        dog1 = {
            'name': name,
            'gender': gender,
            'type': type,
            'jiao':jiao,
            }
        return dog1
    def jiao(name):	
        #  狗的动作
        print('%s正在叫' % dog['name'])
    return init(name,gender,type)


d1 = dog('1','公','天狗')
print(d1)
#{'name': '狗1', 'gender': '公', 'type': '田园犬', 'jiao': <function dog.<locals>.jiao at 0x000001979B45DBF8>}

d1['jiao'](d1)	# 狗1正在叫

4.面向对象编程来实现

class Dog():
    def __init__(self,name,gender,type):
#  这个就是上面的init() 函数，初始化函数，类一运行就会执行这个函数
        self.name = name
        self.gender = gender
        self.type = type
    def jiao(self):	
        #  这里的self实际上就是对象本身
        print('%s正在叫' %self.name)

dog1 = Dog('狗1','公','天狗')
dog1.jiao()	

#总结一下

1、面向对象分为两种：面向对象设计和面向对象编程，只要包含一类事物的总和（类 ）以及这一类产生了实例，那就是一个面向对象。所以并不是包含class（类）才叫做面向对象。

2、面向对象两个概念：类（class）和对象（object）。其中类就是一类事物的特征和动作的总和（例如人这一个种类），是一个抽象的概念
而对象就是由这一个类实例化出来的一个具体的例子，就好比是一个个的人

3、什么叫实例化：
由类产生对象这一个过程就叫实例化，结果是一个对象或者叫一个实例。

编程思想

1.面向过程编程
	将程序的执行流程化 即分步操作 分步的过程中解决问题
  	eg:注册、登录、结算购物车...
      """注册:第一步获取用户名 第二步比对用户名数据 ..."""
      """结算:第一步获取购物车数据 第二步计算钱数   ..."""
	过程可以理解成是流水线 面向过程编程可以理解成是在创建一条流水线
  
  
2.面向对象编程
	核心就是'对象'二字 
		对象其实就是一个"容器" 将数据与功能整合到一起
  只要是符合上述描述的事物都可以称之为是对象!!!
  	eg:
      人狗大战最后的函数内部含有数据和功能 可以称之为面向对象编程
      模块文件内部含有数据和功能 也可以称之为面向对象编程
  """仔细的想想会发现 python中一切皆对象!!!"""
  python针对面向对象编程提供了专门的语法 识别度更高 编写更精简
		eg:人、动物、游戏角色
"""
面向过程与面向对象两者没有优劣之分 具体要结合实际情况
甚至很多时候两者是混合在一起的!!! 思想占据的比例不同而已
"""
#把大象关进冰箱的不同思路：

#面向过程思想：
1打开冰箱门。
2.将大象关进冰箱。
3.关闭冰箱门。

#面向对象思想：
1.找到一个能够打开冰箱的人。
2.找到能够将大象关进冰箱的人。
3.找到一个能够关闭冰箱的人。

类与对象的概念

#类的概念：
一种数据类型 本身并不占内存空间 跟所学过的number，string，booleann等相似
用类创建的实例化对象(变量) 对象占内存空间

#类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类

#属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法

类与对象的创建

"""
在代码编程中是先有类才能有对象
"""
# 先定义类 后产生对象
# 学生类
class Student:
    # 学生类公共的数据
    school = '清华大学'
    # 学生类公共的功能
    def choose_course(self):
        print('学生选课功能')
        
#语法结构
class 类名:
    类体代码
1.class是定义类的关键字
2.类名类似于函数名 但是首字母推荐大写 用于区分
3.类体代码就是存放对象公共数据和功能的地方
    数据: 变量名 = 变量值
    功能: 函数
        
#查看名称空间的方法>>>:__dict__
print(Student.__dict__)  # 返回值是一个字典
print(Student.__dict__['school'])  # 获取类中的属性
print(Student.__dict__['choose_course'])  # 获取类中的属性
"""类获取数据和功能有一个简便的方式>>>:句点符"""

print(Student.school)	# 清华大学

'''类有一个方法：__dict__,调用这个方法可以打印出类的所有属性，返回的是一个字典的形式，下面我们把类的属性打印出来'''

print(Student.choose_course)	
#<function Student.choose_course at 0x00000281EAA6E2F0>

对象的实例化：

class Student:
    def __init__(self, name, age, gender):
        '''该方法就一个功能>>>:给对象添加独有的数据'''
        self.name = name  # obj.__dict__['name'] = name
        self.age = age  # obj.__dict__['age'] = age
        self.gender = gender  # obj.__dict__['gender'] = gender

    # 学生类公共的数据
    school = '清华大学'

    # 学生类公共的功能
    def choose_course(self):
        print('学生选课功能')
        
        
'''类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法 '''

obj1 = Student('jason', 18, 'male')

obj2 = Student('kevin', 28, 'female')
print(obj1.__dict__)
#{'name': 'jason', 'age': 18, 'gender': 'male'}

print(obj2.__dict__)
#{'name': 'kevin', 'age': 28, 'gender': 'female'}

"""

类中的__init__方法会在类产生对象的时候自动执行
类产生对象的具体步骤
    1.先创建一个没有独有数据的空对象  {}
    2.将空对象和类括号内传入的数据一并交给__init__执行
        __init__的第一个参数就是对象本身
            __init__(obj,name,age,gender)
    3.将创建好的对象自动返回

ps:针对括号内第一个形参self其实就是一个普通的变量名而已
只不过该变量名将来专门接收对象的 所以给它起了个固定的名字叫self
"""

对象实例化过程演变：

#过程演变：
1.逐步给对象添加独有的数据

obj1.__dict__['name'] = 'jason'  # obj1.name = 'jason'
obj1.__dict__['age'] = 18  # obj1.age = 18
obj1.__dict__['gender'] = 'male'  # obj1.gender = 'male'

2.将冗余的添加步骤封装成函数

def init(obj,name,age,gender):
    obj.name = name  # obj.__dict__['name'] = name
    obj.age = age  # obj.__dict__['age'] = age
    obj.gender = gender  # obj.__dict__['gender'] = gender
    
3.简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去
    
obj1 = Student()
obj2 = Student()
Student.set_info(obj1,'jason',18,'male')
Student.set_info(obj2,'kevin',28,'female')

4.类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法

obj1 = Student('jason', 18, 'male')
obj2 = Student('kevin', 28, 'female')
print(obj1.__dict__)
print(obj2.__dict__)

绑定方法：

class Dog():
    def __init__(self,name,gender,type):
        self.name = name
        self.gender = gender
        self.type = type
    def jiao(self):	
        print('%s正在叫' %self.name)
        
#类调用类中函数 有几个参数就需要传几个参数
dog1 = Dog('狗1','公','天狗')

dog1.jiao()		# 狗1正在叫
'对象调用类中函数  会将当前调用的对象当做第一个参数自动传入'