本文深入探讨了面向对象编程的思想，包括面向过程、函数式和面向对象的区别。通过实例展示了如何使用Python实现阶乘计算，同时讲解了类和对象的概念，以及创建和使用类与对象的方法。接着，介绍了初始化方法`__init__`、属性（类属性和对象属性）以及方法（对象方法、类方法和静态方法）。最后，通过具体的类定义，如狗、人、矩形、二维点和圆等，阐述了属性和方法的实践应用。
面向对象编程
编程思想
编程思想：面向过程编程(穷人思想)、函数式编程(小资)、面向对象编程(富豪)
# 编程实现功能：1*2*3*..*10
# 面向过程编程:
s = 1
for x in range(1, 11):
s *= x
print(s)
# 函数式编程编程:
from math import factorial
print(factorial(10))
print(factorial(5))
class Math:
@staticmethod
def factorial(num: int):
s = 1
for x in range(1, num+1):
s *= x
return s
@staticmethod
def cube(num):
return num ** 3
print(Math.factorial(10))
类和对象
什么是类、什么是对象
"""
什么类：拥有相同功能相同属性的对象的集合 （抽象的概念）
什么对象：对象是类的实例（具体的事物）
从生活的角度理解类和对象：
人是类，余婷就是对象、骆昊是另外一个对象
杯子是类，我桌上这个杯子就是对象
"""
创建类和创建对象
"""
1）创建类 - 就是用代码描述清楚这个类是拥有哪些相同功能(函数)和哪些相同属性(变量)的对象的集合
语法：
class 类名:
类的说明文档
类的内容
说明：
class - 关键字；固定写法
类名 - 程序员自己命名；
要求：标识符、不是关键字
规范：见名知义；驼峰式命名，并且第一个字母大写；不使用系统的函数名、类名、模块名
: - 固定写法
类的说明文档 - 多行注释
类的内容 - 包含属性和方法
属性：类属性(类的字段)、对象属性
方法：对象方法、类方法、静态方法
注：方法是定义在类中的函数
2) 创建对象
语法：
类名()
"""
创建类
class Person:
"""类的说明文档"""
# 属性
# 方法
pass
创建对象
p1 = Person()
print(p1)
p2 = Person()
print(p2)
对象方法
什么是对象
"""
1）怎么定义:
直接定义在类中函数就是对象方法
2）怎么调用: 通过 '对象.' 的形式来调用
3）特点:
有默认参数self，这个参数在调用的时候不用传参，系统会自动将当前对象传给self。（谁调用就指向谁）
"""
class Student:
# study是一个对象方法
def study(self):
print(f'self:{self}')
print('学习')
def eat(self, food):
print(f'吃{food}')
stu1 = Student()
stu2 = Student()
print(f'stu1:{stu1}')
print(f'stu2:{stu2}')
stu2.study()
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. 属性 - 定义在类中的变量
"""
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)
c1 = Circle()
# 使用对象属性
print(c1.radius)
# 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())
print(c2.area())
方法 定义在类中的函数
"""
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()
print(f'A:{A}')
A.func2()
A.func3()
-
定义一个狗类和一个人类：
狗拥有属性：姓名、性别和品种 拥有方法：叫唤
人类拥有属性：姓名、年龄、狗 拥有方法：遛狗
class Dog: def __init__(self, name, gender, breed): self.name = name self.gender = gender self.breed = breed def dog_squawks(self): print(f'小狗{self.name}') class Person: def __init__(self, name, age, dog): self.name = name self.age = age self.dog = dog #方法 - 遛狗 def Walk_dog(self): print(f'{self.name}在遛TA的狗{self.dog}') dog = Dog('阿呆','公',2) dog.dog_squawks() person = Person('铁蛋', 18, dog.name) person.Walk_dog() -
定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积
class Rectangles: def __init__(self, loog, width): self.loog = loog self.width = width def perimter(self): return (self.loog + self.width) * 2 def area(self): return self.loog * self.width rectangle = Rectangles(100, 5) #长8宽5的长方形 print(f'长为{rectangle.loog}宽为{rectangle.width}的长方形的周长为:{rectangle.perimter()}') print(f'长为{rectangle.loog}宽为{rectangle.width}的长方形的周长为:{rectangle.area()}') -
定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离
import math import re class Point: def __init__(self, **point): self.x1 = point['x1'] self.y1 = point['y1'] self.x2 = point['x2'] self.y2 = point['y2'] def distance(self): return math.sqrt(math.pow((int(self.x1) - int(self.x2)), 2) + math.pow((int(self.y1) - int(self.y2)), 2)) point = Point(x1=0, y1=0, x2=1, y2=1) print(f'点{(point.x1,point.y1)}到点{(point.x2,point.y2)}的距离为{point.distance()}') result = re.findall(r"\d{1,}?\.\d{2}", str(point.distance())) print(f'距离为：', result) -
定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切
import math import re class Circle: pi = 3.1415926 def __init__(self, *center, radius): self.radius = radius self.x = center[0] self.y = center[1] # 周长 def perimeter(self): return 2 * Circle.pi * self.radius # 面积 def area(self): return Circle.pi * self.radius ** 2 # 判断是否内切 def cut_inside(self, x, y, r): dis = math.sqrt((x - int(self.x)) ** 2 + (y - int(self.y)) ** 2) if (dis == abs(float(r - self.radius))): print(f'圆心为{(self.x, self.y)}半径为{self.radius}的圆与圆心为{(x, y)}半径为{r}的圆内切！') else: print(f'圆心为{(self.x, self.y)}半径为{self.radius}的圆与圆心为{(x, y)}半径为{r}的圆不内切！') circle = Circle(0, 0, radius=5) result = re.findall(r"\d{1,}?\.\d{2}", str(circle.perimeter())) print(f'半径为{circle.radius}的圆的周长为:', result) result = re.findall(r"\d{1,}?\.\d{2}", str(circle.area())) print(f'半径为{circle.radius}的圆的面积为:', result) circle.cut_inside(2, 0, 3) -
定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度
class LineSegment: def __init__(self, start_point, end_point): self.start_point = start_point self.end_point = end_point # 方法 def length(self): return self.end_point - self.start_point linesegment = LineSegment(11, 99) print(f'起点为{linesegment.start_point}终点为{linesegment.end_point}的线段长度为{line_segment.length()}')
扫一扫
305
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
