服务器之家

服务器之家 > 正文

Python全栈之面向对象基础

时间:2022-03-10 00:29     来源/作者:熬夜泡枸杞

1. 面向对象oop了解

?
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
31
32
33
34
35
36
37
38
39
40
# ### oop 面向对象的程序开发
# (1) 类的定义
# 1
class Car:
    pass
# 2 推荐
class Car():
    pass
# 3.
class Car(object):
    pass
    
# (2)类的实例化
class Car():
    pass
obj = Car()
print(obj)
# (3)类的基本结构
"""
类中两样东西:
    (1)成员属性
    (2)成员方法
"""
class Car():
    # 成员属性
    color = "白色"
    # 成员方法
    def didi():
        print("小车会嚓嚓的叫")
 
# 语法上不报错,但是严禁使用,破坏了类中的结构,不要裸露的把判断和循环直接写在类中,而是用方法包起来
class Car():
    if 5 ==5 :
        print(11223344)
# (4)类的命名
"""类的命名 : 推荐使用大驼峰命名法,每个单词的首字母都要大写"""
"""
mycar => MyCar
zhangbaozhang => ZhangBaoZhang
"""

2. 对象的相关操作

?
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# ### 面向对象的封装 - 对象的操作
"""
封装:
    1.私有 : 在类内可以互相访问,在类外不能访问
    2.公有 : 在类内或者类外都可以访问
类中成员:
    1.成员属性
    2.成员方法
绑定方法:
    1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
    2.绑定到类   : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法
使用方式:
    对象.成员属性
    对象.成员方法
"""
class MyCar():
    # 公有属性
    logo = "布加迪威龙"
    # 私有属性
    __price = "2000万"
    # 公有方法
    def run(self):
        print("百公里油耗300L,logo={} , price={}".format(self.logo, self.__price))
    # 私有方法
    def __info(self):
        print("车主信息保密,据说是某个房地产大佬的儿子")
# 实例化对象(类的实例化)
obj = MyCar()
# (1)实例化的对象访问成员属性和方法
# 公有
print(obj.logo)
obj.run()
# 私有 (私有成员无法在类外访问,类内可以)
# obj.__price error
# obj.run()
# obj.__info() error
 
#(2)实例化的对象动态添加公有成员属性
obj.color = "尿黄色"
obj.logo = "五菱宏光"
print(obj.color)
print(obj.logo)
# __dict__ 获取类对象的内部成员
print(obj.__dict__)
print(MyCar.__dict__)
#(3)实例化的对象动态添加公有成员方法
# 1.无参方法
def dahuangfeng():
    print("请加我大黄蜂")
obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()
# 2.有参方法
# 基本版
def qingtianzhu(name):
    print("请叫我一柱擎天么,{}".format(name))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
# 升级版
def qingtianzhu(obj,name):
    print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")
# 究极版
"""如果要创建绑定方法,参数的顺序,self对象本身要放到第一位."""
def qingtianzhu(obj,name):
    print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))
import types
# 创建绑定方法,系统自动把该对象当成参数传递给方法;
# types.MethodType(方法,对象) => 绑定方法  
res = types.MethodType(qingtianzhu,obj)
print(res)
obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")
# 3.lambda表达式
obj.weizhentian = lambda : print("我是威震天")
obj.weizhentian()

小提示:

?
1
2
类对象在调用方法,如果方法是类外的(自定义的方法),那么不会自动传参的(不会把类对象传到方法里面)
self是用来接收对象这参数(self只是一个名字而已,无所谓,习惯用self)

Python全栈之面向对象基础

3. 类的相关操作

?
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# ### 面向对象的封装 - 类的操作
"""
使用方式:
    类.成员属性
    类.成员方法
"""
class MyCar():
    # 公有成员属性
    platenum = "京A7758BB"
    # 私有成员属性
    __earning = "月收入6000"
    # 公有成员方法
    def car_info():
        print("牌照信息可以公开")
        print("<======>")
        MyCar.__money_info()
    # 私有成员方法
    def __money_info():
        print( "收入信息保密" , MyCar.__earning )
 
# (1)定义的类访问公有成员属性和方法
print(MyCar.platenum)
MyCar.car_info()
# MyCar.__money_info() error
# (2)定义的类动态添加公有成员属性
MyCar.oil = "1000L"
print(MyCar.oil)
print(MyCar.__dict__)
# (3)定义的类动态添加公有成员方法
# 1.无参方法
def car_light():
    print("我是造车灯的方法")
MyCar.car_light = car_light
MyCar.car_light()
# 2.有参方法
def car_engine(name):
    print("我是造{}发动机的方法".format(name))
MyCar.car_engine = car_engine
MyCar.car_engine("三缸发动机")
# 3.lambda表达式
MyCar.luntai = lambda : print("我是造轮胎的方法")
MyCar.luntai()
 
# 对比 对象和类之间的不同
"""
1.类中的无参方法默认只能类来调用,对象无法调取
2.对象可以调用类中的成员,反过来,类不能调用对象中的成员
3.每创建一个对象都会在内存中占用一份空间,对象之间是彼此独立的;
"""
obj = MyCar()
# obj.car_info() error
MyCar.car_info()
 
obj.price = "10万"
print(MyCar.price)

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# ### 1.如何在类外访问私有成员
class Plane():
    # 公有成员
    captian = "赵沈阳"
    # 私有成员
    __air_sister = "3名空姐"
    # 公有绑定方法
    def fly(self):
        print("飞机要非要平流层,才能减少震动",self.__air_sister)
    # 私有绑定方法
    def __age(self):
        print("空姐年龄保密")
    # 公有无参方法
    def fly2():
        print("航天飞机飞到天空层,翱翔太空")
    # 私有无参方法
    def __earn():
        print("机长的收入保密")
    def pub_get1(self):
        print(self.__air_sister)
        self.__age()
    def pub_get2():
        print(Plane.__air_sister)
        Plane.__earn()
# 实例化对象
obj = Plane()
# 方法一.访问私有成员 (不推荐)
# python私有化: 采取了改名策略 =>  _类名 + __air_sister
# print(obj.__air_sister)
print(obj._Plane__air_sister)
print(Plane.__dict__)
"""
{'__module__': '__main__', 'captian': '赵沈阳',
'_Plane__air_sister': '3名空姐',
'fly': <function Plane.fly at 0x7f2774616158>, '_Plane__age': <function Plane.__age at 0x7f27746161e0>, 'fly2': <function Plane.fly2 at 0x7f2774616268>, '_Plane__earn': <function Plane.__earn at 0x7f27746162f0>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
"""
# 方法二.访问私有成员 (使用类中的公有方法,间接访问私有成员) (推荐)
obj = Plane()
obj.pub_get1()
Plane.pub_get2()
# ### 2.使用类对象删除相应的成员
"""
1.对象可以访问类中的公有成员,但是无权修改或者删除该类中的成员
2.对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的,类如果也没有直接报错;
"""
# 删除对象成员属性
obj.captian = "赵世超"
del obj.captian
print(obj.captian)
# 删除对象成员方法
obj.basketball = lambda : print("我的私人飞机可以在天上打篮球")
print(obj.__dict__)
obj.basketball()
del obj.basketball
print(obj.__dict__)
# obj.basketball() error
# 删除类中成员属性
del Plane.captian
print(Plane.__dict__)
# Plane.captian
# print(obj.captian) error
# 删除类中成员方法
del Plane.fly2
# Plane.fly2() error
# 注意: 对象无法调无参方法!! 返回来,类可以调用对象的绑定方法么? 可以!!
Plane.fly(obj)

小提示:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
如果在类外添加公有方法
def  __abc():
    print(1)
 在类外定义的方法__abc()只是简单的函数名字而已,之后在类里面定义
的时候,__abc()才是私有方法。
删除或创建私有的方法,要在类外去操作
对象在调用属性的时候,先看自己有没有,然后在看类中的属性
class Plane():
    def fly1(self):
        print("飞机要起飞")
   def fly2(self):
       print("飞机真的要起飞了"self.captian)
   def fly3():
        print("飞机不起飞")
Plane.fly1(1) 类可以调用有参的方法,随便穿个值进去即可
Plane.fly2(1) 这样的话就报错,Plane.fly2(obj) 把对象传进去就可以出结果
如果说对象调用类中无参的方法是不会成功的

5. 小练习

?
1
2
3
4
5
6
7
8
9
10
11
12
1.请定义一个交通工具(Vehicle)的类,其中有:
属性:速度(公有speed), 车的类型(私有type)
方法:速度(公有setSpeed),加速(私有speedUp),减速(私有speedDown)
让公有setSpeed调用私有speedUp和私有speedDown
2.用类改写:猜数字游戏:
一个类有两个成员num和guess,
num有一个初值100。
定义一个方法guess,
调用guess,如果大了则提示大了,小了则提示小了。等于则提示猜测成功。
3.创建一个圆Circle类。
为该类提供一个变量r表示半径
方法一返回圆的面积,方法二返回圆的周长;

小提示:

?
1
2
3
如果在类内的话,都是用对象调用方法或变量(self.speed、self.eat()),如果不是类的话,可以直接调变量和方法
r = 3 归属于circle这个类
self.r = r 归属于self这个对象

答案:

?
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
"""
1.请定义一个交通工具(Vehicle)的类,其中有:
属性:速度(公有speed), 车的类型(私有type)
方法:速度(公有setSpeed),加速(私有speedUp),减速(私有speedDown)
让公有setSpeed调用私有speedUp和私有speedDown
"""
class Vehicle():
    speed = "百公里1小时"
    __type = "拖拉机小蹦蹦"
    def setSpeed(self):
        self.__speedUp()
        self.__speedDown()
    def __speedUp(self):
        print("我是加速方法,速度{}".format(self.speed))
    def __speedDown(self):
        print("我是减速方法,小车的类型是{}".format(Vehicle.__type))
obj = Vehicle()
obj.setSpeed()
"""
2.用类改写:猜数字游戏:
一个类有两个成员num和guess,
num有一个初值100。
定义一个方法guess,
调用guess,如果大了则提示大了,小了则提示小了。等于则提示猜测成功。
"""
import re
class GuessGame():
    num = 100
    def guess(self):
        while True:
            n = input("请输入要猜测的数字")
            obj = re.search(r"^\d+$",n)
            # print(obj)
            if obj:
                n = int(obj.group())
                if n > self.num:
                    print("大了..")
                elif n < self.num:
                    print("小了..")
                elif n == self.num:
                    print("ok~ bingo")
                    break
            else:
                print("输入的内容不正确")
# obj = GuessGame()
# obj.guess()
"""
3.创建一个圆Circle类。
为该类提供一个变量r表示半径
方法一返回圆的面积,方法二返回圆的周长;
"""
import math
class Circle():
    r = 3
    def area(self):
        return math.pi * self.r ** 2
    def perimeter(self):
        return 2 * math.pi * self.r
obj = Circle()
res1 = obj.area()
res2 = obj.perimeter()
print(res1,res2)
# 方法二 (推荐)
import math
class Circle():
    def __init__(self,r):
        self.r =
    def area(self):
        return math.pi * self.r ** 2
    def perimeter(self):
        return 2 * math.pi * self.r
obj = Circle(4)
res1 = obj.area()
res2 = obj.perimeter()
print(res1,res2)

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注服务器之家的更多内容!

原文链接:https://blog.csdn.net/weixin_46818279/article/details/121368048

标签:

相关文章

热门资讯

2022年最旺的微信头像大全 微信头像2022年最新版图片
2022年最旺的微信头像大全 微信头像2022年最新版图片 2022-01-10
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整 2021-08-24
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
返回顶部