或者一个字典中对应key的数据，如果有对应key，则返回key的值，如果没有则返回default默认值，如果没有设置默认值，则按None处理
2）dict()函数
生成字典
b = ((1, "张三"), (2, "李四"), (3, "王五")) b = [(1, "张三"), (2, "李四"), (3, "王五")] b = ([1, "张三"], [2, "李四"], [3, "王五"]) b = [[1, "张三"], [2, "李四"], [3, "王五"]] # 四种方式均可以 print(dict(b)) 输出： {1:"张三"，2:"李四"，3:"王五"}当有两个列表或元祖符合键值对时，可以使用zip（）函数现将键值对组合.
x = (1, 2, 3) y = ("红", "黄", "蓝") print(dict(zip(x, y)))
3）zip()函数
把可迭代对象按索引进行组合成元祖，按对象中最小索引返回，返回的是zip对象（可迭代对象），可以以列表list()这个函数（对象迭代器）的形式将其以列表形式读取出来
aList = [1, 2, 3, 4] print(list(zip(aList))) # 结果为：[(1,), (2,), (3,), (4,)]aList = [1, 2, 3, 4] bList = ["a", "b", "c", "d"] print(list(zip(aList, bList))) # 结果：[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]aList = [1, 2, 3, 4] bList = ["a", "b", "c", "d"] for i, j in zip(aList,bList): print(i, j) # 结果： 1 a 2 b 3 c 4 d
4）range(起始值，结束值，步进值)函数
生成一个左开右闭数列，同时返回的是一个range对象（可迭代对象），需要用list（）函数进行读取
print(list(range(1, 10, 1))) # 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]其中起始值默认为0，步进值默认为1，要省略同时省略
print(list(range(10))) # 结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]5)pprint()模块
使长字段文本更容易阅读
import pprint d = { "apple": {"juice":4, "pie":5}, "orange": {"juice":6, "cake":7}, "pear": {"cake":8, "pie":9} } pprint.print(d) # 结果： {'apple': {'juice': 4, 'pie': 5}, 'orange': {'cake': 7, 'juice': 6}, 'pear': {'cake': 8, 'pie': 9}}参考链接：
6)Threading多线程模块
threading.Thread(target=函数)
进行多线程创建
import threading import time def demo_1(): while True: print("111111") time.sleep(1) t1 = threading.Thread(target=demo_1) t1.start() while True: print("333333") time.sleep(1)threading.Thread(targrt=函数，args(x, y,...))
当多线程的函数需要传递参数时，需要用args进行传递，注意这里必须是元组形式，不管参数有几个
import threading import time def demo_1(num1, num2): print(num1+num2) time.sleep(1) t1 = threading.Thread(target=demo_1, args=(1, 2)) t1.start()threading.Thread(targrt=函数，args(x, y,...)， kwargs={})
当需要指定传递的参数时，可以使用kwargs，进行指定参数的传递，这里的key就是对应要传递的参数名，对应key值就是要传递的值
import threading import time def demo_1(num1, num2, n): print(num1+num2+n) time.sleep(1) t1 = threading.Thread(target=demo_1, args=(1, 2), kwargs={"n": 1}) t1.start()threading.enumerate()
生成一个当前进程数的列表
import threading import time print(threading.enumerate()) def demo_1(): for a in range(5): print("111111") time.sleep(1) t1 = threading.Thread(target=demo_1) t1.start() print(threading.enumerate()) time.sleep(6) print(threading.enumerate())通过创建类来继承threading父类
用此方法时，必须创建run方法，通过创建的类方法调用start（），程序会自动寻找run
方法进行多线程操作，run方法的结束意味着多线程结束
import threading class MyThread(threading.Thread): def run(self): print("hahahah") t_1 = MyThread() t_1.start()threading.Thread.join()
用来阻塞主线程，作用是，等副线程结束后，才会继续操作主线程
import threading from time import sleep, ctime def world(): for i in range(2): print "Hello World! " + ctime() sleep(2) def ivanli(): for i in range(2): print "Hello Ivanli! " + ctime() sleep(5) def getThreads(): threads = [] t1 = threading.Thread(target=world) t2 = threading.Thread(target=ivanli) threads.append(t1) threads.append(t2) return threads if __name__ == "__main__": threads = getThreads() for t in threads: t.start() for t in threads: t.join() print "main process .. " main process最后才会输出如果在每个线程后跟上join（）那么每个线程都会被保护，即执行完第一个线程后，才会执行接下来的线程
import threading from time import sleep, ctime def world(): for i in range(2): print "Hello World! " + ctime() sleep(2) def ivanli(): for i in range(2): print "Hello Ivanli! " + ctime() sleep(5) def getThreads(): threads = [] t1 = threading.Thread(target=world) t2 = threading.Thread(target=ivanli) threads.append(t1) threads.append(t2) return threads if __name__ == "__main__": threads = getThreads() for t in threads: t.start() t.join() print "main process .. "threading.Event（）
1）threading.Event（）.set()：主动设置为True
2）threading.Event（）.clear()：主动设置为False
3）threading.Event（）.wait(Timeout=None)：等待None s设置为True，若未设置，则
永远等待
在副进程的过程中，如果事件被置为False，则会一直等待事件被置为True后，才会继续副进程中接下来的代码
import threading import time,random def say(e): time.sleep(random.random()) print '准备说话中。。。。' e.wait() time.sleep(random.random()) print('%s->可以开始说话了' % (threading.currentThread().name)) e = threading.Event() t1 = threading.Thread(target=say, args=(e,), name='线程1') t2 = threading.Thread(target=say, args=(e,), name='线程2') t1.start() t2.start() time.sleep(10) e.set() 两个副进程到“准备说话中。。。”时就在等待事件被置为True，直到主进程运行到了set()才会继续进程
7)格式化操作符
print("{0}:{1}".format(10, 1)) # 类似传参，012.。代表参数的位置 print("{0}{name}".format(10, name=1)) # 传参，但是可以指定参数名称 print("{0:.3f}".format(3.14159)) # 传参，通过：指定对参数的操作。3f就保留小数点后三位 print("{0:10}={1:10d}".format(10, 20)) # 传参，通过：指定对参数的操作10即参数右侧空10位，10d就是左侧空十位 print("{0:*>10}".format(1)) # 传参，通过>指定符号的复用，左侧为符号，右侧为复用次数 print("{0:*>10,.2f}".format(100)) # 传参，通过，可以指定多种操作 print("二进制输出{0:b}".format(15)) # 传参，通过d可以进行二进制转换 print("十六进制输出{0:x}".format(15)) # 传参，通过x可以进行十六进制转换 print("千分位输出{0:,}".format(100000000)) # 传参，通过，进行千分位识别 print("{0:+f}".format(11)) # 传参，通过+f可进行带符号输出 print("{0:.2%}".format(0.1234)) # 传参，通过.2%进行百分数操作
8)os模块
os.rename("目标文件/目录名"，"需要更改的文件/目录名")
当需要对其他路径文件进行操作时，需要将加上路径，注意：操作文件名时，只能在相同目录下进行改名，即需要更改的文件名路劲必须加上，且与原始路径一致
os.renames("1111", "2222") os.rename('C:\\Users\\Xianlinnvwu\\Desktop\\新建 文本文档.txt', "C:\\Users\\Xianlinnvwu\\Desktop\\新建个屁.txt")os.renames("目标文件/目录名", "需要更改的文件/目录名")
区别与rename的地方是，此方法可以进行目录树状结构的创建，及可以使用不同目录进行修改，既能修改文件，也能修改目录
os.renames('2222', "b/333")os.remove("文件名")
该方法只能删除文件，不能删除目录
os.remove("b\\333")os.rmdir("目录名")
注意，该目录必须是空目录，否则不能删除，但可以是多层级目录，最终能够删除的是最后那个目录
os.rmdir("a\\b\\c")os.removedirs("目录名")
注意，该目录必须是空目录，否则不能删除，而且对多层级目录进行删除时，会直接删除多层级目录
os.removedirs("a\\b\\c")os.mkdir("需要创建的目录名")
注意，只能在已有的目录下创建新的目录，不能创建目录树
os.mkdir("a")os.makedirs("需要创建的目录名")
注意，可以创建目录树
os.makedirs("a\\b\\c\\d\\f")os.getcwd()
获取当前目录
os.getcwd()os.listdir("目标目录")
将目标目录的内容以列表形式展现
print(os.listdir("a啊"))对文件的高级操作：
a_file = open("a啊\\b啊\\1.txt", "r", encoding="utf-8") b_file = open("a啊\\2.txt", "w", encoding="utf-8") a = a_file.read(1024) b = b_file.write(a)w、r用来指定文件的读写操作类型
调用file.read(数据大小)，可以指定一次性读取内容的大小，以kb为单位
os.path.abspath()
获取当前的绝对路径
print(os.path.abspath(__file__)) # 会输出当前文件 print(os.path.abspath("")) # 只有当前目录 print(os.getcwd()) # 与上面一样os.path.join(路径1, 路径2...)
将路径进行合并
a = "1" b = "2" print(os.path.join(a, b))os.path.split(路径)
将路径进行拆分，分为目录+文件的元组形式
a = "D:\Pycharm\mygame\venv\Scripts\python.exe" print(os.path.split(a)) # 输出为('D:\\Pycharm\\mygame\x0benv\\Scripts', 'python.exe')os.path.splitext(路径)
获取当前文件名类型，分为目录+文件类型的元组形式
a = "D:\Pycharm\mygame\venv\Scripts\python.exe" print(os.path.splitext(a)) # 输出为('D:\\Pycharm\\mygame\x0benv\\Scripts\\python', '.exe')os.path.isdir(路径)判断是不是目录
os.path.exist(路径)判断路径是否真实存在
os.path.isfile(路径)判断是不是文件
os.path.getsize(文件路径)获取文件大小
os.path.dirname(文件)获取目标文件的目录
os.path.basename(文件)获取当前文件名和类型
os.path.getatime(路径)获取最后访问时间
os.pathctime(路径)获取最近创建时间
os.pathmtime(路径)获取文件的修改时间
8)hashlib加密模块
hashlib.md5(str（列表名）).encode（"UTF-8"）)
进行md5加密指定字符串
import hashlib password = "daohaozhe" h1 = hashlib.md5(str(password).encode("utf8"))hashlib.md5(str（列表名）).encode（"UTF-8"）).hexdigest()
获取加密后的数据
import hashlib password = "daohaozhe" h1 = hashlib.md5(str(password).encode("utf8")) print(h1.hexdigest())
9） Python数据类型：bytes和bytearray
都是二进制数据类型，将数据通过二进制进行编码
bytes
类似于字符串，字符串是由一个个字符顺序存储组成的序列，其中每个元素为一个字符。bytes是由一个个bute组成的序列，每一个元素是一个byte
bytearray
是由一个个byte组成的array，其中每一元素为一个byte。
总结：
bytes：可以看做是一组二进制数值（0-255）的str序列
bytearray：可以看做是一组二进制数值（0-255）的list序列
10）字典多值遍历
dict_a = {"a": 1, "b": 2, "c": 3} for a, b in dict_a.items(): print(a) print(b)dict.items()会返回key和key值，所以遍历时，需要用两个参数来接收
11）json模块
可以识别json内容
import json from pprint import pprint with open("can_commands.json","r") as file: dict_read = json.load(file) pprint(dict_read) print(type(dict_read))通过json.load()将内容里的数据以python能识别的对象方式返回，
12）configparser()模块
对配置文件ini进行读写操作
configparser.ConfigParser()
创建一个配置类，通过类可以完成读写操作
import configparser config = configparser.ConfigParserconfig.read("ini文件路径"，encode=utf-8"")
读取ini文件的内容
config.read('pcan_config.ini', encoding="utf-8")config.sections()
读取ini文件内的节点名，并返回一个列表
import configparser config = configparser.ConfigParser() config.read('pcan_config.ini', encoding="utf-8") print(config.sections()) # ['can', 'canfd']config.items（"节点"）
读取对应节点中的内容，并返回一个列表，每个元素都是一对元祖
import configparser config = configparser.ConfigParser() config.read('pcan_config.ini', encoding="utf-8") print(config.sections()) # ['can', 'canfd'] print(config.items("can")) # [('dbc', '20220318-jh1-ES33_ICM_V4.6_INFOCAN_Cluster.dbc'), ('channel', 'PCAN_USBBUS1'), ('bitrate', '500000')] for key, value in config.items("can"): print(key, value) # dbc 20220318-jh1-ES33_ICM_V4.6_INFOCAN_Cluster.dbc # channel PCAN_USBBUS1 # bitrate 500000config.get("节点名"，"节点下的kye")
返回ini文件中对应节点名下的kye的值
import configparser config = configparser.ConfigParser() config.read('pcan_config.ini', encoding="utf-8") print(config.sections()) # ['can', 'canfd'] print(config.items("can")) # [('dbc', '20220318-jh1-ES33_ICM_V4.6_INFOCAN_Cluster.dbc'), ('channel', 'PCAN_USBBUS1'), ('bitrate', '500000')] for key, value in config.items("can"): print(key, value) # dbc 20220318-jh1-ES33_ICM_V4.6_INFOCAN_Cluster.dbc # channel PCAN_USBBUS1 # bitrate 500000 print(config.get("can", "dbc")) # 20220318-jh1-ES33_ICM_V4.6_INFOCAN_Cluster.dbcconfig.has_section("需要搜索的节点名")
查找对应ini文件中是否有搜索节点，返回布尔
print(config.has_section("can")) # Trueconfig.add_section("需要增加的节点名")
在当前读取的ini内存中，增加一个节点名，注意：当前只存在于内存
config.write(一个文件对象)
将当前读取的ini内存，写入ini文件中
文件对象：open（"路径"，"w", encoding="utf-8"）
改文件若不存在，则会自动生成
config.write(open("pcan_config.ini", "w", encoding="utf-8"))config.set("节点名","需要指定的key", "需要指定的key值")
在对应节点增加需要的键值对
注意：当前只存在内存中，要写入，需要write
config.set("can", "num", "3")config.remove_section("需要删除的节点名")
删除指定节点，
注意，当前只在内存删除，要写入，需要write
config.remove_section("lin")config.remove_option("需要key所在的节点"，"需要删除的key")
删除指定节点下的键值对
注意，当前只在内存中删除，要写入，需要write
config.remove_option("can", "num")
13f-string格式化字符串常量
使字符串的拼接更加方便
age = 18 age_diff = 5 print("我今年"+str(age)+"岁，他比我大"+str(age——diff)+"岁") print(f"我今年{age}岁，他比我大{age_diff}岁")
14pysimpelgui-exemaker
1)将PySimpleGUI生成的应用程序打包成exe应用程序
pip install pysimplegui-exemaker
2) 使用方式
在cmd中输入：
python -m pysimplegui-exemaker.pysimplegui-exemaker
15queue
queue的类有四种
1) queue.Queue(maxsize=0)
先进先出队列
maxsize整数，设置队列的最大程度
2) queue.LifoQueue(maxsize=0)
后进先出队列
3) queue.PriorityQueue(maxsize=0)
优先级队列，比较队列每个数据大小，值最小的最先出队(只能比较数字)，一般以
(1,data),(2,data)..这种方式进行数据插入
4) queue.SimpleQueue
先进先出队列的简单类型，没有大小限制，缺少task_done,join这些高级功能
queue的异常种类
1) queue.Empty
主要用于队列没有数据仍取数据时抛出的异常
2) queue.Full
主要用于队列元素容量上限后，继续放入队列时抛出的异常
queue具体类的方法（以下以q代替）
1) q.qsize()
返回队列中元素的个数
2) q.empty()
如果队列为空，返回True，否则返回False
3) q.full()
如果队列元素上限，返回True，否则返回False
4) q.put(item,block=True,timeout=None)
item：放入队列的数据元素
block：判断队列上限时是否可以继续等待放入数据，如果为False，则直接抛出
queue.full异常；如果为True，则可接受timeout时间内放入等待数据，如果
超时，抛出queue.full异常，如timeout未定义，则可以一直等待
5) q.put_nowait(item)
相当于q.put的block=False，即立即检测是否可以放入，否则抛出异常
6) q.get(block=True,timeout=None)
block：判断是否还有数据元素可以取出，如果为False，不会等待，直接抛出异常
queue.Empty；如果为True，则可接受timeout时间内取出数据元素，如果
超时，抛出queue.Empty，如timeout未定义，则可一直等待
7）q.get_nowait()
相当于q.get的block=False，即立即检测是否可以取出，否则抛出异常
queue的高级方法：
1）q.task_done()
一个动作标志，每个get都必须获取一个数据元素，该标志的出现表示队列内的数
据元素已被取出，后续告诉队列，该数据的处理已完成。如果被调用的次数杜宇放
入队列中元素的个数，则抛出ValueError异常。
2）q.join()
与task_done组合使用，他的出现可以一直阻塞后续程序的运行，直到队列中所有
数据元素都被取出和执行，当然只要有元素添加到queue中，task_done都得更
新，直到最终计数等于0，join()作用消失，不会阻塞
16assert
assert judge,str(错误事件抛出文本)
自定义一个条件judge，事件满足条件，程序继续运行，否则 抛出异常"错误事件抛出文本"
17多进程Process
1）用法
from multiprocessing import Process
与多线程的对比
18协程
1）用法
-依赖库
import asyncio
-获取事件循环
loop = asyncio.get_event_loop()
-定义协程
async def myfunc(url):
await get_url(url)
-创建task列表
tasks = [loop.create_task(myfunc(url))for url in urls]
-执行爬虫事件列表
loop.run_until_complete(asyncio.wait(tasks))
19vars
1)vars(object)说明
返回object的属性和属性值的字典对象
class ni(): def __init__(self, a, b, c, d): self.a = a self.b = b self.c = c self.d = d nni = ni(2, 4, 5, 7) print(vars(nni)) for i, j in vars(nni).items(): print(i, '=', j)结果：
{'a': 2, 'b': 4, 'c': 5, 'd': 7} a = 2 b = 4 c = 5 d = 7
20map()
1)map(function,iterable,...)
第一个参数 function 以参数序列(iterable)中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
def plus(a): a += 1 return a a = [1,2] res = map(plus,a) 结果：[2,3]def add(a,b): return a+b a= (1, 2) b = (2,4) res = map(add, a, b) 结果:[3,6]
21time&datetime
from datetime import * import time #要写在from datetime import *的后面 print(time.strftime('%Y/%m/%d %H:%M', time.localtime())) print(datetime.datetime(2022, 6, 29, 23, 59)) print(datetime.datetime.now().strftime('%Y/%m/%d %H:%M')) print(datetime.datetime(2022, 6, 29, 23, 59).strftime('%Y/%m/%d %H:%M'))按自己的形式进行格式化输出
扫一扫
5204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
