python面向对象1

一、类和对象

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

类就是拥有相同功能和相同属性的对象的集合(重要) - 抽象的

对象就是类的实例 - 具体的

如果车是类，具体的某一辆车才是对象

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

"""
1)语法:
class 类名:
    类的说明文档
    类的内容
   
2)说明
class  -  声明类的关键字，固定写法
类名    -  程序员自己命名
          要求: 标识符，不能是关键字
          规范: 见名知义；采用驼峰式命名；首字母大写
类的说明文档  -  用""""""引起来的说明性文字
类的内容  -   用来描述共同的功能和属性
             主要包含方法(声明在类中函数)和属性(声明在类中的变量)
"""
# student_name  -> PEP8     studentName  ->  驼峰式命名


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

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

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

    def opertion(self, char):
        print()

3.创建对象

语法：

类() —— 创建类的对象并且返回

p1 = Person()
# 同一个类的对象可以有对象
p2 = Person()
p3 = p2

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

二、对象方法

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

方法 —— 声明在类中的函数

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

2.对象方法

1)怎么声明: 直接声明在类中的函数就是对象方法

2)怎么调用: 需要对象来调用; 以'对象.对象方法()'的形式来调用

3)特点: 自带参数self, 参数self在通过对象调用的时候不用传参; 系统会自动将当前对象传给self传参；

当前对象 - 当前调用这个方法的对象

当前类的对象能做的事情，self都可以做

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

        # 对象能做的事情self都能做
        self.run()

    def run(self):
        # self=dog2
        print('狗跑步')


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

dog2 = Dog()
print('dog2:', dog2)
dog2.eat('肉')

三、_ _ init _ _ 方法和构造方法

"""
1）构造函数 - python中声明类的时候，系统会自动声明一个和类同名的函数(这个函数就是构造函数)；用来创建当前类的对象。
            当我们调用构造函数创建对象的时候，系统会自动调用类中的__init__方法来初始化对象
2) init方法 - __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()   # TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

stu2 = Student('小明', 18)
stu3 = Student(age=20, name='小花')
stu4 = Student('Tom')

四、类中的属性

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

类中的属性分为2种：字段、对象属性

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(a)    # NameError: name 'a' is not defined
print(Person.a)

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

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


class Student:
    def __init__(self, n, s=0):
        self.name = n
        self.age = 18
        self.score = s


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

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


# 声明一个狗类，拥有属性：品种、名字、颜色、年龄、性别； 功能: 吃(xxx吃xxx)
class Dog:
    def __init__(self, name, bread='土狗', color='黄色', age=1, gender='公狗'):
        self.breed = bread
        self.name = name
        self.color = color
        self.age = age
        self.gender = gender

    def eat(self, food: str):
        # self=dog1; food='肉'
        print('%s在吃%s' % (self.name, food))   # self.name->dog1.name


dog1 = Dog('大黄')
dog2 = Dog('财财', color='黑色')

dog1.eat('肉')
dog2.eat('骨头')

五、类中的方法

1.类中的方法

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

1)对象方法

a.怎么声明：直接声明在类中的函数

b.怎么调用：通过对象来调用

c.特点：自带一个参数self；self在调用的时候不用传参，指向当前对象 self -> 当前对象

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

2)类方法

a.怎么声明：在函数声明前加@classmethod

b.怎么调用：通过类来调用

c.特点：自带一个参数cls; cls在调用的时候不用传参，系统会自动将当前类传给cls

cls -> 当前类 (当前类能做的事情cls都可以做)

d.什么时候用：实现函数的功能不需要对象属性的前提下，需要类

3)静态方法

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')
        # print(num)    # NameError: name 'num' is not defined
        print(Student.num)

        # cls可以创建对象
        stu2 = cls('小花', '112', 20)
        print('stu2:', stu2)
        # cls可以使用类的字段
        print(cls.num)

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


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

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

Student.func2()


class Math:
    pi = 3.1415926

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

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

六、对象属性的增删改查

1.获取属性值

1）对象.属性 - 获取对象指定属性的值

2）getattr(对象, 属性名:str) - 获取对象指定属性的值

3）getattr(对象, 属性名:str, 默认值) - 获取对象指定属性的值，没有不会报错，会获取默认值

2.修改属性和增加属性

1）对象.属性 = 值 当属性存在的时候就是修改；属性不存在的时候是增加

2）setattr(对象, 属性名, 值) 当属性存在的时候就是修改；属性不存在的时候是增加

3.删除对象属性

1) del 对象.属性 - 删除对象中指定的属性

2) delattr(对象, 属性名) - 删除对象中指定的属性

注意: 属性的增删改查只针对指定对象有效，不会影响别的对象

七、内置属性

1. 类._ _ name _ _ - 获取类的名字

2. 对象._ _ class _ _ - 获取对象对应的类(和type(对象)功能一样)

3. 类._ _ doc _ _ - 获取类的说明文档

4.类._ _ dict _ _ - 获取类中所有的字段和字段对应的值，以字典的形式返回

5. (掌握！) 对象._ _ dict _ _ - 获取对象所有的属性和对应的值，以字典的形式返回

注意: 如果设置了_ _ slots _ _,对象的 _ _ dict _ _就不能用

6.类._ _ module _ _ - 获取当前这个类是哪个模块中声明的，返回的是模块名

7.类._ _ bases _ _ - 获取当前类的所有的父类

object是python的基类