Python面向对象基础

Python面向对象基础

---

1. 编程思想

• 面向过程编程、函数式编程、面向对象编程

# 函数式编程：
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))

2. 类和对象

2.1 什么是类、什么是对象

• 什么类：拥有相同功能相同属性的对象的集合（抽象的概念）
• 什么是对象：对象是类的实例（对象是具体的事务）

从生活的角度理解类的对象
杯子是类，我桌上的杯子就是对象

2.2 创建类和对象

1）创建类 - 就是用代码描述清楚这个类是拥有哪些相同功能（函数）和哪些相同属性（变量）的对象的集合。

语法：

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

说明:

class - 关键字；固定写法
类名 - 程序员自己命名；
要求：标识符、不是关键字
规范：见名知意；驼峰式命名，并且第一个字母大写 # StudentName
: - 固定写法
类的说明文档 - 多行注释
类的内容 - 包含属性和方法
属性：类属性(类的字段)、对象属性
方法：对象方法、类方法、静态方法

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

# 创建类
class Person:
    """
    类的说明文档
    """
    # 属性
    # 方法
    def eat(self):
        print('吃')

2）创建对象

语法：

对象名 = 类名()

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

3. 方法

3.1 对象方法：

a. 怎么定义：直接定义在类中函数就是对象方法

b. 怎么调用：通过’对象.'的形式来调用

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

d. 什么时候用：如果实现函数功能需要用到对象属性，就将定义成对象方法

3.2 类方法：

a. 怎么定义：定义函数前加装饰 @classmethod

b. 怎么调用：类.

c. 特点:有个默认参数cls，调用的时候不用传参，系统自动将当前类传给cls

d. 什么时候用：在不需要对象属性的前提下，需要类

3.3 静态方法：

a. 怎么定义：定义函数前加装饰器 @staticmethod

b. 怎么调用：类.

c. 特点：没有默认的参数

d. 什么时候用：在不需要对象属性的前提下，也不需要类

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

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

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

a = A()
a.func1()

A.func2()

A.func3()

4. init方法

__init__方法 - 初始化方法

1）构造方法：函数名和类名相同，用来创建对象的函数

• python的构造函数，不需要程序员自己写，创建类的时候系统会自动创建这个类的构造函数

2）初始化方法：

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

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

class Dog:
    def __init__(self):
        print('初始化方法-创建对象自动调用')

        
do = Dog()

5. 属性

5.1 属性 - 定义在类中的变量

1）类属性

a.怎么定义: 直接定义变量

b.怎么使用: 通过’类.'来使用

c.什么时候用: 属性值不会因为对象不同而不一样

2）对象属性

a.怎么定义：以’self.属性名 = 值’的形式在__init__方法中

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

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

class Circle:
    # pi 是类属性
    pi = 3.1415926
    # self.radius是对象属性
    def __init__(self):
        self.radius = 2

# 使用类属性
r = Circle()
print(Circle.pi)

# 使用对象属性
print(r.radius)

5.2 对象属性的初始值

class Person():
    def __init__(self, name,gender='男'):   # 对象属性有初始值需要放在最后
        self.name = name
        self.gender = gender

        
p1 = Person('小明')
print(p1.name,p1.gender)

5.3 在对象方法中对象属性的使用

class Circle:
    pi = 3.1415926
    def __init__(self, radius):
        self.radius = radius
        
    def area(self):
        # 如果在实现对象方法的功能的时候需要用到对象属性，由self来提供这个对象属性
        return Circle.pi * self.radius ** 2
    
    def perimeter(self):
        return 2 * Circle.pi * self.radius

c1 = Circle(4)
print(c1.area())
print(c1.perimeter())

6. 面向对象实例练习

1. 定义一个狗类和一个人类：

   狗拥有属性：姓名、性别和品种 拥有方法：叫唤

   人类拥有属性：姓名、年龄、狗 拥有方法：遛狗

   class Dog:
   	def __init__(self, dog_name, breed, gender='公'):
           self.dog_name = dog_name
        	self.breed = breed
        	self.gender = gender
   
   	def cry(self):
        	print('汪汪汪')
   
   
   class Person:
    	def __init__(self, name, age):
   		self.name = name
        	self.age = age
       	self.dog = None
   
   	def walk_the_dog(self):
           if self.dog:
           	return (f'{self.name}牵着{self.dog.dog_name}')
       	else:
           	return (f'没有狗！溜自己')
   
   
   p1 = Person('张三', '27')
   p1.dog = Dog('贝拉', '边牧')
   print(p1.walk_the_dog())
   

2. 定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积

   class Orthogon:
       def __init__(self,length, width):
           self.length = length
           self.width = width
       def perimeter(self):
           return (self.length + self.width) * 2
       def area(self):
           return self.length * self.width
   
   ort = Orthogon(4, 9)
   print(f'矩形的周长为：{ort.perimeter()}')
   print(f'矩形的面积为：{ort.area()}')
   

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(4, 2)
   p2 = Point(-2,4)
   print(f'{p1.distance(p2):.2f}')
   

4. 定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切

   class Circle:
   	pi = 3.1415926
   
   	def __init__(self, radius, center=Point()):
   		self.radius = radius
   		self.center = center
   
    	def perimeter(self):
        	return Circle.pi * self.radius * 2
   
    	def area(self):
        	return (Circle.pi * self.radius) ** 2
   
    	def ex_circle(self, other):
       	 if self.radius + other.radius == self.center.distance(other.center):
           	 print('这个圆外切于本来的圆')
       	 else:
           	 print('这个圆与当前圆互不外切')
   
    cir1 = Circle(3,Point(0,0))
    print(f'圆的周长为：{cir1.perimeter():.2f}')
    print(f'圆的面积为：{cir1.area():.2f}')
    cir2 = Circle(2,Point(3,4))
    cir1.ex_circle(cir2)
   

5. 定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度

   class Line:
   	def __init__(self, begin=Point(), end=Point()):
       	self.begin = begin
        	self.end = end
   
   	def length(self):
       	return self.begin.distance(self.end)
   
   p1 = Line(Point(0,0),Point(3,4))
   print(p1.length())