面向对象

一:面向对象初级

1.思考:首先在python中,以前我们以前用到的几乎都是函数式编程,但是有时候函数式编程其中代码重复利用率太高,我们往往会把这些重复代码写进一个函数日后去调用,所以呢,今天所将的面向对象将使我们学习到面向对象编程,面向对象对函数进行封装和分类,让开发变得更快更好,什么是面向对象?

Python中通过使用类(class)和对象(object)来实现面向对象(object-oriented programming,简称OOP
)的编程。 面向对象编程的最主要目的是提高程序的重复使用性,这和函数的目的相类似。

假设我养了一只小鸡,叫summer。它是个对象,属于鸟类。

2.举个简单的例子小明来说:

 比如说我们要实现这个简单的功能
小明,10岁,男,喝酒
小明,10岁,男,吸烟
小明,10岁,男,游戏 老王,50岁,男,喝酒
老王,50岁,男,吸烟
老王,50岁,男,游戏
我们往往在使用函数式编程的时候回这样写
def foo(name,age,sex,content):
print(name,age,sex,cntent)
foo()这里面赋值就行

但是如果用面向对象去做该怎样,因此下面就来具体介绍一下面向对象

 1 class bar:
2 def foo(self,name,age,sex,content):
3 print(name,age,sex,content)
4 obj = bar()
5 obj.foo(小明,10岁,男,喝酒)
6 obj.foo(小明,10岁,男,吸烟)
7 obj.foo(小明,10岁,男,游戏)
8 obj.foo(老王,10岁,男,喝酒)
9 obj.foo(老王,10岁,男,吸烟)
10 obj.foo(老王,10岁,男,游戏)

怎样就通过面向对象来实现了,但是你有可能觉得下面的代码还是很多,但是我们得从多个方面去考虑

3.

3.1    定义(以上面的例子为参考)

函数:

  def *函数名(参数):

面向对象:

  class  * 名字是*(bar)的类   ,这里面第一个参数是self。必须有,是系统帮我们生成的

    def =》名字叫foo的方法

3.2    执行  obj(object对象)

函数:

  函数名(参数)

面向对象:

  obj = bar()    #   创建一个中间人 也就是对象

  obj.foo()

来一个小程序感受一下,其实面向对象就是一个类和对象的结合

 class s:              #类名
def add(self,a,b,c): #函数
print(a+b+c)
return a
obj = s() #中间人,对象
obj.add(1,2,3)
ret = (obj.add(1,2,3))
print(ret) 结果为: # 注意这里面最后又return 最后返回的就是return的值 6
6
1

还有也许有人对self不是太理解,其实他就是中间人也就是对象,来一个例子看一下

 class bar:
def foo(self,arg):
print(self,arg)
obj = bar()
print(obj)
obj.foo(11111111111)
结果显示为:
<__main__.bar object at 0x00000015C1FEB8D0>
<__main__.bar object at 0x00000015C1FEB8D0> 11111111111

你会发现self 和obj是一样的,self是调用方法的对象(中间人)

但是能不能再中间人里面存东西也就是self.name = "sang"这样行不行,其实 是可以的,上面的例子我们是通过中间人也就是对象先去访问类,我们也可以在对象中存东西,再去执行方法再看一个例子

 class foo:
def aaa(self,arg):
print(self,self.name,self.age,self.sex,self.hobby,arg)
mid1 = foo()
mid1.name = "sang"
mid1.age = 20
mid1.sex = "male"
mid1.hobby = "book"
print(mid1.name)
mid1.aaa("you are good")
结果为:
sang
<__main__.foo object at 0x0000008FE2BF24E0> sang 20 male book you are good

这里呢,再看上面小明的例子我们就可以这样写,就不会感觉代码很多了

1 class bar:
2 def foo(self,content):
3 print(self.name,self.age,self.sex,content)
4 obj = bar()
5 obj.name = "小明"
6 obj.age = 10
7 obj.sex = "男"

3.3  创建方法

构造方法,__init__(self,arg)(内部的)

  obj = 类(“all”)

普通方法

  obj = 类(“”)

  obj.普通方法名()

来一个程序来看一下

class bar:
def __init__(self):
print("helo world")
def foo(self):
print("")
z = bar()
print(z)
z.foo()
结果为:
helo world
<__main__.bar object at 0x0000002536D22358>
123

可以看出他先去进行内部的构造方法,再去执行z.foo(),它的特性就是只要类后面加上括号就自动执行,还可以在内部构造方法中加上参数

 class Bar:
def __init__(self,n1,n2,n3,n4,n5,n6):
self.nam1=n1
self.nam2=n2
self.nam3=n3
self.nam4=n4
self.nam5=n5
self.nam6=n6
def foo(self):
print(self.nam1,self.nam2,self.nam3,self.nam4,self.nam5,self.nam6)
z = Bar(1,2,3,4,5,6)
print(z.nam1)
z.foo()
结果为:
1
1 2 3 4 5 6

此时在改进上面小明的例子

class bar:
def __init__(self,n,a,s):
self.name = n
self.age = a
self.sex = s
def foo(self,content):
print(self.name,self.age,self.sex,content)
obj = bar("小明",10,"男")
这样是不是就更加简便了,这就是面向对象的特点

上面的可以看出我们通过person就把值封装到对象里面了,这就是构造封装因此下面引出面向对象的三大特性

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

3.41  封装 :

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。所以,在使用面向对象的封装特性时,需要注意:
将内容封装到某处
从某处调用被封装的内容

来看例子来理解

 1 class person:
2 def __init__(self,name,age):
3 self.n = name
4 self.a = age
5 def show(self):
6 print("%s-%s" %(self.n,self.a))
7 zhangsan = person("张三",22)
8 zhangsan.show()
9 wangwu = person("王五",55)
10 wangwu.show()
结果为:
张三-22
王五-55

那么此时我们再来看一下到底什么时候用函数式编程啥时候用面向对象

适用场景:如果多个函数中有一些相同参数时,转换成面向对象

 1 class DataBaseHelper:
2 def __init__(self, ip, port, username, pwd):
3 self.ip = ip
4 self.port = port
5 self.username = username
6 self.pwd = pwd
7 def add(self,content):
8 # 利用self中封装的用户名、密码等 链接数据
9 print('content')
10 # 关闭数据链接
11 def delete(self,content):
12 # 利用self中封装的用户名、密码等 链接数据
13 print('content')
14 # 关闭数据链接
15 def update(self,content):
16 # 利用self中封装的用户名、密码等 链接数据
17 print('content')
18 # 关闭数据链接
19 def get(self,content):
20 # 利用self中封装的用户名、密码等 链接数据
21 print('content')
22 # 关闭数据链接
23 s1 = DataBaseHelper('1.1.1.1',3306, 'alex', 'sb')

代码

3.42  继承   :

继承,面向对象中的继承和现实生活中的继承相同,即:儿子可以继承父亲的内容。

来看一个例子

 class father:                    #父类,基类
def f1(self): #fi()中的self时形参,代指obj,self是用于调用方法的调用者
print("f1.aaa")
def f2(self):
print("f2.vvv")
class son(father): #子类,派生类,他们的关系是一一对应的,
def f3(self):
print("f3.ccc")
def f2(self): #重写,防止继承父类中的方法
print("son.f2") #son中的f2表示不继承父类中f2,但是如果没有son中的f2,则表示全部继承父类中的,                    不想继承就在son自己中定义一个
11 obj = son()
obj.f3()
obj.f1()
obj.f2()
结果为:
f3.ccc
f1.aaa
son.f2

同时呢,父亲还可以有一个父类,这时候son还可以继承父亲的父类,

但是如果我们既想执行自己得f2又想执行父类的f2该怎么办?

class father:
def f1(self):
print("f1.aaa")
def f2(self):
print("f2.vvv")
class son(father):
def f3(self):
print("f3.ccc")
def f2(self):
print("son.f2")
super(son,self).f2() #执行父类(基类)中的f2方法
father.f2(self) #父类名.父类中的方法(self)
obj = son()
obj.f3()
obj.f1()
obj.f2()
结果为:

f3.ccc
f1.aaa
son.f2
f2.vvv
f2.vvv

3.421 多继承   通俗来说就是说 有多个父类,

class F1():
def a1(self):
print('F1.a') class F2():
def a1(self):
print('F2.a') class S(F1,F2):
pass obj = S()
obj.a()
结果为:F1.a #哪个父类在前面就执行哪一个父类中的

但是如果F1没有戴氏有父类或者F2也有父类,该怎么找,来看例子

 class Base:
def a(self):
print('Base.a')
class F0(Base):
def a1(self):
print('F0.a')
class F1(F0):
def a1(self):
print('F1.a')
class F2(Base):
def a1(self):
print('F2.a')
class S(F1,F2):
pass
obj = S()
obj.a()
结果为: Base.a 你会发现现在左边找,一直往上找,再找右边,但是如果F1和F2的共同的根中有,
F2中也有,它会先找F2,最后才去找根,
总结:
Python中支持多继承
a. 左侧优先
b. 一条道走到黑
c. 同一个根时,根最后执行
 # class BaseHandler():
# pass
# class RequestHandler(BaseHandler):
# def serve_forever(self):
# print("RequestHandler.serve_forever")
# self.process_request()#self 就是obj
# def process_request(self):
# print("RequestHandler.process_request")
#
# class Minx:
# def process_request(self):
#
print("RequestHandler.serve_forever")
  # class son(Minx,RequestHandler):  # pass  # obj = son()  # obj.serve_forever()
结果为:
print("RequestHandler.serve_forever")
print("RequestHandler.serve_forever")  此时 ,obj是son的对象,它会返回到原点再从左开始找。

查看源码进行分析

 import socketserver
obj = socketserver.ThreadingTCPServer(1,2)#创建对象,init
obj.serve_forever()

按住Ctrl  ,点击单词就可以查看源码,还有一个快速定位,但是在使用快速定位前要先选中show members这一项

Ctrl  r  可以修改一个程序中所有你想改的同一个单词

3.43  多态           ==》原生多态

打个比方来说python和Java

 # Java
string v = 'alex'
def func(string arg):
print(arg) #在Java中是需要声明类型的
func('alex')
func(123) # Python
v = 'alex'
def func(arg):
print(arg)
func(1)
func('alex')

二:面向对象中高级

类成员:
# 字段
- 普通字段,保存在对象中,执行只能通过对象访问
- 静态字段,保存在类中, 执行 可以通过对象访问 也可以通过类访问 # 方法
- 普通方法,保存在类中,由对象来调用,self=》对象
- 静态方法,保存在类中,由类直接调用
- 类方法,保存在类中,由类直接调用,cls=》当前类 ######## 应用场景:
如果对象中需要保存一些值,执行某功能时,需要使用对象中的值 -> 普通方法
不需要任何对象中的值,静态方法 # 属性,特性
- 不伦不类

1.普通字段

 class Foo:
def __init__(self, name):
# 普通字段
self.name = name
# 普通方法
def show(self):
print(self.name)
obj = Foo('alex')
obj.name #字段直接去调用
obj.show() #方法加上()才行

1.1静态字段

 class province:
#静态字段属于类
country = "中国"
def __init__(self,name):
#普通字段,属于对象
self.name = name
# henan = province("河南")
# hebei = province("河北")
print(province.country)
henan = province("河南")
print(henan.name)
结果为:

alex
中国
河南

2.方法

 class foo:
def bar(self):
print("you are good")#普通方法
@staticmethod#静态方法保存在类中,由类直接调用
def sta():
print("")
@staticmethod #静态装饰器
def stat(a1,a2):
print(a1,a2)
@classmethod
def classmd(cls):
#cls 是类名
print(cls)
print("classmd") obj = foo()
obj.bar()
foo.sta()
foo.stat(2,3)
foo.classmd()
结果是:
you are good
123
2 3
<class '__main__.foo'>
classmd

3.既能用方法又像用字段

 class foo:
def __init__(self):
self.name = "a"
def bar(self):
print("bar")
@property
def perr(self0):
print("")
return 1 #obj.per = 123
@perr.setter
def perr(self,val):
print(val)
@perr.deleter
def perr(self):
print(666)
obj = foo()
r = obj.perr
#print(r)
obj.perr = 123
del obj.perr
结果为: 其实他们就是一一对应的关系

123
123
666

3.1

 class foo:
def f1(self):
return 123
per = property(fget=f1) 第一种 @property
def per(self):
return 123 第二种 其实这2种方法功能是一样的
obj = foo()
re = obj.per
obj.per
print(re)
所以呢,定义属性有2种方法,分别是装饰器和静态字段
per = property(fget = f1,fset = f2,fdel = f3,doc = "ajakjhs")
最多有三个参数,最后一个参数是介绍这个是干嘛的

3.3   我们在网上看新闻的时候 有时候有很多页,我们可以分页去查看,那么现在就做一个简单的小查看页码的程序

查看页码伪代码

PYTHON开发--面向对象基础入门的更多相关文章

  1. python开发面向对象基础:接口类&抽象类&多态&钻石继承

    一,接口类 继承有两种用途: 一:继承基类的方法,并且做出自己的改变或者扩展(代码重用) 二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实 ...

  2. python开发面向对象基础:封装

    一,封装 [封装] 隐藏对象的属性和实现细节,仅对外提供公共访问方式. [好处] 1. 将变化隔离: 2. 便于使用: 3. 提高复用性: 4. 提高安全性: [封装原则] 1. 将不需要对外提供的内 ...

  3. PYTHON开发--面向对象基础二

    一.成员修饰符 共有成员 私有成员, __字段名 - 无法直接访问,只能间接访问 1.     私有成员 1.1  普通方法种的私有成员 class Foo: def __init__(self, n ...

  4. python开发面向对象基础:人狗大战学面向对象

    一,通过函数写人狗大战这个故事 #!/usr/bin/env python #_*_coding:utf-8_*_ #1.函数 人模子 def person(name,level,life_value ...

  5. python开发面向对象基础:组合&继承

    一,组合 组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合      人类装备了武器类就是组合 1.圆环,将圆类实例后传给圆环类 #!/usr/bin/env python #_*_ ...

  6. 云小课|DGC数据开发之基础入门篇

    阅识风云是华为云信息大咖,擅长将复杂信息多元化呈现,其出品的一张图(云图说).深入浅出的博文(云小课)或短视频(云视厅)总有一款能让您快速上手华为云.更多精彩内容请单击此处. 摘要:欢迎来到DGC数据 ...

  7. python 开发之路 - 入门

    一. python 介绍 Python是著名的"龟叔"Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言.1991年 发布Python ...

  8. VS2013中Python学习笔记[基础入门]

    前言 在上一节中简单的介绍了在VS2013中如何进行开发Hello World,在VS2013中进行搭建了环境http://www.cnblogs.com/aehyok/p/3986168.html. ...

  9. Python学习之路【第一篇】-Python简介和基础入门

    1.Python简介 1.1 Python是什么 相信混迹IT界的很多朋友都知道,Python是近年来最火的一个热点,没有之一.从性质上来讲它和我们熟知的C.java.php等没有什么本质的区别,也是 ...

随机推荐

  1. Java调用MySQL存储过程

    Java调用MySQL的存储过程,需要用JDBC连接,环境eclipse 首先查看MySQL中的数据库的存储过程,接着编写代码调用 mysql> show procedure status; + ...

  2. 【C++自我精讲】基础系列二 const

    [C++自我精讲]基础系列二 const 0 前言 分三部分:const用法.const和#define比较.const作用. 1 const用法 const常量:const可以用来定义常量,不可改变 ...

  3. PowerDesigner跟表的字段加注释

    选择那个表 右键- >Properties- >Columns- >Customize Columns and Filter(或直接用快捷键Ctrl+U)- >Comment( ...

  4. richTextBox插入表格

    附件:http://files.cnblogs.com/xe2011/richTextBox_InsertTable.rar 插入表格 /// <summary> /// 插入表格 /// ...

  5. resin 4.0数据源的配置

    在resin 的conf 文件下有resin.xml  我们在这里能够配置数据源以及配置项目 一.配置多个数据源,多个项目共享这些数据源.也就是这些数据源配置在<host>   </ ...

  6. NuGet的使用心得

    前言 上星期发布了NuGet的使用和服务搭建后,同时NuGet在部门里也使用了起来.经过这些天的使用,总结了些小技巧和注意点,希望和大家分享下. 问题提出 使用了NuGet的朋友们估计都知道,在签入代 ...

  7. careercup-数组和字符串1.3

    1.3 给定两个字符串,请编写程序,确定其中一个字符串的字符重新排序后,能否变成另一个字符串. C++实现代码: #include<iostream> #include<map> ...

  8. LabVIEW系列——生产现场故障邮件通知

    第一步.建立邮件服务器,winmail做邮件服务器是个不错的选择.不过在使用前需要注册. 第二步.创建修改域名.这里创建的域名不是真正的域名,只能用于局域网内.假设:lhy.com.cn 第三步.创建 ...

  9. java String的比较,BOX装箱拆箱,以及面向对象的小代码

    package cn.hncu.day2; public class StringDemo { public static void main(String[] args) { String str1 ...

  10. 路E施工管理ERP系统

      前  景   目前公路工程由于点多.线长.面广.周期久.投资大等原因,管理很难到位,施工过程中存在着大量问题: 规章制度欠缺或不健全,即便是有好的规章制度,在施工过程中也往往形同虚设,不能与现场施 ...