day14-类和对象1

1.面向对象编程

1.面向过程编程  --> 算法、逻辑（数学逻辑）

2.函数式编程  ---> 函数

3.面向对象编程 ---> 类和对象（生活）

代码示例

# 1.面向过程
n = 100
for x in range(n+1):
    sum += x

# 2.函数式编程


def add():
    pass


value = input('数字')
if value == '1':
    """函数"""
    add()

# 3.面向对象


class Studeng_Manager:
    def add(self):
        pass


value = input('数字')
if value == '1':
    """函数"""
    Studeng_Manager.add()

2.类的声明

1.什么是类和对象
类是拥有相同属性和相同功能的对象的集合
对象就是类的实例（类都是抽象的、具体的）

从生活的角度来看类和对象
如果说人是一个类，余婷就是一个对象
如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果水杯是一个类，具体的某一个水杯才是这个类的对象
如果车是一个类，汽车、自行车等这些是这个类的子类，具体的某一辆车才是对象

2.类的声明
格式：
class  类名（父类列表）：
     类的说明文档
     类的内容

说明：
class -> python中声明类的关键字
类名 -> 标识符，不能是关键字，类名使用驼峰式命名，并且首字母必须大写:见名知义
        驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
                    userName
        PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词用下划线隔开
                    user_name

（父类列表） -> 继承语法，让声明的类继承括号中的父类，这个结构可以省略，
让当前类python的基类：object
: -> 固定结构
类的说明文档 —> 注释，对类进行说明
类的内容 --> 包含属性（数据）和方法（函数）
             方法：声明在类中的函数

代码示例

# 声明人这个类，都可以吃饭和睡觉


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

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

3.对象的声明
对象名= 类名（）

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

代码示例

# 声明了Person()
p1 = Person()
p2 = Person()

3.对象方法

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

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

代码示例

class Person:
    # 对象的方法eat

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

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


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

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

运行结果

p1: <__main__.Person object at 0x000001E717428470>
self: <__main__.Person object at 0x000001E717428470>
吃饭！
s_self: <__main__.Person object at 0x000001E717428470>
睡觉
p2: <__main__.Person object at 0x000001E7174284E0>
self: <__main__.Person object at 0x000001E7174284E0>
吃饭！
s_self: <__main__.Person object at 0x000001E7174284E0>
睡觉

4.构造方法和init方法

1.构造方法
构造方法就是函数名和类名一样的方法，作用就是用来创建对象的。声明类的时候，系统会自动为这个类
创建对应的构造方法

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

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

代码示例

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


dog1 = Dog()
print(dog1)

运行结果

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


dog1 = Dog()
print(dog1)

运行结果

<__main__.Dog object at 0x000001B38EA88438>
init方法
<__main__.Dog object at 0x000001B38EA88438>

3.带其他参数的init方法
__init__方法的参数要通过构造方法来传。构造方法的实参，会传给init方法的形参

代码示例

class Person:

    def __init__(self, name='火', age=''):
        print(name, age)


p1 = Person('小明', 45)
p2 = Person(age=89)
p3 = Person('小红')

运行结果

小明 45
火 89
小红 

5.对象的属性

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

属性：用来在类中保存数据的变量。
对象属性：属性的值会因为对象不同 而不同，这种属性就需要声明成对象属性，例如：人的名字、年龄等
          对象属性要通过对象来使用
1.怎么声明对象属性（重点）
a.必须声明在__init__方法中
b.声明格式：self.属性名 = 初值

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

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

代码示例

class Person:
    def __init__(self, name, age=0, sex='grile'):
        self.name = name
        self.age = age
        self.sex = sex


p1 = Person('小明', 45, '男')
print(p1.name)

p2 = Person('小❀')
print(p2.name, p2.age, p2.sex)

运行结果

小明
小❀ 0 grile

6.对象属性的增删改查

1.查（获取对象属性的值）
方法一：对象.属性  -->  获取指定属性的值,属性不存在会报错
方法二:getattr(对象，'属性名'，默认值)  若属性名不存在，则返回默认值（若没有设置默认值。会报错）
方法三：对象.__getattribute__('属性名'） -> 获取指定属性值

代码示例

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('小红')
print(stu1.name)
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name', '张三'))
print(getattr(stu1, 'name1', '张三'))
print(stu1.__getattribute__('age'))

运行结果

小明
小明
小明
张三
0

2.增/改（给对象添加属性）
注意：给对象添加属性和只能添加到当前对象中，不会影响当前类的其他对象
方法一：对象.属性 = 值（属性不存在是增加，存在是修改）
方法二：setattr(对象，'属性名'，属性值)
方法三：对象.__setattr__('属性名'，属性值)

代码示例

stu1.sex = '男'
stu1.age = 2
print(stu1.sex)
print(stu1.age)
setattr(stu1, 'name', '李四')
print(stu1.name)
setattr(stu1, 'name2', '王腾')
print(stu1.name2)

运行结果

0
男
2
李四
王腾

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

代码示例

del stu1.name2

delattr(stu1, 'sex')

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__)
        return str(self.__dict__)

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

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

# 2.将对象作为列表的元素
students = [Student('小郭', 23, 98), Student('香锅', 18, 69), 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)

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

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

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

运行结果

张三
xiaohu
小郭 98
{'name': '香锅', 'age': 18, 'score': 69}
{'name': 'xiaohu', 'age': 18, 'score': 90}
{'name': '小郭', 'age': 23, 'score': 98}
{'name': '小郭', 'age': 23, 'score': 98}
请输入学生的名字：香锅
{'name': '香锅', 'age': 18, 'score': 69}

8.slots魔法

1.类的字段
属性:对象属性，类的字段
类的字段：声明在类里面，函数外面的变量就是类的字段。使用的时候要用类来使用：类.字段
2.__slots__ 用来约束当前的对象的属性与那些

代码示例

class Dog:
    # 类的字段
    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)


print(Dog.num)

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

运行结果

10
10

9.内置类属性

代码示例

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

# 2.__doc__
"""
类.__doc__ --> 获取类的说明文档
"""
print(Person.__doc__)

# 3.__class__
"""
对象.__class__ -> 获取对象的类
"""
print(Person.__class__)
my_class = p1.__class__
print(my_class('小花', 65, '女'))
p2 = my_class('小花', 65, '女')
print(p2.name)

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

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

# 6.__bases__
"""
类.__bases__ -> 获取当前类的父类，返回的是一个元组，元组的元素是一个类
"""
print(Person.__bases__)
print(p1)

运行结果

Person
人类
<class 'type'>
{__main__.Personobject at 0x207886284a8}
小花
{'__module__': '__main__', '__doc__': '人类', 'num': 61, '__init__': <function Person.__init__ at 0x0000020788624D90>, 'run': <function Person.run at 0x000002078862B268>, '__str__': <function Person.__str__ at 0x000002078862B2F0>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
{'name': '小明', 'age': 18, 'sex': '男'}
__main__
(<class 'object'>,)
{__main__.Personobject at 0x20788628438}