萍乡李兴球的博客_信奥C++/Python/Scratch

for循环里还有两个秘密，一个秘密叫break,一个秘密叫continue。它们配合默契，能让我们的编程水平更上一层楼，现在我们就来学习它们的用法吧。

break 语句

开运动会了，同学们跃跃欲试。只听见一声令下，同学们如离弦之箭地跑了出去。突然，山雨欲来风满城，雷公电母齐奏乐，倾盆大雨泻不止，淋得同学一声湿。校长先生立宣布：比赛中断把家还！中断的英文是break，在Python编程中，也有break命令，它能中断什么？看看下面小框框，学习中断莫慌张：

>>> for i in range(10):       #  迭代i拾次
   if  i > 5:break      # 如果i大于5，中断循环
print(i,end=' ')              # 打印i的值，以空格结束

  
0 1 2 3 4 5 
>>>

在上在的代码中，第2句，瞧准了，它的意思很好理解：如果i大于5，则中断。我们看到的结果是上面的for循环只打印了从0到5的数据，其它的数据被break强行“中断”了。

来次小小的总结，break是用来中断循环语句的，一般情况下，它会在一个条件判断语句中，当条件满足后，就会中断循环，循环也就运行结束了。需要注意的是，它只会中断自己所在的这一层for循环。如果有嵌套的for循环，那它可不会越级地中断上一层的for循环。请看下面的代码：

>>> for k in range(5):       # 迭代k伍次
       for i in range(10):   # 迭代i拾次
     if i > 5 :break         # 如果i大于5则中断
     print(i,end=' ')        # 打印i的值，以空格结束
  print()

  
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5 
0 1 2 3 4 5

上面的代码打印了5行0 1 2 3 4 5。这说明break对上一层的for循环一点影响也没有。

continue语句

天空放晴万里无云，学生上学比赛继续进行。前面，由于下了大雨，校运会被中断了，这次由于天气变好了，所以比赛又继续接着进行了。“继续”的英文为continue。在Python中也有continue语句，它是继续下一轮，或继续下一次迭代的意思。它像break语句一样，也是放在循环语句中。下面的代码展示了它的用法：

>>> for i in range(10):          # 迭代i拾次
  if i == 5 :continue      # 如果i等于5，继续下一次迭代
  print(i,end=' ')         # 打印i的值，以空格结束

  
0 1 2 3 4 6 7 8 9 
>>>

上面可怜的5，被忽略了，它并没有被打印出来。这是由于在for循环里的if语句捣的鬼。第2行的意思是说，如果i和5相等，那么继续下一次迭代，所以5就打印不到了。下面我们再看一个例子：

>>> import random                  # 导入随机模块
>>> for i in range(5):             # 迭代i伍次
        x = random.randint(-5,5)   # 生成 从-5到5之间的随机整数
  if x == 0: continue        # 如果x等于0，继续下一次迭代
  print(1/x)                 # 打印1/x的值

  
-0.5
0.2
0.3333333333333333
0.3333333333333333
0.25

在上面的代码，如果没有if语句，由于x的值可能为0，所以程序会出错，但是通过合理地运用continue语句避免了发生1除以0的情况，小兵也有大用途哦。

有参函数(Parametric Function)

奶牛吃的是草，挤的是奶。工厂输入原料，输出产品。有句谚语叫物华天宝，人杰地灵，物华天宝是自然环境，如果把它看成是输入，那么“人”就是这个自然环境的输出。正所谓一方水土一方人。有种测试叫黑盒测试，测试人员根本不会去了解或理解黑盒里的东西是怎么实现的，只要给它输入条件，如果它能输出正确的结果，就说明功能已经OK了。上回我们提到了函数有返回值，返回值可以看成是函数的输出。函数还会有输入，这些输入是通过参数实现的。我们都用过print语句，它的参数就是逗号隔开的数据。它的返回值其实是None。每个函数都有返回值，我们没有写它具体的返回值的时候，它会默默地返回None，如果要写返回值的话，该如何定义函数呢？以下是语法图：

上面的参数列表是以逗号隔开的变量名称，类型可以是整数，字符串等。最后一句return语句用来返回数据的。return在英文中就是返回的意思。当调用函数的时候，小括号中的值会传递给参数，如下图所示：

下面我们来定义一个有参数的函数：

>>> def add(x,y):      #  定义函数，有两个参数
  z = x + y            # 把参数的值加起来赋值给z
  return z             # 返回z

>>> s = add(32,76)     # 调用函数，返回结果用s进行引用
>>> s
108

当调用add函数的时候，32会被赋值给x,76会被赋值给y。在函数进行一系列运算后它把z变量的值返回以供使用，这就是函数的输出。简而言之，这个add函数的输入是两个数据，输出是它们的和。需要注意的是，在调用函数时实际书写的顺序要和定义时的顺序一致，否则会发生牛头不对马嘴的情况，严重地会导致程序运行出错。请看下面一例：

>>> def do_stuff(first,second,third):
  string = "小明" + first + "后" + second  +"再" + third
  return string

>>> do_stuff("吃饭","刷牙","起床")
'小明吃饭后刷牙再起床'
>>> do_stuff("起床","刷牙","吃饭")
'小明起床后刷牙再吃饭'
>>>

形参与实参(Formal and Actual parameter)

上面我们提到了参数，在定义函数时小括号内的参数是形式上的参数，叫做形参，而在调用的时候用的是实际的具体数据，这叫实际参数，简称实参。形式参数在接收到数据时，它就成了一个局部变量了。以下是一个例子：

>>> def zsum(number):               #  定义函数，有形式参数为number
  s = 0
  for n in range(1,number+1):
    s = s + n
  return s

>>> zsum(10)                  # 调用函数，10 是实际参数
55
>>>

有个小问题，在函数内部能改变形式参数的值吗？这里需要说明的是，通过def是定义函数，并不是真正的执行函数。由于形式参数它已经接受到了实际参数的值，这时候它是一个本地变量了。这个变量的值当然能被改变。请看下列代码示例：

>>> def times(number):
        number = number * number
  return number

>>> times(8)
64
>>> times(16)
256
>>>

其实上面的times直接用return times*times就能达到同样的效果，上面这么写只是为了教学演示。

函数概述(Overview of  Function)

在Python中有一个重要的概念叫函数。我们常常用不求甚解来形容对某些事物不去追究原理或原因。如，人们不会去追究发动机的原理而照样开小汽车，人们只要知道操控它就行了。人们也不知道大米酿造成白酒的化学原理，可是千百年来，照样是出了很多著名的白酒品牌。在Python中有print命令，相信大家都不知道它把字符串打印到IDLE中的具体原理。还有诸如随机模块的randint命令，os模块的那些命令，我们都不知道它们的原理。这些是预定义好的一些命令。命令，它能实现某种功能（function）。当我们要实现某种功能时，可以查找Python手册或其它模块中有没有相应的命令。如果找不到了，那就需要自己制造一个命令来实现这个功能了，这叫定义函数（在英文中它的翻译就是function）。函字通涵，它是蕴涵的意思。函数是组织好的,可重复使用的,用来实现某种功能的代码段。要使用函数，需要先定义它。函数定义好了，我们就能使用它们，这叫调用函数。在海龟画图中，我们接触过很多命令，它们都是事先定义好的函数。 接下来我们来定义函数，并且使用它们。

定义函数(Define Function)

在上面的图示中，def三个字是英文define的前三个字母，它就是定义的意思。在def之后是空格，接着就是函数名称，函数名称后是小括号号，最后面是冒号，需要注意一下的是，无论是小括号还是冒号，都是英文的半角符号，要不然就会出错。

上面的语句一、语句…和语句n就是语句组。给函数实现某种功能就要靠它的语句组了。最简单的语句组可以说是pass了。语句组中同样级别的语句们的缩进数要一致，否则就会出错。 以下是一个定义函数的例子：

>>> def  introduce():                 # 定义一个函数，名字叫introduce
   print("My name is rose")
print("My age is 11")
  
>>> 
>>>  introduce()                     # 调用函数 
My name is rose
My age is 11 

调用函数的方式就是写上函数名称，后面跟上小括号就行了。上面的第7行语句调用了函数，它只是简单地打印了一些字符串。我们可以用type命令查看函数的类型，也可以在调用函数的时候不输入小括号看看是个什么结果。

>>> introduce                                     # 不输入小括号，直接查看函数
<function introduce at 0x0000000002FDBBF8>        # 返回的是函数表述字符串
>>> type(introduce)                               # 查看introduce的类型
<class 'function'>                                # <类 ‘函数’>
>>>

在函数中当然也能使用导入进来的其它命令，接下来的例子命令使用了random中的randint和os模块中的mkdir命令。

>>> import random                    # 导入随机模块
>>> import os                        # 导入os模块
>>> def make_random_dir():           # 定义函数，名称为 make_random_dir
  s = ""
  for n in range(10):         # 迭代10次n
     s = s + str(random.randint(0,9)) # 产生0到9之间的随机数，转换成字符串，连接起来
  os.mkdir(s)                     # 在当前文件夹下建立名字为s的文件夹

  
>>> make_random_dir()              # 调用函数

上面定义了一个有一定使用价值的函数，它的名字叫make_random_dir，寓意为建立随机目录。当我们给函数，变量等取名字的时候，通常要给它们起一个恰当的名字，最好能直接表示函数的功能，当然不能和已有的命令、模块名等重名，更不能乱写。上面稍微难理解的是第6行代码，我们首先看str小括号里的命令。这个命令是：random.randint(0,9)。它会产生从0到9之间的随机整数。它产生后，str会把它转换成字符。最后这个字符和s连接起来了，结果就是s变长了一位。这个函数实现的功能就是，首先会产生一个随机的包括全是数字的字符串，然后在当前工作目录下以这个字符串为名称，建立一个新的目录。

现在，我们定义的函数都是没有参数的，可以称之为无参函数。所谓参数，先理解为在定义函数时候，在它的小括号有变量。既然有无参数的函数，那么可能某些函数就会有参数，暂且称之为有参函数，关于它，我们以后再学习。

书山有路勤为径,学海无边苦作舟。说的是读书方面的事情。在计算机里也有“读”的概念，它指的是把文件的内容加载到内存，方便让我们看到它的内容。下面我们就来看看文件长什么样吧。

文件概论(file Introduction)

打开计算机，双击播放器，欣赏小电影，阅读电子书。这些可能是你习以为常的动作。其实你都进行了打开文件的操作。当双击的时候，就会对应有一个程序来打开电影，电子书或图像。一部电影对应着一个视频文件，一部电子书可能对应着一个文本文件，而一幅图可能对应的就是一张图像文件。有部电影叫《正义联盟》，我们下载了它放在电脑中的某个文件夹。它的名称可能是下面这样，对着它单击右键，显示出它的一些信息，请看以下图示：

上面的文件名有三部分，分别是点号前面的字符，点号，点号后面的字符。点号后面的叫扩展名或后缀名，当然也有人把点号本身也连同进去说它们是后缀名。

Python源文件的后缀名是py。 对着Python的源代码文件单击右键。我们能清楚地看到文件的类型、大小、创建时间、打开方式等等。原来，扩展名也是可以用来标识文件的类型。我们说上面的文件是py文件也是可以的，它实质上是文本文件。文本文件的后缀名可能有很多，如txt,html,asp,php,bat等等。我们可以用Python打开它们，看看文本文件里有些什么东西。

读文本文件(read text file)

打开文本文件用open命令，它会返回一个文件对象，通过文件对象我们就能使用read方法读出它的内容，然后把内容通过一个变量名称进行引用，最后通过print打印，我们就能看到它的内容了。假设有一个文本文件的名字为“唐诗.txt”，以下是打开它的示例：

>>> f = open("唐诗.txt")   # 打开文件
>>> fc = f.read()         # 读取文件内容
>>> f.close()            # 关闭文件
>>> print(fc)            # 打印文件内容

在上面的代码中，open命令根据文件名打开文件，生成了文件对象， 我们用f来引用它。需要注意的时候，如果文件不存在，那么是打不开的，并且会显示文件找不到的错误。文件对象有read命令，通过这个命令就能读取的文件内容。不过，如果不把文件的内容用fc来引用，那么我们无法通过print打印了。当读出了文件内容后，我们一定要关闭文件，用f的close命令就行了。

其实在用open命令打开文件的时候，它还有一个参数。关于参数，我们现在理解为在命令中小括号里面的数据即可，参数可能有个名称，这叫关键词参数。open命令的第一个参数是文件名，第一个参数是模式，英文为mode。它决定了打开文件的时候是否是读还是写，上面我们没有写这个参数，那么open命令就默认为读文件。以下是示例代码：

>>> f = open("唐诗.txt",mode='r')
>>> fc = f.read()
>>> f.close()
>>> print(fc)

上面的open命令的小括号里有两个数据，第一个表示文件名，第二个表示读写模式。mode在英文中就是模式的意思。让mode的值为’r’，表示在用open命令打开它时，只能读取它的内容。我们是无法修改文件的内容的，如果要修改它的内容怎么办，这就要把模式改为’w’。接下来，我们来写一写文件。

写文本文件(write text file)

写文件会改变文件的内容，当我们以写的模式打开文件时，如果文件不存在，那么会自动创建那个文件。下面的代码将会创建一个新的文件：

>>> f = open("唐诗.txt",mode='w')
>>> f.write("这是一首李白写的诗。\n")
>>. f.write("静夜思............。\n")
>>> f.close()

上面的代码会在当前文件夹打开名为”唐诗.txt”的文件，如果它不存在，则会创建它。如果它存在，那么它的内容将会被改写。 如果它里面有非常重要的内容，那么当写完后，运行close命时，那么以前的数据会全部丢失，这将会造成损失。

附，在IDLE中的当前文件夹可以通过导入os模块，运行os.getcwd()获取。

加密解密(Encrypt and Decrypt)

我们可以把一串字符转换成另一种形式，让别人无法明白，而自己通过程序则可以把它恢复为原来的样子， 那么就能读懂了。怎么转换呢？有很多种方法，字母都有一个编号，这个编号叫ASCII码，是美国人制定的，现在已经成为国际标准了。这个编号可以用ord命令求出来。反过来，一个编号也就对应着一个字母，用chr命令可以把这个字母显示出来。以下是代码示例：

>>> ord('a')                     # 求字母a的编号
97
>>> chr(97)                      # 求编号为97对应的字符
'a'
>>> for number in range(48,58):   # 迭代number从48到57
      print(chr(number),end=' ')

  
0 1 2 3 4 5 6 7 8 9
>>> chr(ord('a'))               # 求字母a的编号所对应的字符
'a'
>>> chr(ord('a')+1)             # 求字母a的编号增加1后所对应的字符
'b'
>>>

从上面的例子中，我们看到48编号的字符为”0″，而57编号的字符为”9″ 。ord命令取自英文order的前三个字母，chr命令取自character(字符)的相关字符。

有趣的是第10行，它求出字母a的编号，然后又用chr去求这个编号所对应的字符，得到的结果当然是字母a了。这好像没有什么用处，其实不然。下面就运用这种方法对字符串进行加密。如果把某个字符的编号加上一个数字，再用chr把它转换成字符，好像这个字符就“加密”了一样。以下是把一串字符进行简易加密的代码。

>>> string = 'a rose and a cat'
>>> string2 = ""
>>> for c in string:                      # 迭代字符串
        string2 = string2 + chr(ord(c)+1) # 连接字符串
  
>>> string2
'b!sptf!boe!b!dbu'
>>>

string本来是一朵玫瑰和一只猫，现在它变成了一串我们谁也不认识的字符串了。这就是一个非常简单的加密过程。现在我们再编制一个程序，把它转换回去。

>>> string3 = "" 
>>> for c in string2:            # 迭代string2
       string3 = string3 + chr(ord(c)-1)

  
>>> string3
'a rose and a cat'
>>>

给字符串加密的方法加是把字符的编码加1，所以解密的方法就是反过来就行了，上面的代码又把字符串还原成一朵玫瑰和一只猫了。

“随机”取整(“random” randint)

天有不测风云，人有祸福旦夕。买彩票的人说不定哪天会中奖，或者天上掉下金砖砸中你也说不定。貌似我们上天自有安排，很多事情我们无法决定，正所谓塞翁失马，焉知祸福。在现在所谓的“大数据”时代，对海量的数据进行统计分析还能对“未来”进行预测。不过，我敢肯定的时，这些数据都是在一定的范围之内的。前面我们学了range命令，它能取一系列范围内的整数，如果要取一系列范围内的随机一个数据，需要如何编写代码？Python本身可是无能为力了，这得搬求兵。这求兵的名字叫random。它就是鼎鼎大名的随机模块。怎么个搬法，用import random就行了。import是导入，输入的意思。救兵搬来了要怎么使用这个大神呢？大神有很多魔法，这之一是randint，下面我们来看看如何使用randint吧。代码如下所示：

>>> import random              # 导入随机模块
>>> random.randint(0,100)       # 随机取一个从0到100之间的整数
16
>>> random.randint(10,20)      # 随机取一个从10到20之间的整数
19
>>>  
>>> random.randint(-10,10)     # 随机取一个从-10到10之间的整数
9
>>>

randint命令是random和integer的组合。我们把它叫随机取整命令。 在上面的代码中，我们通过import random导入了随机模块，然后调用了它的randint命令。它是用来随机从某个范围内取一序列整数的。这个命令有两个参数，第一个参数表示数据的起始值，第二个参数表示数据的结束值。起始值要小于结束值，否则红色的字符给你的颜色会非常好看。

>>> import random
>>> random.randint(100,10)           # 起始数据大于结束数据，无法取得整数
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    random.randint(100,10)
  File "C:\Python\Python36\lib\random.py", line 221, in randint
    return self.randrange(a, b+1)
  File "C:\Python\Python36\lib\random.py", line 199, in randrange
    raise ValueError("empty range for randrange() (%d,%d, %d)" % (istart, istop, width))
ValueError: empty range for randrange() (100,11, -89)
>>>

创建列表 (create list)

前面我们犹抱琵琶半遮面地谈过列表。列表这位“仁兄”是现在要正式出场了。我们把它请出来，看看它的“庐山真面目”。怎么个请法，方法有二。第一种方法就是直接输入一对中括号，即[]，第二个方法就是用命令list加小括号，这样列表就“光着膀子”诞生了。下面的代码生成了两个列表，一个名为one,一个名为two。只不过它们都是空空如也，就是说两个列表中没有数据。

>>> one = []              # 直接用中括号新建一个空列表
>>> two = list()          # 新list命令新建一个空列表
>>> one
[ ]
>>> type(one)             # 显示one的类型
<class 'list'>
>>>

有句谚语叫：墙上芦苇,头重脚轻根底浅，山间竹笋,嘴尖皮厚腹中空。上面的两个列表光有皮囊一付，留在“世上”貌似无用。佛祖以仁爱为厚德，暂且我们不要删除它们。我们要对它们进行“改造”，给它们添加数据，让它们有用武之地。英语中的append是添加的意思，在Python中用它做为列表的添加命令。用法见下面的代码：

>>> three = list()         # 新建空的列表，名为three
>>> three.append(1)        # 给three添加1
>>> three.append(2)        # 给three添加2
>>>three.append(3)         # 给three添加3
>>> three
[1, 2, 3]

通过append命令，我们给列表添加了三个数据。append的用法是不是非常简单呢？这三个数据在列表中以逗号为分隔，它们从左数到右有一个“编号”，这个“编号”正式的名称叫索引(index)，也可以称之为下标。索引是从0开始的。在这个列表中索引为0的数据是1，索引为1的数据是2，索引为2的数据是3。新建列表的时候，我们可以直接在中括号是写入数据，由于在列表中不仅可以存储数字，还能存储字符串，以下列表存储了一些水果的英文名称。

>>> fruit = ['apple','banana','peach','watermelon']
>>> 
>>> fruit.append('pear')
>>> fruit
['apple', 'banana', 'peach', 'watermelon', 'pear']
>>>

如果要引用列表中的数据或者修改列表中的数据要如何书写？首先，需要指定索引号，这样就能知道对哪个数据进行操作了。接着，把索引号放在中括号中就行了，当然还要指明是取哪个列表的数据，下面的代码修改了索引为0的数据，打印了其它的数据。

>>> fruit[0] = 'pineapple'        # 修改索引为0的数据
>>> print(fruit[1])               # 打印索引为1的数据        
banana
>>> print(fruit[2])               # 打印索引为2的数据
peach
>>> print(fruit[3])               # 打印索引为3的数据
watermelon
>>> print(fruit[4])               # 打印索引为4的数据
pear
>>> print(fruit[5])               # 打印索引为5的数据
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    print(fruit[5])
IndexError: list index out of range
>>> fruit
['pineapple', 'banana', 'peach', 'watermelon', 'pear']
>>>

在上面的代码中，fruit列表有5个数据，那么它最大的索引号为4。如果试图访问fruit[5]那就会出现索引错误。上面的英文：IndexError: list index out of range就是索引错误，列表的索引超出范围之意思。

来次小小的总结，在Python列表就是以逗号隔开，以中括号括起来的数据集合，这些数据可以是小数，可以是逻辑数据，也可以是字符串，甚至是另一个列表。要访问或修改列表中的数据都要通过索引号来进行。列表的故事说不完，今天暂且到此结束。

“随机”取样(“random” sample)

在Python中有很多模块，其中有一个是模块的名称叫random。它在英文中就是随机的意思。导入这个模块用命令import random即可，import 是导入、输入的意思。在这个模块里有一个命令叫sample，它的意思是取样本。所谓取样就是从一些东西里面抽取一些来，然后进行分析。假设超市进货的时候，卡车拉来一大批苹果，经理可能会随机抽取一些苹果来验证质量，这就是取样本的一个过程。接下来，假设有一个列表中存储了苹果的质量，我们来随机取样。

>>> import random
>>> apple = [32,76,88,10,24,256,32,56,80,40,50]
>>> random.sample(apple,3)
[80, 32, 56]
>>>

上面第一行代码中的apple是一个列表，现在我们只要知道它是用中括号括起来的，以逗号隔开的数据集合就行了。apple里有11个数据，代表11个苹果的质量。第2行的代码是随机抽取3个苹果的质量的意思。我们看到了返回的结果也是一个列表。

简而言之，random.sample命令就是随机从一个序列中出取一些数据，当然，抽取的数据的数量不能大于序列的数据数量。下面的代码从26个英文字母中抽取10个字母。

>>> letters = 'abcdefghijklmnopqrstuvwxyz'
>>> random.sample(letters,10)
['a', 'z', 'y', 'e', 'l', 'p', 't', 'v', 'b', 'w']
>>>

关于random模块，先就叙述到这里。上次我们用open命令打开文件，一次性读取了文件的全部内容，接下来我们一行一行的读取。

按行读取文本文件(Read text files by line)

打开文本文件用open命令，它会返回一个文件对象。这个文件对象是可以用for来迭代的。以下是迭代文件对象的示例：

>>> f = open("D:/test.txt")        # 默认为只读方式打开文件
>>> for line in f:                 # 以行迭代文件对象
        print(line)                # 打印line

静夜思

李白	
>>> f.close()

通过上面迭代f，我们看出来了它是以行来迭代的，每次迭代，line就获取一行的内容。在test.txt文件中，只有紧挨着的两行的内容，由于print打印line完成的时候会默认打印一个换行符号，所以上面的静夜思下面多打印了一个换行符号。当文件的内容都输出了后，不要忘了用close命令关闭文件。

局部变量(Local Variable)

有句谚语叫盲人摸象，盲人们看不到整体的大象，他们摸到什么就说大象像什么。这里将要说的是一个局部的概念。前面讲了函数的定义，在函数内部也是可以定义变量的。不过，如果想在函数外面使用函数里面的变量，那是无法使用的，就像你在老家讲的方言，到了外地，别人无法听懂，所以老家方言无法使用。接下来，我们“以身试法”，看看在函数外面使用函数内部定义的变量会怎么样，以下是代码示例：

>>> def func1():       # 定义函数，名称为func1
  number = 1           # 定义变量，名称为number
  print(number)

  
>>> print(number)
Traceback (most recent call last):
  File "<pyshell#61>", line 1, in <module>
    print(number)
NameError: name 'number' is not defined
>>>

上面的代码“强行”打印曾经在函数内部定义的变量number的值，然而并没有什么用处。Python给你提示了一个叫NameError的错误。在第10行，提示了名字‘number’没有定义。

由于number这个变量，它是在函数内部定义的，它只是局限于在函数内使用，所以它叫局部变量，也叫本地变量。既然有局部变量，那相对而言，是不是有全局变量呢？答案是肯定的，它能贯穿全局，可“厉害”着呢。

全局变量(Global Variable)

当你爬上一座高峰，或许能看到一座小城市的整体面貌。这叫一览众山小，说的是一个全局的概念。相对于在函数内定义的变量，在函数外部定义的变量叫全局变量。如果不需要修改这个全局变量的值，那么可以直接引用这个全局变量的值。以下是一个例子：

>>> number2 = 10                  #  定义全局变量
>>> def func2():                  # 定义函数
  number3 = number2 + 10    # 定义局部变量，同时赋值
  print(number3)

  
>>> number2
10
>>> number3

在上面的func2中有两个变量，一个number3是局部变量，一个number2是函数外部的变量，由于不需要修改它的值，所以可以直接引用它的值。如果我们要在函数内部修改number2的值，则要用global申明一下它是全局变量。global 在英文中就是全局的意思，在Python中用它来申明一个变量为全局变量。以下示例修改了number2的值。

>>> number2 = 10               # 定义全局变量
>>> def double():                # 定义函数
  global number2            # 申明number2为全局变量
  number2 = number2 * 2  

  
>>> double()
>>> number2
20
>>>

在上面的第3行是申明number2为全局变量的语句，如果不申明，将会报错，到底会报什么错误，我们来实践一下：

>>> number3 = 0               # 定义全局变量
>>> def double():               # 定义函数 
  number3 = number3 * 2       # 试图修改变量的值

  
>>> double()
Traceback (most recent call last):
  File "<pyshell#86>", line 1, in <module>
    double()
  File "<pyshell#85>", line 2, in double
    number3 = number3 * 2
UnboundLocalError: local variable 'number3' referenced before assignment
>>>

在上面的代码中，定义函数的时候是不会出错的，但是在调用函数的时候出错了，显示的是未绑定的局部错误（UnboundLocalError）。 我们来假设一下，如果number3是本地变量，使用它时应该先定义，而第3行并没有事先定义number3就直接让它乘以2。如果number3是全局变量，第3行试图修改这个全局变量的值，但并没有申明number3为全局变量。

上面的两种假设说明number3即不是本地变量也不是外地变量，就像你到了外地，即不是外地人，也不是本地人一样，这里就产生了矛盾，所以出错是必然的。其实在第3行代码，Python试图把number3当成本地变量，但在使用它时并未赋值，所以显示了local variable ‘number3’ referenced before assignment这行英文(本地变量在赋值前就被引用)。

还有一种情况，那就是在函数内部定义了和外部同名的变量，那么优先使用函数内部的这个变量。请输入以下代码，体验一下这种情况。

>>> number5 = 10           # 定义全局变量
>>> def test1():           # 定义函数test1
  number5 = 20             # 定义局部变量
  print(number5)

  
>>> test1()
20
>>> number5               # number5的值并没有改变
10

上面第9行试图显示number5的值，结果是10,并不是函数内部那个number5的值。这说明函数内定义的number5的确是局部变量，而外部的number5的值丝毫没有改变。

我们应该尽量减少在函数内部使用全局变量。一般情况下，应该使用返回值让函数和它外层代码建立联系。函数是有返回值的，关于返回值的概念，下次再讲解。

nonlocal变量(nonlocal Variable)

前面说了全局变量和本地变量，还有一种特殊的情况，即在函数中又定义了一个函数这种情况。 如果在内部函数中要修改上层那个函数的值的话，那么申明变量的类型应该为nonlocal。先看看下面的例子：

>>> def zsum(x,y):
  z = x + y
  def func():          # 在函数中又定义了一个函数
    nonlocal z   # 申明z为nonlocal变量
    z = z * 2
  func()               # 调用func函数
  print(z)             # 打印z的值

>>> zsum(3,7)
20

在上面的代码中，func函数是在一个函数中所定义的内部函数。它要修改z的值，但是z并不是全局变量，所以不能申明它为全局变量。Python规定要申明它为nonlocal变量才能修改它的值。nonlocal字面意思是非本地的意思。如果不申明z为nonlocal变量，则运行到z = z * 2时肯定会出错。如果直接让z = 2 ，那么不会出错，这是由于Python把它当成func函数内的局部变量了。

模块(Module)

有部可爱的动画片叫《万能阿曼》。讲的是热心助人的阿曼，是小镇上的修理高手，带着他爱讲话万能工具们，什么疑难杂症都难不倒他们。你看，下面的小阿曼提着它的工具箱又要出发了。阿曼的工具箱有好几个呢。针对什么电器坏了，他会带上不一样的工具箱。工具箱里面有很多的工具，有电动工具，有手动工具，有各式各样的镙丝刀，有各式各样的钳子，如尖嘴钳、老虎钳、斜口钳。还有各式各样的扳手，用来拧开或拧紧各种大镙丝。想像一下，如果没有这些工具，万能阿曼可就变成万痴阿曼了啊。

有句话叫工欲善其事，先必利其器。万能阿曼之所以万能，和他能熟悉地使用各种工具是分不开的。在Python编程中，我们也有很多“工具箱”。如果要下载文件，有一个叫request的工具箱。如果要制作游戏有一个叫pygame的工具箱。如果要画图，有一个叫turtle的工具箱。这些工具箱在Python编程中叫模块。它们是由专业的开发人员开发的。要使用这些模块的话，使用命令“import 模块名”就行了，是不是很简单呢。

类和函数(Class and Function)

前面说了万能阿曼可是有很多不同的工具箱。我们就假设它有电动工具箱，手动工具箱，园艺专用工具箱，电脑维修工具箱吧。这里就是一个分类的概念。在Python编程的较高级阶段，我们要学习“类”这个概念，它和我们现实中分类的概念是一致的。在工具箱里可能会有各式各样的起子，它们也是属于一类。每把起子能拧起和它大小匹配的某种镙丝钉。这些起子是早就生产好了的。万能阿曼只要直接使用即可。在Python编程中，也有很多现成的工具，我们只要直接使用它们就行了。这些现成的工具有一个专业的名称为函数。函数的英文名叫function，直译为功能的意思。要编写程序，离不开熟练地使用各种函数。如果你学过scratch，一种儿童编程语言，那么肯定用scratch的各种积木拼搭过很多小作品。下面的两个命令配合重复执行，就能让角色转圈。

这些命令实现了某种功能，它们其实就是函数，而重复执行10次则是一种控制结构。在课程《我的世界》我们使用的基本都是别人制作好的函数或类，这并没有关系。只要实现了目的就行了。有句话叫拿来主义，前人已经编写了很多优秀的函数和类等，除非特别的必要，我们不必去重复地编写它们。Python之所有高效，这和它有众多的模块及各式各样的函数是分不开的。不过，除了熟练掌握工具或许还不太够，如果我们要进行3D编程，那么掌握3D坐标系那可是必需的。

三维坐标系 (Three-dimensional coordinate system)

要学习三维坐标系，先看下二维坐标系。二维就是有两个维度或两个指标来表示位置的意思。这是怎么样的两个指标呢？下面有一只小黄猫，假设我们是在天上朝下看它，所以看到的是俯视图，还假设单位为米。我们来看下面的图示：

	小黄猫扒在一个十字架的中央一动不动的。如果它往前，倒退，左右转弯。它都是在同一个平面上移动。橙色的线条我们称为x轴，蓝色的线条我们称之为z轴。这个时候它在中央，我们称为它在原点。
	如果小黄猫往右转(90度)，前进100，它就到了左边如图所示的位置。这时候我们称它的位置为(100,0)，它在z轴右边。
	如果小黄猫再往左转(90度)，再前进100。这时我们称它的位置为（100，100）。它在z轴右边，并且在x轴上边。
	如果小黄猫再往左拐，前进200，那么它将会到达如左图所示的位置。这个时候它的位置我们记为(-100,100)，为什么小括号里的第一个数是负100呢。这是由于它在蓝色线条，也就是z轴的左边。
	如果小黄猫再往左拐，前进200，那么它将会到达如左图所示的位置。这个时候它的位置我们记为(-100,-100)，为什么小括号里的数都是负100呢。这是由于它不仅在蓝色线条左边，也在橙色线条的下边。
	如果小黄猫再往左拐，前进100，那么它将会到达如左图所示的位置。这个时候它的位置我们记为(0,-100)，为什么小括号里的第一数是0呢。这是由于它离蓝色线条的距离是0。如果它再前进50，你能说出它的位置吗？

上边我们所记的位置叫做坐标。不过这只是记录了小黄猫在平面上的位置，所以这个坐标是二维坐标。它有两个值，第一个值表示到蓝色线条的最短距离，如果在蓝色线条右边，这个数值就是正数。如果在蓝色线条左边，也就是我们说的z轴，这个值就是负数。

坐标中的第二个数值表示小猫到橙色线条，也就我们说的x轴的最短距离。如果小猫在橙色线条的上面，那第二个数值就是正数。如果它在橙色线条的下面，那么第二个数值就是负数。

当小猫在原点的时候，距离x轴和z轴的距离都是零，所以它的坐标是(0,0)。假设它在原点，方向为左，前进了100，这时候它的坐标就是(-100,0)。如果它再倒退200，这时候它的坐标就变成了（100,0）了。

综上所述，描述位置的两个指标是分别到z轴的最短距离和到x轴的最短距离。现在又来了一只小蓝猫。如下图所示，它距离小黄猫头顶上有100米的距离。 那这只小蓝猫的坐标怎么表示呢？

小黄猫距离地面的距离是0，而蓝猫距离地面的距离是100。这时候我们给坐标增加一个数据用来表示这个距离。那么，小黄猫的坐标就是(0,0,0)，而小蓝猫的坐标就是(0,0,100)。最后面的这个100表示是高度，如果它在小黄猫的下面，那么这个值就是负数。我们把这个高度用y来表示，相应的上面的红色线条叫y轴。小括号里面有三个数据了，这就是三维坐标表示法。如果这个时候蓝猫往下降了50米，那么它的坐标是什么呢？如果蓝猫再往前移动100，这时候它的坐标又是多少？

上面的x轴和z轴表示了一个平面，我们把它叫xz平面。在《我的世界》游戏中，史蒂夫就是在这个平面上行走，当然史蒂夫的高度会变化。在游戏中是以z轴正方向为正朝南，x轴正方向为正朝东。当进入游戏后，可以按F3键时，能看到一些信息。如史蒂夫的坐标，它的方向等，如下图所示：

1. 列表切片(List Slice)

   Python中的列表存储的是一系列数据，每个数据都可以通过索引来修改或引用它的值。假设我要取列表中的连续的一片数据，比如索引从1开始到6结束，但不包括索引为6的所有数据，应该怎么操作呢？这可以通过编写代码实现，以下是示例代码：

2. >>> data =[3,2,7,6,8,10,24,76,8]            # 定义列表 
   >>> start = 1                             #  定义起始索引
   >>> end = 6                             #  定义结束索引
   >>> subdata = [ ]                         # 定义空列表
   >>> for index in range(start,end):           # 从start到end迭代index
     subdata.append(data[index])          # 给列表添加数据
   
              
   >>> subdata
   [2, 7, 6, 8, 10]
   >>>
   

   上面的确是一个不错的方法，但是每次取一序列数据都要编写一段代码吗？答案是否定的。Python早为我们准备好了更简洁的语法来获取列表中的一片数据。这叫做切片，对列表进行切片操作，返回的结果也是列表。显然，我们需要知道起始索引和结束索引，就像上面一样，然后把这两个值放在中括号中以冒号隔开。以下是切片语法示例：

3. >>> sub = data[start:end]	 # 取data列表中以start开始，end结束，不包括end索引数据的数据       
   >>> sub		       
   [2, 7, 6, 8, 10]
   >>>
   

   我们看到，结果和我们上面编写的程序运行的结果是一模一样的。以下是图示：

4. 
5. 上图起始索引是1，结束索引是6。如果不写start，那么会默认从零开始，如果不写end，那么会把start后面的所有数据都包括。如果两个都不写，相当于拷贝了列表。我们来实践一下：

6. >>> data =[3,2,7,6,8,10,24,76,8]
   >>> data[:5]                    # 取从索引为0开始到5结束的所有数据(不包括索引为5，下同)
   [3, 2, 7, 6, 8]
   >>> data[5:]                    # 取从索引为5开始的所有数据
   [10, 24, 76, 8]
   >>> data[:]                     # 取从索引为0开始的所有数据
   [3, 2, 7, 6, 8, 10, 24, 76, 8]
   >>>
   

   由于列表中最后一个数据的索引可以写为-1，所以下面的语法也是可以的。

7. >>> data[5:-1]           # 取从索引为5开始到最后一个数据的所有数据
   [10, 24, 76]
   >>> data[:-4]            # 取从0开始到索引为-4的那一序列数据
   [3, 2, 7, 6, 8]
   >>>
   

   如果要取1，3，5，7索引号的这几个数据应该怎么取呢？这也可以通过编写一个程序来实现，当然Python也为我们准备好了语法，接下来先学习步长。

   步长(Step)

8. 步长，就是每步的长度之简称。它的英文为step，就是步骤，步子的意思。我们知道，range可以生成一系列整数。它有步长这个参数，如range(1,10,2)中的2就是步长。它能产生1,3,5,7,9这几个数据。 在这里，每步的长度是2，当我们不写第三个参数的时候，步长默认为1。如果要取列表[3,2,7,6,8,10,24,76,8]中的索引号为奇数的所有数据，我们先来编个程序完成这个要求，请看代码：

9. >>> subdata = []
   >>> data = [3,2,7,6,8,10,24,76,8]
   >>> for index in range(1,8,2):
     subdata.append(data[index])
   
     
   >>> subdata
   [2, 6, 10, 76]
   >>>
   

   当然，Python也为我们准备好了语法，我们只要在切片的时候再加一个参数就行了。这个参数就是步长。上面得出来的结果，我们只要用subdata = data[1:8:2]这句代码就行了。以下是图例：

10. 
11. 上面data[1:8:2]中的2就是步长，像range命令一样，不写它的值它是默认为1的,所以data[1:8:]和data[1:8]的值是一样的。步长一般是正数，它也可以是负数，这时候我们就要倒着取数据，如data[-1:0:-1]，表示从最后一个数据开始，倒着取数据，一直取到索引为0的数据，所以返回的列表是：[8, 76, 24, 10, 8, 6, 7, 2]。看下面两种取法，返回的列表是一样的：

12. >>> data[-1::-1]              # 取从倒数第一个数据开始的所有数据
    [8, 76, 24, 10, 8, 6, 7, 2, 3]
    >>> data[::-1]                # 由于步长为-1，所以也是取从倒数第一个数据开始的所有数据
    [8, 76, 24, 10, 8, 6, 7, 2, 3]
    

    前面说了，如果不写起始索引，那么默认为0，不过那是在步长为正数的情况。如果步长为负数，那么不写起始索引的话，默认是-1。综上所述，列表切片语法图为：

13. 

1. 类的继承(Class Inheritance)

2. 前面我们定义了类，用类生成了对象。对象能接收数据及输出结果。在具体的编程中，主要考虑程序中会有什么对象，如何让对象之间进行数据交互，这是一种叫面向对象编程的方法。要学好这种方法，还要学习另一个非常重要的概念，叫做继承。俗话说，种瓜得瓜，种豆得豆，老鼠儿子会打洞。它们说的都是一种继承的关系。有继承，就会有变异，随着环境的改变，岁月的变迁，老鼠儿孙们可能会不断变异从而形成新的物种。现代计算机语言中，面向对象编程虽然是更加抽象的编程方法，但是我们也没必要想得那么复杂，在海龟画图中我们就不断地和海龟类打交道。由于在Python中类和类之间也会有继承关系，所以通过继承Turtle类，我们可以定义新的类， 让海龟摇身一变成“人”类也是完全有可能的。假设有一个Fruit(水果)类，我们再定义一个Apple类，让它继承自Fruit类，那么Fruit就是它的父类，也称基类或超类，相应的Apple称为Fruit的子类。子类会继承父类的属性和方法，当然也可以定义新的方法，如果子类定义了和父类同名的方法，这叫做重写父类的方法。下面是Fruit类的代码：

3. >>> class Fruit:                  # 定义名为Fruit的类
        def __init__(self,w,c):      # 初始化方法
            self.weight = w          # 设定初始重量
            self.color = c          # 设定初始颜色
        def addweight(self,w):      
            self.weight += w        # 将重量增加w
        def getweight (self):  
            return self.weight     # 返回self的重量
   

   所有的水果都有重量，有颜色，上面的weight属性代表水果的重量，color属性代表水果的颜色。addweight方法能让水果的重量增加，getweight方法用来返回水果的重量。接下来定义一个叫Apple的类，让它继承自Fruit类。

4. >>> class Apple(Fruit):                # 定义名为Apple的类，它继承自Fruit
        def __init__(self,w,c,shape):     # 初始化方法
           Fruit.__init__(self,w,c)       # 首先运行父类的初始化方法
           self.shape = shape             # 新增形状属性，并赋值
        def getshape(self):      
          return self.shape               #  返回形状
   

   上面的第1行代码定义了一个名为Apple(苹果)的类，它继承自Fruit类。语法就是在类的名字后面写上小括号，小括号里写上父类的名字即可。在苹果类的初始化方法中，我们调用了父类的初始化方法，注意，这是必需的，一般是写在初始化方法的第一行。父类的初始化方法对重量和颜色进行了赋值，然后就是第4行代码，它对shape(形状)进行了赋值。

   如果对第4行代码：self.shape = shape比较迷惑的话，首先要知道在self的点后面的名字是我们自定义的属性，这个属性的名称叫shape。而在等于号后面的shape是给这个属性赋的值，它是从方法的参数列表中来的。下面是实例化Apple类时的赋值图。

5. 
6. 第5行代码定义了一个方法，它直接返回对象的形状。由于苹果类继承自水果类，所以它也有addweight方法和getweight方法。注意，实例化苹果类时，它有三个参数。以下是代码：

7. >>> a = Apple(50,"red","circle")         # 实例化一个苹果
   >>> a.addweight(100)                 # 增重100
   >>> print(a.getweight())                # 打印重量
   >>> print(a.getshape())                # 打印形状
   

   类的继承示例一(Inheritance Example one)

8.  上面说了类和类之间有继承的关系，我们学了海龟模块，每个海龟都是通过Turtle类来生成的。那么我们定义的类能不能继承自Turtle类呢？这当然是可以的，假设我们有一些海龟对象，我们并不需要它们画画，并且希望它们的形状都是圆形，那么我们应该把它们归为一类，假设叫Ball，以下是Ball的代码。

9. >>> from turtle import Turtle                          # 从海龟模块导入Turtle类
   >>> class Ball(Turtle):                                # 定义球类，继承自Turtle类
     def __init__(self):
       Turtle.__init__(self,shape='circle')     # 首先调用父类的初始化方法
       self.penup()                        # 由于不需要画画，所以让它抬笔
     def move(self,dx,dy):                       # 定义移动方法
       x = self.xcor() + dx                # 水平坐标增dx
       y = self.ycor() + dy                # 垂直坐标增dy
       self.goto(x,y)                      # 坐标定位
   
       
   >>> ball = Ball()                       #  实例化一个小球
   >>> while True:
     ball.move(1,1)                         # 让小球每次在水平和垂直方向上移动一个单位
   

   由于Ball类是继承自Turtle类，所以它就像Turtle类的亲生儿子一样，继承了海龟所有的方法和属性。在第5 行代码中，由于海龟类的对象默认是落笔的，但我们并不希望它的儿子Ball类画画，所以把它给抬笔了。

   在第6行定义了一个叫move的方法。它的作用是让对象在水平和垂直方向上位移。 第12行代码是生成了一个ball，它不断地调用move方法，每次在水平和垂直方向上都移动1个单位。结果就是运行程序的时候看到一个小球朝右上角移动。通过定义move方法，好像Ball类相对于Turtle类发生了变异一样。

1. 类的继承示例二(Inheritance Example two)

2.  上面我们定义了一个Ball类，它有移动的方法，可是球移动一会儿就不见了。接下来我们定义一个弹球类，让它可以“碰到边缘就反弹”。我们让弹球类继承自球类。重新编写它的move方法实现这个功能。代码如下所示：

3. from turtle import Turtle
   from random import randint
   class Ball(Turtle):    
       def __init__(self):
           Turtle.__init__(self,shape='circle')
           self.penup()
           self.sw = self.screen.window_width()       # 定义sw属性，它的值是屏幕的宽度
           self.sh = self.screen.window_height()       # 定义sh属性，它的值是屏幕的高度        
       def move(self,dx,dy):
           x = self.xcor() + dx
           y = self.ycor() + dy
           self.goto(x,y)	    
   class BounceBall(Ball):                            # 定义BounceBall类，它继承自Ball类  
       def __init__(self):
           Ball.__init__(self)                         # 调用父类的初始化方法
           self.xspeed = randint(-5,5)                 # 设定xspeed属性，代表每次的水平位移 
           self.yspeed = randint(-5,5)                 # 设定yspeed属性，代表每次的垂直位移
       def move(self):        
           x = self.xcor() + self.xspeed                # 对象的x坐标加上水平位移
           y = self.ycor() + self.yspeed                # 对象的y坐标加上垂直位移
           self.goto(x,y)                             # 定位到新的位置
           if x > self.sw//2 or x < -self.sw//2:      # 如果x坐标大于或小于屏幕宽度的一半
               self.xspeed = -self.xspeed              # 水平位移取负
           if y > self.sh//2 or y <  -self.sh//2:      # 如果y坐标大于或小于屏幕高度的一半
               self.yspeed = -self.yspeed              # 垂直位移取负
   ball = BounceBall()
   while True:
       ball.move()       
   

   上面的代码运行的时候，我们能看到一个黑色的小球，它碰到窗口的边框会反弹，这是由于我们在BounceBall类的定义中对move方法进行了重写。我们把小球看成一个点，当小球的坐标大于或等于屏幕宽度的一半的时候，我们让它的xspeed取反，这样它在水平方向上就会朝相反的方向移动了。垂直反弹的原理也是一样的。在这里反弹原理不是重点，重点就是我们可以重新改写父类的方法，并且在有些情况下要先调用父类的同名方法。如果要让一个方法失效，也可以通过改写父类的方法，只要定义同名方法，把它的语句组换成pass就行了。

   通过继承某类，我们不必编写重复的代码，只要把缺少或需要优化的功能重新编写就行了。子类可以重新编写父类的方法，这也叫做方法重载。

1. 类的方法(Class Method)

2. 在学习类的定义当中，我们学习了__init__，它是初始化函数，并且说了在类中定义的函数也叫方法。在类中还能定义其它的方法。如，哺乳动物有走的行为，我们可以定义相应的走的方法。下面我们定义一个叫Animal的类，它有走的方法。

3. >>> class Animal:                       # 定义名为Animal的类
     def __init__(self,weight):      # 实始化方法，有参数名为weight
       self.weight = weight    # 给对象的weight属性赋值为weight
     def walk(self):                 # 设定walk方法
       print("走一步")         # walk方法具体执行的代码 
   
       
   >>> pig = Animal(100)                   # 实例化一个Animal
   >>> pig.walk()                          # 调用pig的walk方法
   走一步
   >>>
   

   上面的第4行代码定义了一个名为walk的方法，它有一个参数名为self,这个参数用来表示实例化后的对象。 第9行调用了这个walk方法，就像调用函数一样，只不过在点号前面写上对象的名称。调用时，self参数会收到对象名，然后执行方法的代码。上面定义的walk太简单了，方法就是函数，它能接收很多参数，接下来我们定义有更多参数的方法。

4. 类的方法示例一(Method Example one)

5. 下面我们定义一个有些实用价值的类，它的名字叫Point。我们用它来代表平面上的点。它有两个属性，分别表示x和y坐标，以下是示例代码：

6. >>> class Point:                    # 定义名为Point的类
        def __init__(self,x,y):        # 初始化方法
              self.x = x               # 设定x坐标
              self.y = y               # 设定y坐标
        def move(self,dx,dy):          #  定义move方法
              self.x = self.x + dx     #  x坐标增加dx
              self.y = self.y + dy     #  y坐标增加dy
   
        def distance(self,other):  
           """计算两点的长度"""
           dx = self.x - other.x
           dy = self.y - other.y
           return (dx * dx + dy * dy ) ** 0.5
   
   
   >>> p = Point(20,20)              # 实例化一个点
   >>> p.move(80,80)                 # 把点的x和y坐标各增加80
   >>> print(p.x,p.y)                # 打印点的坐标
   >>> print(p.distance(Point(0,0))  # 打印p点到原点之间的距离
   

   通过move方法把p点的x和y坐标都增加80，就改变了它的坐标。这个点就像左图这样从(20,20)移到了(100,100)的坐标。

   在第9行定义了一个叫distance(距离)的方法，它是用来计算两个点的距离的。具体的计算代码不懂没有关系，重点在于第10行写上了这个方法的说明。它是用三引号括起来的字符串，这叫文档字符串。最后函数返回了两点之间的距离。在实际的编码中，我们还要判断other参数是不是一个Point类的实例，在这里省略了。如果对第19行不太明白，可以看看下面这张图示：

7. 
8. Point(0,0)用来实例化一个对象。p点的distance方法用来计算它和另一个对象的距离。这个距离最后用print打印出来。

9. 类的方法示例二(Method Example two)

   上面我们定义了一个Point类，它有移动的方法，可是我们看不到这个点的移动过程。如果想让这个点真正的移动起来那多好。这是可以实现的，我们学了海龟画图，可以让它来移动。下面Point类中的初始化方法和移动方法都增加了代码，为的就是有这种可视化效果。代码如下所示：

10. """可移动的点类.py"""
    from turtle import Turtle
    
    class Point:                         # 定义名为Point的类
        def __init__(self,x,y):             # 初始化方法
           self.x = x                    # 设定x坐标
           self.y = y                    # 设定y坐标
           self.t = Turtle(shape='circle')   # 属性t的值是一只海龟
           self.t.color('blue')             # 设定颜色为蓝色
           self.t.penup()                # 抬笔           
               
        def move(self,dx,dy):
           """在水平和垂直方向增加距离"""
           self.x = self.x + dx     #  x坐标增加dx
           self.y = self.y + dy     #  y坐标增加dy
           self.t.goto(self.x,self.y) # 坐标变化后让海龟到达指定位置
    
    p = Point(0,0)
    for i in range(100):
        p.move(1,1)
    

    上面的代码运行的时候，我们能看到一个蓝点慢悠悠地移动。这是由于在初始化函数中给Point类增加了一个属性t，它的值是一个海龟对象。当每次用move方法改变了点的坐标值的时候就用了海龟的goto方法让它到达这个位置。

1. 类的概述(Class Introduce)

2. “小明，去买点水果回来做沙拉吧。”，妈妈对小明说。小明也没有再问，就随便买了些苹果，梨子，桔子之类的水果回来。在这里，水果，就是一个类别。它们有共同的属性，如质量，颜色，价格等。在生活中，很多事物都可以归为一个类别。我们也学过很多数据类型，它们有的是整数，有的是字符串，有的是列表。用type命令就能显示出它们的类别出来。现在让我们复习一下所学过的类别吧。在IDLE里输入type和数据，看看它们是什么类别，下面是示例代码：

3. >>> x = 5
   >>> type(x)                 # 显示x的类别
   <class 'int'>
   >>> string = "Python"
   >>> type(string)             # 显示string的类别
   <class 'str'>
   >>> f = 32.768
   >>> type(f)                  # 显示f的类别
   <class 'float'>
   >>> type([])                 # 显示[ ]的类别
   <class 'list'>
   >>> type(True)              # 显示True的类别
   <class 'bool'>       
   >>>
   >>> from turtle import Turtle  # 从海龟模块导入Turtle类
   >>> t = Turtle()
   >>> type(t)                 # 显示t的类别
   <class 'turtle.Turtle'>
   

   上面的14行以上的都是Python内置的类型，而第16行则是Python自带的海龟模块里面的一个类型，它叫Turtle类。通过Turtle类，我们可以新建一个海龟对象，所新建的海龟都有共同的属性和命令。那么问题来了，这个Turtle类是怎么“制作”出来的？ 当然，它是由一个程序员编写的，以供我们学习编程。要学习编写一个Turtle类超出了我们的学习范围。我们现在学习如何编写一个非常简单的类。

4. 定义类(Define Class)

5. 我们学习过定义函数，用的是def 关键词。如果要定义一个类，则用的是class关键词。最简单的类是这样的：class  Test:pass。这就定义了一个类，它的名字是Test，它的内容是pass，也就是没有内容，但它可是真正能使用的类。用Turtle类生成一只小海龟也叫做实例化一只小海龟，这只小海龟就是生成的一个对象。 刚才我们定义了一个叫Test的类，那么也能用它生成一个对象，用Test()这个命令就行了，当然我们一般给它取个名字，也可以把这个名字叫做t，以下是示例代码：

6. >>> class Test:           #  定义类Test
     pass              #  忽略内容
   
   >>> t = Test()            # 实例化Test
   >>> type(t)               # 查看t的类别
   <class '__main__.Test'>
   >>> 
   

   上面我们用Test类实例化了一个对象，这个对象的名字叫t。用type命令能查看到它的类别。上面的类太简单了，我们可以在类中定义一个叫初始化的函数，当实例化对象的时候，这个函数会马上运行，它会对这个对象进行初始化，这个函数的名字一定要是__init__。下面我们来定义它。

7. >>> class Test:                  # 定义名叫Test的类
      def __init__(self):          # 定义初始化方法
         print("我诞生了。")
   
         
   >>> t = Test()                    # 实例化Test类
   我诞生了。
   >>>  
   

   上面我们定义了初始化函数。需要说明的是，在类中所定义的函数叫方法，它的第一个参数用来表示实例化后的自己，一般用的名称是self(自己)。当实例化的时候，__init__方法就对自己进行初始化。 当然，既然它是函数，也就会有返回值，不过一般初始化方法不用返回数据。函数可不止一个参数，也可能有几个，接下来，我们新建一个叫Point的类，并且给它的初始化方法加了两个参数。以下是代码示例：

8. >>> class Point:                            # 定义名叫Point的类
      def __init__(self,x,y):            # 定义初始化方法 
         self.x = x                      # 设定属性x，赋值为x
         self.y = y                      # 设定属性y，赋值为y
        	    
   >>> p = Point(10,10)                        # 实例化一个点，x值是10,y值也是10
   >>> print(p.x)                              # 打印p.x的值              
   10
   >>> print(p.y)                              # 打印p.y的值
   10
   >>> p.z = 20                                # 新增一个属性叫z，并赋值
   >>> print(p.z)
   20
   >>>
   

   point在英文中是点的意思，在这里我们用它来代表一个平面坐标点。所有的坐标点都有共同的属性，如x坐标，y坐标。我们定义的Point类就是用来代表坐标点的，注意它的第一个字母为大写，这是一种约定俗成的写法。 Point类的初始化方法里有三个参数，self代表实例化后的自己，x用来代表x坐标的初始值，y用来代表y坐标的初始值。这是我们的一种设定，这三个参数分别用a,b,c理论上也是没有任何问题的。

   第三句代码是self.x = x，我们用它来表示这个点初始化后的x坐标的值是x。self.y = y设定了这个坐标点的y值。 下面是p点实例化时的赋值图：

9. 
10. 上面在初始化方法中用点号给对象增加了两个变量，它们叫做属性。如果要修改它们的值的话，直接用点号操作符，让它等于某个值就可以了。我们在类之外也可以直接给对象增加属性，如可以写p.z = 20，这样p点又增加了一个属性了。综上所述，定义类的语法是首先用关键词class，然后加空格，接着写上类的名字，这个名字的第一个字母应该用大写，最后就是冒号。通常情况下，我们会定义__init__方法。以下是类的定义示例图：
11. 
12. 定义类，和定义函数相似之处在于，这都是我们的一种设计。类就相当于对象的蓝图或模版，它就像一座工厂，不过它能实例化很多对象。现在我们编写程序，或许先要考虑一下，在程序中会出现什么对象，然后这些对象会有什么共同的性质或行为，然后思考如何把它们定义成一个类。

13. 练习

14. 下列代码在IDLE中是什么操作？有什么问题吗？

15. >>> class fruit
            pass
    

    说说下列IDLE中每行代码的意思。

16. >>> class Python:
          def __init__(self,length):
            self.length = length
            print("我的长度是：",self.length)
      
        
    >>> snake = Python(100)
    我的长度是： 100
    >>> snake.length = 200
    >>> snake.weight = 300
    >>>
    
    

    • 阅读下列代码，说出每行代码的意思，它的运行结果是什么，代码有什么问题?

    • >>> import random
      >>> class random:
        def __init__(self,x):
          self.x = x * 2
          
      >>> r = random(10)
      >>> print(r.x)
      >>> random.randint(10,20)