day2023-3-24-面向对象

Posted summer--alian

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了day2023-3-24-面向对象相关的知识，希望对你有一定的参考价值。

一、编程思维

根据面对问题不同人呈现出的思维模式不同，可以将编程思维分为三种：

1.面向过程编程（穷人思想）—— 遇到问题马上想到的是解决这个问题的具体逻辑和步骤

2.函数式编程（小资思想）—— 遇到问题马上想到的是有没有一个已经存在的函数可以解决这个问题，如果没有就造一个（一个函数只具备一个功能）

3.面向对象编程（富豪思想）—— 遇到问题马上想到的是有没有一个具有这个功能的对象，如果没有就造对象（一个对象可以同时具有多个功能）

二、类和对象

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

类就是具有相同功能或者相同属性的对象的集合。（类是抽象的概念）
对象就是类的实例。（对象是类具体的表现）

如果人是类，lisa是人的对象，jenny是另一个对象。
车是类，lisa的车是对象，jenny的车是另一个对象。
用面向对象编程实现斗地主游戏，类是斗地主游戏，每一盘游戏是对象。

2.定义类 —— 创建类

1）定义类：用代码来描述你的这个类是拥有哪些相同功能（用函数）和哪些相同属性（用变量）的对象的集合。
2）语法：
class 类名(父类)：
类的说明文档
类的内容（包含方法和属性）

3）说明：
a.class —— 关键字，固定写法
b.类名 —— 由程序员自己命名
两个要求：是标识符，不是关键字
规范：见名知义；不使用系统的函数名、类名和模块名；采用驼峰式命名（大驼峰）
c.类的说明文档 —— 本质就是一个多行注释
d.类的内容 —— 包含定义在类中的函数（方法）和定义在类中的变量（属性）
方法包括：对象方法、类方法、静态方法
属性包括：类属性、对象属性

class Dog:
    """这是狗"""
    pass

3.创建对象

对象是通过类来创建的。

语法：
类名()

dog1 = Dog()
dog2 = Dog()
print(dog1)
print(dog2)

三、方法

1.什么是方法

定义在类中的函数就是方法

2.不同的方法的使用

1）对象方法
a.怎么定义:直接定义在类中的函数就是对象方法
b.怎么调用:以’对象.xxx()'的形式来调用
c.特点:自带参数self，调用函数的时候self不需要传参，系统自动将当前对象传给self(谁调用self指向谁)

2）类方法
a.怎么定义:定义函数前添加装饰器@classmethod
b.怎么调用:以’类名.xxx()'的形式来调用
c.特点:自带参数cls，调用函数的时候cls不需要传参，系统会自动将当前类传给cls

3）静态方法
a.怎么定义:定义函数前添加装饰器@staticmethod
b.怎么调用:以’类名.xxx()'的形式来调用
c.特点:没有特点

class A:
    # func1、func2是对象方法
    def func1(self):
        # self = a1
        print(f'self:self')
        print('对象方法')

    def func2(self, a, b=2):
        print(f'对象方法2, a:a, b:b')

    # func3是类方法
    @classmethod
    def func3(cls):
        print(f'cls:cls')
        print('类方法')

    # func4是静态方法
    @staticmethod
    def func4():
        print('静态方法')


a1 = A()
a2 = A()
print(f'a1:a1')
print(f'a2:a2')
# 通过对象调用对象方法
a2.func1()             # 对象方法
a1.func2(100)          # 对象方法2, a:100, b:2
a1.func2(100, 200)     # 对象方法2, a:100, b:200

# 通过类调用类方法
print(f'A:A')
A.func3()

# 通过类调用静态方法
A.func4()


class Math:
    @staticmethod
    def sum(n1, n2):
        pass

    @staticmethod
    def factorial(num):
        pass

四、初始化方法

1.魔法方法

1）魔法方法的特点：
a.函数名以 __ 开头，并且以 __ 结尾
b.魔法方法不需要程序员自己调用，系统会在特定情况下自动调用

2）两个常见的魔法方法
a.init
如果在类中添加了__init__方法，那么在创建当前类的对象的时候就会自动调用它;
创建对象的时候需不需要实参，需要几个实参，由类中的__init__决定

b.repr
如果类中添加了__repr__方法，打印类的对象的时候会自动调用这个方法，并且将这个方法对应返回作为打印结果进行打印。
在类中添加__repr__方法的时候，这个方法的返回值必须是字符串。

class A:
    def __init__(self):
        print('init方法被调用')


a1 = A()     # init方法被调用
a2 = A()     # init方法被调用


class B:
    def __init__(self, m, n):
        print(f'm:m, n:n')

    def __repr__(self):
        return '<B的对象>'


b1 = B(10, 20)          # m:10, n:20
B(m=100, n=200)    # m:100, n:200
print(b1)               # <B的对象>

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

    def __repr__(self):
        return

stu1 = Student('小明')
stu2 = Student('小花', 19, '女')

五、属性

属性 —— 定义在类中的变量

类中的属性分为：类属性、对象属性

1）类属性
a.怎么定义:直接在类中定义的变量就是类属性
b.怎么使用:以'类名.xxx'的方式使用
c.什么时候用:如果属性值不会因为对象不同而不一样，就定义成类属性

2）对象属性
a.怎么定义:以'self.属性名 = 属性值'的形式定义在__init__方法中
b.怎么使用:以'对象.xxx'的方式使用
c.什么时候用:属性值会因为对象不同而不一样，就定义成对象属性

class A:
    # a、name就是类属性
    m = 10
    name = 'lisa'

    # x和n是对象属性
    def __init__(self):
        self.x = 101
        self.n = 'hello'


# 通过类使用类属性
print(A.m)
print(A.name)

# 通过对象使用对象属性
a1 = A()
print(a1.x)
print(a1.n)


class Dog:
    def __init__(self, name, breed, age=3, gender='公'):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed


dog1 = Dog('喜喜', '泰迪')
print(dog1.name)         # 喜喜



class Circle:
    pi = 3.1415926

    def __init__(self, r=0):
        self.r = r

    # 如果对象方法中需要用到对象属性，由self来提供
    def area(self):
        return Circle.pi * self.r ** 2

    def length(self):
        return 2 * Circle.pi * self.r


c1 = Circle(10)
print(c1.area())

c1.r = 20
print(c1.area())

c1.r = 25
print(c1.length())

六、继承

1.继承

继承：让子类直接拥有父类的属性和方法

子类 —— 继承者
父类 —— 被继承的类

2.继承语法

语法：
class 类名(父类1, 父类2, 父类3, ...):
    类的说明文档
    类的内容

注意：定义类的时候没有写父类，那么这个类会默认继承 object(基类)

class A:
    m = 100

    def __init__(self):
        self.n = 444

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

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

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


class B(A):
    # 添加新的类属性
    x = 'hello'

    # 添加新的对象属性
    def __init__(self):
        super().__init__()       # 调用父类的对象属性
        # super(B, self).__init__()
        self.p = 888

    # 添加新的方法
    def func11(self):
        print('对象方法2')


b1 = B()
# 使用A中的内容
print(B.m)
print(b1.n)
b1.func1()
B.func2()

# 使用B中的内容
print(B.x)
b1.func11()
print(b1.p)

day6-2面向对象


概述:


  • 面向过程：根据业务逻辑从上到下写垒代码
  • 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

  • 面向对象：对函数进行分类和封装，让开发“更快更好更强...”



注：Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程

创建类和对象

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

技术分享

  • class是关键字，表示类

  • 创建对象，类名称后加括号即可

# 创建类
class Foo:
     
    def Bar(self):
        print ‘Bar‘
 
    def Hello(self, name):
        print ‘i am %s‘ %name
 
# 根据类Foo创建对象obj
obj = Foo()
obj.Bar()            #执行Bar方法
obj.Hello(‘wupeiqi‘) #执行Hello方法　

  • 面向对象：【创建对象】【通过对象执行方法】

  • 函数编程：【执行函数】


面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

  • 将内容封装到某处

  • 从某处调用被封装的内容

第一步：将内容封装到某处

技术分享

 self 是一个形式参数，当执行 obj1 = Foo(‘wupeiqi‘, 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo(‘alex‘, 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

技术分享

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

  • 通过对象直接调用

  • 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

1
2
3
4
5
6
7
8
9
10
11
12
13
class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = Foo(‘wupeiqi‘, 18)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性





以上是关于day2023-3-24-面向对象的主要内容，如果未能解决你的问题，请参考以下文章

Python-面向对象-Day7

Python面向对象-day07

day06 - Python - 面向对象

Python基础day-16[面向对象编程(未完)]

Python之路_Day7

python15 - day07 面向对象