面向对象导入、编程思想、类与对象的概念、创建、对象的实例化方法
面向对象案例导入——人狗大战
1.创造出人和狗
person1 = {
'name':'nana',
'type':'汉子',
'attack_val':2000,
'life_val':2000
}
dog1 = {
'name':'小黑',
'type':'比特',
'attack_val':200,
'life_val':100
}
>>>当需要创造无数多个狗和人时，一个个写代码，代码太冗余了，并且定义任何狗的字典基本不变，我们就可以封装成函数
2.将定义的人和狗封装成函数，优化代码
def get_person(name,type,attack_val,life_val):
person_obj = {
'name':name,
'type':type,
'attack_val':attack_val,
'life_val':life_val
}
return person_obj
p1 = get_person('nana','汉子',2000,2000)
print(p1) # {'name': 'nana', 'type': '汉子', 'attack_val': 2000, 'life_val': 2000}
def get_dog(name,type,attack_val,life_val):
dog_obj = {
'name':name,
'type':type,
'attack_val':attack_val,
'life_val':life_val
}
return dog_obj
d1 = get_dog('小黑','比特',200,100)
print(d1) # {'name': '小黑', 'type': '比特', 'attack_val': 200, 'life_val': 100}
>>>需要让人和狗具备攻击的能力
3.定义两个函数让人和狗可以有攻击能力
def person_attack(person_obj,dog_obj):
print(f'即将被攻击的狗：{dog_obj.get("name")} 当前生命值:{dog_obj.get("life_val")}')
print(f"准备攻击的人：{person_obj.get('name')} 当前生命值:{person_obj.get('life_val')} ")
person_obj['life_val'] -= dog_obj.get('attack_val')
print(f"{person_obj.get('name')}剩余生命值{person_obj['life_val']}")
def dog_attack(dog_obj,person_obj):
print(f'即将被攻击的人：{person_obj.get("name")} 当前生命值:{person_obj.get("life_val")}')
print(f"准备攻击的狗：{dog_obj.get('name')} 当前生命值:{dog_obj.get('life_val')} ")
dog_obj['life_val'] -= person_obj.get('attack_val')
print(f"{dog_obj.get('name')}剩余生命值{dog_obj['life_val']}")
person_attack(p1,d1)
# 即将被攻击的狗：小黑 当前生命值:100
# 准备攻击的人：nana 当前生命值:2000
# nana剩余生命值1800
dog_attack(d1,p1)
# 即将被攻击的人：nana 当前生命值:1800
# 准备攻击的狗：小黑 当前生命值:100
# 小黑剩余生命值-1900
>>>人和狗攻击的函数，可以被任意调用，出人可以调用狗攻击的功能，狗可以调用人攻击的功能
eg：
person_attack(d1,p1)
# 即将被攻击的狗：nana 当前生命值:2000
# 准备攻击的人：小黑 当前生命值:100
# 小黑剩余生命值-1900
dog_attack(p1,d1)
# 即将被攻击的人：小黑 当前生命值:-1900
# 准备攻击的狗：nana 当前生命值:2000
# nana剩余生命值1800
>>>实现人和人攻击狗的函数绑定，狗和狗攻击人的函数绑定
4.将人的数据和人攻击狗的函数绑定在一起，狗的数据和狗攻击人的数据绑定在一起
将人的数据与人攻击狗的功能绑定在一起，就实现了只有人可以调用人攻击狗的功能，将狗的数据和狗攻击人的数据绑定在一起，就实现了只有狗可以调用狗攻击人的功能
def get_person(name,type,attack_val,life_val):
def person_attack(person_obj, dog_obj):
print(f'即将被攻击的狗：{dog_obj.get("name")} 当前生命值:{dog_obj.get("life_val")}')
print(f"准备攻击的人：{person_obj.get('name')} 当前生命值:{person_obj.get('life_val')} ")
person_obj['life_val'] -= dog_obj.get('attack_val')
print(f"{person_obj.get('name')}剩余生命值{person_obj['life_val']}")
person_obj = {
'name':name,
'type':type,
'attack_val':attack_val,
'life_val':life_val,
'person_attack':person_attack
}
return person_obj
def get_dog(name,type,attack_val,life_val):
def dog_attack(dog_obj,person_obj):
print(f'即将被攻击的人：{person_obj.get("name")} 当前生命值:{person_obj.get("life_val")}')
print(f"准备攻击的狗：{dog_obj.get('name')} 当前生命值:{dog_obj.get('life_val')} ")
dog_obj['life_val'] -= person_obj.get('attack_val')
print(f"{dog_obj.get('name')}剩余生命值{dog_obj['life_val']}")
dog_obj = {
'name':name,
'type':type,
'attack_val':attack_val,
'life_val':life_val,
'dog_attack':dog_attack
}
return dog_obj
p1 = get_person('nana','汉子',2000,2000) # {'name': 'nana', 'type': '汉子', 'attack_val': 2000, 'life_val': 2000, 'person_attack': <function get_person....>}
d1 = get_dog('小黑','比特',200,100) # {'name': '小黑', 'type': '比特', 'attack_val': 200, 'life_val': 100, 'dog_attack': <function get_dog....}
p1.get('person_attack')(p1,d1)
# 即将被攻击的狗：小黑 当前生命值:100
# 准备攻击的人：nana 当前生命值:2000
# nana剩余生命值1800
d1.get('dog_attack')(d1,p1)
# 即将被攻击的人：nana 当前生命值:1800
# 准备攻击的狗：小黑 当前生命值:100
# 小黑剩余生命值-1900
编程思想
编程思想一共有两类：面向对象编程和面向过程编程
1.面向过程编程：就是按照指定的步骤依次执行，最终获取到想要的结果(执行一系列的流程)
2.面向对象编程：
核心'对象'：对象其实就是一个容器，将里面的数据和功能绑定在了一起
3.区别：
3.1 面向过程编程相当于给出一个问题的具体解决方案
3.2 面向兑现编程相当于创造出一些事物就可以了
ps:两种编程思想没有优劣之分，仅仅是使用场景不同，甚很多时候都是两者兼用至
对象与类的概念
1.类：是多个对象相同的数据和功能的结合体，主要用于记录多个对象相同的数据和功能
2.对象：是数据与功能的结合体，用于记录多个对象不同的数据和功能
ps：在面向对象编程中，类仅仅是用于节省代码，对象才是核心
对象与类的创建
在编程里，必须现有类才能产生对象。面向对象编程的本质时将数据和功能绑定在一起，为了突出面向对象编程的形式，python特地开发了一套语法专门用于面向对象编程的操作
创建类的语法结构
class 类名：
类体代码（对象公共的数据、方法）
1.class是定义类的关键字
2.类名：命名与变量名命名一致，推荐首字母大写(为了更好区分函数)
3.类体代码：在类定义的时候就会执行（与函数不同，函数在调用的时候才执行函数体代码）
类体代码包括：对象公共的数据和方法
查看名称空间中名字的方法
1.通过字典取值的方式获取名字
class Student:
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
print(Student) # <class '__main__.Student'>
print(Student.__dict__) # {'__module__': '__main__', 'school': '清华大学', 'choose_course': <function Student.choose_course at 0x000002393CDFCAE8>,...}
print(Student.__dict__.get('school')) # 清华大学
print(Student.__dict__['school']) # 清华大学
2.通过句点符
class Student:
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
print(Student.school) # 清华大学
print(Student.choose_course) # <function Student.choose_course at 0x0000027CB0A6CAE8>
类实例化产生对象
通过类名加括号就可以产生对象；通过句点符就可以获取类的名称空间名字，还可以修改名字(仅仅修改的是对象里的名字)；将类或者对象句点符后面的东西称为属性名或方法
class Student:
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
stu1 = Student()
print(stu1) # <__main__.Student object at 0x000002CCAE757358>
print(stu1.__dict__) # {}
print(stu1.school) # 清华大学
print(stu1.choose_course) # <bound method Student.choose_course of <__main__.Student object at 0x000001F554B17358>>
stu1.school = '北京大学'
print(stu1.school) # 北京大学
print(Student.school) # 清华大学
对象的实例化方法(独有数据)
需求：创建学生对象
1.直接利用双下dict方法向字典添加键值对
class Student:
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
obj1 = Student()
obj1.__dict__['name'] = 'nana'
obj1.__dict__['age'] = 18
obj1.__dict__['hobby'] = 'read'
print(obj1.__dict__) # {'name': 'nana', 'age': 18, 'hobby': 'read'}
>>>当需要创建多个学生对象的时候，如果还是一个个写结构相同的代码，太繁琐>>>封装成函数
2.将添加独有数据的代码封装成函数
class Student:
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
def init(obj,name,age,hobby):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
obj1 = Student()
init(obj1,'nana',18,"read")
print(obj1.__dict__) # {'name': 'nana', 'age': 18, 'hobby': 'read'}
>>>init函数是专们给学生对象创建独有的数据，其他对象不可以调用>>>面向对象思想，将数据和功能结合在一起
3.将函数封装到学生类中(面向对象思想)
class Student:
def init(obj, name, age, hobby):
obj.__dict__['name'] = name
obj.__dict__['age'] = age
obj.__dict__['hobby'] = hobby
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
stu1 = Student()
print(stu1.__dict__) # {}
Student.init(stu1,'nana',18,'read')
print(stu1.__dict__) # {'name': 'nana', 'age': 18, 'hobby': 'read'}
>>>python将进一步优化
4.进一步优化
双下init作用：
class Student:
def __init__(self, name, age, hobby):
self.name = name # obj.__dict__['name'] = name
self.age = age # obj.__dict__['age'] = age
self.hobby = hobby # obj.__dict__['hobby'] = hobby
school='清华大学'
def choose_course(self):
course1 = 'python'
return course1
stu1 = Student('nana',18,'read')
print(stu1.__dict__) # {'name': 'nana', 'age': 18, 'hobby': 'read'}
ps：stu1 = Student('nana',18,'read')
>>>:先产生一个空对象；然后自动调用类里面的双下init方法，将产生的空对象当成第一个参数传入；最后将产生的对象返回出去
浙公网安备 33010602011771号