day 19 小结

面向对象基础和面向过程编程
- 面向过程编程:
  - 优点:
  - 缺点:
- 面向对象编程:
  - 优点:
  - 缺点:
什么是类
- 类: 对象是特征与技能的结合体,类是一系列对象相同的特征和技能的结合体
对象
- 调用类发生的事情:
对象与类的查找顺序
对象绑定方法的特殊之处
python中一切皆对象

面向对象基础和面向过程编程

1.什么是面向对象

指的是一门编程思想

面向过程编程:

核心是"过程"二字,过程指的是做事情的步骤,即先做什么再做什么

基于该编程思想编写程序,就好比一条工厂流水线,一种机械式的思维方式

优点:

逻辑清晰,复杂问题流程化,进而简单化

缺点:

可拓展性差

面向对象编程:

核心是"对象"二字,对指的是特征与技能的结合体.

基于该编程思想编写程序,就好比在创造世界,一种上帝式的思维方式

优点:

可扩展性高

缺点:

编写程序的复杂程度要远高于面向过程编程思想

优先使用面向对象过程还是面向对象?

面向过程结合面向对象一起使用

# 选课系统项目

什么是类

类型,类别,分类

先定义类,后调用类产生对象

在现实世界中:

对象是一个个具体存在的事物,类是由人类文明的发展抽象总结出来的

在程序中:

必须遵守,先有类,再有对象

如何定义类:

先从现实世界中,基于一个个的对象,抽取出类

类: 对象是特征与技能的结合体,类是一系列对象相同的特征和技能的结合体

定义类的语法:

class 类名:
    对象相同的特征
    对象相同的技能

class : 用来定义类的,class后跟的是类名.

类名: 类的名字,用来调用创造对象的.

注意: 类名必须要遵守驼峰命名法.

在定义类发生的事情:

1.类在定义时,会产生一个类的名称空间.

2.会把类内部所有名字,扔进类的名称空间中

注意: 类在定义阶段就已经产生好了名称空间,执行python

class OldboyStudent:
    school = 'oldboy'
    
    def learn(self):
        print('learn python...')
        
    def choose_coures(self):
        print('choose_python...')
      
# OldboyStudent ---> 会指向类的名称空间
print(OldboyStudent.__dict__)   # 查看类的名称空间内所有名字
print(OldboyStudent.__dict__.get('school')) # oldboy

# 查 
print(OldboyStudent.__dict__.get('school'))
print(OldboyStudent.school)
# 改
OldboyStudent.school = 'oldgirl'
# 增
OldboyStudent.address = '上海'
# 删
del OldboyStudent.address
'''
类.特征或技能的方式对类内部的名字进行修改
"."会指向类内部的名称空间,从而获得名字
'''

对象

如何产生对象:
语法:
类名 + ()调用类产生对象

名称空间的产生:
1.类的名称空间在类定义阶段就产生了
2.对象的名称空间,在调用类时产生

问题: 对象与对象之间的特征与技能一样
解决:在类内部定义__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 ....')

调用类发生的事情:

1.首先会产生一个空的对象,就是产生'对象的名称空间'

2.会自动触发__init__
3.会把对象以及括号内的参数一并传给__init__函数

总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例

#　查看类的名称空间
print(OldboyStudent.__dict__)

# 查看对象的名称空间
print(stu1.name,stu1.school)

对象与类的查找顺序

1.对象.属性若对象本身有,则优先查找对象自己的.

2.若对象本身没有,则去类里面找,若类没有,则报错.

class OldboyStudent:
    SCHOOL = 'oldboy'
    NAME = 'DDDD'
    
    def __init__(self,name,age,sex,school):
        self.name = name
        self.age = age
        self.sex = sex
        self.school = school
        
stu1 = OldboyStudent('小整',17,'male','odgirl')
print(stu1.SCHOOL)

print(stu1.NAME)
print(stu1.AGE)
print(OldboyStudent.AGE)

对象绑定方法的特殊之处

类内部的函数主要是给对象用的:

1.由类来调用类内部的函数,该函数只是一个普通的函数,普通函数需要接受几个参数就得传入几个参数

2.由对象来调用称之为对象的绑定方法,不同的对象调用该绑定方法,则会将不同的对象传入该绑定方法中

****对象的绑定方法,是由对象来调用的,特殊之处就是把对象当作第一个参数传入该方法中

class OldboyStudent:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 特征
    school = 'oldboy'
    # 技能
    def learn(self):  # 普通函数
    	print('learn python...')
    
    def choose_course(self,course):	# self = 
        print(f'[{self.name}]choose_course{coures}...')
    
    # print(OldboyStudent.learn)  # function
# OldboyStudent.learn(123)


stu1 = OldboyStudent('高凤凤1', 73, 'female')
stu2 = OldboyStudent('高凤凤2', 84, 'male')

# 对象之间与类的方法功能是一样的
# OldboyStudent.learn(123)
# stu1.learn()
# print(OldboyStudent.learn)
# print(stu1.learn)
# print(stu2.learn)

stu1.choose_course('python')  # choose_course(self, 'python')
stu2.choose_course('linux')  # choose_course(self, 'python')

python中一切皆对象

'''
int,float,str,list,tuple,dict,set,bool
在python中一切皆对象.
'''

# 定义一个列表
list1 = [1, 2, 3]  # list([1, 2, 3])
print(list1)  # [1, 2, 3]
print(id(list1))  # 2738050243464
print(type(list1))  # <class 'list'>


# print(list)
# list1.append(1)


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))
print(type(s1))
print(type(l))
print(type(t))
print(type(d))
print(type(s2))
print(type(b))
# print(filter)
# print(map)