前言

os.path是平台独立的文件名管理库，使用该库能够很方便来处理多个平台上的文件。即使程序不打算在平台之间移值，也应当使用os.path库来完成可靠的文件名解析。

本篇博文将详细介绍os.path库的用法。

解析路径的基本用法

os.path中的第一组函数可以用来将表示文件名的字符串解析为文件名的各个组成部分。这些函数并不要求路径真正存在，它们只是单纯的处理字符串而已。

常用的解析函数如下：

import os

paths = ["D:/document/csdn/opencv/20/10.png",
         "D:/document/csdn/opencv/20/",
         "D:/document/csdn/opencv/20",
         "d:" + os.sep + "10" + os.extsep + "txt",
         os.pardir + os.sep + "10" + os.extsep + "txt",
         os.curdir + os.sep + "10" + os.extsep + "txt", ]

for path in paths:
    print(path)
    print(os.path.split(path))

运行之后，效果如下：

os.sep：路径分隔符，字符串“/”或者“\”

os.extsep：文件名后缀的字符串“.”（点）

os.pardir：目录上一级，字符串“…”（双点）

os.curdir：当前目录，字符串“.”（点）

os.path.split：分割路径为两部分元组，第2个元素为路径最后的部分，可能是文件名，可能是空。第2个元素是前面的路径不包括文件名。

dirname()与basename()

当然，我们还可以不使用os.path.split进行分割，直接使用dirname()与basename()函数返回这两部分，具体代码如下：

import os

paths = ["D:/document/csdn/opencv/20/10.png",
         "D:/document/csdn/opencv/20/",
         "D:/document/csdn/opencv/20",
         "d:" + os.sep + "10" + os.extsep + "txt",
         os.pardir + os.sep + "10" + os.extsep + "txt",
         os.curdir + os.sep + "10" + os.extsep + "txt", ]

for path in paths:
    print(path)
    print(os.path.dirname(path))
    print(os.path.basename(path))

运行之后，效果如下：

dirname()：返回文件路径最后一个分隔符前的路径

basename()：返回文件路径最后一个分隔符后面的内容

splitext()与commonprefix()

splitext()函数与split()类似，不过它会根据扩展名分隔符而不是目录分隔符来分解路径。一般我们用该方法与前面的basename()结合获取文件名。具体代码如下：

import os

path = "D:/document/csdn/opencv/20/10.png"
filename = os.path.basename(path)
print(os.path.splitext(filename))

这里，我们会得到文件名以及后缀。运行效果如下：

当然，这是在存在文件名的情况下，如果只是单纯的路径，我们会得到空字符串。而如果直接跳过basename()，我们会得到前面的路径加文件名。

至于commonprefix()函数，它是用于判断一堆路径是否具有统一的公共前缀，如果有返回公共前缀。具体代码如下：

import os

paths = ["D:/document/csdn/opencv/20/10.png",
         "D:/document/csdn/opencv/20/",
         "D:/document/csdn/opencv/20",]

for path in paths:
    print(path)
print("公共前缀")
print(os.path.commonprefix(paths))

运行之后，效果如下：

相信大家测试的时候，发现了一个差不多的函数：commonpath()。该函数的才是我们最长使用的，因为commonprefix()有缺陷，我们先来看一段代码：

import os

paths = ["D:/document/csdn/opencv/20/10.png",
         "D:/document/csdn/opencv/2011111",
         "D:/document/csdn/opencv/20",]

for path in paths:
    print(path)
print("公共前缀")
print(os.path.commonpath(paths))
print(os.path.commonprefix(paths))

运行之后，效果如下：

可以看到，commonpath()函数返回的是共同的路径前缀，而commonprefix()虽然返回的路径存在，但不是共同的路径前缀，因为2011111是一个文件，commonprefix()将其裁成（20，1111）了。

建立路径

Join()

在实际的项目中，我们除了进行路径的分解以外，我们还可能会从其他字符串建立路径。要将多个路径组成一个值，可以使用join()。具体代码如下所示：

import os

paths = [['one', 'two', 'thress'], ['/', 'tow', 'one', 'three'], ['/one', '/two', '/three']]

for path in paths:
    print(path)
    print(os.path.join(*path))

运行之后，效果如下：

需要注意的是，如果链接的参数有“/”开头，那么前面所有的参数将会被丢弃，如/three一样。

expanduser()

os.path还提供了直接主目录名拼接方法：expanduser()。它会将字符串“~”开头的路径转换为主目录路径。具体代码如下：

import os

paths = ['~Data','~Temp','~Hello']

for path in paths:
    print(path)
    print(os.path.expanduser(path))

运行之后，效果如下：

expandvars()

expandvars()函数会扩展路径中所有出现的shell环境变量。例如：

import os

os.environ['LYJ']="liyuanjing"
print(os.path.expandvars('/user/$LYJ'))

运行之后，效果如下：

格式化路径

在实际的路径拼接中，如果我们的字符串本身不规则，比如使用了两个或多个“/”，亦或者是其他字符，造成路径格式本身错误。那么，我们就需要对路径进行格式化处理，具体的格式化函数为：normpath()。

示例如下：

import os

paths = ['Data/../yello','Temp//liyuanjing','Hello/./world']

for path in paths:
    print('{}    :     {}'.format(path,os.path.normpath(path)))

运行之后，效果如下：

需要注意的是，在字符串路径中，发现…/会直接删除前面所有路径字符串。

绝对路径转换

在程序中，除了有上面这些相对路径之外，还会有绝对路径。那么，如果将所有相对路径转换为绝对路径呢？

我们先来看一段代码：

import os

os.chdir('C:/Users')
paths = ['../', 'Temp/liyuanjing', './world']

for path in paths:
    print('{}    :     {}'.format(path, os.path.abspath(path)))

运行之后，效果如下：

文件属性获取

在实际的文件处理中，我们可能还会获取各种文件的属性用于参考。比如获取文件的创建时间，访问时间，修改时间以及文件的大小（字节）等。

示例如下：

import os

path=r"E:\Project\python\base_demo\英文文档1.txt"

print(path)
print('文件创建时间:{}'.format(os.path.getctime(path)))
print('文件访问时间:{}'.format(os.path.getatime(path)))
print('文件修改时间:{}'.format(os.path.getmtime(path)))
print('文件大小:{}字节'.format(os.path.getsize(path)))

运行之后，效果如下：

判断文件

在程序中进行文件操作时，往往我们会进行容错判断，用于获取文件路径指的是一个文件还是一个目录，另外哪怕文件路径正确，我们还要判断文件是否确实存在，这些都是必不可少的步骤。

os.path给我们提供了很多测试文件的条件的函数，如下表所示：

函数名	意义
exists(path)	判断 path 对应的文件是否存在，如果存在，返回 True；反之，返回 False
lexists(path)	判断路径是否存在，如果存在，则返回 True；反之，返回 False
isabs(path)	判断是否为绝对路径
isfile(path)	判断路径是否为文件
isdir(path)	判断路径是否为目录
islink(path)	判断路径是否为链接文件（类似 Windows 系统中的快捷方式）
ismount(path)	判断路径是否为挂载点
sameopenfile(fp1, fp2)	判断 fp1 和 fp2 是否指向同一文件
relpath(path[, start])	从 start 开始计算相对路径。
samefile(path1, path2)	判断目录或文件是否相同。
samestat(stat1, stat2)	判断 stat1 和 stat2 是否指向同一个文件。

测试代码如下：

import os

path = r"E:\Project\python\base_demo\英文文档1.txt"

print(path)
print('文件是否存在:{}'.format(os.path.exists(path)))
print('路径是否存在:{}'.format(os.path.lexists(path)))
print('是否为绝对路径:{}'.format(os.path.isabs(path)))
print('路径是否为文件:{}'.format(os.path.isfile(path)))
print('路径是否为目录:{}'.format(os.path.isdir(path)))
print('路径是否为链接文件:{}'.format(os.path.islink(path)))
print('路径是否为挂载点:{}'.format(os.path.ismount(path)))
print('是否指向同一文件:{}'.format(os.path.sameopenfile(os.open(path, os.O_RDONLY), os.open(path, os.O_RDONLY))))
print('path的真实路径:{}'.format(os.path.realpath(r'python\base_demo\英文文档1.txt')))
print('从 start 开始计算相对路径:{}'.format(os.path.relpath(path, 'python')))
print('判断目录或文件是否相同:{}'.format(os.path.samefile(path, path)))

运行之后，效果如下：

一、xxxTo方法

Path类中提供了一套xxxTo方法，其作用是从起点到终点移动path画笔并绘制线（moveTo方法只移动path画笔不绘制线），线有直线和曲线。
方法汇总如下表所示：

方法名	参数解析
lineTo(float x, float y)	绘制直线，x：终点x坐标值，y：终点y坐标值
moveTo(float x, float y)	移动画笔，x：终点x坐标值，y：终点y坐标值
arcTo(RectF oval, float startAngle, float sweepAngle)	绘制圆弧，oval：圆弧矩形区域，startAngle：起始角度，sweepAngle：圆弧旋转的角度
arcTo(RectF oval, float startAngle, float sweepAngle,boolean forceMoveTo)	绘制圆弧，oval：圆弧矩形区域，startAngle：起始角度，sweepAngle：圆弧旋转的角度，forceMoveTo：是否在绘制圆弧前移动（moveTo）path画笔位置
arcTo(float left, float top, float right, float bottom, float startAngle,float sweepAngle, boolean forceMoveTo)	绘制圆弧，left、top、right、bottom组成圆弧矩形区域，startAngle：起始角度，sweepAngle：圆弧旋转的角度，forceMoveTo：是否在绘制圆弧前移动（moveTo）path画笔位置
quadTo(float x1, float y1, float x2, float y2)	绘制二阶贝塞尔曲线，控制点坐标：(x1,y1)，终点坐标：(x2,y2)
cubicTo(float x1, float y1, float x2, float y2,float x3, float y3)	绘制三阶贝塞尔曲线，其中控制点1坐标为(x1,y1)，控制点2坐标为(x2,y2)，终点坐标为(x3,y3)

1、lineTo(float x, float y)

绘制直线：从当前画笔位置出发，连接终点(x,y)。

示例如下：

path.lineTo(300,300);
canvas.drawPath(path,paint);

2、moveTo(float x, float y)

移动画笔：从当前画笔位置移动到终点(x,y)

示例如下：

path.moveTo(100,100);
path.lineTo(300,300);
canvas.drawPath(path,paint);

3、arcTo

3.1、arcTo(RectF oval, float startAngle, float sweepAngle)

绘制圆弧：从当前画笔位置出发，连线到内切矩形区域oval的圆弧的起始角度startAngle位置（X轴正方向为0°），顺时针旋转绘制圆弧，旋转度数为sweepAngle（sweepAngle为负时则逆时针旋转）

示例如下：

RectF rectF = new RectF(100,100,300,400);
path.arcTo(rectF,0,180);
canvas.drawPath(path,pathPaint);

3.2、arcTo(RectF oval, float startAngle, float sweepAngle,boolean forceMoveTo)

绘制圆弧：若forceMoveTo为false，则用法和arcTo(RectF oval, float startAngle, float sweepAngle)一样，绘制圆弧之前不会移动（moveTo）path画笔位置。若为true，先强制调用moveTo移动path画笔至圆弧起点，再绘制圆弧。PS：如果调用arcTo(RectF oval, float startAngle, float sweepAngle,boolean forceMoveTo)方法之前没有对path进行任何操作，则forceMoveTo设置true或false效果都和设置true一样

示例如下，注意对比之间的差异：

RectF rectF = new RectF(100,100,300,400);
path.moveTo(100,100);
path.arcTo(rectF,0,180,false);
path.close();
canvas.drawPath(path,pathPaint);

RectF rectF = new RectF(100,100,300,400);
path.moveTo(100,100);
path.arcTo(rectF,0,180,true);
path.close();
canvas.drawPath(path,pathPaint);

RectF rectF = new RectF(100,100,300,400);
path.arcTo(rectF,0,180,false);
path.close();
canvas.drawPath(path,pathPaint);

3.3、arcTo(float left, float top, float right, float bottom, float startAngle,float sweepAngle, boolean forceMoveTo)

绘制圆弧：与arcTo(RectF oval, float startAngle, float sweepAngle,boolean forceMoveTo)用法一样

4、quadTo(float x1, float y1, float x2, float y2)

绘制二阶贝塞尔曲线：从path画笔当前位置出发，以(x₁,y₁)为控制点，向终点(x₂,y₂)绘制一条二阶贝塞尔曲线

示例如下：

path.moveTo(100,100);
path.quadTo(200,0,400,100);
canvas.drawPath(path,pathPaint);

5、cubicTo(float x1, float y1, float x2, float y2,float x3, float y3)

绘制三阶贝塞尔曲线：从path画笔当前位置出发，以(x1,y1)为控制点1，以(x2,y2)为控制点2，向终点(x3,y3)绘制一条三阶贝塞尔曲线

示例如下：

path.moveTo(100,100);
path.cubicTo(200,0,300,90,500,100);
canvas.drawPath(path,pathPaint);

圆形其实也是由四段三阶贝塞尔曲线组成，我们绘制其中两段看看效果即可，示例如下：

path.moveTo(300,200);
path.cubicTo(300,200+100*0.551915024494f,200+100*0.551915024494f,300,200,300);

path.moveTo(200-20,300);
path.cubicTo(200-100*0.551915024494f-20,300,100-20,200+100*0.551915024494f,100-20,200);
canvas.drawPath(path,pathPaint);

二、rXxxTo方法

rXxxTo方法的r意思是relative，即相对的意思，方法有四个，如上图所示，其功能与对应的xxxTo方法一样，区别在于rXxxTo方法在绘制Path时是以当前path画笔位置为坐标原点，即相对于path画笔位置进行绘制，而xxxTo方法的坐标原点则与当前canvas坐标原点一致。

例如，我们使用xxxTo方法：

path.moveTo(100,100);
path.lineTo(300,300);
canvas.drawPath(path, pathPaint);

上述代码是从(100,100)到(300,300)绘制一条直线，那么如果用rXxxTo方法，相对(100,100)这个点绘制直线，则终点应为(300-100,300-100)，即终点设为(200,200)，如下所示：

path.moveTo(100,100);
path.rLineTo(200,200);
canvas.drawPath(path, pathPaint);

效果都是一样的：

三、addXxx方法

Path类中还提供了一套addXxx方法，字面理解就是添加一段相应的线，线可以是曲线、完整的圆形、矩形等，甚至可以是另一组Path的线。所谓添加的意思，我个人理解就是在绘制这段线前，移动（moveTo）path画笔位置到线的起始位置，然后再绘制线，也就是说添加的这段线，与之前绘制的Path是分离的（除非后绘制的这段线的起始点与之前Path的终点一致）。

方法汇总如下表所示：

方法名	参数解析
addArc(RectF oval, float startAngle, float sweepAngle)	添加圆弧，oval：圆弧矩形区域，startAngle：起始角度，sweepAngle：圆弧旋转的角度
addArc(float left, float top, float right, float bottom, float startAngle,float sweepAngle)	添加圆弧，left、top、right、bottom组成圆弧矩形区域，startAngle：起始角度，sweepAngle：圆弧旋转的角度。ps：此方法在API 19以上有效
addCircle(float x, float y, float radius, Direction dir)	添加圆形，x：圆形圆心的x坐标，y：圆形圆心的y坐标，radius：圆形半径，dir：线的闭合方向（CW顺时针方向
addOval(RectF oval, Direction dir)	添加椭圆，oval：椭圆内切的矩形区域，dir：线的闭合方向（CW顺时针方向
addOval(float left, float top, float right, float bottom, Direction dir)	添加椭圆，left、top、right、bottom组成椭圆内切的矩形区域，dir：线的闭合方向（CW顺时针方向
addRect(RectF rect, Direction dir)	添加矩形，rect：矩形区域，dir：线的闭合方向（CW顺时针方向
addRect(float left, float top, float right, float bottom, Direction dir)	添加矩形，left、top、right、bottom组成矩形区域，dir：线的闭合方向（CW顺时针方向
addRoundRect(RectF rect, float rx, float ry, Direction dir)	添加统一圆角的圆角矩形，rect：矩形区域，rx：椭圆圆角的横轴半径，ry：椭圆圆角的纵轴半径，dir：线的闭合方向（CW顺时针方向
addRoundRect(float left, float top, float right, float bottom, float rx, float ry,Direction dir)	添加统一圆角的圆角矩形，left、top、right、bottom组成矩形区域，rx：椭圆圆角的横轴半径，ry：椭圆圆角的纵轴半径，dir：线的闭合方向（CW顺时针方向
addRoundRect(RectF rect, float[] radii, Direction dir)	添加非统一圆角的圆角矩形，rect：矩形区域，radii：矩形四个椭圆圆角的横轴半径和纵轴半径的数组，一共8个数值，dir：线的闭合方向（CW顺时针方向
addRoundRect(float left, float top, float right, float bottom, float[] radii,Direction dir)	添加非统一圆角的圆角矩形，left、top、right、bottom组成矩形区域，radii：矩形四个椭圆圆角的横轴半径和纵轴半径的数组，一共8个数值，dir：线的闭合方向（CW顺时针方向
addPath(Path src)	添加一组Path，src：要添加的Path
addPath(Path src, float dx, float dy)	添加一组平移后的Path，src：要添加的Path，dx：平移的x坐标，dy：平移的y坐标
addPath(Path src, Matrix matrix)	添加一组经过矩阵变换后的Path，src：要添加的Path，matrix：3x3的矩阵

1、addArc(RectF oval, float startAngle, float sweepAngle)

添加圆弧：addArc两个方法使用起来与arcTo(RectF oval, float startAngle, float sweepAngle,boolean forceMoveTo)中forceMoveTo设置为true效果一致，就不展开赘述了

2、addCircle(float x, float y, float radius, Direction dir)

添加圆形：以点(x,y)为圆心，添加一个半径长为radius的圆形，绘制起始角度为0°（x轴方向），绘制方向通过dir的值而定，dir为CW时顺时针绘制，dir为CCW时逆时针绘制。

方法比较简单，主要是对比CW和CCW的区别，我们用canvas.drawTextOnPath方法突显顺时针和逆时针绘制的效果，示例如下：

path.addCircle(200,150,100, Path.Direction.CW);//顺时针绘制
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

path.addCircle(200,150,100, Path.Direction.CCW);//逆时针绘制
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

3、addOval(RectF oval, Direction dir)

添加椭圆：在oval矩形区域中，添加一个内切的椭圆，绘制起始角度为0°（x轴方向），绘制方向通过dir的值而定，dir为CW时顺时针绘制，dir为CCW时逆时针绘制。

注： addOval(RectF oval, Direction dir)和addOval(float left, float top, float right, float bottom, Direction dir)效果是一样的，就不分开讲了。

示例如下：

RectF rectF = new RectF(100,100,400,250);
path.addOval(rectF, Path.Direction.CW);
canvas.drawPath(path,pathPaint);

4、addRect(RectF rect, Direction dir)

添加矩形：添加一个区域为rect的矩形，绘制起点为左上角，绘制方向通过dir的值而定，dir为CW时顺时针绘制，dir为CCW时逆时针绘制。

注： addRect(RectF rect, Direction dir)和addRect(float left, float top, float right, float bottom, Direction dir)效果是一样的，就不分开讲了

示例如下：

RectF rectF = new RectF(100,100,400,250);
path.addRect(rectF, Path.Direction.CW);
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

5、addRoundRect

5.1、addRoundRect(RectF rect, float rx, float ry, Direction dir)

添加统一圆角的圆角矩形：添加一个区域为rect的圆角矩形，四个角的圆角大小一致，圆角的横轴半径为rx，纵轴半径为ry，dir为CW时顺时针绘制，绘制起点为左下角，dir为CCW时逆时针绘制，绘制起点为左上角（注意对比顺时针和逆时针的绘制起点）。

注： addRoundRect(RectF rect, float rx, float ry, Direction dir)和addRoundRect(float left, float top, float right, float bottom, float rx, float ry,Direction dir)效果是一样的，就不分开讲了。

示例如下：

RectF rectF = new RectF(100,100,400,350);
path.addRoundRect(rectF,60,30,Path.Direction.CW);//顺时针
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

RectF rectF = new RectF(100,100,400,350);
path.addRoundRect(rectF,60,30,Path.Direction.CCW);//逆时针
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

5.2、addRoundRect(RectF rect, float[] radii, Direction dir)

添加非统一圆角的圆角矩形：添加一个区域为rect的圆角矩形，四个角的圆角的横轴和纵轴半径由radii数组中的8个数值决定，dir为CW时顺时针绘制，绘制起点为左下角，dir为CCW时逆时针绘制，绘制起点为左上角（注意对比顺时针和逆时针的绘制起点）。

注： 需要注意的是，如果radii数组中的元素小于8，系统会抛出错误信息radii[] needs 8 values，如下图所示：


注： addRoundRect(RectF rect, float[] radii, Direction dir)和addRoundRect(float left, float top, float right, float bottom, float[] radii,Direction dir)效果是一样的，就不分开讲了。

RectF rectF = new RectF(100,100,400,350);
float[] radii = {60,30,30,70,100,100,10,40};
path.addRoundRect(rectF,radii,Path.Direction.CW);
canvas.drawPath(path,pathPaint);
canvas.drawTextOnPath("绘制顺序", path, 0, 0, paint);

6、addPath(Path src)

添加一组名为src的Path副本

Path copyPath = new Path();
copyPath.moveTo(100,100);
copyPath.lineTo(150,200);
copyPath.quadTo(200,100,350,200);
copyPath.lineTo(100,250);
copyPath.close();
path.addPath(copyPath);
canvas.drawPath(path,pathPaint);

6.1、addPath(Path src, float dx, float dy)

添加一组名为src的Path副本，然后将其进行平移，x轴上的平移距离为dx，y轴上的平移距离为dy

Path copyPath = new Path();
copyPath.moveTo(100,100);
copyPath.lineTo(150,200);
copyPath.quadTo(200,100,350,200);
copyPath.lineTo(100,250);
copyPath.close();
path.addPath(copyPath,300,0);//向x轴正方向平移300像素距离
canvas.drawPath(path,pathPaint);

6.2、addPath(Path src, Matrix matrix)

添加一组名为src的Path副本，然后将其进行矩阵变换，矩阵为matrix（3x3的矩阵）

Path copyPath = new Path();
copyPath.moveTo(100,100);
copyPath.lineTo(150,200);
copyPath.quadTo(200,100,350,200);
copyPath.lineTo(100,250);
copyPath.close();

Matrix mMatrix = new Matrix();
mMatrix.setScale(1,-1);//以x轴为中线进行翻转
mMatrix.postRotate(90);//以坐标轴原点为中心点顺时针旋转90°

path.addPath(copyPath,mMatrix);
canvas.drawPath(path,pathPaint);

四、填充模式

方法名	参数解析
setFillType(FillType ft)	设置Path的填充模式，ft：填充类型，有EVEN_ODD ，INVERSE_EVEN_ODD ，WINDING ，INVERSE_WINDING 四种模式
getFillType()	获取当前Path的填充模式
isInverseFillType()	判断当前Path填充模式是否是反向规则(INVERSE_XXX)
toggleInverseFillType()	当前Path的填充模式与其反向规则模式进行相互切换

五、其他方法

方法名	参数解析
close()	封闭当前Path，连接起点和终点
reset()	清空Path中的所有直线和曲线，保留填充模式设置，不保留Path上相关的数据结构
rewind()	清空Path中的所有直线和曲线，不保留填充模式设置，但会保留Path上相关的数据结构，以便高效地复用
set(Path src)	用名为src的Path替换当前的Path
op(Path path, Op op)	当前Path与名为path的Path进行布尔运算（取差集、交集、并集等），op：运算逻辑，有DIFFERENCE（差集），REVERSE_DIFFERENCE（差集），INTERSECT（交集），UNION（并集），XOR（异或）五种运算逻辑可选。ps：此方法在API 19以上有效
offset(float dx, float dy)	平移当前Path，x轴上平移的距离为dx，y轴上平移的距离为dy
offset(float dx, float dy, Path dst)	平移名为dst的Path，x轴上平移的距离为dx，y轴上平移的距离为dy
transform(Matrix matrix)	对当前Path进行矩阵变换，矩阵为matrix（3x3矩阵）
transform(Matrix matrix, Path dst)	对名为dst的Path进行矩阵变换，矩阵为matrix（3x3矩阵）
setLastPoint(float dx, float dy)	设置终点，设置当前Path最后一个点的位置为(dx,dy)
isEmpty()	判断当前Path是否为空
isConvex()	判断当前Path围成的图形是否凸多边形。ps：此方法在API 21以上有效
isRect(RectF rect)	判断当前Path是否为矩形，如是，则将当前Path存储到新建的rect中

注： 这里大多数方法都比较简单，有些之前已经应用过，就不展开来讲了，下面介绍一下其中比较特别且常用的几个方法。

1、op(Path path, Op op) 布尔运算

前面的表格我们提到参数op共有五种运算逻辑可选，下面我们就来看看这五种运算逻辑是如何影响两个Path之间的关系的，我们先用不同的颜色绘制出一个矩形和一个圆形，观察一下它们的位置和关系：

Path path1 = new Path();
path1.addRect(100,100,300,300, Path.Direction.CW);
pathPaint.setColor(Color.GREEN);
canvas.drawPath(path1,pathPaint);

Path path2 = new Path();
path2.addCircle(300,250,100,Path.Direction.CW);
pathPaint.setColor(Color.RED);
canvas.drawPath(path2,pathPaint);

下面我们对这两个Path进行布尔运算：

1.1、DIFFERENCE（差集）

若op方法的调用关系为path1.op(path2, Path.Op.DIFFERENCE)，则运算结果是path1减去与path2的交集后剩下的部分，即path1与path2的并集减去path2部分

Path path1 = new Path();
path1.addRect(100,100,300,300, Path.Direction.CW);

Path path2 = new Path();
path2.addCircle(300,250,100,Path.Direction.CW);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path1.op(path2, Path.Op.DIFFERENCE);//path1与path2进行布尔运算，结果保存至path1
    canvas.drawPath(path1,pathPaint);
}

//也可以这样写
Path path3 = new Path();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path3.op(path1,path2,Path.Op.DIFFERENCE);//path1与path2进行布尔运算，结果保存至path3
    canvas.drawPath(path3,pathPaint);
}

可以用path1.op直接运算，也可以新建一个path3保存path1和path2的运算结果，效果都是一样的

1.2、REVERSE_DIFFERENCE（差集）

若op方法的调用关系为path1.op(path2, Path.Op.REVERSE_DIFFERENCE)，则运算结果是path2减去与path1的交集后剩下的部分，即path1与path2的并集减去path1部分

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path1.op(path2, Path.Op.REVERSE_DIFFERENCE);//path1与path2进行布尔运算，结果保存至path1
    canvas.drawPath(path1,pathPaint);
}

//也可以这样写
Path path3 = new Path();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path3.op(path1,path2,Path.Op.REVERSE_DIFFERENCE);//path1与path2进行布尔运算，结果保存至path3
    canvas.drawPath(path3,pathPaint);
}

1.3、INTERSECT（交集）

若op方法的调用关系为path1.op(path2, Path.Op.INTERSECT)，则运算结果是path1与path2的交集

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path1.op(path2, Path.Op.INTERSECT);//path1与path2进行布尔运算，结果保存至path1
    canvas.drawPath(path1,pathPaint);
}

//也可以这样写
Path path3 = new Path();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path3.op(path1,path2,Path.Op.INTERSECT);//path1与path2进行布尔运算，结果保存至path3
    canvas.drawPath(path3,pathPaint);
}

1.4、UNION（并集）

若op方法的调用关系为path1.op(path2, Path.Op.UNION)，则运算结果是path1与path2的并集

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path1.op(path2, Path.Op.UNION);//path1与path2进行布尔运算，结果保存至path1
    canvas.drawPath(path1,pathPaint);
}

//也可以这样写
Path path3 = new Path();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path3.op(path1,path2,Path.Op.UNION);//path1与path2进行布尔运算，结果保存至path3
    canvas.drawPath(path3,pathPaint);
}

1.5、XOR（异或）

若op方法的调用关系为path1.op(path2, Path.Op.XOR)，则运算结果是path1与path2的并集减去path1与path2的交集

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path1.op(path2, Path.Op.XOR);//path1与path2进行布尔运算，结果保存至path1
    canvas.drawPath(path1,pathPaint);
}

//也可以这样写
Path path3 = new Path();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    path3.op(path1,path2,Path.Op.XOR);//path1与path2进行布尔运算，结果保存至path3
    canvas.drawPath(path3,pathPaint);
}

2、setLastPoint(float dx, float dy)

当Path在调用setLastPoint方法之前执行了某项操作时（绘制直线或曲线等），会将该操作的终点强制设置为(dx,dy)并连线（线的曲直取决于该操作本身是绘制直线还是曲线）

理解这个方法之前，首先我们要知道无论是使用addXxx方法还是xxxTo方法等在绘制过程中其实都是根据一堆点的集合，按顺序连线（直线或曲线）后绘制出Path最终的样子，setLastPoint方法正是改变此方法调用之前点的集合中最后一个点的位置。下面我们通过封闭图形（矩形）和非封闭图形（一段圆弧）的例子更好地理解这个方法。

//用绿线绘制一个矩形
path.addRect(new RectF(100,100,300,300), Path.Direction.CW);
pathPaint.setColor(Color.GREEN);
canvas.drawPath(path,pathPaint);

//强制设置最后一个点为(150,250)，用红线绘制观察变化
path.reset();
path.addRect(new RectF(100,100,300,300), Path.Direction.CW);
path.setLastPoint(150,250);
pathPaint.setColor(Color.RED);
canvas.drawPath(path,pathPaint);

//用绿线绘制一个旋转180°的圆弧
path.addArc(new RectF(100,100,300,300),0,180);
pathPaint.setColor(Color.GREEN);
canvas.drawPath(path,pathPaint);

//强制设置最后一个点为(200,200)，用红线绘制观察变化
path.reset();
path.addArc(new RectF(100,100,300,300),0,180);
path.setLastPoint(200,200);
pathPaint.setColor(Color.RED);
canvas.drawPath(path,pathPaint);

url是Django 1.x中的写法,在Django2.1中，开始舍弃Django1.x中的url写法。在Django2.x中，描写url配置的有两个函数path和re_path，re_path()函数可以看做是django 1.x中得url函数,即可以在路径中使用正则。

默认url(route, view, kwargs=None, name=None)

默认path(route, view, kwargs=None, name=None)

默认re_path(route, view, kwargs=None, name=None)

本文重点描述path和re_path，前五条内容即可实现基本运用

1、概述

要设计应用程序的URL，可以创建一个非正式的称为URLconf（URL配置）的Python模块。此模块是纯Python代码，是URL路径表达式与Python函数（您的视图）之间的映射。该映射可以根据需要短或长。它可以引用其他映射。并且，因为它是纯Python代码，所以它可以动态构造。

2、django如何处理请求

当用户请求一个页面时，Django根据下面的逻辑执行操作：

(1)决定要使用的根URLconf模块。通常，这是ROOT_URLCONF设置的值，但是如果传入的HttpRequest对象具有urlconf属性（由中间件设置），则其值将被用于代替ROOT_URLCONF设置。
(2)加载该模块并寻找可用的urlpatterns。 它是django.conf.urls.url()实例的一个列表。
(3)依次匹配每个URL模式，在与请求的URL相匹配的第一个模式停下来。（注意url在列表中的位置）
(4)导入并调用匹配行中给定的视图，该视图是一个简单的Python函数（被称为视图函数）,或基于类的视图。 视图将获得如下参数:
    <1>一个HttpRequest 实例。
    <2>如果匹配的正则表达式返回了没有命名的组，那么正则表达式匹配的内容将作为位置参数提供给视图。
    <3>关键字参数由正则表达式匹配的命名组组成，但是可以被django.conf.urls.url()的可选参数kwargs覆盖。
    <4>如果没有匹配到正则表达式，或者过程中抛出异常，将调用一个适当的错误处理视图。

3、转换器(django2.0 以上默认使用的是path转换器)

from django.urls import path
    from . import views

    urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<int:year>/', views.year_archive),
    path('articles/<int:year>/<int:month>/', views.month_archive),
    path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
    ]

/articles/2005/03/ 将匹配第三条，并调用views.month_archive(request, year=2005, month=3)；
/articles/2003/匹配第一条，并调用views.special_case_2003(request)；
/articles/2003将一条都匹配不上，因为它最后少了一个斜杠，而列表中的所有模式中都以斜杠结尾；
/articles/2003/03/building-a-django-site/ 将匹配最后一个，并调用views.article_detail(request, year=2003, month=3, slug="building-a-django-site"

注意：

（1）要捕获一段url中的值，需要使用尖括号，而不是之前的圆括号；
（2）可以转换捕获到的值为指定类型，比如例子中的int。默认情况下，捕获到的结果保存为字符串类型，不包含/这个特殊字符；
（3）匹配模式的最开头不需要添加/，因为默认情况下，每个url都带一个最前面的/。

默认情况下，Django内置下面的路径转换器：

str：匹配任何非空字符串，但不含斜杠/，如果你没有专门指定转换器，那么这个是默认使用的；
int：匹配0和正整数，返回一个int类型
slug：可理解为注释。该转换器匹配任何ASCII字符以及连接符和下划线，比如’ building-your-1st-django-site‘；
uuid：匹配一个uuid格式的对象。为了防止冲突，规定必须使用破折号，所有字母必须小写，例如’075194d3-6885-417e-a8a8-6c931e272f00‘ 。返回一个UUID对象；
path：匹配任何非空字符串，重点是可以包含路径分隔符’/‘。这个转换器可以帮助你匹配整个url而不是一段一段的url字符串。

4、使用正则表达式

如果路径和转换器语法不足以定义URL模式，则也可以使用正则表达式。使用 re_path()代替path()。

在Python正则表达式中，已命名正则表达式组的语法为(?Ppattern)，其中name是组的名称，并且 pattern是要匹配的某种模式。

示例URLconf，使用正则表达式重写：

from django.urls import path, re_path

from . import views

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    re_path(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    re_path(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<slug>[\w-]+)/$', views.article_detail),
]

与示例URLconf区别：

（1）将要匹配的确切URL受到更多限制。例如，年份10000将不再匹配，因为年份整数被限制为正好是四位数长。
（2）无论正则表达式进行哪种匹配，每个捕获的参数都将作为字符串发送到视图。
（3）当从使用re_path()切换为使用path()， re_path()反之亦然时，特别重要的是要注意视图参数的类型可能会发生变化，因此您可能需要调整视图。
（4）当命名的组与未命名的组两种样式混合使用时，任何未命名分组path('(\d+)/',view)都会被忽略，只有命名分组path('(?P<year>\d+)/',view)才会传递到视图函数。
（5）未命名分组将正则表达式匹配到的内容当作位置参数，命名分组将正则表达式匹配到的内容当作关键字参数

5、include（）

在任何时候，urlpatterns都可以“include”其他URLconf模块。这本质上是一组位于其他url之下的“roots”。

from django.urls import include, path

urlpatterns = [
    path('community/', include('aggregator.urls')),
    path('contact/', include('contact.urls')),
]

每当Django遇到时include()，它都会截断直到该处匹配的URL的任何部分，并将剩余的字符串发送到包含的URLconf中以进行进一步处理。

另一种可能性是通过使用path()实例列表包括其他URL模块 。例如，考虑以下URLconf：

from django.urls import include, path

from apps.main import views as main_views
from credit import views as credit_views

extra_patterns = [
    path('reports/', credit_views.report),
    path('reports/<int:id>/', credit_views.report),
    path('charge/', credit_views.charge),
]

urlpatterns = [
    path('', main_views.homepage),
    path('help/', include('apps.help.urls')),
    path('credit/', include(extra_patterns)),
]

/credit/reports/将由credit_views.report()视图处理 。

可用于从URLconf中删除重复使用单个模式前缀的冗余。

from django.urls import path
from . import views

urlpatterns = [
    path('<page_slug>-<page_id>/history/', views.history),
    path('<page_slug>-<page_id>/edit/', views.edit),
    path('<page_slug>-<page_id>/discuss/', views.discuss),
    path('<page_slug>-<page_id>/permissions/', views.permissions),
]

可通过仅说明一次公共路径前缀并对不同的后缀进行分组：

from django.urls import include, path
from . import views

urlpatterns = [
    path('<page_slug>-<page_id>/', include([
        path('history/', views.history),
        path('edit/', views.edit),
        path('discuss/', views.discuss),
        path('permissions/', views.permissions),
    ])),
]

                    以下为深入了解内容

6、注册自定义路径转换器

对于更复杂的匹配要求，您可以定义自己的路径转换器。

转换器是包含以下内容的类：

一个regex类属性，作为一个字符串。
一个to_python(self, value)方法，用于将匹配的字符串转换为应该传递给视图函数的类型。如果它不能转换给定的值，就会引发ValueError。ValueError被解释为没有匹配，因此404响应被发送给用户，除非另一个URL模式匹配。
一个to_url(self, value)方法，用于将Python类型转换为要在URL中使用的字符串。

class FourDigitYearConverter:
    regex = '[0-9]{4}'

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return '%04d' % value

使用register_converter()以下命令在URLconf中注册自定义转换器类 ：

from django.urls import path, register_converter
from . import converters, views

register_converter(converters.FourDigitYearConverter, 'yyyy')

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<yyyy:year>/', views.year_archive),
    ...
]

7、URLconf匹配的内容

URLconf按照正常的Python字符串匹配请求的URL。不包括GET或POST参数或域名及请求方法。

例如，在对的请求中https://www.example.com/myapp/，URLconf将寻找myapp/。

在请求中https://www.example.com/myapp/?page=3，URLconf将寻找myapp/。

8、为视图参数指定默认值

一个方便的技巧是为视图的参数指定默认参数。这是一个示例URLconf和视图：

from django.urls import path

from . import views

urlpatterns = [
    path('blog/', views.page),
    path('blog/page<int:num>/', views.page),
]

两个URL模式都指向同一个视图 views.page，但是第一个模式没有从URL中捕获任何内容。如果第一个模式匹配，该page()函数将使用它的默认参数num；如果第二个模式匹配， page()将使用num捕获的任何值。

9、自定义错误视图

当Django无法找到所请求URL的匹配项时，或者引发异常时，Django会调用默认错误视图，Django中的默认错误视图对于大多数Web应用程序来说已经足够了，但是如果您需要任何自定义行为，可以在您的根URLconf中设置这些值，在任何其他URLconf中设置这些变量将无效。
值必须是可调用的，或者是表示视图的完整Python导入路径的字符串，应该调用该视图来处理当前的错误情况。

该page_not_found()视图被覆盖 handler404：

handler404 = 'mysite.views.my_custom_page_not_found_view'

该server_error()视图被覆盖 handler500：

handler500 = 'mysite.views.my_custom_error_view'

该permission_denied()视图被覆盖 handler403：

handler403 = 'mysite.views.my_custom_permission_denied_view'

该bad_request()视图被覆盖 handler400：

handler400 = 'mysite.views.my_custom_bad_request_view'

10、捕捉的参数

包含的URLconf从父URLconfs接收任何捕获的参数，：

# In settings/urls/main.py
from django.urls import include, path

urlpatterns = [
    path('<username>/blog/', include('foo.urls.blog')),
]

# In foo/urls/blog.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.blog.index),
    path('archive/', views.blog.archive),
]

在上面的示例中，捕获的"username"变量按预期传递给了include的URLconf。

11、传递额外的选项到函数

URLconfs有一个钩子，可让您将额外的参数作为Python字典传递给视图函数。

该path()函数可以使用可选的第三个参数，该参数应该是传递给view函数的额外关键字参数的字典。

from django.urls import path
from . import views

urlpatterns = [
    path('blog/<int:year>/', views.year_archive, {'foo': 'bar'}),
]

在此示例中，对于的请求/blog/2005/，Django将调用views.year_archive(request, year=2005, foo=‘bar’)
该技术在联合框架中用于将元数据和选项传递给视图。

注：URL模式可能会捕获命名的关键字参数，并且还会在其额外参数的字典中传递具有相同名称的参数。发生这种情况时，将使用字典中的参数代替URL中捕获的参数。

同样，您可以将额外选项传递给include()，所包含的URLconf中的每一行都将传递额外选项。

例如，这两个URLconf集在功能上是相同的：

设置一：

# main.py
from django.urls import include, path

urlpatterns = [
    path('blog/', include('inner'), {'blog_id': 3}),
]

# inner.py
from django.urls import path
from mysite import views

urlpatterns = [
    path('archive/', views.archive),
    path('about/', views.about),
]

设置二：

# main.py
from django.urls import include, path
from mysite import views

urlpatterns = [
    path('blog/', include('inner')),
]

# inner.py
from django.urls import path

urlpatterns = [
    path('archive/', views.archive, {'blog_id': 3}),
    path('about/', views.about, {'blog_id': 3}),
]

请注意，无论视图实际上是否接受这些选项，额外的选项将始终传递到所包含的URLconf中的每一行。因此，仅当您确定所包含的URLconf中的每个视图都接受要传递的额外选项时才有用。

12、URL的反向解析

在Django项目上进行工作时，通常需要获取最终形式的URL，以嵌入生成的内容（视图和资产URL，向用户显示的URL等）或在服务器上处理导航流程侧面（重定向等）

Django提供了一个解决方案，使得URL映射器是URL设计的唯一存储库。将其与URLconf一起提供，然后可以在两个方向上使用它：

（1）从用户/浏览器请求的URL开始，它将调用正确的Django视图，以提供可能需要的任何参数以及从URL中提取的值。
（2）从标识相应的Django视图以及将传递给该视图的参数值开始，获取关联的URL。

上述（2）是所谓的URL反向解析，反向URL匹配，反向URL查找或简称URL反向。

Django提供了执行URL反转的工具，这些工具与需要URL的不同层相匹配：

在模板中：使用url模板标记
在Python代码中：使用reverse()函数
在与Django模型实例的URL处理有关的更高级别的代码中：get_absolute_url()方法

再次考虑以下URLconf条目：

from django.urls import path

from . import views

urlpatterns = [
    path('articles/<int:year>/', views.year_archive, name='news-year-archive'),
]

可以使用以下模板代码获取它们：

<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>
{# Or with the year in a template context variable: #}
<ul>
{% for yearvar in year_list %}
<li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
{% endfor %}
</ul>

在Python代码中：

from django.http import HttpResponseRedirect
from django.urls import reverse

def redirect_to_year(request):
    year = 2006
    return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))

13、嵌套参数

正则表达式允许嵌套参数，而Django会解析它们并将其传递给视图。反转时，Django将尝试填写所有外部捕获的参数，而忽略任何嵌套的捕获参数。考虑以下URL模式，这些URL模式可以选择采用page参数：

from django.urls import re_path

urlpatterns = [
    re_path(r'^blog/(page-(\d+)/)?$', blog_articles),                  # bad
    re_path(r'^comments/(?:page-(?P<page_number>\d+)/)?$', comments),  # good
]

这两种模式都使用嵌套的参数并将解析:例如，blog/page-2/将导致与blog_articles的匹配，其中包含两个位置参数:page-2/和2。第二种模式将comments/page-2/与关键字参数page_number设置为2匹配。在本例中，外部参数是一个非捕获参数。
blog_articles视图需要反转最外层捕获的参数，在本例中是page-2/或无参数，而comments可以反转，既不需要参数，也不需要page_number的值。
嵌套捕获的参数在视图参数和URL之间创建了一个强耦合，正如blog_articles所示:视图接收URL的一部分(page-2/)，而不是只接收视图想要的值。这种耦合在反转时更加明显，因为要反转视图，我们需要传递URL片段而不是页码。

只捕获视图需要处理的值，并在正则表达式需要参数而视图忽略参数时使用非捕获参数。