pythonOOP基础和进阶

本文主要是介绍pythonOOP基础和进阶，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

【●】OOP基础
面向对象编程 Object-Oriented Programming(OOP)
OOA   OOD  OOP 
分析 设计 编程

编程思想： 
面向过程: 
1 分析出解决问题的步骤，然后逐步解决。 例如：筹办婚礼 1、发请柬(贴照片 设计邀请语 制作请柬 发送请柬) 2、宴席 （找厨师 购买食材 设计菜品 准备餐具 桌椅板凳） 3、婚礼仪式 （找主持人 设计仪式流程 有哪些环节）。
2 公式：程序 = 算法 + 数据结构 
3 优点：所有环节、细节自己掌控 
4 缺点：面面俱到 要考虑所有细节、工作量大

面向对象:
1 指定解决问题的人，分配工作 例如：筹办婚礼 1、发请柬--->摄影公司 （对象） 2、宴席----->酒店（对象） 3、婚礼仪式->婚庆公司 （对象）
2 公式：程序 = 对象 + 交流（交互）

3 优点：分类解决问题 各司其职 、高复用

1.基本概念
 ●  类（Class）：  类，具有相同属性和行为的对象的统称，是抽象的概念。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
 ◆ 属性=数据  行为=方法

 ● 实例化：创建一个类的实例，类的具体对象。
 ● 方法：类中定义的函数。
 ● 对象：类的具体实例，归属某个类别的个体。对象包括两个数据成员（类变量和实例变量）和方法。  
 ● 类是创建对象的“模板”。 类里包括：个体的属性 和 个体的行为 数据 方法
 

● 类：拥有相同属性和行为的对象分为一组，即为一个类

      /-------> BYD  E6(京A.88888)    实例(也叫对象)
车(类)
      \-------> BWM  X5(京B.66666)    实例(也叫对象)

       /-------> 100    (对象)
int(类)
       \-------> 200    (对象)
       
        /------> 张三   (对象)   
人(类)
        \------> 李四      (对象)

2.创建类
 ● 使用 class 语句来创建一个新类， class 之后为类的名称并以冒号结尾
 ● 类名建议使用驼峰形式
 class 类名():
   变量名=值
   # 类里有固定的内置方法 ：内置方法的名称和功能是固定的。
                            内置方法的功能体内容可以自己定义。
   def 函数名():     #自定义方法
   函数体

3.使用类
创建类的对象（实用类），创建的对象可以使用类里数据和方法
对象名 = 类名

[root@dc python]# vim class.py
class person():    #定义类 名叫person
    money='1亿'    #类里的数据（数据是对象的属性）

    def running(self,name,gl):   #类里的方法（方法是对象的行为）
        print(f'{name}今天跑了{gl}公里')

#创建类的对象，一个类可以创建很多对象，对象可以使用类提供的数据和方法。
p1 = person()   #创建类的第1个对象
p2 = person()   #创建类的第2个对象

print('定个小目标赚',p1.money)
p1.running('静丫丫',28)  #对象调用类的方法时，方法有形参要传给形参赋值。
p2.running('小小',50)

[root@dc python]# python3 class.py
定个小目标赚 1亿
静丫丫今天跑了28公里
小小今天跑了50公里

◆把已有的类当做模块使用
[root@dc python]# vim myclass.py
在创建类的对象上面添加以行代码 if

[root@dc python]# vim class2.py
import myclass   #把定义了类的文件当模块导入

p1 = myclass.person()   #创建对象

print('p1的小目标赚:',p1.money)  #使用类的数据
p1.running("张三丰",100)      #使用类的方法

[root@dc python]# python3 class2.py
定个小目标赚 1亿
张三丰今天跑了100公里

4.继承：类的重要特点
子类会继承父类的数据和方法

4.1单继承
class 类名（父类):  #括号里的类  就是当前类的父类
      当前类的功能体
注：当是一个类的子类后，就可以使用父类的数据和方法

[root@dc classdir]# vim class3.py
class shi_fu():  #师傅类
    tools="百香锅"
    def make_cake(self):
            print("独门配置 百年传承")

class tu_di(shi_fu): #徒弟类 pass ，
#括号里的类名 就是当前类的父类  反过来说当前创建的类是子类
        pass

td1 = tu_di()  #创建徒弟对象
print("我的武器是:",td1.tools)
td1.make_cake()  #可以调用父类的方法
[root@dc classdir]# python3 class3.py
我的武器是: 百香锅
独门配置 百年传承

4.2多重继承
在创建新类时，可以有多个父类
class 类名（类名列表）：#括号里的就是父类的名
   类的功能代码（定义当前类的数据和方法）

[root@dc classdir]# vim class4.py

class father():
    def running(self):
        x = "开着劳斯莱斯 跑!!!"
        return x

class mother():
    def woker(self):
        y = "开着法拉利去上班"
        return y

class son(father,mother):
    pass

s1 = son()
s2 = son()

#s1.woker()
#s2.running()

print("大儿子去上班了",s1.woker())
print("小儿子泡妞去了",s2.running())

[root@dc classdir]# python3 class4.py

二、特殊方法
1. _init_方法

2. _str_方法

3. _call_方法
4. _del_ 方法

● 魔法方法:(就是类的内置方法)具体特殊功能的函数, 函数名都是事先定义好的
注意：内置方法功能是固定的，程序员可以做的是方法的内容。

1.魔法方法 _ init _() #创建对象后，对自动调用类里的__init__方法。
作用初始化对象，创建对象时默认调用，

例1.创建学生类 student
student类的对象 有个属性 班级名称，
对象的班级名称默认就是nsd2103
[root@dc classdir]# vim student.py

class  student():
    def __init__(self):
        self.classname="nsd2103"

    def prinfo(self):
            print("我在%s班"%self.classname)

s1 = student()
s1.prinfo()

s2 = student()
s2.prinfo()

#s3 = student()
#s3.prinfo("nsd2102")
[root@dc classdir]# python3 student.py
我在nsd2103班
我在nsd2103班

例2.可以自定义的班级的
[root@dc classdir]# vim student.py
class  student():
    def __init__(self,banji):
            self.classname=banji

    def prinfo(self):
            print("我在%s班"%self.classname)

s1 = student("nsd2103")
s1.prinfo()

s2 = student("nsd2101")
s2.prinfo()

#s3 = student()
#s3.prinfo("nsd2102")
[root@dc classdir]# python3 student.py
我在nsd2103班
我在nsd2101班

例3.可以自定义班级、方向
[root@dc classdir]# python3 student.py

class  student():
    def __init__(self,banjiname,fxname):
            self.classname=banjiname
            self.sd=fxname

    def prinfo(self):
            print("我在%s班,学的是%s"%(self.classname,self.sd))

s1 = student("nsd2103","云计算")
s2 = student("nsd2101","人工智能")
s3 = student("nsd2102","黑盒测试")

s1.prinfo()
s2.prinfo()
s3.prinfo()
[root@dc classdir]# python3 student.py
我在nsd2103班,学的是云计算
我在nsd2101班,学的是人工智能
我在nsd2102班,学的是黑盒测试

2.魔法方法 _ str _() #作用输出return 的返回值 默认输出对象的内存地址 
plj = person("girl",20) print(plj) #

[root@dc classdir]# vim student.py
class  student():
    def __init__(self,banjiname,fxname):
            self.classname=banjiname
            self.sd=fxname
    def __str__(self):
        return "aaaaaaxxxxx"

    def prinfo(self):
            print("我在%s班,学的是%s"%(self.classname,self.sd))

s1 = student("nsd2103","云计算")
s2 = student("nsd2101","人工智能")
s3 = student("nsd2102","黑盒测试")

s1.prinfo()
s2.prinfo()
s3.prinfo()

print("#" * 20)
print(s1)
[root@dc classdir]# python3 student.py
我在nsd2103班,学的是云计算
我在nsd2101班,学的是人工智能
我在nsd2102班,学的是黑盒测试
####################
aaaaaaxxxxx

3.魔法方法 _ call _() 把类的对象当做方法执行的时候，会自带执行__call__()。 将实例当成函数来调用，执行此函数内的代码
[root@dc classdir]# vim student.py

class  student():
    def __init__(self,banjiname,fxname):
            self.classname=banjiname
            self.sd=fxname

    def __str__(self):
        return "aaaaaaxxxxx"

    def __call__(self):
            print(self.classname,self.sd)

    def prinfo(self):
            print("我在%s班,学的是%s"%(self.classname,self.sd))

s1 = student("nsd2103","云计算")
s2 = student("nsd2101","人工智能")
s3 = student("nsd2102","黑盒测试")
s1.prinfo()
s2.prinfo()
s3.prinfo()

print("#" * 20)
print(s1)
print(s2)
print(s3)

print("#" * 20)
s1()
s2()
s3()
[root@dc classdir]# python3 student.py
我在nsd2103班,学的是云计算
我在nsd2101班,学的是人工智能
我在nsd2102班,学的是黑盒测试
####################
aaaaaaxxxxx
aaaaaaxxxxx
aaaaaaxxxxx
####################
nsd2103 云计算
nsd2101 人工智能
nsd2102 黑盒测试

4.魔法方法 _ del _() 删除对象时自动调用del() 方法 
[root@dc classdir]# vim student.py
class  student():
    def __init__(self,banjiname,fxname):
            self.classname=banjiname
            self.sd=fxname

    def __str__(self):
        return "aaaaaaxxxxx"

    def __call__(self):
            print(self.classname,self.sd)

    def __del__(self):
            print("类的对象被删除!!!")

    def prinfo(self):
            print("我在%s班,学的是%s"%(self.classname,self.sd))

s1 = student("nsd2103","云计算")
s2 = student("nsd2101","人工智能")
s3 = student("nsd2102","黑盒测试")
s1.prinfo()
s2.prinfo()
s3.prinfo()

print("#" * 20)
print(s1)
print(s2)
print(s3)

print("#" * 20)
s1()
s2()
s3()
[root@dc classdir]# python3 student.py
我在nsd2103班,学的是云计算
我在nsd2101班,学的是人工智能
我在nsd2102班,学的是黑盒测试
####################
aaaaaaxxxxx
aaaaaaxxxxx
aaaaaaxxxxx
####################
nsd2103 云计算
nsd2101 人工智能
nsd2102 黑盒测试
类的对象被删除!!!
类的对象被删除!!!
类的对象被删除!!!

二、绑定方法

1.构造器方法
 ● 当实例化类的对象是，构造器方法默认自动调用
 ● 实例本身作为第一个参数，传递给self

2.其他绑定方法
 ● 类中定义的方法需要绑定在具体实例，由实例调用
 ● 实例方法需要明确调用

【●】OOP进阶
一、组合和派生
1.什么是组合
 ● 类被定义后，目标就是要把它当成一个模块来使用，并把这些对象嵌入到你的代码中去。
 ● 组合就是让不同的类组合并加入到其他类中来增加功能和代码重用性。
 ●可以在一个大点的类中创建其他类的实例，实现一些其他属性和方法来增强对原来的类对象。

2.组合应用
●两个类明显不同
●一个类是另一个类的组件

【●】re模块
一、正则表达式
用来描述数据共性特点的表达式。
表达式由固定符号组成。
每种符号表示了固定意义。

●正则表达式的作用
在数据里过滤与表达式匹配的数据。

正则表达--元字符
单个字符
记号    说 明
.    匹配任意字符（换行符除外）
[…x-y…]    匹配字符组里的任意字符
[^…x-y…]    匹配不在字符组里的任意字符
\d    匹配任意数字，与[0-9]同义
\w    匹配任意数字字母字符，与[0-9a-zA-Z_]同义
\s    匹配空白字符，与[ \r\v\f\t\n]同义

一组字符
记号    说 明
literal    匹配字符串的值
re1|re2    匹配正则表达式re1或re2
*    匹配前面出现的正则表达式零次或多次
+    匹配前面出现的正则表达式一次或多次
?    匹配前面出现的正则表达式零次或一次
{M, N}    匹配前面出现的正则表达式至少M次最多N次

其他元字符
记号    说 明
^    匹配字符串的开始
$    匹配字符串的结尾
\b    匹配单词的边界
()    对正则表达式分组，把正则表达式作为整体匹配，保存与正则表达式匹配        的数据 专业的叫法后向引用
\nn    匹配已保存的子组

● 正则符号 回顾 

[root@teacher ~]# cat /code/re.txt
tam tbm tcm txm txym tom tomorrow t
@tom
nb
atom  btom  ftomw  ttomz
NB
666888999
t0m t1m t2m T8m t10m
t m t_m t*m t$M  t-m t@m
tabm tababm tabababm  tababababm
tm ttm tttm tttttm ttttttm
gd gad gacd gacacd gacacacd gacacacd  gacacacd gacacacacd
[root@teacher ~]#

正则匹配例子
grep "^a" /code/re.txt
grep '.' /code/re.txt
grep '[at]' /code/re.txt
grep '[abc]' /code/re.txt
grep '[a-c]' /code/re.txt
grep '[a-z]' /code/re.txt
grep '[A-Z]' /code/re.txt
grep '[a-Z]' /code/re.txt
grep '[a-zA-Z]' /code/re.txt
grep '[0-9]' /code/re.txt
grep '[0-10]' /code/re.txt
grep '[0-19]' /code/re.txt
grep '[0-9]' /code/re.txt
grep '[0123456789]' /code/re.txt
grep '[_]' /code/re.txt
grep '[-]' /code/re.txt
grep '[_-@]' /code/re.txt
grep '[1-9]' /code/re.txt
grep '[-_@]' /code/re.txt
grep '[^0-9]' /code/re.txt
grep '^[0-9]' /code/re.txt
grep '^t' /code/re.txt
grep '^[t0-9]' /code/re.txt
grep '[0-9]' /code/re.txt
grep 'm' /code/re.txt
grep 'abc' /code/re.txt
grep 'ac' /code/re.txt
grep '^t\|^[0-9]' /code/re.txt
grep '^t\|d$' /code/re.txt
grep 'd$' /code/re.txt
grep '.$' /code/re.txt
grep ' $' /code/re.txt
grep 'd$' /code/re.txt
grep '^t\|d$' /code/re.txt
grep 'g.\?d' /code/re.txt
grep '\btom' /code/re.txt
grep '\btom\b' /code/re.txt
grep '^.' /code/re.txt
grep [afw] /code/re.txt
grep [a-Z0-9] /code/re.txt
grep ^ /code/re.txt
grep . /code/re.txt
grep ^. /code/re.txt
grep ^[a-Z0-9] /code/re.txt
grep [^a-Z0-9] /code/re.txt
grep a /code/re.txt
grep aaa /code/re.txt
grep ... /code/re.txt
grep ... /code/re.txt
grep ^t /code/re.txt
grep $ /code/re.txt
grep .$ /code/re.txt
grep ^. /code/re.txt
grep ^..$ /code/re.txt
grep ^..$ /code/re.txt
grep 'g.d' /code/re.txt
grep 'g.*d' /code/re.txt
grep 'gacd' /code/re.txt
grep 'gacd' /code/re.txt
grep 'gac*d' /code/re.txt
grep 'g(ac)*d' /code/re.txt
grep 'g\(ac\)*d' /code/re.txt
grep 'g\(ac\)+d' /code/re.txt
grep 'g\(ac\)\+d' /code/re.txt
grep 'g\(ac\)\?d' /code/re.txt
grep 'g\(ac\)\{2\}d' /code/re.txt
grep 'g\(ac\)\{2,\}d' /code/re.txt
grep 'g\(ac\)\{2,3\}d' /code/re.txt
grep 'g\(ac\)\{,3\}d' /code/re.txt
grep 'tom' /code/re.txt
grep '\btom' /code/re.txt
grep 'tom' /code/re.txt
grep '\btom' /code/re.txt
grep '\btom\b' /code/re.txt
grep '^.' /code/re2.txt
grep '^..*' /code/re2.txt
grep '(^.)(.*)' /code/re2.txt
grep '^..*' /code/re2.txt
grep '^.' /code/re.txt

◆ ()
()  功能1  是把正则表达式作为整体匹配
          grep 'gac*d'  /code/re.txt 
          grep 'g\(ac\)*d' /code/re.txt
        

     功能2  保存与正则表达式匹配的数据 专业叫法后向引用
            按照括号的顺序 获取保存的数据
            (正则表达式)(正则表达式)(正则表达式)
                \1       \2          \3 
例子            
每行的第1个字符 都用小括号 () 括起来  后边剩下的所有都有[] 括起来
例如  (A)[BCEFJ]  
vim  re2.txt   
abcefgj
1234567890
ABCDEFG
WERSFSAFAW
:%s/\(^.\)\(.*\)/(\1)[\2]/

替换后的效果
(a)[bcefgj]
(1)[234567890]
(A)[BCDEFG]
(W)[ERSFSAFAW]

二、核心函数和方法

获取数据里与正则表达式匹配的数据
import re
函数包括： match() search()  group()   findall()  finditer()  compile()
           split()  sub() 

1.match函数
match()函数 尝试用正则表达式模式从字符串的开头匹配，如果匹配成功，则返回一个匹配对象；否则返回None

>>> import  re
>>> m = re.match('foo', 'food')           #成功匹配
>>> print(m)
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> 
>>> m = re.match(‘foo’, ‘seafood’)      #未能匹配
>>> print(m)
None

例子2
>>> import re
>>> re.match('f..','food buyfood goodfood eatfood')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> 
>>> re.match('f..','buyfood goodfood eatfood')
>>> 
>>> m=re.match('f..','buyfood goodfood eatfood')
>>> print(m)
None
>>> 
>>> m2=re.match('f..','food buyfood goodfood eatfood')
>>> m2.group()
'foo'
>>>

2.search函数
search()函数: 在字符串中查找正则表达式模式的第一次出现，如果匹配成功，则返回一个匹配对象；否则返回None

>>> import re
>>> m = re.search('foo', 'food')
>>> print(m)
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> 
>>> m = re.search(‘foo’, ‘seafood’)      #可以匹配在字符中间的模式
>>> print(m)
<_sre.SRE_Match object; span=(3, 6), match='foo'>

例子2
>>> re.search('f..','food buyfood goodfood eatfood')
<_sre.SRE_Match object; span=(0, 3), match='foo'>
>>> 
>>> m1 = re.search('f..','food buyfood goodfood eatfood')
>>> 
>>> m2 = re.search('f..','buyfood goodfood eatfood')
>>> 
>>> m1.group()
'foo'
>>> m2.group()
'foo'
>>> 

3.group方法
group方法：使用match或search匹配成功后，返回的匹配对象可以通过group方法获得匹配内容

>>> import re
>>> m = re.match('foo', 'food')
>>> print(m.group())
foo

>>> m = re.search('foo', 'seafood')
>>> m.group()
'foo'

4.findall函数
findall函数：在字符串中查找正则表达式模式的所有出现；返回一个匹配对象的列表

>>> import re
>>> m = re.search('foo', 'seafood is food')
>>> print(m.group())    #search只匹配模式的第一次出现
foo
>>> 
>>> m = re.findall(‘foo’, ‘seafood is food’)  #获得全部的匹配项
>>> print(m)
['foo', 'foo']

例子2
>>> m1 = re.findall('f..','food buyfood goodfood eatfood')
>>> 
>>> m2 = re.findall('f..','buyfood goodfood eatfood')
>>> 
>>> print(m1)
['foo', 'foo', 'foo', 'foo']
>>> 
>>> print(m2)
['foo', 'foo', 'foo']
>>> 

5.finditer函数
finditer()和findall()函数有相同的功能，但返回的不是列表而是迭代器；对于每个匹配，该迭代器返回一个匹配对象

>>> m = re.finditer('foo','food buyfood goodfood eatfood')
>>> for i in m:
...     print(i.group())
... 
foo
foo
foo
foo
>>>

6.compile函数
compile函数: 对正则表达式模式进行编译，返回一个正则表达式对象 不是必须要用这种方式，但是在大量匹配的情况下，可以提升效率

>>> import re
>>> patt = re.compile('foo')
>>> m = patt.match('food buyfood goodfood eatfood')
>>> m.group()
'foo'
>>>

例子2
>>> patt=re.compile('f..')
>>> m = patt.findall('buyfood goodfood eatfood')
>>> print(m)
['foo', 'foo', 'foo']

7.split方法
split方法: 根据正则表达式中的分隔符把字符分割为一个列表，并返回成功匹配的列表 字符串也有类似的方法，但是正则表达式更加灵活

>>> import re      #使用 . 和 - 作为字符串的分隔符
>>> mylist = re.split('\.|-', 'hello-world.data')
>>> print(mylist)
['hello', 'world', 'data']
>>> L1 = re.split('-','hello-world.data')
>>> L1
['hello', 'world.data']

8.sub方法
sub方法 把字符串中所有匹配正则表达式的地方替换成新的字符串

>>> import re
>>> m = re.sub('girl', 'woman', 'she is a girl  beautiful girl')
>>> print(m)
she is a woman  beautiful woman
>>> 
>>> m = re.sub('^.','S','she is a girl beautful girl')
>>> m
'She is a girl beautful girl'
>>>
0
-----------------------------------------------------------------

匹配MAC地址的正则表达式
使用十六进制数 表示  必须知道十六进制数的范围
0 1 2 3 4 5 6 7 8 9 a b c d e f 或A B C D E F

 正确格式：
  每2位十六进制数为一组 共由6组组成 每组之间使用：分割
例如：40：8d：5c：da：0e：3b

这篇关于pythonOOP基础和进阶的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！