第019篇 :面向对象1

1、编程思想

 面向过程(穷人思想) -- 算法逻辑(解决问题的工具)
 函数式编程(小资思想) -- 函数(解决问题的工具)
 面向对象(富豪思想) -- 类和对象(解决问题的工具)


2、类和对象

2.1、什么是类,什么是对象

 概念:
  类就是拥有相同功能和相同属性的对象的集合 --> 抽象的
  对象就是类的实例 --> 具体的
  如果人是一个类;每一个人就是一个对象。

2.2、类的声明
  • 创建对象的写法:类():创建类的对象并返回
类的说明 -- 用代码描述清楚这个类是哪些相同的功能和相同属性的集合

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

说明:
    class:声明类的关键字,固定写法
    类名:程序员自己命名
        要求:标识符,不能是关键字
        规范:见名知义;采用驼峰式命名;首字母大写
    类的说明文档:用 """""" 引起来的说明性文字
    类的内容:用来描述共同的功能和属性
              主要包含方法(声明在类中的函数)和属性(声明在类中的变量)    
class Person:
    """人类"""
    def eat(self):
        print('人类阔以吃饭')

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

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

# 创建对象
"""
类():创建类的对象并返回
"""
p1 = Person()
print(p1, id(p1))

p2 = Person()
print(p2, id(p2))

3、init方法和构造方法

1)构造函数:python在声明类的时候,系统会自动声明一个和类同名的函数(这个函数就是构造函数);用来创建类的对象
            当我们调用构造函数创建对象的时候,系统会自动调用类中的 __init__ 方法来初始化对象

2)init方法:__init__是一个魔法方法;也是一个对象方法。声明的时候函数名必须是 __init__,并且保证这个方法是对象方法。
            声明后不用调用,系统会自动调用。

记住:
    a、创建对象的时候系统会自动调用__init__方法
    b、创建对象的时候,构造函数需不需要参数,需要几个参数看__init__方法除了self有没有其他的参数,有几个参数。
class Parson:
    def __init__(self):
        print('init方法')
        print(self)

Parson()

print('---')

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

Student('小明', 18)
Student(name='小宝', age=21)

4、类中的属性

  • 类中的属性:就是类中的保存数据的变量
  • 类中的属性分为两种:字段、对象属性
 字段和对象属性
# 字段
"""
1)怎么声明:直接声明在类中函数外面的变量就是字段
2)怎么使用:通过类来使用;以 类.字段 的形式去使用
3)什么时候用:不会因为对象不同而不一样的属性就声明成对象属性
"""

# 对象属性
"""
1)怎么声明:声明在init方法中;以 self.属性名=值 的形式来声明
2)怎么使用:通过对象来使用;以 对象.属性 的形式来使用
3)什么时候用:会因为对象不同而不一样的属性就声明成对象属性
"""
class Person:
    # a就是字段
    a = 10

    # name和age就是对象属性
    def __init__(self, name, age):
        self.name = name
        self.age = age


print(Person.a)

p1 = Person('李白', 21)
print(p1.name, p1.age)

p1 = Person('豆腐', 20)
print(p1.name, p1.age)

 声明一个狗类,拥有属性:品种、名字、颜色、年龄、性别;吃(xxx吃xx)

class Dog:
    def __init__(self, varieties, name, color, age, gender):
        self.varieties = varieties
        self.name = name
        self.color = color
        self.age = age
        self.gender = gender

    def eat(self, foot):
        print('这是一条全身{}的{}的{},它的名字叫{},是一条{};他最喜欢的就是啃{}。'.format(self.color, self.age, self.gender, self.name, self.varieties, foot))


d1 = Dog('中华田园犬', '旺财', '黄色', '三岁半', '公狗')

d1.eat('骨头')

5、类中的方法

  • 类中的方法:指的是类中共同的功能
  • 方法:声明在类中的函数
  • 类中的方法分为三种:对象方法,类方法,静态方法
# 1)对象方法
"""
a、怎么声明:直接声明在类中的函数就是对象方法
b、怎么调用:需要对象来调用。以 对象的.对象方法() 的形式来调用
c、特点:自带参数self,参数self在通过对象调用的时候不用传参;系统会自动将当前对象传给self;
        当前方法:当前调用这个方法的对象(谁去调用它就指向谁)
        当前类的对象能做的事情,self都能做。
"""
class Dog:
    # eat就是对象方法
    def eat(self, food):
        # print('self:', self, id(self))
        print('够吃%s'%food)
        # 对象能做的事情self都能做
        self.run()

    def run(self):
        print('会跑')


dog1 = Dog()
# print('dog1:', dog1, id(dog1))
dog1.eat('肉包子')

 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 = 90
    def __init__(self, name, tel, age=18):
        self.name = name
        self.tel = tel
        self.age = age

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

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

        # cls可以创建对象
        stu2 = cls('大黄', '121')
        stu2.study()
        # cls可以使用类的字段
        print(cls.num)

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


# 对象方法
stu1 = Student('小明', '151')
stu1.study()

# 类方法
print(Student.num)
Student.func1()

# 静态方法
Student.func2()

 对象方法、类方法、静态方法的一个坑

class Keng:
    num = 100

    def func1(self):
        print('坑的类方法')

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

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

# 注意:理论上类中的所有方法都可以通过对象或者类调用
# Keng.func1(12)  # 用类调用对象方法,self将会失去意义
Keng().func1()  # 正解

k = Keng()

# k.func2()   # 用对象调用类方法是多此一举,cls还是当前类
Keng.func2()    # 正解

# k.func3()     # 用对象调用类方法是多此一举,cls还是当前类
Keng.func3()    # 正解

6、对象属性的增删改查

  • 属性的增删改查只针对指定对象有效,不会影响别的对象

class Person:

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


p1 = Person('小明', gender='女')
p2 = Person('小红', 21)

# 1、获取属性值
"""
1)对象.属性名:获取对象知道对象的值
2)getattr(对象, 属性名: str):获取对象指定属性的值 
  getattr(对象, 属性名: str, 默认值):获取对象指定属性的值 
"""
print(p1.name)  # 属性不存在会报错
print(getattr(p1, 'name'))  # 属性不存在会报错
print(getattr(p1, 'name', '小白'))    # 属性不存在不会报错,而是会返回默认值

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


# 修改属性和增加属性
"""
1)对象.值=值:当属性存在的时候就是修改;属性不存在的时候就是增加
2)setattr(对象,属性ming,值):当属性存在的时候就是修改;属性不存在的时候就是增加
"""
# 改
p1.age = 28
print(p1.age)
setattr(p1, 'age', 32)
print(p1.age)

# 增
p1.height = 175
print(p1.height)
setattr(p1, 'weight', 63)
print(p1.weight)


# 3、删除
"""
1)del 对象.属性:删除对象中指定的属性
2)delattr(对象, 属性名):删除对象中指定的属性
"""
del p1.name
print(getattr(p1, 'name', None))
delattr(p1, 'age')
print(getattr(p1, 'age', None))

7、内置类属性

  • 内置类属性:声明类的时候系统提供的属性
  • 如果slots存在,则d.dict不能用
     name,doc,dict,module,bases
class Dog:
    """狗类"""
    num = 10

    # __slots__ = ('name', 'age', 'gender', '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 fun2(cls):
        print('对象方法')

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


d = Dog('小白')

# 类.__name__:获取类的名
print(Dog.__name__)

# 对象.__class__:获取对象对应的类(和type(对象)功能一样)
print(type(d))
print(d.__class__)

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


# 对象.__dict__:获取对象中所有的属性和对应的值,以字典的形式返回
# 类.__dict__:获取类中所有的字段和字段对应的值,以字典的形式返回
print(d.__dict__)   # 注意:如果__slots__存在,则d.__dict__不能用
print(Dog.__dict__)


d.weight = 25


# 类.__module__:获取当前这个类是在什么地方声明的
print(Dog.__module__)



# 类.__bases__:获取当前类的父类
# object是python的基类
print(Dog.__bases__)

你可能感兴趣的:(第019篇 :面向对象1)