面向过程
# 核心和过程二字， 先干什么，在干什么，最后干什么
它是一种思想
?
# 优点：复杂的问题简单化，进而流程化
# 缺点：扩展性差
?
# 应用场景：对扩展性要求不高的地方
面向过程和面向对象没有谁好谁坏
面向对象
# 核心是对象二字，
1. 程序中：
就是盛放数据属性和功能的容器
2. 现实中：
特征与技能的结合体
# 优点： 扩展性强，维护性强
# 缺点：编程复杂度高
# 应用场景：对扩展性要求较高的地方
类的定义和对象的产生
"""
驼峰命名：大驼峰，小驼峰
大驼峰：UserName => 类名推荐使用
小驼峰：userName
下划线的命名：user_name 除类名之外推荐使用
类名的命名：大驼峰
class 类名():
pass
是先有类还是先有对象？
1. 现实中：
先有对象，在有类
2. 在程序中:
必须要先定义类，在调用类得到对象
"""
# 定义类
class Student():
school = ‘SH‘
def choose_course(stu_obj, course):
pass
print(123)
"""
定义类发生了几件事？
1. 立即执行类体代码，
2. 产生一个类的名称空间，把类体中的属性名和函数名都扔到一个大字典中
3. 把类的名称空间绑定给__dict__ 类名.__dict__
"""
# Student.school
#
如何查看类的名称空间
# Student.__dict__
?
# 如何调用类？类名()
stu1 = Student() # 由Student类产生的对象 Object 空对象
stu2 = Student() # 由Student类产生的对象 Object 空对象
stu3 = Student() # 由Student类产生的对象 Object 空对象
?
stu1 = {‘name‘:‘qq‘, ‘age‘:18}
?
定制对象自己独有的属性
class Student():
school = ‘SH‘
# 初始化方法,__init__名字一定不能改，__开头的方法都称为魔术方法， 简称魔法
##############调用类的时候自动触发的方法###########################
def __init__(self, name, age, gender):\
# stu_obj = stu1 => {‘k‘:‘v‘} {‘name11111‘}
# name => name形参
self.name = name
self.age = age
self.gender = gender
?
stu = Student(‘lili‘, 18, ‘male‘) # stu = Student(stu, ‘lili‘, 18, ‘male‘)
stu1 = Student(jack‘, 19, ‘female‘) # stu = Student(stu, ‘jack‘, 18, ‘male‘)
print(stu) # {‘name‘:‘‘, ‘age‘:‘‘, ‘gender‘:‘‘}
print(stu1) # {‘name‘:‘‘, ‘age‘:‘‘, ‘gender‘:‘‘}
?
?
属性的查找
class Student():
school = ‘SH‘
# 初始化方法,__init__名字一定不能改，__开头的方法都称为魔术方法， 简称魔法
##############调用类的时候自动触发的方法###########################
def __init__(self, name, age, gender):\
# stu_obj = stu1 => {‘k‘:‘v‘} {‘name11111‘}
# name => name形参
self.name = name
self.age = age
self.gender = gender
def func(self):
pass
# 1. 类属性的查找
# 查找属性
Student.school
# 增加
Student.x = ‘xxx‘
# 修改
Student.school = ‘yyy‘
# 删除
del Student.school
# 方法的调用
# 默认情况方法是给对象用的
Student.func(stu) # 要
#################对象属性的查找#################################
stu = Student()
# 查找属性
stu.school
# 增加
stu.x = ‘xxx‘
# 修改
stu.school = ‘yyy‘
# 删除
del stu.school
#################对象方法的查找#################################
stu.func() # stu.func(stu) 对象调用方法，第一个参数不用传递
######################补充##############################
调用类的过程也是实例化的过程，得到的结果就叫一个实例
面向对象的小案例
?
"""
?
题目：
定义一个类，产生一堆对象
要求：
要有一个计数器，记录一共差生了多少个对象
"""
?
?
class Student():
count = 0
# {‘count‘:0}
# {‘count‘:1}
# {‘count‘:2}
# {‘count‘:3}
def __init__(self, name, age):
# self => obj => {‘name‘:‘qq‘, ‘count‘:1}
# self => obj1 => {‘name‘:‘jack‘, ‘count‘:1}
self.name = name
self.age = age
Student.count += 1
?
?
obj = Student(‘qq‘, 18)
obj1 = Student(‘lili‘, 18)
obj2 = Student(‘jack‘, 18)
?
?
print(obj.count)
print(obj1.count)
print(obj2.count)
绑定方法
# 绑定方法分为两种：
1. 绑定给对象的 # 就是让对象来调用的
2. 绑定给类的 # 就是让类来调用的
# 1. 绑定给对象的
class Student():
school = ‘cs‘
?
def __init__(self, name, age):
self.name = name
self.age = age
?
# 在类中书写方法，默认绑定给对象使用的
def tell_info(self):
print("%s-%s" % (self.name, self.age))
?
def func(self):
print("func")
?
obj = Student(‘jack‘, 18)
obj.tell_info()
obj.func()
# 2.
?
import settings
class Mysql:
school = ‘SH‘
?
def __init__(self, ip, port):
self.ip = ip
self.port = port
?
非绑定方法
?
"""
非绑定方法：即不绑定给对象，也不绑定给类
"""
?
# import uuid
# print(uuid.uuid4())
?
?
class Test():
def __init__(self, name, age):
self.name = name
self.age = age
self.id = self.create_id()
?
隐藏属性
class Student():
__school = ‘SH‘ # _Student__school
?
# school = ‘SH‘ # _Student__school
?
def __init__(self, name):
self.__name = name # self._Student__name
?
def func(self):
print(‘func‘)
?
def get_school(self):
return self.__school # self._Student__school
?
class Student():
__school = ‘cs‘ # _Student__school
?
# school = ‘cs‘ # _Student__school
?
def __init__(self, name):
self.__name = name # self._Student__name
?
def __func(self): # _Student__func
print(‘func‘)
?
def get_school(self):
return self.__school # self._Student__school
?
def set_school(self, v):
if type(v) is not str:
return
self.__school = v
?
?
?
def get_func(self):
return self.__func()
"""
隐藏属性特点:
1. 在类定义阶段发生了变形: _类名__属性名
2. 对内不对外，
为什么要隐藏:
对内部的属性或者方法做隐藏，可以更好的限制外部使用者， 要想让外部访问，在类内部定义对外可访问的接口。
"""
property装饰器
"""
property装饰器： 就是将函数功能封装成数据属性
"""
?
class Student():
__school = ‘cs‘ # _Student__school
__name = ‘qq‘
def __init__(self, name):
self.__name = name # self._Student__name
?
def __func(self): # _Student__func
print(‘func‘)
?
# @property # 这个函数已经变成了属性
# def get_name(self):
# return self.__name # self._Student__school\
?