欢迎光临
我们一起进阶

python面向对象-面向对象讲解

扫码或搜索:沉默王二
发送 290992
即可立即永久解锁本站全部文章
上面我们讲完了函数式编程,接下来我们讲面向对象编程
首先先讲什么是面向对象:

面向对象编程简单来说就是基于对 类 和 对象 的使用,所有的代码都是通过类和对象来实现的编程就是面向对象编程!

面向对象的三大特性:封装、继承、多态

后面会详细讲解封装、继承、多态。

面向对象技术详细:

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员:类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

局部变量:定义在方法中的变量,只作用于当前实例的类。

实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。

继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟”是一个(is-a)”关系(例图,Dog是一个Animal)。

实例化:创建一个类的实例,类的具体对象。

方法:类中定义的函数。

对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

新手看到这是不是有点不知所措,哈哈哈,我当初也是这样,先了解一下,后面会详细讲解。

今天先讲类与对象

在python2中,分新式类与经典类,python3统一都是新式类【新式类,class 类名:】【经典类,class 类名(object)】

class Chinese:   #class是关键字,表示类名
    pass
print(Chinese)

p1=Chinese() #实例化过程,创建对象,类名后面加括号
print(p1)

实例化,由类产生对象的过程叫做实例化,类实例化的结果就是一个对象,或者叫做一个实例

ps:类中的函数第一个参数必须是self  类中定义的函数叫做 “方法”

类是用来描述一类事物,类的对象指的是这一类事物中的一个个体
是事物就要有属性,属性分为:

1.数据属性:就是变量
2.函数属性:就是函数,在面向对象里通常称为方法
注:类和对象均是用点来访问自己的属性

 class Chinese:
     dang='我爱中国'
     def tu_tan():
         print('张口就是一痰')
     def queue(self):
         print('随意就是一插')
 print(Chinese.dang) #调用类Chinese的数据属性
 Chinese.tu_tan() #调用方法
 Chinese.queue('zy') #queue方法必须传一个参数
 print(Chinese.__dict__)  #Chinese所有的方法
 print(Chinese.__dict__['dang'])  #在字典中找出了dang这个数据属性
 print(Chinese.__dict__['tu_tan']) #内存地址,加()就是地址的内容
 Chinese.__dict__['tu_tan']()
 Chinese.__dict__['queue'](666) #必须给queue传一个参数

我爱中国
张口就是一痰
随意就是一插
 {'__dict__': <attribute '__dict__' of 'Chinese' objects>, '__module__': '__main__', 'queue': <function Chinese.queue at 0x0000029230A14C80>, 'tu_tan': <function Chinese.tu_tan at 0x0000029230A148C8>, 'dang': '我爱中国', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
 我爱中国
 <function Chinese.tu_tan at 0x0000029230A148C8>
 张口就是一痰
 随意就是一插

对象:

class Chinese:
      dang='我爱中国'
      # def __init__(name,age,gender):  #开头结尾都有两个_ _表示是系统内置的方法
      #     dic={
      #         'name':name,
      #         'age':age,
      #         'gender':gender
      #     }
      #     return dic
     def __init__(self,name,age,gender):
         print('开始')
         self.mingzi=name  # 其实就是字典中封装了名字,年级,性别
         self.nianji=age
         self.xingbie=gender
         print('结束')
 #class的__init__就是不需要返回任何值,它会自动返回
     def tu_tan():
         print('张口就是一痰')
     def queue(self):
         print('随意就是一插')

 person1=Chinese('zy',18,'female')  #实例化就是在触发系统内置的__init__
 print(person1.__dict__)  #实例化后的字典形式 __dict__
 print(person1.mingzi)  #调用person1字典的mingzi
 print(person1.dang)  #person1调用类class的属性

 Chinese.tu_tan()
 Chinese.queue(person1)  #必须传参数

 结果:
 # 结束
 # {'xingbie': 'female', 'nianji': 18, 'mingzi': 'zy'}
 # zy
 # 张口就是一痰
 # 随意就是一插

类属性的增删改查:

class Chinese:
      country='China'
      def __init__(self,name):
          self.name=name
      def play_ball(self,ball):
          print("%s 正在打%s" %(self.name,ball))

  print(Chinese.country)  #查看

 Chinese.country='Japan'
 print(Chinese.country)   #修改

 p1=Chinese('alex')
 print(p1.__dict__)
 print(p1.country)

 Chinese.dang='dang' #增加
 print(Chinese.dang)
 print(p1.dang)

 del Chinese.dang   #删除
 del Chinese.country
 print(Chinese.__dict__)

 结果:
 # China
 # Japan
 # {'name': 'alex'}
 # Japan
 # dang
 # dang
 # {'__module__': '__main__', '__init__': <function Chinese.__init__ at 0x000001FE771948C8>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'play_ball': <function Chinese.play_ball at 0x000001FE77194C80>, '__doc__': None}

实例属性的增删改查: (实例只有数据属性)

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)
 print(p1.play_ball)  #这一步实际上是访问类

 #增加
 p1.age=18
 print(p1.__dict__)
 print(p1.age)

 #修改
 p1.age=19
 print(p1.__dict__)
 print(p1.age)

 #删除
 del p1.age
 print(p1.__dict__)

 结果:
 #{'name': 'alex'}
 # alex
 # <bound method Chinese.play_ball of <__main__.Chinese object at 0x000002042B47A400>>
 # {'age': 18, 'name': 'alex'}
 # 18
 # {'age': 19, 'name': 'alex'}
 # 19
 # {'name': 'alex'}

对象与实例属性:

1 class Chinese:
 2     country='China'
 3     def __init__(self,name):
 4         self.name=name
 5     def play_ball(self,ball):
 6         print("%s 正在打%s" %(self.name,ball))
 7 p1=Chinese('alex')
 8 print(p1.country)
 9 p1.country='Japan'
10 print(Chinese.country) #类的
11 print(p1.country)  #实例的
12 结果:
13 #China
14 #China
15 #Japan
16 
17 country='China'
18 class Chinese:
19 
20     def __init__(self,name):
21         self.name=name
22     def play_ball(self,ball):
23         print("%s 正在打%s" %(self.name,ball))
24 p1=Chinese('alex')
25 print(p1.country)   #报错,因为p1调用country在class里面找,找不到不会出去找
26 
27 country='China'
28 class Chinese:
29     country='中国'
30     def __init__(self,name):
31         self.name=name
32         print(country)
33 #只是返回一个普通的变量,只有点调用的时候才在类属性或者实例属性字典里面去找,所以返回China
34 p1=Chinese('alex')
35 print(p1.country) #这才是调用实例属性,country才是'中国'

1 class Chinese:
 2     country = 'China'
 3     def __init__(self,name):
 4         self.name=name
 5 p1=Chinese('alex')
 6 p1.country='Japan'
 7 print(Chinese.country)  #类属性没有变,所以结果还是China
 8 
 9 
10 class Chinese:
11     country = 'China'
12     li=['a','b']
13     def __init__(self,name):
14         self.name=name
15 p1=Chinese('alex')
16 print(p1.li)
17 # p1.li=[666]
18 # print(Chinese.li)  #类的列表还是没变的
19 p1.li.append('cc')   #直接改了类里面的列表
20 print(p1.__dict__)
21 print(Chinese.li)  #类里面的列表被改变之后,打印出来的里边当然是新列表['a', 'b', 'cc']

赞(1) 打赏
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

小白学堂,学的不止是技术,更是前程

关于我们免责声明

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏