python 进阶内容

python 进阶内容

入门内容进查看python3 30分钟入门

1. 文件

1.1. 打开文件

<var> = open(<filename>,<method>)

• 第一个参数文件名
• 第二个参数打开方式
  • x:创建
  • r:读
  • w:写
  • a:追加

1.2. 读取文件

<file>.read(<num>)        #<num>表示读几个字符，默认所有
<file>.readline(<num>)    #<num>表示读几个字符，默认所有，但最多一行
<file>.readlines(<num>)   #<num>表示读几个字符，默认所有，但会把每一行存在一个字符串列表里
for <var> in <file>:      #按行循环读取文件

注意：

• 每行的结尾换行符读到内存会以“\n”的形式体现出来
• print()默认加上换行，如果不需要换行可以加上end=""

1.3. 写入文件

print(<str>,end="",file=<file>)

1.4. 示例

将a.txt的内容复制到b.txt

def main():
    out_file = open("out.txt", "r")
    in_file = open("in.txt", "w")

    for l in out_file:
        print(l, end="")
        print(l, end="", file=in_file)

    out_file.close()
    in_file.close()


main()

2. 异常

2.1. 格式

try:
    statement
except:
    statement
else:
    statement
finally:
    statement

• except后接异常类型，例如except ValueError:
• 也可同时接多个异常，用元组包起来，例如except (RuntimeError, TypeError, NameError):
• 可以有多个except，例如

except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])

• 不接异常类型会捕获未标明的所有异常
• else仅当没出现异常时执行
• finally无论如何都会执行，并且在异常被抛出之前执行

2.2. 抛出异常

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

2.3. 预定义清理行为with

for line in open("myfile.txt"):
    print(line, end="")

当我们打开文件之类的操作可能会导致异常，是的文件没有被正常关闭，此刻使用with可解决这类问题

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

3. 线程

Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

3.1. 使用 _thread 模块创建线程

_thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数。

示例：

import _thread


# 为线程定义一个函数
def print_time(threadName):
    count = 0
    while count < 5:
        count += 1
        print("{} {}\n".format(threadName, count), end="")


# 创建两个线程
try:
    _thread.start_new_thread(print_time, ("Thread-1",))
    _thread.start_new_thread(print_time, ("Thread-2",))
except:
    print("Error: 无法启动线程")
    raise

while True:
    pass

===================output==============

Thread-1 1
Thread-1 2
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4
Thread-1 3
Thread-1 4
Thread-2 5
Thread-1 5

3.2. 使用 threading 模块创建线程

通过直接从 threading.Thread 继承创建一个新的子类，并实例化后调用 start() 方法启动新线程，即它调用了线程的 run() 方法：

import threading


class myThread(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        print("开始线程：" + self.name)
        print_time(self.name)
        print("退出线程：" + self.name)


def print_time(threadName):
    count = 0
    while count < 5:
        count += 1
        print("{} {}\n".format(threadName, count), end="")


# 创建新线程
thread1 = myThread("Thread-1")
thread2 = myThread("Thread-2")

# 开启新线程
thread1.start()
thread2.start()
# 等待至线程中止
thread1.join()
thread2.join()
print("退出主线程")

===============output================

开始线程：Thread-1
Thread-1 1
Thread-1 2
开始线程：Thread-2
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4
Thread-1 3
Thread-1 4
Thread-2 5
退出线程：Thread-2
Thread-1 5
退出线程：Thread-1
退出主线程

3.3. 线程同步

在创建线程前生成一个线程锁

threadLock = threading.Lock()

在线程中需要同步的代码前后加上

# 获取锁，用于线程同步
threadLock.acquire()
需要同步的代码
# 释放锁，开启下一个线程
threadLock.release()

4. 正则表达式

re 模块使 Python 语言拥有全部的正则表达式功能。

4.1. 常用方法

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

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

4.1.1.1. span()获取匹配位置

import re
print(re.match('www', 'www.shanyu.work'))  # 在起始位置匹配
print(re.match('www', 'www.shanyu.work').span())  # 在起始位置匹配
print(re.match('work', 'www.shanyu.work'))   # 不在起始位置匹配

==========output==========

<re.Match object; span=(0, 3), match='www'>
(0, 3)
None

4.1.1.2. group()

import re
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))   #123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))   #123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))   #abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))   #456

• 正则表达式中的三组括号把匹配结果分成三组
• group()等同group()，返回所有

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

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

import re
print(re.search('www', 'www.shanyu.work'))  # 在起始位置匹配
print(re.search('www', 'www.shanyu.work').span())  # 在起始位置匹配
print(re.search('work', 'www.shanyu.work'))   # 不在起始位置匹配

==============output==========
<re.Match object; span=(0, 3), match='www'>
(0, 3)
<re.Match object; span=(11, 14), match='work'>

4.1.3. re.sub(pattern, repl, string, max=0)

re.sub用于替换字符串中的匹配项

import re
print(re.sub('www', '***', 'www.shanyu.work'))  # 在起始位置匹配
print(re.sub('work', '***', 'www.shanyu.work'))   # 不在起始位置匹配

=======output============

***.shanyu.work
www.shanyu.***

4.2. flags介绍

多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

4.3. pattern模式匹配

• 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
• 多数字母和数字前加一个反斜杠时会拥有不同的含义。
• 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
• 反斜杠本身需要使用反斜杠转义。
• 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串r'str'来表示它们。模式元素(如r'/t'，等价于'//t')匹配相应的特殊字符。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}
re{ n,}	精确匹配n个前面表达式。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	G匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字
\W	匹配非字母数字
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的子表达式。
\10	匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

4.3.1. 示例

4.3.1.1. 字符匹配

实例	描述
python	匹配 "python".

4.3.1.2. 字符类

实例	描述
[Pp]ython	匹配 "Python" 或 "python"
rub[ye]	匹配 "ruby" 或 "rube"
[aeiou]	匹配中括号内的任意一个字母
[0-9]	匹配任何数字。类似于 [0123456789]
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何字母及数字
[^aeiou]	除了aeiou字母以外的所有字符
[^0-9]	匹配除了数字外的字符

4.3.1.3. 特殊字符类

实例	描述
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。

5. JSON解析

Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它包含了两个函数：

• json.dumps(): 对数据进行编码。
• json.loads(): 对数据进行解码。

import json

# Python 字典类型转换为 JSON 对象
data = {
    "no": 1,
    "name": "WGSpring",
    "bool": False
}

json_str = json.dumps(data)
data_from_json = json.loads(json_str)
print("Python 原始数据：", data)
print("JSON 对象：", json_str)
print("Python 对象：", data_from_json)

===================output=============

Python 原始数据： {'no': 1, 'name': 'WGSpring', 'bool': False}
JSON 对象： {"no": 1, "name": "WGSpring", "bool": false}
Python 对象： {'no': 1, 'name': 'WGSpring', 'bool': False}

如果你要处理的是文件而不是字符串，你可以使用 json.dump() 和 json.load() 来编码和解码JSON数据。例如：

# 写入 JSON 数据
with open('data.json', 'w') as f:
    json.dump(data, f)

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

6. Socket编程

6.1. 简单实例

服务器 server.py

import socket

# 创建 socket 对象
serversocket = socket.socket(
    socket.AF_INET, socket.SOCK_STREAM)

# 绑定服务，指定主机和端口
host,port = "127.0.0.1",9999
serversocket.bind((host, port))

# 设置最大连接数，超过后排队
serversocket.listen(5)

while True:
    # 建立客户端连接
    clientsocket, addr = serversocket.accept()
    print("连接地址" , str(addr))

    msg = '欢迎连接' + host + ':' + str(port) + '聊天室！'
    clientsocket.send(msg.encode('utf-8'))
    clientsocket.close()

客户端 client.py

import socket

# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接服务，指定主机和端口
host,port = "127.0.0.1",9999
s.connect((host, port))

# 接收小于 1024 字节的数据
msg = s.recv(1024)

s.close()

print (msg.decode('utf-8'))

先运行server.py，再运行client.py

6.2. socket()函数

Python 中，我们用 socket（）函数来创建套接字，语法格式如下：

socket.socket([family[, type[, proto]]])
参数

• family: 套接字家族可以使AF_UNIX或者AF_INET
• type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM
• protocol: 一般不填默认为0.

6.3. Socket 对象(内建)方法

函数	描述
服务器端套接字	—
s.bind()	绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
s.listen()	开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()	被动接受TCP客户端连接,(阻塞式)等待连接的到来
客户端套接字
s.connect()	主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex()	connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv()	接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send()	发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall()	完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvform()	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto()	发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()	关闭套接字
s.getpeername()	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])	返回套接字选项的值。
s.settimeout(timeout)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()	返回套接字的文件描述符。
s.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()	创建一个与该套接字相关连的文件