1.执行cmd命令，不显示执行过程中弹出的黑框1234567891011def run_cmd( cmd_str='', echo_print=1):    """    执行cmd命令，不显示执行过程中弹出的黑框    备注：subprocess.run()函数会将本来打印到cmd上的内容打印到python执行界面上，所以避免了出现cmd弹出框的问题    :param cmd_str: 执行的cmd命令    :return:     """    from subprocess import run    if echo_print == 1:        print('\n执行cmd指令="{}"'.format(cmd_str))    run(cmd_str, shell=True)2.执行cmd命令，并得到执行后的返回值，python调试界面输出返回值12345678910def run_cmd_Popen_fileno(cmd_string):    """    执行cmd命令，并得到执行后的返回值，python调试界面输出返回值    :param cmd_string: cmd命令，如：'adb devices'    :return:    """    import subprocess         print('运行cmd指令：{}'.format(cmd_string))    return subprocess.Popen(cmd_string, shell=True, stdout=None, stderr=None).wait()3.执行cmd命令，并得到执行后的返回值,python调试界面不输出返回值12345678910def run_cmd_Popen_PIPE(cmd_string):    """    执行cmd命令，并得到执行后的返回值,python调试界面不输出返回值    :param cmd_string: cmd命令，如：'adb devices"'    :return:    """    import subprocess         print('运行cmd指令：{}'.format(cmd_string))    return subprocess.Popen(cmd_string, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding='gbk').communicate()[0]调用方法1234if __name__ == '__main__':    run_cmd_run('adb devices')    run_cmd_Popen_fileno('adb devices')    run_cmd_Popen_PIPE('adb devices')执行结果执行cmd指令="adb devices"List of devices attached3356caad    device运行cmd指令：adb devicesList of devices attached3356caad    device运行cmd指令：adb devices补充：python调用cmd进行输入输出由于程序需要用java和python混用，所以可以取巧，就是在python中调用cmd，在cmd中执行java所以，进行了一下测试。完美运行123456import oswith open("text1.txt","w",encoding="utf8") as file1:    mystr = os.popen("ipconfig")  # popen与system可以执行指令,popen可以接受返回对象    mystr = mystr.read()  # 读取输出    file1.write(mystr)     #写入文件

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。def sum_fun(*args):      def add_fun():         s = 0         for i in args:             s += i         return s     return add_fun  f = sum_fun(1, 2, 3, 4, 5, 6, 7, 8, 9) add = f() print(add)  # 45 当我们调用 sum_fun 时，返回的并不是求和结果，而是求和函数 add_fun , 将其赋值给f，当我们在调f函数时才返回求和结果s。用filter函数来计算素数  用filter来计算素数其中一个方法是埃氏筛法。  给出要筛数值的范围n，找出以内的素数。先用2去筛，即把2留下，把2的倍数剔除掉；再用下一个质数，也就是3筛，把3留下，把3的倍数剔除掉；接下去用下一个质数5筛，把5留下，把5的倍数剔除掉；不断重复下去…用Python高阶函数来实现这个算法：1、我们先写一个生成器构造一个从3开始的无限奇数序列，首先排除偶数。12345def odd_num():  # 奇数生成器函数    n = 1    while True:        n += 2        yield n2、写一个筛选的函数，这里使用了匿名函数，返回判断是否为可整除数12def un_divisible(n):  # 判断是否为可整除数    return lambda x: x % n > 03、使用filter来过滤，不断返回素数的生成迭代1234567def primes():  # 素数生成器函数    yield 2    it = odd_num()    while True:        n = next(it)        yield n        it = filter(un_divisible(n), it)  # 过滤出不可以整除的数4、判断素数方法就产生了，这里需要手动结束一下12345for i in primes():  # 打印小于100的素数    if i < 100:        print(i)    else:        break 高阶函数实现打印小于100的素数：12345678910111213141516171819202122232425262728293031323334# -*- coding: utf-8 -*-# @File  : 返回函数计算质数.py# @author: Flyme awei # @email : Flymeawei@163.com# @Time  : 2022/8/21 15:17# 得到所有的质数，打印小于100的所有的质数# 最小的质数是2， 质数:只能被1和它本身整除的数# 思路:先得到所有大于1的奇数， --> 生成器，在把生成器中的所有元素过滤去掉: 那些可以被小于元素本身的质数整除的数# 1.得到所有的大于1奇数的生def odd_num():    n = 1    while True:        n += 2        yield ndef un_divisible(n):  # 判断是否能够整除的函数，n代表从生成器中拿到的一个大于1的质数    return lambda x: x % n > 0  # x是某一个奇数，n:小于当前x的一个质数# 2.创建一个质数的生成器，最小的质数是2def primes():    yield 2    n = odd_num()  # g为大于1的奇数生成器    while True:        x = next(n)        g = filter(un_divisible(n), n)        yield xfor i in primes():    if i < 100:        print(i, end=' ')    else:        break

re.search()：匹配整个字符串，并返回第一个成功的匹配。如果匹配失败，则返回None pattern: 匹配的规则,string : 要匹配的内容,flags 标志位 这个是可选的,就是可以不写,可以写, 比如要忽略字符的大小写就可以使用标志位flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：re.I 忽略大小写re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境re.M 多行模式re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库re.X 为了增加可读性，忽略空格和 # 后面的注释示例代码：【检查字符串是否以 "Long" 开头并以 "China" 结尾】import re   s = "Long live the people's Republic of China" ret = re.search("^Long.*China$", s)   print(ret) print(ret.group()) print(ret[0]) 示例代码：【在字符串中搜索第一个空白字符】import re   s = "Long live the people's Republic of China" ret = re.search("\s", s)   print(ret) print(ret.start())示例代码：【如果search未匹配到，返回None】import re  s = "Long live the people's Republic of China"ret = re.search("USA", s)  print(ret) 示例代码：【忽略大小写】import re   s = "Long live the people's Republic of China" # ret1 = re.search('long', s)  这行代码直接报错 ret1 = re.search('l', s) print(ret1) print(ret1.span()) print(ret1.string) print(ret1.group())   print("*" * 50)   ret2 = re.search('long', s, re.I) print(ret2) print(ret2.span()) print(ret2.string) print(ret2.group())示例代码：【group()的使用】 import re   s = 'abc123def456ghi789' ret_compile = re.compile("([a-z]*)([0-9]*)([a-z]*)") print(ret_compile)   ret = ret_compile.search(s) print(ret) print(ret.group()) print(ret.group(0))  # group()和group(0) 一样匹配的是整体 print(ret.group(1))  # 匹配第1个小括号的内容 print(ret.group(2))  # 匹配第2个小括号的内容 print(ret.group(3))  # 匹配第3个小括号的内容 示例代码：【group()分组的使用】import re   s = 'abc123def456ghi789' ret_compile = re.compile("(?P[a-z]*)(?P[0-9]*)(?P[a-z]*)") print(ret_compile)   ret = ret_compile.search(s) print(ret) print(ret.group()) print(ret.group(0))  # group()和group(0) 一样匹配的是整体 print(ret.group(1))  # 匹配第1个小括号的内容 print(ret.group(2))  # 匹配第2个小括号的内容 print(ret.group(3))  # 匹配第3个小括号的内容   print("*" * 100)   print(ret.group()) print(ret.group("num1"))  # 这里效果等同于group(1) print(ret.group("num2"))  # 这里效果等同于group(3) print(ret.group("num3"))  # 这里效果等同于group(3)

 Xpath是什么？ XPath即为XML路径语言（XML Path Language），它是一种用来确定XML文档中某部分位置的语言。 XPath基于XML的树状结构，提供在数据结构树中找寻节点的能力。起初XPath的提出的初衷是将其作为一个通用的、介于XPointer与XSL间的语法模型。但是XPath很快地被开发者采用来当作小型查询语言。  安装xpath库 1、我们需要进入当前我们这个项目的Scripts目录打开cmd  查看目录方法:在pycharm中file -> setting -> Project: exercise -> Project Interpreter查看其中的 Project Interpreter 中的地址  2、进入cmd进入该目录  3、安装 pip install lxml如果没有在项目下pip可能会报错，但是放心这里虽然报错但是可以运行xpath语法介绍路径常用规则nodename：选取此节点的所有子节点/：从根节点选取//：选取所有节点，不考虑位置.:选取当前节点..:选取当前节点的父节点@：选取属性 谓语规则  谓语被镶嵌在方括号内用来查找某个特定的节点或者包含某个特定的值的节点  xpath('/body/div[1]'):选取body下的第一个div节点 xpath('/body/div[last()]'):选取body下最后一个div节点 xpath('/body/div[last()-1]'):选取body下倒数第二个div节点 xpath('/body/div[positon()]'):选取body下前两个div节点 xpath(/body/div[@class]'):选取body下带有class属性的div节点 xpath('/body/div[@class="main"]'):选取body 下class属性为main的div节点 xpath('/body/div[price>35.00]'):选取body 下price元素值大于35的div节点 通配符  xpath ('/div/*'):选取div下的所有子节点 xpath('ldiv[@*]'):选取所有带属性的div节点 xpath('//div|//table'):选取所有的div和table节点 使用"|”运算符可以选取多个路径  函数介绍  starts-with：例xpath('I/div[starts-with(@id,"ma")J')选取id值以ma开头的div节点 contains：例xpath('lldiv[contains(@id, "ma")J')选取id值包含ma的div节点 and：例xpath('I/div[contains(@id,"ma") and contains(@id,"in")J')选取id值包含ma和in的div节点 text()：例xpath('I/div[contains(text(), "ma")) 选取节点文本包含ma的div节点 xpath使用范例 from lxml import etree wb_data = """ first itemsecond itemthird itemfourth itemfifth item"""html = etree.HTML(wb_data)print(html)result = etree.tostring(html)print(result.decode("utf-8"))我们输出了一个html对象，使用etree.tostring(html)方法可以补全我们在html里没有完成的标签，所以给我们补上了最后一个a标签的后半部分，而且给我们补上了1、使用/获取某个标签的内容from lxml import etreewb_data = """ first itemsecond itemthird itemfourth itemfifth item"""html = etree.HTML(wb_data)html_data = html.xpath('/html/body/div/ul/li/a')print(html)for i in html_data:print(i.text)这里还有另外一种方法，可以在需要找的内容后面加/text()就行效果于上面相同2、打开读取html文件新建html文档hello.html编写如下内容first itemsecond itemthird itemfourth itemfifth item试着打开读取htmlhtml = etree.parse('test.html')html_data = etree.tostring(html,pretty_print=True)res = html_data.decode('utf-8')print(res)3、打印指定路径下a标签的属性（可以通过遍历拿到某个属性的值，查找标签的内容）html = etree.HTML(wb_data)html_data = html.xpath('/html/body/div/ul/li/a/@href')for i in html_data: print(i)4、查找到绝对路径下a标签属性等于link2.html的标签我们知道我们使用xpath拿到得都是一个个的ElementTree对象，所以如果需要查找内容的话，还需要遍历拿到数据的列表。html = etree.HTML(wb_data)html_data = html.xpath('/html/body/div/ul/li/a[@href="link2.html"]/text()')print(html_data)for i in html_data: print(i)5、使用绝对路径查找，查找li标签下的a标签内容html = etree.HTML(wb_data)html_data = html.xpath('//li/a/text()')print(html_data)for i in html_data: print(i)

浅拷贝：切片，赋值，调用copy模块的copy方法深拷贝：用copy模块的deepcopy方法Python 中的大多数对象，比如列表 list、字典 dict、集合 set、numpy 数组，和用户定义的类型（类），都是可变的。意味着这些对象或包含的值可以被修改。但也有些对象是不可变的，例如数值型 int、字符串型 str 和元组 tuple。1、复制不可变数据类型：复制不可变数据类型，不管 copy 还是 deepcopy, 都是同一个地址。当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的 id 值与浅复制原来的值相同。2、复制可变数据类型：    直接赋值：其实就是对象的引用（别名）。    浅拷贝(copy)：拷贝父对象，不会拷贝对象内部的子对象（拷贝可以理解为创建内存）。产生浅拷贝的操作有以下几种：        使用切片 [:] 操作        使用工厂函数（如 list/dir/set ）, 工厂函数看上去像函数，实质上是类，调用时实际上是生成了该类型的一个实例，就像工厂生产货物一样.        使用copy 模块中的 copy() 函数，b = a.copy(), a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。    深拷贝(deepcopy)：copy 模块的 deepcopy() 方法，完全拷贝了父对象及其子对象，两者是完全独立的。深拷贝，包含对象里面的子对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变。浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象（容器）就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型（没有子对象），没有拷贝一说，产生的都是原对象的引用。浅明拷贝与深拷贝的区别：#!/usr/bin/Python3# -*-coding:utf-8 -*-import copya = [1, 2, 3, ['a', 'b', 'c']]b = a  # 赋值，传对象的引用c = copy.copy(a)  # 浅拷贝d = copy.deepcopy(a)  # 深拷贝a.append(4)a[3].append('d')print(id(a), id(b), id(c), id(d))  # a 与 b 的内存地址相同print('a = ', a)print('b = ', b)print('c = ', c)print('d = ', d)  # [1, 2, 3, ['a', 'b', 'c']]

python基本数据类型python中的基本数据类型可以分为两类数字类型（number）：整型（int）浮点型（float）布尔值（Bool）复数（complex）组合数据（composite Data）：字符串（String）列表（List）元组（Tuple）字典（Dictionary）集合（Set）同时还有特殊的一种类型：空类型（None）整型（int）整型(Int)：包括正整数、负整数和零。在Python中，整型不限制大小，没有Python 2.X中的长整型(Long)。整数可以是二进制、八进制、十进制和十六进制整数。十进制整数，使用0～9共10个数字表示，如3、-4、0等。二进制整数，以0B或0b开头，如：0B1011(相当于- 十进制的11)、-0b101(相当于十进制的-5)。八进制整数，以0o或0O 开头，如：0o56(相当于十进制的46)、-0O145(相当于十进制的-101)。十六进制整数，以0x 或0X开头，如：0xAF(相当于十进制的175)、-0X123(相当于十进制的-291)。不同进制的数可以通过python内置函数相互转化：bin（）函数：将其他进制的数转化为二进制数。int（）函数：将其他进制数转化为十进制数。oct（）函数：将其他进制数转化为八进制数。hex（）函数：将其他进制数转化为十六进制数。print("十进制数→二进制数:", bin(56)) print("十进制数→八进制数:", oct(-32)) print("十六进制数→十进制数:", int(0x48)) print("十进制数→十六进制数:", hex(18))输出结果为：十进制数→二进制数: 0b111000 十进制数→八进制数: -0o40 十六进制数→十进制数: 72 十进制数→十六进制数: 0x12在python3.6上的版本中可以支持数字键使用_分隔符进行分隔，这样来大大提高可读性print(3_4_5_6) print(1_2_3.4_5_6)输出结果：3456 123.456浮点型浮点类型（Float）类型：包括整数部分和小数部分，十进制形式，也可以用科学计数法表示（带有指数的浮点数）。十进制表示的浮点数，如0.33、-7.88、0.0等科学计数法表示的浮点数，如32.6e18(相当于3.26×1019)，-9.268E-3(相当于-0.009268)。在Python中，浮点数有大约17位有效数字，绝对值范围10-308到10308的，不支持32位的单精度浮点数。范例：浮点数的不同输出格式：f = 32.6e18 print("f =",f) print("f = %e"%f) print("f = %f"%f)运行结果：f = 3.26e+19 f = 3.260000e+19 f = 32600000000000000000.000000浮点数的运算浮点数的运算总是会出现误差，这一点在python中也会有出现浮点数的运算 误差以下面的代码为例：a = 0.1 b = 0.2 print("a + b =",a + b) #比较浮点数大小. if((a + b) == 0.3): print("(a + b) == 0.3") else: print("(a + b) != 0.3")正常在进行计算时0.1+0.2应该为0.3，但是结果却是这样的a + b = 0.30000000000000004 (a + b) != 0.3在最后会出现不定的误差，但是这种误差非常的小，于是为了使最终的结果保持正确，一般使用浮点数计算进行判定的语句中我们都需要先确定其精确度，来保持结果的正确上面的列子中我们只需要保证误差小于我们的精确度就可以保证我们的结果的正确性，于是上面的代码可以这样修改a = 0.1 b = 0.2 print("a + b =",a + b) #比较浮点数大小. if(abs(a+b-0.3)<0.01): print("(a + b) == 0.3") else: print("(a + b) != 0.3")这样就可以保证结果在精确度内，就算出现误差结果也不会出错复数类型**复数(Complex)：由实数部分和虚数部分构成， 复数的形式：a + bj、a + bJ或complex(a, b)**表示如12.6 + 5j，-7.4-8.3J，complex(2.3,4.5)。复数z可以用z.real来获得实部，用z.imag来获得虚部。范例：复数的运算c1 = 1.2 + 5.3j c2 = 4.6 + 60.8J a=complex(2.3,4.5) print("c1 + c2 =",c1 + c2) print(a) 运行结果如下：c1 + c2 = (5.8+66.1j) (2.3+4.5j)当把复数作为一个对象进行输出时会自动的在其两边加上括号布尔类型布尔类型(Bool)的常量包括True 和 False，分别表示真和假。 非0数字、非空字符串、非空列表、非空元组、非空字典、非空集合等在进行条件判断时均视为真(True)；反之视为假(False)。 例如:判断列表是否为空信阳 = ["息县","罗山","固始","淮滨"] if 信阳: print("列表'信阳'不为空！") else: print("列表'信阳'为空！")运行结果：列表'信阳'不为空列表不为空判断为真布尔类型的常量(True和False)如果出现在算术运算中，True 被当作 1，False 被当作 0>>> print(True + 2) 3 >>> print(False + 2) 2 字符串类型在Python中，字符串属于不可变有序序列可使用单引号、双引号、三单引号或三双引号作为定界符不同的定界符之间可以互相嵌套。三引号可以创建多行字符串,如注释注意：在Python中，不支持字符类型，单个字符也是字符串。Python为字符串中的每个字符分配一个数字来指代这个元素的位置，即索引。 第一个元素的索引是0，第二个元素的索引是1，以此类推。 同时，字符串还支持反向索引，字符串中最后一个字符的索引是-1，倒数第二个字符的索引是-2，以此类推(见下图)。范例：字符串的访问>>> str = "sophiscated" >>> str #整个字符串. 'sophiscated' >>> str[1] #索引为1的字符. 'o' >>> str[2:] #从索引2开始的所有字符. 'phiscated' >>> str[:] #整个字符串. 'sophiscated' >>> str[:4] #索引为4之前的所有字符. 'soph'

摘要：经常有朋友问，学 Python 面向对象时，翻阅别人代码，会发现一个 super() 函数，那这个函数的作用到底是什么？本文分享自华为云社区《Python 中的 super 函数怎么学，怎么解？》，作者：梦想橡皮擦。实战场景经常有朋友问，学 Python 面向对象时，翻阅别人代码，会发现一个 super() 函数，那这个函数的作用到底是什么？super() 函数的用途如下，在子类中调用父类的方法，多用于类的继承关系。其语法格式如下所示：super(type[, object-or-type])参数说明如下：type：类，可选参数object-or-type：对象或类，一般为 self，也是可选参数。返回值是代理对象。可以直接查询官方帮助手册：help(super)输出信息如下所示：Help on class super in module builtins:class super(object)| super() -> same as super(__class__, )| super(type) -> unbound super object| super(type, obj) -> bound super object; requires isinstance(obj, type)| super(type, type2) -> bound super object; requires issubclass(type2, type)| Typical use to call a cooperative superclass method:| class C(B):| def meth(self, arg):| super().meth(arg)| This works for class methods too:| class C(B):| @classmethod| def cmeth(cls, arg):| super().cmeth(arg)对输出结果进行分析之后，可以得到如下结论：super 类是一个继承自 object 的类，super() 函数就是对该类的实例化；调用 super() 实例化之后，返回一个 super 对象；super() 参数有四种搭配，具体看上述输出；实战编码单继承使用直接看一下单继承相关代码，其中使用类名去调用父类方法。class A:def funA(self):print("执行 A ，输出橡皮擦")class B(A):def funB(self):# self 表示 B 类的实例A.funA(self)print("执行 B ，输出铅笔")b = B()b.funB()上述代码在 B 类中增加了 funB 函数，并且去调用 A 类中的 funA 函数，此时输出的内容如下所示：执行 A ，输出橡皮擦执行 B ，输出铅笔如果将上述代码修改为 super() 函数调用父类方法，可以使用下述代码：class A:def funA(self):print("执行 A ，输出橡皮擦")class B(A):def funB(self):# 注意 super() 函数的用法super().funA()print("执行 B ，输出铅笔")b = B()b.funB()上述代码与之前的运行结果一致，在单继承的层级结构中，super 可以直接引用父类，即在子类中不需要使用父类名调用父类方法，而使用 代理对象（super 对象） 去调用，这样的好处就是当父类名改变或继承关系发生改变时，我们不需要对调用进行反复修改。接下来看一下多继承情况下，super() 函数的实战场景。class A:def run(self):print('AAA')class B:def run(self):print('BBB')class C:def run(self):print('CCC')class D(A, B, C):def run(self):super().run()d = D()d.run()此时输出的结果是 AAA，可以看到 super 匹配到的数据是 A 类中的 run 函数，也就是最左侧类中的方法，下面修改一下各类中 run 函数的名称，使其存在差异。class A:def run1(self):print('AAA')class B:def run2(self):print('BBB')class C:def run3(self):print('CCC')class D(A, B, C):def run(self):# 调用 B 中 run2super().run2()d = D()d.run()当一个类继承多个类时，如果第一个父类中没有提供该方法，当前类实例就会通过 __mro__ 属性进行向上搜索，如果到 object 类都没有检索到该方法，就会引发 AttributeError 异常。基于上述逻辑，我们可以扩展一下，使用 super() 函数中的参数。class A:def run(self):print('AAA')class B:def run(self):print('BBB')class C:def run(self):print('CCC')class D(A, B, C):def run(self):# 调用 C 中 runsuper(B, self).run()d = D()d.run()此时输出的结果是 CCC，该结果输出表示了使用 super 函数之后，可以使用 super(类,self) 指定以哪个类为起点检索父类中的方法，上述代码设置的 B，就表示从 B 开始检索，后续找到了 C 类，其中包含 run() 方法，所以输出 CCC。__mro__ 属性的说明。MRO 是 method resolution order，即方法解析顺序，其本质是继承父类方法时的顺序表。在 Python 中可以使用内置属性 __mro__ 查看方法的搜索顺序，例如下述代码，重点查看输出部分内容。class A:def run(self):print('AAA')class B:def run(self):print('BBB')class C:def run(self):print('CCC')class D(A, B, C):def run(self):# 调用 C 中 runsuper(B, self).run()print(D.__mro__)输出的结果如下所示：(, , , , )你可以修改一下继承顺序，然后得到不同的输出结果。(, , , , )在搜索方法的时候，是按照 __mro__ 的输出结果从左到右进行顺序查找的，逻辑如下：A. 找到方法，停止检索；B. 没有找到，继续检索下一类；C. 如果到最后都没有找到，程序报错。

文章转自： 迷途小书童的Note软硬件环境windows 10 64bitvisual studio 2019cuda 11.1cudnn 8.0.5opencv 4.5.1darknet 2021.03.27cmake 3.20.0安装配置opencv来到opencv的官方网站下载页面 https://opencv.org/releases/下载后是一个exe文件，打开傻瓜式一步步安装就好了，记录好安装路径(我这里是D:\Tools\OpenCV\opencv)，然后增加一个环境变量OpenCV_DIR，指向opencv安装后的build目录，如下接下来分别将opencv下的build\x64\vc15\bin和build\x64\vc15\lib目录，追加到PATH环境变量中，如下编译darknet.exe下载cmake，地址是：https://cmake.org/download/，也是傻瓜式的安装。然后打开cmake-gui.exe源码目录和编译目标目录都指向darknet的源码目录，这里使用AlexeyAB的版本 https://github.com/AlexeyAB/darknet接下来就是点击Configure然后就是Generate最后Open Project随即，visual studio 2019就打开了darknet工程，点击右侧的ALL_BUILD --> 生成等待一会，就可以编译完成最后我们来测试一下，将Debug\darknet.exe和3rdparty\pthreads\bin下的pthreadGC2.dll和pthreadVC2.dll都拷贝到darknet源码根目录下，除此以外，还要准备权重文件yolov4.weights然后执行图片测试命令.\darknet.exe detect cfg\yolov4.cfg yolov4.weights data\dog.jpg编译dll如果要编译动态链接库dll的话，进入到darknet源码下的build\darknet，用visual studio 2019打开yolo_cpp_dll.sln同样地，右键生成这里出现了一个错误错误 MSB4019 找不到导入的项目“C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\MSBuild\Microsoft\VC\v160\BuildCustomizations\CUDA 10.1.props”。请确认 Import 声明“C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\MSBuild\Microsoft\VC\v160\\BuildCustomizations\CUDA 10.1.props”中的表达式正确，且文件位于磁盘上。yolo_cpp_dll D:\Projects\darknet-master\build\darknet\yolo_cpp_dll.vcxproj 55我的系统中，cuda明明是11.1版本，为何会出现cuda 10.1的报错？编辑文件yolo_cpp_dll.vcxproj，将里面的cuda 10.1版本改成你系统中的版本，我这里是cuda 11.1，包括.props和.targets重新生成，还是报错接下来，右键点击解决方案，进入到项目属性，点击CUDA C/C++ --> Device，找到Code Generation，将compute_30;sm_30删除，然后保存，重新生成这时候就能够编译成功了最近再多聊一句，在python中使用上面生成的yolo_cpp_dll.dll文件时(通常使用ctypes这个库)需要注意下，由于yolo_cpp_dll.dll依赖于同目录下的pthreadGC2.dll和pthreadVC2.dll，因此，想通过ctypes.CDLL来调用yolo_cpp_dll.dll，就需要讲这几个dll文件放在同一个目录下，不然就会报类似下面的错误python CDLL OSError: [WinError 126] The specified module could not be found

开始码代码之前，我们先来了解一下三种邮件服务协议：1、SMTP协议SMTP(Simple Mail Transfer Protocol)，即简单邮件传输协议。相当于中转站，将邮件发送到客户端。2、POP3协议POP3(Post Office Protocol 3)，即邮局协议的第3个版本，是电子邮件的第一个离线协议标准。该协议把邮件下载到本地计算机，不与服务器同步，缺点是更易丢失邮件或多次下载相同的邮件。3、IMAP协议IMAP(Internet Mail Access Protocol)，即交互式邮件存取协议。该协议连接远程邮箱直接操作，与服务器内容同步。然后介绍一下email包这个包的中心组件是代表电子邮件消息的“对象模型”。 应用程序主要通过在 message 子模块中定义的对象模型接口与这个包进行交互。 应用程序可以使用此 API 来询问有关现有电子邮件的问题、构造新的电子邮件，或者添加或移除自身也使用相同对象模型接口的电子邮件子组件。 也就是说，遵循电子邮件消息及其 MIME 子组件的性质，电子邮件对象模型是所有提供 EmailMessage API 的对象所构成的树状结构。接下来我们通过具体的代码实现一个登录邮箱客户端，下载邮件，解析邮件附件内容的功能。首先我们需要定义一个邮件解析的类，该类需要三个变量：1、邮箱所属的imap服务地址；2、邮箱账号；3、邮箱密码【注：不同邮箱需要不同的安全策略，例如qq邮箱需要短信验证，获取登录授权码，而不是明文密码去登录远程客户端】 class Email_parse:      def __init__(self,remote_server_url,email_url,password):         # imap服务地址         self.remote_server_url = remote_server_url         # 邮箱账号         self.email_url = email_url         # 邮箱密码         self.password = password 然后定义类中入口函数，登录远程，默认获取第一页所有的邮件。我们获取邮件的主题，并打印出来【不同邮件主题的编码可能不同，二进制需要转码才能正确显示】    def main_parse_Email(self):         """入口函数，登录imap服务"""         server = imaplib.IMAP4_SSL(self.remote_server_url, 993)         server.login(self.email_url, self.password)         server.select('INBOX')         status,data = server.search(None,"ALL")         if status != 'OK':             raise Exception('read email error')         emailids = data[0].split()         mail_counts = len(emailids)         print("count:",mail_counts)         # 邮件的遍历是按时间从后往前，这里我们选择最新的一封邮件         for i in range(mail_counts - 1, mail_counts - 2, -1):             status, edata = server.fetch(emailids[i], '(RFC822)')             msg = email.message_from_bytes(edata[0][1])             #获取邮件主题title             subject = email.header.decode_header(msg.get('subject'))             if type(subject[-1][0]) == bytes:                 title = subject[-1][0].decode(str(subject[-1][1]))             elif type(subject[-1][0]) == str:                 title = subject[-1][0]             print("title:", title) 其中，msg变量保存的就是邮件的主体，接下来因为会重复用到msg和tilte，我们将构造一个类函数返回msg和title。    def get_email_title(msg):         subject = email.header.decode_header(msg.get('subject'))         if type(subject[-1][0]) == bytes:             title = subject[-1][0].decode(str(subject[-1][1]))         elif type(subject[-1][0]) == str:             title = subject[-1][0]         print("title:", title)         return title 解析邮件，我们分为两部分，邮件正文【HTML】和附件【xlsx等】，判断有附件，我们就保存到固定的路径下。表格的解析不再赘述了，pandas之类的包足以搞定。    def get_att(msg):         """获取附件并下载"""         filename = Email_parse.get_email_name(msg)         for part in msg.walk():             file_name = part.get_param("name")             if file_name:                 data = part.get_payload(decode=True)                 if data != None:                     att_file = open('./src/' + filename, 'wb')                     att_file.write(data)                     att_file.close()                 else:                     pass 邮件正文内容，我们直接解析html，将文本内容直接保存到.txt文件中，方便读取。    def get_text_from_HTML(msg):         """获取邮件中的html"""         filename = Email_parse.get_email_name(msg)         current_title = Email_parse.get_email_title(msg)         print("filename:",filename,type(filename))         for part in msg.walk():             if not part.is_multipart():                 result = part.get_payload(decode=True)                 result = result.decode('gbk')                 f = open(f'./src/{current_title}.txt','w')                 f.write(result)                 f.close()                 return result 完整代码 import email import imaplib from email.header import decode_header import pandas as pd import datetime  class Email_parse:     def __init__(self,remote_server_url,email_url,password):         self.remote_server_url = remote_server_url         self.email_url = email_url         self.password = password      def get_att(msg):         filename = Email_parse.get_email_name(msg)         for part in msg.walk():             file_name = part.get_param("name")             if file_name:                 data = part.get_payload(decode=True)                 if data != None:                     att_file = open('./src/' + filename, 'wb')                     att_file.write(data)                     att_file.close()                 else:                     pass      def get_email_title(msg):         subject = email.header.decode_header(msg.get('subject'))         if type(subject[-1][0]) == bytes:             title = subject[-1][0].decode(str(subject[-1][1]))         elif type(subject[-1][0]) == str:             title = subject[-1][0]         print("title:", title)         return title      def get_email_name(msg):         for part in msg.walk():             file_name = part.get_param("name")             if file_name:                 h = email.header.Header(file_name)                 dh = email.header.decode_header(h)                 filename = dh[0][0]                 if dh[0][1]:                     value, charset = decode_header(str(filename, dh[0][1]))[0]                     if charset:                         filename = value.decode(charset)                         print("附件名称：", filename)                         return filename      def main_parse_Email(self):         server = imaplib.IMAP4_SSL(self.remote_server_url, 993)         server.login(self.email_url, self.password)         server.select('INBOX')         status,data = server.search(None,"ALL")         if status != 'OK':             raise Exception('read email error')         emailids = data[0].split()         mail_counts = len(emailids)         print("count:",mail_counts)         for i in range(mail_counts - 1, mail_counts - 2, -1):             status, edata = server.fetch(emailids[i], '(RFC822)')             msg = email.message_from_bytes(edata[0][1])             subject = email.header.decode_header(msg.get('subject'))             if type(subject[-1][0]) == bytes:                 title = subject[-1][0].decode(str(subject[-1][1]))             elif type(subject[-1][0]) == str:                 title = subject[-1][0]             print("title:", title)             Email_parse.get_att(msg)             Email_parse.get_text_from_HTML(msg)      def get_text_from_HTML(msg):         filename = Email_parse.get_email_name(msg)         current_title = Email_parse.get_email_title(msg)         print("filename:",filename,type(filename))         for part in msg.walk():             if not part.is_multipart():                 result = part.get_payload(decode=True)                 result = result.decode('gbk')                 f = open(f'./src/{current_title}.txt','w')                 f.write(result)                 f.close()                 return result  if __name__ == "__main__":     remote_server_url = 'imap.qq.com'     email_url = "*********@qq.com"     password = "**********"     demo = Email_parse(remote_server_url,email_url,password)     demo.main_parse_Email() 

一、route()路由概述功能：将URL绑定到函数路由函数route()的调用有两种方式：静态路由和动态路由二、静态路由和动态路径方式1：静态路由@app.route(“/xxx”) xxx为静态路径 如：：/index / /base等,可以返回一个值、字符串、页面等 from flask import Flask app = Flask(__name__)  @app.route('/hello') def hello_world():     return 'Hello World!!!'      @app.route('/pro') def index():     return render_template('login.html')  if __name__ == '__main__':     app.run(debug = True) 方式2：动态路由采用<>进行动态url的传递@app.route(“/”),这里xxx为不确定的路径。 from flask import Flask app = Flask(__name__)  @app.route('/hello/') def hello_name(name):    return 'Hello %s!' % name  if __name__ == '__main__':    app.run(debug = True) 三、route()其它参数1.methods=[‘GET’,‘POST’]当前视图函数支持的请求方式，不设置默认为GET请求方式不区分大小写methods=[‘GET’] 支持的请求方法为GETmethods=[‘POST’] 支持的请求方法为POSTmethods=[‘GET’,‘POST’] 支持的请求方法为POST GET  @app.route('/login', methods=['GET', 'POST'])  # 请求参数设置不区分大小写，源码中自动进行了upper   def login():       if request.method == 'GET':           return render_template('login.html')       elif request.method == 'POST':           username = request.form.get('username')           pwd = request.form.get('pwd')           if username == 'yang' and pwd == '123456':               session['username'] = username               return 'login successed 200  ok!'           else:               return 'login failed!!!'

引言你写了一个 api，接受 client 上传的文件，然后在上传到 oss，你会怎么做？先写硬盘，然后在上传到 oss？太笨了！你写了一个截图服务，截到的图要上传到 oss，你会怎么做？先写硬盘，在上传到 oss？太笨了！这篇文章教你重新做人！文本类型使用 io.StringIO1234567import iofrom loguru import loggerfile_like_obj = io.StringIO("hahaha")logger.debug(file_like_obj)logger.debug(type(file_like_obj))logger.debug(getattr(file_like_obj,'read'))logger.debug(file_like_obj.read())输出结果如下：2022-07-11 21:23:51.206 | DEBUG    | __main__::8 - <_io.StringIO object at 0x100323eb0>2022-07-11 21:23:51.206 | DEBUG    | __main__::9 -2022-07-11 21:23:51.206 | DEBUG    | __main__::10 -2022-07-11 21:23:51.206 | DEBUG    | __main__::11 - hahaha再看一个熟悉的：12345import iofrom loguru import loggerfile_like_obj = io.StringIO("hahaha")with file_like_obj as f:    logger.debug(f.read())输出结果如下：2022-07-11 21:35:04.620 | DEBUG    | __main__::9 - hahaha二进制类型使用 io.BytesIO使用 requests 把字符串按照文件上传下面的代码是标准的上传文件的代码：123456import requestsimport ioresponse = requests.post('http://localhost:5000/', files={    'file': open('纵观人类文明史.txt', 'r', encoding='utf-8')})print(response.text)但是我想把 open('纵观人类文明史.txt', 'r', encoding='utf-8') 替换为字符串。为此我想到的办法是把字符串先写到硬盘上，在按照上面的代码上传，可是这太低效率（硬盘太低效率），平白无故多了两次硬盘读写操作，我想直接把内存中的字符串按照文件上传有什么办法吗？

这篇文章主要介绍了python groupby函数实现分组选取最大值与最小值，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下现在需要将course分组,然后选择出每一组里面的最大值和最小值,并保留下来实现下面数据结果：直接使用groupby函数,不能直接达到此效果,需要在groupby函数上添加apply和lambda函数import pandas as pd data = pd.read_excel('group_apply.xlsx') data1 = data.groupby('course').apply(lambda t: t[(t['grade']==t['grade'].min()) ^ (t['grade']==t['grade'].max())])前面的index，是两列,所以需要处理一下,这个是groypby函数处理之后所产生,只需要删除即可data2 = data1.reset_index(drop=True)代码整合import pandas as pd data = pd.read_excel('group_apply.xlsx') data1 = data.groupby('course').apply(lambda t: t[(t['grade']==t['grade'].min()) ^ (t['grade']==t['grade'].max())]) data2 = data1.reset_index(drop=True)

前言在设计用例的时候,有些用例只是参数数据的输入不一样,比如登录这个功能,操作过程是一样的.如果重复去写操作过程会增加代码量,对应这种多组数据的测试用例,可以用数据驱动设计模式,一组数据对应一个测试用例,用例自动加载生成.一.ddt简单介绍1.ddt是什么ddt:data driver tests ，数据驱动测试，是一种单元测试框架2.使用ddt\的好处如"前言"所说3.导入ddt模块ddt属于第三方模块,需要安装,安装方法:方法一:在cmd命令中输入:pip install ddt方法二:pycharm中打开终端,输入:pip install ddt4.四种模式ddt要与unittest单元测试框架一块结合使用@ddt：引入ddt模块@data：导入数据@unpack：拆分数据     @file_data：导入外部数据二.ddt处理各种类型数据注意:1.使用ddt模块要在测试类前用@ddt进行修饰 2.要导入测试数据需在测试用例(以test_开头的方法)前用@data修饰 3.若需对测试数据进行拆分需用@unpack修饰 4.若需导入外部数据需用@file_data修饰1.分析ddt工作原理代码中@data(1,2,“jack”)传入了三个元素，故ddt自动生成了3个测试用用例。分别打印传入的数据注意:对于没有使用ddt的测试用例来说,一个test_开头的测试方法一次只能生成一个测试用例,但是有了ddt之后,可以一次向测试方法中传入多个测试数据,而生成测试用例的个数是根据@data中传入的测试数据的元素而定的.2.ddt测试元祖数据2.1测试单组元素2.2测试多组未分解元素 2.3测试多组分解元素3.ddt测试列表数据3.1多组列表拆分数据3.2复杂列表(含字典)拆分数据 4.ddt测试字典数据4.1多组字典数据拆分 5.ddt测试字典列表数据结合 在实际应用中会存在数据比较多的情况，如果都直接把数据传入@data中会显得代码非常冗杂，以包含多个字典的列表数据为例，可将包含多个字典的元素存放在一个列表变量中，在@data中传入列表变量即可 6.ddt测试读取文件数据数据格式必须为json,且必须为双引号的键值对形式

作用：pygame一般用来做游戏注意：1.在使用pygame提供的功能之前，需要调用init方法2.在游戏结束前需要调用 quit 方法pygame中的各个函数：1.pygame.init()：该函数在使用pygame时进行初始化，只有引用了该函数才能使用pygame提供的所用功能2.pygame.Rect():该函数可以设置一张图片的位置以及大小，这是一个特殊的函数，不需要引用init函数都可以使用3.pygame.display.set_mode(resolution=(0,0),flags=0,depth=0)：该函数可以创建游戏的主窗口对象，参数1：指定屏幕的宽和高，默认与屏幕大小一致参数2：指定屏幕的附加选项，默认不传递参数3：颜色的位数，默认自动匹配4.pygame.display.update()：刷新主窗口内容5.pygame.image.load()：加载需要的图片6.主窗口对象.blit(图像，位置)：将图像绘制到指定的位置7.pygame.time.Clock()：创建一个时间对象，用来控制帧率8.时间对象.tick(数字)：控制每秒的帧率9.pygame.event.get()：事件监听，返回的是一个列表10.pygame.sprite.Sprite：精灵，用来存储图像数据images和rect的对象11.pygame.sprite.Group(精灵1，精灵2)：创建精灵组对象12.精灵组对象.update()：更新精灵组中精灵的位置13.精灵组对象.draw()：把精灵组中的所有精灵绘画到主窗口14.pygame.time.set_time(eventid,milliseconds)：设置每个一段时间程序会执行什么内容，第一个需要基于常量pygame.USEREVENT来指定，第二个参数是毫秒值15.pygame.key.get_pressed()：按键监听，会返回所有按键的元组，通过键盘常量，判断元组中某个按键是否被触发，如果被触发对应数值为116.pygame.sprite.groupcollide(精灵组1，精灵组2，bool，bool)：检测两个精灵组的碰撞，会返回一个字典，第一个参数和第三个参数关联，第二个参数和第四个参数关联，当bool类型为真时，碰撞会被销毁17.pygame.sprite.spritecollide(精灵，精灵组，bool)：检测精灵和精灵组的碰撞，会返回一个精灵组的列表，当bool类型为真时，精灵组会被销毁一个飞机大战的游戏总结：import pygame import time from plane_Sprite import *   class PlaneGame(object):     def __init__(self):         print('初始化')         # 1.创建游戏窗口         self.screem = pygame.display.set_mode(SCREEM_RECT.size)  # 这里需要拿到元组类型的数据，使用 .size 可以拿到数组中的数据         # 2.创建游戏时钟         self.clock = pygame.time.Clock()         # 3.调用私有方法，精灵和精灵组的创建         self.__create_sprite()         # 4.创建敌机定时器         pygame.time.set_timer(CREATE_ENEMY_EVENT, 1000)         # 5.创建子弹定时器         pygame.time.set_timer(HERO_FIRE_EVENT, 500)     def __create_sprite(self):         # 创建背景精灵类         # bg1 = BackGround('./images/background.jpg')         # bg2 = BackGround('./images/background.jpg')         bg1 = BackGround()         bg2 = BackGround(True)         self.back_groud = pygame.sprite.Group(bg1, bg2)  # 创建背景精灵组         self.enemy_group = pygame.sprite.Group()  # 创建敌机精灵组         self.he1 = Hero()         self.hero_group = pygame.sprite.Group(self.he1)  # 创建英雄精灵组       def StartGame(self):         print('开始游戏')         while True:             # 1.设置刷新的帧率             self.clock.tick(SHUA)             # 2.事件监听             self.__event_handler()             # 3.碰撞检测             self.__check_cllide()             # 4.更新/和绘制精灵组图片             self.__update_sprite()             # 5.更新显示             pygame.display.update()     # 定义私有方法     def __event_handler(self):         """监听事件处理"""         for event in pygame.event.get():             if event.type == pygame.QUIT:                 # 调用静态方法：使用类名                 PlaneGame.__game_over()             # 判断定时器事件             elif event.type == CREATE_ENEMY_EVENT:                 # 创建敌机对象                 enemy = Enemy()                 # 添加到精灵组中                 self.enemy_group.add(enemy)             elif event.type == HERO_FIRE_EVENT:                 self.he1.fire()         # 获取键盘信息         key_pressed = pygame.key.get_pressed()         # 判断对应的键盘         if key_pressed[pygame.K_RIGHT]:             self.he1.speed = 3         elif key_pressed[pygame.K_LEFT]:             self.he1.speed = -3         elif key_pressed[pygame.K_UP]:             self.he1.speed = -2         elif key_pressed[pygame.K_DOWN]:             self.he1.speed = 2         else:             self.he1.speed = 0     def __check_cllide(self):         """碰撞检测"""         # 子弹摧毁敌机         pygame.sprite.groupcollide(self.he1.bullets, self.enemy_group, True, True)         # 敌机撞毁英雄         enemy_list = pygame.sprite.spritecollide(self.he1, self.enemy_group,True)         if len(enemy_list) > 0:             # 销毁英雄             self.he1.kill()             # 结束游戏             PlaneGame.__game_over()     def __update_sprite(self):         """更新精灵组"""         self.back_groud.update()  # 刷新图像数据         self.back_groud.draw(self.screem)  # 绘画图像         # 敌机精灵组更新         self.enemy_group.update()         self.enemy_group.draw(self.screem)         # 英雄精灵组更新         self.hero_group.update()         self.hero_group.draw(self.screem)         # 子弹精灵组更新         self.he1.bullets.update()         self.he1.bullets.draw(self.screem)     @staticmethod # 静态方法     def __game_over():         """结束游戏"""         print('游戏结束')         pygame.quit()         exit() if __name__ == "__main__":       # 创建游戏对象     plane_start = PlaneGame()     # 启动游戏     plane_start.StartGame()

这篇文章主要介绍了Python 字典(Dictionary)的详细操作方法,需要的朋友可以参考下Python字典是另一种可变容器模型，且可存储任意类型对象，如字符串、数字、元组等其他容器模型。一、创建字典字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下：dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}也可如此创建字典dict1 = { 'abc': 456 }dict2 = { 'abc': 123, 98.6: 37 }注意：每个键与值用冒号隔开（:），每对用逗号，每对用逗号分割，整体放在花括号中（{}）。键必须独一无二，但值则不必。值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。二、访问字典里的值把相应的键放入熟悉的方括弧，如下实例:1234567dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};print "dict['Name']: ", dict['Name'];print "dict['Age']: ", dict['Age'];#以上实例输出结果：#dict['Name']: Zara#dict['Age']: 7如果用字典里没有的键访问数据，会输出错误如下：dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};print "dict['Alice']: ", dict['Alice'];以上实例输出结果：#KeyError: 'Alice'三、修改字典向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:12345678dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};dict['Age'] = 8; # update existing entrydict['School'] = "DPS School"; # Add new entry  print "dict['Age']: ", dict['Age'];print "dict['School']: ", dict['School'];#以上实例输出结果：#dict['Age']: 8#dict['School']: DPS School四、删除字典元素能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令，如下实例：12345678910dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};del dict['Name']; # 删除键是'Name'的条目dict.clear();  # 清空词典所有条目del dict ;  # 删除词典print "dict['Age']: ", dict['Age'];print "dict['School']: ", dict['School'];#但这会引发一个异常，因为用del后字典不再存在：dict['Age']:五、字典键的特性字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：12345dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};print "dict['Name']: ", dict['Name'];#以上实例输出结果：#dict['Name']: Manni2）键必须不可变，所以可以用数，字符串或元组充当，所以用列表就不行，如下实例：12345dict = {['Name']: 'Zara', 'Age': 7};print "dict['Name']: ", dict['Name'];#以上实例输出结果：#TypeError: list objects are unhashable六、字典内置函数&方法Python字典包含了以下内置函数：cmp(dict1, dict2) #比较两个字典元素。len(dict) #计算字典元素个数，即键的总数。str(dict) #输出字典可打印的字符串表示。type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。Python字典包含了以下内置方法：radiansdict.clear() #删除字典内所有元素radiansdict.copy() #返回一个字典的浅复制radiansdict.fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值radiansdict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值radiansdict.has_key(key) #如果键在字典dict里返回true，否则返回falseradiansdict.items() #以列表返回可遍历的(键, 值) 元组数组radiansdict.keys() #以列表返回一个字典所有的键radiansdict.setdefault(key, default=None) #和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为defaultradiansdict.update(dict2) #把字典dict2的键/值对更新到dict里radiansdict.values() #以列表返回字典中的所有值