cfree运行程序错误的原因_Python入门教程 | 第 8 章 错误、调试和测试

第八章 错误、调试和测试

在程序运行过程中,总会遇到各种各样的错误。

有的错误是程序编写有问题造成的,比如本来应该输出整数结果输出了字符串,这种错误我们通常称之为bug,bug是必须修复的。

有的错误是用户输入造成的,比如让用户输入email地址,结果得到一个空字符串,这种错误可以通过检查用户输入来做相应的处理。

还有一类错误是完全无法在程序运行过程中预测的,比如写入文件的时候,磁盘满了,写不进去了,或者从网络抓取数据,网络突然断掉了。这类错误也称为异常,在程序中通常是必须处理的,否则,程序会因为各种问题终止并退出。

Python内置了一套异常处理机制,来帮助我们进行错误处理。

此外,我们也需要跟踪程序的执行,查看变量的值是否正确,这个过程称为调试。Python的pdb可以让我们以单步方式执行代码。

最后,编写测试也很重要。有了良好的测试,就可以在程序修改后反复运行,确保程序输出符合我们编写的测试。

8.1 错误处理

在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数open(),成功时返回文件描述符(就是一个整数),出错时返回-1

用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须用大量的代码来判断是否出错:

def foo():
    r = some_function()
    if r==(-1):
        return (-1)
    # do something
    return r

def bar():
    r = foo()
    if r==(-1):
        print('Error')
    else:
        pass

一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)。

所以高级语言通常都内置了一套try...except...finally...的错误处理机制,Python也不例外。

8.1.1 try

让我们用一个例子来看看try的机制:

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

当我们认为某些代码可能会出错时,就可以用try来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接跳转至错误处理代码,即except语句块,执行完except后,如果有finally语句块,则执行finally语句块,至此,执行完毕。

上面的代码在计算10 / 0时会产生一个除法运算错误:

try...
except: division by zero
finally...
END

从输出可以看到,当错误发生时,后续语句print('result:', r)不会被执行,except由于捕获到ZeroDivisionError,因此被执行。最后,finally语句被执行。然后,程序继续按照流程往下走。

如果把除数0改成2,则执行结果如下:

try...
result: 5
finally...
END

由于没有错误发生,所以except语句块不会被执行,但是finally如果有,则一定会被执行(可以没有finally语句)。

你还可以猜测,错误应该有很多种类,如果发生了不同类型的错误,应该由不同的except语句块处理。没错,可以有多个except来捕获不同类型的错误:

try:
    print('try...')
    r = 10 / int('a')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
finally:
    print('finally...')
print('END')

int()函数可能会抛出ValueError,所以我们用一个except捕获ValueError,用另一个except捕获ZeroDivisionError

此外,如果没有错误发生,可以在except语句块后面加一个else,当没有错误发生时,会自动执行else语句:

try:
    print('try...')
    r = 10 / int('2')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
else:
    print('no error!')
finally:
    print('finally...')
print('END')

Python的错误其实也是class,所有的错误类型都继承自BaseException,所以在使用except时需要注意的是,它不但捕获该类型的错误,还把其子类也“一网打尽”。比如:

try:
    foo()
except ValueError as e:
    print('ValueError')
except UnicodeError as e:
    print('UnicodeError')

第二个except永远也捕获不到UnicodeError,因为UnicodeErrorValueError的子类,如果有,也被第一个except给捕获了。

Python所有的错误都是从BaseException类派生的,常见的错误类型和继承关系看这里:

https://docs.python.org/3/library/exceptions.html#exception-hierarchy

使用try...except捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数main()调用bar()bar()调用foo(),结果foo()出错了,这时,只要main()捕获到了,就可以处理:

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        print('Error:', e)
    finally:
        print('finally...')

也就是说,不需要在每个可能出错的地方去捕获错误,只要在合适的层次去捕获错误就可以了。这样一来,就大大减少了写try...except...finally的麻烦。

8.1.2 调用栈

如果错误没有被捕获,它就会一直往上抛,最后被Python解释器捕获,打印一个错误信息,然后程序退出。来看看err.py

# err.py:
def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    bar('0')

main()

执行,结果如下:

$ python3 err.py
Traceback (most recent call last):
  File "err.py", line 11, in 
    main()
  File "err.py", line 9, in main
    bar('0')
  File "err.py", line 6, in barreturn foo(s) * 2
  File "err.py", line 3, in fooreturn 10 / int(s)
ZeroDivisionError: division by zero

出错并不可怕,可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的调用函数链:

错误信息第1行:

Traceback (most recent call last):

告诉我们这是错误的跟踪信息。

第2~3行:

 File "err.py", line 11, in 
    main()

调用main()出错了,在代码文件err.py的第11行代码,但原因是第9行:

 File "err.py", line 9, in main
    bar('0')

调用bar('0')出错了,在代码文件err.py的第9行代码,但原因是第6行:

File "err.py", line 6, in bar
    return foo(s) * 2

原因是return foo(s) * 2这个语句出错了,但这还不是最终原因,继续往下看:

File "err.py", line 3, in foo
    return 10 / int(s)

原因是return 10 / int(s)这个语句出错了,这是错误产生的源头,因为下面打印了:

ZeroDivisionError: integer division or modulo by zero

根据错误类型ZeroDivisionError,我们判断,int(s)本身并没有出错,但是int(s)返回0,在计算10 / 0时出错,至此,找到错误源头。

!> 出错的时候,一定要分析错误的调用栈信息,才能定位错误的位置。

14e45102bd3dd02ae85934cba48e54e2.png
异常栈

8.1.3 记录错误

如果不捕获错误,自然可以让Python解释器来打印出错误堆栈,但程序也被结束了。既然我们能捕获错误,就可以把错误堆栈打印出来,然后分析错误原因,同时,让程序继续执行下去。

Python内置的logging模块可以非常容易地记录错误信息:

# err_logging.py

import logging

def foo(s):
    return 10 / int(s)

def bar(s):
    return foo(s) * 2

def main():
    try:
        bar('0')
    except Exception as e:
        logging.exception(e)

main()
print('END')

同样是出错,但程序打印完错误信息后会继续执行,并正常退出:

$ python3 err_logging.py
ERROR:root:division by zero
Traceback (most recent call last):
  File "err_logging.py", line 13, in main
    bar('0')
  File "err_logging.py", line 9, in bar
    return foo(s) * 2
  File "err_logging.py", line 6, in foo
    return 10 / int(s)
ZeroDivisionError: division by zero
END

通过配置,logging还可以把错误记录到日志文件里,方便事后排查。

8.1.4 抛出错误

因为错误是class,捕获一个错误就是捕获到该class的一个实例。因此,错误并不是凭空产生的,而是有意创建并抛出的。Python的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。

如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用raise语句抛出一个错误的实例:

# err_raise.py
class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

执行,可以最后跟踪到我们自己定义的错误:

$ python3 err_raise.py 
Traceback (most recent call last):
  File "err_throw.py", line 11, in 
    foo('0')
  File "err_throw.py", line 8, in fooraise FooError('invalid value: %s' % s)
__main__.FooError: invalid value: 0

只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型(比如ValueErrorTypeError),尽量使用Python内置的错误类型。

最后,我们来看另一种错误处理的方式:

# err_reraise.py

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n

def bar():
    try:
        foo('0')
    except ValueError as e:
        print('ValueError!')
        raise

bar()

bar()函数中,我们明明已经捕获了错误,但是,打印一个ValueError!后,又把错误通过raise语句抛出去了,这不有病么?

其实这种错误处理方式不但没病,而且相当常见。捕获错误目的只是记录一下,便于后续追踪。但是,由于当前函数不知道应该怎么处理该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。好比一个员工处理不了一个问题时,就把问题抛给他的老板,如果他的老板也处理不了,就一直往上抛,最终会抛给CEO去处理。

raise语句如果不带参数,就会把当前错误原样抛出。此外,在exceptraise一个Error,还可以把一种类型的错误转化成另一种类型:

try:
    10 / 0
except ZeroDivisionError:
    raise ValueError('input error!')

只要是合理的转换逻辑就可以,但是,决不应该把一个IOError转换成毫不相干的ValueError

小结:

Python内置的try...except...finally用来处理错误十分方便。出错时,会分析错误信息并定位错误发生的代码位置才是最关键的。

程序也可以主动抛出错误,让调用者来处理相应的错误。但是,应该在文档中写清楚可能会抛出哪些错误,以及错误产生的原因。

8.2 调试

程序能一次写完并正常运行的概率很小,基本不超过1%。总会有各种各样的bug需要修正。有的bug很简单,看看错误信息就知道,有的bug很复杂,我们需要知道出错时,哪些变量的值是正确的,哪些变量的值是错误的,因此,需要一整套调试程序的手段来修复bug。

8.2.1 print()

第一种方法简单直接粗暴有效,就是用print()把可能有问题的变量打印出来看看:

def foo(s):
    n = int(s)
    print('>>> n = %d' % n)
    return 10 / n

def main():
    foo('0')

main()

执行后在输出中查找打印的变量值:

$ python err.py
>>> n = 0
Traceback (most recent call last):
  ...
ZeroDivisionError: integer division or modulo by zero

print()最大的坏处是将来还得删掉它,想想程序里到处都是print(),运行结果也会包含很多垃圾信息。所以,我们又有第二种方法。

8.2.2 断言

凡是用print()来辅助查看的地方,都可以用断言(assert)来替代:

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

def main():
    foo('0')

assert的意思是,表达式n != 0应该是True,否则,根据程序运行的逻辑,后面的代码肯定会出错。

如果断言失败,assert语句本身就会抛出AssertionError

$ python err.py
Traceback (most recent call last):
  ...
AssertionError: n is zero!

程序中如果到处充斥着assert,和print()相比也好不到哪去。不过,启动Python解释器时可以用-O参数来关闭assert

$ python -O err.py
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

!> 注意:断言的开关“-O”是英文大写字母O,不是数字0。

关闭后,你可以把所有的assert语句当成pass来看。

8.2.3 logging

print()替换为logging是第3种方式,和assert比,logging不会抛出错误,而且可以输出到文件:

import logging

s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)

logging.info()就可以输出一段文本。运行,发现除了ZeroDivisionError,没有任何信息。怎么回事?

别急,在import logging之后添加一行配置再试试:

import logging
logging.basicConfig(level=logging.INFO)

看到输出了:

$ python err.py
INFO:root:n = 0
Traceback (most recent call last):
  File "err.py", line 8, in 
    print(10 / n)
ZeroDivisionError: division by zero

这就是logging的好处,它允许你指定记录信息的级别,有debuginfowarningerror等几个级别,当我们指定level=INFO时,logging.debug就不起作用了。同理,指定level=WARNING后,debuginfo就不起作用了。这样一来,你可以放心地输出不同级别的信息,也不用删除,最后统一控制输出哪个级别的信息。

logging的另一个好处是通过简单的配置,一条语句可以同时输出到不同的地方,比如console和文件。

8.2.4 pdb

第4种方式是启动Python的调试器pdb,让程序以单步方式运行,可以随时查看运行状态。我们先准备好程序:

# err.py
s = '0'
n = int(s)
print(10 / n)

然后启动:

$ python -m pdb err.py
> /Users/michael/Github/learn-python3/samples/debug/err.py(2)()
-> s = '0'

以参数-m pdb启动后,pdb定位到下一步要执行的代码-> s = '0'。输入命令l来查看代码:

(Pdb) l
  1     # err.py
  2  -> s = '0'
  3     n = int(s)
  4     print(10 / n)

输入命令n可以单步执行代码:

(Pdb) n
> /Users/michael/Github/learn-python3/samples/debug/err.py(3)()
-> n = int(s)
(Pdb) n
> /Users/michael/Github/learn-python3/samples/debug/err.py(4)()
-> print(10 / n)

任何时候都可以输入命令p 变量名来查看变量:

(Pdb) p s
'0'
(Pdb) p n
0

输入命令q结束调试,退出程序:

(Pdb) q

这种通过pdb在命令行调试的方法理论上是万能的,但实在是太麻烦了,如果有一千行代码,要运行到第999行得敲多少命令啊。还好,我们还有另一种调试方法。

8.2.5 pdb.set_trace()

这个方法也是用pdb,但是不需要单步执行,我们只需要import pdb,然后,在可能出错的地方放一个pdb.set_trace(),就可以设置一个断点:

# err.py
import pdb

s = '0'
n = int(s)
pdb.set_trace() # 运行到这里会自动暂停
print(10 / n)

运行代码,程序会自动在pdb.set_trace()暂停并进入pdb调试环境,可以用命令p查看变量,或者用命令c继续运行:

$ python err.py 
> /Users/michael/Github/learn-python3/samples/debug/err.py(7)()
-> print(10 / n)
(Pdb) p n0
(Pdb) c
Traceback (most recent call last):
  File "err.py", line 7, in 
    print(10 / n)
ZeroDivisionError: division by zero

这个方式比直接启动pdb单步调试效率要高很多,但也高不到哪去。

8.2.6 IDE

如果要比较爽地设置断点、单步执行,就需要一个支持调试功能的IDE。目前比较好的Python IDE有:

  • Visual Studio Code:https://code.visualstudio.com/,需要安装Python插件。
  • PyCharm:http://www.jetbrains.com/pycharm/
  • 另外,Eclipse[1]加上pydev[2]插件也可以调试Python程序。

小结:

写程序最痛苦的事情莫过于调试,程序往往会以你意想不到的流程来运行,你期待执行的语句其实根本没有执行,这时候,就需要调试了。

虽然用IDE调试起来比较方便,但是最后你会发现,logging才是终极武器。

8.3 单元测试

如果你听说过“测试驱动开发”(TDD:Test-Driven Development),单元测试就不陌生。

单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

比如对函数abs(),我们可以编写出以下几个测试用例:

  1. 输入正数,比如11.20.99,期待返回值与输入相同;
  2. 输入负数,比如-1-1.2-0.99,期待返回值与输入相反;
  3. 输入0,期待返回0
  4. 输入非数值类型,比如None[]{},期待抛出TypeError

把上面的测试用例放到一个测试模块里,就是一个完整的单元测试。

如果单元测试通过,说明我们测试的这个函数能够正常工作。如果单元测试不通过,要么函数有bug,要么测试条件输入不正确,总之,需要修复使单元测试能够通过。

单元测试通过后有什么意义呢?如果我们对abs()函数代码做了修改,只需要再跑一遍单元测试,如果通过,说明我们的修改不会对abs()函数原有的行为造成影响,如果测试不通过,说明我们的修改与原有行为不一致,要么修改代码,要么修改测试。

这种以测试为驱动的开发模式最大的好处就是确保一个程序模块的行为符合我们设计的测试用例。在将来修改的时候,可以极大程度地保证该模块行为仍然是正确的。

我们来编写一个Dict类,这个类的行为和dict一致,但是可以通过属性来访问,用起来就像下面这样:

>>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1

mydict.py代码如下:

class Dict(dict):

    def __init__(self, **kw):
        super().__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

为了编写单元测试,我们需要引入Python自带的unittest模块,编写mydict_test.py如下:

import unittest

from mydict import Dict

class TestDict(unittest.TestCase):

    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEqual(d.a, 1)
        self.assertEqual(d.b, 'test')
        self.assertTrue(isinstance(d, dict))

    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')

    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEqual(d['key'], 'value')

    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']

    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

编写单元测试时,我们需要编写一个测试类,从unittest.TestCase继承。

test开头的方法就是测试方法,不以test开头的方法不被认为是测试方法,测试的时候不会被执行。

对每一类测试都需要编写一个test_xxx()方法。由于unittest.TestCase提供了很多内置的条件判断,我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是assertEqual()

self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等

另一种重要的断言就是期待抛出指定类型的Error,比如通过d['empty']访问不存在的key时,断言会抛出KeyError

with self.assertRaises(KeyError):
    value = d['empty']

而通过d.empty访问不存在的key时,我们期待抛出AttributeError

with self.assertRaises(AttributeError):
    value = d.empty

8.3.1 运行单元测试

一旦编写好单元测试,我们就可以运行单元测试。最简单的运行方式是在mydict_test.py的最后加上两行代码:

if __name__ == '__main__':
    unittest.main()

这样就可以把mydict_test.py当做正常的python脚本运行:

$ python mydict_test.py

另一种方法是在命令行通过参数-m unittest直接运行单元测试:

$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s

OK

这是推荐的做法,因为这样可以一次批量运行很多单元测试,并且,有很多工具可以自动来运行这些单元测试。

8.3.2 setUp 与 tearDown

可以在单元测试中编写两个特殊的setUp()tearDown()方法。这两个方法会分别在每调用一个测试方法的前后分别被执行。

setUp()tearDown()方法有什么用呢?设想你的测试需要启动一个数据库,这时,就可以在setUp()方法中连接数据库,在tearDown()方法中关闭数据库,这样,不必在每个测试方法中重复相同的代码:

class TestDict(unittest.TestCase):

    def setUp(self):
        print('setUp...')

    def tearDown(self):
        print('tearDown...')

可以再次运行测试看看每个测试方法调用前后是否会打印出setUp...tearDown...

小结:

  • 单元测试可以有效地测试某个程序模块的行为,是未来重构代码的信心保证。
  • 单元测试的测试用例要覆盖常用的输入组合、边界条件和异常。
  • 单元测试代码要非常简单,如果测试代码太复杂,那么测试代码本身就可能有bug。
  • 单元测试通过了并不意味着程序就没有bug了,但是不通过程序肯定有bug。

8.4 文档测试

如果你经常阅读Python的官方文档,可以看到很多文档都有示例代码。比如re模块[3]就带了很多示例代码:

>>> import re
>>> m = re.search('(?<=abc)def', 'abcdef')
>>> m.group(0)
'def'

可以把这些示例代码在Python的交互式环境下输入并执行,结果与文档中的示例代码显示的一致。

这些代码与其他说明可以写在注释中,然后,由一些工具来自动生成文档。既然这些代码本身就可以粘贴出来直接运行,那么,可不可以自动执行写在注释中的这些代码呢?

答案是肯定的。

当我们编写注释时,如果写上这样的注释:

def abs(n):
    '''
    Function to get absolute value of number.
    Example:
    >>> abs(1)
    1
    >>> abs(-1)
    1
    >>> abs(0)
    0
    '''
    return n if n >= 0 else (-n)

无疑更明确地告诉函数的调用者该函数的期望输入和输出。

并且,Python内置的“文档测试”(doctest)模块可以直接提取注释中的代码并执行测试。

doctest严格按照Python交互式命令行的输入和输出来判断测试结果是否正确。只有测试异常的时候,可以用...表示中间一大段烦人的输出。

让我们用doctest来测试上次编写的Dict类:

# mydict2.py
class Dict(dict):
    '''
    Simple dict but also support access as x.y style.
    >>> d1 = Dict()
    >>> d1['x'] = 100
    >>> d1.x
    100
    >>> d1.y = 200
    >>> d1['y']
    200
    >>> d2 = Dict(a=1, b=2, c='3')
    >>> d2.c
    '3'
    >>> d2['empty']
    Traceback (most recent call last):
        ...
    KeyError: 'empty'
    >>> d2.empty
    Traceback (most recent call last):
        ...
    AttributeError: 'Dict' object has no attribute 'empty'
    '''
    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

if __name__=='__main__':
    import doctest
    doctest.testmod()

运行python mydict2.py

$ python mydict2.py

什么输出也没有。这说明我们编写的doctest运行都是正确的。如果程序有问题,比如把__getattr__()方法注释掉,再运行就会报错:

$ python mydict2.py
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 10, in __main__.Dict
Failed example:
    d1.x
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'x'
**********************************************************************
File "/Users/michael/Github/learn-python3/samples/debug/mydict2.py", line 16, in __main__.Dict
Failed example:
    d2.c
Exception raised:
    Traceback (most recent call last):
      ...
    AttributeError: 'Dict' object has no attribute 'c'
**********************************************************************
1 items had failures:
   2 of   9 in __main__.Dict
***Test Failed*** 2 failures.

注意到最后3行代码。当模块正常导入时,doctest不会被执行。只有在命令行直接运行时,才执行doctest。所以,不必担心doctest会在非测试环境下执行。

小结:

doctest非常有用,不但可以用来测试,还可以直接作为示例代码。通过某些文档生成工具,就可以自动把包含doctest的注释提取出来。用户看文档的时候,同时也看到了doctest。

8.5 参考资料

  • 廖雪峰 - Python 3.x - 错误、调试和测试[4]

Reference

[1]

Eclipse: http://www.eclipse.org/

[2]

pydev: http://pydev.org/

[3]

re模块: https://docs.python.org/3/library/re.html

[4]

廖雪峰 - Python 3.x - 错误、调试和测试: https://www.liaoxuefeng.com/wiki/1016959663602400/1017598814713792

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/489325.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

我的世界服务器物品id错误,我的世界错误代码,怎么弄

我的世界错误代码&#xff0c;怎么弄0xu1125yuan2017.07.24浏览323次分享举报1.Minecraft:[16:05:37][Clientthread/FATAL][NotEnoughItemsFingerprintVerification]:ThefingerprintformodNotEnoughItemsisinvalid!Expected:f1850c39b2516232a2108a7bd84d1cb5df9... 1.Minecraf…

今日头条CEO朱文佳:新一代搜索引擎已经来了

来源&#xff1a;今日头条11月27日&#xff0c;今日头条CEO朱文佳在36kr wise大会上谈及头条搜索。在他看来&#xff0c;要做好搜索&#xff0c;有三件事最重要。首先是技术&#xff0c;技术决定搜索的体验&#xff1b;其次是内容&#xff0c;内容是搜索的根本&#xff1b;最后…

串口打印怎么使用】_爱普生打印机怎么使用 爱普生打印机使用方法【详解】...

市面上的打印机品牌有很多&#xff0c;其中就有爱普生打印机&#xff0c;这个品牌的打印机是在上个世纪的四十年代成立的&#xff0c;并且爱普生这款打印机逐渐深入我们的生活&#xff0c;一般我们很多都会使用爱普生打印机来打印资料或者是下载各种工作材料&#xff0c;那么你…

日益谨慎的谷歌AI,会在自我限制中越走越慢吗?

来源&#xff1a;wired为了防止技术被滥用&#xff0c;谷歌对新推出的人脸识别服务进行了限制&#xff0c;但这种限制有时候反而会让竞争对手抢得市场先机。谷歌之所以成为今天的谷歌&#xff0c;是因为它不断创造先进的新技术&#xff0c;并将这些技术向所有人开放。大型企业和…

用jsp实现右导航窗格_手机导航如何投放到汽车中控屏?建议用这2种办法,轻松实现同屏...

对于我们许多的司机来说&#xff0c;虽然车上有车载导航&#xff0c;但是出于个人习惯&#xff0c;我们很多人还是习惯用手机导航&#xff0c;由于手机导航它的定位较为精准&#xff0c;而且使用起来比较方便&#xff0c;所以说更受司机朋友的青睐&#xff0c;但是有一个毛病就…

MFC编程入门之十五(对话框:一般属性页对话框的创建及显示)

属性页对话框包括向导对话框和一般属性页对话框两类&#xff0c;上一节讲了如何创建并显示向导对话框&#xff0c;本节将继续介绍一般属性页对话框的创建和显示。 实际上&#xff0c;一般属性页对话框的创建和显示过程和向导对话框是很类似的。将上一节中的向导对话框进行少量修…

javascript 等待指定时间_javascript的单线程和任务队列

一、JavaScript为什么设计为单线程&#xff1f;JavaScript语言的一大特点就是单线程&#xff0c;换言之就是同一个时间只能做一件事。其他任务都必须在后面排队等待。for(var i 0; i < 5; i) {console.log(i); } console.log(end);上面的代码&#xff0c;只有for循环执行完…

2019年云计算行业深度报告

来源&#xff1a;西部证券 导语 根据 Gartner 数据 2018 年全球公有云市场规模达到 1392 亿美元&#xff0c;2015 年至 2018 年复合增长 28.24%&#xff0c;预计 2021 年规模将达到 2461 亿美元。 一、云计算蓬勃发展&#xff0c;驱动数据中心基础设施采购 1.1 云计算蓬勃发展&…

dataframe 一列的不同值_pandas | 详解DataFrame中的apply与applymap方法

点击上方蓝字&#xff0c;关注并星标&#xff0c;和我一起学技术。今天是pandas数据处理专题的第5篇文章&#xff0c;我们来聊聊pandas的一些高级运算。在上一篇文章当中&#xff0c;我们介绍了panads的一些计算方法&#xff0c;比如两个dataframe的四则运算&#xff0c;以及da…

https访问http加载不出图片_前端解决第三方图片防盗链的办法

作者&#xff1a;biaochenxuying转发链接&#xff1a;https://github.com/biaochenxuying/blog/issues/31问题笔者网站的图片都是上传到第三方网站上的&#xff0c;比如 简书、掘金、七牛云上的&#xff0c;但是最近简书和掘金都开启了 防盗链&#xff0c;防止其他网站访问他们…

java spring boot 注解验证_如何理解Java原生注解和Spring 各种注解?

作者&#xff1a;digdeep.cnblogs.com/digdeep/p/4525567.html导引Spring中的注解大概可以分为两大类&#xff1a;spring的bean容器相关的注解&#xff0c;或者说bean工厂相关的注解&#xff1b;springmvc相关的注解。spring的bean容器相关的注解有&#xff1a;Required&#x…

数据驱动的未来城市八大趋势

来源&#xff1a;微信公众号腾讯研究院 趋势一 更可持续 城市的发展要为整个人类文明的永续传承和为后人能享受到更高质量的生活为目标。一个更加智慧的城市&#xff0c;势必具有着更加可持续发展的能力。新科技为城市的核心系统的设施提供了更为智能、高效率的调配方案&#x…

浪潮服务器bios怎么找回密码,服务器BIOS密码丢失解决方法

先升级iBMC&#xff0c;再升级bios&#xff0c;可以将bios密码重置。此案例以RH2288为例&#xff1a;1、登录到iBMC web界面&#xff0c;点击系统设置里的固件升级&#xff0c;将BMC升级包image.hpm上传后&#xff0c;点击升级&#xff0c;因为BMC主备两个镜像&#xff0c;需要…

看了中国与别国的科研差距后,究竟什么才是真正的科研精神?

来源&#xff1a;募格学术 目前&#xff0c;中国的科研环境越来越好&#xff0c;单就硬件上来讲&#xff0c;与欧美发达国家没有很大差别。2014年&#xff0c;中国研发投入13400亿元&#xff0c;占GPD2.1%&#xff0c;这个比例超过了欧盟。然而&#xff0c;引人深思的是中国缺席…

numpy 转置_Numpy基础:数组转置和轴对换

转置&#xff08;transpose&#xff09;是重塑的一种特殊形式&#xff0c;它返回的是源数据的视图&#xff08;不会进行任何复制操作&#xff09;。数组不仅有transpose方法&#xff0c;还有一个特殊的T属性。In[70]:arrnp.arange(15).reshape((3,5))In[71]:arrOut[71]: array(…

word2016 图片去底灰_看来看去,还是高级灰最耐看,喜欢现代简约风的你,选它准不会错...

经常看到有人问&#xff1a;不想要大白墙&#xff0c;给家里装点什么颜色好&#xff1f;这个问题其实没有固定答案&#xff0c;毕竟对于色彩的感受&#xff0c;每个人都不一样。没有固定答案不代表没有选择&#xff0c;好看又百搭的色彩有很多&#xff0c;但是能做到经典与时尚…

惊人的预测——来自2019麦肯锡报告《中国与世界》完整版

来源&#xff1a;麦肯锡全球研究院 自从中国开始建立与世界各国的经济往来、拥抱市场机制&#xff0c;并积极接纳全球最佳实践以后&#xff0c; 中国经济便迈入了腾飞阶段。如今&#xff0c;中国已凭借其庞大的经济体量跻身全球大国之列。中国在2013年跃居全球第一大商品贸易国…

匹夫细说C#:庖丁解牛迭代器,那些藏在幕后的秘密

匹夫细说C#&#xff1a;庖丁解牛迭代器&#xff0c;那些藏在幕后的秘密c#语言规范阅读目录0x00 前言0x01 你好&#xff0c;迭代器0x02 原来是状态机呀0x03 状态管理0x04 总结回到目录0x00 前言在匹夫的上一篇文章《匹夫细说C#&#xff1a;不是“栈类型”的值类型&#xff0c;从…

法国公布“人机协同”项目第二批研究计划

来源&#xff1a;法国《航宇防务》/图片来自互联网出处&#xff1a;国防科技要闻近日&#xff0c;法国公布了“人机协同”&#xff08;MMT&#xff09;项目第二批研究计划。MMT项目由法国武器装备总署&#xff08;DGA&#xff09;管理&#xff0c;于2018年3月启动&#xff0c;是…

xp打印服务器win10的系统连接不上,Win10系统访问WinXP系统共享打印机却连接不了的解决方法...

在今天的Win10系统的使用教程中&#xff0c;我们将来学习的是Win10系统访问WinXP系统共享打印机却连接不了的问题。不过&#xff0c;小编得事先说一下&#xff0c;Win10系统是可以直接连接WinXP系统共享打印机的&#xff0c;只是个别用户由于一些原因而出现这个状况&#xff0c…