本文将讨论多少python3，以及多少python3具有相应的知识点。我希望这对您有帮助。不要忘记收集此网站。
本文目录清单：
1. Python3 Pyqt5 Pyinstaller装满了太多，包装为40。参考文献库写在下面，请查看如何简化IT！Intersection2。后端编程python3删除，测试和性能分析（下图）3。Python3＆基本数据类型（1）我还，由于对TXT的简单格式输出，实际上有90m，震惊，我期待它，我期待它，期待的是科学的伟大神。
单位测试
为程序编写测试 - 如果您这样做-Shelp来减少错误的出现并提高我们按预期运行该程序的信心。基础上，测试不能保证正确性，因为对于大多数程序，可能的输入范围和可能的计算范围是如此大，只能实际测试最小的部分。不过，通过仔细选择测试方法和目标，可以提高代码的质量。
可以执行大量不同类型的测试，例如可用性测试，功能测试和集成测试。在这里，我们仅谈论单元测试一对单独的功能，类和测试方法，以确保其行为以确保其行为遇到预期。
TDD的一个关键点是，当我们要添加一个函数时，例如在类中添加方法 - 我们首次编写测试用例。当然，测试将失败，因为我们实际上没有编写此方法。现在，我们编写此方法。该方法通过测试后，我们可以返回所有测试，以确保我们新添加的代码没有预期的副作用。一旦所有测试运行（包括我们为新功能编写的测试），我们可以检查我们的代码，并且可以合理地相信计划行为符合我们的期望 - 当然，前提是我们的测试是适当的。
例如，我们编写了一个函数，该函数将字符串插入特定的索引位置，该函数可以按以下方式启动我们的TDD：
def insert_at（字符串，位置，插入）：
“”“返回字符串的副本，并在位置插入
字符串=“ abcde”
结果= []
对于i在范围（-2，len（string） + 2）的范围内：
... result.append（insert_at（字符串，i，“ - ”））
结果[：5]
['abc-de'，'abcd-e'，'-abcde'，'a-bcde'，'ab-cde']
结果[5：]
['abc-de'，'abcd-e'，'abcde-'，'abcde-']
”“”
返回字符串
对于不返回任何参数的函数或方法（通常不返回），我们通常会给它一个由通行证组成的套件。对于那些返回那些返回toparameters的价值的人来说，这就是我们在这里所做的。（在更复杂的情况下，返回的伪造对象可能更有用，而提供模拟对象的第三党派模块可用。）
运行医生时，它将失败，并且字符串（'abcd-ef'，'abcde-f'等）以及其实际字符串（全部为'abcd-ef'）每个预期字符串（所有都是'abcd--ef'）。一旦医生完全正确，您可以编写功能的主要部分。在此示例中，它只是一个简单的返回字符串[：position] + insert + string [position：]。减少一些输入操作，然后Doctest会立即引起错误。）
Python的标准库提供了两个单位测试模块，一个是医生，在这里简要提及，另一个是UnitSest。此外，还有一些针对Python的第三部分测试工具。最著名的两个是鼻子（鼻子）（code.google.com/p/python-nose）和py.test（codeSpeak.net/dist/test/test/test.html)..一个范围范围较大的功能，同时保持与模块的兼容性，py.test使用其他方式尝试尽可能多地消除模型测试代码。整个代码树或某个部分（例如已经播放的模块）。在确定哪些测试工具的确定之前，对测试有严重关注的人，对于研究这两个（以及其他有吸引力的）第三部分很有价值模块。
创建Doctst是很简单的：我们在模块中编写测试，功能和方法。对于模块，我们简单地添加了3行：
如果__name__ ==“ __ main__”：
进口医生
doctst.testmod（）
也可以在程序内使用医生。例如，blocks.py程序（其模块落后）具有其自身功能的医生，但以下代码结束了：
如果__-Name __ ==“ __ main __”：
main（main（main（主）
这里只是调用程序的主要（）函数，并且没有该程序的医生。在实验程序中有两种方法。输入Python3 -M医生blocks.py在控制台（在WNDOWS平台上，使用Python3 3）。如果所有测试都很好，则没有输出。因此，我们可能宁愿执行Python3-M Doctest blocks.py-V，因为这将列出每个执行的医生，结果将在最后给出。
执行医生的另一种方法是使用Unitest Module创建一个单独的测试程序。在概念中，Unittest模块是基于Java的Junit单元测试库进行建模，并用于创建包含测试用例的测试套件。联合模块可以创建基于医生的测试用例，不知道程序中包含的任何内容，只要它知道它包含医生。test_blocks.py）：
进口医生
导入UNITSEST
导入块
suite = unittest.testsuite（）
suite.addtest（doctest.doctestsuite（块））
runner = unittest.texttestrunner（）
打印（Runner.Run（Suite））
请注意，如果您使用此方法，则对程序的名称有隐式约束：程序名称必须是有效的模块名称。导入转换量无效，在Python标识符中，连接符号无效（避免使用此约束，但最简单的解决方案是使用始终使用有效模块名称的程序文件名，例如，例如，例如，例如，例如，例如，例如，例如，例如，例如，例如，例如例如，例如，使用卓越来替换连接器）。此处显示的结构（创建一个或多个测试用例或测试套件，运行整体测试套件，输出结果）是典型的机会测试。运行时，此特定实例会产生以下结果：
Em
......................................................................................................................................................................................................................................................................................................................................................................................................
在0.244s进行了3次测试
好的
每次执行测试案例时，都会输出输出（因此上述输出位于3个末端的最前沿），然后是连接符号线，然后进行测试摘要（如果任何测试失败，将会有更多将会有更多的输出信息）。
如果我们尝试将测试分开（在典型的情况下，每个要测试的程序和模块都有测试用例），请不要再使用医生，而是直接使用Untist Module的功能 - 尤其是我们习惯于使用Junit到使用JunitMethods在测试过程中将Ounittest模块与代码分开 - 这种方法对大型项目（测试写作人员和开发人员）特别有用，此方法特别有用。此外，UnitTest单元测试被编写为独立的Python模块，因此，在docstring中编写测试案例时，它不会受到兼容性和明智的限制。
UNITSEST模块定义了4个关键概念。测试固定装置是描述描述创建测试（以及使用后）的代码的术语。典型的示例是用于创建测试的输入文件，最后删除输入文件和结果输出文件。测试套件是一组测试用例的组合。测试用例是测试的基本单位-We将很快看到实例。测试操作员是一个或多个测试套件的对象。
在典型情况下，通过创建UnitTest.testcase的子类实现测试套件。以“测试”开头的每个名称都是测试用例。如果我们需要完成任何创建操作，则可以通过称为setup（）的方法实现；同样，对于任何清洁操作，我们还可以实现一种称为撕裂的方法（）。对于测试浮点的数量），assertraises（）等非常有用，包括许多相应的反反代码，例如assertfalse（），assertnotequal（），failife qual（），failife qual（），failuneless equalequal（）
UNITSEST模块的存档良好并提供了很多功能，但是在这里我们只使用一个非常简单的测试套件来感觉到模块的使用。在这里要使用的示例，练习需要创建一个原子模块，可以使用该模块作为确保或所有更改的上下文经理，将所有更改应用于列表，收集或词典，或不应用所有更改。该解决方案提供的Atomic.py模块使用30行实现原子类，并提供了一个模块医生大约100行。在这里，我们将创建一个test_atomic.py模块，并使用Unitest替换医生以删除医生。
在编写测试模块之前，我们需要考虑需要哪些测试。我们需要测试3种不同的数据类型：列表，集合和词典。对于列表，插入项的值，删除或修改项需要测试。失败时，实际效果不会改变。
在结构上，测试不同的数据类型基本相同。因此，我们只会为测试列表编写测试用例，并将其他人作为练习。Test_atomic.py模块必须导入到Untist Module和要测试的原子模块中。
创建一个Unittest文件时，我们通常创建模块而不是程序。在每个模块中，我们定义一个或多个UNITEST.TESTCASE子类。例如，在test_atomic.py.py模块中只有一个单独的UnitSest-testcase子类，它是testatomic（将是testatomic（将是遗嘱）稍后解释），并如下结束两行：
如果名称==“ __ -main __”：
UNITEST.MAIN（）
这两个行允许模块单独运行。当然，该模块也可以从其他测试程序中导入并运行 - 如果这只是多个测试套件之一，这是有意义的。
如果要从其他测试程序运行test_atomic.py模块，则可以编写类似的程序。我们习惯了
导入UNITSEST
导入test_atomic
suite = unittest.testloader（）。loadTestsfromtestcase（test_atomic.testatomic）
runner = unittest.texttestrunner（）
PNNT（Runner.Run（Suite））
在这里，我们创建了一个单独的套件，该套件是通过读取test_atomic模块来实现的，通过读取Unittest模块读取并使用每个测试*（）方法（在这种情况下为test_list_success（），test_list_fail（），稍后。作为测试案例。
现在，我们将检查睾丸类课程的实现。对于普通子类（不包括UnitTest.testcase子类），不需要实施初始化过程。在这种情况下，我们需要构建一种方法，但是我们不需要清理，我们将实施两个测试用例。
def设置（self）：
self.original_list = list（范围（10））
我们已经使用unittest.testcase.setup（）方法来创建单独的测试数据片段。
def test_list_succeed（SELD）：
itms = self.original_list [：]
与原子（项目）作为原子：
Atomic.Append（1999）
atomic.insert（2，-915）
Del Atomic [5]
原子[4] = -782
atomic.insert（0，-9）
self.sersertequal（项目，
[-9，0，1，-915，2，-782，5，6，7，8，9，9，9，1999））））））
DEF TEST_LIST_FAIL（SELD）：
itms = self.original_list [：]
使用self.sassertraises（属性）：
与原子（项目）作为原子：
Atomic.Append（1999）
atomic.insert（2，-915）
Del Atomic [5]
原子[4] = -782
atomic.poop（）＃typo
self.sertlistequal（项目，self.original_list）
在这里，我们直接在测试方法中编写测试代码，而无需内部函数，而不再使用Unittest.testcase.assertraise（）作为上下文管理器（预期代码生成attributeError）。在最后，我们还使用了UnitSest。python 3.1的testCase.AssertListequal（）方法。
正如我们已经看到的，Python测试模块易于使用且极其有用，尤其是在我们的TDD中。它们还具有许多功能和功能，这些功能和功能比这里更显示了 - 例如，可以跳过测试的能力，这有助于理解平台之间的区别 - 并且它们具有良好的文档支持。缺乏功能 - 但鼻子和py.test提供-TEST -EST -TEST，尽管此功能有望在随后的Python版本中出现（也许也许会出现与Python 3.2 - ）。
绩效分析（分析）
如果程序运行缓慢或消耗比预期的要多得多，则问题通常是所选算法或数据结构不合适的，或者以低效的方式实现。不肯定问题的原因，最好的方法是准确地找到问题发生的问题，而不仅仅是检查代码并尝试优化它。随机优化将导致错误的引入，或加快程序中该程序的整体性能的加快，这不是口译员大部分时间消耗的地方。
在深入讨论之前，要注意一些易于学习和使用并且对改善程序性能不利的Python计划设计习惯是有意义的。这些技术在Python版本中不是特定的，而是一种合理的Python Program设计风格最初，当您只需要阅读序列时，最好使用元组而不是列表。其次，发电机，而不是创建一个大元组和列表并在其上迭代；第三，尝试使用python build -in buald -in -inden -in -in -in -inbledicts，列表，元组，而没有意识到自己的自定义结构，因为构建的数据结构已高度优化；第四，当从一个小字符串生成一个大字符串时，请勿连接到ConnectInstead的小字符串，它会积聚在列表中，最后将字符串列表组合到单独的字符串中；第五和最后一点函数）或从数据结构中访问，然后更好的方法是创建和使用本地变量访问对象以提供更快的访问速度。
Python Standard库提供了两个特别有用的模块，可以帮助调查代码的性能问题。一个是TimeIt模块 - 该模块可用于定时一个小python代码，可用于比较两个或更多的性能特定功能或方法。另一个是CPROFILE模块，可用于配置文件程序的性能 - 该模块已分解了呼叫计数和次数，以找到性能瓶颈。
要了解TimeIt模块，我们将查看一些小实例。请说，有3个函数function_a（），function_b（），function_c（），3个函数执行相同的计算，但分别使用不同的算法。如果将这些函数放置在中相同的模块（或导入），您可以使用TimeIt模块运行和比较。以下是该模块使用的最后一个代码：
如果__name__ ==“ __ -main __”：
重复= 1000
对于（“ function_a”，“ function_b”，“ function_c”）中的函数：
t = timeit.timer（“ {0}（x，y）”。格式（function），从__ -main __ import {0}，x，y” .format（function））
sec = t.t.timeit（重复） /重复
print（“ {function}（）{sec：.6f} sec” .format（** locals（）））
给出timeit.timer（）构造函数的第一个参数是我们要执行和定时的代码，其形式为字符串。第二个参数是可选的，或要执行的字符串。这次是在计划提供一些建立工作之前的代码之前。在这里，我们介绍了要从__ -main __（即此）模块进行测试的功能，并且有两个变量（x和y）作为输入数据传输。这两个变量作为该模块中的全局变量提供。我们还可以导入数据，例如从其他模块导入数据。
调用TimeIt（）timeit.timer对象的timeIt（）方法时，首先执行构造函数的第二个参数（如果有），然后执行构造函数的第一个参数和执行的执行时间。timeit.timer的返回值.TimeIt（）方法是第二个计数的时间，类型为float。默认情况下，TimeIt（）方法重复100万次并返回所有执行的总数，但是在这种特定情况下，仅1000次可以给出有用的结果，因此可以给出重复计数时间的数量。阐述规范。执行每个功能后，使用重复的总数来删除总数，并获得平均执行时间，函数名称和执行时间在控制台中打印。
function_a（）0.001618秒
function_b（）0.012786秒
function_c（）0.003248秒
在此示例中，function_a（）显然是最快的 - 至少对于此处使用的输入数据。在某些情况下，一个一个一个，例如输入数据，将对性能产生巨大影响 - 可能需要使用多个集合输入数据测试每个功能以涵盖代表性测试用例，以及总执行时间或平均执行时间计算。
有时监视您的定时代码不是很方便，因此TimeIt模块提供了一种在命令行中执行定时时间的方法。例如，在myModule.py模块中使用function function_a（）的时间，您可以输入控制台中的以下命令：python3 -m timeIt -n 1000 -s“来自myModule image_a，x，y” function_a（x，x，x，y，y，y，y”（像通常的the Windows环境一样，我们必须使用诸如c的内容，例如c：python3lpython.exe替换python3）。-m选项用于python解释器，以便它们可以加载指定的模块（以下是TimeIt），而其他选项则由TimeIt Module.-n选项处理。-n选项指定周期计数的数量，-s选项指定要建立，最后一个参数是要执行和计时的代码。命令完成后，结果将被打印到控制台，例如：
1000循环，最佳3：1.41毫秒 /循环
之后，我们可以轻松地采用其他两个函数来整体上比较它。
CPROFILE模块（或统称称为CPROFILE模块的配置文件模块）也可以用于比较函数和方法的性能。与提供原始正时的TimeIt模块不同，CPROFILE模块准确地显示了什么被调用以及每个呼叫花费多少时间。以下是像以前一样比较三个函数的代码：
如果__name__ ==“ __ -main __”：
对于（“ function_a”，“ function_b”，“ function_c”）中的函数：
cprofile.run（“对于1000范围内的i）：{0}（x，y）”。格式（函数））
我们必须将重复时间的数量放在代码中以传递到cprofile.run（）函数的代码，但是无需创建任何创建，因为模块功能将使用内省来查找功能和变量需要使用。这里没有明确的print（）语句，因为默认情况下，cprofile.run（）函数将在控制台中打印其输出。以下是所有功能的相关结果（省略了某些无关线，并且该格式也已稍作调整以适应页面）：
1003函数电话为1.6661 CPU秒
ncalls tottime percall cumtime percall文件名：lineno（函数）
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 {内置方法exec}
5132003功能在22.700 CPU秒内调用
ncalls tottime percall cumtime percall文件名：lineno（函数）
1 0.487 0.487 22.700 22.700：1（）
1000 0.011 0.000 22.213 0.022 myModule.py.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 {内置方法bisectjeft}
1 0.000 0.000 22.700 22.700 {内置方法exec}
1000 0.001 0.000 0.001 0.000 {内置方法len}
1000 15.149 0.015 22.196 0.022 {内置方法排序}
5129003功能在12.987 CPU秒内调用
ncalls tottime percall cumtime percall文件名：lineno（函数）
1 0.205 0.205 12.987 12.987：l（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 {内置方法exec}
NCALLS（“呼叫数”）列出了指定函数的调用数量（在文件名中列出：Lineno（函数））。回想一下我们重复1,000个呼叫，因此我们必须记住此数字。Tottime.tottime（“总时间”）列出函数中的总时间消耗，但不包括函数调用调用的其他函数所花费的时间。第一个percall列出了函数每个调用的平均时间（tottime // ncalls / ncalls）.cumtime（“累积时间”）列出在功能上花费的时间并包含在称为其他函数的函数中花费的时间。第二个percall列出了函数每个调用的平均时间，包括函数功能的时间消耗。
此输出信息比TimeIt模块的原始计时信息更具启发性。我们可以立即发现function_b（）和function_c（）使用已称为超过5,000次的发电机，因此它们的速度至少为10次比那慢。添加，function_b（）调用更常见的函数，包括调用构建的-in satted（）函数，这使其几乎是function_c（）。当然，timeit（）模块提供足够的信息要查看这些定时差异，但是CPROFILE模块允许我们理解为什么存在这些差异。正如TimeIt模块允许代码在不监视的情况下对代码定时，Cprofile模块可以执行此操作。但是，当使用CPROFILE时来自命令行的模块，我们无法准确指定要执行的内容 - 但是只需执行给定的程序或模块并报告所有这些时序结果。需要使用的命令行是Python3 -M Cprofile Progamormodule.py。生成的输出信息与先前看到的相同。输出信息样本如下。
10272458功能电话（10272457原始呼叫）37.718 CPU SECS
ncalls tottime percall cumtime percall文件名：lineno（函数）
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（）”）要替换function_b（）的调用。或可以保存完整的配置文件数据并使用PSTATS模块进行分析。要保存配置文件，您必须修改命令行：python3 -m cprofile -o profiledatafileprogramodule.py.py.您可以分析配置文件数据，例如启动空闲，导入PSTATS模块并将其授予保留的配置文件，或者可以在控制台中使用PSTAT。
以下是一个非常简短的控制台会话示例。为了使其适合页面显示，我们已经进行了适当的调整。我们自己的输入显示在一个粗糙的身体中：
$ python3 -m cprofile -o profile.dat mymodule.py
$ python3 -m pstats
欢迎使用个人资料统计浏览器。
％读取profile.dat
profile.dat％呼叫者函数_B
随机上市顺序是用户
由于限制，列表从44减少到1
功能由...调用
ncalls tottime cumtime
：27（function_b）-1000 0.011 22.251：12（）
profile.dat％callees函数_B
随机上市顺序是用户
由于限制，列表从44减少到1
称为...的功能
ncalls tottime cumtime
：27（函数_b） -
1000 0.005 0.005内置方法双向设备
1000 0.001 0.001内置方法Len
1000 1 5.297 22.234内置方法排序
profile.dat％退出
输入帮助以获取命令列表，并按照命令名称获取有关命令的更多信息。轮廓数据，例如Runsnakerun（），它需要依赖于WXPYTHON GUI库。
使用TimeIT和CPROFILE模块，我们可以确定自己的代码中哪些领域的成本超出预期；使用CPROFILE模块，我们可以准确地计算出时间消耗的时间。
上述内容取自视频课程05后端编程Python-19调试，测试和性能调整（下）。有关更多实用的示例，请参阅视频说明。跟随张成员谈论编程，学习更容易学习。您可以在不花钱的情况下学习真正的技能。
Python提供的基本数据类型：值（整数，浮点类型，复数，布尔值等），字符串，列表，元组，字典，集合等，简单地分类：
通常称为整数，值为正值或负数，没有小数点。
Python 3的整数可以用作长类型，因此Python 3不使用
Python 2长类型。
当Python初始化时，将自动建立一个小整数对象池，以促进我们在后期打电话并避免重复生成！这是一个指针阵列，其中包含262点，范围为-5至256。
Python的浮点是数学的小数，类似于C语言的双倍。
浮点也是十进制的小数，例如1.23、3.14，-9.01等。，或12.3e8，0.000012可以写为1.2e-5，依此类推。
复数数是由实际数字和虚拟编号部分组成的。它可以用a + bj或复杂（a，b）表示。真实部分A和复数数的虚拟B是浮点。
对与错，0和1。在传统意义上，积极和反向是布尔人的类型。
但是在Python语言中，布尔类型只有两个值，真实和错误。请注意，这是英语单词的对与错，必须将第一个字母大写。
在python，0，0.0，-0.0，无，空字符串“”，空元组（），空列表[]，空词典{}都被视为false，并且有自定义类型。（）或len（）或len（）方法和方法返回0或false，然后示例也被视为false，其他对象为true
BUR值也可以通过和或，也可以计算。
1）操作是操作，只有所有操作是真实的，并且操作的结果是真实的；
2）或计算是或操作，只要其中一个是正确的，或计算结果为真。
3）不是操作是非操作。这是一个单眼操作员，将真实变成false和false成真。
例如：
从上述情况下，可以看出，在执行四个操作时，True显然被视为1，错误被视为0。
4）空气价值
空价值不是布尔类型，而是与布尔人有密切的关系。
空值是python中的特殊值，它由无代表（第一字母）。不能理解为0，因为0是整数类型，没有一个特殊的值。没有一个布尔人类型，而是noneype。
在某些特定情况下，数字类型需要转换。
Python提供了一个构建的数据类型转换功能：
int（x）将x转换为整数。如果x是浮点数，则十进制零件是截获的。
Float（X）将X转换为浮点数。
复杂（x）将x转换为复数，实际编号部分为x，虚拟编号部分为0。
复杂（x，y）：将x和y转换为复数，实际部分是x，虚拟编号部分为y。
可以将Python字符串包含在单个引号或双引号号码中，甚至可以使用三个引号。字符串是任何文本“”或“”“”而不是任何文本。
例如：'abc'，“ xyz”等等。请注意，请注意''或“”本身只是一种表示的方式，而不是字符串的一部分。因此，字符串'abc'只是a，b，并且C.if'本身也是一个角色，然后您可以使用““我还好”。“我好的”中包含的字符是6个字符6个字符。
该字符串包括特殊字符，可以通过过境字符识别
但是，如果字符串中有很多字符需要义，则需要添加很多字符。为了简化，Python还允许“ R''”内部字符串的字符串
例如：
打印r'\ \'#output：\ \ \
字符串的一些常见操作
切割作是指操作操作的操作
语法：序列[起始位置：结束实验室：购买]
A。请勿包括与竞标相对应的数据，而正整数也可以是正整数。
b。这些步骤是选择间隔，并且可以使用正整数和负整数。默认步骤为1。
查找（）：检测该字符串中是否包含串串。如果该字符串的开始的位置启动，则将返回-1。
index（）：检测该字符串中是否包含串串。如果您在此字符串开始时返回起始位置的位置，则将报告异常。
rfind（）：与find（）功能相同，但是搜索启动在右侧。
rindex（）：与index（）相同的功能，但是搜索在右侧启动。
count（）：返回字符串中出现在字符串中的次数。
替换（）：替换
split（）：根据指定的字符对字符串进行分配。
join（）：符符或?串合的字符串，也就是说，将多个字符串组合到新字符串中。
Capitalize（）：将字符串中的字符转换为编写。
title（）：将每个单词??单词转换为写作。
lower（）：写入以在字符串中写入。
upper（）：写下字符串以在字符串中写入。
LSTRIP（）：删除字符串左侧的空字符。
RSTRIP（）：删除右侧的字符串的空字符串。
strip（）：删除字符串两侧的空字符。
ljust（）：返回?ly????，并填充指定的字符（默认空间）以填充新的??的新字符串。
rjust（）：返回原始字符的原始字符串的正确对手，并填充新字符串，语法和语法和语法，以及
ljust（）是相同的。
中心（）：返回?c?????????????????
法律与ljust（）相同。
SO被称为判断是判断对与错，而返回结果是布尔数据类型：true或false。
startswith（）：检查字符串是否以指定的?字符串开头，然后返回true，否则返回false.if SET
开始和结束投标将在指定范围内检查。
endswith（）：检查字符串是否在指定的字符串上结束，然后返回true，否则返回false。
开始和结束投标将在指定范围内检查。
isalpha（）：如果字符串中的字符很少，并且所有字符都是字符，则它们返回true，否则它们返回false。
isDigit（）：如果字符串仅包含数字，则返回true，否则返回false。
isalnum（）：如果字符串中的字符很少，并且所有字符都是字体或数字，则它们返回到true，否则返回
错误的。
这是python3引入多少m和python3的终结。我想知道您是否从中找到了所需的信息？如果您想进一步了解此信息，请记住要收集对该网站的关注。