面向对象基础

编程思想

# 编程思想：面向过程编程(穷人思想)、函数式编程(小资)、面向对象编程(富豪)

# 编程实现功能：1*2*3*..*10
# 面向过程编程:
s = 1
for x in range(1, 11):
    s *= x
print(s)

# 函数式编程编程:
from math import factorial
print(factorial(10))


class Math:
    @staticmethod
    def factorial(num: int):
        s = 1
        for x in range(1, num+1):
            s *= x
        return s

 
print(Math.factorial(10))

类和对象

# 1. 什么是类、什么是对象
"""
什么类：拥有相同功能相同属性的对象的集合（抽象的概念）
什么对象：对象是类的实例（具体的事物）
"""
# 2. 创建类和创建对象
"""
1）创建类  -  就是用代码描述清楚这个类是拥有哪些相同功能(函数)和哪些相同属性(变量)的对象的集合
语法：
class 类名:
    类的说明文档
    类的内容
    
说明：
class   -   关键字；固定写法
类名     -   程序员自己命名；
            要求：标识符、不是关键字
            规范：见名知义；驼峰式命名，并且第一个字母大写；不使用系统的函数名、类名、模块名
:       -   固定写法
类的说明文档  -   多行注释
类的内容    -   包含属性和方法
               属性：类属性(类的字段)、对象属性
               方法：对象方法、类方法、静态方法

注：方法是定义在类中的函数


2) 创建对象
语法：
类名()
"""


# 创建类
class Person:
    """类的说明文档"""
    # 属性
    # 方法
    pass


# 创建对象
p1 = Person()
print(p1)

p2 = Person()
print(p2)

对象方法

# 1. 什么是对象方法
"""
1）怎么定义:
直接定义在类中函数就是对象方法

2）怎么调用: 通过 '对象.' 的形式来调用

3）特点:
有默认参数self，这个参数在调用的时候不用传参，系统会自动将当前对象传给self。（谁调用就指向谁）
"""


class Student:
    # study是一个对象方法
    def study(self):
        print(f'self:{self}')

    def eat(self, food):
        print(f'吃{food}')


stu1 = Student()
stu2 = Student()
print(f'stu1:{stu1}')	# stu1:<__main__.Student object at 0x0000016E26653490>
print(f'stu2:{stu2}')	# stu2:<__main__.Student object at 0x0000016E26653160>
stu2.study()			# # self:<__main__.Student object at 0x000001F7B9FE3160>
stu1.eat('米饭')		# # 吃米饭

__init__方法

# 1. __init__方法  - 初始化方法
"""
1）构造方法： 函数名和类名相同，用来创建对象的函数就是构造函数（构造方法）
python的构造函数，需要程序员自己写，创建类的时候系统会自动创建这个类的构造函数

2）初始化方法：
a. 当通过类创建对象的时候系统会自动调用__init__方法
b. 在调用调用构造函数创建对象的时候，需不需要参数需要几个参数看对应的__init__除了self以外有
   没有额外的参数，有几个额外的参数。
c. 程序员在类中添加__init_方法的时候只需要保证方法名是__init__有默认参数self就可以。
   形参和函数体可以根据情况随便添加

补充：前后都有两个下划线的方法又叫魔法方法，这类方法不需要程序员去调用，在特定情况下会被自动调用
"""


class Dog:
    def __init__(self, x=9):
        print('初始化方法')


p1 = Dog(10)
p2 = Dog(x=20)
p3 = Dog()

属性

1) 类属性
a.怎么定义: 直接定义类中的变量
b.怎么使用: 通过 '类.' 的方式来使用
c.什么时候用: 属性值不会因为对象不同而不一样


2) 对象属性
a.怎么定义：
以 'self.属性名 = 值' 的形式定义在__init__方法中

b.怎么使用：以 '对象.'的方式来使用

c.什么时候用： 
属性值会因为对象不同而不一样的时候就使用对象属性
"""


class Circle:
    # a 是类属性
    a = 10
    # pi 是类属性
    pi = 3.1415926

    # radius是对象属性
    def __init__(self):
        self.radius = 1


# 使用类属性
print(Circle.a)		# 10

c1 = Circle()
# 使用对象属性
print(c1.radius)	# 1


# 2. 对象属性的初始值
class Person:
    def __init__(self, name, gender='男'):
        self.name = name
        self.gender = gender
        self.age = 0


p1 = Person('小明')
p2 = Person('张三')
p3 = Person('小花', '女')

print(p1.name, p1.gender)	# 小明 男
print(p2.name, p2.gender)	 # 张三 男
print(p3.name, p3.gender)	# 小花 女

# 3. 在对象方法中对象属性的使用


class Circle:
    pi = 3.1415926

    def __init__(self, radius):
        self.radius = radius

    def area(self):
        # 如果在实现对象方法的功能的时候需要用到对象属性，由self来提供这个对象属性
        # return 圆周率 x 圆半径的平方
        return Circle.pi * self.radius ** 2


c1 = Circle(2)
c2 = Circle(4)

print(c1.area())	# 12.5663704
print(c2.area())	 # 50.2654816

方法

# 1. 方法     -   定义在类中的函数
"""
1）对象方法
a.怎么定义：直接定义在类中
b.怎么调用：对象.
c.特点：有个默认参数self，self不用传参，谁调用self就指向谁
d.什么时候用：如果实现函数的功能需要用到对象属性，就将定义成对象方法

2）类方方法
a.怎么定义：定义函数前加装饰 @classmethod
b.怎么调用：类.
c.特点：有个默认参数cls，调用时候不用传参，系统自动将当前类传给cls
d.什么时候用：在不需要对象属性的前提下，需要类

3）静态方法
a.怎么定义：定义函数前加装饰器 @staticmethod
b.怎么调用：类.
c.特点：没有默认参数
d.什么时候用：在不需要对象属性的前提下，也不需要类
"""


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

    @classmethod
    def func2(cls):
        print(f'cls:{cls}')
        print('类方法')
        b = cls()
        print(f'b:{b}')

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


a = A()
a.func1()	# 对象方法	# <class '__main__.A'>

print(f'A:{A}')		# A:<class '__main__.A'>
A.func2()	#  # cls:<class '__main__.A'>    # 类方法   # b:<__main__.A object at 0x000001AD96BC66A0>

A.func3()	# 静态方法

习题

# 1.定义一个狗类和一个人类：
# 狗拥有属性：姓名、性别和品种 拥有方法：叫唤
# 人类拥有属性：姓名、年龄、狗 拥有方法：遛狗


class Dog:
    def __init__(self, name, breed, gender='母狗'):
        self.name = name
        self.gender = gender
        self.breed = breed
        
    def bark(self):
        print(f'{self.name}:汪汪汪!')
 

class Person:
    def __init__(self, name, age=18):
        self.name = name
        self.age = age
        self.dog = None

    def walk_the_dog(self):
        if self.dog:
            print(f'{self.name}牵着{self.dog.name}散步！')
        else:
            print('没有狗！遛自己！')


p1 = Person('小明')
p1.dog = Dog('财财', '土狗')
p1.walk_the_dog()


# 2. 定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积
class Rect:
    def __init__(self, length=10, width=10):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return (self.length + self.width) * 2


# 3.定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance(self, other):
        return ((self.x - other.x)**2 + (self.y - other.y)**2) ** 0.5


p1 = Point()
p2 = Point(10, 0)
print(p1.distance(p2))


# 4.定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切
class Circle:
    def __init__(self, r, center=Point()):
        self.r = r
        self.center = center

    def is_exterior_contact(self, other):
        return self.center.distance(other.center) == self.r + other.r


# 5.定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度
class Line:
    def __init__(self, start=Point(), end=Point()):
        self.start = start
        self.end = end

    def length(self):
        return self.start.distance(self.end)