Python高级教程（一）

友友们，Python入门教程已经更新完了，接下来我们将学习高级教程。

一、面向对象

1、面向对象技术简介

• 类：用来描述相同的属性和方法的对象的集合。对象是类的实例
• 方法：类中定义的函数
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体外。
• 数据成员：类变量或者实例变量用于处理类及实例对象的相关数据
• 方法重写：如果父类继承的方法不能满足子类的需求可以进行改写，这个过程叫方法的覆盖，也称为方法的重写
• 局部变量：定义在方法中的变量
• 实例变量：在类中声明，属性是用变量来表示的，这种变量称为实例变量。实例变量就是用一个self修饰的变量
• 继承：派生类（子类）继承基类（父类）的字段和方法。
• 实例化：创建一个类的实例。类的具体对象
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

2、类定义

语法格式：

class ClassName:

        statement

3、类对象

类对象支持两种操作： 属性引用和实例化

属性引用的标准语法：obj.name

#类的定义
class Myclass:
    a=555
    def f(self):
        return 'happy day'
#实例化
x=Myclass()
#访问类的属性和方法
print(x.a)
print(x.f())
#输出结果
555
happy day

类中有一个特殊方法（构造方法）__init__()，该方法在类实例化时会自动调用。__init__()方法可以有参数，参数通过__init__()传递到类的实例化操作上。

#类的定义
class Myclass:
    def __init__(self,a,b):
        self.a=a
        self.b=b
#实例化
x=Myclass(555,'happy day')
#访问类的属性和方法
print(x.a)
print(x.b)
#输出结果
555
happy day

self代表类的实例而非类，类的方法与普通的函数只有一个特别的区别：它们必须有一个额外的参数名称（self）

4、类的方法

在类的内部使用def关键字来定义一个方法与一般的函数定义不同，类方法必须包含参数self。

#类的定义
class Myclass:
    #定义基本属性
    name=''
    age=0
    #定义私有属性
    __weight=0
    #定义构造方法
    def __init__(self,name,age,__weight):
        self.n=name
        self.a=age
        self.w=__weight
    def speak(self):
        print("%s有%d岁了"%(self.name,self.age))
x=Myclass('john',10,50)
x.speak()
#输出结果
John有10岁了

在属性前加__变成私有属性，私有属性在类外部无法直接进行访问。、

5、继承

派生类的语法格式：

class DerivedClassName(BaseClassName):

        statement

 派生类（子类）DerivedClassName会继承父类（基类）BaseClassName的属性和方法

6、多继承

多继承的语法格式

class DerivedClassName（BaseClassName1，BaseClassName2，BaseClassName3）：

        statement

7、方法重写 

如果父类的方法不能满足你的需求，可以在子类重写你父类的方法

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
#输出结果
调用子类方法
调用父类方法

二、命名空间和作用域

1、命名空间

命名空间是从名称到对象的映射，大部分的命名空间都是通过Python字典来实现的。

它的优点是提供在项目中避免名字冲突的一种方法，且各个命名空间是独立的，没有任何关系所以一个命名空间不能有重名。

三种命名空间：

• 内置名称：Python语言内置的名称，比如函数名和异常名称。
• 全局名称：模块中定义的名称记录了模块的变量，比如函数、类、其它导入的模块、常量。
• 局部变量：函数中定义的名称记录了函数的变量，比如函数的参数和局部定义的变量。

三种命名空间查找顺序：局部》全局》内置

命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期结束。因此，我们不能从外部命名空间访问内部命名空间的对象。

#全局名称：
var1=5
def function():
    #局部变量：
    var2=5
    def inner_function():
        #内置变量
        var3=5

2、作用域

作用域就是一个Python程序可以直接访问命名空间的正文区域。

Python的作用域有四种：

• L（Local）：最内层，包含局部变量，比如函数或者方法内部
• E(Encloding)：包含非局部(nonlocal)和非全局(nonglobal)的变量。比如两个嵌套函数，一个函数A里面又包含的一个函数B，那么对于B中名称来说A的作用域就是nonlocal
• G(Global):当前脚本的最外层，比如当前模块的全局变量
• B(Built-in)：包含了内置的变量和关键字，最后被搜索

作用域的查找顺序：L>E>G>B

#全局作用域
var1=5
def outer():
    
    #闭包函数外的函数中
    var2=4
    def inner():
        
        #局部作用域
        var3=3

在Python中只有模块、类、函数才会引入新的作用域，其它的代码块是不会引入新的作用域的。

3、全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在被声明的函数内部访问，而全局变量可以在整个程序内访问。调用函数时，所有函数内声明的变量名称都将被加入到作用域中。

total=0 #全局变量
def sum(a,b):
    total=a+b #这里的total是局部变量
    print(total) #函数内是局部变量
    return total
sum(10,30) #调用函数
print(total) #函数外是全局变量
#输出结果
40
0

4、global和nonlocal关键字

当局部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字。

a=5
def function():
    global a #使用global关键字声明
    print(a)
    a=123
    print(a)
function()
print(a)
#输出结果
5
123
123

如果想修改嵌套作用域中的变量则要用nonlocal关键字。

def function():
    a=123
    def inner_function():
        nonlocal a #使用nonlocal关键字声明
        a=456
        print(a)
    inner_function()
    print(a)
function()
#输出结果
456
456

三、标准库

1、文件通配符

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表。

import glob
print(glob.glob('*.py'))
#输出结果
['baoliuzi.py', 'base64.py', 'eee.py', 'findEmploy.py', 'test3.py']

输出全部后缀为.py的文件。

2、命令行参数

通过脚本经常调用命令行参数，这些命令行参数以链表形式存储在sys模块的argv变量中。

import sys
>>> print(sys.argv)
#输出结果
['demo.py', 'one', 'two', 'three']

3、字符串正则匹配

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案。

import re
print(re.sub())

4、数学

math模块为浮点运算提供了对底层C函数库的访问。

import math
print(math.cos(math.pi/4))
#输出结果
0.7071067811865476

random模块提供了生成随机数的工具

import random
print(random.choice(['apple','pear','banana','hello']))
#输出结果
banbana

四、正则表达式

正则表达式是一个特殊的字符序列，它能帮组你方便的检查一个字符串是否与某种模式匹配。

re模块使Python语言拥有全部的正则表达式功能。compile函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象，该对象拥有一系列方法用于正则表达式匹配和替换。

1、re.match函数

re.match从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match（）就会返回none。匹配成功则返回一个匹配的对象。

re.match(pattern,string,flags=0)

参数说明：pattern：匹配正则表达式，string：要匹配的字符串，flags：标志位，用于控制正则表达式的匹配方式。如：是否区分大小写，多行匹配等。

import re
print(re.match('www','www.taobao.com').span())#在起始位置匹配
print(re.match('com','www.taobao.com'))#不在起始位置匹配
#输出结果
(0, 3)
None

2、re.search方法

re.search扫描整个字符串并返回第一个成功的匹配。

re.search(pattern,string,flags=0)

import re
print(re.search('www','www.taobao.com').span())#在起始位置匹配
print(re.search('com','www.taobao.com').span())#不在起始位置匹配
#输出结果
(0, 3)
(11, 14)

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式则匹配失败，而re.search匹配整个字符串直到找到一个匹配。

3、检索和替换

Python的re模块提供了re.sub用于替换字符串中的匹配项。

re.sub(pattern,repl,string,count=0,flags=0)

参数说明：repl：替换的字符串，也可以是一个函数。string：要被查找替换的原始字符串。count：模式匹配后替换的最大次数，默认0表示替换所有的匹配。

import re
phone="1866654265#######"
a=re.sub(r'#','',phone)
print("电话号码为：",a)
#输出结果
电话号码为： 1866654265

4、compile（）函数

compile函数用于编译正则表达式，生成一个正则表达式对象，供match（）和search（）两个函数使用。

re.compile(pattern,[,flags])

参数说明：pattern：一个字符串形式的正则表达式。flags：可选，表示匹配模式，比如忽略大小写，多行模式等。

import re
pattern=re.compile(r'\d+')#用于匹配一个数字
a=pattern.match('one124two45three456',2,10)#从e开始匹配
print(a)
a=pattern.match('one124two45three456',3,10)#从1开始匹配
print(a)
#输出结果
None
<re.Match object; span=(3, 6), match='124'>
 
 

5、findall

在字符串中找到正则表达式所匹配的所有子串并返回一个列表。如果多个匹配模式则返回元祖列表，如果没有找到匹配的则返回空列表。

re.findall(pattern,string,flags=0)

import re
pattern=re.compile(r'\d+')
a1=pattern.findall('www.123taobao456')
a2=pattern.findall('www.123taobao456',6,10)
print(a1)
print(a2)
#输出结果
['123', '456']
['3']