一 . 面向对象基础
1.社么是面向对象？
指的是一门编程思想。
#### 回顾 面向对象编程
核心是“过程‘二字，过程指的是做事情的步骤，即先做什么再做什么
基于该编程思想编写程序，就好比一条工厂流水线，一种机械式的思维方式。
优点：逻辑清晰，复杂的问题流程化，进而简单化。
缺点：可扩展性差。
面向对象编程：
核心是'对象'二字‘，对象指的是特征与技能的结合体
基于该编程思想编写程序，就好比在创造，一种上帝式的思维方式。
优点：可扩展性高
缺点：编写程序的复杂程度要远远大于面向过程编程思想。
优先适应面向过程还是面向对象？
面向过程结合面向对象一起使用
2.如何造对象？
什么是类？
类型，类别，分类。
先定义类.后调用类产生对象。
—在现实世界中：
对象是一个个具体存在的事物，类是由人类文明的发展抽象总结出来的。
—在程序中：
必须遵循。先有类，再有对象。
类：对象是特征与机能的结合体，类是一系列对象相同的特征与机能的结合体。
代码演示 在现实世界中：
学生对象1：
特征：
school = "oldboy" # 学校
name = "梁大大"
age = 20
sex = "gril"
技能：
learn #学习
choose_course # 选课
学生对象2：
特征：
school = 'oldboy' #学校
name = '三毛'
age = 23
sex = 'female'
技能：
learn #学习
choose_course #选课
类： 相同特征
shool = 'oldboy'
相同技能
learn
choose_course
二 . 类
'''
类:
对象是特征与技能的结合体，类是一系列对象相同的特征与技能的结合体。
如何定义类:
首定义类，后调用类创造对象。
定义类的语法:
def 函数名():
class 类名:
对象相同的特征
对象相同的技能
class: 用来定义类的，class后跟的是类名。
类名: 类的名字，用来调用创造对象的。
注意: 类名必须要遵循驼峰命名法，python在定义变量与函数时不推荐使用，但在定义类时推荐使用。
在定义类发生的事情:
1.类在定义时，会产生一个空的名称空间。
2.会把类内部所有名字，扔进类的名称空间中。
注意: 类在定义阶段就已经产生好了名称空间，执行python文件时会执行类内部的代码。
学生类:
相同特征 --> 类内部的变量
school
相同技能 --> 类内部的函数
learn
choose_course
'''
学生类
class oldboyStudent：
特征：
school = 'oldboy'
print('tank is handsome...')
技能：
def learn(self):
print('learn python')
def choose_course(self):
print('choose_course...')
#OldboyStudent ---> 会指向类的名称空间
print(OldboyStudent.__dict__) # 查看类的名称空间内所有名字
print(OldboyStudent.__dict__.get('school')) # oldboy
'''
类.特征或技能的方式对类内部的名字进行修改。
"."会指向类内部的名称空间，从而获取名字。
'''
# 查
# print(OldboyStudent.school) # oldboy
# 改
# OldboyStudent.school = 'oldgirl'
# print(OldboyStudent.school) #oldgirl
# 增
# print(OldboyStudent.address) # 报错，特征也称之为属性
# OldboyStudent.address = '上海'
# print(OldboyStudent.address)
# 删
# del OldboyStudent.address
# print(OldboyStudent.address)
# OldboyStudent.choose_course(123)
三.对象
如何产生对象：
语法：
类名 + () 调用类产生对象。
名称空间的产生：
1.类的名称空间在类定义阶段已经产生了。
2.对象的名称空间，在调用类时产生。
学生类：
lass OldboyStudent:
# 特征
school = 'oldboy'
print('tank is handsome...')
# 技能
def learn(self):
print('learn python...')
def choose_course(self): # self = None
print('choose_course ....')
stu1 = OldboyStudent() # OldboyStudent()---> 学生对象
stu2 = OldboyStudent() # OldboyStudent()---> 学生对象
stu3 = OldboyStudent() # OldboyStudent()---> 学生对象
print(stu1, stu2, stu3)
print('stu1', stu1.school)
stu1.learn() #stu1 oldboy
stu1.choose_course() #learn python...
print('stu2', stu2.school) #choose_course ....
stu2.learn() #stu2 oldboy
stu2.choose_course() #learn python...
print('stu3', stu3.school) # choose_course ....
stu3.learn() #stu3 oldboy
stu3.choose_course()# learn python... choose_course ....
问题：对象与对象之间的特征与性能一样。
解决：在类内部定义__ init __ 函数。
中文翻译：为对象初始化某些属性。
__ init __: 会在调用时，制动出发该函数。
class OldboyStudent:
# 若__init__中有self以外的参数，调用类时必须在括号内传入参数。
def __init__(self, x, y, z): # self --> 就是对象本身 x = 高峰峰 y=93 z=female
# print(self, x, y, z)
# print('此处时__init__。。。。')
# 给对象添加特征的方式二：
self.name = x
self.age = y
self.sex = z
# 特征
school = 'oldboy'
# print('tank is handsome...')
# 技能
def learn(self):
print('learn python...')
def choose_course(self): # self = None
print('choose_course ....')
stu1 = OldboyStudent('高峰峰', 93, 'female') # OldboyStudent()---> 学生对象
stu2 = OldboyStudent('小丁丁', 84, 'female') # OldboyStudent()---> 学生对象
stu3 = OldboyStudent('大丁丁', 18, 'male') # OldboyStudent()---> 学生对象
print(stu1)
print(stu2)
print(stu3)
# 给对象添加属性的方式一:
print(stu1.name) #高峰峰
stu1.name = '高峰峰'
stu1.age = 93
stu1.sex = 'female'
print(stu1.name, stu1.age, stu1.sex) #高峰峰 93 female
**** 调用类发生的事情
1.首先会产生一个空对象，就是产生“就像的名称空间”。
2.会自动触发__ init __。
3.会把对象本身以及括号内的参数一并传给 __ init __函数。
****总结：调用类会产生一个对象，调用类的过程叫做类的实例化，产生的对象称之为类的一个实列。
******调用类发生的事情:
1.首先会产生一个空的对象，就是产生“对象的名称空间”。
2.会自动触发__init__。
3.会把对象本身以及括号内的参数一并传给__init__函数。
******总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例.
'''
# 查看类的名称空间
print(OldboyStudent.__dict__) #{'__module__': ......
'__doc__': None}
# 查看对象的名称空间
print(stu1.__dict__) #{'name': '高峰峰', 'age': 93, 'sex': 'female'}
print(stu1.name, stu1.school) #高峰峰 oldboy
四. 对象与类的查找顺序
对象与类的查找顺序：
1.对象.属性，若对象本身有，则优先查找对象自己的。
2.若对象本身没有，则去类里面找，若类没有，则报错。
class OldboyStudent:
SCHOOL = 'oldboy'
NAME = 'DDDDDDDD'
def __init__(self, name, age, sex, school):
self.name = name
self.age = age
self.sex = sex
self.SCHOOL = school
stu1 = OldboyStudent('小正正', 17, 'male', 'oldgirl')
print(stu1.SCHOOL) #oldgirl
print(stu1.NAME)# DDDDDDDD
print(stu1.AGE) #没有这个值AGE 则报错
print(OldboyStudent.AGE)
五. 对象绑定方法的特殊之处
类内部的函数主要时给对象用的：
1.由类来调用内部的函数，该函数只是一个普通的函数。普通函数需要接收几个参数就得传入几个参数。
2.由对象来调用称之为对象的绑定方法。
不同的对象调用该绑定方法，则会将不同的对象传入该绑定方法中。
**** 对象的绑定方法，是由对象来调用的。
特殊之处就是把对像当作第一个参数传入该方法。
六 . python一切皆是对象
class Foo:
def append(self, x):
print(x)
pass
# print(Foo)
# obj = Foo()
# obj.append(1)
f = float()
s1 = str()
l = list()
t = tuple()
d = dict()
s2 = set()
b = bool()
print(type(f)) #<class 'float'>
print(type(s1)) #<class 'str'>
print(type(l))
print(type(t))
print(type(d))
print(type(s2))
print(type(b)) # <class 'bool'>
面向对象编程:
核心是 “对象”， 对象指的是 特征与技能 结合体。
基于该编程思想编写程序，就好比在创造世界，一种上帝式思维方式。
优点:
可扩展性强。
缺点:
编写复杂难度较面向过程高。
'''
# 1.类的实例化: 调用类的过程称之为类的实例化，产生的对象也可以称之为类的一个实例。
'''
调用类产生对象发生的事情:
1.会产生一个空对象的名称空间
2.会自动触发__init__，并且会将对象当做第一个参数传入。
3.会将调用类括号内的参数一并传给__init__().
'''
class People:
country = 'China'
def __init__(self, name, age, sex):
print(self.__dict__)
print(self)
self.name = name
self.age = age
self.sex = sex
print(self.__dict__)
# 注意: 看到self就应该知道是对象本身
def learn(self):
print('learning....')
p_obj = People('tank', 17, 'male')
# print(p_obj.name, p_obj.age, p_obj.sex)
# 2.查看类与对象的名称空间 类.__dict__ 对象.__dict__
# print(People.__dict__)
# print(p_obj.__dict__)
# 3.类或对象的属性操作: 查、增、改、删
# print(People.country)
# People.number = 1500
# print(People.number)
# People.country = '中国'
# print(People.country)
# del People.country
# print(People.country)
# print(p_obj.name)
# p_obj.sal = 150000000
# print(p_obj.sal)
# p_obj.age = 16
# print(p_obj.age)
# del p_obj.sal
# print(p_obj.sal)
# 4.类中数据属性（类中的变量）: 类中属性是给对象使用的，对象引用类中的属性，指向的都是类中同一个内存地址。
# p_obj1 = People('tank', 17, 'male')
# p_obj2 = People('jason', 71, 'female')
# p_obj3 = People('大饼', 72, 'female')
# print(p_obj1.country, id(p_obj1.country))
# print(p_obj2.country, id(p_obj2.country))
# print(p_obj3.country, id(p_obj3.country))
# 5.类中的方法（类中的函数）: 类中的方法是给对象使用的，
# 由不同的对象来调用就会将方法绑定给不同的对象, 并且会将对象当做第一个参数传入。
# print(People.learn)
# print(p_obj1.learn) # bound method
# print(p_obj2.learn)
# print(p_obj3.learn)
# 6.对象属性的查找顺序: 先从对象自己名称空间中查找 ---》 类的名称空间中查找
# print(p_obj1.country)
# print(p_obj1.country2)
# 7.对象绑定方法的特殊之处:
'''
1.会将对象当做第一个参数传入。******
2.若对象的绑定方法中还有其他参数，会一并传入。
'''
# p_obj1对象.对象的绑定方法learn(p_obj1):
# p_obj1.learn()
# 8.一切皆对象: 在python3中，类即类型。
# print(type(p_obj1)) # <class '__main__.People'>
# str1 = 'tank'
# print(type(str1)) # <class 'str'>
#
# list1 = [1, 2, 3]
# print(type(list1)) # <class 'list'>