面向对象

编程思想：

• 1.面向过程的编程 --》 算法、逻辑（数学逻辑）
• 2.函数式编程 --》函数，模块
• 3.面向对象编程 --》类和对象（生活逻辑）

n = 100
sum1 = 0
for x in range(n+1):
    sum1 += 1

def add_student():
    pass

class Student_Manager:
    def add_student(self):
        pass

value = input('数字')
if value == '1':
    add_student()

类的声明

1.什么是类和对象

• 类是拥有相同属性和相同功能的对象集合
  对象 --》 就是类的实例（具体的）

从生活的角度来看类和对象
如果说人是一个类，yt就是一个对象。
如果车是一个类，汽车、自行车这些是这个类的子类，具体的这辆车才是类的对象

2.类的声明

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

#1.声明Person类，吃饭和睡觉
class Person:
    """人类"""
    def eat(self):
        print('吃饭')
    def sleep(self):
        print('睡觉')

3.对象的声明

• 对象名 = 类名（）
  对象名 -》 变量名
  类名 -》必须是声明过的类

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

对象方法

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

• 对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self，需要使用对象来调用
• 对象方法的调用：对象.方法名()。调用对象方法的时候，不需要给默认参数self 传参 系统会自动将当前对象传递给self。
• self谁调用当前的对象方法，self就指向谁.self就是当前类的对象，类的对象能做的事情，self都能做

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

p1 = Person()
print('p1',p1)
p1.eat('小明')

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

构造方法和init方法

1.构造方法

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

2.init方法

• 对象手法
• 不需要手动调用会自动调用

class Dog:
    """dog类"""
    def __init__(self):
        print('init方法')
dog1 = Dog()

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

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

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

p1 = Person('小红','18')

对象的属性

• 类的内容包含属性和方法，属性又分为对象属性和类的字段
• 属性：用来在类中保存数据的变量。
• 对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等 对象属性要通过对象来使用

1.对象属性的声明（重点！！）

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

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

class Person:
    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.sex = '男'

p1 = Person()
print(p1.age)

class Person1:
    def __init__(self, name, age=0, sex='girl'):
        self.name = name
        self.age = age
        self.sex = sex
        self.id = '0001'
p1= Person1('小明',30,'女')
p1.name = 'XiaoMing'
print(p1.name)
p1.id ='0001'
print(p1.id)
p2 =Person1('小红',30,'男')
print(p2.name)
p3 =Person1('小花')
print(p3.sex)

对象属性的增删改查

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.查（获取对象属性的值）

• 方法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.对象.r__getattribute__（属性名）--》获取指定的属性值，属性不存在会报错

print(stu1.__getattribute__('study_id'))

#增、改

• 注意：给对象添加属性，只能添加到当前对象中。不会影响当前类的其他对象
• 方法1：对象.属性 == 值（属性不存在就是添加，存在就是修改）
• 方法2：setattr（对象，属性名，属性值）
• 方法3：对象.r__setattr__(属性名，属性值)

stu1.sex = '男'
print(stu1.sex)

#修改
stu1.name = '李四'
print(stu1.name)

#修改
setattr(stu1, 'name', '娜美')
print(stu1.name)

#增加
setattr(stu1, 'name2', 'Lisa')
print(stu1.name2)

＃3.删除

• 注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
• 方法1：del 属性.对象
• 方法2：delattr（对象.属性名）
• 方法3：r__delattr__(属性名)

del  stu1.age
# print(stu1.age)

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

stu1.__delattr__('name')

7.对象的使用

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

num = int()
print(num.bit_length())

list1 = ['a', 1]
list1.append('abc')
print(list1)

#定制当前类对象打印格式，函数的返回值必须是字符串

• def str(self):
  return str(self.dict)

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.score)

#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('小红', 18, 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.r__slots__:用来约束当前类的对象的属性有哪些

class Dog:
    #num就是类的字段
    num = 10
    __slots__ = ('color', 'name', 'type','sex')

    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(1, 1, 1)

#1.r__name__

• 类.r__name__ ->获取当前类的名字

print(Person.__name__,type(Person.__name__))

#2.r__doc__

-类.r__doc__ -》 获取类的说明文档

print(Person.__doc__)
print(int.__doc__)
print(dict.__doc__)

#3.r__class__

my_class = p1.__class__
p2 = my_class('小花', 10, '女')
p2 =Person('小花', 10, '女')
print('===================================')
print(p2.name)
print(Person.num)
print(my_class.num)

#4.dict

• 类.dict --> 获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
• 对象.dict --> 获取当前对象所有的属性和其对应的值，以字典的形式返回

print(Person.__dict__)
print(p1.__dict__)

#5.module

• 类.module -> 获取当前类所在的模块

print(Person.__module__)

from datetime import datetime
print(datetime.__module__)

#6.bases

• 类.bases ->获取当前类的父类，返回的是一个元祖，元祖的元素是类

print(Person.__bases__)
print(p1)