首页 > 编程语言 > 详细

python高级应用

时间:2020-02-28 17:16:02      阅读:58      评论:0      收藏:0      [点我收藏+]

一:错误和异常

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: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,\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(),会出现如下结果:

 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    匹配任意空白字符, 相当于 [ \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

python高级应用

原文:https://www.cnblogs.com/zhuhuibiao/p/12377787.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!