py 面向对象编程及类与对象的概念学习 day 25
作者：互联网
今日内容学习
今天学习的主要是面向对象以及类与对象的概念
'总体概述'
1、面向过程：c语言
2、面向对象：所谓面向对象，其实就是说，站在上帝的视角下，世界万物一切皆对象。把拥有共同属性的归为一类，这就是class的由来
3、类的定义：
（1）类的关键字：class
（2）类中有属性、方法（就是之前学习过的函数），类里面的属性（类有三种属性：字段、方法、特性）及方法，调用的前提是首先要对类进行实例化处理。类的实例化处理必须调用__init__初始化方法
（3）类的名称首字母必须是大写的
class Student:
school = '金职院'
def get_id():
print('学号是')
4、函数与方法的区别
（1）定义位置
A、函数：Python的函数是直接写在Python模块中的，即在.py文件中直接定义
B、方法：只能定义在class类中。
（2）定义方式
A、函数：函数定义的方式 def 函数名()，括号里面写形参，也可以省略不写形参
B、方法：方法定义的方式， 首先方法是定义在类中的，其他大体和函数定义差不多，这里需要注意的一点就是方法必须带一个默认参数self，self指的是类自己
（3）调用方式
A、函数：直接使用函数名(参数1，参数2，…)调用
B、方法：方法：方法是通过 对象.方法 的方式调用的（这里是指对象方法）
'最主要要知道的是数据与功能进行绑定'
def get_person(name, gender, age, t_type, attack_val, life_val):
# 将人的攻击动作放在产生人的函数内
def person_attack(person_obj, dog_obj):
"""
:param person_obj: 接收一个人
:param dog_obj: 接收一条狗
"""
print('当前狗的血量是:%s' % dog_obj.get('life_val'))
dog_obj['life_val'] -= person_obj.get('attack_val')
print("""人:%s 锤了狗:%s 一下 狗掉血:%s 剩余血量:%s""" % (
person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj['life_val']))
data_dict = {
'name': name,
'gender': gender,
'age': age,
't_type': t_type,
'attack_val': attack_val,
'life_val': life_val,
'person_attack':person_attack
}
return data_dict
def get_dog(name, t_type, attack_val, life_val):
def dog_attack(dog_obj, person_obj):
"""
:param dog_obj: 接收一条狗
:param person_obj: 接收一个人
"""
# 使用最简答的掉血逻辑 血量减去对方攻击力
print('当前人的血量是:%s' % person_obj.get('life_val'))
person_obj['life_val'] -= dog_obj.get('attack_val')
print("""狗:%s 咬了人:%s 一口 人掉血:%s 剩余血量:%s""" % (
dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj['life_val']))
data_dict = {
'name': name,
't_type': t_type,
'attack_val': attack_val,
'life_val': life_val,
'dog_attack':dog_attack
}
return data_dict
p1 = get_person('jason','male',18,'猛男',800, 1000)
p2 = get_person('kevin','female',28,'淑女',10,100)
dog1 = get_dog('小黑', '松狮犬', 300, 500)
dog2 = get_dog('小白', '泰迪犬', 50, 200)
p1['person_attack'](p1,dog1)
dog1['dog_attack'](dog1,p2)
# 上述将数据与功能整合到一起的操作其实就是 面向对象编程的思想
编程思想
今天学习了两种不同的编程：
'面向过程编程'和'面向对象编程'
1.面向过程编程
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
# 一条线贯穿前后流程，就是按顺序进行一连贯的编程
2.面向对象编程
核心是'对象'
对象其实就像是一个'容器'，将数据和功能整合到一起
面向对象编程是把构成问题的事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
面向对象是按功能的来划分问题，而不是步骤
假如要改动一个功能，按照面向过程编程就要重写,而按照面向对象编程就只用改动局部先相关的对象
# 区别：
'面向过程:'
优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源
缺点：没有面向对象易维护、易复用、易扩展
'面向对象:'
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点：性能比面向过程低
类和对象的概念
'对象:'数据与功能的结合体
'类:'即类别、种类 相当于诸多对象公有的特征(数据、功能)
简单来说就是某一类事物，它们具有相同的属性
'二者的关系:'对象是由类派生的、创建的。一个类可以创建无穷多个对象，每个对象都属于类。
例子：
类：猫
对象：橘猫，布偶猫，加菲猫
'类':其实就是某一类事物，具有相同的属性
'对象':就是类的实例
# 类也算是对象>>>一切皆对象
类与对象的创建
'在代码中是先有类才能有对象'
# 因为要先定义类，然后才能产生对象
# 学生类
class Student:
# 学生类公共数据
school = '金职院'
# 学生类公共的功能
def choose_course(self):
print('学生选课功能')
'类体代码无需调用就会执行 产生类的名称空间'
上面就是一个大致的类
语法结构
class 类名：
类体代码
1.class是定义类的关键字
2.类名类似于函数名，但是首字母推荐大写，用于区分
3.类体代码就是存放对象公共数据和功能的地方
数据:变量名 = 变量值
功能: 函数
# 查看名称空间的方法就是双下dict>>>:__dict__
print(Student.__dict__) # 返回值是一个字典
print(Student.__dict__['school']) # 获取类中的属性
等同于
print(Student.school) # 金职院
print(Student.__dict__['choose_course']) # 获取类中的属性
等同于
print(Student.choose_course)
'如何产生对象: 类名加括号'
# 对象1 : obj1
obj1 = Student() # 类名加括号就是在产生一个对象
# 对象2 : obj2
obj2 = Student()
print(obj1.__dict__, obj2.__dict__) # {} {}
print(obj1.school) # 金职院
print(obj2.school) # 金职院
print(obj1.choose_course) # bound method(绑定方法)
print(obj2.choose_course) # bound method(绑定方法)
# 可以直接修改类中公共数据
Student.school = '北京大学' # Student.__dict__['school'] = '北京大学' 修改名字与值的对应关系
print(obj1.school) # 北京大学
print(obj2.school) # 北京大学
对象的实例化
实例化就是类到对象的过程
# 学生类
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() # 目前对象没有自己独有的属性
obj2 = Student()
print(obj1.__dict__) # 此步骤是给字典添加键值对
print(obj2.__dict__)
'开始给对象添加数据'
obj1.__dict__['name'] = 'jason' # obj1.name = 'jason'
obj1.__dict__['age'] = 18 # obj1.age = 18
obj1.__dict__['gender'] = 'male' # obj1.gender = 'male'
obj2.__dict__['name'] = 'kevin' # obj2.name = 'kevin'
obj2.__dict__['age'] = 2 # obj2.age = 28
obj2.__dict__['gender'] = 'female' # obj2.gender = 'female'
print(obj1.__dict__,obj2.__dict__)
print(obj1.name) # jason
print(obj2.name) # kevin
'方案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
init(obj1,'jason',18,'male')
init(obj2,'kevin',28,'female')
print(obj1.name)
print(obj2.name)
'方案3:简单的封装成函数没有提现出面向对象整合的精髓>>>:将函数写到类中去'
obj1 = Student()
obj2 = Student()
Student.set_info(obj1,'jason',18,'male')
Student.set_info(obj2,'kevin',28,'female')
print(obj1.name) # jason
print(obj2.name) # kevin
'方案4:类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法'
obj1 = Student('jason', 18, 'male')
obj2 = Student('kevin', 28, 'female')
print(obj1.__dict__)
print(obj2.__dict__)
__init__方法：它会在类的对象被实例化时立即运行
类产生对象的具体步骤
1.先调用类产生一个没有独有数据的空对象 {}
2.将空对象和类括号内传入的数据一并交给__init__执行 类名.__init__(obj,name,age,gender)
__init__的第一个参数就是对象本身
3.将创建好的对象自动返回
'括号内第一个形参self其实就是一个普通的变量名,就像是默认的名字self'
绑定方法
'在类中定义的函数默认都是绑定给对象使用的,就是对象来调会自动将对象当做第一个参数传入'
class Student:
school = '清华大学'
# __init__方法不要自己去调用
def __init__(self, name, age):
self.name = name
self.age = age
def func(self):
print('%s正在调用func方法'%self.name)
def index(self):
print('%s正在调用index方法'%self.name)
obj1 = Student('jason', 18)
# print(obj1)
obj2 = Student('kevin', 28)
# 类调用类中函数，有几个参数就需要传几个参数
Student.func(123,222)
# 对象调用类中函数，会将当前调用的对象当做第一个参数自动传入
obj1.func()
obj2.func()
print(obj1.func)
print(obj2.index)
1.凡是类中的方法和函数，都是绑定给对象使用的
2.绑定方法都有自动传值的功能。传递进去的值，就是对象本身
3.如果类想调用绑定方法，就必须遵循函数的参数规则，有几个参数，就必须传递几个参数
今天学的对象和类的概念还可以理解，但是ATM还是没有完全掌握，所以要多去练习了
标签：__,25,obj,name,及类,obj1,dict,面向对象编程,print 来源： https://www.cnblogs.com/kazz/p/16108311.html