具有名字的元组
例题1
表示坐标x为1，y为2，z为3的坐标 from collections import namedtuple point = namedtuple(‘坐标‘,[‘x‘,‘y‘,‘z‘]) # 第二个参数可以传可迭代对象 #point = namedtuple(‘坐标‘,‘x y z‘) # 也可以传字符串 字符串之间用逗号隔开 p = point(1,2,3) # 元素个数必须和namedtuple第二个参数里的数量一致 print(p) # 坐标(x=1, y=2, z=3) print(p.x) # 1 print(p.y) # 2 print(p.z) # 3
例题2
用具有元组名来表示扑克牌的花色与大小 from collections import namedtuple card = namedtuple(‘扑克牌‘,‘color number‘) p = card(‘♠‘,‘A‘) print(p) # 扑克牌(color=‘♠‘, number=‘A‘) print(p.color) # ♠ print(p.number) #A
定义：可以快速的从另外一侧追加和推出对象
首先，之前了解过队列，队列就是先进先出(FIFO first in first out)
队列 import queue q = queue.Queue() # 生成队列对象 q.put(‘first‘) # 往队列中添加值 q.put(‘second‘) q.put(‘third‘) print(q.get()) # first # 朝队列要值 print(q.get()) # second print(q.get()) # third print(q.get()) # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止
deque 双端队列
注意
1.队列不支持在任意位置插值，只能在首尾插值
from collections import deque q = deque([‘a‘,‘b‘,‘c‘]) # 生成双端队列对象 q.append(1) # 在尾部添加数字1 q.appendleft(2) # 在左边添加数字2 print(q) # 打印结果：deque([2, ‘a‘, ‘b‘, ‘c‘, 1])
q.pop() # 在添加之后的基础上取出尾部 q.popleft() # 在添加之后的基础上取出头部 print(q) # 打印结果：deque([‘a‘, ‘b‘, ‘c‘]) from collections import deque q = deque([‘a‘,‘b‘,‘c‘]) # 生成双端队列对象 q.insert(1,2) # insert可以根据索引在任意位置插值 print(q) # 打印结果：deque([‘a‘, 2, ‘b‘, ‘c‘])
使用dict时，key时无序的。在对dict做迭代时，我们无法确定key的顺序。
如果需要保持key的顺序，可以用OrderDict
首先定义一个字典：
建议在python2中实现，效果会更加明显 >>> d = dict([(‘a‘,1),(‘b‘,2),(‘c‘,3)]) >>> print(d) {‘a‘: 1, ‘b‘: 2, ‘c‘: 3} # 字典无序 >>> >>> from collections import OrderedDict >>> od = OrderedDict([(‘a‘,1),(‘b‘,2),(‘c‘,3)]) >>> print(od) OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)]) # 字典有序 >>>
定义一个空列表，效果会更加明显 >>> order_d1 = dict() >>> order_d1[‘x‘] = 1 >>> order_d1[‘y‘] = 2 >>> order_d1[‘z‘] = 3 >>> print(order_d1) {‘y‘: 2, ‘x‘: 1, ‘z‘: 3} >>> for i in order_d1: ... print(i) ... y x z >>> #字典无序 >>> from collections import OrderedDict >>> order_d1 = OrderedDict() >>> order_d1[‘x‘] = 1 >>> order_d1[‘y‘] = 2 >>> order_d1[‘z‘] = 3 >>> print(order_d1) OrderedDict([(‘x‘, 1), (‘y‘, 2), (‘z‘, 3)]) >>> for i in order_d1: ... print(i) ... x y z >>> # 字典有序
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {‘k1‘: 大于66 , ‘k2‘: 小于66}from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = defaultdict(list) # 后续该字典中新建的key对应的value默认就是列表 for value in values: if value>66: my_dict[‘k1‘].append(value) else: my_dict[‘k2‘].append(value) print(my_dict) # defaultdict(<class ‘list‘>, {‘k2‘: [11, 22, 33, 44, 55, 66], ‘k1‘: [77, 88, 99, 90]})
s = ‘abcdeabcdabcaba‘ res = Counter(s) print(res) # Counter({‘a‘: 5, ‘b‘: 4, ‘c‘: 3, ‘d‘: 2, ‘e‘: 1})
三种表现形式：
1.时间戳(timestamp)
2.格式化时间（Format String）
3.结构化时间(struct_time)
1.>时间戳
通常来说，时间戳表示的是从1970年1月1日00：00:00开始按秒计算的偏移量.
import time print(time.time()) # 1563447675.0913758 距离1970年1月1日00:00:00的时间（按秒计算）
2.>格式化时间
import time print(time.strftime(‘%Y-%m-%d‘)) # 2019-07-18 print(time.strftime(‘%Y-%m-%d %H-%M-%S‘)) # 2019-07-18 19-10-04 print(time.strftime(‘%Y-%m-%d %X‘)) # 2019-07-18 19:11:18 #print(time.strftime(‘%Y-%m-%d %H-%M-%S‘)) 等价于 print(time.strftime(‘%Y-%m-%d %X‘))
格式化时间字符串（Format String）
%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） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身
3.结构化时间
localtime将一个时间戳转换为当前时区的struct_time import time print(time.localtime()) print(time.localtime(time.time())) print(time.strftime(‘%Y-%m‘,time.localtime()))
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
4.三种格式之间的转换
5.常用方法
1.time.sleep(secs) (线程)推迟指定的时间运行。单位为秒。 2.time.time() 获取当前时间戳
import datetime print(datetime.date.today()) # date:年月日 print(datetime.datetime.today()) # datetime:年月日 时分秒
本地日期 import datetime res = datetime.date.today() print(res.year) # 2019年 print(res.month) # 7月 print(res.day) # 18日 print(res.weekday()) # 0-6表示星期 0表示周一 print(res.isoweekday()) # 1-7表示星期 7就是周日
时间的运算操作
current_time = datetime.date.today() # 日期对象 timetel_t = datetime.timedelta(days=7) # timedelta对象 res1 = current_time+timetel_t # 日期对象 格式： 日期对象 = 日期对象 +/- timedelta对象 timedelta对象 = 日期对象 +/- 日期对象
UTC时间
import datetime dt_today = datetime.datetime.today() # 当前时间 dt_now = datetime.datetime.now() # 当前时间 dt_utcnow = datetime.datetime.utcnow() # UTC时间（相差8个小时） print(dt_today) print(dt_now) print(dt_utcnow)
import random print(random.random()) # 大于0且小于1之间的小数 print(random.uniform(1,2)) # 大于1且小于2之间的小数
2.随机整数
import random print(random.randint(1,5)) # 大于等于1且小于等于5之间的整数 print(random.randrange(1,10,2)) # 大于等于1且小于10之间的奇数
3.随机摇号
import random print(random.choice([1,‘23‘,[4,5]])) #1或者23或者[4,5]
4.练习：
生成随机验证码
import random def get_code(n): code = ‘‘ for i in range(n): # 先生成随机的大写字母 小写字母 数字 upper_str = chr(random.randint(65,90)) lower_str = chr(random.randint(97,122)) random_int = str(random.randint(0,9)) # 从上面三个中随机选择一个作为随机验证码的某一位 code += random.choice([upper_str,lower_str,random_int]) return code res = get_code(4) print(res)
os模块是与操作系统交互的一个接口
os.listdir(‘dirname‘) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表的方式打印
os.mkdir(‘dirname‘) 自动创建文件夹
os.rmdir(‘dirname‘) 只删除空文件夹，若不是空文件夹则无法删除，会报错
os.path.exists 判断文件是否存在
os.path.isfile 只能判断文件，不能判断文件夹th
获取当前工作目录
os.chdir(‘dirname‘) 改变当前工作目录
import sys sys.path.append() # 将某个路径添加到系统的环境变量中 print(sys.platfrom) # 返回操作系统平台名称 print(sys.version) # python解释器的版本 print(sys.argv) # 命令行启动文件 （可以做身份验证）
将其他数据类型转换成字符串的过程叫做序列化.
写入文件的数据必须是字符串
基于网络传输的数据必须是二进制
反序列化：字符串转换成其他数据类型
1.>以某种存储形式使自定义对象持久化
2.>将对象从一个地方传递到另一个地方
3.>是程序更具维护性
所有语言都支持json格式
支持的数据类型很少：字符串，列表，字典，整型，元祖（转成列表） 布尔值
dumps和loads
import json d = {"name":"jason"} res = json.dumps(d) # json格式的字符串 必须是双引号‘{"name": "jason"}‘ print(res,type(res)) # {"name": "jason"} <class ‘str‘> res1 = json.loads(res) # 将json格式的字符串转换成原来的数据类型 print(res1,type(res1)) # {‘name‘: ‘jason‘} <class ‘dict‘>
dump和losd
import json d = {"name":"jason"} with open(‘userinfo‘,‘w‘,encoding=‘utf-8‘) as f: json.dump(d,f) # 转字符串并自动写入文件 with open(‘userinfo‘,‘r‘,encoding=‘utf-8‘) as f: res = json.load(f) print(res,type(res)) # 可以将字符串读取成原来的数据类型
可以将文件写入两次，但是不能够多次反序列化
只支持python
python所有的数据类型都支持
dumps和loads
import pickle d = {‘name‘:‘jason‘} res = pickle.dumps(d) print(pickle.dumps(d)) # 将对象直接转成二进制 res1 = pickle.loads(res) print(res1,type(res1)) # {‘name‘: ‘jason‘} <class ‘dict‘> # 反序列化即可转成原来的数据类型
dump和losd
用pickle操作文件的时候 文件的打开模式必须是b模式
import pickle d = {"name":"jason"} with open(‘userinfo_1‘,‘wb‘) as f: pickle.dump(d,f) # 此为二进制，无法查看 with open(‘userinfo_1‘,‘rb‘) as f: res = pickle.load(f) print(res,type(res)) # {‘name‘: ‘jason‘} <class ‘dict‘>
sub :子
process:进程
subprocess:子进程
1.用户通过网络连接上了你的这台电脑
2.用户输入相应的命令 基于网络发送给了你这台电脑上某个程序
3.获取用户命令 里面subprocess执行该用户命令
4.将执行结果再基于网络发送给用户
这样就实现 用户远程操作你这台电脑的操作
while True: cmd = input(‘cmd>>>:‘).strip() import subprocess obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) # print(obj) print(‘正确命令返回的结果stdout‘,obj.stdout.read().decode(‘gbk‘)) print(‘错误命令返回的提示信息stderr‘,obj.stderr.read().decode(‘gbk‘))
原文：https://www.cnblogs.com/xiongying4/p/11208631.html
