python菜鸟教程3,如何使用python中的turtle画一个红苹果🍎？
python菜鸟教程3,如何使用python中的turtle画一个红苹果🍎？详细介绍
本文目录一览： 如何使用python中的turtle画一个红苹果？
Turtle库是Python语言中一个很流行的绘制图像的函数库,想象一个小乌龟,在一个横轴为x、纵轴为y的坐标系原点...
全部代码如下列出, 使用的是python3。
可以作为参考，这个代码比较简单，是用圆形来近似地画一个苹果。
可以复制代码，我把缩进也打进去了，因此我加上了网页链接，目的地是菜鸟教程（不过与本题无关，[doge]）
from turtle import *
def leaf(radius,an=90,co="green",co1="green"):
width(3)
color(co,co1);
pass
begin_fill()
circle(radius/2., an)
end_fill()
def stem(radius):
color("")
right(90)
fd(radius)
color("brown")
right(0)
width(9)
circle(radius*5,-19)
color("")
pass
def pulp(radius):
pass#果肉
begin_fill()
circle(radius);
end_fill()
color("white")
left(90)
fd(0.24/0.84*radius)
left(90)
begin_fill()
circle(1.32/0.84*radius);
end_fill()
color("");
home()
fd(radius*5/4/9);
right(90)
fd(radius*2);
right(180);
color("white")
fd(0.16/0.84*radius)
right(-90)
begin_fill()
circle(0.48/0.84*radius);
end_fill()
color("");
fd(0.13/0.37*radius)#0.13
right(90)
bk(0.06/0.43*radius)
left(90);
color("")
def main():
speed="fast";
aplfr=160;
reset()
width(3)
#yin(200, "black", "white")
#yin(200, "white", "black")
ht();
home();
color("")
fd(aplfr/9.);
rt(90);
#fd(aplfr/9)
color("red")
right(90)
strt=pos()
pulp(aplfr*2/2.5)#0.84
home()
setpos(strt)
stem(40)
home()
left(180-80);#init as 0
st();
pass
leaf(aplfr)
left(90);
leaf(aplfr)
pass
return "Done!"
if __name__ == '__main__':
main()
mainloop()
后端编程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
OK
每次执行一个测试用例时，都会输出一个句点（因此上面的输出最前面有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 (www.vrplumber.com/prograinming/runsnakerun), 该工具需要依赖于wxPython GUI库。
使用timeit与cProfile模块，我们可以识别出我们自己代码中哪些区域会耗费超过预期的时间；使用cProfile模块，还可以准确算岀时间消耗在哪里。
以上内容部分摘自视频课程 05后端编程Python-19调试、测试和性能调优(下) ，更多实操示例请参照视频讲解。跟着张员外讲编程，学习更轻松，不花钱还能学习真本领。
close()是python内置函数吗菜鸟教程
是。用于刷新和关闭IO对象（文件）。关闭后的文件不能再进行读写操作， 否则会触发ValueError错误。close（）方法是Python中的内置方法，所以close（）是python内置函数菜鸟教程。Python是一种跨平台的计算机程序设计语言，是ABC语言的替代品，属于面向对象的动态类型语言。
python exec() 菜鸟教程上的例子，最后一个结果为34的看不懂，求教
exec(expr, {'x':1,'y':2}) 这句很明显：30+1+2=33
exec(expr, {'x':1,'y':2}, {'y':3,'z':4})这句：
x传入的是1，y第一个传入的是2，第二次传的是3将之前的2覆盖了。所以y是3，z传入的是4。但是在expr里面重新给z赋值了30，所以结果是30+1+3=34
math.exp(-x)应该用np.exp(-x)；
The Zen of Python是Python语言的指导原则，遵循这些基本原则，Python代码有下列四大特征就成为一个准高手了：
1. 丰富的注释，包含参数说明，函数/类用途，甚至大段原理阐述与例子。
2. 充分用好装饰器/Python内嵌函数等高级功能。
3. 完善的异常处理，比如RuntimeError, ValueError。
4. 严格的PEP8规范代码。
0基础学习python怎么入门呢？
零基础学Python的入门学习路径。
第一阶段 - Python 数据科学
Python 基础语法
入门及环境安装 、基本语法与数据类型、控制语句、错误及异常、错误处理方法、异常处理方法 、常用内置函数 、函数创建与使用、Python 高级特性、高级函数、Python 模块、PythonIO 操作 、日期与时间 、类与面向对象 、Python 连接数据库
Python 数据清洗
数字化 Python 模块Numpy、数据分析利器Pandas、Pandas 基本操作、Pandas 高级操作
Python 数据可视化
数据可视化基础、MLlib（RDD-Base API）机器学习、MatPlotlib 绘图进阶、高级绘图工具
第二阶段 - 商业数据可视化
Excel 业务分析
Excel 基础技能、Excel 公式函数、图表可视化、人力 & 财务分析案例、商业数据分析方法、商业数据分析报告
Mysql 数据库
Mysql 基础操作（一）、Mysql 基础操作（二）、Mysql 中级操作、Mysql 高级操作、电商数据处理案例
PowerBI
初级商业智能应用 （PowerQuery）、初级商业智能应用 （PowerPivot）、初级商业智能应用案例、存储过程、PowerBI Desktop 案例、PowerBI Query 案例
统计学基础
微积分、线性代数基础、统计基础
Tableau
Tableau 基本操作、Tableau 绘图、Tableau 数据分析、Tableau 流量分析
SPSS
客户画像、客户价值模型、神经网络、决策树、时间序列
第三阶段 - Python 机器学习
Python 统计分析
数据准备、一元线性回归、多元线性回归、一般 logistic 回归、ogistic 回归与修正
Python 机器学习基础
机器学习入门、KNN 讲义、模型评估方法、模型优化方法、Kmeans、DBSCAN、决策树算法实战
Python 机器学习中级
线性回归、模型优化方法、逻辑回归、朴素贝叶斯、关联规则、协同过滤、推荐系统案例
Python 机器学习高级
集成算法 - 随机森林、集成算法 -AdaBoost、数据处理和特征工程、SVM、神经网络、XGBoost
第四阶段 - 项目实战
电商市场数据挖掘项目实战
项目背景 & 业务逻辑 、指定分析策略 、方法实现与结果 、营销活动设计及结果评价 、撰写数据分析报告
金融风险信用评估项目实战
项目背景 & 业务逻辑 、建模准备 、数据清洗 、模型训练 、模型评估 、模型部署与更新
第五阶段 - 数据采集
爬虫类库解析 、数据解析 、动态网页提取 、验证码、IP 池 、多线程爬虫 、反爬应对措施 、scrapy 框架
第六阶段 - 企业课
团队户外拓展训练 、企业合作项目课程 、管理课程 、沟通表达训练 、职业素养课程
以上就是零基础Python学习路线的所有内容，千锋Python的课程你可以去试试
该如何学习Python呢？
（1）选择学习方向。学习Python主要目的是用语言来解决问题，而不是了解这门语言。Python应用方向有很多，Python基础知识学习完后，应用方向不同需求也不同；虽然Python需要系统化的学习，但是在学习Python的时候，想要告诉大家还是需要提前确定一下自己感兴趣的方向，有针对性的学习更为重要。
（2）规划学习路线。当确定好自己的发展方向之后，下一步就是顺着方向去学习，建立好自己的学习路线。要有系统化的学习路线，需要完成什么样的目标，需要学习哪些知识，需要懂哪些知识，这样每次学习一个部分，就可以有实际的结果输出，结果的输出才可以鼓励进行下一步的学习。
（3）合理规划时间。划好自己的学习时间，每天进度是什么，每天学习几个小时都是需要提前确定的，有计划有规划的去学习，坚持下来才会有意外的收获。
用任何编程语言来开发程序，都是为了让计算机工作。目前有很多种流行的编程语言，如难学的C语言，普遍的Java语言，适合初学者的Basic语言，适合网页编程的JavaScript语言等，Python适合初学者的一种计算机程序设计语言。
主要学习语法就可以。网上有很多公共免费课程，可以先尝试自学下。语法很简单的。了解到如何和定义变量，如果使用就可以了。
有视频教程也有文字课程。然后就是多实践多练习，多写代码就可以了
主要看自己的时间是否允许，可以通过报名培训班进行学习，一般是1-3个月，但学习费用比较高。如果因为工作原因时间不允许也可以选择线上学习，购买一些网上教学视频课程，或者书籍资料都可以学的，主要还是要有耐心，坚持。
建议根据个人学习习惯来定，视频接受效率快，可以B站搜索一些基础视频，或购买某些教程；
文章接受效率快的，可以去python或python3菜鸟教程学习！
链接：http://pan.baidu.com/s/1VFYbfZcE5a808W7ph9-qDQ
提取码：238d
零基础学python课程。Python是目前最流行的动态脚本语言之一。本课程由浅入深，全面、系统地介绍了使用Python进行开发的各种知识和技巧。 包括Python环境的安装和配置、Python的基本语法、模块和函数、内置数据结构、字符串和文件的处理、正则表达式的使用、异常的捕获和处理、面向对象的语言特性和设计、Python的数据库编程、Tkinter GUI库的使用、HTML应用、XML应用、Django网页开发框架的使用、测试驱动开发模式应用、Python中的进程和线程、Python系统管理、网络编程、Python图像处理、Python语言的扩展和嵌入以及Windows下Python开发等。
课程目录：
python语言的特点
python的发展历史与版本
python的安装
python程序的书写规则
基础数据类型
变量的定义和常用操作
序列的概念
字符串的定义和使用
......
如何自学Python？
分享Python学习路线。
第一阶段Python基础与Linux数据库。这是Python的入门阶段，也是帮助零基础学员打好基础的重要阶段。你需要掌握Python基本语法规则及变量、逻辑控制、内置数据结构、文件操作、高级函数、模块、常用标准库模块、函数、异常处理、MySQL使用、协程等知识点。
学习目标：掌握Python基础语法，具备基础的编程能力；掌握Linux基本操作命令，掌握MySQL进阶内容，完成银行自动提款机系统实战、英汉词典、歌词解析器等项目。
第二阶段WEB全栈。这一部分主要学习Web前端相关技术，你需要掌握HTML、CSS、JavaScript、jQuery、BootStrap、Web开发基础、VUE、Flask Views、Flask模板、 数据库操作、Flask配置等知识。
学习目标：掌握WEB前端技术内容，掌握WEB后端框架，熟练使用Flask、Tornado、Django，可以完成数据监控后台的项目。
第三阶段数据分析+人工智能。这部分主要是学习爬虫相关的知识点，你需要掌握数据抓取、数据提取、数据存储、爬虫并发、动态网页抓取、scrapy框架、分布式爬虫、爬虫攻防、数据结构、算法等知识。
学习目标：可以掌握爬虫、数据采集，数据机构与算法进阶和人工智能技术。可以完成爬虫攻防、图片马赛克、电影推荐系统、地震预测、人工智能项目等阶段项目。
第四阶段高级进阶。这是Python高级知识点，你需要学习项目开发流程、部署、高并发、性能调优、Go语言基础、区块链入门等内容。
学习目标：可以掌握自动化运维与区块链开发技术，可以完成自动化运维项目、区块链等项目。
按照上面的Python学习路线图学习完后，你基本上就可以成为一名合格的Python开发工程师。当然，想要快速成为企业竞聘的精英人才，你需要有好的老师指导，还要有较多的项目积累实战经验。
自学本身难度较高，一步一步学下来肯定全面且扎实，如果自己有针对性的想学哪一部分，可以直接跳过暂时不需要的针对性的学习自己需要的模块，可以多看一些不同的视频学习。
1、编程就需要用到编程语言，Python就是时下最流行的编程语言之一。Python是一门非常通用的高级语言，它可以在苹果电脑的Mac系统上运行，可以在Windows上运行，也可以在树莓派的Linux系统上运行。
2、与其他语言相比，Python更加简洁，它能用比其他语言少得多的代码行数实现相同的功能，Python代码的可读性也更强，便于初学者学习，能够让你更快地具备开发能力。
3、同时Python的应用也十分广泛，它具有十分丰富的第三方库，能够用于网站开发、大数据分析、人工智能开发、自动驾驶等几乎所有领域。
随身编程课，每天5分钟，轻松学Python。微信公众号「Python学习随身课堂」开启编程学习之旅。
零基础自学Python，其实说难也不难，说不难也难，难的是需要足够坚持，足够聪明，如果你有很强的意志力和学习力，也是可以自学Python的，首先你需要先给自己制定一个具体的学习路线，根据学习路线制定具体的学习方案，将Python知识一步步分解开来学习，这样既不会学的混乱，也能做到心中有数，当然最主要的是这个学习路线要循序渐进的来，切不可急功近利，因为基础打牢，能力才能一步步的提升。其次就是根据学习路线找一些相关的网课来学习，或者是看直播课，一般的视频网课都是成套的，学起来也是循序渐进的，可以跟着一起学习，平时学习的时候也可以多留意Python相关的学习网站，一般的学习网站上都会有比较多的学习资料，小伙伴们可以跟着学习资料多多练习，总之，自学不易，贵在坚持，选择自学的小伙伴们要做好心理准备。
零基础的小伙伴自学起来其实还是很有难度的，在学习过程中，可能会遇到各种各样的问题，最主要的是遇到疑难问题无人解答，只能靠自己摸索解决，这个时候也不要着急，可以在Python相关的群里问一下也在学Python的人。
python语法优美，容易入门，是一个不错的工具！
主要课程内容有：
①Python软件开发基础
②Python软件开发进阶
③Python全栈式WEB开发
④Python多领域开发
想要系统学习，你可以考察对比一下开设有相关专业的热门学校，好的学校拥有根据当下企业需求自主研发课程的能力，能够在校期间取得大专或本科学历，中博软件学院、南京课工场、南京北大青鸟等开设相关专业的学校都是不错的，建议实地考察对比一下。
祝你学有所成，望采纳。
如何学习 Python 的问题其实在知乎上已经有很多答案了，我就在这里讲讲我的故事吧，这是我18年刚入职的时候写的。
先简单自我介绍下，文科生，英语专业，今年大学本科刚毕业。最开始接触编程是在大四前的那个暑假，由于自己性格偏内向，不太喜欢过多的人际交往，想着往技术方向发展，加上网络上充斥着程序员薪资高的言论，于是下决心学习编程。
学编程必然要从一门语言入手，当时上知乎查了一下，发现对于0基础的人，两个编程语言推荐的比较多，一个是 Java，一个是 Python，又看到有大神说 Python 易学，但 Java 工作机会更多，于是选择了 Java（跑题了？）。
学习方式是跟着视频来学，现在还记得那个Java教学的老师是马士兵，配置好环境后，学了浮点数整数等基本概念，还记得一开始代码总是要写什么 public static void，然后就没有然后了，Java就一直呆在硬盘里，一个学期过去了。
在习惯性虚度光阴中，总有几天是踌躇满志的，于是在大四的寒假，我又找回了学编程的冲动。又去知乎逛了一圈，可能由于 Python 发展势头迅猛，推荐学 Python 的越来越多，而且我想着科班生在学校就已经学 Java了（不知真假），我大四再开始学的话，劣势太大，于是我又下定决心学习 Python！
人生苦短，我用 Python！先自己洗脑一波！
说到 Python，廖雪峰的教程广受好评，于是我打开了廖雪峰的Python3教程，Python 果然比 Java 语法简单多了，一口气我就学到了 for 循环，然后卡在了continue上，接着我在网上查了很多关于 continue 的讲解，最后终于，没有 continue（继续）下去了……又荒废了几周后，我在某晚的颓废过后重振雄风，重新开始了了 Python 的学习，这次我直接下了本《简明Python教程》（A Bit of Python），跟着PDF来，为了防止自己迎难而退，我囫囵吞枣地过了一遍，看懂了的就自己敲一遍代码，没理解的就照抄一遍代码，成功地完成了第一次比较完整的入门学习。
其实现在网络资源很多，跟网课学是更有效率的选择，不然很容易跟我一样从入门到放弃，毕竟对着书自学，有问题的地方得不到解答，跟着网课学就不一样了，有社群老师会跟踪解答问题，还有社群小伙伴一起营造学习氛围
后来我迫于就业压力，战略性地调整了学习方向，开始学习 Excel 和 SQL，往数据分析方面找工作。
由于非科班出身，并且没有数据分析的经验和作品，最后就业的岗位是初级数据分析师，其实就是个“表哥”，SQL 导一导数据，然后 Excel 弄一弄透视表，求求平均数什么的，没啥技术含量。幸好工作比较清闲，刚入职也没什么事干。 得知整个数据组缺乏爬虫技能之后，我决定把爬虫学一学。Python 爬虫早就耳闻，但是一直没有学习的动机，这下好了，反正闲着也闲着，不如学学爬虫，万一学会了，不就能有一技之长在公司立足了？
第二天，我就马上开始了着手去做了，Python 基础语法虽然不太熟悉了，但是哪里不懂就直接百度，又把爬虫相关的 Python 语法熟悉了一遍，列表、字典、遍历、函数这些，当天下午就写出了第一个爬虫！整个过程都是疯狂汲取知识，出结果的那一刹那，真是喜不自禁，这种正面反馈更激励了我写代码！每天快下班的时候，同事都在百无聊赖地倒计时，而我越到下班越发奋，因为在工作中有收获了，我在家就可以心安理得地荒废光阴了，这种每天都有进展的感觉太棒了！
现在的我，想往更高层次的数据分析方向发展，目前学习了numpy，pandas 和 matplotlib 这三个经典的 Python 数据分析的库，Power Bi 也开始接触了，但统计学和算法方面迟迟没有系统地学习。
一些建议
我现在也勉勉强强算是入门了吧，本着分享的精神，想给准备学习 Python 或者正在入门 Python 的朋友们一些建议供参考：
1.脚踏实地写代码
新手阶段，大家肯定会有很多困惑，喜欢在论坛、qq、微信群上问类似的问题：“0基础能不能学 Python”，“现在学Python晚不晚？”，“什么编辑器好”，“要不要在 Linux 上学习 Python“，”Python3 还是 Python2？“……对于以上问题，我的简单答复是，能学，不晚，sublime text 3或者 pycharm，windows上入门没有问题，Python3。其实，很多时候我们问问题并不是真的疑惑，只是在拖延，不想去行动，“种一棵树最好的时间是十年前，然后是现在”，我们要花精力解决的是实际码代码中出现的问题，而不是自己空想出来的问题。而且这些问题并没有绝对的正误之分，弄懂一个另一个也就触类旁通了。我给的答案都是主流的选择，相应地网上会有更多的资料。
2.多种途径查问题
别指望一本书能解决所有问题，有时候一个问题想不通看不懂的时候，换一种方式查，比如廖雪峰教程上看的一个语法不懂，就去菜鸟教程看一看，再不懂就在网上搜搜，多看看别人是怎么理解的，不同人有不同的看法，不一定哪一个就刚好能说通你。网上资源很多，但是你会发现过时的、错误的信息也同样多，代码的东西多尝试不怕的，不要怕犯错，因为在错误中更能发现自己理解上的偏差。伸手党一般不会有人搭理的，所以学会在网络中找现成的答案是自学的重要步骤。
3.实战实战实战！
基础语法过一遍就好了，不必深究，在项目中会不断地涉及到基础知识，忘了再查很快就能熟悉的。在基础上花太多时间往往会导致进度过慢，成就感不足，难以坚持。直接从实战中边练边学，想往数据分析方面发展，就大胆地学习 numpy、pandas、matplotlib，想搞爬虫就赶紧看看 requests，pyquery，正则表达式，想搞 web 不妨试试 flask，Python有很多优秀的库，大神们早就给我们提供了处理问题的捷径，站在前人的肩膀上，我们入门的难度更低了，有了基本的语法知识，就赶紧去实战中巩固吧！
不要囤书！不要囤资料！一定要有目的的去学，有目标才有方向，尤其对初学者而言。
谢谢你能看到这里。
以下是python全栈开发课程学习路线，可以按照这个课程大纲有规划的进行学习：阶段一：Python开发基础Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。
阶段二：Python高级编程和数据库开发Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。
阶段三：前端开发Python全栈开发与人工智能之前端开发知识学习内容包括：Html、CSS、JavaScript开发、Jquery&bootstrap开发、前端框架VUE开发等。
阶段四：WEB框架开发Python全栈开发与人工智能之WEB框架开发学习内容包括：Django框架基础、Django框架进阶、BBS+Blog实战项目开发、缓存和队列中间件、Flask框架学习、Tornado框架学习、Restful API等。
阶段五：爬虫开发Python全栈开发与人工智能之爬虫开发学习内容包括：爬虫开发实战。
阶段六：全栈项目实战Python全栈开发与人工智能之全栈项目实战学习内容包括：企业应用工具学习、CRM客户关系管理系统开发、路飞学城在线教育平台开发等。
阶段七：数据分析Python全栈开发与人工智能之数据分析学习内容包括：金融量化分析。
阶段八：人工智能Python全栈开发与人工智能之人工智能学习内容包括：机器学习、数据分析 、图像识别、自然语言翻译等。
阶段九：自动化运维&开发Python全栈开发与人工智能之自动化运维&开发学习内容包括：CMDB资产管理系统开发、IT审计+主机管理系统开发、分布式主机监控系统开发等。
阶段十：高并发语言GO开发Python全栈开发与人工智能之高并发语言GO开发学习内容包括：GO语言基础、数据类型与文件IO操作、函数和面向对象、并发编程等。
对于Python开发有兴趣的小伙伴们，不妨先从看看Python开发教程开始入门！B站上有很多的Python教学视频，从基础到高级的都有，还挺不错的，知识点讲的很细致，还有完整版的学习路线图。也可以自己去看看，下载学习试试。
python执行以下代码报：ConnectionRefusedError： [WinError 10061] 由于目标计算机积极拒绝，无法连接。
是不是这样，这样没有问题，但是如果你在同一个IDEL里开服务和客户端就会出那个问题，因为开一个就要把另一个停了
python执行八错：ConnectionRefusedError: [WinError 10061] 由于目标计算机积极拒绝，无法连接。是设置错误造成的，解决方法如下：
1、首先，打开py文件，如下图代码。
2、然后运行py文件提示报错系统找不到指定文件，从网上下载一个chromedriver.exe文件，放在Python根目录下。
3、然后，再次运行run——run module。
4、打开窗口如下图。
5、这样就不会报错了。
求比较好的Python练习网站
可以尝试在python二级官网地址，上面不仅可以在线编程，同时也可以尝试联系考试题目（当然前提是有python考试的参考资料的验证码权限才全）
适合 Python 入门学习的5个网站
1. Python官方网站
最权威的 Python 教程。
2. 菜鸟教程 Python 教程
基本入门级教程，还有一些简单的进阶教程。
3. 廖雪峰的 Python 教程
廖雪峰老师的教程相当不错，由浅入深，算是 进阶教程，一步步深入，后面还提供了一个实战教程。
4. Python 中文学习大本营
这里有 Flask 资料大全，如果你需要，可以找到
你想要的几乎所有教程。
5. github
希望对在大学里学习 Python 课程的同学，或者新手学习 Python 提供帮助。
python中的函数是什么
Python3 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。
请点击输入图片描述
语法
Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表）: 函数体默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。
实例
让我们使用函数来输出"Hello World！"：
#!/usr/bin/python3def hello() :print("Hello World!")hello()
更复杂点的应用，函数中带上参数变量:
实例(Python 3.0+)
比较两个数，并返回较大的数:
#!/usr/bin/python3 def max(a, b): if a > b: return a else: return b a = 4b = 5print(max(a, b))
以上实例输出结果：
5实例(Python 3.0+)
计算面积函数:
#!/usr/bin/python3 # 计算面积函数def area(width, height): return width * height def print_welcome(name): print("Welcome", name) print_welcome("Runoob")w = 4h = 5print("width =", w, " height =", h, " area =", area(w, h))
以上实例输出结果：
Welcome Runoobwidth = 4 height = 5 area = 20函数调用
定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数：
实例(Python 3.0+)
#!/usr/bin/python3 # 定义函数def printme( str ): # 打印任何传入的字符串 print (str) return # 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")
以上实例输出结果：
我要调用用户自定义函数!再次调用同一函数参数传递
在 python 中，类型属于对象，变量是没有类型的：
a=[1,2,3]a="Runoob"以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。
可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
python 传不可变对象实例
通过 id() 函数来查看内存地址变化：
实例(Python 3.0+)
def change(a): print(id(a)) # 指向的是同一个对象 a=10 print(id(a)) # 一个新对象 a=1print(id(a))change(a)
以上实例输出结果为：
437936913800364379369424可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。
传可变对象实例
可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]) print ("函数内取值: ", mylist) return # 调用changeme函数mylist = [10,20,30]changeme( mylist )print ("函数外取值: ", mylist)
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]函数外取值: [10, 20, 30, [1, 2, 3, 4]]参数
以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数
默认参数
不定长参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：
实例(Python 3.0+)
#!/usr/bin/python3 #可写函数说明def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数，不加参数会报错printme()
以上实例输出结果：
Traceback (most recent call last): File "test.py", line 10, in
printme()TypeError: printme() missing 1 required positional argument: 'str'关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
实例(Python 3.0+)
#!/usr/bin/python3 #可写函数说明def printme( str ): "打印任何传入的字符串" print (str) return #调用printme函数printme( str = "菜鸟教程")
以上实例输出结果：
菜鸟教程以下实例中演示了函数参数的使用不需要使用指定顺序：
实例(Python 3.0+)
#!/usr/bin/python3 #可写函数说明def printinfo( name, age ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数printinfo( age=50, name="runoob" )
以上实例输出结果：
名字: runoob年龄: 50默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
实例(Python 3.0+)
#!/usr/bin/python3 #可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数printinfo( age=50, name="runoob" )print ("------------------------")printinfo( name="runoob" )
以上实例输出结果：
名字: runoob年龄: 50------------------------名字: runoob年龄: 35不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vartuple) # 调用printinfo 函数printinfo( 70, 60, 50 )
以上实例输出结果：
输出: 70(60, 50)如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) for var in vartuple: print (var) return # 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )
以上实例输出结果：
输出:10输出:706050还有一种就是参数带两个星号 **基本语法如下：
def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]加了两个星号 ** 的参数会以字典的形式导入。
实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明def printinfo( arg1, **vardict ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vardict) # 调用printinfo 函数printinfo(1, a=2,b=3)
以上实例输出结果：
输出: 1{'a': 2, 'b': 3}声明函数时，参数中星号 * 可以单独出现，例如:
def f(a,b,*,c): return a+b+c如果单独出现星号 * 后的参数必须用关键字传入。
>>> def f(a,b,*,c):... return a+b+c... >>> f(1,2,3) # 报错Traceback (most recent call last): File "
", line 1, in
TypeError: f() takes 2 positional arguments but 3 were given>>> f(1,2,c=3) # 正常6>>>匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression如下实例：
实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数print ("相加后的值为 : ", sum( 10, 20 ))print ("相加后的值为 : ", sum( 20, 20 ))
以上实例输出结果：
相加后的值为 : 30相加后的值为 : 40return语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：
实例(Python 3.0+)
#!/usr/bin/python3 # 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total # 调用sum函数total = sum( 10, 20 )print ("函数外 : ", total)
以上实例输出结果：
函数内 : 30函数外 : 30强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:def f(a, b, /, c, d, *, e, f): print(a, b, c, d, e, f)以下使用方法是正确的:
f(10, 20, 30, d=40, e=50, f=60)以下使用方法会发生错误:
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式