面向对象一

7-02 788 views

一、面向对象设计

面向对象设计(Object oriented design):将一类事物的数据和动作整合到一起,即面向对象设计

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def school(name,addr,type):
    def init(name, addr, type):
        sch = {
            'name': name,
            'addr': addr,
            'type': type,
            'test': test,
            'recruit': recruit,
        }
        return sch
    def test(school):
        print('%s 学校正在考试' %school['name'])
    def recruit(school):
        print('%s %s 正在招生' %(school['type'],school['name']))
    return  init(name,addr,type)
 
s1=school('清华大学','北京','公立学校')
print(s1)
#{'recruit': <function school.<locals>.recruit at 0x000001BB3023E400>, 'test': <function school.<locals>.test at 0x000001BB3023E378>, 'name': '清华大学', 'type': '公立学校', 'addr': '北京'}
print(s1['name'])  #清华大学
s1['recruit'](s1)  #公立学校 清华大学 正在招生
 
s2=school('北大','北京','公立学校')
print(s2)
print(s2['name'],s2['addr'],s2['type'])  #北大 北京 公立学校
s2['recruit'](s2)  #公立学校 北大 正在招生

二、面向对象编程

用面向对象编程独有的语法class去实现面向对象设计

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type
 
    def bark(self):
        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))
 
    def eat(self):
        print('[%s]正在吃骨头' %(self.name))
 
    def sleep(self):
        print('[%s]正在睡觉' %(self.type))
 
dog1=Dog('小黑','female','京巴')
print(dog1.__dict__)   #{'name': '小黑', 'type': '京巴', 'gender': 'female'}
 
dog1.bark()
dog1.eat()
dog1.sleep()

三、类

对象是具体的存在,而类仅仅只是一个概念,并不真实存在,在程序中,务必保证先定义类,后产生对象

类:把一类事物的相同的特征和动作整合到一起就是类,类是一个抽象的概念

对象:基于类二创建的一个具体的事物(具体存在的),也是特征和动作整合到一起

实例化:有类生产对象的过程叫实例化,类实例化的结果就是一个对象(实例=对象)

3.1、类的声明

01
02
03
04
05
06
07
08
09
10
11
12
'''
class ClassName:
    '类的文档注释'
    类体
'''
 
#创建有一个类
class Data:
    pass
 
#实例化
d1=Data()

3.2、经典类和新式类

01
02
03
04
05
06
07
08
09
#经典类
class 类名:
    pass
 
#新式类
class 类名(父类):
    pass
 
#注意:在python2中存在经典类和新式类,但在python3中只有新式类

3.3、类的属性

类的属性分为:

  • 数据属性:变量
  • 函数属性:函数,在面向对象中称为方法
  • 类和对象均用点来访问自己的属性
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Dog:
    '这是一个狗的类'
    feature='哺乳动物'
    def eat():
        print('吃骨头')
    def sleep(self):
        print('sleeping')
#
print(Dog.feature)  #哺乳动物
Dog.eat()   #吃骨头
Dog.sleep("小黑"#sleeping
 
print(dir(Dog))  #打印key值
#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'eat', 'feature', 'sleep']
 
print(Dog.__dict__) #查看属性字典,打印键值对
#{'eat': <function Dog.eat at 0x00000183C602E158>, '__dict__': <attribute '__dict__' of 'Dog' objects>, 'sleep': <function Dog.sleep at 0x00000183C602E378>, '__module__': '__main__', 'feature': '哺乳动物', '__weakref__': <attribute '__weakref__' of 'Dog' objects>, '__doc__': '这是一个狗的类'}
 
print(Dog.__dict__['feature'])  #哺乳动物
Dog.__dict__['eat']()  #吃骨头
Dog.__dict__['sleep'](1#sleeping
 
print(Dog.__name__)  #Dog
print(Dog.__doc__)   #这是一个狗的类
print(Dog.__module__)  #__main__

查看类的属性有两种方法:

  • dir(类名):查出来的是一个名字列表
  • 类名.__dict__:查出来的是一个字典,key为属性名,value是属性值

特殊的属性:

01
02
03
04
05
06
07
print(Dog.__name__)  #Dog ==>类的名字(字符串)
print(Dog.__doc__)   #这是一个狗的类  ==>文档字符串
print(Dog.__module__)  #__main__  ==>类定义所在的模块
print(Dog.__base__)   #<class 'object'>  ==>类的第一个父类
print(Dog.__bases__)  #(<class 'object'>,) ==>类的所有类构成的元祖
print(Dog.__dict__)   #{'__doc__': '这是一个狗的类', 'sleep': <function Dog.sleep at 0x000001CC7319E378>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, 'eat': <function Dog.eat at 0x000001CC7319E158>, '__module__': '__main__', 'feature': '哺乳动物'}
print(Dog.__class__)  #<class 'type'>  ==>实例对应的类(仅新式类)

3.4、类属性的增删改查

01
02
03
04
05
06
07
08
09
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
class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name))
 
#查看
print(Chinese.country)  #China
 
#修改
Chinese.country='AAA'
print(Chinese.country)  #AAA
 
p1=Chinese('abc')
print(p1.__dict__)  #{'name': 'abc'}
print(p1.country)   #AAA
 
#增加
Chinese.location = "Asia"
print(Chinese.location)  #Asia
print(p1.location)      #Asia
 
#删除
del Chinese.location
del Chinese.country
 
print(Chinese.__dict__)
# print(Chinese.country)  #AttributeError: type object 'Chinese' has no attribute 'country'
 
def eat(self,food):
    print('%s 正在吃%s' %(self.name,food))
 
#增加函数方法
Chinese.eat=eat
 
print(Chinese.__dict__)
p1.eat('美食'#abc 正在吃美食
 
def test(self):
    print('test')
 
Chinese.play_ball=test
p1.play_ball()   #test  ==>相当于 Chinese.play_ball(p1)

四、实例

对象是由类实例化来的。类实例化的结果称之为一个实例或一个对象

4.1、实例化

01
02
03
04
05
06
07
08
09
10
class Dog:
    '这是一个狗的类'
    feature='哺乳动物'
    def eat(self):
        print('吃骨头')
    def sleep(self):
        print('sleeping')
 
dog1 = Dog() #类名() ==>实例化
print(dog1)  #<__main__.Dog object at 0x00000227ABEC5C50>

4.2、构造方法

使用类的内置方法__init__方法,在类()实例化时会自动执行,为实例定制数据属性

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Dog:
 
    feature='哺乳动物'
    def __init__(self,name,age,gender): #实例化可以简单理解为执行该函数的过程,实例本身会当做参数传给self
        self.name = name
        self.age = age
        self.gender = gender
 
    def eat(self):
        print('吃骨头')
    def sleep(self):
        print('sleeping')
 
dog1 = Dog("黑",10,"female"#==>相当于Dog.__init__(self,name,age,gender)
print(dog1)  #<__main__.Dog object at 0x0000019EC86043C8>
print(dog1.__dict__)  #{'name': '黑', 'age': 10, 'gender': 'female'} ==>只有数据属性
print(Dog.__dict__)  #函数属性只存在类中
#{'__weakref__': <attribute '__weakref__' of 'Dog' objects>, 'feature': '哺乳动物', '__init__': <function Dog.__init__ at 0x000001DA9FA3E378>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__module__': '__main__', '__doc__': None, 'sleep': <function Dog.sleep at 0x000001DA9FA3E488>, 'eat': <function Dog.eat at 0x000001DA9FA3E400>}
 
print(dog1.age)  #10
# print(dog1.eat(dog1))  #TypeError: eat() takes 1 positional argument but 2 were given
 
#只能通过类取调用类的函数属性,然后把实例当做变量传给self
Dog.eat(dog1)  #吃骨头

4.3、查看实例属性

01
02
print(dir(dog1))
print(dog1.__dict__)  #{'name': '黑', 'age': 10, 'gender': 'female'} ==>只有数据属性

4.4、特殊实例属性

类和对象虽然调用__dict__返回的是一个字典结构,但是不要直接修改字典,会导致oop不稳定

01
02
03
04
dog1 = Dog("黑",10,"female")
print(dog1.__class__)  #<class '__main__.Dog'>
print(dog1.__dict__)   #{'gender': 'female', 'name': '黑', 'age': 10}
print(dog1.__dict__["gender"])  #female

4.5、实例属性增删改查

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.__dict__)   #{'name': 'alex'}
 
#查看
print(p1.name)  #alex
print(p1.play_ball)  #<bound method Chinese.play_ball of <__main__.Chinese object at 0x00000246ADEE5C18>>
 
#增加
p1.age=18
print(p1.__dict__)  #{'age': 18, 'name': 'alex'}
print(p1.age)   #18
#
#不要修改底层的属性字典
# p1.__dict__['sex']='male'
# print(p1.__dict__)
# print(p1.sex)
 
# #修改
p1.age=19
print(p1.__dict__)  #{'age': 19, 'name': 'alex'}
print(p1.age)
#
#删除
del p1.age
print(p1.__dict__)  #{'name': 'alex'}

4.6、类与实例属性注意事项

01
02
03
04
05
06
07
08
09
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
77
78
#实例一
class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
 
p1=Chinese('AA')
print(p1.country)  #China
p1.country='日本'
print('类:',Chinese.country)  #类: China
print('实例:',p1.country)     #实例: 日本
 
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++
#实例二
country='中国'
class Chinese:
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('AAA')
print(p1.country)  #AttributeError: 'Chinese' object has no attribute 'country'
#类中没有country属性
 
#++++++++++++++++++++++++++++++++++++++++++++++++++++++
#实例三
country='大中国'
class Chinese:
    # country='中国'  #当类中没有时会报错
    def __init__(self,name):
        self.name=name
        print('--->',country)
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
 
print(Chinese.__dict__)
# print(Chinese.country)  #AttributeError: type object 'Chinese' has no attribute 'country'
p1=Chinese('alex')
# print('实例--------》',p1.country)  #AttributeError: 'Chinese' object has no attribute 'country'
 
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#实例四
class Chinese:
    country='China'
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
 
print(p1.country)  #China
p1.country='Japan' #修改的是实例的属性
print(Chinese.country) #China
 
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#实例五
class Chinese:
    country='China'
    l=['a','b']
    def __init__(self,name):
        self.name=name
 
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))
p1=Chinese('alex')
print(p1.l)  #['a', 'b']
# p1.l=[1,2,3]
# print(Chinese.l)
# print(p1.__dict__)
p1.l.append('c'#通过append方式修改的是类的属性
print(p1.__dict__)  #{'name': 'alex'}
print(Chinese.l)    #['a', 'b', 'c']

新手练习Python项目

转载:https://zhuanlan.zhihu.com/p/22164270   学习编程专栏连载编程新手练手项目系列之python项目篇,同样也欢迎热爱学习、对Java感兴趣的朋友学习翻...

阅读全文

Python项目汇总

今天给大家带来一批宝贝,大家可以在深夜里独自把玩,也可以在广场上一边遛狗一边和盆友们品鉴。 转载:https://juejin.im/post/6844903524514398215 ##学...

阅读全文

面向对象实战

一 引子 学完了面向对象的基础知识后,很明显你还是不知该如何下手,凡是都得有个章法 此刻有经验的人可能会想到瀑布模型、螺旋模型、迭代开发、敏捷、RUP等...

阅读全文

评论已经关闭。