最近项目当中要用python来实现一些功能，于是就抓紧时间学习了一下python，顺便将学习过程当中的一些知识点记录下来，方便随时查阅：

1、我们先用 print 语句完成程序员们老生常谈第一个编程实例，Hello World！

>>> print 'Hello World!'
Hello World!

2、函数 abs()接受一个数值输入，然后输出这个数值的绝对值：

>>> abs(-4)
4
>>> abs(4)
4

3、在下面的例子中，我们把一个字符串赋值给变量 myString，先用 print 来显示变量的内容，之后用变量名称来显示。
核心笔记：在交互式解释器中显示变量的值
通常当你想看变量内容时，你会在代码中使用 print 语句输出。不过在交互式解释器中，你可以用 print 语句显示变量的字符串表示，或者仅使用变量名查看该变量的原始值。在下面的例子中，我们把一个字符串赋值给变量 myString，先用 print 来显示变量的内容，之后用变量名称来显示。

>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'
>>> myString = 'Hello World!'
>>> print myString
Hello World!
>>> myString
'Hello World!'

注意：在仅用变量名时，输出的字符串是被用单引号括起来了的。这是为了让非字符串对
象也能以字符串的方式显示在屏幕上－－即它显示的是该对象的字符串表示，而不仅仅是字符
串本身。引号表示你刚刚输入的变量的值是一个字符串。

4、下划线(_)在解释器中有特别的含义，表示最后一个表达式的值。所以上面的代码执行之后，下划线变量会包含字符串：

>>>_ 
Hello World!

5、Python 的 print 语句，与字符串格式运算符( % )结合使用，可实现字符串替换功能，这一点和 C 语言中的 printf()函数非常相似：

>>> print "%s is number %d!" % ("Python", 1)
Python is number 1!

%s 表示由一个字符串来替换，而%d 表示由一个整数来替换，另外一个很常用的就是%f， 它表示由一个浮点数来替换。我们会在本章中看到更多类似的例子。Python 非常灵活，所以即使你将数字传递给 %s，也不会像其他要求严格的语言一样引发严重后果。

6、Print 语句也支持将输出重定向到文件。这个特性是从Python2.0 开始新增的。符号 >> 用来重定向输出，下面这个例子将输出重定向到标准错误输出：

import sys
print >> sys.stderr, 'Fatal error: invalid input!'
import sys
print >> sys.stderr, 'Fatal error: invalid input!'

下面是一个将输出重定向到日志文件的例子：

logfile = open('/tmp/mylog.txt', 'a')
print >> logfile, 'Fatal error: invalid input!'
logfile.close()

7、程序输入和 内建函数raw_input()
从用户那里得到数据输入的最容易的方法是使用 raw_input()内建函数。 它读取标准输入，并将读取到的数据赋值给指定的变量。 你可以使用 int() 内建函数将用户输入的字符串转换为整数。

>>> user = raw_input('Enter login name: ')
Enter login name: root                         
>>> print 'Your login is:', user
Your login is: root

上面这个例子只能用于文本输入。 下面是输入一个数值字符串(并将字符串转换为整数）的例子：

>>> num = raw_input('Now enter a number: ')
Now enter a number: 1024
>>> print 'Doubling your number: %d' % (int(num) * 2)
Doubling your number: 2048

内建函数 int()将数值字符串转换成整数值，这样才可以对它进行数学运算。

8、在学习 Python 的过程中，如果需要得到一个生疏函数的帮助，只需要对它调用内建函数help()。通过用函数名作为 help()的参数就能得到相应的帮助信息：

>>> help(raw_input)
Help on built-in function raw_input in module __builtin__:
raw_input(...)
raw_input([prompt]) -> string

9、range()函数经常和 len()函数一起用于字符串索引。 在这里我们要显示每一个元素及其索引值：

>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i], '(%d)' % i
a (0)
b (1)
c (2)

10、列表解析，你可以在一行中使用一个 for 循环将所有值放到一个列表当中：

>>> squared = [x ** 2 for x in range(4)]
>>> for i in squared:
... print i
0
1
4
9

列表解析甚至能做更复杂的事情， 比如挑选出符合要求的值放入列表：

>>> sqdEvens = [x ** 2 for x in range(8) if not x % 2]
>>> for i in sqdEvens:
... print i
0
4
16
36

11、列表和元组
可以将列表和元组当成普通的“数组”，它能保存任意数量任意类型的 Python 对象。和数组一样，通过从 0 开始的数字索引访问元素，但是列表和元组可以存储不同类型的对象。列表和元组有几处重要的区别。列表元素用中括号( [ ])包裹，元素的个数及元素的值可以改变。元组元素用小括号(( ))包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。通过切片运算( [ ] 和 [ : ] )可以得到子集，这一点与字符串的使用方法一样。

>>> aList = [1, 2, 3, 4]
>>> aList
[1, 2, 3, 4]
>>> aList[0]
1
>>> aList[2:]
[3, 4]
>>> aList[:3]
[1, 2, 3]
>>> aList[1] = 5
>>> aList
[1, 5, 3, 4]

元组也可以进行切片运算，得到的结果也是元组（不能被修改）：

>>> aTuple = ('robots', 77, 93, 'try')
>>> aTuple
('robots', 77, 93, 'try')
>>> aTuple[:3]
('robots', 77, 93)
>>> aTuple[1] = 5
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment

12、字典
字典是 Python 中的映射数据类型，工作原理类似 Perl 中的关联数组或者哈希表，由键-值(key-value)对构成。几乎所有类型的 Python 对象都可以用作键，不过一般还是以数字或者字符串最为常用。值可以是任意类型的 Python 对象，字典元素用大括号({ })包裹。

>>> aDict = {'host': 'earth'} # create dict
>>> aDict['port'] = 80 # add to dict
>>> aDict
{'host': 'earth', 'port': 80}
>>> aDict.keys()
['host', 'port']
>>> aDict['host']
'earth'
>>> for key in aDict:
... print key, aDict[key]
...
host earth
port 80

13、要给你的代码添加错误检测及异常处理， 只要将它们封装在 try-except 语句当中。 try之后的代码组， 就是你打算管理的代码。 except 之后的代码组， 则是你处理错误的代码。

try:
filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine, fobj.close()
except IOError, e:
print 'file open error:', e

14、文件和内建函数 open() 、file()
如何打开文件

handle = open(file_name, access_mode = 'r')

file_name 变量包含我们希望打开的文件的字符串名字， access_mode 中 'r' 表示读取，'w' 表示写入，
'a' 表示添加。其它可能用到的标声还有 '+' 表示读写， 'b'表示二进制访问. 如果未提供 access_mode ，
默认值为 'r'。如果 open() 成功， 一个文件对象句柄会被返回。所有后续的文件操作都必须通过此文件
句柄进行。当一个文件对象返回之后， 我们就可以访问它的一些方法， 比如 readlines() 和 close().
文件对象的方法属性也必须通过句点属性标识法访问（参阅下面的核心笔记）
核心笔记：什么是属性？
属性是与数据有关的项目， 属性可以是简单的数据值， 也可以是可执行对象， 比如函数
和方法。哪些对象拥有属性呢？ 很多。 类， 模块， 文件还有复数等等对象都拥有属性。
我如何访问对象属性？ 使用句点属性标识法。 也就是说在对象名和属性名之间加一个句
点： object.attribute
下面有一些代码， 提示用户输入文件名， 然后打开一个文件， 并显示它的内容到屏幕上：

filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
print eachLine,
fobj.close()

15、我们的代码中另一个有趣的语句是我们又一次在 print 语句中使用逗号来抑制自动生成的换行符号。

16、python注释
一、python单行注释符号(#)
井号(#)常被用作单行注释符号，在代码中使用#时，它右边的任何数据都会被忽略，当做是注释。print 1 #输出1#号右边的内容在执行的时候是不会被输出的。
二、批量、多行注释符号
在python中也会有注释有很多行的时候，这种情况下就需要批量多行注释符了。多行注释是用三引号''' '''包含的，例如：

python 多行注释符

17、模块是一种组织形式， 它将彼此有关系的 Python 代码组织到一个个独立文件当中。模块可以包含可执行代码， 函数和类或者这些东西的组合。当你创建了一个 Python 源文件，模块的名字就是不带 .py 后缀的文件名。一个模块创建之后， 你可以从另一个模块中使用 import 语句导入这个模块来使用。
如何导入模块

import module_name

如何访问一个模块函数或访问一个模块变量一旦导入完成， 一个模块的属性（函数和变量）可以通过熟悉的 .句点属性标识法访问。

module.function()
module.variable

现在我们再次提供 Hello World! 例子， 不过这次使用 sys 模块中的输出函数。

>>> import sys
Edit By Vheavens
Edit By Vheavens                              
>>> sys.stdout.write('Hello World!\n')
Hello World!
>>> sys.platform
'win32'
>>> sys.version
'2.4.2 (#67, Sep 28 2005, 10:51:12) [MSC v.1310 32 bit(Intel)]'```
这些代码的输出与我们使用 print 语句完全相同。** 唯一的区别在于这次调用了标准输出的 write()方法，而且这次需要显式的在字符串中提供换行字符， 不同于 print 语句， write()不会自动在字符串后面添加换行符号。**

17、什么是“PEP”？
在本书中你会经常看到 PEP 这个字眼。 一个 PEP 就是一个 Python 增强提案(Python Enhancement Proposal)， 这也是在新版 Python 中增加新特性的方式。

18、实用的函数
本章中， 我们用到了很多实用的内建函数。我们在表 2.1 中总结了这些函数， 并且提供了一些其它的有用函数。（注意我们并没有提供完整的使用语法，仅提供了我们认为可能对你有用的部分）
表 2.1 对新 Python 程序员有用的内建函数

函数 描述
dir([obj]) 显示对象的属性，如果没有提供参数， 则显示全局变量的名字
help([obj]) 以一种整齐美观的形式 显示对象的文档字符串， 如果没有提供任何参数， 则会进入交互式帮助。
int(obj) 将一个对象转换为整数
len(obj) 返回对象的长度
open(fn, mode) 以 mode('r' = 读， 'w'= 写)方式打开一个文件名为 fn 的文件
range([[ start ,] stop [, step ]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start默认值为 0， step默认值为1。
raw_input(str) 等待用户输入一个字符串， 可以提供一个可选的参数 str 用作提示信息。
str(obj) 将一个对象转换为字符串
type(obj) 返回对象的类型（返回值本身是一个 type 对象！）```

19、一行过长的语句可以使用反斜杠( \ ) 分解成几行，如下例：

# check conditions
if (weather_is_hot == 1) and \
(shark_warnings == 0):
send_goto_beach_mesg_to_pager()```
在含有小括号、中括号、花括号时可以多行书写。另外就是三引号包括下的字符串也可以跨行书写。

display a string with triple quotes

print'''hi there, this is a long message for you
that goes over multiple lines... you will find
out soon that triple quotes in Python allows
this kind of fun! it is like a day on the beach!'''

set some variables

go_surf, get_a_tan_while, boat_size, toll_money = (1,'windsurfing', 40.0, -2.00)```
如果要在使用反斜线换行和使用括号元素换行作一个选择，我们推荐使用括号，这样可读性会更好。

20、缩进相同的一组语句构成一个代码块，我们称之代码组。像 if、while、def 和 class 这样的复合语句，首行以关键字开始，以冒号( : )结束，Python 使用缩进来分隔代码组。代码的层次关系是通过同样深度的空格或制表符缩进体现的。同一代码组的代码行必须严格左对齐（左边有同样多的空格或同样多的制表符），如果不严格遵守这个规则，同一组的代码就可能被当成另一个组，甚至会导致语法错误。

21、核心风格：缩进四个空格宽度，避免使用制表符，没有缩进的代码块是最高层次的，别称做脚本的“main”部分。

22、分号( ; )允许你将多个语句写在同一行上，语句之间用分号隔开，而这些语句也不能在这行开始一个新的代码块。这里有一个例子：

import sys; x = 'foo'; sys.stdout.write(x + '\n')

必须指出一点， 同一行上书写多个语句会大大降低代码的可读性，Python 虽然允许但不提倡你这么做。

23、关键字列表和 iskeyword()函数都放入了 keyword模块以便查阅

>>> import keyword
>>> keyword.iskeyword('class')
True
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec',
 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise',
 'return', 'try', 'while', 'with', 'yield']
>>> len(keyword.kwlist)
31```

24、专用下划线标识符
Python 用下划线作为变量前缀和后缀指定特殊变量。稍后我们会发现，对于程序来说，其中的有些变量是非常有用的，而其他的则是未知或无用的。这里对 Python 中下划线的特殊用法做了总结：
- \_xxx 不用'from module import *'导入
- \_\_xxx\_\_系统定义名字
- \_\_xxx 类中的私有变量名
核心风格：避免用下划线作为变量名的开始
因为下划线对解释器有特殊的意义，而且是内建标识符所使用的符号，我们建议程序员避免用下划线作为变量名的开始。一般来讲，变量名_xxx 被看作是“私有的”，在模块或类外不可以使用。当变量是私有的时候，用_xxx 来表示变量是很好的习惯。因为变量名__xxx__对Python 来说有特殊含义，对于普通的变量应当避免这种命名风格。

25、**只有一个模块，也就是包含主程序的模块会被直接执行，或由用户通过命令行执行，或作为批处理执行， 或由 Unix cron 任务定时执行，或通过 Web 服务器调用，或通过 GUI 执行。 通常只有主程序模块中有大量的顶级可执行代码，所有其它被导入的模块只应该有很少的顶级执行代码，所有的功能代码都应该封装在函数或类当中。**

26、核心笔记：__name__ 指示模块应如何被加载
**由于主程序代码无论模块是被导入还是被直接执行都会运行， 我们必须知道模块如何决定运行方向。一个应用程序可能需要导入另一个应用程序的一个模块，以便重用一些有用的代码（否则就只能用拷贝粘贴那种非面向对象的愚蠢手段）。这种情况下，你只想访问那些位于其它应用程序中的代码，而不是想运行那个应用程序。因此一个问题出现了，“Python 是否有一种方法能在运行时检测该模块是被导入还是被直接执行呢？” 答案就是......(鼓声雷动).....没错！ __name__ 系统变量就是正确答案。如果模块是被导入， __name__ 的值为模块名字如果模块是被直接执行， __name__ 的值为 '__main__'**

27、del 语句能够直接释放资源

28、当变量被赋值给另外一个对象时，原对象的引用计数也会自动减 1：

foo = 'xyz'
bar = foo
foo = 123```
当字符串对象"xyz"被创建并赋值给 foo 时， 它的引用计数是 1. 当增加了一个别名 bar时， 引用计数变成了 2. 不过当 foo 被重新赋值给整数对象 123 时， xyz 对象的引用计数自动减 1，又重新变成了 1.

29、总结一下，一个对象的引用计数在以下情况会减少：

• 一个本地引用离开了其作用范围。比如 foobar()(参见上一下例子）函数结束时。
• 对象的别名被显式的销毁。
  del y # or del x
• 对象的一个别名被赋值给其它的对象
  x = 123
• 对象被从一个窗口对象中移除
  myList.remove(x)
• 窗口对象本身被销毁
  del myList # or goes out-of-scope

30、del 语句
Del 语句会删除对象的一个引用，它的语法是：
del obj1[, obj2[,... objN]]
例如，在上例中执行 del y 会产生两个结果：

• 从现在的名字空间中删除 y
• x 的引用计数减一
  引申一步， 执行 del x 会删除该对象的最后一个引用， 也就是该对象的引用计数会减为0， 这会导致该对象从此“无法访问”或“无法抵达”。 从此刻起， 该对象就成为垃圾回收机制的回收对象。 注意任何追踪或调试程序会给一个对象增加一个额外的引用， 这会推迟该对象被回收的时间。

31、异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生```

下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，且并未发生异常：

!/usr/bin/python

-- coding: UTF-8 --

try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
以上程序输出结果：
$ python test.py
内容写入文件成功
$ cat testfile # 查看写入的内容
这是一个测试文件，用于测试异常!!```

使用except而不带任何异常类型
你可以不带任何异常类型使用except，如下实例：

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码```
以上方式try-except语句捕获所有发生的异常。但这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。
**使用except而带多种异常类型**
你也可以使用相同的except语句来处理多个异常信息，如下所示：

try:
正常的操作
......................
except(Exception1[, Exception2[,...ExceptionN]]]):
发生以上多个异常中的一个，执行这块代码
......................
else:
如果没有异常执行这块代码
try-finally 语句
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise```

异常的参数
一个异常可以带上参数，可作为输出的异常信息参数。你可以通过except语句来捕获异常的参数，如下所示：

try:
    正常的操作
   ......................
except ExceptionType, Argument:
    你可以在这输出 Argument 的值...```
变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。元组通常包含错误字符串，错误数字，错误位置。
**实例**
以下为单个异常的实例：

!/usr/bin/python

-- coding: UTF-8 --

定义函数

def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "参数没有包含数字\n", Argument

调用函数

temp_convert("xyz");```
以上程序执行结果如下：

$ python test.py 
参数没有包含数字
invalid literal for int() with base 10: 'xyz'```
**触发异常**
我们可以使用raise语句自己触发异常，raise语法格式如下：

raise [Exception [, args [, traceback]]]```
语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
实例
一个异常可以是一个字符串，类或对象。 Python的内核提供的异常，大多数都是实例化的类，这是一个类的实例的参数。
定义一个异常非常简单，如下所示：

def functionName( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后，后面的代码就不会再执行```
**注意**：为了能够捕获异常，"except"语句必须有用相同的异常来抛出类对象或者字符串。例如我们捕获以上异常，"except"语句如下所示：

try:
正常逻辑
except "Invalid level!":
触发自定义异常
else:
其余代码
实例

!/usr/bin/python

-- coding: UTF-8 --

定义函数

def mye( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 触发异常后，后面的代码就不会再执行

try:
mye(0) // 触发异常
except "Invalid level!":
print 1
else:
print 2```
执行以上代码，输出结果为：

$ python test.py 
Traceback (most recent call last):
  File "test.py", line 11, in <module>
    mye(0)
  File "test.py", line 7, in mye
    raise Exception("Invalid level!", level)
Exception: ('Invalid level!', 0)```

32、通过调用 type()函数你能够得到特定对象的类型信息：

type(42)
<type 'int'>```
我们仔细研究一下这个例子，请注意看 type 函数有趣的返回值。我们得到一个简洁的输出结果<type 'int'>。不过你应当意识到它并不是一个简简单单的告诉你 42 是个整数这样的字符串。您看到的<type 'int'>实际上是一个类型对象，碰巧它输出了一个字符串来告诉你它是个 int 型对象。
现在你该问自己了，那么类型对象的类型是什么？来， 我们试验一下：

>>> type(type(42))
<type 'type'>```
没错，所有类型对象的类型都是 type，它也是所有 Python 类型的根和所有 Python 标准类的默认元类（metaclass）。

33、核心笔记：布尔值
Python 有一个特殊的类型，被称作 Null 对象或者 NoneType，它只有一个值，那就是 None。它不支持任何运算也没有任何内建方法。如果非常熟悉 C 语言，和 None 类型最接近的 C 类型就是 void，None 类型的值和 C 的 NULL 值非常相似（其他类似的对象和值包括 Perl 的 undef 和Java 的 void 类型与 null 值）。

None 没有什么有用的属性，它的布尔值总是 False。

所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔 True 或 False 值。空对象、值为零的任何数字或者 Null 对象 None 的布尔值都是 False。
下列对象的布尔值是 False。
-  None
-  False (布尔类型)
-  所有的值为零的数：                   
-  0 (整型)
-  (浮点型)
-  0L (长整型)
-  0.0+0.0j (复数)
-  "" (空字符串)
-  [] (空列表)
-  () (空元组)
- {} (空字典)

值不是上面列出来的任何值的对象的布尔值都是 True，例如 non-empty、 non-zero 等等。
用户创建的类实例如果定义了 nonzero(\_\_nonzero_\_())或 length（\_\_len__()）且值为 0，那
么它们的布尔值就是 False。

34、python查询所有内建函数
dir(\_\_builtins__)

35、repr(obj) 或 `obj` 返回一个对象的字符串表示

36、str()和 repr() (及 `` 运算符)
内建函数 str() 和 repr() 或反引号运算符(``) 可以方便的以字符串的方式获取对象的内容、类型、数值属性等信息。str()函数得到的字符串可读性好， 而 repr()函数得到的字符串通常可以用来重新获得该对象, 通常情况下 obj == eval(repr(obj)) 这个等式是成立的。这两个函数接受一个对象做为其参数， 返回适当的字符串。在下面的例子里， 我们会随机取一些 Python 对象来查看他们的字符串表示。

str(4.53-2j)
'(4.53-2j)'

str(1)
'1'

str(2e10)
'20000000000.0'

str([0, 5, 9, 9])
'[0, 5, 9, 9]'

repr([0, 5, 9, 9])
'[0, 5, 9, 9]'

[0, 5, 9, 9]
'[0, 5, 9, 9]'```
尽管 str(),repr()和``运算在特性和功能方面都非常相似， 事实上 repr() 和 `` 做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示， 也就是说绝大多数情况下可以通过求值运算(使用 eval()内建函数)重新得到该对象，但 str()则有所不同。str() 致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于 eval()求值， 但很适合用于 print 语句输出。需要再次提醒一下的是， 并不是所有 repr()返回的字符串都能够用eval()内建函数得到原来的对象：

>>> eval(`type(type))`)
File "<stdin>", line 1
eval(`type(type))`)
^
SyntaxError: invalid syntax    ```       
也就是说 repr() 输出对 Python 比较友好， 而 str()的输出对人比较友好。虽然如此，很多情况下这三者的输出仍然都是完全一样的。
**核心笔记：为什么我们有了 repr()还需要``？
在 Python 学习过程中，你偶尔会遇到某个运算符和某个函数是做同样一件事情。之所以如
此是因为某些场合函数会比运算符更适合使用。举个例子， 当处理类似函数这样的可执行对象
或根据不同的数据项调用不同的函数处理时，函数就比运算符用起来方便。另一个例子就是双
星号(\**)乘方运算和 pow()内建函数，x \*\* y 和 pow(x,y) 执行的都是 x 的 y 次方。**
译者注：事实上 Python 社区目前已经不鼓励继续使用``运算符。

37、Python 不支持方法或函数重载， 因此你必须自己保证调用的就是你想要的函数或对象。