一：错误和异常
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:PythonCode2file2datas.txt" #绝对路径 从磁盘盘符开始 file_path,file_name = os.path.split(path2) print('文件路径:{0}; 文件名:{1}。'.format(file_path,file_name)) #文件路径不存在，就创建 isDirectorie(file_path)
运行结果：
文件路径:D:PythonCode2file2; 文件名:datas.txt。
D:PythonCode2file2,目录不存在，已创建!
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:PythonCode2file2datas.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! ', 'Hello Python02! ', 'Hello Python03! ', 'Hello Python04! ']
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:PythonCode2file2datas.txt" #删除文件 deleteFile(path2)
运行结果：
D:PythonCode2file2datas.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:PythonCode2file2datas.txt" file_path,file_name = os.path.split(path2) #删除文件 deleteDir(file_path)
运行结果：
D:PythonCode2file2,目录已删除！
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':'123456','tom':'7890','jim':'111111'} # 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": "123456", "tom": "7890", "jim": "111111"}
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': '123456', 'tom': '7890', 'jim': '111111'}
<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,' shelf->',root.attrib.get('shelf')) #遍历子节点 for child in root: print(' 标签:',child.tag ,' title->',child.attrib.get('title')) print(' 标签:',child.find('type').tag,' 标签节点值=>',child.find('type').text) print(' 标签:',child.find('author').tag,' 标签节点值=>',child.find('author').text) print(' 标签:',child.find('description').tag,' 标签节点值=>',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()，会出现如下结果：
1 import threading 2 import time 3 4 #打印1到5的数字 5 def function1(sleepTime): 6 for i in range(1,6): 7 print(i) 8 #表示进程挂起(休眠)的时间，参数单位：秒 9 time.sleep(sleepTime) 10 11 #打印A到E的字符 12 def function2(sleepTime): 13 for i in range(65,70): 14 print(chr(i)) 15 time.sleep(sleepTime) 16 17 if __name__ == "__main__": 18 print('主线程的名字',threading.current_thread().getName()) 19 thread01 = threading.Thread(target=function1,args=(1,),name="线程1") 20 thread02 = threading.Thread(target=function2,args=(1,),name="线程2") 21 star = time.time() 22 thread01.start() 23 thread02.start() 24 #join():所完成的工作就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束之后，主线程在终止 25 # thread01.join() 26 # thread02.join() 27 end = time.time() 28 print('主线程结束了！' , threading.current_thread().name) 29 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)
运行结果：
['1', '45', '5', '6', '45', '882']
4、元字符
^ 匹配开始位置，多行模式下匹配每一行的开始
$ 匹配结束位置，多行模式下匹配每一行的结束
. 匹配任意字符（不包括换行符）
d 匹配一个数字， 相当于 [0-9]
D 匹配非数字,相当于 [^0-9]
s 匹配任意空白字符， 相当于 [ fv]
S 匹配非空白字符，相当于 [^ fv]
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处的正则
umber 匹配和前面索引为number的分组捕获到的内容一样的字符串
A 匹配字符串开始位置，忽略多行模式
匹配字符串结束位置，忽略多行模式
匹配位于单词开始或结束位置的空字符串
B 匹配不位于单词开始或结束位置的空字符串
关于正则表达式 本人总结的 123 https://www.cnblogs.com/zhuhuibiao/p/10937586.html