一、面向对象编程
编程思想：
面向过程编程 ---> 算法，逻辑(数学逻辑)
函数式编程 ---> 函数，模块
面向对象编程 ---> 类和对象 (生活)
面向过程编程：
n = 100
sum1 = 0
for x in range(n+1):
sum1 += x
函数式编程：
def add_student():
pass
面向对象编程：
class Student_Manager:
def add_student(self):
pass
value = input('数字')
if value == '1':
# add_student()
Student_Manager().add_student()
二、类的声明
1.什么是类和对象
类 - 是拥有相同属性和相同功能的对象的集合（抽象的）
对象 - 就是类的实例（具体的）
从生活的角度来看类和对象
如果说人是一个类，你大爷就是一个对象，你二婶婶也是一个对象
如果说电脑是一个类，我桌上的这台笔记本电脑就是一个对象
如果水杯是一个类，具体的某个水杯才是一个对象
如果车是一个类，汽车、自行车、摩托车等这些事这个类的子类，具体的某一辆车才是对象
2.类的声明
- 格式：
class 类名(父类列表):
类的说明文档
类的内容
- 说明：
class --> python中声明类的关键字
类名 --> 标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写；见名知意
驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
例：userName
PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词之间用下划线隔开
例：user_name(父类列表) --> 继承语法，让声明的类继承括号中的父类，这个结构可以省略，让当前类继承python的基类：object
: --> 固定结构
类的说明文档 --> 注释，对类进行说明
类的内容 --> 包含属性(变量)和方法(函数)
方法：声明在类中的函数
# 声明Person类，吃饭和睡觉
class Person:
"""人类"""
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
3.对象的声明
对象名 = 类名()
对象名 --> 变量名
类名 --> 必须是声明过的类
# 声明了Person类的对象p1,p2
p1 = Person()
p2 = Person()
p1.eat()
p2.sleep()
三、对象方法
类的内容包含属性和方法，方法分为对象方法、类方法和静态方法
对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self,通过对象来调用
对象方法的调用：对象.方法名()
注意：调用对象方法的时候，不需要给默认参数self传参，系统会自动将当前对象传递给selfself: 谁调用当前的对象方法，self就指向谁。self就是当前类的对象，类的对象能做的事情，self都能做
# 声明类
class Person:
"""人类"""
# 对象方法
def eat(self, name):
# self = p1, name = 'aaa'
print('self:', self)
print('吃饭')
def sleep(self):
print('睡觉')
# 声明对象
p1 = Person()
print('p1:', p1) # p1: <__main__.Person object at 0x0000000002811F60>
p1.eat('aaa')
# self: <__main__.Person object at 0x0000000002811F60>
# 吃饭
p2 = Person()
print('p2:', p2) # p2: <__main__.Person object at 0x0000000002197470>
p2.eat('aaa')
# self: <__main__.Person object at 0x0000000002197470>
# 吃饭
class Person:
"""人类"""
# 对象方法
def eat(self, name):
# self = p1, name = 'aaa'
print('self:', self)
print('吃饭')
self.sleep() # eat的self也可以调用sleep函数
def sleep(self):
print('s_self:', self) # sleep的self指向调用sleep的eat的self
print('睡觉')
p1 = Person()
print('p1:', p1) # p1: <__main__.Person object at 0x00000000027C75C0>
p1.eat('aaa')
# self: <__main__.Person object at 0x00000000027C75C0>
# 吃饭
# s_self: <__main__.Person object at 0x00000000027C75C0>
# 睡觉
四、构造方法和init方法
1.构造方法
构造方法就是函数名和类名一样的方法，作用就是用来创建对象的，
声明类的时候，系统会自动为这个类创建对应的构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用__init__方法对这个对象进行初始化
2.__init__方法
对象方法
不需要手动调用，创建完对象后，会被自动调用__init__方法去对这个对象进行初始化，
最后将创建好的对象的地址返回
class Dog:
"""狗类"""
def __init__(self):
print('init方法')
dog1 = Dog() # init方法
3.带其他参数的init方法
__init__方法的参数要通过构造方法来传，（构造方法的实参，会传递给init方法的形参）
class Person:
def __init__(self, name='', age=0):
print(name, age)
p1 = Person('小明', 20) # 小明 20
五、对象的属性
类的内容包含属性和方法，属性又分为对象属性和类的字段
- 属性：用来在类中去保存数据的变量。
- 对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等
对象属性要通过对象来使用
1. 对象属性的声明(重点！)
a.必须声明在__init__方法中
b.声明格式：self.属性 = 初值
2. 使用对象属性: 对象.属性
# 声明一个人类，要求有名字，年龄和性别属性
class Person:
def __init__(self):
self.name = '张三'
self.age = 18
self.sex = '男'
p1 = Person()
print(p1.name)
p2 = Person()
print(p2.name)
3.创建对象的时候可以给对象属性赋值
# 声明一个人类，有名字、年龄、性别三个属性。要求创建不同对象的时候就可以直接确定不同属性值
class Person2:
def __init__(self, name1, age1=0, sex1='girl'):
self.name = name1
self.age = age1
self.sex = sex1
self.id = '0001'
def func1(self):
# self = p3
self.name = '路飞'
print(self.name)
def func2(self):
# self = p3
print('func2', self.name)
p1 = Person2('小明', 30, '女')
print(p1.name)
p1.name = 'XiaoMing' # 可以修改属性的值
print(p1.name)
p1.id = 'p0001'
print(p1.id)
p2 = Person2('小红', 18, '男')
print(p2.name)
p3 = Person2('小花')
print(p3.name)
p3.func1()
p3.func2()
if __name__ == '__main__':
pass
六、对象属性的增删改查
class Student:
def __init__(self, name='', age=0, study_id='001'):
self.name = name
self.age = age
self.study_id = study_id
stu1 = Student('小明')
stu2 = Student('小红', 18)
1.查（获取对象属性的值）
方法1：对象.属性 --> 获取指定属性的值，属性不存在会报错
print(stu1.name) # 小明
# print(stu1.name2) # AttributeError: 'Student' object has no attribute 'name2'
方法2：getattr(对象，属性名，默认值）
--> 获取指定属性值，如果设置了默认值当属性不存在的时候不会报错，并将默认值作为结果返回
（如果没有设置默认值，属性不存在，还是会报错）
print(getattr(stu1, 'name')) # 小明
# print(getattr(stu1, 'name2')) # AttributeError: 'Student' object has no attribute 'name2'
print(getattr(stu1, 'name2', '张三')) # 张三
方法3：对象.__getattribute__(属性名) --> 获取指定属性值,属性不存在会报错
print(stu1.__getattribute__('name')) # 小明
print(stu1.__getattribute__('study_id')) # 001
# print(stu1.__getattribute__('name2')) # AttributeError: 'Student' object has no attribute 'name2'
2.增/改（给对象添加属性）
注意：给对象添加属性，只能添加到当前对象中，不会影响当前类的其他对象
方法1：对象.属性 = 值 （属性不存在的时候增加，存在的时候就是修改）
方法2：setattr(对象, 属性名, 属性值) （属性不存在的时候增加，存在的时候就是修改）
方法3：对象.__setattr__(属性名, 属性值)S (属性不存在的时候增加，存在的时候就是修改）
# 增加
stu1.gender = 'male'
print(stu1.gender) # male
# print(stu2.gender) # AttributeError: 'Student' object has no attribute 'gender'
# 修改
stu1.name = '李四'
print(stu1.name) # 李四
# 修改
setattr(stu1, 'name', '娜美')
print(stu1.name) # 娜美
# 增加
setattr(stu1, 'name2', '比利王')
print(stu1.name2) # 比利王
3.删（删除对象属性）
注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象, 属性名)
方法三：对象.__delattr__(属性名)
del stu1.age
# print(stu1.age) # AttributeError: 'Student' object has no attribute 'age'
print(stu2.age) # 18
delattr(stu1, 'gender')
# print(stu1.gender) # AttributeError: 'Student' object has no attribute 'gender'
stu1.__delattr__('name')
七、对象的使用
import copy
python中所有的数据都是对象，所有的变量存储的都是对象的地址
int是一个类，整数是一个对象：
num = int(10)
print(num.bit_length()) # 4
C语言（相对C语言，python对数据操作更灵活）：
10 -> 4字节 -> 32bits (存储范围2^32-1)
1000 -> 32bits
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# 定制当前类的对象的打印格式，函数的返回值必须是字符串
def __str__(self):
# return str(self.__dict__) # 按字典方式打印
# 按照自定义的方式打印
return 'name:' + self.name + '== age:'+ str(self.age) + '== score:' + str(self.score)
1.将对象给别的变量赋值
stu1 = Student('XiaoHua', 18, 90)
stu2 = stu1 # 赋对象地址，stu1和stu2都指向一个对象
stu3 = copy.copy(stu1) # 产生新的对象，将新的地址赋值给stu3
stu1.name = '张三'
print(stu2.name) # 张三
print(stu3.name) # XiaoHua
2.将对象作为列表的元素
students = [Student('小明', 23, 89), Student('小红', 18, 90), stu3]
# 找到列表students中成绩最好的学生的名字
max1 = students[0].score
name = students[0].name
for stu in students:
if stu.score >= max1:
max1 = stu.score
name = stu.name
print(name, max1) # XiaoHua 90
对列表中的学生按年龄从小到大排序:
# def func1(item):
# return item.age
students.sort(key=lambda item: item.age)
for stu in students:
print(stu)
# name:小红== age:18== score:90
# name:XiaoHua== age:18== score:90
# name:小明== age:23== score:89
找出最大值（max函数的使用方法（类似sort，使用函数作为参数））：
max1 = max(students, key=lambda item: item.score)
print('max:', max1) # max: name:小红== age:18== score:90
练习：将上述列表中指定的学生修改为指定的值（根据姓名查找指定学生的信息，根据姓名修改指定学生的年龄）
def find_stu(students):
name = input('请输入查找的学生的姓名：')
for stu in students:
if stu.name == name:
print(stu)
return stu
stu = find_stu(students)
stu.age = 30
print(stu)
八、slots魔法
1. 属性和类的字段
属性：对象属性，类的字段
类的字段：声明在类里面，函数外面的变量就是类的字段。
使用的时候要通过类来使用: 类.字段
2. __slots__: 用来约束当前类的对象属性有哪些
class Dog:
# num就是类的字段
num = 10
__slots__ = ('color', 'name', 'type1', 'gender', 'price', 'age')
def __init__(self, color, name, type1):
self.color = color
self.name = name
self.type1 = type1
print(Dog.num)
print(Dog.num) # 10
Dog.num = 100
print(Dog.num) # 100
dog1 = Dog('黄色', '大黄', '土狗') # 100
# dog1.neme = '大灰' # AttributeError: 'Dog' object has no attribute 'neme'
dog1.age = 5
九、内置类属性
class Person:
"""人类"""
# 类的字段
num = 61
# 对象属性
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
# 对象方法
def run(self):
print('%s在跑' % self.name)
p1 = Person('小明', 18, '男')
- 1.
__name__
类.__name__--> 获取当前类的名字
print(Person.__name__, type(Person.__name__)) # Person <class 'str'>
- 2.
__doc__
类.__doc__--> 获取当前类的说明文档
print(Person.__doc__, type(Person.__doc__)) # 人类 <class 'str'>
print(int.__doc__, type(int.__doc__))
-
__class__
对象.__class__--> 获取对象的类，类能做的事情，他都可以做
-
my_class = p1.__class__
print(p1.__class__) # <class '__main__.Person'>
p2 = my_class('小花', '10', '女')
print(p2) # <__main__.Person object at 0x00000000027F7438>
print(p2.name) # 小花
print(Person.num) # 61
print(my_class.num) # 61
-
__dict__
类.__dict__--> 获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
对象.__dict__--> 获取当前对象所有的属性和其对应的值，以字典的形式返回
-
print(Person.__dict__)
# {'__module__': '__main__', '__doc__': '人类', 'num': 61, '__init__': <function Person.__init__ at 0x00000000027A4A60>, 'run': <function Person.run at 0x00000000027A4AE8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
print(p1.__dict__) # {'name': '小明', 'age': 18, 'gender': '男'}
# print('===:', list.__dict__)
-
__module__
类.__module__--> 获取当前类所在的模块名
-
print(Person.__module__) # __main__
-
__bases__
类.__bases__--> 获取当前类的父类，返回的是一个元组，元组的元素是类
-
print(Person.__bases__) # (<class 'object'>,)
