码迷,mamicode.com
首页 > 其他好文 > 详细

3.1 面向对象的基本知识

时间:2018-05-29 01:46:22      阅读:165      评论:0      收藏:0      [点我收藏+]

标签:扩展性   操作   学生   tin   对象   hid   分类   lex   __init__   

一、面向过程:

       核心是过程二字,过程指的是解决问题的步骤,设计一条流水线,机械式的思维方式

优点: 复杂的问题流程化,进而简单化

缺点:扩展性差

适用场景:需求固定的情况 

技术分享图片
 1 import json
 2 import re
 3 def interactive():
 4     name=input(>>: ).strip()
 5     pwd=input(>>: ).strip()
 6     email=input(>> ).strip()
 7     return {
 8         name:name,
 9         pwd:pwd,
10         email:email
11     }
12 
13 def check(user_info):
14     is_valid=True
15 
16     if len(user_info[name]) == 0:
17         print(用户名不能为空)
18         is_valid=False
19 
20     if len(user_info[pwd]) < 6:
21         print(密码不能少于6位)
22         is_valid=False
23 
24     if not re.search(r@.*?\.com$,user_info[email]):
25         print(邮箱格式不合法)
26         is_valid=False
27 
28     return {
29         is_valid:is_valid,
30         user_info:user_info
31     }
32 
33 def register(check_info):
34     if check_info[is_valid]:
35         with open(db.json,w,encoding=utf-8) as f:
36             json.dump(check_info[user_info],f)
37 
38 
39 
40 def main():
41     user_info=interactive()
42 
43     check_info=check(user_info)
44 
45     register(check_info)
46 
47 if __name__ == __main__:
48     main()
View Code

 

二 、 面向对象

       核心就是对象二字,对象就是特征与技能的结合

      优点:可扩展性

      缺点: 编程复杂度高

      应用场景: 用户需求经常变化,互联网应用,游戏,企业内部应用(如:办公系统)

 

三、类的定义与实例化,以及类的使用

     类就是一系列对象相似的特征与技能的结合体

     强调:站在不同的角度,得到的分类是不一样的。

     在现实世界中:一定先有对象,后有类

     在程序中:一定得先定义类,后调用类来产生对象  类相当于模版

     

     类在定义的时候就调用了。

      特征:用变量定义

      技能:用函数定义 

      查看类的名称空间

     print(类名.__dict__)

   print(类名.__dict__[‘school‘])

 

      类的用法:

技术分享图片
 1 # 先定义类
 2 class LuffyStudent:
 3     # 数据属性
 4     school = luffycity
 5 
 6     # 函数属性
 7     def learn(self):
 8         print(is learning)
 9 
10     # 函数属性
11     def eat(self):
12         print(is eating)
13 
14 
15 #后产生对象
16 stu1 = LuffyStudent()
17 
18 #查看类的名称空间
19 print(LuffyStudent.__dict__)
20 print(LuffyStudent.__dict__[school])
21 
22 # 查看类的属性
23 print(LuffyStudent.school)  #等价于print(LuffyStudent.__dict__[‘school‘])
24 
25 # 增加类的属性
26 LuffyStudent.country = china
27 #print(LuffyStudent.__dict__)
28 print(LuffyStudent.country)
29 
30 # 删除类的属性
31 del LuffyStudent.country
32 
33 # 改类的属性
34 LuffyStudent.school = Luffycity
View Code

     总结:

     1. () 的作用

     函数() : 执行函数体的代码

     类(): 是实例化产生对象,在定义类的时候就已经执行了类体的代码

     2. 类的作用

      1) 对属性的操作,增删改查

      2) 实例化产生一个个的对象

 

四、对象

       (一)__init__

      __init__方法为对象定制对象自己独有的特征  

      加上__init__方法后,实例化的步骤:

      1. 先产生一个空对象

      2. 自动触发__init__方法 ,第一参数self是对象自己,不需要传

技术分享图片
 1 class LuffyStudent:
 2     school=luffycity
 3 
 4     #            stu1, ‘王二丫‘, ‘女‘, 18
 5     def __init__(self,name,sex,age):
 6         self.Name=name
 7         self.Sex=sex
 8         self.Age=age
 9 
10         #stu1.Name=‘王二丫‘
11         #stu1.Sex=‘女‘
12         #stu1.Age=18
13 
14     def learn(self):
15         print(is learning)
16 
17     def eat(self):
18         print(is sleeping)
19 
20 
21 #后产生对象
22 stu1=LuffyStudent(王二丫,,18) #LuffyStudent.__init__(stu1,‘王二丫‘,‘女‘,18)
23 
24 #加上__init__方法后,实例化的步骤
25 # 1、先产生一个空对象stu1
26 # 2、LuffyStudent.__init__(stu1,‘王二丫‘,‘女‘,18)
27 
28 
29 #
30 print(stu1.__dict__)
31 print(stu1.Name)
32 print(stu1.Sex)
33 print(stu1.Age)
34 
35 #
36 stu1.Name=李二丫
37 print(stu1.__dict__)
38 print(stu1.Name)
39 
40 
41 # 删除
42 del stu1.Name
43 print(stu1.__dict__)
44 
45 #
46 stu1.class_name=python开发
47 print(stu1.__dict__)
48 
49 
50 stu2=LuffyStudent(李三炮,,38) #Luffycity.__init__(stu2,‘李三炮‘,‘男‘,38)
51 print(stu2.__dict__)
52 print(stu2.Name)
53 print(stu2.Age)
54 print(stu2.Sex)
View Code

         (二 ) 对象调用类中的属性与方法

    对象:特征与技能的结合体
    类:类是一系列对象相似的特征与相似的技能的结合体

              类中的数据属性:是所以对象共有的 , id 都是同一个

print(LuffyStudent.school,id(LuffyStudent.school))
print(stu1.school,id(stu1.school))
print(stu2.school,id(stu2.school))
print(stu3.school,id(stu3.school))

             类中的函数属性:是绑定给对象使用的,绑定到不同的对象是不同的绑定方法,对象调用绑定方式时,会把对象本身当作第一个传入,传给self

          

print(LuffyStudent.learn)
LuffyStudent.learn(stu1)  #stu1.learn()
LuffyStudent.learn(stu2)
LuffyStudent.learn(stu3)

# 如果类中的函数有参数,则:
stu1.learn(‘python‘) # LuffyStudent.learn(stu1,‘python‘)

  类中定义的函数,没有经过任何附加处理的情况下,实际上是绑定给对象调用的。

       谁来调就把谁当作第一个参数传入给self,谁来调就是谁来执行。

 

名称空间:

    全局变量,类变量,对象变量同名

    则,优化使用对象变量,

    如果没有对象变量,则找类变量,

    如果类变量没有,就到父类找,父类没有,再到父父类,不会到全局找。

stu1.x=‘from stu1‘
LuffyStudent.x=‘from Luffycity class‘
print(stu1.__dict__)
print(stu1.x)

  

 python一切皆对象,python3统一了类与类型的

l1=[1,2,3] #l=list([1,2,3])
l2=[] #l=list([1,2,3])
# l1.append(4) #list.append(l1,4)
list.append(l1,4)
print(l1)

 

面向对象的可扩展性:

class Chinese:
    county=‘China‘
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def eat(self):
        print(‘%s is eating‘ %self.name)

p1=Chinese(‘egon‘,18,‘male‘)
p2=Chinese(‘alex‘,38,‘female‘)
p3=Chinese(‘wpq‘,48,‘female‘)

# print(p1.county)
# print(p2.county)
# print(p3.county)

p1.eat()
p2.eat()
p3.eat()

  

  五、练习

‘‘‘
练习1:编写一个学生类,产生一堆学生对象, (5分钟)

要求:

有一个计数器(属性),统计总共实例了多少个对象
‘‘‘

class Student:
    school=‘luffycity‘
    count=0

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        # self.count+=1  是对象自己独有的。 想要实现的是所有对象都能感应到。应该是共有的特征。
        Student.count+=1

    def learn(self):
        print(‘%s is learing‘ %self.name)


stu1=Student(‘alex‘,‘male‘,38)
stu2=Student(‘jinxing‘,‘female‘,78)
stu3=Student(‘egon‘,‘male‘,18)

#对象.count 其实就是student.count ,值都相等
# print(Student.count)
# print(stu1.count)  #自己没有count属性,就去类中找count
# print(stu2.count)
# print(stu3.count)
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)

  

 对象交互:

‘‘‘
练习2:模仿LoL定义两个英雄类, (10分钟)   

要求:

英雄需要有昵称、攻击力、生命值等属性;
实例化出两个英雄对象;
英雄之间可以互殴,被殴打的一方掉血,血量小于0则判定为死亡。
‘‘‘

class Garen:
    camp=‘Demacia‘

    def __init__(self,nickname,life_value,aggresivity):
        self.nickname=nickname
        self.life_value=life_value
        self.aggresivity=aggresivity

    def attack(self,enemy):
        enemy.life_value-=self.aggresivity
        #r1.life_value-=g1.aggresivity

class Riven:
    camp = ‘Noxus‘

    def __init__(self, nickname, life_value, aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity

    def attack(self, enemy):
        enemy.life_value -= self.aggresivity

g1=Garen(‘草丛伦‘,100,30)

r1=Riven(‘可爱的锐雯雯‘,80,50)

print(r1.life_value)
g1.attack(r1)
print(r1.life_value)

  

     

3.1 面向对象的基本知识

标签:扩展性   操作   学生   tin   对象   hid   分类   lex   __init__   

原文地址:https://www.cnblogs.com/beallaliu/p/9101769.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!