类和对象

1.什么是类，什么是对象

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

如果人是类，余婷和骆昊就是对象
如果车是类，具体某一辆车才是对象

2.类的声明 - 用代码描述清楚这个类是哪些相同功能和相同属性的集合

"""
1)语法:
class 类名:
    类的说明文档
    类的内容

2)说明
class - 声明类的关键字
类名 - 标识符，不能关键字，见名知义，采用驼峰式;首字母大写
类的说明文档 - 用""""""引起来的说明性文字
类的内容 - 用来描述共同的功能和属性
         主要包含方法(声明在类中的函数)和属性(声明在类中的变量)
"""


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

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

    def thinking(self):
        print('人类思考')

3.创建对象

"""
语法:
类() - 创建类的对象并返回
"""

p1 = Person()
p2 = Person()

print(id(p1), id(p2))

对象方法

1.类中的方法 - 就是类中共同的功能

方法 - 声明在类中的函数

类中的方法分为三种:对象方法、类方法、静态方法

2.对象方法

"""
1)怎么声明 - 直接声明在类中的函数就是对象方法
2)怎么调用：需要对象来调用;以'对象.对象方法()'的形式来调用
3)特点:有个自带参数self,参数self在通过对象调用的时候不用传参
        系统会自动将当前对象给self传参
        当前对象 - 当前调用这个方法的对象
        当前类的对象能做的事情，self都可以做
"""


class Dod:
    # eat就是对象方法
    def eat(self, food='骨头'):
        print('self:', self)
        print('狗吃' + food)


dog1 = Dod()    # dog1就是Dog的对象
print('dog1:', dog1)
dog1.eat()

init的方法和构造方法

1.init的方法和构造方法

"""
1)构造函数 - python中声明类的时候,系统会自动声明一个和类同名的函数
            这个函数就是构造函数，用来创建当前类的对象
            当我们调用构造函数创建对象的时候，
            系统会自动调用类中的__init__方法来初始化对象
            
2)__init__方法 - 魔法方法;也是一个对象方法。声明的时候函数名必须是__init__
                        并且保证这个方法是对象方法
                        声明后不用去调用，系统会自动调用

记住:a.创建对象的时候系统自动调用__init__方法
    b.创建对象的时候，构造函数需不需要参数，需要几个参数看__init__除了self以外
    需要几个参数
"""


class Person:
    def __init__(self):
        print('init方法')


p1 = Person()
p2 = Person()


class Student:
    def __init__(self, name, age=10):
        print('学生类的init', name, age)


stu1 = Student('小明', 18)
stu2 = Student(age=20, name='小花')

类中的属性

1.类中的属性 - 就是类中保存数据的变量

类中的属性分为两种:字段、对象属性

2.字段

1)怎么声明:直接声明在类里面函数外面中的变量就是字段
2)怎么使用:通过类使用:以'类.字段'的形式去使用
3)什么时候用:不会因为对象不同而不同的属性就声名成对象属性

3.对象属性

1)怎么声明:
声明在init方法中;以'self.属性名=值'的形式来声明

2)怎么使用:通过对象来使用;以'对象.属性'的形式来使用

3)什么时候用:会因为对象不同而不同的属性就声名成对象属性

class Person:
    # a就是字段
    a = 10

    # name和age就是对象属性
    def __init__(self):
        self.name = '小明'
        self.age = 18


print(Person.a)

p1 = Person()
print(p1.name, p1.age)

p2 = Person()
print(p2.name, p2.age)

print('===================================================')


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


stu1 = Student('小明')
print(stu1.name, stu1.age, stu1.score)

stu2 = Student('小花', 60)
print(stu2.name, stu2.age, stu2.score)

print('==================================================')
# 声明一个狗类，拥有属性:品种、名字、颜色、年龄、性别;吃(XXX吃XXX)


class Dog:
    def __init__(self, name, pz='土狗', color='黄色', age=1, sex='公'):
        self.pz = pz
        self.name = name
        self.color = color
        self.age = age
        self.sex = sex

    def eat(self, food):
        print('%s吃%s' % (self.name, food))


dog1 = Dog('旺财', age=3)
dog2 = Dog('小强', '二哈', '黑白')

print(dog1.pz, dog1.name, dog1.color, dog1.age, dog1.sex)
print(dog2.pz, dog2.name, dog2.color, dog2.age, dog2.sex)
dog1.eat('屎')
dog2.eat('骨头')

类中的方法

1.类中的方法

类中的方法有三种:对象方法、类方法、静态方法

1)对象方法
a.怎么声明:直接声明在类中的函数
b.怎么调用:通过对象来调用
c.特点:自带一个参数self;self在调用的时候不用传参，指向当前对象
self -> 当前对象

d.什么时候用:如果实现函数的功能需要用到对象属性，这个函数就声名成对象方法

2)类方法
a.怎么声明:在函数声明前加@classmethod
b.怎么调用:通过类来调用
c.特点:自带参数cls, cls调用时不用传参，系统会自动将当前类传给cls
cls -> 当前类(当前类能做的事情cls都可以做)
d.什么时候用:实现函数的功能不需要对象属性的前提下，需要类的时候用类方法

2)静态方法
a.怎么声明:在函数声明前加@staticmethod
b.怎么调用:通过类来调用
c.特点:没有自带的参数
d.什么时候用:实现函数的功能不需要对象属性的前提下，也不需要类的时候用静态方法

class Student:
    num = 100

    def __init__(self, name, tel, age=18):
        self.name = name
        self.age = age
        self.tel = tel

    # study是对象方法
    def study(self):
        print('%s在学习' % self.name)

    @classmethod
    def func1(cls):
        print('cls:', cls)
        print('类方法func1')

        # cls可以创建对象
        stu2 = cls('小花', 112, 20)
        print('stu2:', stu2)
        print(cls.num)

    @staticmethod
    def fun2():
        print('静态方法fun2')


stu = Student('小明', '110')
stu.study()

print('Student:', Student)
Student.func1()
Student.fun2()


class Math:
    pi = 3.141592653

    @classmethod
    def circle_area(cls, r):
        return cls.pi * r ** 2

    @staticmethod
    def sum(num1, num2):
        return num1 + num2


class Keng:
    num = 100

    def func1(self):
        print('坑中的对象方法')

    @classmethod
    def func2(cls):
        print('坑中的类方法')

    @staticmethod
    def func3():
        print('坑中的静态方法')


# 注意:类中的所有方法都可以通过对象或者类调用
# 类调用对象方法
Keng.func1(1)  # 用类调用对象方法self会失去意义
k = Keng()
k.func2()       # 用对象调用类方法多此一举，cls还是当前类
k.func3()       # 同上

对象属性的增删改查

class Person:

    def __init__(self, name, age=18, gender='女'):
        self.name = name
        self.age = age
        self.gender = gender


p1 = Person('小明', gender='男')
p2 = Person('小红', 20)

# 1.获取属性的值
# 属性的增删改查只针对指定的对象有效，不会影响别的对象
"""
1)对象.属性 - 获取对象指定属性的值
2)getattr(对象,属性名:str) - 获取对象指定属性的值
3)getattr(对象,属性名:str,默认值) - 获取对象指定属性的值
"""
print(p1.name)
print(getattr(p1, 'name'))
print(getattr(p1, 'aaa', '无名氏'))

# attr = input('输入需要获取的属性:')
# print(getattr(p1, attr))


# 2.修改属性和增加属性
"""
1)对象.属性 = 值  -  当属性存在的时候就是修改，不存在就是增加
2)setattr(对象,属性名,值)  -  当属性存在的时候就是修改，不存在就是增加
"""

# 改
p1.age = 28
print(p1.age)

setattr(p1, 'age', 30)
print(p1.age)


# 增
p1.height = 180
print(p1.height, getattr(p1, 'height'))

setattr(p1, 'weight', 70)
print(p1.weight)


# 3.删除对象属性
"""
1)del 对象.属性 - 删除对象中指定的属性
2)delattr(对象,属性名) - 删除对象中指定的属性
"""

# del p1.name
# print(p1.name)
#
# delattr(p1, 'age')
# print(p1.age)

内置属性

# 内置类属性 - 声明类的时候系统提供的属性


class Dog:
    """狗类！"""
    num = 100

    # 约束对象属性
    # __slots__ = ('name', 'age', 'gender', 'height', 'weight')

    def __init__(self, name, age=3, gender='公狗'):
        self.name = name
        self.age = age
        self.gender = gender

    def func1(self):
        print('对象方法', self.name)

    @classmethod
    def func2(cls):
        print('类方法')

    @staticmethod
    def func3():
        print('静态方法')


dog1 = Dog('大黄')

# 1. 类.__name__    -    获取类的名字

print(Dog)
print(Dog.__name__)


# 2. 对象.__class__  -  获取对象对应的类(和type(对象)功能一样)
print(type(dog1))
print(dog1.__class__)


# 3. 类.__doc__    -    获取类的说明文档
print(Dog.__doc__)


# 4. __dict__

# 类.__dict__    -    获取类中所有字段和字段对应的值，以字典的形式返回
print(Dog.__dict__)


# 5.(掌握!) 对象.__dict__  -  获取对象所有的属性和对应的值，以字典形式返回
print(dog1.__dict__)

# 6.__slots__  -  用来约束当前类最多能够拥有的对象属性

# 注意 __dict__和__slots__只能存在一个，不可兼得

# 7.类.__module__  -  获取当前这个类实在哪个模块中声明的,返回模块名
print(Dog.__module__)
print(int.__module__)


# 8. 类.__bases__    -    获取当前类的父类

# object是python的基类
print(Dog.__bases__)