概述

  • 面向过程:根据业务逻辑从上到下写垒代码
  • 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可
  • 面向对象:对函数进行分类和封装,让开发“更快更好更强...”

面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,即:将之前实现的代码块复制到现需功能处。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
while True
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
 
    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

随着时间的推移,开始使用了函数式编程,增强代码的重用性和可读性,就变成了这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
 
while True
 
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
 
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
 
    if 内存占用 > 80%:
        发送邮件('内存报警'

今天我们来学习一种新的编程方式:面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)
注:Java和C#来说只支持面向对象编程,而python比较灵活即支持面向对象编程也支持函数式编程

创建类和对象

面向对象编程是一种编程方式,此编程方式的落地需要使用 “类” 和 “对象” 来实现,所以,面向对象编程其实就是对 “类” 和 “对象” 的使用。

  类就是一个模板,模板里可以包含多个函数,函数里实现一些功能

  对象则是根据模板创建的实例,通过实例对象可以执行类中的函数

  • class是关键字,表示类
  • 创建对象,类名称后加括号即可

ps:类中的函数第一个参数必须是self(详细见:类的三大特性之封装)
   类中定义的函数叫做 “方法”

#!usr/bin/env python
# -*- coding:utf-8 -*-
#创建类
class Foo:
def Bar(self):
print('Bar')
def Hello(self,name):
print('hello %s' %name)
#根据类Foo创建对象
foo = Foo()
foo.Bar() #执行Bar方法
foo.Hello('SUNXIAO') #执行Hello方法

内部实际传参数的逻辑: foo.Hello('SUNXIAO')  --> Hello(self  = foo,name = 'SUNXIAO')

诶,你在这里是不是有疑问了?使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便

  • 面向对象:【创建对象】【通过对象执行方法】
  • 函数编程:【执行函数】

观察上述对比答案则是肯定的,然后并非绝对,场景的不同适合其的编程方式也不同。

总结:

1)函数式的应用场景 --> 各个函数之间是独立且无共用的数据

2)面向对象的使用场景:

A、同一类型的方法具有相同的参数时,直接封装到对象中即可

B、把类当做模板,创建多个对象,对象内封装的数据可以不一样

self详解

#!usr/bin/env python
# -*- coding:utf-8 -*-
#创建类
class Foo:
def Bar(self):
print('Bar',self) #self打印:<__main__.Foo object at 0x000001EC4601ADA0>
def Hello(self,name):
print('hello %s' %name)
#根据类Foo创建对象
foo1 = Foo()
print(foo1)
foo1.Bar() #执行Bar方法,打印出:Bar <__main__.Foo object at 0x000001EC4601ADA0> #由上面的代码结果可以看出,在执行Bar方法时,python自动将对象foo1传递了Bar方法作为第一个参数

面向对象三大特性

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

一、封装

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以,在使用面向对象的封装特性时,需要:

  • 将内容封装到某处
  • 从某处调用被封装的内容

第一步:将内容封装到某处

__init__(self)为构造方法,当创建对象时,首先执行的就是构造方法

__del__()  析构方法,当解释器销毁对象时自动调用该方法

self 是一个形式参数,当执行 obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj1

当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2

所以,内容其实被封装到了对象 obj1 和 obj2 中,每个对象中都有 name 和 age 属性,在内存里类似于下图来保存。

第二步:从某处调用被封装的内容

调用被封装的内容时,有两种情况:

  • 通过对象直接调用
  • 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名

class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
obj1 = Foo('sunxiao',28)
print(obj1.name) #sunxiao
print(obj1.age) # obj2 = Foo('sunyu','')
print(obj2.name) #sunyu
print(obj2.age) #

直接调用

2、通过self间接调用被封装的内容

执行类中的方法时,需要通过self间接调用被封装的内容

class Foo:
def __init__(self,name,age):
self.name = name
self.age = age
def detail(self):
print(self.name)
print(self.age)
obj1 = Foo('sunxiao',28)
obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18 obj2 = Foo('sunyu','')
obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78

简介调用

综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容。

练习一:在终端输出如下信息

  • 小明,10岁,男,上山去砍柴
  • 小明,10岁,男,开车去东北
  • 小明,10岁,男,最爱大保健
  • 老李,90岁,男,上山去砍柴
  • 老李,90岁,男,开车去东北
  • 老李,90岁,男,最爱大保健
  • 老张...
def kanchai(name,age,gender):
print('%s,%s岁,%s,上山去砍柴' %(name,age,gender))
def qudongbei(name,age,gender):
print('%s,%s岁,%s,去东北' %(name,age,gender))
def dabaojian(name,age,gender):
print('%s,%s岁,%s,大保健' %(name,age,gender)) kanchai('小敏',20,'男')
qudongbei('小明',18,'男')
dabaojian('老张',65,'男')

函数式编程

class Person:
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def kanchai(self):
print('%s,%s岁,%s,上山去砍柴' %(self.name,self.age,self.gender))
def qudongbei(self):
print('%s,%s岁,%s,开车去东北' %(self.name,self.age,self.gender))
def dabaojian(self):
print('%s,%s岁,%s,最爱大保健' %(self.name,self.age,self.gender))
p1 = Person('xiaoming','','男')
p1.kanchai()
p1.qudongbei()
p2 = Person('老张',65,'男')
p2.dabaojian()

面向对象编程

上述对比可以看出,如果使用函数式编程,需要在每次执行函数时传入相同的参数,如果参数多的话,又需要粘贴复制了...  ;而对于面向对象只需要在创建对象时,将所有需要的参数封装到当前对象中,之后再次使用时,通过self间接去当前对象中取值即可。

 

练习二:游戏人生程序

1、创建三个游戏人物,分别是:

  • 梅超风,女,18,初始战斗力1000
  • 张三丰,男,20,初始战斗力1800
  • 黄蓉,女,19,初始战斗力2500

2、游戏场景,分别:

  • 草丛战斗,消耗200战斗力
  • 自我修炼,增长100战斗力
  • 多人游戏,消耗500战斗力
#!usr/bin/env python
#-*- coding:utf-8 -*-
class Person:
def __init__(self,name,gender,age,fight):
self.name = name
self.gender = gender
self.age = age
self.fight = fight
def grassland(self):
"""注释:草丛战斗,消耗200战斗力"""
self.fight -= 200
def practice(self):
"""注释:自我修炼,增长100战斗力"""
self.fight += 100
def commandfight(self):
"""多人游戏:消耗500战斗力"""
self.fight -= 500
def detail(self):
temp = '姓名%s;性别%s;年龄%s;战斗力%s' %(self.name,self.gender,self.age,self.fight)
print(temp) p1 = Person('sun','男',100,10000)
p1.detail()
p1.commandfight()
p1.detail()

游戏人生

二、继承

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

例如:

  猫可以:喵喵叫、吃、喝、拉、撒

  狗可以:汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:

上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:

  动物:吃、喝、拉、撒

     猫:喵喵叫(猫继承动物的功能)

     狗:汪汪叫(狗继承动物的功能)

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Animal:
def eat(self):
print('%s吃' %self.name)
def drink(self):
print('%s喝' %self.name)
def shit(self):
print('%s拉' %self.name)
def pee(self):
print('%撒' %self.name)
class Cat(Animal):
def __init__(self,name):
self.name = name
def cry(self):
print('喵喵叫')
class Dog(Animal):
def __init__(self,name):
self.name = name
def cry(self):
print('汪汪叫') dog1 = Dog('老李家的小狗')
dog1.eat()
dog1.cry()
cat1 = Cat('小明家的小猫')
cat1.drink()
cat1.cry()

继承实例

所以,对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。

注:除了子类和父类的称谓,你可能看到过 派生类 和 基类 ,他们与子类和父类只是叫法不同而已。

如果子类和父类都存在相同名称的方法,子类对象优先调用子类中的方法,父类对象优先调用父类的方法

那么问题又来了,多继承呢?

  • 是否可以继承多个类
  • 如果继承的多个类每个类中都定了相同的函数,那么那一个会被使用呢?

1、Python的类可以继承多个类,Java和C#中则只能继承一个类

2、Python2.7中的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先广度优先

Python中经典类和新式类的区别:

  区别主要体现在继承上:

    Python的类可以继承多个类,Java和C#中则只能继承一个类

    Python的类如果继承了多个类,那么其寻找方法的方式有两种

        当类是经典类时,多继承情况下,会按照深度优先方式查找

        当类是新式类时,多继承情况下,会按照广度优先方式查找

简单点说就是:经典类是纵向查找,新式类是横向查找

如下例:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Life():
def daily(self):
print "繁衍" class Animal(Life):
def daily(self):
print "吃"
print "喝"
print "拉"
print "撒" class Puru(Life):
def __init__(self):
pass class cat(Puru,Animal):
def __init__(self):
print "喵喵" a = cat()
a.daily() # 执行结果是:
# 喵喵
# 繁衍

python2.7经典类 深度查找

#!usr/bin/env python
# -*- coding:utf-8 -*- class Life(object):
def daily(self):
print "繁衍" class Animal(Life):
def daily(self):
print "吃"
print "喝"
print "拉"
print "撒" class Puru(Life):
def __init__(self):
pass class cat(Puru,Animal):
def __init__(self):
print "喵喵" a = cat()
a.daily() # 执行结果是:
# 喵喵
# 吃
# 喝
# 拉
# 撒

python2.7新式类 广度查找

经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了很多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。

 

3、python3中不再区分经典类和新式类,只有一种查找方式

面向对象之多继承易错点,函数中调用函数同样按照同样是按照上图对象所在类的顺序查找:
利用:类名.mro()可以查看类的继承顺序,例如上图中的 A.mro()
 
#!usr/bin/env python
# -*- coding:utf-8 -*-
class A:
def f1(self):
print("A")
def Bar(self):
self.f1()
class B(A):
def f1(self):
print("B")
class C:
def f1(self):
print("C")
class D(B,C):
pass d = D()
d.Bar() #B,在执行self.f1()时,因为是D创建的对象,所以也是按照D B A C的顺序查找的

调用顺序易错点

子类执行父类构造方法的两种方式:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Animal:
def __init__(self):
print('A构造方法')
self.ty = "动物"
def aaa(self):
print("aaa")
class Cat(Animal):
def __init__(self):
print('B构造方法')
self.n = '猫'
#执行父类的构造方法,这样系统会按照上图的规则去父类找init构造方法,所以建议此种方法
super(Cat,self).__init__()
#或者用下面方法执行,此种方法随意性比较强,容易混乱
#Animal.__init__(self)
b = Cat()
# B构造方法
# A构造方法

子类执行父类构造方法

 补充:

子类调用父类的构造方法__init__()的两种方法:

#!/ufr/bin/env python
# -*- coding:utf-8 -*- class Animal:
def __init__(self):
print('A构造方法')
self.ty = '动物' class Cat(Animal):
def __init__(self):
print('B构造方法')
self.n = "猫"
super(Cat, self).__init__() #第一种调用父类的构造方法,推荐这种使用方法,按照python的规则(顺序)去调用
#Animal.__init__(self) #第二种调用父类的构造方法 c = Cat()
print(c.__dict__)
#结果:
# B构造方法
# A构造方法
#{'n': '猫', 'ty': '动物'}

 利用反射导入模块、查找类、创建对象、查找字段

三、多态 

Pyhon不支持Java和C#这一类强类型语言中多态的写法,因为python的变量是不区分类型的,所以python原生支持多态,如下例:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class C1:
def f1(self):
print('C1')
class C2:
def f1(self):
print('C2') def f2(arg):
arg.f1() c1 = C1()
c2 = C2()
f2(c1) #C1
f2(c2) #C2

多态

练习实例:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Weapon:
def __init__(self,name,limit_level,attack,duration):
self.name = name #武器名字
self.limit_level = limit_level #等级限制
self.attack = attack #攻击
self.duration = duration #持久 耐久 class Role: #角色
def __init__(self,name,blood,base_attack = 100):
self.name = name #角色名字
self.blood = blood #血
self.base_attack = base_attack #基础攻击 class Magic(Role): #魔法师
def magic_attack(self,target,weapon):
"""魔法攻击,target为攻击目标,需传入Role的子类对象,weapon,需传入Weapon对象"""
target.blood -= (weapon.attack + self.base_attack) #目标血量降低=攻击方的基础攻击+攻击方的武器攻击 magic1 = Magic('笑熬浆糊',3000)
scarecrow1 = Role('稻草人',500,50)
mofazhang = Weapon('魔法杖',10,50,100) magic1.magic_attack(scarecrow1,mofazhang) #传入被攻击对象和使用武器
print(scarecrow1.blood)
magic1.magic_attack(scarecrow1,mofazhang)
print(scarecrow1.blood)

传奇模仿

扩展:

重载:类中的方法,方法名相同,方法的个数不同,python是不支持重载的,C# JAVA语言中支持重载

重写:子类集成父类可以重写方法,子类对象调用方法的时候优先调用的是子类的方法

四、静态字段、静态方法、类方法、特性(属性)

1、静态字段存在的意义:当类中具有相同字段和值的时候,如果在对象中设置需要每个对象都需要赋值,例如:

静态字段尽量用类去调用,类的方法用对象去调用

#!/ufr/bin/env python
# -*- coding:utf-8 -*- class Province:
country = "China" #创建静态字段,静态字段存储在类中
def __init__(self,name):
self.name = name #创建普通字段,普通字段存储在对象中
def print_name(self):
print('%s' %(self.name))
shandong = Province('山东省')
hebei = Province("河北省")
shandong.print_name() print(hebei.country) #调用静态字段的第1中方法
print(Province.country) #调用静态字段的第2种方法,推荐使用这种,原则是谁的成员谁调用 Province.print_name(shandong) #调用类的方法的第1种方法
shandong.print_name() #调用类的方法的第2种方法,推荐使用这种,原则类的方法由对象调用

静态字段、静态方法、类方法实例:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Province:
country = "China" #创建静态字段,静态字段存储在类中
def __init__(self,name):
self.name = name #创建普通字段,普通字段存储在对象中 def print_name(self):
print('%s' %(self.name)) @staticmethod #静态方法,静态方法相当于普通函数
def static_method(args): #注意静态方法没有self
print(args) @classmethod #类方法
def class_method(cls): #类方法必须有cls参数,代指类
cls.static_method(cls.country) #可以直接调用类的静态方法,把静态字段传入 shandong = Province('山东省')
hebei = Province("河北省")
#调用类的普通方法的两种方式
shandong.print_name()
Province.print_name(hebei) #可以用这种方式调用方法 #调用类的静态方法的两种方式
Province.static_method('类调用静态方法')
shandong.static_method('shandong对象调用静态方法') #调用静态字段的两种方法
print(Province.country)
print(shandong.country) #类的方法有两种调用方式
Province.class_method()
shandong.class_method()
#总结:虽然有两种方式调用,但潜规则是:
#1、对象调用:类中的方法、普通字段
#2、由类调用:静态字段、静态方法、类方法

静态字段、静态方法、类方法

2、特性(属性)

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Province:
def __init__(self,name):
self.name = name @property #特性(属性),只能传递self参数;调用时不用加括号,即以字段的形式调用
def county(self):
if self.name == "山东省":
return ["五莲县","莒县","东港区"]
else:
return["未知"] shandong = Province("山东省")
re = shandong.county #特性(属性)的调用方法
print(re)

特性(属性)实例

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Province:
def __init__(self,name):
self.name = name
if self.name == "山东省":
self.li = ["五莲县","莒县","东港区"]
else:
self.li = ["未知"] @property #特性(属性),只能传递self参数;调用时不用加括号,即以字段的形式调用
def county(self):
return self.li
@county.setter #当设置特性(属性)时调用此函数
def county(self,value):
self.li = value
shandong = Province("山东省")
re1 = shandong.county #特性(属性)的调用方法
print(re1)
re2 = shandong.county = ["日照市","济南市"] #['日照市', '济南市']
print(re2)

改变特性(属性)值的方法

成员总结,类的成员有:

对象中: 一般字段、一般方法

类中:静态字段、静态方法、类方法、特性(属性)

其实就是三大类:字段、方法、特性

那么用类还是对象调用呢:只记住一句话,传self的用对象调用,其他的用类调用

3、面向对象之成员修饰符

成员的前面加两个下划线(__)表示私有的,只能在类的内部调用,外部不能调用,只能在成员所属类的内部能访问,其子类和对象都是不能访问的,字段和方法都是适用的

1)静态字段的私有修饰符

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Province:
__country = 'China'
def __init__(self):
pass
def print_country(self):
return Province.__country p = Province()
#print(Province.__country) #此句报错因为__country是私有静态字段
print(p.print_country())

静态字段修饰符

成员修饰符:所有成员加两个下划线(__)均可变为私有的,变为私有的后只能在本类中被访问,其继承类中也不能访问。

2)如果想调用私有字段或方法怎么办呢?可以在字符或方法名前面加(_类名.)的方法进行调用,但一般不建议这么做,例如:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Province:
__country = 'China'
def __init__(self,name):
self.__name = name
def print_country(self):
return Province.__country p = Province("山东")
print(p._Province__name) #山东

外部调用私有方法或字段

4、类的特殊成员

1)__init__()

2)__del__()

3)__call__(self),类中的call的特殊方法,可以用对象加括号执行。(对象())

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self):
print('__init__')
def __call__(self,*args,**kwargs):
print('__call__')
foo = Foo()
foo() #输出:'__call__'。对象加括号,实际是执行的__call__()函数。两句合起来:Foo()()

4)getitem setitm delitem

foo["key"]  调用 getitem  ;  foo[1:3] 调用getitem ; python2.x中是调用的getslice

foo["key"] = value 调用setitem ; foot[1:3] = [11,22,33]调用的是setitem;python2.x中调用的是setslice

del foo["key"] 调用delitem;  del foor[1:3] 调用的是delitem ; python2.x中调用的是delslice

例如:

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self):
pass
def __getitem__(self,item): #对应的是:foo["key"]
print(item)
def __setitem__(self, key, value): #对应的是:foo["key"] = "value"
print("%s:%s" %(key,value))
def __delitem__(self, key): #对应的是:del foo["key"]
print('delte this' + key) foo = Foo()
foo['key']
foo["key"] = "value"
del foo["key"]

字典方式的执行方法

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self):
pass
def __getitem__(self,item): #对应的是:foo[1:20:2]
print(item.indices(100)) #最大值为100,将slice对象转为元组(1, 20, 2)
def __setitem__(self, key, value): #对应的是:foo[1:3] = [11,22]
emp = key.indices(100)
print(emp,value)
def __delitem__(self, key): #对应的是:del foo[1:3]
print(key.indices(100)) foo = Foo()
foo[1:20:2] #打印:(1, 20, 2)
foo[1:3] = [11,22] #打印输出:(1, 3, 1) [11, 22]
del foo[1:3] #打印输出:(1, 3, 1)
#slice.indices()

切片特殊方法用法

5)类的特殊成员之__dict__  ,查看对象或类中的成员

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self):
self.name = 'sunshuhai'
def hello(self):
pass
foo = Foo()
print(foo.__dict__) #查看对象中的成员
print(Foo.__dict__) #查看类中的成员

__dict__

6)特殊成员之__iter__(self)方法

当for循环类的对象时,实际执行的就是类中的__iter__(self)方法

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __iter__(self):
yield 1
yield 2
yield 3 foo = Foo()
for i in foo: #当循环对象时,实际执行的是特殊方法__iter__(self)
print(i)

特殊方法__iter__(self)

7)类的特殊成员之__str__(self)

在用print打印对象,或将对象转为字符串时,会自动执行__str__(self)方法

#!usr/bin/env python
# -*- coding:utf-8 -*-
class Foo:
def __init__(self,ef):
self.ef = ef
def __str__(self):
return self.ef exception = Foo('出错了。。。。')
print(exception) #出错了。。。。,实际调用的是__str__(self)方法

类的特殊方法__str__(self)

8)了解:类的特殊成员之new和metaclass

类是由对象Type创建的

【python之路面向对象】初级篇的更多相关文章

  1. python之路 面向对象进阶篇

    一.字段 字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同, 普通字段属于对象 静态字段属于类 class Province: # 静态字段 countr ...

  2. 第四篇:python 高级之面向对象初级

    python 高级之面向对象初级   python 高级之面向对象初级 本节内容 类的创建 类的构造方法 面向对象之封装 面向对象之继承 面向对象之多态 面向对象之成员 property 1.类的创建 ...

  3. Python 正则表达式入门(初级篇)

    Python 正则表达式入门(初级篇) 本文主要为没有使用正则表达式经验的新手入门所写. 转载请写明出处 引子 首先说 正则表达式是什么? 正则表达式,又称正规表示式.正规表示法.正规表达式.规则表达 ...

  4. python 高级之面向对象初级

    python 高级之面向对象初级 本节内容 类的创建 类的构造方法 面向对象之封装 面向对象之继承 面向对象之多态 面向对象之成员 property 1.类的创建 面向对象:对函数进行分类和封装,让开 ...

  5. Python之路【第九篇】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy   Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用 ...

  6. 转载 Python 正则表达式入门(初级篇)

    Python 正则表达式入门(初级篇) 本文主要为没有使用正则表达式经验的新手入门所写.转载请写明出处 引子 首先说 正则表达式是什么? 正则表达式,又称正规表示式.正规表示法.正规表达式.规则表达式 ...

  7. 【Python之路】特别篇--Python面向对象(初级篇)

    概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发“更快更好更强...” 面向过程编程最易被初学 ...

  8. python 面向对象初级篇

    Python 面向对象(初级篇) 概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发" ...

  9. 【Python之路】特别篇--Python面向对象(进阶篇)

    上一篇<Python 面向对象(初级篇)>文章介绍了面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个“函数”供使 ...

  10. Python之路【第九篇】:Python面向对象

    阅读目录 一.三大编程范式 编程范式即编程的方法论,标识一种编程风格: 大家学习了基本的python语法后,大家可以写python代码了,然后每个人写代码的风格不同,这些不同的风格就代表了不同的流派: ...

随机推荐

  1. 一个简单的基于Tornado二手房信息统计项目的开发实现

    Purpose 最近因为要买房子,扫过了各种信息,貌似lianjia上的数据还是靠点谱的(最起码房源图片没有太大的出入),心血来潮想着做几个图表来显示下房屋的数据信息,顺便练练手. 需求分析 1从li ...

  2. MATLAB 中自定义函数的使用

    MATLAB在文件内部(在函数内部)定义函数,但文件名以开头函数来命名,与Java中每个文件只能有一个公开类,但在文件内部还是可以定义其他非公开类一个道理. 无参函数 do.m function do ...

  3. c#窗体开发

    奇: 常用控件的使用(期间参杂着VS快捷键/常用设置) 快捷键:引用命名空间:shift+alt+F10 断点:F9 调试:F5 逐句调试(每行代码一次跳转):F11 逐过程调试:F10 重构提取方法 ...

  4. JS控制语句 编程练习 学生数据,分别是姓名、性别、年龄和年级,接下来呢,我们要利用JavaScript的知识挑出其中所有是大一的女生的的名字哦。

    编程练习 在一个大学的编程选修课班里,我们得到了一组参加该班级的学生数据,分别是姓名.性别.年龄和年级,接下来呢,我们要利用JavaScript的知识挑出其中所有是大一的女生的的名字哦. 学生信息如下 ...

  5. .net Cache的用法

    HttpContext.Current.Cache 使用方法 .net Cache 怎么使用 /// <summary>        /// 简单创建/修改Cache,前提是这个值是字符 ...

  6. Django流程

    开始具体的代码之旅前,先来宏观地看下Django是如何处理Http Resquest的,如下图: 假设你已经在浏览器输入了 http://127.0.0.1:8000/polls/,接下来浏览器会把请 ...

  7. 【CQOI2015】选数

    题面 Description 我们知道,从区间[L,H](L和H为整数)中选取N个整数,总共有(H-L+1)^N种方案.小z很好奇这样选出的数的最大公约数的规律,他决定对每种方案选出的N个整数都求一次 ...

  8. 高效开发 Dubbo?用 Spring Boot 可得劲!

    不仅简化了 Dubbo 基于 xml 配置的方式,也提高了日常开发效率,甚至提升了工作幸福感. 为了节省亲爱的读者您的时间,请根据以下2点提示来阅读本文,以提高您的阅读收获效率哦. 如果您只有简单的 ...

  9. 反编译之paktool工具

    1.官网配置mac教程https://ibotpeaches.github.io/Apktool/install/ (1)右键选择:链接储存为(命名:apktool,格式:选择所有文件): (2)下载 ...

  10. JEECG 4.0 版本发布,JAVA快速开发平台

    JEECG 4.0 版本发布,系统全面优化升级,更快,更稳定!         导读                               ⊙平台性能优化,系统更稳定,速度闪电般提升      ...