面向对象介绍
'''
1.什么是面向对象？
面向对象是一门编程思想!
- 面向过程编程思想:
核心是 “过程” 二字，过程指的是解决问题的步骤，即先干什么再干什么！
基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式。
优点:
将复杂的问题流程化，进而简单化
缺点:
牵一发而动全身，程序的可扩展性差。
注意: 编程思想仅仅是一门思想，与任何的技术无关。
- 面向对象编程思想:
注意: 要将自己当做一个上帝！！！
核心是 “对象” 二字，对象指的是 “特征与技能” 的结合体。
基于该编程思想编写程序，就好比在创造世界，一种 “上帝式” 的思维方式。
优点:
可扩展性高。
缺点:
编写程序的复杂程度比面向过程高。
2.如何产生对象:
1) 什么是类？
类指的是类型、类别。
- 在两种角度去看待:
- 现实世界中:
- 先有一个个的对象，经过社会的文明发展，随之总结出类。
对象是实际存在的，而类抽象产生的。
- 在程序中:
- 必须先有类，再通过“调用类，产生对象”。
对象指的是 “特征与技能” 的结合体， 类指的是一系列 “对象之间相同的特征与技能” 的结合体。
2) 如何定义类:
- 如何写类并产生对象:
- 先从现实世界中通过一个个对象总结出类。
- 然后再定义类，后调用类产生对象。
- 比如: 选课系统:
- 选课系统学生类:
- 学生对象1:
特征:
- 姓名: 胡晨阳
- 性别: female
- 年龄: 95
- 学校: oldboy
- 技能:
- 技术: python
- 学习: learn
- 选课: course
- 学生对象2:
特征:
- 姓名: 高弟
- 性别: female
- 年龄: 98
- 学校: oldboy
- 技能:
- 技术: python
- 学习: learn
- 选课: course
3) 定义类语法:
class 关键字: 帮你产生类的。
class 类的名字:
- 对象之间相同的特征
- 学校
school = 'oldboy'
- 对象之间相同的技能
- python
def python():
pass
- learn
def learn():
pass
- course
def course():
pass
'''
类
'''
class 类名:
特征
技能
定义类名的规范:
- 驼峰命名法
'''
# def foo(): # 函数名指向的是函数的内存地址
# pass
# print(foo) # <function foo at 0x000001CDFF119048>
# 定义老男孩学生类
class OldboyStudent: # 类名指向的是类的内存地址
# 学生相同的特征
# 在类中的特征 也称之为 “属性” attribute
school = 'oldboy'
# 学生相同的技能
# 注意: 在类内部定义函数，会默认有一个参数self
def learn(self): # self此时当做一个形参
print('learning....')
print(OldboyStudent) # <class '__main__.OldboyStudent'>
# 查看类的名称空间
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)
# 类提供一种特殊获取名字的方式 “类名.名字” 的方式
# # 查
# print(OldboyStudent.school)
# OldboyStudent.learn('tank')
#
# # 改
# OldboyStudent.school = 'OldGirl'
# print(OldboyStudent.school)
# 删
# del OldboyStudent.school
# 增
# OldboyStudent.school = 'Oldboy'
# print(OldboyStudent.school)
# OldboyStudent.old_student = 'HuChenYang'
# print(OldboyStudent.old_student)
'''
- 函数的名称空间：
在调用函数时产生，函数调用结束后销毁。
- 类的名称空间:
在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
'''
对象
'''
对象的产生:
- 调用类产生对象
类名 + () 调用类产生对象
类的名称空间在定义时产生，对象的名称空间在调用类时产生。
调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
'''
# class Student:
# # 学校
# school = 'oldboy'
#
# # 学习技能 ----> method ---》 方法
# def learn(self):
# print(self) #
# print('learning...')
#
#
# # stu1 = Student()
# # stu2 = Student()
# # stu3 = Student()
# # print(Student) #
# # print(Student.school, 'Student...')
# # print(Student.learn, 'Student...')
# # Student.learn(123)
# print('=' * 100)
#
# # print(stu1) # <__main__.Student object at 0x0000017BFF8A5898>
# # print(stu1.school, 'stu1...')
# print(stu1.learn, 'stu1...')
# # print(stu1)
# # 对象调用方法时: 会将对象当做第一个参数传入方法中。
# stu1.learn() #
#
# print('=' * 100)
# # print(stu2) # <__main__.Student object at 0x0000017BFF8A5898>
# # print(stu2.school, 'stu2...')
# print(stu2.learn, 'stu2...')
# stu2.learn()
#
# print('=' * 100)
# # print(stu3) # <__main__.Student object at 0x0000017BFF8A5898>
# # print(stu3.school, 'stu3...')
# print(stu3.learn, 'stu3...')
# stu3.learn()
'''
由对象来调用类内部的函数，称之为对象的绑定方法。
对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。
'''
class Student:
# 学校
school = 'oldboy'
def __init__(self, name, sex, age): # stu1, 'tank', 'male', 17
print(self.__dict__)
# 给对象添加新的属性
self.name = name # stu1.x = 'tank'
self.sex = sex # stu1.y = 'male'
self.age = age # stu1.z = 17
# 查看当前对象的名称空间
print(self.__dict__)
# 学习技能 ----> method ---》 方法
def learn(self):
print(self) #
print('learning...')
# 查看类的名称空间
print(Student.__dict__)
# stu1 = Student() # Student(stu1) ---> __init__(self) ----> self == stu1
# stu2 = Student() # Student(stu2) ---> __init__(self) ----> self == stu2
# stu3 = Student() # Student(stu3) ---> __init__(self) ----> self == stu3
# stu1.name = '江鹏'
# stu1.sex = 'female'
# stu1.age = 84
# print(stu1.name, stu1.sex, stu1.age)
#
# print(stu1)
# print(stu2)
# print(stu3)
# **** 想要在调用类时，为对象传入对象独有 特征
# ***** __init__(self, name, sex, age): # name---> tank , sex---> male, age----> 17
# 调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__()
# stu1 = Student('tank', 'male', 17)
# 注意: 凡是在类内部定义的，__开头或者__结尾的方法都有特殊的意义。
# 在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入, 与括号内所有的参数一并传给__init__()。
# __init__(self):
对象名字的查找顺序
'''
对象名字的查找顺序： *******
1.对象.属性，会先找对象自己的。
2.若对象没有，会去找类的。
3.若类没有，则会报错。
'''
class People:
country = 'China'
name = 'jason'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print('running...')
obj1 = People('tank', 17, 'male')
print(obj1.name) # tank 找对象自己的name属性
print(obj1.country) # China 对象没有，找类中的属性
# AttributeError: 'People' object has no attribute 'jason'
# print(obj1.jason) # 对象没有，类也没有，就会报错!
print(obj1.__dict__)
# 给对象的名称空间添加 country='中国' 属性
obj1.country = '中国'
print(obj1.__dict__)
print(People.__dict__)
print(obj1.country)
一切皆对象
'''
在python中一切皆对象。
'''
# class Foo:
# def __init__(self, x, y, z):
# self.x = x
# self.y = y
# self.z = z
# 产生对象
# 调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
# foo_obj = Foo(10, 20, 30)
# print(foo_obj)
# number = 10 # int(10) ----> __init__(number, 10)
# int(10)
# l1 ---> list对象
# l1 = list([1, 2, 3])
# dict()
# tuple((1, 2, 3))
# float
# str
# set
# bool
# enumerate
# bytes
# filter
'''
需求: 有一个人对象，狗对象，人狗互咬。
- 对象人1:
- 特征:
- 生命
- 名字: name = '高弟'
- 攻击力: arg
- 技能:
- 咬：bite
- 对象人2:
- 特征:
- 生命
- 名字: name = '胡博'
- 攻击力: arg
- 技能:
- 咬：bite
- 对象人3:
- 特征:
- 生命
- 名字: name = '张志刚'
- 攻击力: arg
- 技能:
- 咬：bite
- 抽象出类:
- 人类:
- 相同特征
- 生命
- 相同技能
- 咬
狗对象1:
- 特征:
- 生命: 250
- 名字: name = 'HCY'
- 品种: dog_type = '哈士奇'
- 攻击力: arg
- 技能:
- 咬：bite
狗对象2:
- 特征:
- 生命: 400
- 名字: name = 'jason'
- 品种: dog_type = '哈巴犬'
- 攻击力: arg
- 技能:
- 咬：bite
狗对象3:
- 特征:
- 生命: 200
- 名字: name = 'sean'
- 品种: dog_type = '沙皮'
- 攻击力: arg
- 技能:
- 咬：bite
狗类:
- 相同特征
- 相同技能
- 咬
'''
# 人类
class People:
def __init__(self, name, life, arg):
self.name = name
self.life = life
self.arg = arg
# 人调用bite时，传入狗对象
def bite(self, dog_obj):
print(f'人：[{self.name}] 开始 咬 狗:[{dog_obj.name}]!')
# 减掉狗对象中的生命值 值为人的攻击力
dog_obj.life -= self.arg
print(f'狗的生命值减掉: [{self.arg}], 还剩狗的血量: [{dog_obj.life}]')
if dog_obj.life <= 0:
print(f'狗[{dog_obj.name}]已经挂了')
return True
# 狗类
class Dog:
def __init__(self, name, life, dog_type, arg):
self.name =