一、面向对象

编程思想：

1.面向过程编程 ---> 算法，逻辑(数学逻辑)

2.函数式编程 ---> 函数，模块

3.面向对象编程 ---> 类和对象 (生活)

---

二、类的声明

1.什么是类和对象

类 - 是拥有相同属性和相同功能的对象的集合（抽象的）

对象 - 就是类的实例（具体的）

从生活的角度来看类和对象

如果说人是一个类， 余婷就是一个对象，骆昊也是一个对象

如果说电脑是一个类，我桌上的这台mac就是一个对象

如果水杯是一个类，具体的某个水杯才是这个类的对象

如果车是一个类，汽车、自行车、摩托车等这些是这个类的子类， 具体的某一辆车才是对象

2.类的声明

格式：
class 类名(父类列表):
    类的说明文档
    类的内容

说明:

class -> python中声明类的关键字

类名 -> 标识符,不能是关键字;类名使用驼峰式命名，并且首字母大写;见名知义

驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写.。例如：userName

PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词之间用下划线隔开。例如：user_name

(父类列表) -> 继承语法，让声明的类继承括号中的父类。这个结构可以省略，让当前类继承python的基类:object

: -> 固定结构

类的说明文档 -> 注释，对类进行说明。

类的内容 -> 包含属性(变量)和方法(函数)。方法：声明在类中的函数

# 声明Person类，吃饭和睡觉
class Person:
    """人类"""

    def eat(self):
        print('吃饭！')

    def sleep(self):
        print('睡觉！')

3.对象的声明

格式：

对象名 = 类名()

对象名 -> 变量名

类名 -> 必须是声明过的类

# 声明了Perosn类的对象p1
p1 = Person()
p2 = Person()

---

三、对象方法

1.类的内容包含属性和方法, 方法分为对象方法、类方法和静态方法

对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self, 通过对象来调用

对象方法的调用: 对象.方法名()。调用对象方法的时候，不需要给默认参数self传参。系统会自动将当前对象传递给self 。

self: 谁调用当前的对象方法，self就指向谁。self就是当前类的对象，类的对象能做的事情，self都能做

# 声明类
class Person:
    """人类"""

    # 对象方法eat
    def eat(self, name):
        # self = p1, name = '小明'
        print('self:',self)
        print('吃饭！')
        self.sleep()

    def sleep(self):
        print('s_self', self)
        print('睡觉')

# 声明对象
p1 = Person()
print('p1:', p1)
p1.eat('小明')
# p1.sleep()

p2 = Person()
print('p2:', p2)
p2.eat('小红')

---

四、构造方法和init方法

1.构造方法

构造方法就是函数名和类名一样的方法，作用是用来创建对象的。

声明类的时候，系统会自动为这个类创建对应构造方法

创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法去对这个对象进行初始化,最后将创建好的对象的地址返回

2.__init__方法

对象方法，不需要手动调用，创建完对象后，会被自动调用

class Dog:
    """🐶类"""
    def __init__(self):
        print(self)
        print('init方法')

dog1 = Dog()
print(dog1)
dog2 = Dog()

3.带参其他参数的init方法

__init__方法的参数要通过构造方法来传。（构造方法的实参，会传递给init方法的形参）

class Person:
    def __init__(self, name='', age=0):
        print(name, age)


p1 = Person('小红', 20)
p2 = Person('小明')
p3 = Person(age=10)

---

五、对象的属性

类的内容包含属性和方法，属性又分为对象属性和类的字段

属性：用来在类中去保存数据的变量。

对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等

对象属性要通过对象来使用

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'


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)

---

六、对象属性的增删改查

class Student:
    def __init__(self, name1='', age1=0, study_id1='001'):
        self.name = name1
        self.age = age1
        self.study_id = study_id1


stu1 = Student('小明')
stu2 = Student('小红', 18)

方法1：对象.属性 --> 获取指定属性值，属性不存在会报错

print(stu1.name)
# print(stu1.name2)   # AttributeError: 'Student' object has no attribute 'name2'

方法2：getattr(对象, 属性名, 默认值) -> 获取指定属性值，如果设置了默认值当属性不存在的时候不会报错， 并且会将默认值作为结果。(如果没有设置默认值，属性不存在还是会报错)

print(getattr(stu1, 'name'))
print(getattr(stu1, 'name2', '张三'))

方法3：对象.getattribute(属性名) -> 获取指定属性值.属性不存在会报错

print(stu1.__getattribute__('study_id'))
# print(stu1.__getattribute__('study_id2')) # AttributeError: 'Student' object has no attribute 'study_id2'

2.增/改(给对象添加属性)

注意：给对象添加属性，只能添加到当前对象中。不会影响当前类的其他对象

方法1：对象.属性 = 值 (属性不存在的时候增加,存在的是就是修改)

方法2：setattr(对象,属性名,属性值)

方法3：对象.setattr(属性名,属性值)

# 添加
stu1.sex = '男'
print(stu1.sex)

# 修改
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)

print(stu1.sex)
delattr(stu1, 'sex')
# print(stu1.sex)

stu1.__delattr__('name')

---

七、对象的使用

class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

    # 定制当前类对象的打印格式，函数的返回值必须是字符串
    def __str__(self):
        return str(self.__dict__)


# 1.将对象给别的变量赋值
stu1 = Student('xiaoHua', 18, 90)
stu2 = stu1   # 赋对象地址
stu3 = copy.copy(stu1)   # 产生新的对象，将新的地址赋值

stu1.name = '张三'
print(stu2.name)
print(stu3.name)

# 2.将对象作为列表的元素
students = [Student('小明', 23, 89), stu3, Student('小红', 10, 67)]
# 找到列表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)

# 对列表中的学生按年龄从小到大排序
students.sort(key=lambda item: item.age)
for stu in students:
    print(stu)

max1 = max(students, key=lambda item: item.score)
print('max:',max1)

# 1.根据姓名查找指定学生的信息。2.根据姓名修改执行的学生的年龄
name = input('请输入学生的名字:')
for stu in students:
    if stu.name == name:
        stu.age = 18
        print(stu)

---

八、slots魔法

1.类的字段

属性：对象属性，类的字段

类的字段: 声明在类里面，函数外面的变量就是类的字段。使用的时候要通过类来使用：类.字段

2.slots: 用来约束当前类的对象的属性有哪些

class Dog:
    # num就是类的字段
    num = 10

    __slots__ = ('color', 'name', 'type', 'sex', 'price', 'age')

    def __init__(self, color, name, type):
        self.color = color
        self.name = name
        self.type = type
        self.sex = '公的'
        print(Dog.num)


Dog.num = 100
print(Dog.num)

dog1 = Dog('黄色', '大黄', '土狗')

# dog1.neme = '财财'
# print(dog1.name)
dog1.age = 3

---

九、内置类属性

class Person:
    """人类"""
    # 类的字段
    num = 61

    # 对象属性
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    # 对象方法
    def run(self):
        print('%s在跑' % self.name)

    def __str__(self):
        return '<<'+self.__class__.__module__+'.'+self.__class__.__name__+\
                'object at ' + hex(id(self))+'>>'
p1 = Person('小明', 18, '男')

属性名	作用	举例
类.__name__	获取当前类的名字	print(Person.__name__)
类.__doc__	获取类的说明文档	print(Person.__doc__)
对象.__class__	获取对象的类, 类能做的事情，他都可以做	my_class = p1.__class__
类.__dict__	获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）	print(Person.__dict__)
对象.__dict__	获取当前对象所有的属性和其对应的值，以字典的形式返回	print(p1.__dict__)
类.__module__	获取当前类所在的模块名	print(Person.__module__)
类.__bases__	获取当前类的父类, 返回的是一个元祖，元祖的元素是类	print(Person.__bases__)