python3标准库函数,python38标准库

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Python常用函数三有哪些？这7个函数使用频率最高，总算搞明白了

1.1 例如：print(hex(2))案例

1.2 输出函数：print(hex(2))

1.3 输出结果：0x2

1.4 解析说明：返回16进制的数。

2.1 例如：print(chr(10))案例

2.2 输出函数：print(chr(10))

2.3 输出结果：0o12

2.4 解析说明：返回当前整数对应的ASCll码

3.1 例如：print(ord("b"))案例

3.2 输出函数：print(ord("b"))

3.3 输出结果：98

3.4 解析说明：返回当前ASCll码的10进制数

4.1 例如：print(chr(97))

4.2 输出函数：print(chr(97))

4.3 输出结果：b

4.4 解析说明：返回当前ASCll码的10进制数。

案例一：给你一个字符串,s = 'hello kitty'

1.1 输出函数：print(s.capitalize())

1.2 输出结果：0x2

1.3 解析说明：返回16进制的数。

2.1输出函数：print(s.replace('kitty','kuang'))

2.2 输出结果：hello kuang

2.3 解析说明：替换功能，将kitty换成kuang。

2.4 输出函数：print(s.replace('4','KK'))

2.5 输出结果：12KK12KK

2.6 解析说明：所有的4都替换成KK

2.7 输出函数：print(s.replace('4','KK'))

2.8 输出结果：12KK12KK124

2.9 解析说明：将前两个的4替换成go

案例一：给你一个字符串，ip = '192.168.1.1'

3.1 输出函数：print(ip.split(','))

3.2 输出结果：['192.168.1.1']

3.3 解析说明：将字符串分割成列表

案例一：给你一个字符串，ip = '192.168.1.1'

3.3 输出函数：print(ip.split(',',2))

3.4 输出结果：['192.168.1.1']

3.5 解析说明：从第二个开始分割成列表

相关问答

Q1: 后端编程Python3-调试、测试和性能剖析(下)

单元测试（Unit Testing）

为程序编写测试——如果做的到位——有助于减少bug的出现，并可以提高我们对程序按预期目标运行的信心。通常，测试并不能保证正确性，因为对大多数程序而言，可能的输入范围以及可能的计算范围是如此之大，只有其中最小的一部分能被实际地进行测试。尽管如此，通过仔细地选择测试的方法和目标，可以提高代码的质量。

大量不同类型的测试都可以进行，比如可用性测试、功能测试以及整合测试等。这里, 我们只讲单元测试一对单独的函数、类与方法进行测试，确保其符合预期的行为。

TDD的一个关键点是，当我们想添加一个功能时——比如为类添加一个方法—— 我们首次为其编写一个测试用例。当然，测试将失败，因为我们还没有实际编写该方法。现在，我们编写该方法，一旦方法通过了测试，就可以返回所有测试，确保我们新添加的代码没有任何预期外的副作用。一旦所有测试运行完毕（包括我们为新功能编写的测试），就可以对我们的代码进行检查，并有理有据地相信程序行为符合我们的期望——当然，前提是我们的测试是适当的。

比如，我们编写了一个函数，该函数在特定的索引位置插入一个字符串，可以像下面这样开始我们的TDD：

def insert_at（string, position, insert）:

"""Returns a copy of string with insert inserted at the position

string = "ABCDE"

result =[]

for i in range(-2, len(string) + 2):

... result.append(insert_at(string, i,“-”))

result[:5]

['ABC-DE', 'ABCD-E', '-ABCDE','A-BCDE', 'AB-CDE']

result[5:]

['ABC-DE', 'ABCD-E', 'ABCDE-', 'ABCDE-']

"""

return string

对不返回任何参数的函数或方法（通常返回None）,我们通常赋予其由pass构成的一个suite,对那些返回值被试用的，我们或者返回一个常数（比如0）,或者某个不变的参数——这也是我们这里所做的。（在更复杂的情况下，返回fake对象可能更有用一一对这样的类，提供mock对象的第三方模块是可用的。）

运行doctest时会失败，并列出每个预期内的字符串（'ABCD-EF'、'ABCDE-F' 等），及其实际获取的字符串（所有的都是'ABCD-EF'）。一旦确定doctest是充分的和正确的，就可以编写该函数的主体部分，在本例中只是简单的return string[:position] + insert+string[position:]。（如果我们编写的是 return string[:position] + insert,之后复制 string [:position]并将其粘贴在末尾以便减少一些输入操作，那么doctest会立即提示错误。）

Python的标准库提供了两个单元测试模块，一个是doctest,这里和前面都简单地提到过，另一个是unittest。此外，还有一些可用于Python的第三方测试工具。其中最著名的两个是nose (code.google.com/p/python-nose)与py.test (codespeak.net/py/dist/test/test.html), nose 致力于提供比标准的unittest 模块更广泛的功能，同时保持与该模块的兼容性，py.test则采用了与unittest有些不同的方法，试图尽可能消除样板测试代码。这两个第三方模块都支持测试发现，因此没必要写一个总体的测试程序——因为模块将自己搜索测试程序。这使得测试整个代码树或某一部分 (比如那些已经起作用的模块)变得很容易。那些对测试严重关切的人，在决定使用哪个测试工具之前，对这两个(以及任何其他有吸引力的)第三方模块进行研究都是值得的。

创建doctest是直截了当的：我们在模块中编写测试、函数、类与方法的docstrings。对于模块，我们简单地在末尾添加了 3行：

if __name__ =="__main__":

import doctest

doctest.testmod()

在程序内部使用doctest也是可能的。比如，blocks.py程序(其模块在后面)有自己函数的doctest，但以如下代码结尾：

if __name__== "__main__":

main()

这里简单地调用了程序的main()函数，并且没有执行程序的doctest。要实验程序的 doctest,有两种方法。一种是导入doctest模块，之后运行程序---比如，在控制台中输入 python3 -m doctest blocks.py (在 Wndows 平台上，使用类似于 C:Python3 lpython.exe 这样的形式替代python3)。如果所有测试运行良好，就没有输出，因此，我们可能宁愿执行python3-m doctest blocks.py-v,因为这会列出每个执行的doctest,并在最后给出结果摘要。

另一种执行doctest的方法是使用unittest模块创建单独的测试程序。在概念上， unittest模块是根据Java的JUnit单元测试库进行建模的，并用于创建包含测试用例的测试套件。unittest模块可以基于doctests创建测试用例，而不需要知道程序或模块包含的任何事物——只要知道其包含doctest即可。因此，为给blocks.py程序制作一个测试套件，我们可以创建如下的简单程序(将其称为test_blocks.py)：

import doctest

import unittest

import blocks

suite = unittest.TestSuite()

suite.addTest(doctest.DocTestSuite(blocks))

runner = unittest.TextTestRunner()

print(runner.run(suite))

注意，如果釆用这种方法，程序的名称上会有一个隐含的约束：程序名必须是有效的模块名。因此，名为convert-incidents.py的程序的测试不能写成这样。因为import convert-incidents不是有效的，在Python标识符中，连接符是无效的（避开这一约束是可能的，但最简单的解决方案是使用总是有效模块名的程序文件名，比如，使用下划线替换连接符）。这里展示的结构（创建一个测试套件，添加一个或多个测试用例或测试套件，运行总体的测试套件，输出结果）是典型的机遇unittest的测试。运行时，这一特定实例产生如下结果：

...

.............................................................................................................

Ran 3 tests in 0.244s

每次执行一个测试用例时，都会输出一个句点（因此上面的输出最前面有3个句点），之后是一行连接符，再之后是测试摘要（如果有任何一个测试失败，就会有更多的输出信息）。

如果我们尝试将测试分离开（典型情况下是要测试的每个程序和模块都有一个测试用例），就不要再使用doctests,而是直接使用unittest模块的功能——尤其是我们习惯于使用JUnit方法进行测试时ounittest模块会将测试分离于代码——对大型项目（测试编写人员与开发人员可能不一致）而言，这种方法特别有用。此外，unittest单元测试编写为独立的Python模块，因此，不会像在docstring内部编写测试用例时受到兼容性和明智性的限制。

unittest模块定义了 4个关键概念。测试夹具是一个用于描述创建测试（以及用完之后将其清理）所必需的代码的术语，典型实例是创建测试所用的一个输入文件，最后删除输入文件与结果输出文件。测试套件是一组测试用例的组合。测试用例是测试的基本单元—我们很快就会看到实例。测试运行者是执行一个或多个测试套件的对象。

典型情况下，测试套件是通过创建unittest.TestCase的子类实现的，其中每个名称以“test”开头的方法都是一个测试用例。如果我们需要完成任何创建操作，就可以在一个名为setUp()的方法中实现；类似地，对任何清理操作，也可以实现一个名为 tearDown()的方法。在测试内部，有大量可供我们使用的unittest.TestCase方法，包括 assertTrue()、assertEqual()、assertAlmostEqual()（对于测试浮点数很有用）、assertRaises() 以及更多，还包括很多对应的逆方法，比如assertFalse()、assertNotEqual()、failIfEqual()、 failUnlessEqual ()等。

unittest模块进行了很好的归档，并且提供了大量功能，但在这里我们只是通过一个非常简单的测试套件来感受一下该模块的使用。这里将要使用的实例,该练习要求创建一个Atomic模块，该模块可以用作一个上下文管理器，以确保或者所有改变都应用于某个列表、集合或字典，或者所有改变都不应用。作为解决方案提供的Atomic.py模块使用30行代码来实现Atomic类，并提供了 100行左右的模块doctest。这里，我们将创建test_Atomic.py模块，并使用 unittest测试替换doctest,以便可以删除doctest。

在编写测试模块之前，我们需要思考都需要哪些测试。我们需要测试3种不同的数据类型：列表、集合与字典。对于列表，需要测试的是插入项、删除项或修改项的值。对于集合，我们必须测试向其中添加或删除一个项。对于字典，我们必须测试的是插入一个项、修改一个项的值、删除一个项。此外，还必须要测试的是在失败的情况下，不会有任何改变实际生效。

结构上看，测试不同数据类型实质上是一样的，因此，我们将只为测试列表编写测试用例，而将其他的留作练习。test_Atomic.py模块必须导入unittest模块与要进行测试的Atomic模块。

创建unittest文件时，我们通常创建的是模块而非程序。在每个模块内部，我们定义一个或多个unittest.TestCase子类。比如，test_Atomic.py模块中仅一个单独的 unittest-TestCase子类，也就是TestAtomic (稍后将对其进行讲解)，并以如下两行结束:

if name == "__main__":

unittest.main()

这两行使得该模块可以单独运行。当然，该模块也可以被导入并从其他测试程序中运行——如果这只是多个测试套件中的一个，这一点是有意义的。

如果想要从其他测试程序中运行test_Atomic.py模块，那么可以编写一个与此类似的程序。我们习惯于使用unittest模块执行doctests,比如：

import unittest

import test_Atomic

suite = unittest.TestLoader().loadTestsFromTestCase(test_Atomic.TestAtomic)

runner = unittest.TextTestRunner()

pnnt(runner.run(suite))

这里，我们已经创建了一个单独的套件，这是通过让unittest模块读取test_Atomic 模块实现的，并且使用其每一个test*()方法(本实例中是test_list_success()、test_list_fail()，稍后很快就会看到)作为测试用例。

我们现在将查看TestAtomic类的实现。对通常的子类(不包括unittest.TestCase 子类)，不怎么常见的是，没有必要实现初始化程序。在这一案例中，我们将需要建立一个方法，但不需要清理方法，并且我们将实现两个测试用例。

def setUp(self)：

self.original_list = list(range(10))

我们已经使用了 unittest.TestCase.setUp()方法来创建单独的测试数据片段。

def test_list_succeed(self):

items = self.original_list[:]

with Atomic.Atomic(items) as atomic:

atomic.append(1999)

atomic.insert(2, -915)

del atomic[5]

atomic[4]= -782

atomic.insert(0, -9)

self.assertEqual(items,

[-9, 0, 1, -915, 2, -782, 5, 6, 7, 8, 9, 1999])

def test_list_fail(self):

items = self.original_list[:]

with self.assertRaises(AttributeError):

with Atomic.Atomic(items) as atomic:

atomic.append(1999)

atomic.insert(2, -915)

del atomic[5]

atomic[4] = -782

atomic.poop() # Typo

self.assertListEqual(items, self.original_list)

这里，我们直接在测试方法中编写了测试代码，而不需要一个内部函数，也不再使用unittest.TestCase.assertRaised()作为上下文管理器(期望代码产生AttributeError)。最后我们也使用了 Python 3.1 的 unittest.TestCase.assertListEqual()方法。

正如我们已经看到的，Python的测试模块易于使用，并且极为有用，在我们使用 TDD的情况下更是如此。它们还有比这里展示的要多得多的大量功能与特征——比如，跳过测试的能力，这有助于理解平台差别——并且这些都有很好的文档支持。缺失的一个功能——但nose与py.test提供了——是测试发现，尽管这一特征被期望在后续的Python版本(或许与Python 3.2—起)中出现。

性能剖析（Profiling）

如果程序运行很慢，或者消耗了比预期内要多得多的内存，那么问题通常是选择的算法或数据结构不合适，或者是以低效的方式进行实现。不管问题的原因是什么，最好的方法都是准确地找到问题发生的地方,而不只是检査代码并试图对其进行优化。随机优化会导致引入bug,或者对程序中本来对程序整体性能并没有实际影响的部分进行提速，而这并非解释器耗费大部分时间的地方。

在深入讨论profiling之前，注意一些易于学习和使用的Python程序设计习惯是有意义的，并且对提高程序性能不无裨益。这些技术都不是特定于某个Python版本的，而是合理的Python程序设计风格。第一，在需要只读序列时，最好使用元组而非列表；第二，使用生成器，而不是创建大的元组和列表并在其上进行迭代处理；第三，尽量使用Python内置的数据结构 dicts、lists、tuples 而不实现自己的自定义结构，因为内置的数据结构都是经过了高度优化的；第四，从小字符串中产生大字符串时，不要对小字符串进行连接，而是在列表中累积，最后将字符串列表结合成为一个单独的字符串；第五，也是最后一点，如果某个对象(包括函数或方法)需要多次使用属性进行访问(比如访问模块中的某个函数)，或从某个数据结构中进行访问，那么较好的做法是创建并使用一个局部变量来访问该对象，以便提供更快的访问速度。

Python标准库提供了两个特别有用的模块，可以辅助调査代码的性能问题。一个是timeit模块——该模块可用于对一小段Python代码进行计时，并可用于诸如对两个或多个特定函数或方法的性能进行比较等场合。另一个是cProfile模块，可用于profile 程序的性能——该模块对调用计数与次数进行了详细分解，以便发现性能瓶颈所在。

为了解timeit模块，我们将查看一些小实例。假定有3个函数function_a()、 function_b()、function_c(), 3个函数执行同样的计算，但分别使用不同的算法。如果将这些函数放于同一个模块中(或分别导入)，就可以使用timeit模块对其进行运行和比较。下面给出的是模块最后使用的代码：

if __name__ == "__main__":

repeats = 1000

for function in ("function_a", "function_b", "function_c"):

t = timeit.Timer("{0}(X, Y)".format(function),"from __main__ import {0}, X, Y".format(function))

sec = t.timeit(repeats) / repeats

print("{function}() {sec:.6f} sec".format(**locals()))

赋予timeit.Timer()构造子的第一个参数是我们想要执行并计时的代码，其形式是字符串。这里，该字符串是“function_a(X,Y)”；第二个参数是可选的，还是一个待执行的字符串，这一次是在待计时的代码之前，以便提供一些建立工作。这里，我们从 __main__ (即this)模块导入了待测试的函数，还有两个作为输入数据传入的变量(X 与Y),这两个变量在该模块中是作为全局变量提供的。我们也可以很轻易地像从其他模块中导入数据一样来进行导入操作。

调用timeit.Timer对象的timeit()方法时，首先将执行构造子的第二个参数(如果有)，之后执行构造子的第一个参数并对其执行时间进行计时。timeit.Timer.timeit()方法的返回值是以秒计数的时间，类型是float。默认情况下，timeit()方法重复100万次，并返回所有这些执行的总秒数，但在这一特定案例中，只需要1000次反复就可以给出有用的结果, 因此对重复计数次数进行了显式指定。在对每个函数进行计时后，使用重复次数对总数进行除法操作，就得到了平均执行时间，并在控制台中打印出函数名与执行时间。

function_a() 0.001618 sec

function_b() 0.012786 sec

function_c() 0.003248 sec

在这一实例中，function_a()显然是最快的——至少对于这里使用的输入数据而言。在有些情况下一一比如输入数据不同会对性能产生巨大影响——可能需要使用多组输入数据对每个函数进行测试，以便覆盖有代表性的测试用例，并对总执行时间或平均执行时间进行比较。

有时监控自己的代码进行计时并不是很方便，因此timeit模块提供了一种在命令行中对代码执行时间进行计时的途径。比如，要对MyModule.py模块中的函数function_a()进行计时，可以在控制台中输入如下命令：python3 -m timeit -n 1000 -s "from MyModule import function_a, X, Y" "function_a(X, Y)"(与通常所做的一样，对 Windows 环境，我们必须使用类似于C:Python3lpython.exe这样的内容来替换python3)。-m选项用于Python 解释器，使其可以加载指定的模块(这里是timeit),其他选项则由timeit模块进行处理。 -n选项指定了循环计数次数，-s选项指定了要建立，最后一个参数是要执行和计时的代码。命令完成后，会向控制台中打印运行结果，比如：

1000 loops, best of 3: 1.41 msec per loop

之后我们可以轻易地对其他两个函数进行计时，以便对其进行整体的比较。

cProfile模块(或者profile模块，这里统称为cProfile模块)也可以用于比较函数与方法的性能。与只是提供原始计时的timeit模块不同的是，cProfile模块精确地展示了有什么被调用以及每个调用耗费了多少时间。下面是用于比较与前面一样的3个函数的代码：

if __name__ == "__main__":

for function in ("function_a", "function_b", "function_c"):

cProfile.run("for i in ranged 1000): {0}(X, Y)".format(function))

我们必须将重复的次数放置在要传递给cProfile.run()函数的代码内部，但不需要做任何创建，因为模块函数会使用内省来寻找需要使用的函数与变量。这里没有使用显式的print()语句，因为默认情况下，cProfile.run()函数会在控制台中打印其输出。下面给出的是所有函数的相关结果(有些无关行被省略，格式也进行了稍许调整，以便与页面适应)：

1003 function calls in 1.661 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.003 0.003 1.661 1.661 :1 ( )

1000 1.658 0.002 1.658 0.002 MyModule.py:21 (function_a)

1 0.000 0.000 1.661 1.661 {built-in method exec}

5132003 function calls in 22.700 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.487 0.487 22.700 22.700 : 1 ( )

1000 0.011 0.000 22.213 0.022 MyModule.py:28(function_b)

5128000 7.048 0.000 7.048 0.000 MyModule.py:29( )

1000 0.00 50.000 0.005 0.000 {built-in method bisectjeft}

1 0.000 0.000 22.700 22.700 {built-in method exec}

1000 0.001 0.000 0.001 0.000 {built-in method len}

1000 15.149 0.015 22.196 0.022 {built-in method sorted}

5129003 function calls in 12.987 CPU seconds

ncalls tottime percall cumtime percall filename:lineno(function)

1 0.205 0.205 12.987 12.987 :l ( )

1000 6.472 0.006 12.782 0.013 MyModule.py:36(function_c)

5128000 6.311 0.000 6.311 0.000 MyModule.py:37( )

1 0.000 0.000 12.987 12.987 {built-in method exec}

ncalls ("调用的次数")列列出了对指定函数(在filename:lineno(function)中列出) 的调用次数。回想一下我们重复了 1000次调用，因此必须将这个次数记住。tottime (“总的时间”)列列出了某个函数中耗费的总时间，但是排除了函数调用的其他函数内部花费的时间。第一个percall列列出了对函数的每次调用的平均时间(tottime // ncalls)。 cumtime ("累积时间")列出了在函数中耗费的时间，并且包含了函数调用的其他函数内部花费的时间。第二个percall列列出了对函数的每次调用的平均时间，包括其调用的函数耗费的时间。

这种输出信息要比timeit模块的原始计时信息富有启发意义的多。我们立即可以发现，function_b()与function_c()使用了被调用5000次以上的生成器，使得它们的速度至少要比function_a()慢10倍以上。并且，function_b()调用了更多通常意义上的函数，包括调用内置的sorted()函数，这使得其几乎比function_c()还要慢两倍。当然,timeit() 模块提供了足够的信息来查看计时上存在的这些差别，但cProfile模块允许我们了解为什么会存在这些差别。正如timeit模块允许对代码进行计时而又不需要对其监控一样，cProfile模块也可以做到这一点。然而，从命令行使用cProfile模块时，我们不能精确地指定要执行的是什么——而只是执行给定的程序或模块，并报告所有这些的计时结果。需要使用的命令行是python3 -m cProfile programOrModule.py,产生的输出信息与前面看到的一样，下面给出的是输出信息样例，格式上进行了一些调整，并忽略了大多数行：

10272458 function calls (10272457 primitive calls) in 37.718 CPU secs

ncalls tottime percall cumtime percall filename:lineno(function)

10.000 0.000 37.718 37.718 :1 ( )

10.719 0.719 37.717 37.717 :12( )

1000 1.569 0.002 1.569 0.002 :20(function_a)

1000 0.011 0.000 22.560 0.023 :27(function_b)

5128000 7.078 0.000 7.078 0.000 :28( )

1000 6.510 0.007 12.825 0.013 :35(function_c)

5128000 6.316 0.000 6.316 0.000 :36( )

在cProfile术语学中，原始调用指的就是非递归的函数调用。

以这种方式使用cProfile模块对于识别值得进一步研究的区域是有用的。比如，这里我们可以清晰地看到function_b()需要耗费更长的时间，但是我们怎样获取进一步的详细资料？我们可以使用cProfile.run("function_b()")来替换对function_b()的调用。或者可以保存完全的profile数据并使用pstats模块对其进行分析。要保存profile,就必须对命令行进行稍许修改:python3 -m cProfile -o profileDataFile programOrModule.py。之后可以对 profile 数据进行分析，比如启动IDLE,导入pstats模块，赋予其已保存的profileDataFile,或者也可以在控制台中交互式地使用pstats。

下面给出的是一个非常短的控制台会话实例，为使其适合页面展示，进行了适当调整，我们自己的输入则以粗体展示：

$ python3 -m cProfile -o profile.dat MyModule.py

$ python3 -m pstats

Welcome to the profile statistics browser.

% read profile.dat

profile.dat% callers function_b

Random listing order was used

List reduced from 44 to 1 due to restriction

Function was called by...

ncalls tottime cumtime

:27(function_b) - 1000 0.011 22.251 :12( )

profile.dat% callees function_b

Random listing order was used

List reduced from 44 to 1 due to restriction

Function called...

ncalls tottime cumtime

:27(function_b)-

1000 0.005 0.005 built-in method bisectJeft

1000 0.001 0.001 built-in method len

1000 1 5.297 22.234 built-in method sorted

profile.dat% quit

输入help可以获取命令列表，help后面跟随命令名可以获取该命令的更多信息。比如, help stats将列出可以赋予stats命令的参数。还有其他一些可用的工具，可以提供profile数据的图形化展示形式，比如 RunSnakeRun (), 该工具需要依赖于wxPython GUI库。

使用timeit与cProfile模块，我们可以识别出我们自己代码中哪些区域会耗费超过预期的时间；使用cProfile模块，还可以准确算岀时间消耗在哪里。

以上内容部分摘自视频课程 05后端编程Python-19调试、测试和性能调优(下) ，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。

Q2: Python 常用的标准库以及第三方库有哪些

推荐5个常用的Python标准库：

1、os：提供了不少与操作系统相关联的函数库

os包是Python与操作系统的接口。我们可以用os包来实现操作系统的许多功能，比如管理系统进程，改变当前路径，改变文件权限等。但要注意，os包是建立在操作系统的平台上的，许多功能在Windows系统上是无法实现的。另外，在使用os包中，要注意其中的有些功能已经被其他的包取代。

我们通过文件系统来管理磁盘上储存的文件。查找、删除、复制文件以及列出文件列表等都是常见的文件操作。这些功能通常可以在操作系统中看到，但现在可以通过Python标准库中的glob包、shutil包、os.path包以及os包的一些函数等，在Python内部实现。

2、sys：通常用于命令行参数的库

sys包被用于管理Python自身的运行环境。Python是一个解释器，也是一个运行在操作系统上的程序。我们可以用sys包来控制这一程序运行的许多参数，比如说Python运行所能占据的内存和CPU，Python所要扫描的路径等。另一个重要功能是和Python自己的命令行互动，从命令行读取命令和参数。

3、random：用于生成随机数的库

Python标准库中的random函数，可以生成随机浮点数、整数、字符串，甚至帮助你随机选择列表序列中的一个元素，打乱一组数据等。

4、math：提供了数学常数和数学函数

标准库中，Python定义了一些新的数字类型，以弥补之前的数字类型可能的不足。标准库还包含了random包，用于处理随机数相关的功能。math包补充了一些重要的数学常数和数学函数，比如pi、三角函数等等。

5、datetime：日期和时间的操作库

日期和时间的管理并不复杂，但容易犯错。Python的标准库中对日期和时间的管理颇为完善，你不仅可以进行日期时间的查询和变换，还可以对日期时间进行运算。通过这些标准库，还可以根据需要控制日期时间输出的文本格式

Q3: python常用函数包有哪些？

一些python常用函数包：

1、Urllib3

Urllib3是一个 Python 的 HTTP 客户端，它拥有 Python 标准库中缺少的许多功能：

线程安全

连接池

客户端 SSL/TLS 验证

使用分段编码上传文件

用来重试请求和处理 HTTP 重定向的助手

支持 gzip 和 deflate 编码

HTTP 和 SOCKS 的代理支持

2、Six

six 是一个是 Python 2 和 3 的兼容性库。这个项目旨在支持可同时运行在 Python 2 和 3 上的代码库。它提供了许多可简化 Python 2 和 3 之间语法差异的函数。

3、botocore、boto3、s3transfer、awscli

Botocore是 AWS 的底层接口。Botocore是 Boto3 库（#22）的基础，后者让你可以使用 Amazon S3 和 Amazon EC2 一类的服务。Botocore 还是 AWS-CLI 的基础，后者为 AWS 提供统一的命令行界面。

S3transfer（#7）是用于管理 Amazon S3 传输的 Python 库。它正在积极开发中，其介绍页面不推荐人们现在使用，或者至少等版本固定下来再用，因为其 API 可能发生变化，在次要版本之间都可能更改。Boto3、AWS-CLI和其他许多项目都依赖s3transfer。

4、Pip

pip是“Pip Installs Packages”的首字母递归缩写。

pip很容易使用。要安装一个包只需pip install package name即可，而删除包只需pip uninstall package name即可。

最大优点之一是它可以获取包列表，通常以requirements.txt文件的形式获取。该文件能选择包含所需版本的详细规范。大多数 Python 项目都包含这样的文件。

如果结合使用pip与virtualenv（列表中的 #57），就可以创建可预测的隔离环境，同时不会干扰底层系统，反之亦然。

5、Python-dateutil

python-dateutil模块提供了对标准datetime模块的强大扩展。我的经验是，常规的Python datetime缺少哪些功能，python-dateutil就能补足那一块。

6、Requests

Requests建立在我们的 #1 库——urllib3基础上。它让 Web 请求变得非常简单。相比urllib3来说，很多人更喜欢这个包。而且使用它的最终用户可能也比urllib3更多。后者更偏底层，并且考虑到它对内部的控制级别，它一般是作为其他项目的依赖项。

7、Certifi

近年来，几乎所有网站都转向 SSL，你可以通过地址栏中的小锁符号来识别它。加了小锁意味着与该站点的通信是安全和加密的，能防止窃听行为。

8、Idna

根据其 PyPI 页面，idna提供了“对 RFC5891 中指定的应用程序中国际化域名（IDNA）协议的支持。”

IDNA的核心是两个函数：ToASCII和ToUnicode。ToASCII会将国际 Unicode 域转换为 ASCII 字符串。ToUnicode则逆转该过程。在IDNA包中，这些函数称为idna.encode()和idna.decode()

9、PyYAML

YAML是一种数据序列化格式。它的设计宗旨是让人类和计算机都能很容易地阅读代码——人类很容易读写它的内容，计算机也可以解析它。

PyYAML是 Python 的YAML解析器和发射器，这意味着它可以读写YAML。它会把任何 Python 对象写成YAML：列表、字典，甚至是类实例都包括在内。

10、Pyasn1

像上面的IDNA一样，这个项目也非常有用：

ASN.1 类型和 DER/BER/CER 编码（X.208）的纯 Python 实现

所幸这个已有数十年历史的标准有很多信息可用。ASN.1是 Abstract Syntax Notation One 的缩写，它就像是数据序列化的教父。它来自电信行业。也许你知道协议缓冲区或 Apache Thrift？这就是它们的 1984 年版本。

11、Docutils

Docutils是一个模块化系统，用来将纯文本文档处理为很多有用的格式，例如 HTML、XML 和 LaTeX 等。Docutils能读取reStructuredText格式的纯文本文档，这种格式是类似于 MarkDown 的易读标记语法。

12、Chardet

你可以用chardet模块来检测文件或数据流的字符集。比如说，需要分析大量随机文本时，这会很有用。但你也可以在处理远程下载的数据，但不知道用的是什么字符集时使用它。

13、RSA

rsa包是一个纯 Python 的 RSA 实现。它支持：

加密和解密

签名和验证签名

根据 PKCS#1 1.5 版生成密钥

它既可以用作 Python 库，也能在命令行中使用。

14、Jmespath

JMESPath，发音为“James path”，使 Python 中的 JSON 更容易使用。它允许你声明性地指定如何从 JSON 文档中提取元素。

15、Setuptools

它是用于创建 Python 包的工具。不过，其文档很糟糕。它没有清晰描述它的用途，并且文档中包含无效链接。最好的信息源是这个站点，特别是这个创建 Python 包的指南。

16、Pytz

像dateutils一样，这个库可帮助你处理日期和时间。有时候，时区处理起来可能很麻烦。幸好有这样的包，可以让事情变得简单些。

17、Futures

从 Python 3.2 开始，python 提供current.futures模块，可帮助你实现异步执行。futures 包是该库适用于 Python 2 的 backport。它不适用于 Python3 用户，因为 Python 3 原生提供了该模块。

18、Colorama

使用 Colorama，你可以为终端添加一些颜色：

更多Python知识请关注Python自学网

Q4: 二级Python----Python的内置函数及标准库（DAY 8）

python的内置函数（68个）

Python考核31个内置函数，

python内置了很多内置函数、类方法属性及各种模块。当我们想要当我们想要了解某种类型有哪些属性方法以及每种方法该怎么使用时，我们可以使用dir()函数和help()函数在python idle交互式模式下获得我们想要的信息。

• dir()函数获得对象中可用属性的列表

Python中的关键词有哪些？

dir(__builtins__)：查看python内置函数

help(‘keywords‘)：查看python关键词

如微分积分方程的求解程序、访问互联网、获取日期和时间、机器学习算法等。这些程序往往被收入程序库中，构成程序库。

只有经过严格检验的程序才能放在程序库里。检验，就是对程序作充分的测试。通常进行的有正确性测试、精度测试、速度测试、边界条件和出错状态的测试。经过检验的程序不但能保证计算结果的正确性，而且对错误调用也能作出反应。程序库中的程序都是规范化的。所谓规范化有三重含义：①同一库里所有程序的格式是统一的；② 对这些程序的调用方法是相同的；③ 每个程序所需参数的数目、顺序和类型都是严格规定好的。

Python的库包含标准库和第三方库

标准库：程序语言自身拥有的库，可以直接使用。help('modules')

第三方库：第三方者使用该语言提供的程序库。

标准库： turtle 库（必选）、 random 库（必选）、 time 库（可选）。

• turtle 库：图形绘制库

原理如同控制一只海龟，以不同的方向和速度进行位移而得到其运动轨迹。

使用模块的帮助时，需要先将模块导入。

例如：在IDLE中输入import turtle

dir(turtle)

help(turtle.**)

1.画布

画布就是turtle为我们展开用于绘图区域, 我们可以设置它的大小和初始位置。