python高级应用

一：错误和异常

1、python错误和异常

语法错误：Python的语法错误或者解析错。

异常：运行时检测到的错误被称为异常。

2、异常处理

Python中使用try except 语句来捕获并处理异常

语法：

def div(a,b): 

    try: 

        a/b 

    except ZeroDivisionError:   #捕获除数为0异常

        print('除数不能为0')

    except TypeError:  #捕获类型不统一异常

        print('类型不统一！')

    else: 

        print("没有捕获到异常") 

说明：处理异常的工作方式

①.执行try子句（在关键字try和关键字except之间的语句） 如果没有异常发生，忽略except子句，try子句执行后结束。

②.如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。甚至会导致程序崩溃，

③、最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一 个错误信息，然后再次把异常抛出。

④、一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。但最多只有一个分支会被执行。 一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个 元组，例如 except (RuntimeError, TypeError, NameError):

⑤、try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。

3、案例分析

def method(a,b):
    try:
        c = a/b
        print("hello...")
    except ZeroDivisionError:   #捕获除数为0异常
        print('除数不能为0')
    except TypeError:  #捕获类型不统一异常
        print('类型不统一！')
    except:
        #在以上except语句，未捕捉到异常类型，执行...
        print('出现了未知错误!')
    else:
        print('代码没有发生异常') #未出现异常，执行代码

#代码无异常，try与except之间的语句正常执行，最终执行else语句
method(2,3)
print('-------------------')
#代码出现异常，从发生异常语句(try....except)后的语句
#(print("hello..."))，都将不在执行，执行捕捉到异常的except语句
method(2,0)

运行结果：

hello...
代码没有发生异常
-------------------
除数不能为0

4、抛出异常

Python 使用 raise 语句抛出一个指定的异常。

try:
     s = None
     if s is None:
         print ("s 是空对象")
         raise NameError     #如果引发NameError异常，后面的代码将不能执行
     print (len(s))  #这句不会执行，但是后面的except还是会走到
except NameError:
     print ("空对象没有长度")

运行结果:

s 是空对象
空对象没有长度

二：读取键盘输入

python提供了input()内置函数，从标准输入读入一行文本(String)，默认的标准输入是键盘。input()可以接收一个python表达式作为输入，并将运算结果返回，接收到的值是字符串，如果需要运算，需要转换成数值类型

1、普通案例

str = input()
print('您输入的内容时：{}'.format(str))
print('----------------------------')
str2 = input('请输入您的名字：')  #参数是，输入提示语句
print('您输入的内容时：{}'.format(str2))

运行结果：

name
您输入的内容时：name
----------------------------
请输入您的名字：小明
您输入的内容时：小明

2、运算案例

num01 = int(input('输入第一个数字：'))
num02 = int(input('输入第二个数字：'))
yunsuanfu = input('请输入运算符：')
result = 0
if yunsuanfu == '+':
    result = num01+num02
elif yunsuanfu == '-':
    result = num01-num02
elif yunsuanfu == '*':
    result = num01*num02
elif yunsuanfu == '/':
    result = num01/num02
elif yunsuanfu == '%':
    result = num01%num02
elif yunsuanfu == '//':
    result = num01//num02
else:
    result = '您输入的运算符，无法识别...'
print('{0}{1}{2}={3}'.format(num01,yunsuanfu,num02,result))

运行结果：

输入第一个数字：200
输入第二个数字：50
请输入运算符：*
200*50=10000

三：文件

为了持久的保存内存数据，我们一般把内存数据以文件方式存储到本地磁盘中。Python 提供了必要的函数和方法进行默认情况下的文件基本操作

1、文件操作流程

①、打开文件，得到文件对象并赋值给一个变量

②、通过文件对象对文件进行操作

③、关闭文件

2、文件类型

①、字符文件：存放字符内容的文件

②、字节文件：存放二进制内容的文件（word[有排版等信息]、图片、声音、视频等...）

3、open(fileName,mode) 将会返回一个file对象

fileName:包含了你要访问的文件名称的字符串的值

mode：打开文件方式的模式(只读、写入、追加...),默认是只读(r)

打开模式

①、"r" 以读方式打开文件，只能读取文件，如果文件不存在，会放生异常

②、"w" 以写方式打开文件，如果文件不存在，创建该文件，如果文件已经存在，里面含有内容会被清掉

③、"rb" 以读二进制数据打开文件，只能读文件 ， 如果文件不存在，会发生异常

④、"wb" 以写入二进制数据打开，只能写文件， 如果文件不存在，创建该文件， 如果文件已存在，先清空，再打开文件

⑤、"rt" 以文本读方式打开，只能读文件 ，如果文件不存在，会发生异常

⑥、"wt" 以文本写方式打开，只能写文件， 如果文件不存在，创建该文件， 如果文件已存在，先清空，再打开文件

⑦、"rb+" 以二进制读方式打开，可以读、写文件 ， 如果文件不存在，会发生异常

⑧、"wb+" 以二进制写方式打开，可以读、写文件， 如果文件不存在，创建该文件，如果文件已存在，先清空，再打开文件

⑨、"a" 打开文件从文件末尾加数据

4、创建目录

import os
#目录是否存在
def isDirectorie(dirName):
    #判断父目录是否存在
    if not os.path.exists(dirName):
        os.makedirs(dirName)  #创建目录
        print('{0},目录不存在，已创建!'.format(dirName))
    else:
        print('{0},目录存在!'.format(dirName))

path2 = r"D:\PythonCode2\file2\datas.txt" #绝对路径 从磁盘盘符开始
file_path,file_name = os.path.split(path2)
print('文件路径:{0};\t文件名:{1}。'.format(file_path,file_name))
#文件路径不存在，就创建
isDirectorie(file_path)

运行结果：

文件路径:D:\PythonCode2\file2;  文件名:datas.txt。
D:\PythonCode2\file2,目录不存在，已创建!

5、向文件内，写内容

write和writelines的区别

①、write()需要传入一个字符串做为参数,否则会报错
    ②、 writelines()既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件
    注意 ：writelines必须传入的是字符序列,不能是数字序列。如：list_1023 = [1,2,3,4,5] 报错:TypeError: write() argument must be str, not list

#向文件里写内容
def writeInfo(writePath,writeStr):
    #以写的方式打开文件(文件不存在，会自动创建)
    file = open(writePath,'w')
    try:
        file.write(writeStr) # 将string写入到文件中(必须是字符串)
        #writelines()既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件
        #注意 ：writelines必须传入的是字符序列,不能是数字序列
        count_list = ['b', 'a', 'a', 'b', 'a', 'c', 'b', 'b']
        file.writelines(count_list)
    finally:
        file.close()

path2 = r"D:\PythonCode2\file2\datas.txt" #绝对路径 从磁盘盘符开始
#向文件里写内容
writeInfo(path2,'Hello Python!')

6、读取文件内容

①、read()

特点是：读取整个文件，将文件内容放到一个字符串变量中。

劣势是：如果文件非常大，尤其是大于内存时，无法使用read()方法。

②、readline()方法

特点：readline()方法每次读取一行；返回的是一个字符串对象，保持当前行的内存

缺点：比readlines慢得多

③、readlines()方法

特点：一次性读取整个文件；自动将文件内容分析成一个行的列表。

缺点：若一个文件特别大，name一次性将文件都读入内存，容易奔溃

#读取文件内容
def readInfo(readPath):
    file = open(readPath,'r')  #以写的方式打开文件
    #读取文件所有内容(数据量过大，可能造成内存不足)
    str = file.read()
    print(str)
    file.close()
    print('-----------------------')
    file = open(readPath,'r')
    line1 = file.readline() #读取一行
    line2 = file.readline()
    print(line1+line2)
    file.close()
    print('-----------------------')
    file = open(readPath,'r')
    lines = file.readlines() #返回文件中包含的所有行 返回的是一个list， 每一行作为一个列表的元素
    print(lines)
    file.close()

path = "test.txt"
#读取文件内容
readInfo(path)

运行结果：

Hello Python01!
Hello Python02!
Hello Python03!
Hello Python04!
-----------------------
Hello Python01!
Hello Python02!
-----------------------
['Hello Python01!\n', 'Hello Python02!\n', 'Hello Python03!\n', 'Hello Python04!\n']

7、删除文件

import os
#删除文件
def deleteFile(fileName):
    if os.path.isfile(fileName):
        os.remove(fileName)
        print("{0}文件已删除！".format(fileName))
    else:
        print("{0}文件不存在！".format(fileName))

path2 = r"D:\PythonCode2\file2\datas.txt"
#删除文件
deleteFile(path2)

运行结果：

D:\PythonCode2\file2\datas.txt文件已删除！

8、删除目录

import os
#删除目录
def deleteDir(dirName):
    if os.path.exists(dirName):
        shutil.rmtree(dirName)  #空目录、有内容的目录都可以删
        print('{0},目录已删除！'.format(dirName))
    else:
        print('{0},目录不存在!'.format(dirName))

path2 = r"D:\PythonCode2\file2\datas.txt"
file_path,file_name = os.path.split(path2)
#删除文件
deleteDir(file_path)

运行结果：

D:\PythonCode2\file2,目录已删除！

9、其他操作

①、复制

shutil.copyfile("oldfile","newfile")  oldfile和newfile都只能是文件

②、移动（改变了文件的位置）

shutil.move("oldfile","newfile")

四：json操作

是一种轻量级的数据交换格式，python3 中可以使用json模块来对json数据进行编解码

1、python数据类型对应的json数据类型

dict   ->   object

list tuple  ->  array

str  ->    string

数字 -> number

True  -> true

False  -> false

None  ->  null

2、常用操作

①、python类型转成json串(传字符串)：json.dumps()

②、python类型转成json串(传文件)：json.dump()

③、json串转成python类型(传字符串)：json.loads()

④、json串转成python类型(传文件)：json.load()

3、dumps()：python类型转成json串(传字符串)

import  json

# python的字典类型
data = {
    'no':100,
    'name':'tom',
    'url': 'http://www.baidu.com',
    None:True
}

print('data的数据类型:',type(data))
json_str = json.dumps(data) #字典转成json串(传字符串)
print('json数据：',json_str)
print('json_str数据类型：',type(json_str)) #json本身就是字符串

运行结果：

data的数据类型: <class 'dict'>
json数据：{"no": 100, "name": "tom", "url": "http://www.baidu.com", "null": true}
json_str数据类型：<class 'str'>

4、json.loads()：json串转成python类型(传字符串)：

import  json

# python的字典类型
data = {
    'no':100,
    'name':'tom',
    'url': 'http://www.baidu.com',
    None:True
}

json_str = json.dumps(data)
print('json数据：',json_str)
print('json_str数据类型',type(json_str))
#json串转成字典(传字符串)
python__dict = json.loads(json_str)
print('字典数据：',python__dict)
print('python__dict数据类型',type(python__dict))

运行结果：

json数据：{"no": 100, "name": "tom", "url": "http://www.baidu.com", "null": true}
json_str数据类型 <class 'str'>
字典数据：{'no': 100, 'name': 'tom', 'url': 'http://www.baidu.com', 'null': True}
python__dict数据类型 <class 'dict'>

5、json.dump()：python类型转成json串(传文件)：

import  json

#写入的数据
data = {'zhangxuan':'','tom':'','jim':''}

# file = open('data.json','w')
# json.dump(data, file)
#将open('data.json','w')部分，看做f去操作，冒号后缩进，缩进的内容是对f的操作
with open('data.json','w') as f:
    json.dump(data,f)

运行结果：data.json文件写入内容，如下

{"zhangxuan": "", "tom": "", "jim": ""}

6、json.load()：json串转成python类型(传文件)：

import  json

#读取数据
with open('data.json','r') as f:
    data_dict = json.load(f)
print(data_dict)
print(type(data_dict))

运行结果：

{'zhangxuan': '', 'tom': '', 'jim': ''}
<class 'dict'>

五：xml解析

是可扩展标记语言，xml被设计用来传输和存储数据，是一套定义语义标记的规则，这些标记将文档分成许多部件并对这些部件加以标识。

python有3中解析xml方法：SAX、DOM、ElementTree

1、SAX (simple API for XML )

Python 标准库包含 SAX 解析器，SAX 用事件驱动模型，通过在解析XML的过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。

2、DOM(Document Object Model)

将 XML 数据在内存中解析成一个树，通过对树的操作来操作XML。

3、ElementTree(元素树)

ElementTree就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。

注意：因DOM需要将XML数据映射到内存中的树，一是比较慢，二是比较耗内存，而SAX流式读取XML文件，比较快，占用内存少，但需要用户实现回调函数（handler）。

xml文件（books.xml）

<?xml version="1.0"?>
<collection shelf="New Arrivals">
  <book title="三国演义">
     <type>军事历史题材</type>
     <author>罗贯中</author>
     <description>中国古典四大名著之一</description>
  </book >
  <book  title="西游记">
    <type>剧情/古装/奇幻/冒险</type>
    <author>吴承恩</author>
    <description>明代小说家吴承恩文学古典名著</description>
  </book>
</collection>

ElementTree解析方法简介

import xml.etree.cElementTree as et

#读取XML文件
tree = et.parse('books.xml')
root = tree.getroot()

#tag：获得标签名
#attrib：获得标签shelf的属性值
print('标签:',root.tag,'\tshelf->',root.attrib.get('shelf'))

#遍历子节点
for child in root:
    print('\t标签:',child.tag ,'\ttitle->',child.attrib.get('title'))
    print('\t\t标签:',child.find('type').tag,'\t标签节点值=>',child.find('type').text)
    print('\t\t标签:',child.find('author').tag,'\t标签节点值=>',child.find('author').text)
    print('\t\t标签:',child.find('description').tag,'\t标签节点值=>',child.find('description').text)

运行结果：

标签: collection   shelf-> New Arrivals
  标签: book   title-> 三国演义
    标签: type   标签节点值=> 军事历史题材
    标签: author   标签节点值=> 罗贯中
    标签: description   标签节点值=> 中国古典四大名著之一
  标签: book   title-> 西游记
    标签: type   标签节点值=> 剧情/古装/奇幻/冒险
    标签: author   标签节点值=> 吴承恩
    标签: description   标签节点值=> 明代小说家吴承恩文学古典名著

六：时间模块(python专门用来处理时间的内建库)

1、time( )函数

用于返回当前时间的时间戳(从1970年1月1日00时00分00秒到现在的浮点秒数)

import time
time01 = time.time()
print(time01, type(time01)) # 1573466214.1254914 <class 'float'>

运行结果：

1573466214.1254914 <class 'float'>

2、time.localtime()函数

作用是格式化时间戳为本地时间(struct_time类型）。如果secs参数未传入，就以当前时间为转换标准

参数说明：

tm_year=2019,-> 年

tm_mon=11,-> 月

tm_mday=5,-> 日

tm_hour=14, ->时

tm_min=13, ->分

tm_sec=43,->秒

tm_wday=1,  ->星期（从0开始，0是星期一）

tm_yday=309, ->一年中的第几天

tm_isdst=0) ->是否为夏令时

import time
time02 = time.localtime()
print(time02, type(time02))

运行结果：

time.struct_time(tm_year=2019, tm_mon=11, tm_mday=11, tm_hour=17, tm_min=59, tm_sec=20, tm_wday=0, tm_yday=315, tm_isdst=0) <class 'time.struct_time'>

3、time.mktime(struct_time)函数

将一个时间戳struct_time对象转换为时间戳。

import time
struct_time = time.localtime()
time03 = time.mktime(struct_time)
print(time03, type(time03))

运行结果：

1573466486.0 <class 'float'>

4、time.asctime(struct_time=None)函数

传入一个struct_time对象，返回"Sun Jun 20 23:21:05 1993"这种格式的字符串。不传参数，返回当前时间的这种格式的字符串。

import time
time04 = time.asctime()
print(time04, type(time04))

运行结果：

Mon Nov 11 18:03:31 2019 <class 'str'>

5、time.strftime(format[, struct_time])函数

传入格式和struct_time，返回按照format格式格式化后的时间字符串。

时间日期格式化符号：

%y 两位数的年份表示（00-99）

%Y 四位数的年份表示（000-9999）

%m 月份（01-12）

%d 月内中的一天（0-31）

%H 24小时制小时数（0-23）

%I 12小时制小时数（01-12）

%M 分钟数（00=59）

%S 秒（00-59）

import time
time05 = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
time06 = time.strftime('%Y/%m/%d %H:%M:%S',time.localtime())
print(time05, type(time05))
print(time06,type(time06))

运行结果：

2019-11-11 18:05:28 <class 'str'>
2019/11/11 18:05:28 <class 'str'>

6、time.strptime(string[, format])函数

将字符串时间转为struct_time，是time.strftime()的逆向操作。如果你不传入format参数，那么将会采用默认格式%a %b %d %H:%M:%S %Y

import time
time_str = "2019-08-02 18:49:00"
format = "%Y-%m-%d %H:%M:%S"
time06 = time.strptime(time_str, format)
print(time06, type(time06))

7、sleep(secs) 函数

用于推迟调用线程的运行，可通过参数secs指定进程挂起的时间

import time
print("----")
time.sleep(3) #延迟3秒
print("----")

七：多线程

①、进程：通俗理解一个运行的程序或者软件,进程是操作系统资源分配的基本单位

②、线程：运行在进程上下文的逻辑流，程序的执行路径，每个线程都有自己的线程上下文，包含唯一的线程ID（就当前所属进程而言）

③、线程安全：同一个进程中的线程，共享相同的运行环境，共享同一片数据空间，所以线程间的通讯比进程间的通信更简单，但是这样的共享是会有危险的，如果多线程共同访问同一数据，因为访问顺序的不同，可能会导致结果不一致。

④、多线程编程的目的：

cpu大多情况下是属于空置状态，正常下激活的线程虽多，但不一定都在工作，即使在工作，也不可能得到100%利用，肯定有浪费的，多线程能够充分利用这些可能要浪费的时间片，并行处理子任务，大幅度地提升整个任务的效率。

⑤、线程生命周期：

创建 -> 执行(run) ->消亡

创建 -> 执行(run) -> 暂停(time.sleep()) ->执行  ->消亡

⑥、常用方法：    

init(group=None, tatget=None, name=None, args=(),kwargs ={}, verbose=None, daemon=None) ：实例化一个线程对象，需要有一个可调用的target，以及其参数args或kwargs。还可以传递name 或group 参数，不过后者还未实现。此外， verbose 标志也是可接受的。而daemon 的值将会设定thread.daemon 属性/标志

start()：开始执行该线程

run()：定义线程功能的方法（通常在子类中被应用开发者重写）

join(timeout=None)：直至启动的线程终止之前一直挂起；除非给出了timeout（秒），否则会一直阻塞，可实现线程插入功能

1、单线程案例

import threading
import time

#打印1到5的数字
def function1(sleepTime):
    for i in range(1,6):
        print(i)
        #表示进程挂起(休眠)的时间，参数单位：秒
        time.sleep(sleepTime)

#打印A到E的字符
def function2(sleepTime):
    for i in range(65,70):
        print(chr(i))
        time.sleep(sleepTime)

if __name__ == "__main__":
    #任何进程默认就会启动一个线程，称为主线程，主线程可以启动新的子线程
    #current_thread()：返回返回当前线程的实例
    #调用线程对象的getName()方法获取单前线程的名字
    print('主线程的名字',threading.current_thread().getName())
    #time.time()：返回当前时间的时间戳（1970纪元后经过的浮点秒数）
    star = time.time()
    function1(1)
    function2(1)
    end = time.time()
    print('主线程结束了！' , threading.current_thread().name)
    print("单线程使用时间："+str(end-star))

运行结果：

主线程的名字 MainThread
1
2
3
4
5
A
B
C
D
E
主线程结束了！MainThread
单线程使用时间：10.003108739852905

2、多线程案例

import threading
import time

#打印1到5的数字
def function1(sleepTime):
    for i in range(1,6):
        print(i)
        #表示进程挂起(休眠)的时间，参数单位：秒
        time.sleep(sleepTime)

#打印A到E的字符
def function2(sleepTime):
    for i in range(65,70):
        print(chr(i))
        time.sleep(sleepTime)

if __name__ == "__main__":
    #创建线程  target：线程执行的方法（注意不能加方法的小括号）
    #args：传入的参数（注意需要用元组方式）    name：线程的名字
    thread01 = threading.Thread(target=function1,args=(1,),name="线程1")
    thread02 = threading.Thread(target=function2,args=(1,),name="线程2")
    #开始执行该线程
    thread01.start()
    thread02.start()

运行结果：

1
A
B
2
C
3
D
4
E
5

3、多线程效率测试

import threading
import time

#打印1到5的数字
def function1(sleepTime):
    for i in range(1,6):
        print(i)
        #表示进程挂起(休眠)的时间，参数单位：秒
        time.sleep(sleepTime)

#打印A到E的字符
def function2(sleepTime):
    for i in range(65,70):
        print(chr(i))
        time.sleep(sleepTime)

if __name__ == "__main__":
    print('主线程的名字',threading.current_thread().getName())
    thread01 = threading.Thread(target=function1,args=(1,),name="线程1")
    thread02 = threading.Thread(target=function2,args=(1,),name="线程2")
    star = time.time()
    thread01.start()
    thread02.start()
    #线程.setDaemon(False)：这里默认是False ->主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束
    #线程.setDaemon(True)：设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止
    #join():所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止
    thread01.join()
    thread02.join()
    end = time.time()
    print('主线程结束了！' , threading.current_thread().name)
    print("多进程使用时间："+str(end-star))

运行结果：效率提升了近一倍

主线程的名字 MainThread
1
A
B
2
C
3
D
4
E
5
主线程结束了！MainThread
多进程使用时间：5.00428581237793

4、join()方法应用

①、停止当前线程thread1执行当前指定线程thread2，线程thread2执行完，再继续执行线程thread1

import threading
import time

def fun1(a):
    for i in range(1,6):
        print(threading.current_thread().getName(),i)
        time.sleep(a)    #1秒
        if i==2:
            thread2 = threading.Thread(target=fun2,args=(1,),name="线程2")
            thread2.start()
             #停止当前线程thread1执行当前指定线程thread2，线程thread2执行完，再继续执行线程thread1
            thread2.join() 

def fun2(a):
    for i in range(65,70):
        print(threading.current_thread().getName(),chr(i))
        time.sleep(a)

thread1 = threading.Thread(target=fun1,args=(1,),name="线程1")
thread1.start()

运行结果：

线程1 1
线程1 2
线程2 A
线程2 B
线程2 C
线程2 D
线程2 E
线程1 3
线程1 4
线程1 5

②、守护线程

join():所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止。

线程.setDaemon(False)：这里默认是False ->主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到自己的任务结束。承接上面【多线程效率测试】案例，如果去掉：thread01.join()   thread02.join()，会出现如下结果：

 import threading
 import time

 #打印1到5的数字
 def function1(sleepTime):
     for i in range(1,6):
         print(i)
         #表示进程挂起(休眠)的时间，参数单位：秒
         time.sleep(sleepTime)

 #打印A到E的字符
 def function2(sleepTime):
     for i in range(65,70):
         print(chr(i))
         time.sleep(sleepTime)

 if __name__ == "__main__":
     print('主线程的名字',threading.current_thread().getName())
     thread01 = threading.Thread(target=function1,args=(1,),name="线程1")
     thread02 = threading.Thread(target=function2,args=(1,),name="线程2")
     star = time.time()
     thread01.start()
     thread02.start()
     #join():所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止
     # thread01.join()
     # thread02.join()
     end = time.time()
     print('主线程结束了！' , threading.current_thread().name)
     print("多进程使用时间："+str(end-star))

运行结果：

主线程的名字 MainThread
1
A
主线程结束了！MainThread
多进程使用时间：0.0009992122650146484
2
B
C
3
D
4
E
5

③、线程.setDaemon(True)：设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止

import threading
import time

#打印1到5的数字
def function1(sleepTime):
    for i in range(1,6):
        print(i)
        #表示进程挂起(休眠)的时间，参数单位：秒
        time.sleep(sleepTime)

#打印A到E的字符
def function2(sleepTime):
    for i in range(65,70):
        print(chr(i))
        time.sleep(sleepTime)

if __name__ == "__main__":
    print('主线程的名字',threading.current_thread().getName())
    thread01 = threading.Thread(target=function1,args=(1,),name="线程1")
    thread02 = threading.Thread(target=function2,args=(1,),name="线程2")
    #线程.setDaemon(True)：设置子线程为守护线程时，主线程一旦执行结束，则全部线程全部被终止执行，可能出现的情况就是，子线程的任务还没有完全执行结束，就被迫停止
    thread01.setDaemon(True)
    thread02.setDaemon(True)
    thread01.start()
    thread02.start()
    print('主线程结束了！' , threading.current_thread().name)

运行结果：

主线程的名字 MainThread
1
A
主线程结束了！MainThread

5、面向对象(继承)的应

import threading
import time

class MyThread01(threading.Thread):

    def __init__(self,a,name):
        super().__init__(args=(a,),name=name)
        #threading.Thread.__init__(self,args=(a,))
        self.a = a

    def run(self):
        for i in range(1,6):
            print(threading.current_thread().getName(),i)
            time.sleep(self.a)    #1秒

class MyThread02(threading.Thread):

    def __init__(self,a,name):
        super().__init__(args=(a,),name=name)
        #threading.Thread.__init__(self,args=(a,))
        self.a = a

    def run(self):
        for i in range(65,70):
            print(threading.current_thread().getName(),chr(i))
            time.sleep(self.a)

thread01 = MyThread01(1,'线程一')
thread01.start()
thread02 = MyThread02(2,'线程二')
thread02.start()

运行结果：

线程一 1
线程二 A
线程一 2
线程二 B
线程一 3
线程一 4
线程二 C
线程一 5
线程二 D
线程二 E

八、正则表达式

是用来匹配字符串的一种工具，也就是在一大串字符中，寻找你需要的内容。常用来网页爬虫、文稿整理、数据筛选等。

在python中通过内置的re库来使用正则表达式，它提供了所有正则表达式的功能。

1、re.compile()函数

用于编译正则表达式，生成一个正则表达式（Pattern）对象

re.compile(pattern)   pattern参数:一个字符串形式的正则表达式

2、findall()函数

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

findall(string)  string参数：待匹配的字符串。

3、案例1

import re

string="A1.45，b5，6.45，882"
regex = re.compile(r"\d+")   #匹配多个连续的字符
info = regex.findall(string)  #返回所匹配的所有子字符串
print(info)

运行结果：

['', '', '', '', '', '']

4、元字符

^    匹配开始位置，多行模式下匹配每一行的开始

$    匹配结束位置，多行模式下匹配每一行的结束

.    匹配任意字符（不包括换行符）

\d    匹配一个数字， 相当于 [0-9]

\D    匹配非数字,相当于 [^0-9]

\s    匹配任意空白字符， 相当于 [ \t\n\r\f\v]

\S    匹配非空白字符，相当于 [^ \t\n\r\f\v]

\w    匹配数字、字母、下划线中任意一个字符， 相当于 [a-zA-Z0-9_]

\W    匹配非数字、字母、下划线中的任意字符，相当于 [^a-zA-Z0-9_]

*    匹配前一个元字符0到多次

+    匹配前一个元字符1到多次

?    匹配前一个元字符0到1次

{m,n}    匹配前一个元字符m到n次

\\     转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\\.只能匹配.，不能再匹配任意字符

[]    字符集，一个字符的集合，可匹配其中任意一个字符

|    逻辑表达式 或 ，比如 a|b 代表可匹配 a 或者 b

(...)    分组，默认为捕获，即被分组的内容可以被单独取出，默认每个分组有个索引，从 1 开始，按照"("的顺序决定索引值

(?iLmsux)    分组中可以设置模式，iLmsux之中的每个字符代表一个模式,用法参见 模式 I

(?:...)    分组的不捕获模式，计算索引时会跳过这个分组

(?P<name>...)    分组的命名模式，取此分组中的内容时可以使用索引也可以使用name

(?P=name)    分组的引用模式，可在同一个正则表达式用引用前面命名过的正则

(?#...)    注释，不影响正则表达式其它部分,用法参见 模式 I

(?=...)    顺序肯定环视，表示所在位置右侧能够匹配括号内正则

(?!...)    顺序否定环视，表示所在位置右侧不能匹配括号内正则

(?<=...)    逆序肯定环视，表示所在位置左侧能够匹配括号内正则

(?<!...)    逆序否定环视，表示所在位置左侧不能匹配括号内正则

(?(id/name)yes|no)    若前面指定id或name的分区匹配成功则执行yes处的正则，否则执行no处的正则

\number    匹配和前面索引为number的分组捕获到的内容一样的字符串

\A    匹配字符串开始位置，忽略多行模式

\Z    匹配字符串结束位置，忽略多行模式

\b    匹配位于单词开始或结束位置的空字符串

\B    匹配不位于单词开始或结束位置的空字符串

关于正则表达式 本人总结的 123  https://www.cnblogs.com/zhuhuibiao/p/10937586.html