python补充

一、py中内置的专门用来处理事件的标准库模块

该模块下有一个叫做：datetime的类，这个类提供各种时间操作的方法和属性
1，引入

from datetime import datetime,timedelta

2、获取当前日期方法：now(),today()

now = datetime.now()
print(now)

3、创建指定的时间：传参，依次是：年，月，日，时，分，秒为单位的int类型数据

that_time = datetime(1999,9,9,10,10,10)
print(that_time)

4、datetime下的类属性

获取py中日期对象能处理的最小最大日期
print(datetime.min)
print(datetime.max)

5、datetime下的实例属性：year、month、day、hour、minute、second、microsecond

now = datetime.now()
print('当前的时间是：%d年，%d月，%d日，%d时，%d分，%d秒，%d微秒' %(now.year,now.month,now.day,now.hour,now.minute,now.second,now.microsecond))

6、实例方法

weekday():返回日期对象星期几:计数从0开始
print(now.weekday())
isoweekday():返回日期所对应的星期，计数从1开始
print(now.isoweekday())

7、datetime中的+号或-号：可以和timedelta对象创建一个若干时间后的日期对象，timedelta:是一个表示日期或时间的变量

later = now + timedelta(days=3)#创建一个3天的事件变量
early = now - timedelta(days=3) #创建一个三天前的日期变量
print(later)

8、> < == !=:这些判断换运算符进行日期判断，谁比谁早

print(now > early)
print(later < now)
early <=now <=later

9、获取时间戳:timestamp(),以秒为单位（其他语言是以毫秒为单位）
时间戳（timestamp），一个能表示一份数据在某个特定时间之前已经存在的、完整的、可验证的数据,通常是一个字符序列，唯一地标识某一刻的时间

that_time = datetime(1970, 2, 1, 8, 0, 5);
print(that_time.timestamp())

二、自定义元组类：namedtupe,该类是一个工厂函数，创建出各种自定义的tuple子类

from collections import namedtuple, deque, Counter, defaultdict, OrderedDict

1、 namedtuple(a,b):a是要创建的新类类名，b参数是新类中管理数据的索引，列表结构。
创建一个新类，类名是Point,该类创建出的对象除了元组默认自带的属性、方法外，使用x\y作为新数据的索引。
Point = namedtuple('Point', ['z', 'y', 'x'])
通过Point类创建的对象，拥有元组所有的属性和方法

point1 = Point(z=10, y=15, x= 30);
print(point1)
print(point1.x) 
print(point1.y)

2、_make():namedtuple下的类方法，参数是容器类型的数据或迭代器。根据参数创建出一个新对象

nums = [20,130, 20]
p1 = Point._make(nums);
print(p1.x)
print(p1.y)
print(p1.z)

3、实例方法 _asdict()：返回一个列表

p = p1._asdict()
print(p)

4、_replace() :新定义的类是创建自定义的不可变元组的对象，如果要需改对象中的数据，使用_replace()

Circle = namedtuple('Circle', ['x', 'y', 'r']);
circ = Circle(x=5, y=5, r=10)
# print(circ.x)
circ2 = circ._replace(x = 10);
print(circ2.x)
print(circ.x)

5、_source:类属性，获取到定义当前类的源码
print(Circle._source)
6、 _fields:类属性，获取到当前类中的所有属性
print(Circle._fields)
7、deque：创建一个双向列表的对象，list是一个单项列表，双向列表的执行效率比单项列表高

append(x): 从列表的末尾拼接数据

d = deque(range(12))
d.append(10);
d.append(10);
print(d)

appendleft(x): 从列表的开头拼接数据

d.appendleft(-1)

appendleft(x): 从列表的开头拼接数据

d.appendleft(-1)
print(d)

clear():清空列表
copy():深拷贝列表

d1 = d.copy()
print(d1)
d.appendleft(-2)
print(d)
print(d1)

count(x):统计特定参数x在列表中出现的次数

count = d.count(10)
print(count)

extend(iterable):向右扩展列表

d.extend([12, 13, 14, 15])
print(d)

extexdleft(iterable):向左扩展列表

d.extendleft([-10,-9,-8])
print(d)

index(x): 查找x在列表中第一次出现时的下标，并返回，如果没有，程序抛出异常

index = d.index(10);
print(index)

insert(index, x):把元素x插入到index的下标中

d.insert(0, 'hello');
print(d)

pop():从右侧删除最后一个数据，把数据返回出来

data = d.pop()
print(d)
print(data)

popleft():从左侧删除第一个数据，并把数据返回出来

data = d.popleft()
print(d)
print(data)

remove(x):删除列表中第一个x元素,如果指定的元素不存在，程序抛出异常

d.remove(10)
print(d)

reverse()：反转列表中的元素

d.reverse()
print(d)

listDeque = deque([1, 2, 3, 4, 5], 5);
print(listDeque.maxlen)
listDeque.append(10)
print(listDeque)
listDeque.appendleft(0)
print(listDeque)

Counter是dict的子类，常用这个类来统计集合中元素出现的次数
创建counter对象

c1 = Counter('abbcccdcisaxascdsvs')
print(c1['a'])

c2 = Counter({'a':12, 'b':15, 'd': 12});
print(c2)

# 通过关键字参数创建对象
c3 = Counter(name='张三', age=12);
print(c3)

defaultdict(函数)：该类创建出来的对象属于字典类型，与普通字典类型不同的是，如果访问到不存在的key，则会返回默认值，而不是抛出异常

d = defaultdict(lambda: '默认值');
d['name'] = '张三'
d['age'] = 18

print(d['hobby'])

利用defaultdict统计字符个数

s = 'ascascdchowenfdcdcweaxasx'
d = defaultdict(int)
for k in s:
    d[k] = d[k] + 1


print(d)

OrderedDict():创建出来的字典对象是有序字典，key值排序是固定的

od = OrderedDict()
od['x'] = 12
od['y'] = 13
od['z'] = 14
print(od)

py中的正则

引入

import re

match():从头检查字符串和正则是否匹配

s = 'hello world'
 m = re.match('[a-z]',s)
m = re.match('he',s)
print(m.group())

search():在待匹配字符串中任意一个位置上能和正则匹配上，则返回匹配到的对象

m = re.search('l',s)
print(m.group())

字符串拆分：split

s = '10,20,30'
r = re.split('\,',s)#一逗号来切分
print(r)

替换字符串：sub():返回字符串

s = '一只乌鸦口渴了'
r = re.sub('一','二',s)#第一个是要被替换的，第二个是用来替换第一个的，第三个是在s中
print(r)

s = 'dxs43546axfdsgfdgsaf'
r = re.sub('\d+','x',s)
print(r)

subn():返回一个元祖，第一个元素是修改完的字符串，第二个元素是原字符串被修改的次数

r = re.subn('\d+','x',s)
print(r)

findall():返回所有的匹配字符串

s = 'a2143b3254n43'
r = re.findall('\d+',s)
print(r)

finditer():查找所有匹配的字符串，返回值时迭代器

r = re.finditer('\d+',s)
print(r)
for x in r:
    # print(x)
    print(x.group())

处理数据类型转换

import  json
d = {
    "name":"张三",
    "age":12,
    "hobby":["girls","women"]
}

# 序列化：把obj类型设置进文件中
r = json.dump(d,open('./data.json',mode='w+'))

# r = json.dumps(d)
print(r)

# 反序列化：把文件中的json字符串或变量中保存的json字符串转为json对象
with open('./data.json',mode='r+',encoding='utf-8') as f:
    obj = json.load(f)
    print(obj)

异常处理

# try:
    # py中有可能出现错误的语句
# except:[异常类型]:
    #针对异常处理语句

AssertionError:失败的assert语句
AttributeError:失败的属性、索引、赋值
EOFError:文件末尾异常
FloatingPointError:失败的浮点数据操作
GeneratorError：生成器函数内部出错
IOError：输入输出错误
IndentationError：语句缩进出错
KeyError：在影射中key值找不到
keyboardInterrupt:用户按下中断键退出控制台(ctrl+c)
MemoryError:可恢复的内存不足错误
NameError：在全局或局部作用域中未找到名称
NotImpementedError：未实现的功能
OSError：操纵系统错误
RefernceError：引用错误，引用数据类型被销毁，但是依然继续调用
RuntimeError：其他类型未包含的错误
SyntaxError：语法错误
UnicodeError:Unicode编码、解码错误
ValueError:类型正确，值错误
ZeroDivisionError：除0错误

强制抛出异常：有程序员手动通过代码向控制台报错
raise语句抛出异常
raise NameError('名字出错啦')

try:
    raise NameError('a变量不存在')
except NameError as error:
    print(error)
    print('异常被捕捉到')
except ValueError:
    print('异常被ValueError捕捉')

网络编程

TCP编程
客户端

# 导入socket模块下的所有方法
from socket import *

#创建表里保存地址信息
# 客户端要连接的服务器ip
host = 'localhost'
# 要连接的服务器的端口号
port = 10000
# 创建服务器地址
address = (host,port)
# 客户端缓冲区的大小(字节)
bufSize = 1024

# 创建套接字对象
tcpCliSocket = socket(AF_INET,SOCK_STREAM)#socket函数
# 用套接字(客户端)连接服务器
tcpCliSocket.connect(address)
while True:
    data = input('>')
    if not data:
        break
    # 把用户输入的消息发送给服务器端
    tcpCliSocket.send(data.encode('utf-8'))
    #接收服务器响应
    data = tcpCliSocket.recv(bufSize)
    if not data:
        break
    # 把接收到的数据显示在控制台中
    print(data.decode('utf-8'))
#如果程序出现意外：遇到空字符而离开死循环，关闭会话连接
tcpCliSocket.close()

服务器端

from socket import *
import re
host = 'localhost'
port = 10000
address = (host,port)
bufSize = 1024

# 创建socket对象
tcpSevSock = socket(AF_INET,SOCK_STREAM)
#绑定物理网卡
tcpSevSock.bind(address)
# 监听来自客户端请求状态
tcpSevSock.listen()

print("正在等待客户端链接...")
# 接收客户端链接
tcpCliSock,cliAddress = tcpSevSock.accept()
print('来自：' ,cliAddress,'的链接...')
while True:
    #获取到客户端发过来
    data = tcpCliSock.recv(bufSize)
    if not data:
        break
    # 解码数据
    data = data.decode('utf-8')
    if re.search('傻x',data):
        data = '请不要骂人哦'
    elif re.search('吃饭',data):
        data = '不要吃太多，会被杀掉哦'
    else:
        data = '我不理解妮子啊说什么'
    # 向客户端发送数据
    tcpCliSock.send(data.encode('utf-8'))
# 如果意外退出循环，关闭服务器和客户端
tcpCliSock.close()
tcpSevSock.close()

UDP编程
客户端

from socket import *
host = 'localhost'
port = 20000
address = (host,port)
bufSize = 1024
# 创建基于udp协议的socket对象
udpCliSock = socket(AF_INET,SOCK_DGRAM)
# 把用户数据发给服务器
while True:
    data = input('>')
    if not data:
        break
    # 发数据到指定的地址
    udpCliSock.sendto(data.encode('utf-8'),address)
udpCliSock.close()