1⃣️面向对象编程

编程思想：

1.面向过程编程 ---> 算法、逻辑
2.函数式编程 --> 函数
3.面向对象编程 -->类和对象

2⃣️类的声明

1.什么是类

类 - 是拥有相同属性和相同功能的对象的集合(抽象的)
对象 - 就是类的实例(具体的)

从生活的角度来看类和对象
如果说认识一个类， 水原佑果就是一个对象，藤原浩也是一个对象
如果说电脑是一个类，我桌上的这台Mac就是一个对象
如果水杯是一个类，我手上的这个杯子就是一个对象
如果车是一个类、汽车、自行车、摩托车等这些是车这个类的子类，具体的某一辆车才是对象:object

2.类的声明

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

说明：
class - > python中声明类的关键字
类名 -> 标识符,不能是关键字;类名使用驼峰式命名，并且首字母大写;见名知义
驼峰式命名:如果一个名字有多个单词组成,第一个单词首字母小写,后面每个单词首字母都要大些
userName
PEP8命名规范:如果一个名字有多个单词组成,所有字母小写,多个单词之间用下划线隔开
user_name
(父类列表) -> 继承语法,让声明的类继承括号中的夫类。这个结构可以省略,让当前类继承python基类
: -> 固定结构
类的说明文档 -> 注释,对类进行说明。
类的类容 -> 包含属性(变量)和方法(函数)
方法:声明在类中的函数

.声明Person类,吃饭和睡觉

class Person:
    """人类"""
    def eat(self):
        print('吃饭')
    def sleep(self):
        print('睡觉')

3.对象的声明

格式:
对象名 = 类名()

对象名 -> 变量名
类名 -> 必须是声明过的类
"""

声明了Person类的对象p1,p2

p1 = Person()
p2 = Person()

3⃣️对象方法

1.

类的类容包含属性和方法,方法分为对象方法、类方法和静态方法
对象方法:直接声明在类中的函数就是对象方法。对象方法都一个默认参数self,通过对象来调用
对象方法的调用: 对象.方法名()。调用对象方法的时候，不需要给默认值self传参，系统会自动当前对象传递给self
self:谁调用当前的对象方法,self就指向谁。self就是当前类的对象,类的对象能做的self就能做

class Person:
    """人类"""

    def eat(self, name):
        print('吃饭')


p1 = Person()
p1.eat(10, 12)

4⃣️构造方法和init方法

1.构造方法

构造方法就是函数名和类名一样的方法,作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应的构造方法
创建对象的过程:调用构造方法在内存中开辟空间创建对象,并且会自动调用init方法去对这个对象初始化,最后将创建好的对象地址返回

2.init方法

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

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


dog1 = Dog()
print(dog1)

3.带其他参数的init方法

init方法的参数通过构造方法来传参。(构造方法的实参，会传递给init方法的形参)

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


p1 = Person('小明', 23)

5⃣️对象的属性

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

属性:用来在类中去保存数据的变量。
对象属性:属性的值会因为对象的不同而不同,这中属性就需要声明成对象属性,比如人的名字、年龄等
对象属性要通过对象来使用

1.对象属性的声明(重点！)

a.必须声明在init方法中
b.声明的格式: self.属性 = 初值

2.使用对象属性: 对象.属性

class Person():
    def __init__(self):
        self.name = 'hjj'
        self.age = 23
        self.sex = '男'


p1 = Person()

print(p1.sex, Person().sex)

3.创建对象的时候可以给对象属性赋值

声明一个人类,有名字，年龄性别。要求创建对象的时候就可以确定不同的属性值

class Person1:
    def __init__(self, name1, age1, sex1):
        self.name = name1
        self.age = age1
        self.sex = sex1

p1 = Person1('藤原浩', 40, '男')


print(p1.name)

6⃣️对象属性的增删改查

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

stu1 = Student('小明')

1.查(获取对象属性的值)

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

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

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

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

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

print(stu1.__getattribute__('name'))

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

注意：给对象添加属性，只能添加到当前对象中。不会影响到当前类的其他对象
方法一:对象.属性 = 值(属性不存在的时候增加，存在的时候就是修改)
方法二:setattr(对象,属性名,属性值)
方法三:对象.setattr(属性名,属性值)

stu1.name = '浅野启介'
print(stu1.name)
setattr(stu1, 'name', '藤井树')
print(stu1.name)

3.删除(删除对象属性)

注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象, 属性名)
方法三：对象.delattr()属性名

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

delattr(stu1, 'age')

7⃣️对象的使用

python中所有的数据都是对象，所有的变量存储的都是对象的地址

import copy


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, 88), Student('小蛙', 2, 32)]

找到列表students成绩最好的学生的名字

max1 = 0
for x in students:
    if x.age > max1:
        max1 = x.age

print(max1)

对列表中的学生按年龄从小到大排序

students.sort(key=lambda item: item.age)
for x in students:
    print(x)

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

根据姓名查找指定学生的信息

def select():
    stu_name = input('请输入学生姓名')
    for stu in students:
        if stu.name == stu_name:
            print(stu)
            c_age = input('请输入修改的年龄')
            stu.age = int(c_age)
            print(stu)
select()

8⃣️slots魔法

1.类的字段

属性：对象属性，类的字段
类的字段：声明在类里面，函数的外面的变量。使用的时候要通过类来使用：类.字段

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

class Dog:
    num = 10
    __slots__ = ('color', 'name', 'type')  # 指定只能添加的属性

    def __init__(self, color, name, type):

        self.color = color
        self.name = name
        self.type = type
        print(Dog.num) 

        
print(Dog.num)


dog1 = Dog('黄色', 'py', '柯基')

9⃣️内置类的属性

class Person:
    """人类"""

    # 类的字段
    num = 39

    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('py', 12, '男')
# 1.__name__
"""
类.__name__  -->获取当前类的名字

"""

print(Person.__name__)

# 2,__doc__
"""
类.__doc__ -->获取当前类的说明文档
"""

print(Person.__doc__)

# 3.__class__
"""
对象.__class__ -> 获取对象的类

"""
my_class = p1.__class__

print(my_class('aa', 1, 'nan').num)

# 4.__dict__
"""
类.__dict___ -->获取当前类的所有类的字段和其对应的值，以字典的形式返回
对象.__dict__ -->获取当前对象所有的属性和其对应的值，一字典的形式返回
"""
print(Person.__dict__)
print(p1.__dict__)

# 5.__module__
"""
类.__module__ --> 获取当前类所在的模块
"""
print(Person.__module__)

# 6.__base__
"""
类.__base__ --> 获取当前类的夫类，返回的是一个元祖，元祖的元素是类

"""
print(Person.__bases__)
print(p1)