面向对象基础和面向过程编程
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)