面向对象进阶

编程思想:面向过程编程,函数式编程,面向对象编程

1
函数式编程
1
2
3
4
5
6
7
def jiecheng(k:int):
cheng = 1
for item in range(1,k+1):
cheng *= item
return cheng

print(jiecheng(10))

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

1
2
类:拥有相同功能和相同属性的对象的集合
对象:对象是类的实例

2.创建类和创建对象

1
创建类: - 就是用代码描述清楚这个类是拥有哪些相同功能(函数)和属性(变量)的对象的集合
1
2
3
4
5
6
7
8
9
10
11
12
13
1)语法:
class 类名:
类的说明文档
类的内容

类名-见名知意,标识符,驼峰式命名,首字母大写,不使用系统的函数名,类名,模块名
类的内容 - 包含属性和方法
属性:类属性(类的字段),对象属性
方法:对象方法,类方法,静态方法

2)创建对象
语法:类名()

1
2
3
4
5
6
7
8
9
10
### 创建类
class Person:
# 属性
# 方法
def eat(self):
print("干饭")


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

1.对象方法

1
2
3
4
5
6
7
1)怎么定义
直接定义在类中的函数 - 对象方法
2)怎么调用
通过"对象."的形式来调用
3)特点
有默认参数self,这个参数在函数调用时不需要传参,系统会自动将当前对象传给self(谁调用就指向谁)

1
2
3
4
5
6
7
8
9
10
11
12
class Student:
def study(self):
print(f'self:{self}')
print("学习") # study是一个对象方法

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

stu1 = Student() # stu1是一个对象
stu1.study() #调用对象方法
print(f'stu1:{stu1}')
stu1.eat("牛肉") # 调用对象方法

1. __init__方法 - 初始化方法

1
2
3
4
5
6
7
8
9
10
11
1)构造方法:函数名和类名相同,用来创建对象的函数就是构造函数-构造方法
python的构造函数,在创建类的时候系统会自动创建这个类的构造函数

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

补充:方法名前后都有两个下划线的方法又叫魔法方法,这类方法在特定情况下被自动调用,不需要程序员主动调用
1
2
3
4
5
class Dog:
def __init__(self):
print("初始化方法") # 通过类创建对象的时候自动调用

p1 = Dog()

1.属性

1
2
3
4
5
6
7
8
9
10
11
12
13
1)类属性
a.怎么定义:直接定义在类中的变量
b.怎么使用:通过"类.变量名"的方式来使用
c.什么时候用:属性值不会因为对象不同而不一样



2)对象属性
a.怎么定义:
"self.属性名 = 值" 的形式定义在__init__方法中
b.怎么使用
"对象."的方式来使用
c.什么时候用
1
2
3
4
5
6
7
8
9
10
11
12
class Circle:
pi = 3.1415926 # pi就是一个类属性

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

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

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

2.对象属性的初始值

1
2
3
4
5
6
7
8
9
10
11
12
13
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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Circle:
pi = 3.1415926 # pi就是一个类属性

def __init__(self,radius):
self.radius = radius #radius就是一个对象属性

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

def perimeter(self):
return Circle.pi * self.radius * 2

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

print(c1.area())
print(c2.area())

print(c1.perimeter())
print(c2.perimeter())

方法 - 定义在类中的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1.对象方法
a.怎么定义 - 直接定义在类中
b.怎么调用 - 对象.
c.特点 - 有个默认参数self,self不用传参,谁调用self就指向谁
d.什么时候用 - 如果实现函数的功能需要用到对象属性,就定义成对象方法

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

3.静态方法
a.怎么定义 - 定义函数前加装饰器 @staticmethod
b.怎么调用 - 类.
c.特点 - 没有默认参数
d.什么时候用 - 在不需要对象属性的前提下,也不需要类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A:

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

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

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

a = A()
a.func1()

print(f'A:{A}')
A.func2()

A.func3()

作业

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Dog:

def __init__(self,name,sex,variety):
self.name = name
self.sex = sex
self.variety = variety

@classmethod
def cry_out(cls):
print("叫唤")


dog1 = Dog('小白','母狗','阿拉斯加')
print(dog1.name,dog1.sex,dog1.variety)
Dog.cry_out()

class Person:

def __init__(self, name, age, dog):
self.name = name
self.age = age
self.dog = dog

@classmethod
def walk_the_dog(self):
print("遛狗")

p1 = Person("小明",'18','小白')
print(p1.name,p1.age,p1.dog)
Person.walk_the_dog()

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Rectangle:
def __init__(self,length,width):
self.length = length
self.width = width

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

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

r1 = Rectangle(2,3)

print(f'r1的面积是{r1.area()}周长是{r1.perimeter()}')

3. 定义一个二维点类,拥有属性:x坐标、y坐标 拥有方法:求当前点到另外一个点的距离

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
"""方法1"""
class TwoDimensionalPoint:
def __init__(self,x,y):
self.x = x
self.y = y

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

P1 = TwoDimensionalPoint(0,0)

print(P1.distance(1,2))

"""方法2"""
class TwoDimensionalPoint:
def __init__(self,x,y):
self.x = x
self.y = y

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

P1 = TwoDimensionalPoint(0,0)
P2 = TwoDimensionalPoint(1,2)
print(P1.distance(P2))

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Circle:
pi = 3.14
def __init__(self,radius,center=None):
self.radius = radius
self.center = center


def area(self):
return Circle.pi * self.radius ** 2

def perimeter(self):
return Circle.pi * self.radius * 2

def external(self,other):
P = ((self.center[0] - other.center[0])**2 + (self.center[1] - other.center[1])**2) ** 0.5
if P == self.radius + other.radius:
return '是外切'
else:
return "不是外切"

C1 = Circle(3)
print(f'圆C1的面积是{C1.area()}周长是{C1.perimeter()}')

C1 = Circle(3,(1,2))
C2 = Circle(6,(5,6))

print(C1.external(C2))

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

1
2
3
4
5
6
7
8
9
10
11
class Segment:
def __init__(self,begin,end):
self.begin = begin
self.end = end

def length(self):
return ((self.begin[0] - self.end[0])**2 + (self.begin[1] - self.end[1])**2) ** 0.5

S1 = Segment((0,0),(3,4))

print(S1.length())