- 面向过程编程
遇到问题直接将逻辑转换成代码，以逻辑思维作为工具 - 函数式编程
遇到问题就思考找一个或者写一个拥有相应功能的函数，以函数作为工具 - 面向对象编程
遇到问题就考虑可不可以有一个类来给我提供相应的功能和数据，以类和对象作为工具
python既支持函数式编程也支持面向对象编程
什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合；类是抽象的
对象就是类的实例；对象是具体的类的声明
类中的内容包含功能（函数）和属性（变量/属性）。
a. class 类名（父类）：
类的内容
b. 说明：
class - python声明类的关键字
类名 - 要求：标识符，不能是关键字
规范：驼峰式命名（通过首字母大写来区分不同的单词）；第一个字母要大写
： - 固定写法
类的内容 - 包含类的方法和属性和说明文档
方法：声明在类中的函数
属性：声明在类里面的变量对象的声明
语法：
类名() - 创建指定类对应的对象并且返回
user_name - pep8
userName - 驼峰式命名
UserName - 类名
class Person:
"""类的说明文档：人类"""
num = 61 # 类中方法
# 类中的方法
def eat(self):
print('人在吃饭')
def main():
# 创建Person类的对象；p1就是对象
p1 = Person()
print(p1)
# 同一个类可以创建多个对象
p2 = Person()
print(p2)
p3 = p2
print(p3)
class 类名：
类中的属性
类中的方法
类中的方法
声明在类中的函数就是方法
类中的方法包括：对象方法（实例方法）、类方法、静态方法对象方法
a. 什么是对象方法
直接声明在类中的方法就是对象方法
有默认参数self
通过'对象.方法（）'的方式来调用（对象方法要通过对象来调用）
b. 参数self
当我们通过对象调用对方方法的时候，self不需要传参；因为系统会自动将当前对象传递给self。
当前对象：调用当前方法的对象（谁调用对象方法self就是谁）
注意：当前类的对象能做的事情，self都能做
class Person:
def run(self):
print('人在跑步')
def main():
# 创建对象
p1 = Person()
# 通过对象p1调用的方法
print('p1:',p1)
p1.run()
init方法：init
init方法是类中的一个特殊的对象方法，专门用来对创建的对象进行初始化。
当通过类创建对象的时候，系统会自动调用init方法。构造方法
a. 声明构造方法
函数名和类名一样的就是构造方法，专门用来创建对象
python中声明类的时候，系统会自动创建这个类对应的构造方法
b. 构造方法的执行过程
当我们构造方法的时候内部会先在内存中开辟空间保存对象，然后用创建的对象去调用init方法
用来对对象进行初始化，init方法调用结束后，返回对象
def Person(x,y):
对象 = 创建对象
对象.init（x,y）
return 对象
注意：如果类的init方法除了self以外还有其他参数，那么我们在创建对象的时候需要通过给init方法传参。
class Person:
# 类中__开头并且__结尾的方法叫做魔方方法。不需要主动调用，系统会自动调用。
def __init__(self):
print('init被调用')
class Dog():
def __init__(self,x,y):
print(x,y)
print('dog的init')
# 构造方法的伪代码
def my_init(x,y,z=0):
print(x,y,z)
def my_Dog(*args,**kwargs):
dog = Dog.__init__()
def main():
p1 = Person()
p2 = Dog(10,20)
if __name__ == '__main__':
main()
- 什么是对象属性
类中的属性分为类的字段和对象属性
a. 对象属性：- 属性值会因为对象不同而不一样，这种属性就应该声明为对象属性
声明在init方法中 - 位置
以'self.属性 = 值'的方式来声明（这的属性就是对象属性） - 方式
通过'对象.属性'的方式来使用 - 使用
b. 类的字段 - 属性的值不会因为对象不同而不同，这种属性就声明为类的字段
直接声明在类的里面，函数的外面的变量，就是函数类的子对
以'字段名 = 值'
通过'类.字段'的方式来使用
class Person:
# num 就是类的字段
num = 61
# 在init方法中声明对象属性
def __init__(self, name1='', age1=0):
self.name = name1
self.age = age1
练习：创建Dog类，有属性名字、类型、年龄
要求创建Dog的对象的时候不能给年龄赋值，可以给类型赋值也可以不用给类型赋值，必须给名字赋值
class Dog:
def __init__(self, name, type=''):
self.name = name
self.type = type
self.age = 0
def eat(self, food):
print('%s在吃%s' % (self.name, food))
练习：声明一个矩形类，拥有属性长和宽，拥有方法求面积和周长
class Rectangle:
def __init__(self, length, width):
self.length = length
self.width = width
def square(self):
return self.length * self.width
def circumference(self):
return 2 * (self.width + self.length)
r1 = Rectangle(200, 100)
print(r1.circumference())
print(r1.square())
dog = Dog('小花','猪')
dog.eat('骨头')
Person.num = 100
print(Person.num)
def main():
p1 = Person('小明', 18)
# 获取对象属性的值
print(p1.name, p1.age)
p2 = Person('小红', 20)
# 修改对象属性的值
p2.name = '李四'
print(p2.name)
if __name__ == '__main__':
main()
python中对象的属性支持增删改查
- 查（获取对象属性）
属性的增删改查
class Person:
def __init__(self, name='', age=0, sex='女'):
self.name = name
self.age = age
self.sex = sex
class Dog:
__slots__ = ('name', 'color') # __slots__约束当前类的对象最多能拥有哪些属性
def __init__(self, name='', color='黑色'):
self.name = name
self.color = color
dog1 = Dog('大黄', '黄色')
p1 = Person('小花')
p2 = Person('小红')
1.查（获取对象属性）
对象.属性 - 获取指定对象指定属性值
getattr(对象，属性名:str，默认值) - 获取指定对象指定属性值,当属性不存在的时候如果给默认值赋了值，程序不会报错，标签将默认值作为结果
当属性不确定的时候可以使用getattr
print(p1.name)
# print(p1.name1) AttributeError: 'Person' object has no attribute 'name1'
print(getattr(p1, 'name', None))
print(getattr(p1, 'name1', None))
增、改
对象.属性 = 值 - 当属性存在的时候修改属性的值；属性不存在的时候添加属性
setattr(对象，属性名，值) - 当属性存在的时候修改属性的值；属性不存在的时候添加属性
p1.name = 'xiaohua'
print(p1.name)
p1.height = 180
print(p1.height)
setattr(p1, 'age', 18)
print(p1.age)
setattr(p1, 'weight', 200)
print(p1.weight)
删
del 对象.属性
delattr(对象，属性名)
del p1.sex
# print(p1.sex) AttributeError: 'Person' object has no attribute 'sex'
delattr(p1, 'age')
注意：对象属性的操作，只针对操作的哪一个对象，不会影响其他对象
内置属性指的是我们创建类的时候系统自动给我们添加的属性（其实是通过继承获取来的）6种
class Person:
# 类的字段
num = 61
#__slots__ = ('name', 'age', 'sex')
# 对象属性
def __init__(self,name='',age='',sex=''):
self.name = name
self.age = age
self.sex = sex
def eat(self,food):
print('%s在吃%s'%(self.name,food))
# 定制对象的打印格式（当我们通过print打印一个对象的时候，实质就是打印对象调用__repr__函数的返回值）
# 这个函数的返回值必须是字符串
def __repr__(self):
# return '<%s.%s object at %s>'%(self.__class__.__module__,self.__class__.__name__,hex(id(self)))
return str(self.__dict__)[1:-1] + 'at' + hex(id(self))
class Car:
def __init__(self,name='汽油车',color='黑色',speed='200'):
self.name = name
self.color = color
self.speed = speed
def __repr__(self):
return '{对象所在模块%s类%s内容%s}'%(self.__class__.__module__,self.__class__.__name__,self.__dict__)
def main():
p1 = Person('小明', 18)
# 1. 类.__name__ - 获取的名字（字符串）
print(Person)
class_name = Person.__name__
print(Person.__name__, type(Person.__name__), type(Person))
# 值是一个字符串，可以当成字符串来用
print(class_name.upper())
# 2. 对象.__class__ - 获取对象对应的类（结果为类）
# 获取对象p1的类
my_class = p1.__class__
print(my_class)
# 可以将my_class当成类来使用
p2 = my_class('小花')
print(my_class.num)
# 3. 类.__doc__ - 获取类的说明文档
print(Person.__doc__)
print(int.__doc__)
# 获取对象p1对应的类的说明文档
print(p1.__class__.__doc__)
# 4.对象.__dict__ - 将对象转换成字典，将属性和值作为字典的键值对
# 注意：当给__slots__赋值后，对象的dict属性就不能使用
print(p1.__dict__)
# 5. 类.__module__ - 获取当前类所在的模块的模块名
print(Person.__module__)
# 6. 类.__bases__ - 获取当前类的父辈(元祖)
print(Person.__bases__)
if __name__ == '__main__':
main()
对象方法：
a. 怎么声明：直接声明在类型
b. 特定：字典self参数，调用的时候不用传参，谁调用指向谁
c. 怎么调用：对象.方法（）
- 类方法：
a. 怎么声明：声明函数前加@classmethod
b. 特定：自带默认参数cls；调用的时候不用传参，系统会自动将调用当前函数的类传给它
(cls是谁调用就指向谁，类方法只能通过类来调用，所有cls就是当前类)
类能做的事情，cls都能做
c. 怎么调用：通过类来调用，类.方法()
3.静态方法
a. 怎么声明：声明函数前加@staticmethod
b. 特点：没有默认参数
c. 怎么调用：通过类来调用，类.方法()
- 在类中怎么选择使用哪种方法：
如果实现类中的函数的功能需要使用对象的属性，那么这个函数就要声明成对象方法；
实现函数的功能不需要对象属性的前提下，如果需要类的字段，就声明成类方法
实现函数的功能既不需要对象属性也不需要类的字段，就声明成静态方法。
class Person:
@staticmethod
def func3():
print('我是静态方法')
@classmethod
def func1(cls):
print('我是类方法2')
@classmethod
def func2(cls):
# 类能做的，cls都能做
p1 = cls() # 用cls来创建对象
print('这是一个类方法')
cls.num = 100 # 用cls来使用类的字段
print('cls:',cls)
cls.func2() # 用cls来使用类的调用
Person.func3()
def main():
Person.func1()
if __name__ == '__main__':
main()