Day-14 - 类和对象（2018-10-17）

一、面向对象编程

编程思想：

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

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

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

面向过程编程：

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 类名(父类列表):
    类的说明文档
    类的内容

• 说明：

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

2. 类名 --> 标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写；见名知意
   驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
   例：userName
   PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词之间用下划线隔开
   例：user_name

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

4. : --> 固定结构

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

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

# 声明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传参，系统会自动将当前对象传递给self

• self: 谁调用当前的对象方法，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__))

• 3. __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

• 4. __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__)

• 5. __module__
类.__module__ --> 获取当前类所在的模块名

print(Person.__module__)  # __main__

• 6. __bases__
类.__bases__ --> 获取当前类的父类，返回的是一个元组，元组的元素是类

print(Person.__bases__)  # (<class 'object'>,)