适合Python使用的开发环境

最后更新于：2022-04-01 21:47:51

## Eclipse+ Python的安装与配置 【关键字】：Python 集成开发环境 Eclipse PyDev 在前面的系列教程中就提到过，当编写的程序越来越复杂时，就需要分多个文件来进行代码的管理。在涉及到多文件时，简单的内置编辑环境IDLE就显得太单薄了，怎么办呢？ 不用担心，其实有很多的编程工具软件—集成开发环境（IDE）软件，可以完成这样的工作，有免费开源的，当然也有收费的，在不同的操作系统平台会有不同特色的软件，也有同一款软件，跨不同的平台都有相应的版本。 这里主要介绍在windows平台下，Eclipse的安装及使用。 1. Eclipse简介 Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。 虽然大多数用户很乐于将 Eclipse 当作 Java 集成开发环境（IDE）来使用，但 Eclipse 的目标却不仅限于此。Eclipse 还包括插件开发环境（Plug-in Development Environment，PDE），这个组件主要针对希望扩展 Eclipse 的软件开发人员，因为它允许他们构建与 Eclipse 环境无缝集成的工具。由于 Eclipse 中的每样东西都是插件，对于给 Eclipse 提供插件，以及给用户提供一致和统一的集成开发环境而言，所有工具开发人员都具有同等的发挥场所。 这种平等和一致性并不仅限于 Java 开发工具。尽管 Eclipse 是使用Java语言开发的，但它的用途并不限于 Java 语言；例如，支持诸如Python，C/C++、COBOL、PHP等编程语言的插件已经可用，或预计将会推出。Eclipse 框架还可用来作为与软件开发无关的其他应用程序类型的基础，比如内容管理系统。 2.  集成开发环境 集成开发环境（Integrated Development Environment，简称 IDE，也有人称为Integration Design Environment、Integration Debugging Environment）是一种辅助程序开发人员开发软件的应用软件。    IDE通常包括编程语言编辑器、编译器／解释器、自动建立工具、通常还包括调试器。有时还会包含版本控制系统和一些可以设计图形用户界面的工具。许多支持面向对象的现代化IDE还包括了类别浏览器、物件检视器、物件结构图。虽然目前有一些IDE支持多种编程语言（例如Eclipse、NetBeans、MicrosoftVisual Studio），但是一般而言，IDE主要还是针对特定的编程语言而量身打造（例如Visual Basic）。 3.  安装Eclipse 1)  Eclipse的安装很简单，只需在其官网上下载并安装即可，网址是：[www.eclipse.org](http://www.eclipse.org)，但是由于Eclipse是基于JAVA的一个开发环境，必须要下载一个JAVA的运行环境，也就是JRE，JRE的下载地址:[http://www.java.com/en/download/manual.jsp](http://www.java.com/en/download/manual.jsp)，进入之后大家自行选择版本就行了，但是要注意区分32bit和64bit版本。 2)  在下载完这些之后还需要下载Python，由于之前已经向大家介绍过的Python的下载及安装方法，这里就不再详细说明了。 3)  接下来就是Pydev的下载。什么是Pydev呢？它就是专门为Python设计的Eclipse Python IDE插件。 首先先启动Eclipse，会出现如下界面： ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/b7e1f7febeb7780d1648e71b9a9d1c14_866x476.jpg) 点击软件上方的Help-Install New Software, 点击Add选项，Name：随便取（例如Pydev），Location：[http://pydev.org/updates](http://pydev.org/updates)，点击OK。如图： ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/625d58a6113e4003a7989c85eeacc2bb_866x685.jpg) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/46704be790928baceb3eb17884e81c9f_866x616.jpg) 之后会出现PyDev的选项，只需要选择PyDev for Eclipse，其他的都不用选。选择之后点下一步，然后下一步安装，然后会让大家填一大堆信不信任的，大家就都填是就好了。 4)  配置PyDev 先重启Eclipse，然后点击软件上方的Window-Preferences，接着点击PyDev—InterpreterPython—New，如图： 之后填上解释器名称和路径，根据自己情况而定，并选择相应路径的python.exe，如图： ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/f0d18b554d667253197a360821b0b927_866x394.jpg) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/b32fd663f8dc751c80ff363739440128_866x676.jpg) 之后大家就selectall就行了。 4．测试 在安装完之后，我们需要测试一下安装的成不成功，点击软件上方的File—New—Project，然后选择PyDev project，如图： ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/ed1fdf91cb55ba1db4b18751524c24f1_820x835.jpg) 之后Project Name随便填一个，然后Grammar Version和Interpreter填相应的版本，然后Finish。如图： ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/446682a705d561402ded80b93e89dbbc_817x1135.jpg)
';

Python程序调试的一些体会

最后更新于：2022-04-01 21:47:49

程序不可能没有bug即便是最顶级的程序员，而且越专业的程序员就越会花时间去调试自己写的程序以求达到完美。那么接下来就像大家介绍一下常见的错误以及调试方法。 常见问题： 1.      缩进问题 这应该是我提到过最多次的问题，只要是一个小小的缩进问题都会导致程序的错误以及无法运行，可见缩进的重要性。 2.      变量类型问题 大家都知道变量有很多类型：int，string，float…但是在写程序中如果错误的表示了变量的类型，很有可能会导致输出结果的错误，或者是程序的无法运行，因为有些语句和函数需要特定的变量类型的参与。 3.      循环边界问题 在写循环语句时候，我们常常会用到range等函数，但是这就出现了一个问题：循环最终到底会在哪里停止，如果考虑不当的话，很可能会导致循环的次数错误，甚至一直无限进行。 4.      局部变量问题 在定义完一个函数，并在函数内书写代码的时候，我们会定义一些变量，但是有时候我们会把函数外的变量直接拿到函数内使用，或者把函数内的变量拿出使用，这就犯了局部变量和全局变量混淆的问题，这种问题一般会导致变量没有被定义的问题。 5.      情况遗漏问题 在处理一些十分复杂的问题，例如上面的24点的问题时，我们有时候可能会遗漏一些可能的情况，这种问题往往不会明显的表现出错误，但是它会导致程序的适应性不高，有可能在一些特殊的情况下无法运行。 调试方法      目前我最常用的调试方法就是在程序中多加一些print语句。通过print语句，我们可以知道每个部分代码所输出的结果，从而在产生错误后，更加容易的找出程序中出现错误的部分在哪里，而不用重新去看整个代码，从而大大节省了时间。在调试完之后我们可以把print语句注释掉以便以后使用（因为有可能不只一个错误）。 验证方法 在把所有表面上的错误解决之后，为了更加深入的增加程序的适应性，我们就需要用一些方法来验证程序。举个例：之前的24点问题，我为了验证数字的调换不会影响最终的结果（例如1347和3174所产生的24点的组合个数是一样的），我带入了许多值进行运算来验证这个程序，甚至把所有的四个数的组合输入到程序中来验证程序的适应性，试图把程序写到完美。还有就是大家可以带入一些特殊值来测试程序边界情况的运行情况。最后我希望大家记住任何程序都可以有改进的空间，大家不要认为写完代码之后就完成了整个程序，其实连50%都不到！ 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

十四、Python编程计算24点（之二）

最后更新于：2022-04-01 21:47:46

## 十、Python编程计算24点（之二） ----From a high school student's view to learnPython 关键字： python 高中生学编程 Python编程入门 计算24点表达式计算 组合问题 三、程序实现 说完了该列举的问题，接下来就是程序的书写部分了，现在我们要回忆之前学的一系列知识，包括函数，列表，循环等等。首先我们来解决组合的书写问题，因为有四个数，我们便可以把这四个数归到同一个列表中，然后再通过调用来运用，但是在这里我们需要创造两个列表，一个是函数里的列表，另一个是函数外引入的参数，因为是要写组合，所以我们就应该将引入的参数分别的赋值给我们在函数内新建的列表，然后再在之后的程序中使用已被赋值的列表。

1

2

3

4

5

   a=[99,99,99,99]

   for i1 inrange(3):

       ifi1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       ifi1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       ifi1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

a就是我们新建的列表，其实列表里的元素随便是什么都可以，只要有四个，因为会被替换掉，接下来就需要用一个循环来解决组合问题。由于有三种情况，所以我们可以用一个三个条件的循环，分别是(ab)(cd) ，(ac) (bd) ，(ad) (bc) 然后再对range函数进行for语句循环操作。这里要注意的一点是：range中是从0开始计算，而且结尾应是前一个数，所以是以3结尾。这样我们就成功的写出了循环的组合语句，我们就不用再在之后的程序中浪费时间重复操作了。 四选三的组合语句也差不多，如下

1

2

3

4

5

6

7

   a=[99,99,99,99]

   sign=['+','-']

   for i1 inrange(4):

       ifi1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       ifi1==1:a[0]=c[0];a[1]=c[1];a[2]=c[3];a[3]=c[2]

       ifi1==2:a[0]=c[0];a[1]=c[2];a[2]=c[3];a[3]=c[1]

       ifi1==3:a[0]=c[1];a[1]=c[2];a[2]=c[3];a[3]=c[0]

接下来我们就要进行枚举各种情况了，但是在枚举前，我们应该再思考一下到底有什么地方可以在进行简化。仔细观察前面列的所有情况，我们可以发现含有+-这两个符号的式子很多，有些式子甚至含有两对到三对，但是如果我们一一去列举所有的情况，未免太复杂：+++，++-，+--，+-+，-++，-+-，--+，---一共八种，也就是说我们要为了之一种简单的情况写八遍差不多的代码，那我们为什么不做一个甚至多重的for循环呢？

1

2

3

4

   sign=['+','-']

    fori2 in sign:

          for i3 insign:

              fori4 in sign:

首先建立一个列表（line1）然后再做一个三重循环，当然这里的循环次数和式子中+-的个数要保持一致。但是为什么*/不用for循环来做呢，因为我们发现其实(c*/d)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

   num4list=[]

   a=[99,99,99,99]

   for i1 inrange(3):

       ifi1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       ifi1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       ifi1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

          

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[2])+'*'+str(a[3])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[0])+'*'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[0])+'/'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[1])+'/'+str(a[0])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[2])+'/'+str(a[3])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[3])+'/'+str(a[2])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'*'+'('+str(a[2])+'/'+str(a[3])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'*'+'('+str(a[3])+'/'+str(a[2])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'*'+'('+str(a[0])+'/'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'*'+'('+str(a[1])+'/'+str(a[0])+')')

看起来很复杂，其实找到规律之后就十分容易了，由于/的符号有顺序一说（a/b和b/a的不同）所以我们需要调换顺序，然后依照规律，我们就可以列出一共10种不同的情况。要注意的是，如果不是str()函数，则需要用双引号来表示字符串的意义。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

     num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[2])+'*'+str(a[3]))

     num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[2])+'/'+str(a[3]))

     num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[3])+'/'+str(a[2]))

     num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[2])+'*'+str(a[3]))

     num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[2])+'*'+str(a[3]))

     num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[2])+'/'+str(a[3]))

     num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[2])+'/'+str(a[3]))

     num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[3])+'/'+str(a[2]))

     num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[3])+'/'+str(a[2]))

     num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[2])+'*'+str(a[3]))

     num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[0])+'*'+str(a[1]))

     num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[2])+'/'+str(a[3]))

     num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[3])+'/'+str(a[2]))

     num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[0])+'/'+str(a[1]))

     num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[1])+'/'+str(a[0]))

这种情况就是a*/b+-c*/d，由于ab和cd之间都有除号，所以这两个字母都需要调换顺序，而且因为中间的符号有减号，所以我们还需要将前两个数字和后两个数字调换顺序来满足所有的情况。而由于只里面只有一个+-所以并不需要用循环来简化，只需枚举即可。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

   num3list=[]

   sign=['+','-']

   a=[99,99,99,99]

   for i1 inrange(3):

       ifi1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       ifi1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       ifi1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

       for i2in sign:

          for i3 insign:

              fori4 in sign:

                 ifi2=='+':

                    i2=''

                num3list.append(i2+'('+str(a[0])+i3+str(a[1])+')'+'*'+'('+str(a[2])+i4+str(a[3])+')')

                num3list.append(i2+'('+str(a[0])+i3+str(a[1])+')'+'/'+'('+str(a[2])+i4+str(a[3])+')')

                num3list.append(i2+'('+str(a[2])+i3+str(a[3])+')'+'/'+'('+str(a[0])+i4+str(a[1])+')')

这是(a+-b)*/(c+-d)的情况，要注意的是，在这几行代码中我们用到了一个三重循环，而+-只有两种，原因是我们在括号的最前面又加了一个符号，仔细观察，我们可以发现这个符号是对第一个括号内的正负进行的判定，因为在第一个括号内会出现a与b调换的情况，而且我们发现第一个括号内会出现答案是负数的情况，但是不要忘了，在第二个括号内的情况和第一个括号内的情况是完全相同的，所以第二个括号内也会出现负数的情况，当第一和第二个括号内的结果均为负数时，就又变成了正数（中间是*/），所以我们并不用在每个括号前加一个符号，取而代之的是在整个式子之前加正负号就可以了。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

   num4list=[]

   a=[99,99,99,99]

    for i1 inrange(3):

       if i1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       if i1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       if i1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

          

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[2])+'*'+str(a[3])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[0])+'*'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[0])+'/'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'/'+'('+str(a[1])+'/'+str(a[0])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[2])+'/'+str(a[3])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'/'+'('+str(a[3])+'/'+str(a[2])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'*'+'('+str(a[2])+'/'+str(a[3])+')')

      num4list.append('('+str(a[0])+'*'+str(a[1])+')'+'*'+'('+str(a[3])+'/'+str(a[2])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'*'+'('+str(a[0])+'/'+str(a[1])+')')

      num4list.append('('+str(a[2])+'*'+str(a[3])+')'+'*'+'('+str(a[1])+'/'+str(a[0])+')')

这是(a*/b)*/(c*/d)的情况，大家如果观察可以发现第一个括号内并没有/的情况，这是因为如果第一个括号内的符号是/，两个括号中间的符号必须是*，否则答案不可能是24，但是如果中间的符号是*，就没必要考虑两个括号的摆放顺序的问题了，所以我索性让第一个括号的符号均为*，看起来也比较整齐。其它的步骤还是和前几个差不多，调换/两端元素的位置，找到规律之后十分简单。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

      num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[2])+'*'+str(a[3]))

      num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[2])+'/'+str(a[3]))

      num4list.append(str(a[0])+'*'+str(a[1])+'+'+str(a[3])+'/'+str(a[2]))

      num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[2])+'*'+str(a[3]))

      num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[2])+'*'+str(a[3]))

      num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[2])+'/'+str(a[3]))

      num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[2])+'/'+str(a[3]))

      num4list.append(str(a[0])+'/'+str(a[1])+'+'+str(a[3])+'/'+str(a[2]))

      num4list.append(str(a[1])+'/'+str(a[0])+'+'+str(a[3])+'/'+str(a[2]))

      num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[2])+'*'+str(a[3]))

      num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[0])+'*'+str(a[1]))

      num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[2])+'/'+str(a[3]))

      num4list.append(str(a[0])+'*'+str(a[1])+'-'+str(a[3])+'/'+str(a[2]))

      num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[0])+'/'+str(a[1]))

      num4list.append(str(a[2])+'*'+str(a[3])+'-'+str(a[1])+'/'+str(a[0]))

这种情况就是a*/b+-c*/d，由于也是两个数字一组的情况，之前的组合代码和上一种情况相同，所以我就索性将两种情况合并在一起，节省了很多时间，但是要注意的是这种情况包含两个*/和一个+-，所以情况比较多，但是/-/的情况显然不可能所以排除，大家要注意不要遗漏或者重复。 接下来就是三个一组的情况：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15


   num5list=[]

   a=[99,99,99,99]

   sign=['+','-']

   for i1 inrange(4):

       ifi1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       ifi1==1:a[0]=c[0];a[1]=c[1];a[2]=c[3];a[3]=c[2]

       ifi1==2:a[0]=c[0];a[1]=c[2];a[2]=c[3];a[3]=c[1]

       ifi1==3:a[0]=c[1];a[1]=c[2];a[2]=c[3];a[3]=c[0]

       for i2in sign:

          for i3 insign:

              fori4 in sign:

                 ifi2=='+':

                    i2=''

                num5list.append('('+i2+str(a[0])+i3+str(a[1])+i4+str(a[2])+')'+'*'+str(a[3]))

                num5list.append('('+i2+str(a[0])+i3+str(a[1])+i4+str(a[2])+')'+'/'+str(a[3]))

(a+-b+-c)*/d由于是三个一组的情况，之前在组合问题中说过有四种情况，而且由于前两个符号都是+-，而我又在第一个数字前加了一个符号来避免调换顺序，我们可以用一个三重循环来解决重复书写的问题，和之前介绍过的技巧一样。同样大家也要注意第一个符号是+的情况是无意义的，所以要把它去掉（line12-line13）。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

   num6list=[]

   a=[99,99,99,99]

   sign=['+','-']

    for i1 inrange(4):

       if i1==0: a[0]=c[0]; a[1]=c[1]; a[2]=c[2];a[3]=c[3]

       if i1==1: a[0]=c[0]; a[1]=c[1]; a[2]=c[3];a[3]=c[2]

       if i1==2: a[0]=c[0]; a[1]=c[2]; a[2]=c[3];a[3]=c[1]

       if i1==3: a[0]=c[1]; a[1]=c[2]; a[2]=c[3];a[3]=c[0]

       for i2 in sign:

          num6list.append(str(a[0])+'*'+str(a[1])+'*'+str(a[2])+i2+str(a[3]))

          num6list.append(str(a[0])+'*'+str(a[1])+'/'+str(a[2])+i2+str(a[3]))

          num6list.append(str(a[0])+'*'+str(a[2])+'/'+str(a[1])+i2+str(a[3]))

          num6list.append(str(a[2])+'*'+str(a[1])+'/'+str(a[0])+i2+str(a[3]))

           for i3 insign:

                 if i2=='-' and i3=='-':

                    continue

                 if i3=='+':

                    i3=''

                num6list.append('('+i3+str(a[0])+i2+str(a[1])+'*'+str(a[2])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[0])+i2+str(a[1])+'/'+str(a[2])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[0])+i2+str(a[2])+'/'+str(a[1])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[0])+i2+str(a[1])+'*'+str(a[2])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[0])+i2+str(a[1])+'/'+str(a[2])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[0])+i2+str(a[2])+'/'+str(a[1])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[0])+'*'+str(a[2])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[0])+'/'+str(a[2])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[2])+'/'+str(a[0])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[0])+'*'+str(a[2])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[0])+'/'+str(a[2])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[1])+i2+str(a[2])+'/'+str(a[0])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[1])+'*'+str(a[0])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[1])+'/'+str(a[0])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[0])+'/'+str(a[1])+')'+'*'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[1])+'*'+str(a[0])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[1])+'/'+str(a[0])+')'+'/'+str(a[3]))

                num6list.append('('+i3+str(a[2])+i2+str(a[0])+'/'+str(a[1])+')'+'/'+str(a[3]))

                num6list.append(i3+str(a[3])+'/'+'('+str(a[0])+i2+str(a[1])+'*'+str(a[2])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[0])+i2+str(a[2])+'/'+str(a[1])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[0])+i2+str(a[1])+'/'+str(a[2])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[1])+i2+str(a[0])+'*'+str(a[2])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[1])+i2+str(a[0])+'/'+str(a[2])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[1])+i2+str(a[2])+'/'+str(a[0])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[2])+i2+str(a[1])+'*'+str(a[0])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[2])+i2+str(a[1])+'/'+str(a[0])+')')

                num6list.append(i3+str(a[3])+'/'+'('+str(a[2])+i2+str(a[0])+'/'+str(a[1])+')')

接下来这个是a*/b*/c+-d和(a+-b*/c)*/d的两种情况的合并，由于这两种都是三个一组的情况，合并可以少些很多重复的代码，但是要注意的是，这两种情况并不是在最后合并，它们各自的前提条件的代码有所区别。因为第一个式子中只有一个+-，而第二个式子中有两个（式子最前要加一个符号），所以所进行的循环操作的次数是不一样的，但是我们仍然可以把它们合并在一起，只需在第一个循环操作结束后直接输出第一个式子的结果，把它们加入到列表中，然后再进行下两个循环操作就可以了。但是对于第二个式子，我们要注意的是在括号之后的符号有/，所以就不可避免的要调换位置，但是再调换位置之后会出现代码不整齐的情况，影响美观，所以我们不妨把这一类单分出来放在最下面。

1

2

3

4

5

6

7

8

9

10

   num7list=[]

   a=[99,99,99,99]

   a[0]=c[0]

   a[1]=c[1]

   a[2]=c[2]

   a[3]=c[3]

   num7list.append(str(a[0])+'*'+str(a[1])+'*'+str(a[2])+'/'+str(a[3]))

   num7list.append(str(a[3])+'*'+str(a[1])+'*'+str(a[2])+'/'+str(a[0]))

   num7list.append(str(a[0])+'*'+str(a[3])+'*'+str(a[2])+'/'+str(a[1]))

   num7list.append(str(a[0])+'*'+str(a[1])+'*'+str(a[3])+'/'+str(a[2]))

这种就是a*/b*/c*/d的情况，但是由于一乘两除或者三个除号的情况是不可能形成24的，所以我们这里只考虑两乘一除的情况，由于没有+-，我们就不需要组合的代码，只需将c列表中的元素赋值给a列表中的每个元素即可。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

   num8list=[]

   a=[99,99,99,99]

   sign=['+','-']

    for i1 inrange(6):

       if i1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       if i1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       if i1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

       if i1==3:a[0]=c[2];a[1]=c[3];a[2]=c[0];a[3]=c[1]

       if i1==4:a[0]=c[1];a[1]=c[3];a[2]=c[0];a[3]=c[2]

       if i1==5:a[0]=c[1];a[1]=c[2];a[2]=c[0];a[3]=c[3]

       for i2 in sign:

           for i3 insign:

              if i2=='-' andi3=='-':

                 continue

              if i2=='+':

                 i2=''

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[2])+'+'+str(a[3]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[3])+'+'+str(a[2]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[2])+'-'+str(a[3]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[3])+'-'+str(a[2]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'/'+str(a[2])+'+'+str(a[3]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'/'+str(a[3])+'+'+str(a[2]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'/'+str(a[2])+'-'+str(a[3]))

             num8list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'/'+str(a[3])+'-'+str(a[2]))


   num10list=[]

   a=[99,99,99,99]

   sign=['+','-']

    for i1 inrange(6):

       if i1==0:a[0]=c[0];a[1]=c[1];a[2]=c[2];a[3]=c[3]

       if i1==1:a[0]=c[0];a[1]=c[2];a[2]=c[1];a[3]=c[3]

       if i1==2:a[0]=c[0];a[1]=c[3];a[2]=c[1];a[3]=c[2]

       if i1==3:a[0]=c[2];a[1]=c[3];a[2]=c[0];a[3]=c[1]

       if i1==4:a[0]=c[1];a[1]=c[3];a[2]=c[0];a[3]=c[2]

       if i1==5:a[0]=c[1];a[1]=c[2];a[2]=c[0];a[3]=c[3]

       for i2 in sign:

           for i3 insign:

              if i2=='-' andi3=='-':

                 continue

              if i2=='+':

                 i2=''

             num10list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[2])+'*'+str(a[3]))

             num10list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'/'+str(a[2])+'*'+str(a[3]))

             num10list.append('('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[2])+'/'+str(a[3]))

             num10list.append(str(a[2])+'/'+'('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[3]))

             num10list.append(str(a[3])+'/'+'('+i2+str(a[0])+i3+str(a[1])+')'+'*'+str(a[2]))


接下来的这两种情况就是最复杂的组合情况了，(a+-b)*/c+-d和(a+-b)*/c*/d这两种情况下的组合，由于这两种情况下用六种的组合情况可以少写一些代码，并且更加简单，我们不妨把三种的组合代码改为六种。  到此为止，我们就把所有的组合的情况都列了出来，但是还有一些后续的程序来保证程序的运行和美观。第一就是我们应该把每一种情况的代码都写入到一个函数中，这样如果我们以后要用到的话，直接调用函数就能解决问题，第二就是我们还应该把所有的情况都加在一起，因为验证的时候要用到的是所有的情况，而把它们合并到一个大函数中就不用一个一个调用了。 四、如何利用之前的函数来进行计算 由于我们的程序越做越大，如果我们还把所有的函数，代码都放在一个模块中，显然是十分的复杂以及不方便，这时我们就要把代码写入不同的文件中，但是最后运行的时候，每个文件都需要被运行，那们我们怎么达成呢？这时我们就要用到import语句了，import语句的主要作用就是将多个文件引入到一个文件中，从而在运行一个文件时，其他的文件也能够被运行。 import语句的语法： import 语句的模块顺序 我们推荐所有的模块在 Python 模块的开头部分导入。而且好按照这样的顺序: Python 标准库模块  Python 第三方模块 应用程序自定义模块  然后使用一个空行分割这三类模块的导入语句。 这将确保模块使用固定的习惯导入, 有助于减 少每个模块需要的import 语句数目。 其他的提示请参考《 Python 风格指南》（Python’s Style Guide）,PEP8 fromtransitionimport* fromexcercise4importbiglist  fromdisorderimportchange_order fromexcercise1importcirculate 这就是我用到的几个import语句。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

十三、Python编程计算24点（之一）

最后更新于：2022-04-01 21:47:44

## 十、Python编程计算24点（之一） ----From a high school student's view to learnPython 关键字： python 高中生学编程 Python编程入门 计算24点表达式计算 组合问题 一、问题介绍 对于1-9中任意取出的四个数，找出这四个数组成的所有四则运算表达式，然后从这些表达式中挑出计算结果为24的表达式；对于表达式，不能够重复，如： (1+2+3)*4与(2+1+3)*4只是加法的顺序有些变化，所以只能够算一种。 组合问题、表达式计算的问题在前面的两篇中都进行了详细的介绍，所以，本篇的问题关键就是如何枚举出4个数的表达式组合。 在解决问题之前，提供一个链接，[点此进入](http://www.zhongguosou.com/game_lookup_tools/game_24_point.html)。在网页上输入任意的四个数，就可以列出所有组合，但结果有很多我们在上面所说的重复的情况： [![十三、Python编程计算24点（之一）](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "十三、Python编程计算24点（之一）")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101eukc&url=http://album.sina.com.cn/pic/d6cca93egx6DdBi4IhU26&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/1728f24bb0b33da154e8469145305ca1_415x233.jpg) 如果你输入1 2 34，给出的答案估计有242个，但绝大多数都是顺序变化，再通过加入完全没有必要的()，重复的结果。 所以我们的目的是给出简洁的结果。 二、问题分析 我们将问题分成几种情况来进行讨论，由简到繁： 1、没有括号的表达式 这是最简单的情况，分为两类 加减组合以及全×： -a+-b+-c+-d and a×b×c×d --- 16 这这情况和数的排列顺序没有关系，全减和全除被排除，因为不可能生成24点 2、两个数分组的表达式 这种情况我们处理类似以下的几种类别： (a×b)/(c×/d) (a*/b)+-(c*/d) (a+-b)*/(c+-d) 对于这类分组，我们首先必须清楚一个问题：四个数中两两组合的种类。 四个数中取两个数的组合这很好算，4(2)=4*3/(1*2)=6: ab ac ad bc bd cd 那么两两组合有几种呢，答案是3 (ab) (cd) (ac) (bd) (ad) (bc) 在明确了这个分类之后，对于上面我们列举的几种情况分别处理时就比较简单了，需要注意的是： 1）.分组内【形如(ab)】、组间【形如(ab)与(cd)】的+*是没有顺序但-/是有顺序的，对于有顺序要求的需要处理(ab)(ba)两种情况，注意不要出现重复的情况。 由于我们将数字进行了组合分类，我们只需处理每一类的情况，其余的分类就可以设计循环来处理，每一次的循环我们只是将abcd赋予了不同的数字，这个需要理解清楚。 2）. 分组内(ab) (cd)两个部分中间的符号若是+*，则只有一种情况，但若是-/，则有(ab) (cd) 和(cd) (ab)两种情况，所以要分类讨论。 3、取3个数分组的表达式 这种情况我们处理类似以下的几种类别： (a+-b+-c)*/d    ① a*b*c/d        ② (a+-b*/c)*/d    ③ d/(a+-b*/c)     ④ a*/b*/c+-d 四个数中取三个数的组合是C4(3)=4，但是涉及③④的需要考虑顺序。 同样，我们对于四种组合，只需要处理一种情况，其余的情况由循环来进行处理，每一次的循环abcd的值不同。 尤其针对③④的情况，对于每一组abcd，例如：在处理(a+b/c)/d的情况时，我们只需处理(a+b/c)/d和(a+c/d)/d以及d/(a+b/c)和d/(a+c/d)，其他的情况都将用循环来自动处理 4、情况四a*/b+-c+-d  (a+-b)c*/d  这种情况其实和第二种情况差不多，但是我们为什么又要把它分到另外的一种情况内呢？这又回归上面所说的四个数中两两选择的问题，原先我们认为只有三种，是因为不用考虑重复的情况，但是这种情况下，(ab)(cd) 与 (cd)(ab)是两种不同的情况，我们来举个例子，a*/b+-c+-d与c*/d+-a+-b明显是两种不同结果的组合，所以组合就从三种变为了两种 5、情况五a*b*c/d  这种情况因为十分简单所以就不用利用组合来实现，直接枚举法就可以。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [六、Python的程序流程](http://blog.sina.com.cn/s/blog_d6cca93e0101ejeg.html)(2013-09-19 16:53:58) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

十二、Python简单数据结构应用（之…

最后更新于：2022-04-01 21:47:42

## 十、Python语言中简单数据结构的应用（之二） ----From a high schoolstudent's view to learn Python 关键字： python 列表 堆栈 数据结构 递归调用 函数 组合问题 后缀表达式 前缀表达式逆波兰表达式 运算符 优先级 四、利用堆栈编程实现复杂的四则运算 本部分使用堆栈将表达式转换为后缀表达式，并计算表达式的值，表达式为四则运算表达式。 ***Postfix notation***is an unambiguous way of writing an arithmetic expres- sion withoutparentheses. It is defined so that if“(*exp*1)**op**(*exp*2)”is a normal, fully parenthesized expression whose operation is**op**, the postfix version of this is“*pexp*1*pexp*2**op**”, where*pexp*1is the postfix version of*exp*1and*pexp*2is the postfix version of*exp*2.The postfix version of a sin- gle number or variable is just thatnumber or variable. For example, the postfix version of“((5+2)∗(8−3))/4”is “5 2 + 8 3 −∗4 /”. Describe a nonrecursiveway of evaluating an expression in postfix notation. 这是《Data Structures andAlgorithms in Python》书中堆栈的一道练习P252. 以下关于后缀表达式的详细说明(参考baidu) 1、概述 不包含括号，[运算符](http://baike.baidu.com/view/425996.htm)放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则，如：(2+ 1) * 3 ， 即2 1 + 3 * 2、计算 运用后缀表达式进行计算的具体做法： 建立一个栈S 。从左到右读后缀表达式，如果读到[操作数](http://baike.baidu.com/view/420846.htm)就将它压入栈S中，如果读到n元运算符(即需要参数个数为n的运算符)则取出由栈顶向下的n项按操作符运算，再将运算的结果代替原栈顶的n项，压入栈S中。如果后缀表达式未读完，则重复上面过程，最后输出栈顶的数值则为结束。 3、转换 计算机实现转换： 将中缀表达式转换为后缀表达式的算法思想： ·开始扫描； ·数字时，加入后缀表达式； ·运算符： 1. 若为 '('，入栈； 1. 若为')'，则依次把栈中的的运算符加入后缀表达式中，直到出现'('，从栈中删除'(' ； 1. 若为 除括号外的其他[运算符](http://baike.baidu.com/view/425996.htm)，当其优先级高于栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的[运算符优先级](http://baike.baidu.com/view/262524.htm)高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。 ·当扫描的中缀表达式结束时，栈中的的所有运算符[出栈](http://baike.baidu.com/view/346791.htm)； 4、人工实现转换 这里给出一个中缀表达式：a+b*c-(d+e) 第一步：按照[运算符](http://baike.baidu.com/view/425996.htm)的优先级对所有的运算单位加括号：式子变成了：((a+(b*c))-(d+e)) 第二步：转换前缀与后缀表达式 - 前缀：把运算符号移动到对应的括号前面 则变成了：-( +(a *(bc))+(de)) 把括号去掉：-+a*bc+de前缀式子出现 - 后缀：把运算符号移动到对应的括号后面 则变成了：((a(bc)* )+ (de)+)- 把括号去掉：abc*+de+-后缀式子出现 发现没有，前缀式，[后缀式](http://baike.baidu.com/view/2973716.htm)是不需要用括号来进行优先级的确定的。如表达式：3+(2-5)*6/3 5、计算机转换过程详细说明 后缀表达式      栈 3_________________+ 3 ________________+( 3 2_______________+(- 3 2 5 -_____________+ 3 2 5 -_____________+* 3 2 5 - 6 *___________+/ 3 2 5 - 6 *3__________+/ 3 2 5 - 6 *3/+________ ("_____"用于隔开后缀表达式与栈) 遍历中缀表达式的每个节点，如果： 1）、 该节点为[操作数](http://baike.baidu.com/view/420846.htm)： 直接拷贝进入后缀表达式 2）、 该节点是运算符，分以下几种情况： A、 为“（”[运算符](http://baike.baidu.com/view/425996.htm)： 压入临时堆栈中 B、 为“）”[运算符](http://baike.baidu.com/view/425996.htm)： 不断地弹出临时堆栈顶部[运算符](http://baike.baidu.com/view/425996.htm)直到顶部的运算符是“（”为止。并把弹出的[运算符](http://baike.baidu.com/view/425996.htm)都添加到后缀表达式中 C、 为其他运算符，有以下步骤进行： 比较该运算符与临时栈栈顶指针的运算符的优先级，如果临时栈栈顶指针的优先级高于该运算符的优先级，弹出并添加到后缀表达式中，反复执行前面的比较工作，直到遇到一个栈顶指针的优先级低于该运算符的优先级，停止弹出添加并把该运算符压入栈中。 此时的比较过程如果出现栈顶的[指针](http://baike.baidu.com/view/159417.htm)为‘（’，则停止循环并把该运算符压入栈中，注意：‘（’不要弹出来。 遍历完中缀表达式之后，检查临时栈，如果还有[运算符](http://baike.baidu.com/view/425996.htm)，则全部弹出，并添加到后缀表达式中。 以上描述的部分来自于网上的资料，写的非常详细，人工转换的例子也有。 五、使用Python的程序实现。 要把下面的仔细看完，还是需要一些耐心的。 首先是一些预处理的函数：目的是检查（）使用是否匹配，有无不合法的字符出现在表达式中：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

# -*- coding=utf-8 -*-


def is_matched(expr):

    """ReturnTrue if all delimiters are properlymatch; 

    Falseotherwise."""

    lefty ='({['

    righty =')}]'

    S =[] 

    for c inexpr:

       if c inlefty: 

          S.append(c)

       elif c inrighty:

          if len(S) ==0: 

              returnFalse

          if righty.index(c) !=lefty.index(S.pop()):

              returnFalse

    returnlen(S) == 0


def validate (instr):

    """检查输入的表达式，将不合法的字符去掉 """

    """对于-()以及(-())这样形式的字符串处理很麻烦，统一转换为(0-1)* """

    op ='+-*/()'          #合法的运算符

    digital ='1234567890.'

    x1 =""

    for i inrange(len(instr)):

       if instr[i] in op or instr[i]in digital:

          x1 = x1 + instr[i]

    x1 =x1.replace('(-', '((0-1)*')

    ifx1[0]=='-':

       x1 = x1.replace('-','(0-1)*', 1) 

    returnx1


这个程序本身没有太多需要解释的，唯一需要注意的是： line1：# -*- coding=utf-8-*- 这可不是注释，虽然以#开头，如果想让.py文件中使用中文的注释，而解释器不报错的话，必须在文件开头加入这么一句。 同时，如果想print语句显示中文字符串，必须注意些： print u”中文显示举例” 在检查了表达式字符串的合法行之后，我们就将表达式中的数与运算符分离，按照各自的类型，逐个按照表达式的顺序存储在一个List中，如’123+234’，字符串123、234会被作为两个整型数保存。 程序如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

def separation (x):

   """

   将表达式进行拆分，拆分的结果存放到一个list中

   由于list中的元素可以为各种类型，这给我们提供了极大的便利

   将数字串转换为int或float型，运算符按字符串存储

   """

   op = '+-*/()'         #合法的运算符

   digital = '1234567890.'

   alist = []

   ifrom = 999

   for i in range(len(x)):

       if x[i] inop:

          if ifrom ==999: 

             alist.append(x[i])

          else:

             if x[i - 1] in digital:

                 if '.' inx[ifrom:i]:

                    alist.append( float(x[ifrom:i] ) )

                else:

                    alist.append( int( x[ifrom:i]) )

             alist.append(x[i])

             ifrom = 999 

      else:

          if ifrom==999:

             ifrom=i 

   if ifrom != 999:

       if '.' inx[ifrom:len(x)]:

          alist.append( float(x[ifrom:len(x)] ) )

      else:

          alist.append( int(x[ifrom:len(x)] ) )

   return alist


最后就是后缀表达式转换的函数了：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

defsuffix_expression_r(exprinlist):

   alist=[]

   blist=[]

   for i in exprinlist:

       if type(i)== float or type(i) == int:

         alist.append(i)    

       if type(i)== str:

          if i=='(':

             blist.append(i)

          if i=='+' ori=='-':

             if len(blist)==0:

                blist.append(i)

             else:

                 whileTrue:

                    x=blist.pop()

                    if x=='+' or x=='-' or x=='*'or x=='/':

                       alist.append(x)

                    if x=='(':

                       blist.append(x)

                       blist.append(i)

                       break

                    if len(blist)==0:

                       blist.append(i)

                       break

          if i=='*' ori=='/':

             if len(blist)==0:

                blist.append(i)

             else:

                 whilelen(blist)>0:

                    x=blist.pop()

                    if x=='*' orx=='/':

                       alist.append(x)

                       blist.append(i)

                       break

                    if x=='+' orx=='-':

                       blist.append(x)

                       blist.append(i)

                       break

                    if x=='(':

                       blist.append(x)

                       blist.append(i)

                       break

          if i==')':

             while len(blist)>0:

                x=blist.pop()

                 ifx!='(':

                    alist.append(x)

                 ifx=='(':

                    break 

   while len(blist)>0:

      alist.append(blist.pop())  

   return alist


函数的输入参数是一个使用separation()函数将字符串表达式转换后的list blist用来模拟存放运算符的堆栈，alist用来存放结果 最后要做的是进行计算，前面所有这些都是为了让计算机知道，哪些是数，哪些是运算操作符，并且将运算符的优先级顺序区分出来，等所有这些都做好，其实计算反而是最简单的事情了，看函数的实现：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20


defcalculation(expression):

   list_a=[] 

   for i in expression:

       iftype(i)==float or type(i)==int:

          list_a.append(i)

       eliftype(i)==str:

          x=list_a.pop()

          y=list_a.pop()

          if i=='+':

             result=x+y

          if i=='-':

             result=y-x

          if i=='*':

             result=x*y

          if i=='/' andabs(x)>1E-9:

             result=y/x

         list_a.append(result)

      else:

          return 'Error'

   return result


函数调用方法：

1

2

3

4

5

6

7

8

9

10

11

12

13

expr ="3+(2-5)*6.0/3"

if notis_matched(expr):

   print u"错误的表达式！"

else:

   temp_x1=validate(expr)

   print(temp_x1)

   expr_list = separation(temp_x1)

   print expr_list

   print suffix_expression_r(expr_list)

   s_expr =suffix_expression_r(expr_list)

   print s_expr

   print expr, ' = ',calculation(s_expr)


显示的运行结果如下： 3+(2-5)*6.0/3 [3, '+', '(', 2, '-', 5, ')','*', 6.0, '/', 3] [3, 2, 5, '-', 6.0, '*', 3,'/', '+'] 3+(2-5)*6.0/3 =  -3.0 六、结束语 看着、想着都很简单的事，为什么让计算机做起来这么复杂呢？甚至都会觉得计算机一点也没有我之前很智能的感觉了。但是在把这个程序做好之后，你输入任一的四则运算表达式，不管多长，它都能瞬间的检查你的表达式是否正确，如果正确的话它也能够瞬间的给你答案，似乎又智能了。 所以，我们应该这么认为：计算机的计算能力是很强大的，关键在于我们能够让它做什么，这个让计算机做什么的过程就是编程的过程。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [六、Python的程序流程](http://blog.sina.com.cn/s/blog_d6cca93e0101ejeg.html)(2013-09-19 16:53:58) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

十一、Python简单数据结构应用（之…

最后更新于：2022-04-01 21:47:39

## 十、Python语言中简单数据结构的应用（之一） ----From a high schoolstudent's view to learn Python 关键字： python 列表 堆栈数据结构 递归调用 函数 组合问题 后缀表达式 前缀表达式 逆波兰表达式 运算符 优先级   本篇我们将简单介绍一下数据结构中的堆栈(stack)，以及在Python中利用堆栈所实现的一些应用。 一、堆栈介绍 堆栈是一个后进先出(LIFO)的数据结构，其工作方式就像往弹夹里面填子弹，在填好子弹之后，如果你要取出一颗子弹，那么你去除的这颗子弹一定是你最后填进去的，如果将子弹全部取出，那最后取出的那颗子弹一定是你最先填进去的那颗。把子弹当成我们程序中操作的元素，那么弹夹就是一个堆栈的模型了。 在栈上"push"元素是个常用术语，意思是把一个对象添加到堆栈中；反之，要删除一个元素,你可以把它"pop"出堆栈。此外，还有”empty”来判断堆栈是否为空状态。 很明显，使用Python中的List非常容易实现堆栈的模型，我们先复习一下List中有哪些内置的方法，在terminal窗口输入： dir(list) ['__add__', '__class__','__contains__', '__delattr__', '__delitem__', '__delslice__','__doc__', '__eq__', '__format__', '__ge__', '__getattribute__','__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__','__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__','__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__','__repr__', '__reversed__', '__rmul__', '__setattr__','__setitem__', '__setslice__', '__sizeof__', '__str__','__subclasshook__', 'append', 'count', 'extend', 'index', 'insert','pop', 'remove', 'reverse', 'sort'] 内容很多，介绍一些常用的： s[i] = x item i of s is replaced byx s[i:j] = t slice of s from i to j isreplaced by the contents of the iterable t del s[i:j] same as s[i:j] = [] s[i:j:k] = t the elements of s[i:j:k] arereplaced by those of t del s[i:j:k] removes the elements ofs[i:j:k] from the list s.append(x) same as s[len(s):len(s)] =[x] s.extend(x) same as s[len(s):len(s)] =x s.count(x) return number of i‘s for whichs[i] == x s.index(x[, i[, j]]) return smallest k such thats[k] == x and i <= k < j s.insert(i, x) same as s[i:i] = [x] s.pop([i]) same as x = s[i]; del s[i];return x s.remove(x) same as dels[s.index(x)] s.reverse() reverses the items of s inplace s.sort([cmp[, key[,reverse]]]) sort the items of s inplace 我们使用List的append()来实现堆栈的push，使用pop()不带参数的情况来实现堆栈的pop，使用len(list)==0来实现empty。 举例： stack=[] len(stack)==0 True stack.append('1') stack.append('2') for a in '3456789': stack.append(a) ...  stack ['1', '2', '3', '4', '5', '6','7', '8', '9'] stack.pop() '9' stack ['1', '2', '3', '4', '5', '6','7', '8'] len(stack)==0 False 二、如何使用堆栈来模拟递归函数调用 看下面的程序，还是一个组合问题的程序：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

def comb(iterable, r,order=1):

   pool = tuple(iterable)

   if order != 1:

       pool =list(pool)

      pool.reverse()

       pool =tuple(pool)


   comb=[]

   n = len(pool)

   if r > n:

       returncomb

   indices = range(r)


   def subcomb(N, m, n, B):

      i=1

       whileTrue:

          if i == m-n+2:

             break

          indices[N-n] = i+B

          ifn-1>0:

             subcomb(N, m-i, n-1, B+i)

          else:

             comb.append(tuple(pool[k-1] for k inindices))

          i += 1

   

   subcomb(r,n,r,0)

   return comb


print "\ncomb-----"

comb1=comb(tuple('123456'),4)

for e in comb1: printe

print len(comb1)


这个程序就不像之前一句一句的详细介绍了，因为使用的方法和之前的没有根本的变化，简单说明如下： - 函数和之前相比，增加了一个参数，并且使用1作为缺省参数值，当该参数不为1时，我们将按照列表中元素的倒序来列出组合 - 递归函数为subcomb()，请注意，这个函数的定义和调用都在函数comb()中，这也是一种合法的方式 - 递归函数subcomb(N, m, n,B)实现的方式和前一篇介绍的稍有不同，前一篇是从后往前开始列出组合结果的，而这个是从前往后来列的，所以在参数中还额外的加了一个B用来表示递归子序列的起始位置；参数N表示最终组合中元素的个数，m、n分别表示当前所求的元素个数和组合中元素个数，递归调用时，m、n、B会变化 程序的运行结果： comb----- ('1', '2', '3', '4') ('1', '2', '3', '5') ('1', '2', '3', '6') ('1', '2', '4', '5') ('1', '2', '4', '6') ('1', '2', '5', '6') ('1', '3', '4', '5') ('1', '3', '4', '6') ('1', '3', '5', '6') ('1', '4', '5', '6') ('2', '3', '4', '5') ('2', '3', '4', '6') ('2', '3', '5', '6') ('2', '4', '5', '6') ('3', '4', '5', '6') 15 介绍这个程序不是主要目的，主要的目的是想说明，递归是可以通过使用堆栈来模拟的，而且最终运行的结果也一模一样。先看程序：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36


def combusestack(iterable, r,order=1):

   pool = tuple(iterable)

   if order != 1:

       pool =list(pool)

      pool.reverse()

       pool =tuple(pool)


   comb=[]

   nc = len(pool)

   if r > nc:

       returncomb

   indices = range(r)


   stack=[]

   res=[-1,-1,-1,-1]

   m, n, B, i = nc, r, 0,1 

   while True:

       while i ==m-n+2:

          if len(stack) ==0: 

             return comb

         (m,n,B,i)=stack.pop()

          i+=1

      indices[r-n] = i+B

       ifn-1>0:

          res=[m, n, B, i]

          stack.append(res)

          m, n, B, i = m-i, n-1, B+i,1

          continue

      else:

          comb.append(tuple(pool[k-1]for k in indices))

       i +=1


print "comb usestack-----"

comb1=combusestack(tuple('123456'),4)

for e in comb1: printe

print len(comb1)

运行结果： comb use stack----- ('1', '2', '3', '4') ('1', '2', '3', '5') ('1', '2', '3', '6') ('1', '2', '4', '5') ('1', '2', '4', '6') ('1', '2', '5', '6') ('1', '3', '4', '5') ('1', '3', '4', '6') ('1', '3', '5', '6') ('1', '4', '5', '6') ('2', '3', '4', '5') ('2', '3', '4', '6') ('2', '3', '5', '6') ('2', '4', '5', '6') ('3', '4', '5', '6') 15 这个程序使用一个List来模拟堆栈，进入堆栈中的元素，也是一个List，我们在原来递归函数进行递归调用的地方，将函数的其中3个参数(N除外，因为在过程中不会改变)以及循环变量i，push到堆栈中，在原来函数结束的地方，在堆栈中pop一个List出来，直到堆栈空为止。 在程序中也出现了一些比较奇特的语句，如line21、line27。 这个程序的目的只是为了验证，递归调用可以通过堆栈来模拟函数调用，变换为非递归的函数；其实这个程序可读性不是很高，而且在line21由于堆栈的弹出，会改变循环变量i的值，在调试程序和理解程序方面会带来困惑。 三、堆栈的简单应用举例 介绍两个例子，一是利用堆栈的特性，反转字符串，另一是利用堆栈，检查表达式中的（）是否匹配。 堆栈所具有的这种后进先出(LIFO)协议的特性，它可以作为一个通用的办法用于反转数据序列。例如，如果按照1，2，3的顺序把值压入一个堆栈，那么从堆栈中将它们弹出时的顺序为3，2，1。 看下面字符窜反转的例子：

1

2

3

4

5

6

7

8

9

10

11

12


defrev(s):

    stack =[]

    n =len(s)

    if n==0: returnNone

    for c in s:stack.append(c)

    revstr =''

    whilelen(stack)>0 :

       revstr += stack.pop()

    returnrevstr


printrev('123456789')

printrev('')


运行结果如下： 987654321 None 下面是关于检查括号是否匹配的例子 文字说明的部分摘录于<> In the following application, we considerarithmetic expressions that may contain various pairs of groupingsymbols, such as • Parentheses: “(” and “)” • Braces: “{”and “}” • Brackets: “[” and “]” Each opening symbol must match itscorresponding closing symbol. For example, a left bracket, “[,”must match a corresponding right bracket, “],” as in the expression[(5+x)-(y+z)]. The following examples further illustrate thisconcept: • Correct: ()(()){([()])} • Correct: ((()(()){([()])})) • Incorrect:)(()){([()])} • Incorrect: ({[])} - Incorrect: ( 程序如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20


defis_matched(expr):

   """Return True if all delimiters are properlymatch; 

   False otherwise."""

   lefty = '({['

   righty = ')}]'

   S = [] 

   for c in expr:

       if c inlefty: 

          S.append(c)

       elif c inrighty:

          if len(S) ==0: 

             return False

          if righty.index(c) !=lefty.index(S.pop()):

             return False

   return len(S) == 0

   

printis_matched('[(5+x)-(y+z)]')

printis_matched('{(5+x)-(y+z)]')

printis_matched('[(5+x)-(y+z))')


运行结果分别显示为：True False False 做一些说明： 我们仍然使用List来模拟堆栈，所以push和empty的形式和真正的堆栈有差异。 程序的流程大致是这样： for循环扫描表达式，如果遇到的字符是’({[‘中的任一个，则将该字符压入堆栈；否则如果字符是’)}]’中的任一个，程序先判断当前堆栈是否为空，为空则返回错误，然后判断符号是否匹配，line13的语句就是检查是否匹配，这是本程序中唯一比较难的语句。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [一、Python语言的入门](http://blog.sina.com.cn/s/blog_d6cca93e0101ebw4.html)(2013-09-08 09:16:19) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

十、Python编程解决组合问题（之二…

最后更新于：2022-04-01 21:47:37

## 九、Python编程解决组合问题（之二） ----From a high school student's view to learn Python 关键字： python组合问题 编程 递归 函数 元组 堆栈 列表 combination function recursive tuplelist stack 四、组合问题的通用算法 到这，肯定有人会问，有没有比这好懂一些的方法呢，这也是我当初的想法，其实在python的库中，就有非常好的实现，因为python本身就有直接解决排列、组合问题的函数提供:[http://www.python.org/doc//current/library/itertools.html](http://www.python.org/doc//current/library/itertools.html) 在列表中你可以看到一个[combinations](http://www.python.org/doc//current/library/itertools.html)的函数，函数的源代码如下： [![十、Python编程解决组合问题（之二）](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "十、Python编程解决组合问题（之二）")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101entc&url=http://album.sina.com.cn/pic/d6cca93egx6Dc1uUUWF95&690) ~~~ def combinations(iterable, r): # combinations('ABCD', 2) --> AB AC AD BC BD CD # combinations(range(4), 3) --> 012 013 023 123 pool = tuple(iterable) n = len(pool) if r > n: return indices = range(r) yield tuple(pool[i] for i in indices) while True: for i in reversed(range(r)): if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range(i+1, r): indices[j] = indices[j-1] + 1 yield tuple(pool[i] for i in indices)  ~~~ 如何使用？如下： importitertools a=('zhao','qian','sun','li','zhou','wu') for b initertools.combinations(a,4): print b ...  ('zhao', 'qian', 'sun', 'li') ('zhao', 'qian', 'sun', 'zhou') ('zhao', 'qian', 'sun', 'wu') ('zhao', 'qian', 'li', 'zhou') ('zhao', 'qian', 'li', 'wu') ('zhao', 'qian', 'zhou', 'wu') ('zhao', 'sun', 'li', 'zhou') ('zhao', 'sun', 'li', 'wu') ('zhao', 'sun', 'zhou', 'wu') ('zhao', 'li', 'zhou', 'wu') ('qian', 'sun', 'li', 'zhou') ('qian', 'sun', 'li', 'wu') ('qian', 'sun', 'zhou', 'wu') ('qian', 'li', 'zhou', 'wu') ('sun', 'li', 'zhou', 'wu') 看起来比我们实现的代码高明得多，能够解决任意序列的任意数量的组合问题；你可能会想，我们整这么多干啥？直接拿来用不就行了，其实，我们的真实目的是学习，学习就应该参考好的，提高自己； 我将这个程序进行了简单的改造:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

 

def combinations(iterable, n):

    pool =tuple(iterable)

   comb=[]

    m =len(pool)

    if n> m:

       return comb

    indices =range(n)

    whileTrue:

       while True:

           comb.append(tuple(pool[i] for i in indices))

           if indices[n-1] < m-1:

               indices[n-1] += 1

           else:

               break

       for i in reversed(range(n-1)):

           if indices[i] != i + m - n:

               indices[i] += 1

               for j in range(i+1, n):

                   indices[j] = indices[j-1] + 1

               break

       else:

           return comb

       

print "\nChange from python itertools"

comb1=combinations(('zhao','qian','sun','li','zhou','wu'),4)

for e in comb1: print e

print len(comb1)

 

可以直接copy形成一个.py文件直接运行，运行结果： Change from python itertools ('zhao', 'qian', 'sun', 'li') ('zhao', 'qian', 'sun', 'zhou') ('zhao', 'qian', 'sun', 'wu') ('zhao', 'qian', 'li', 'zhou') ('zhao', 'qian', 'li', 'wu') ('zhao', 'qian', 'zhou', 'wu') ('zhao', 'sun', 'li', 'zhou') ('zhao', 'sun', 'li', 'wu') ('zhao', 'sun', 'zhou', 'wu') ('zhao', 'li', 'zhou', 'wu') ('qian', 'sun', 'li', 'zhou') ('qian', 'sun', 'li', 'wu') ('qian', 'sun', 'zhou', 'wu') ('qian', 'li', 'zhou', 'wu') ('sun', 'li', 'zhou', 'wu') 15 程序为什么会变的这么复杂呢？ 1  程序考虑了广泛的适用性，能够针对任何的序列来解决组合的问题，而我们上面的程序只能够使用到自然数的数列中 2  程序考虑了意外的情况，如果序列中有6个元素，而你要找7个元素的组合，程序不会发生意外 3  程序没有使用递归，所以解决的过程需要考程序流程来处理 我们还是来讲讲这个程序本身，在开始之前，先介绍一下在这个程序中新出现的一个语法： for语句后面的else for循环可以有 else用于循环后处理(post-processing)，while 循环中的else 处理方式相同，只要for循环是正常结束的(不是通过 break),else子句就会执行 下面介绍程序的算法流程，把这个算法流程搞清楚，程序看起来就会简单很多，但是把这个算法用文字性的语言描述出来，我可真是费了九牛二虎之力： 1  为了使解决问题的方法具有普适性，我们在编写算法的过程中，不会直接的操作序列的每个元素，而是使用每个元素在序列中的序号来进行组合，序号从0开始，在最后形成结果时，再根据序号与序列中元素的对应关系，得到我们想要的结果，这样不管序列是多复杂的元素组成，我们都相当于在解决0~m-1这些数中n个数的组合 2  我们还是回到最开始的那10个步骤，我们之前讲过，对于每一步来说，就是最后的一个元素在进行循环，这具有普遍性，适用于C(m,n)，也就是说，对于从m个元素中取n个元素的组合，在确定了组合中的n-1个元素之后，剩下要做的就是进行循环，每一次的循环确定一个组合的第n个元素，形成一种组合结果。那么现在的难点在与如何程序化的确定那n-1个元素 3  我们再来分析一下那10个步骤，我们固定的3个数从1 23到最后变为3 4 5，看看每一步的变化，我们可以发现一些规律： 变化第三位开始，第①~第③，第三位从3->5 第三位变化完之后，改变第二位，同时，第三位起始位置也+1，重复上一步 上面两步重复执行，知道第二位变为4，再按照类似的步骤，对第一位进行变化，再重复以上两步 4   从上面的描述，最需要我们明白的一点是：除了最后一个数，其他的数只要一变化，这个数后面的数都要重新排序，再进行循环操作。 程序说明： line1：函数定义，传入的参数1是序列，该序列可以是一个list或者tuple或者字符窜，参数2是组合中元素的数量 line2：将传入的参数强制转为tuple，如果是字符窜，如’ABCDEF’，在执行后，pool将等于('A','B', 'C', 'D', 'E', 'F') line3：局部变量，初始化为空list，用来存储结果，并在最后作为返回值 line4：计算序列中元素的数量，保存在变量m中 line5-6：例外情况判断，如果要求组合的数量r<序列中元素的数量，直接返回空list line7：中间变量，在前面的算法流程中讲过，组合的中间结果是用序号来表示的，这个list变量就是这个用途，而且初始化值是第一个组合的序号，如果是从m个元素中取4个的组合，那它的值就为[0,1, 2, 3] line8：这个大的while循环，没执行一次循环，代表的就是我们最开始描述10步中的一步 line9-14：这是一个小循环，目的就是在固定了n-1个数之后，对最后一个数进行循环，并输出结果 line10：这一句从语法上讲最复杂，但从作用上看最简单，我们之前说过，组合的中间结果是元素的序号，为了得到真正的组合结果，还需要根据对应关系，进行一次转换，这就是本句的作用。看看句子本身，append的参数里包含了一个循环，很神奇，这也是python的神奇语法 line11-14：这是循环的是结束还是继续的判断语句，我们知道，最后一个数必须循环到为n-1为止（注意，这里所述的数为序号，序号是从0开始的），所以如果最后一个数比n-1小，就+1继续循环，否则，循环终止 line15-20：这是本程序最难懂的关键点，我们一句一句的说明 line15：for循环语句，我们在算法描述中说了，在最后一个序号循环结束之后，剩余的序号变化是从后往前的，所以我们使用reversed对range产生的list进行了倒转，而且由于这个循环的序号变化，只是针对前面的n-1个，所以range的范围是n-1 line16：判断语句，从最开始的例子，我们知道，对于6取4，固定的3个数从12 3变化为3 45之后，循环会终止，这条语句的目的就是从后往前，逐个的判断，条件是否满足，如果第三位变成了5，那就再循环，判断第二位，依次执行； line17-20：对于line16的判断，假设第二位现在是3，就会执行17-20的语句，line17将第二位+1，line18-19的语句将第二位后面的重新排序，排序之后，line20的break语句跳出这个循环，继续line8的大循环 line21：如果line15-20的循环正常完成（正常完成指的是没有经过break语句跳出），说明12 3已经变为了3 4 5，那么程序就可以结束了 五、结束 用文字来描述这个过程，对我来说是非常有难度的挑战，但从个人的学习经历来看，网上可以找到很多的程序源代码，但是对于初学者，由于这些程序都没有一些详细的描述，所以看起来都比较的困难，所以我还是尝试把我理解的描述清楚，便于像我这样的初学者入门，否则很容易遇难而退。 我再说说我的一些体会，也希望可以对大家有搜帮助： 写程序的目的是解决实际的问题，但是程序也有基本的语法和一些基本的技巧，这些都需要从写一些小的应用程序着手，来积累自己的基础知识，想一下子成为高手，这也没有捷径。 解决某个实际的问题，程序的写法其实有很多种，就想我们在上面看到的组合问题，有很多种写法，其实针对只有一个问题，我们可以相处很多的问题来训练自己，比如： 我们能否将递归方法，也改为一个通用的程序，可以针对任意的序列来解决组合问题？ 我们更改一下程序，让组合的产生顺序发生变化 其实，对一个问题的举一反三，就能够将python的基本语法掌握扎实了。 我的更多文章： - Python程序调试的一些体会(2013-10-06 22:57:35) - 十四、Python编程计算24点（之二）(2013-10-03 22:18:28) - 十三、Python编程计算24点（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - 十二、Python简单数据结构应用（之二）(2013-10-02 22:10:41) - 十一、Python简单数据结构应用（之一）(2013-09-23 23:31:49) - 九、Python编程解决组合问题（之一）(2013-09-21 23:32:54) - 八、Python的函数编程（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - 七、Python的函数编程（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - 六、Python的程序流程(2013-09-19 16:53:58) - 高中生如何学编程(2013-09-02 19:26:01)
';

九、Python编程解决组合问题（之一…

最后更新于：2022-04-01 21:47:35

## 九、Python编程解决组合问题（之一） ----From a high school student's view to learn Python 关键字： python组合问题 编程 递归 函数 元组 堆栈 列表 combination function recursive tuplelist stack 一、组合问题概述 组合是指从给定个数的元素中仅仅取出指定个数的元素，不考虑排序。组合的公式如下： 从m个元素中取n个元素的组合记为：C(m,n)，则： C(m, n) = m!/((m-n)!n!) 在知道了组合的定义以及公式之后，我们要求比如9个数中取4个数的组合以及列出各种组合，是非常简单的，C(9,4)=126。 我开始也想当然，用计算机来解决组合问题，那是不是太小儿科了，可当我一开始着手做，才知道这还真不是一个简单的问题。当然对于计算组合的数量是非常简单（其实，对于我们刚开始学习编程，写一个计算组合数量的程序也不算很简单），那复杂在什么地方呢？ 对于C(9,4)，复杂在于我们如何将所有的组合列出，我们先拿6个数来举例。 列出1 2 3 4 5 6六个数的所有任意四个数的组合 1   固定1 2 3，组合有：1234 1235 1236 2   固定1 2 4，组合有：1245 1246 3   固定1 2 5，组合有：1256 4   固定1 3 4，组合有：1345 1346 5   固定1 3 5，组合有：1356 6   固定1 4 5，组合有：1456 7   固定2 3 4，组合有：2345 2346 8   固定2 3 5，组合有：2356 9   固定2 4 5，组合有：2456 10  固定3 4 5，组合有：3456 共计15种，与C(6,4)=6*5*4*3/(1*2*3*4)=15相符。 二、组合问题的简单算法 如何把这些步骤进行归纳总结，形成一个算法，通过编程让计算机可以自动完成列出各种组合的任务呢？这下你应该体会到，计算机其实并不“聪明”，如果没有人给它执行指令，它其实啥也不会做。言归正传，我们还是来分析一下，这个问题如何解决： 首先，我们分析上面列出的10个步骤，对于1），很明显，在固定了1 23这三个数之后，第四个数就是4、5、6三个数进行了循环（还记得循环吗，计算机最拿手的就是做循环）。 其次，我们再分析1）2）3）这三个步骤中固定的数字，前两个没有变，都是12，只是第三个数在进行循环（又是循环）。 通过分析，我们可以找到这样的规律： 1   先固定3个数，让第四个数进行循环 2   让第三个数循环，重复第一步 3   让第二个数循环，重复第一步 4   让第一个数循环，重复第一步 似乎几个循环就能够搞定，确实如此，看看下面的程序：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def combNumberLoop4(m, b):

    totalNumber= 0

    for i inrange(1, m+2-4):

       b[0] = i

       for j in range(i+1, m+2-3):

           b[1] = j

           for k in range(j+1, m+2-2):

               b[2] = k

               for l in range(k+1, m+2-1):

                   b[3] = l

                   print b

                   totalNumber += 1

    returntotalNumber

 

group=[99,99,99,99]

print "\nUsing Loop: %d\n" % combNumberLoop4(6, group)

 

程序的运行结果如下： [1, 2, 3, 4] [1, 2, 3, 5] [1, 2, 3, 6] [1, 2, 4, 5] [1, 2, 4, 6] [1, 2, 5, 6] [1, 3, 4, 5] [1, 3, 4, 6] [1, 3, 5, 6] [1, 4, 5, 6] [2, 3, 4, 5] [2, 3, 4, 6] [2, 3, 5, 6] [2, 4, 5, 6] [3, 4, 5, 6] Using Loop: 15 对这个程序，做一些说明： 程序使用了函数，函数名为combNumberLoop4 l程序使用了循环，而且是一个多重循环，注意：循环的缩进，循环的变量，循环的范围；每一层的循环，range的起始值都依赖于上一层的循环变量，如果对range函数还有疑问的，请复习一下。 l程序设置了一个计数的变量totalNumber，每算出一种组合，变量+1； l程序有一个return语句，用来返回总共有多少种组合； l程序中使用了列表(list)数据类型，我们先初始化了一个有四个元素的list变量group，group在程序中作为参数，传入到函数中使用，在函数的定义中，我们使用b来接收group，所以在函数中，对于b的操作其实就是对group的操作。函数中有对list中单个元素进行更新； l对于print语句的使用，我们使用了格式化输出，用来显示计算列出的组合数量； l对于函数的调用，我们直接把调用放在了print语句中，显示了python的灵活语法规则； l再一次的强调“缩进”“:”，特别是“缩进”，经常会引起莫名其妙的问题，教训深刻； 我们把变量group在调用函数时，作为参数在传入，那再函数调用返回之后，group的值改变了吗？请大家自己试一试。 组合问题似乎就这么顺利的解决了，但恐怕没有这么简单： 你有没有发现，这个函数有一个严重的缺陷（思考一下），它只能够解决四个数的组合问题。 如果你想解决非四个数的组合问题，那你还得再写一个函数，可是在程序中，为了解决通用型的问题，类似C(m,n)，m、n都会是变化的，我们总不能写n个函数来实现吧？我们似乎应该找一个更通用的办法。 三、组合问题的递归解决 我们再回到C(6,4)问题，除了上面列出的十个步骤，我们换个思路： 如果在6个数中选定一个数，那么确定剩下的3个数是不是变为了“从5个数中选3个数的组合问题”了呢？以此类推，这似乎变成了一个“递归”问题了，确实，我们可以用递归的思路来解决这个问题。 对于C(m,n)列出所有组合的问题，可以按照一下的步骤来进行编程，这次我们按从后往前的顺序来列出所有组合： 1  选定一个元素i，在范围[m, n]内进行循环 2  将i 作为所求组合的最后一个元素 3  如果n-1>0，进行递归调用，求C(m-1,n-1)；否则，输出结果 4  重复① 注意，设计递归函数一定要有终止条件，否则会造成“死循环”。 实现的代码如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

def combNumber(m, n, b):

    globaltotalNumberR

    for i inrange(m, n-1,-1):   

       b[n-1] = i

       if n-1>0:

           combNumber(i-1,n-1,b)

       else:

           print b

           totalNumberR += 1

    returntotalNumberR

 

group=[99,99,99,99,99]

totalNumberR = 0

print "\nUsing Recursive: %d\n" % combNumber(7,5,group)

 

运行结果： [3, 4, 5, 6, 7] [2, 4, 5, 6, 7] [1, 4, 5, 6, 7] [2, 3, 5, 6, 7] [1, 3, 5, 6, 7] [1, 2, 5, 6, 7] [2, 3, 4, 6, 7] [1, 3, 4, 6, 7] [1, 2, 4, 6, 7] [1, 2, 3, 6, 7] [2, 3, 4, 5, 7] [1, 3, 4, 5, 7] [1, 2, 4, 5, 7] [1, 2, 3, 5, 7] [1, 2, 3, 4, 7] [2, 3, 4, 5, 6] [1, 3, 4, 5, 6] [1, 2, 4, 5, 6] [1, 2, 3, 5, 6] [1, 2, 3, 4, 6] [1, 2, 3, 4, 5] Using Recursive: 21 我们还是按照之前的方式对程序进行一些解释：  这是一个通用的程序，这个程序没有前一个程序的限制，可以解决从1~m的数中取n个数的组合问题  为了返回正确的组合数量的统计值，我们设置了变量totalNumberR，注意该变量我们在函数中将它使用global强制转为全局变量，大家可以试一试，如果不这样做，看看返回的结果是什么  从执行结果来看，这次的组合与之前的例子不同，是从最后面的一组组合开始的，在函数的循环中，range使用的步进值为-1  因为要求5个元素的组合，我们将group初始化为5个元素的list  注意递归调用的参数 递归的使用，让程序写起来非常的简洁，但是，在写程序的时候，我有两个地方（其实程序也就难在这两个地方），折腾了好几天才弄清楚：  首先是for循环的循环范围如何确定；   其次是递归调用时使用的参数设计； 和之前介绍递归函数时使用的斐波那契数列的例子，这个程序更难理解执行的顺序，不象fib，只是层层调用而已，而这个程序在调用外面还套了一层循环，增加了理解的难度。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [六、Python的程序流程](http://blog.sina.com.cn/s/blog_d6cca93e0101ejeg.html)(2013-09-19 16:53:58) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

八、Python的函数编程（之二）

最后更新于：2022-04-01 21:47:32

## 八、Python的函数编程（之二） ----From a high schoolstudent's view to learn Python 关键字： python 高中生学编程 MIT公开课视频Python函数编程 递归 递归函数 递归调用 四、Python’s Built-inFunctions Python包含了很多内置的函数： int()、float()、len()、type()、range()、print()、input()、abs()、str()、tuple() 在Python.org上有详细的描述

Built-inFunctions

abs()

divmod()

input()

open()

staticmethod()

all()

enumerate()

int()

ord()

str()

any()

eval_r()

isinstance()

pow()

sum()

basestring()

execfile()

issubclass()

print()

super()

bin()

file()

iter()

property()

tuple()

bool()

filter()

len()

range()

type()

bytearray()

float()

list()

raw_input()

unichr()

callable()

format()

locals()

reduce()

unicode()

chr()

frozenset()

long()

reload()

vars()

classmethod()

getattr()

map()

repr()

xrange()

cmp()

globals()

max()

reversed()

zip()

compile()

hasattr()

memoryview()

round()

__import__()

complex()

hash()

min()

set()

apply()

delattr()

help()

next()

setattr()

buffer()

dict()

hex()

object()

slice()

coerce()

dir()

id()

oct()

sorted()

intern()

这些函数多数都不是经常用到，所以大致了解一下即可，有一些印象，在需要的时候再仔细看看说明。 但在开头列的那几个函数，使用度非常高，应该仔细掌握，主要从以下几个方面进行了解： 函数的作用是什么？ 函数的参数是什么类型、缺省参数是什么？ 函数的返回值是什么类型？ dir([*object*]) Without arguments, return thelist of names in the current local scope. With an argument, attemptto return a list of valid attributes for that object. If the object has a methodnamed __dir__(),this method will be called and must return the list of attributes.This allows objects that implement acustom [__getattr__()](http://docs.python.org/2/reference/datamodel.html) or [__getattribute__()](http://docs.python.org/2/reference/datamodel.html) functionto customize the way [dir()](http://docs.python.org/2/library/functions.html) reportstheir attributes. If the object does notprovide __dir__(),the function tries its best to gather information from theobject’s __dict__ attribute,if defined, and from its type object. The resulting list is notnecessarily complete, and may be inaccurate when the object has acustom [__getattr__()](http://docs.python.org/2/reference/datamodel.html). Thedefault [dir()](http://docs.python.org/2/library/functions.html) mechanismbehaves differently with different types of objects, as it attemptsto produce the most relevant, rather than complete,information: 1. If the object is a moduleobject, the list contains the names of the module’sattributes. 1. If the object is a type orclass object, the list contains the names of its attributes, andrecursively of the attributes of its bases. 1. Otherwise, the list containsthe object’s attributes’ names, the names of its class’sattributes, and recursively of the attributes of its class’s baseclasses. The resulting list is sortedalphabetically. For example: importstruct  dir() *#show the names in the module namespace*  ['__builtins__', '__doc__','__name__', 'struct']  dir(struct) *#show the names in the struct module*  ['Struct', '__builtins__','__doc__', '__file__', '__name__', '__package__', '_clearcache','calcsize', 'error', 'pack', 'pack_into', 'unpack','unpack_from']  classShape(object):        def__dir__(self):           return ['area', 'perimeter','location']  s=Shape()  dir(s)  ['area', 'perimeter','location']  Note Because [dir()](http://docs.python.org/2/library/functions.html) issupplied primarily as a convenience for use at an interactiveprompt, it tries to supply an interesting set of names more than ittries to supply a rigorously or consistently defined set of names,and its detailed behavior may change across releases. For example,metaclass attributes are not in the result list when the argumentis a class. 这是在一本书上找的两个练习： 1. dir()内建函数 - 启动Python 交互式解释器, 通过直接键入 dir() 回车以执行 dir() 内建函数。你看到 什么?显示你看到的每一个列表元素的值,记下实际值和你想像的值 - 你会问, dir() 函数是干什么的?我们已经知道在 dir 后边加上一对括号可以执行 dir() 内建函数, 如果不加括号会如何?试一试。解释器返回给你什么信息? 你认为这个信息表示什么意思 ? - type() 内建函数接收任意的 Python对象做为参数并返回他们的类型。 在解释器中键入 type(dir),看看你得到的是什 - 本练习的最后一部分,我们来瞧一瞧 Python 的文档字符串。 通过dir.__doc__可以访问dir() 内建函数的文档字符串。printdir.__doc__可以显示这个字符串的内容。许多内建 函数,方法,模块及模块属性都有相应的文档字符串。我们希望你在你的代码中也要书写文档 字符串, 它会对使用这些代码的人提供及时方便的帮助。 2. 利用 dir() 找出 sys模块中更多的东西。 1. 启动Python交互解释器,执行dir()函数,然后键入 import sys 以导入 sys 模块。 再次执行 dir() 函数以确认sys 模块被正确的导入。 然后执行 dir(sys) , 你就可以看到 sys模块的所有属性了。 1. 显示 sys 模块的版本号属性及平台变量。记住在属性名前一定要加 sys. ,这表示这个属性是 sys 模块的。其中 version变量保存着你使用的 Python 解释器版本, platform 属性则包含你运行 Python时使用的计算机平台信息。 1. 最后,调用 sys.exit() 函数。这是一种热键之外的另一种退出Python 解释器的方式。 五、常用内建函数的使用 我们先从一些实际的例子着手：


>>>s = 'Hello, world.'

>>>str(s)

'Hello, world.'

>>>repr(s)

"'Hello, world.'"

>>>str(0.1)

'0.1'

>>>repr(0.1)

'0.10000000000000001'

>>>x = 10 * 3.25

>>>y = 200 * 200

>>>s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) +'...'

>>>print s

The value of x is 32.5, and yis 40000...

>>># The repr() of a string adds string quotes andbackslashes:

... hello = 'hello,world\n'

>>>hellos = repr(hello)

>>>print hellos

'hello, world\n'

>>># The argument to repr() may be any Python object:

... repr((x, y, ('spam','eggs')))

"(32.5, 40000, ('spam','eggs'))"


how do you convert values tostrings? Luckily, Python has ways to convert any value to a string:pass it to the [**repr()**](http://www.python.org/doc//current/library/functions.html) or [**str()**](http://www.python.org/doc//current/library/functions.html) functions. The str() function is meant toreturn representations of values which are fairly human-readable,while repr() is meant to generate representations which can be readby the interpreter (or will force a SyntaxError if there is notequivalent syntax). For objects which don’t have a particularrepresentation for human consumption, str() will return the samevalue as repr(). Many values, such as numbers or structures likelists and dictionaries, have the same representation using eitherfunction. Strings and floating point numbers, in particular, havetwo distinct representations. Here are two ways to write atable of squares and cubes: for x in range(1, 11): ...    print repr(x).rjust(2),repr(x*x).rjust(3), ...    # Note trailing comma on previousline ...    print repr(x*x*x).rjust(4) ... 1  1   1 2  4   8 3  9   27 4  16  64 5 25  125 6 36  216 7 49  343 8 64  512 9 81  729 10 100 1000 for x in range(1,11): ...    print '{0:2d} {1:3d} {2:4d}'.format(x, x*x,x*x*x) ... 1  1   1 2  4   8 3  9   27 4  16  64 5 25  125 6 36  216 7 49  343 8 64  512 9 81  729 10 100 1000 使用print进行格式化的结果输出，注意print、range等函数的使用 常用函数： **abs(x)** Return the absolute value of anumber. The argument may be a plain or long integer or a floatingpoint number. If the argument is a complex number, its magnitude isreturned. **all(iterable)** Return True if all elements ofthe iterable are true (or if the iterable is empty). Equivalentto: def all(iterable): for element in iterable:     if notelement:        return False return True **any(iterable)** Return True if any element ofthe iterable is true. If the iterable is empty, return False.Equivalent to: def any(iterable): for element in iterable:     ifelement:        return True return False New in version 2.5. **bin(x)** Convert an integer number to abinary string. The result is a valid Python expression. If x is nota Python int object, it has to define an __index__() method thatreturns an integer. New in version 2.6. **bool([x])** Convert a value to a Boolean,using the standard truth testing procedure. If x is false oromitted, this returns False; otherwise it returns True. bool isalso a class, which is a subclass of int. Class bool cannot besubclassed further. Its only instances are False andTrue. New in version2.2.1. Changed in version 2.3: If noargument is given, this function returns False. **cmp(x, y)** Compare the two objects x and yand return an integer according to the outcome. The return value isnegative if x < y, zero if x == y and strictlypositive if x > y. **complex([real[,imag]])** Create a complex number withthe value real + imag*j or convert a string or number to a complexnumber. If the first parameter is a string, it will be interpretedas a complex number and the function must be called without asecond parameter. The second parameter can never be a string. Eachargument may be any numeric type (including complex). If imag isomitted, it defaults to zero and the function serves as a numericconversion function like int(), long() and float(). If botharguments are omitted, returns 0j. The complex type is describedin Numeric Types — int, float, long, complex. **dir([object])** Without arguments, return thelist of names in the current local scope. With an argument, attemptto return a list of valid attributes for that object. If the object has a methodnamed __dir__(), this method will be called and must return thelist of attributes. This allows objects that implement a custom__getattr__() or __getattribute__() function to customize the waydir() reports their attributes. If the object does not provide__dir__(), the function tries its best to gather information fromthe object’s __dict__ attribute, if defined, and from its typeobject. The resulting list is not necessarily complete, and may beinaccurate when the object has a custom __getattr__(). The default dir() mechanismbehaves differently with different types of objects, as it attemptsto produce the most relevant, rather than complete,information: If the object is a moduleobject, the list contains the names of the module’sattributes. If the object is a type orclass object, the list contains the names of its attributes, andrecursively of the attributes of its bases. Otherwise, the list containsthe object’s attributes’ names, the names of its class’sattributes, and recursively of the attributes of its class’s baseclasses. The resulting list is sortedalphabetically. For example: import struct dir()   # doctest: +SKIP ['__builtins__', '__doc__','__name__', 'struct'] dir(struct)   # doctest:+NORMALIZE_WHITESPACE ['Struct', '__builtins__','__doc__', '__file__', '__name__', '__package__','_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack','unpack_from'] class Foo(object): ...    def __dir__(self): ...        return["kan", "ga", "roo"] ... f = Foo() dir(f) ['ga', 'kan', 'roo'] Note Because dir() is suppliedprimarily as a convenience for use at an interactive prompt, ittries to supply an interesting set of names more than it tries tosupply a rigorously or consistently defined set of names, and itsdetailed behavior may change across releases. For example,metaclass attributes are not in the result list when the argumentis a class. **divmod(a, b)** Take two (non complex) numbersas arguments and return a pair of numbers consisting of theirquotient and remainder when using long division. With mixed operandtypes, the rules for binary arithmetic operators apply. For plainand long integers, the result is the same as (a // b, a % b). Forfloating point numbers the result is (q, a % b), where q is usuallymath.floor(a / b) but may be 1 less than that. In any case q * b +a % b is very close to a, if a % b is non-zero it has the same signas b, and 0 <= abs(a % b) >>range(1, 11) [1, 2, 3, 4, 5, 6, 7, 8, 9,10] range(0, 30, 5) [0, 5, 10, 15, 20,25] range(0, 10, 3) [0, 3, 6, 9] range(0, -10, -1) [0, -1, -2, -3, -4, -5, -6, -7,-8, -9] range(0) [] range(1, 0) [] **raw_input([prompt])** If the prompt argument ispresent, it is written to standard output without a trailingnewline. The function then reads a line from input, converts it toa string (stripping a trailing newline), and returns that. When EOFis read, EOFError is raised. Example: s = raw_input('--> ') MontyPython's Flying Circus s "Monty Python's FlyingCircus" If the readline module wasloaded, then raw_input() will use it to provide elaborate lineediting and history features. **repr(object)** Return a string containing aprintable representation of an object. This is the same valueyielded by conversions (reverse quotes). It is sometimes useful tobe able to access this operation as an ordinary function. For manytypes, this function makes an attempt to return a string that wouldyield an object with the same value when passed to eval_r(),otherwise the representation is a string enclosed in angle bracketsthat contains the name of the type of the object together withadditional information often including the name and address of theobject. A class can control what this function returns for itsinstances by defining a __repr__() method. **reversed(seq)** Return a reverse iterator. seqmust be an object which has a __reversed__() method or supports thesequence protocol (the __len__() method and the __getitem__()method with integer arguments starting at 0). New in version 2.4. Changed in version 2.6: Addedthe possibility to write a custom __reversed__() method. **round(x[, n])** Return the floating point valuex rounded to n digits after the decimal point. If n is omitted, itdefaults to zero. The result is a floating point number. Values arerounded to the closest multiple of 10 to the power minus n; if twomultiples are equally close, rounding is done away from 0 (so. forexample, round(0.5) is 1.0 and round(-0.5) is -1.0). **sorted(iterable[, cmp[,key[, reverse]]])** Return a new sorted list fromthe items in iterable. The optional arguments cmp,key, and reverse have the same meaning as those for the list.sort()method (described in section Mutable Sequence Types). cmp specifies a customcomparison function of two arguments (iterable elements) whichshould return a negative, zero or positive number depending onwhether the first argument is considered smaller than, equal to, orlarger than the second argument: cmp=lambda x,y: cmp(x.lower(),y.lower()). The default value is None. key specifies a function of oneargument that is used to extract a comparison key from each listelement: key=str.lower. The default value is None. reverse is a boolean value. Ifset to True, then the list elements are sorted as if eachcomparison were reversed. In general, the key and reverseconversion processes are much faster than specifying an equivalentcmp function. This is because cmp is called multiple times for eachlist element while key and reverse touch each element only once. Toconvert an old-style cmp function to a key function, see theCmpToKey recipe in the ASPN cookbook. New in version 2.4. **str([object])** Return a string containing anicely printable representation of an object. For strings, thisreturns the string itself. The difference with repr(object) is thatstr(object) does not always attempt to return a string that isacceptable to eval_r(); its goal is to return a printable string.If no argument is given, returns the empty string, ''. For more information on stringssee Sequence Types — str, unicode, list, tuple, buffer, xrangewhich describes sequence functionality (strings are sequences), andalso the string-specific methods described in the String Methodssection. To output formatted strings use template strings or the %operator described in the String Formatting Operations section. Inaddition see the String Services section. See alsounicode(). **sum(iterable[,start])** Sums start and the items of aniterable from left to right and returns the total. start defaultsto 0. The iterable‘s items are normally numbers, and are notallowed to be strings. The fast, correct way to concatenate asequence of strings is by calling ''.join(sequence). Note thatsum(range(n), m) is equivalent to reduce(operator.add, range(n), m)To add floating point values with extended precision, seemath.fsum(). New in version 2.3. **tuple([iterable])** Return a tuple whose items arethe same and in the same order as iterable‘s items. iterable may bea sequence, a container that supports iteration, or an iteratorobject. If iterable is already a tuple, it is returned unchanged.For instance, tuple('abc') returns ('a', 'b', 'c') and tuple([1, 2,3]) returns (1, 2, 3). If no argument is given, returns a new emptytuple, (). tuple is an immutable sequencetype, as documented in Sequence Types — str, unicode, list, tuple,buffer, xrange. For other containers see the built in dict, list,and set classes, and the collections module. **type(object)** Return the type of an object.The return value is a type object. The isinstance() built-infunction is recommended for testing the type of anobject. With three arguments, type()functions as a constructor as detailed below. **xrange([start], stop[,step])** This function is very similarto range(), but returns an “xrange object” instead of a list. Thisis an opaque sequence type which yields the same values as thecorresponding list, without actually storing them allsimultaneously. The advantage of xrange() over range() is minimal(since xrange() still has to create the values when asked for them)except when a very large range is used on a memory-starved machineor when all of the range’s elements are never used (such as whenthe loop is usually terminated with break). CPython implementation detail:xrange() is intended to be simple and fast. Implementations mayimpose restrictions to achieve this. The C implementation of Pythonrestricts all arguments to native C longs (“short” Pythonintegers), and also requires that the number of elements fit in anative C long. If a larger range is needed, an alternate versioncan be crafted using the itertools module: islice(count(start,step), (stop-start+step-1)//step). 六、递归 ------ 如果函数包含了对其自身的调用,该函数就是递归的。如果一个新的调用能在相同过程中较早的调用结束之前开始,那么该过程就是递归的。 可以看一段MIT公开课视频： 递归广泛地应用于使用递归函数的数学应用中，类似数学归纳法。 拿阶乘函数的定义来说明： N! == factorial(N) == 1 * 2 * 3... * N  我们可以用这种方式来看阶乘: ~~~ factorial(N) = N! = N * (N-1)! = N * (N-1) * (N-2)! … = N * (N-1) * (N-2) ... * 3 * 2 * 1 ~~~ 我们现在可以看到阶乘是递归的，因为  factorial(N) = N*factorial(N-1) 换句话说，为了获得 factorial(N)的值，需要计算factorial(N-1)，而且，为了找到 factorial(N-1)，需要计算factorial(N-2)等等。我们现在给出阶乘函数的递归版本。 ~~~ def factorial(n): ...    if n==0 or n==1: ...           return 1 ...    else: ...           returnn*factorial(n-1) ...  factorial(21) 51090942171709440000L factorial(4) 24 factorial(1) 1 factorial(0) 1 ~~~ 特别强调： 1. 递归函数必须有一个终止执行的条件，如我们的例子中，当n=0或者n=1时，会终止；否则，程序将进入一个无限循环的状态，俗称“死循环” 1. 递归虽然使程序看起来非常的简单，但是递归程序如果递归的次数很大的话，将会严重的消耗计算机的内存，甚至可能导致系统的崩溃 下面给出一段视频，里面是以经典的递归问题：斐波那契数列作为例子进行讲解的，值得学习！ 【插入视频】 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [六、Python的程序流程](http://blog.sina.com.cn/s/blog_d6cca93e0101ejeg.html)(2013-09-19 16:53:58) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

七、Python的函数编程（之一）

最后更新于：2022-04-01 21:47:30

## 七、Python的函数编程（之一） ----From a high schoolstudent's view to learn Python 关键字： python 高中生学编程 MIT公开课视频Python函数编程 递归 递归函数 递归调用 一、为什么会引入函数 ------------------------ 在学习的初期阶段，我们写的程序都比较简单，功能比较单一，代码的行数也不会太多；那我们想一想，如果需要处理的应用越来越复杂，我们是不是顺着我们的思路，一直将我们的代码在一个地方不停地写下去呢？如果这样下去，会是什么结果呢？ 你可以想一想，如果一部长篇小说，没有章节划分，甚至连段落都没有，拿到它进行阅读，会是怎样的阅读感受呢？ 其实，我们编写代码，一方面实现代码的功能，另一方面还需要具有较好的可读性，便于维护、修改、和别人使用；所以，随着功能变得复杂，我们会将应用进行分割，简单化、模块化，就象买回来的组装玩具一样，函数（Function）就是这些玩具的各个部件。 我们在学习之初，都用到了print，print其实就是一个函数，只不过它是系统提供的一个函数，他可以被任何人在任何时候使用，来实现它的功能。 下面剪辑的视频还是来自MIT的公开课视频，比较详细的介绍了在编程中为何需要引入函数； 【这里插入视频】 为什么需要引入函数的视频 [![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2d40350b72329b279f62a8695d020039_130x130.jpg)](http://video.sina.com.cn/api/outPlayRefer.php/vid=116153277/uid=3603736894/pid=346/tid=1/s.swf) 函数的实际应用讲解 [![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2d40350b72329b279f62a8695d020039_130x130.jpg)](http://video.sina.com.cn/api/outPlayRefer.php/vid=116151476/uid=3603736894/pid=346/tid=1/s.swf) 二、函数的定义 --------------- 1. 函数的定义 我们从一个例子开始，这是一个可以计算任意大小的斐波那契数列的函数：

1

2

3

4

5

6


def fib(n):  # write Fibonacci series up ton 

  """Print a Fibonacci series up ton.""" 

   a, b = 0, 1 

   while a <n: 

       printa, 

       a, b = b,a+b


在详细的介绍函数的定义之前，我们先看看这段代码： line 1：定义函数 line2：还记得吗，这是一行注释，三引号（单引号效果一项） line3：比较奇特，其实就是赋值语句，对于多个变量需要赋值时，可以按照这样的方式来写，看着比较简洁，按照等号前面的变量顺序，逐个将后面的值赋给变量，这里给变量赋的都是整数，其实任意类型都可以，如： aa, bb, cc, dd = 1, 2.3, 1.3e2,“string” line4：while循环语句，注意写这样的语句，不要忘记”:” line5：这一句我们应该很熟了，但是注意a后面的”,”；这表示在print变量a之后，不换行，因为是循环，所以在下次执行这个print语句时，print的内容会跟在上一次print的后面，不会换行；但是，如果没有”,”那每次执行完print都会自动换行 line 6：在line3我们介绍了这是一种赋值的写法，这一句又深入了，赋值的内容是多个表达式 特别再次强调：注意缩进，本例有两层缩进 函数的定义： 要素一：关键字def 要素二：函数名，和变量名的规则差不多，但是一般好的编程风格是将函数名和它实现的功能变现出来 要素三：函数名后面有一对() 要素四：()中可以含有一个和多个参数，当然也可以没有参数 要素五：”:” 要素六：函数体必须缩进 2. 函数的调用 函数在定义了之后，我们只有进行调用，函数才能够执行，其实在使用print语句的时候，我们就是在“调用print函数“。 那如何调用我们在上面给出的示例呢？ ...>>>*# Now call the function wejust defined:*  ...fib(2000)  0 1 1 2 3 5 8 13 21 34 55 89144 233 377 610 987 1597  fib(2000)就是调用，在下面的一行，就是该函数的执行结果，显示了2000以下的斐波那契数列；因为我们在printa后面加了”,”，所以数列显示在一行，否则，这些数将一行一个竖着显示出来。 3. 关于函数的参数 函数的参数对我们初学者，是比较绕的（个人感觉），其实跟我们数学中的函数有异曲同工之处，数学中的函数如： y=f(x) y=f(x1,y1) y=f(x1, x2, …, xn) 所以，我们可以这么理解： 函数的参数就相当于我们数学中函数的自变量。 函数可以没有参数，也可以有一个或多个参数。 还有一种特殊情况： 回想一下print的使用，我们可以： print a 也可以： print a, b, c, d, e 也就是说，参数的数量是可变的。 以上只是简单的概念性介绍，python在函数参数方面还有很多特点： 1) **缺省参数(default argumentvalues)**

1

2

3

4

5

6


deffib(n=2000):   # writeFibonacci series up to n 

  """Print a Fibonacci series up ton.""" 

   a, b = 0, 1 

   while a <n: 

       printa, 

       a, b = b,a+b


这样定义的函数，我们在调用时，可以直接使用 fib()  0 1 1 2 3 5 8 13 21 34 55 89144 233 377 610 987 1597  但是，如果不是缺省参数定义，这样调用系统会报错： ~~~ fib() Traceback (most recent calllast): File"", line 1, in TypeError: fib() takes exactly1 argument (0 given) ~~~ **2) 关键字参数(keywordarguments)** 关键字参数是针对函数调用而进行设计的语法规则； 对于函数： function_ex(arg1, arg2=”arg2”,arg3) pass#关键字，用来占位 我们可以采用以下的几种方法来调用(我们假设参数的类型为string): ~~~ function_ex(“arg1”) function_ex(arg1=”arg111”,“arg333”) function_ex(”arg111”,arg3=“arg333”) function_ex(arg3=”arg333”,arg1=”arg111”,arg2=”arg222”) ~~~ 采用关键字参数可以不按照参数列表的实际顺序，但是尽量按照顺序来写，否则很容易引起错误 4. **函数的返回值** 还是拿我们数学的函数来进行说明： 对于函数： y=f(x) y=f(x1,y1) y=f(x1, x2, …, xn) 如果我们给定自变量值，肯定有一个y值对应，我们可以类似的认为，y就是函数的返回值。 将上面的fib函数稍作修改：

1

2

3

4

5

6

7

8

def fib2(n): # returnFibonacci series up to n 

  """Return a list containing the Fibonacciseries up to n.""" 

   result = [] 

   a, b = 0, 1 

   while a <n: 

      result.append(a)   # seebelow 

       a, b = b,a+b 

   return result

修改之处有： line1：我们重新取了个名，现在函数名为fib2 line3：新增加了一个变量result，还记得吗，[]表示list类型，我们给result初始化成一个空得list，这一句实现了两个目的：一是隐含的说明了result是一个list类型的变量，二是对变量进行了初始化 line6：这句会比较难懂，list类型在前面的博客中已经有介绍，它包含有有很多的“方法(method)“,来实现各种不同的功能，如：append用来添加一个元素到list，pop可以将list的最后一个元素弹出等…，注意这种调用的写法。result.append(a)等同于result= result + [a] line7：返回result 对于返回值，还需要强调： 要素一： 函数可以没有return语句，但在没有return时，返回值是None，这也是一个保留关键字； ~~~ fib(0)  printfib(0)  None ~~~ 要素二： return语句可以没有值，这种情况，也返回None 要素三： 正常情况，return value 下面是一段视频讲解 插入视频 [![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2d40350b72329b279f62a8695d020039_130x130.jpg)](http://video.sina.com.cn/api/outPlayRefer.php/vid=116151408/uid=3603736894/pid=346/tid=1/s.swf) 三、变量的作用域 --------------------- 我们在程序中会定义很多的变量，在引入了函数之后，变量的作用域（或者说变量的可使用范围）就需要仔细的考虑了。 在函数的外面定义的变量，在函数里可以使用吗？ 在函数里定义的变量，在函数体之外还能够使用吗？ 这些都是我们在这一节讨论的问题。 1、局部变量 简单的说，在函数体之内定义的变量，它的作用域就被限定在函数体内，如果在函数体外使用，就会报错 def func_test01(): ...    a1=10 ...    print a1 ...  func_test01() 10 print a1 Traceback (most recent calllast): File"", line 1, in NameError: name 'a1' is notdefined 2、全局变量 如上述，反之就是全局变量，看如下示例： ~~~ a1=1 def test_func(): ...    print a1 ...    print a2 ...  a2=2 test_func() 1 2 ~~~ 就算a2定义在函数的后面，在函数中也是可以使用的 3、强制为全局变量 如果在函数体内声明一个与全局变量一样名字的变量时，这时候，全局变量将被覆盖，如同声明了一个名字一样的局部变量。

1

2

3

4

5

6

7

8

9

def foo():

   print "\ncalling foo()..."

   bar = 200

   print "in foo(), bar is", bar


bar = 100

print "in __main__, bar is",bar

foo()

print "\nin __main__, bar is(still)", bar

得出的输出结果如下： ~~~ in __main__, bar is100 calling foo()... in foo(), bar is 200 in __main__, bar is (still)100 ~~~ 如何解决这种问题？这就需要使用global来强制将变量设为全局变量，改动如下：

1

2

3

4

5

6

7

8

9

10

def foo():

   global bar

   print "\ncalling foo()..."

   bar = 200

   print "in foo(), bar is", bar


bar = 100

print "in __main__, bar is",bar

foo()

print "\nin __main__, bar is(still)", bar

得出的输出结果如下： ~~~ in __main__, bar is100 calling foo()... in foo(), bar is 200 in __main__, bar is (still)200 ~~~ 这样的话，在调用函数之后，bar的值变被更改了。 我的更多文章： - Python程序调试的一些体会(2013-10-06 22:57:35) - 十四、Python编程计算24点（之二）(2013-10-03 22:18:28) - 十三、Python编程计算24点（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - 十二、Python简单数据结构应用（之二）(2013-10-02 22:10:41) - 十一、Python简单数据结构应用（之一）(2013-09-23 23:31:49) - 十、Python编程解决组合问题（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - 九、Python编程解决组合问题（之一）(2013-09-21 23:32:54) - 八、Python的函数编程（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - 六、Python的程序流程(2013-09-19 16:53:58) - 高中生如何学编程(2013-09-02 19:26:01)
';

六、Python的程序流程

最后更新于：2022-04-01 21:47:28

## 六、Python的程序流程 ----From a high schoolstudent's view to learn Python 关键字： python 高中生学编程 MIT公开课视频 Python语言程序流程 判断 循环 一、条件和分支 在Python中代码的逻辑顺序有几种，而条件和分支是很重要的一类。最典型的体现这一逻辑顺序的语句就是if语句。 if语句： 在Python中if语句看起来十分的简单和熟悉，它由三部分组成：关键字，用于判断的条件表达式，以及在表达式为真或假是应该执行的代码。在之前的内容中已经向大家介绍了简单的if语句的写法并且举了几个例子，那么下面就向大家介绍一下一些复杂的if语句。 1.多重条件表达式 一般大家在写程序的时候只会在条件行中写一个条件，但是通过使用逻辑操作符：and,or,not可以将不同的几个判断条件连接在一起从而形成多重判断条件或是否定判断条件，这样做的好处是可以把一些需要用几个if语句表达的条件和在一个里面从而提高了效率。例如：

1

2

3

4

5

6

>>>i=[1,2,3,4]

>>>x=3

>>>if x<9 and x in i:

...  print('trueanswer')

...

true answer

这样就把需要用两句话表达的式子连接在了一起从而不用大家在写第二遍。 2.单一语句的代码块 虽然大家一般把if语句的开头和条件部分写在两行中，但是其实可以合起来写在一行中，但是我并不推荐大家这么写，虽然这样可能会省空间（省了也没用……）但是这很难区分，而且这样也不能分清逻辑的主次关系，并且如果你要添加新的代码，还是要把它移动到另一行。 else语句 在Python中，大家可能会发现写一个if语句只能给条件的一种可能设置该向下执行的代码，如果要给另一种可能设置该怎么办？这里就引入了和if语句搭配的else语句。如果if语句中的条件表达式的结果为false，那么就会执行else语句中的代码，代码和if语句基本相同：

1

2

3

4

5

6

>>>if x<4:

...          print('small')

...   else:

...          print('big')

...

big

需要注意的是，一般在else之后并不需要像if语句那样添加一些条件，因为else的条件就是if语句条件false时的情况。还有就是要注意else语句的摆放，也就是缩进问题。在Python中，else语句应和if语句搭配使用，但是如果有好几个if语句，而你只想把else语句与其中的一个if语句搭配怎么办？这其实很简单，只需要把else语句和你想搭配的if语句对齐，这就是大家不得不再次注意缩进的问题，因为这是一个十分重要的表示代码的逻辑顺序的问题，例如： 第一个

1

2

3

4

5

6

7

8

>>>x=7

>>>if x>0:

...          ifx<8:

...                 print('small')

...          else:

...                 print('big')

...

small

第二个

1

2

3

4

5

6

7

8

>>>x=7

>>>if x>0:

...          ifx<8:

...                 print('small')

...  else:

...          print('big')

...

small

以上这两种代码的含义是不同的，因为第一个代码中的else语句对应的是第二个语句因为它是和其对其的，但是第二个代码中else和最上面的if语句对齐，因此这就体现出了缩进的重要性，如果缩进错了，结果就可能完全不相同。 elif语句 elif顾名思义，就是else-if语句，用它可以检查多个表达式是否为真，elif语句和else语句一样，也是可加可不加，但是不同的是，一个if语句中最多有一个else语句，但是却可以有很多歌elif语句，例如：

1

2

3

4

5

6

7

8

9

>>>x=9

>>>if x>10:

...          print('big')

...    elifx>6:

...          print('middle')

...    else:

...          print('small')

...

middle

这就是条件分支的主要内容。 二、循环 循环也是在Python中十分常见的逻辑顺序，而这里一般是通过while语句和for语句来体现。 1. While语句 While语句实际上是一个条件循环语句，但是和if语句的条件不同，while中的代码会一直循环执行，直到循环的条件为false。While语句的语法其实和if语句有些相似，但是为了让程序循环起来，就必须要给一个每次循环结束时的指令来让下次循环进行，也就是所谓的自增语句。例如：

1

2

3

4

5

6

7

8

9

10

11

12

>>>x=0

>>>while x<7:

...         print("thenumber is " , x)

...          x+=1

...

the numberis  0

the numberis  1

the numberis  2

the numberis  3

the numberis  4

the numberis  5

the numberis  6

这就是一个while语句计数循环的例子。当然有计数循环就会有无限循环，在其中你必须相信的使用while循环，因为他有可能无限次的循环下去，所以大家要看清楚。 2．for语句 我们现在要介绍的就是Python中的另一个循环语句：for语句。它是Python中最为实用并且强大的循环语句。For循环不同于while循环，它可以提供一个可循环的对象，并将对象（列表，元组等刻可迭代对象）全部执行完才会结束循环。例如：

1

2

3

4

5

6

7

8

9

>>>alist=[1, 2, 3, 4, 5]

>>>for eachnumber in alist:

...          print(eachnumber,"is a integer")

...

1 is a integer

2 is a integer

3 is a integer

4 is a integer

5 is a integer

这就是简单的for语句的例子，而不仅仅可以以列表等为循环对象，连字符串都可以，例如：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

>>>for eachletter in 'HelloPython':

...          print("this is letter", eachletter)

...

this is letter H

this is letter e

this is letter l

this is letter l

this is letter o

this is letter P

this is letter y

this is letter t

this is letter h

this is letter o

this is letter n

3. while与for的区别 来看例子： 1到n得自然数进行累加，求累加和小于10000时的最大自然数n的值？ 在循环次数未知时，如果需要使用循环，就需要使用while

1

2

3

4

5

6

sum = 0

i = 1

while sum + i <=10000:

   sum += i;

   i += 1

print "from 1 to %d, the sum is%d(near 10000)" % (i, sum)


再看例子： 从1累加到10000，求累加和：

1

2

3

4

5

sum = 0

for i inrange(1,10001):

   sum += i

   

print "sum 1 to 10000 is equal%d" % sum

4. range的使用说明 range是一个built-in函数，函数定义如下： **range([start],stop[,step])** This is a versatile function tocreate lists containing arithmetic progressions. It is most oftenused in [**for**](http://www.python.org/doc//current/reference/compound_stmts.html) loops.The arguments must be plain integers. Ifthe *step* argument isomitted, it defaults to 1.If the *start* argument isomitted, it defaults to 0.The full form returns a list of plainintegers [start, start + step, start + 2 * step, ...].If *step* is positive, thelast element is the largest start + i * step lessthan *stop*;if *step* is negative, thelast element is the smallest start + i * step greaterthan *stop*. *step* mustnot be zero (or else [**ValueError**](http://www.python.org/doc//current/library/exceptions.html) israised). Example: ~~~ range(10)  [0, 1, 2, 3, 4, 5, 6, 7, 8,9]  range(1, 11)  [1, 2, 3, 4, 5, 6, 7, 8, 9,10]  range(0, 30, 5)  [0, 5, 10, 15, 20,25]  range(0, 10, 3)  [0, 3, 6,9]  range(0, -10, -1)  [0, -1, -2, -3, -4, -5, -6, -7,-8, -9]  range(0)  []  range(1, 0)  [] ~~~ 注意以下几点： - range()返回的是一个list ~~~ type(range(10)) ~~~ - start的缺省参数为0，step的缺省参数为1（*缺省参数将在函数的章节中介绍） - 如果step的值为负数，则产生的序列为倒序 这就是Python中的条件分支与循环的主要内容，下节会向大家讲解函数的知识。 再次强调，对于循环、条件分支语句在写程序的时候千万注意缩进，如果在程序出错的时候，首先要检查的也是缩进是否准确，然后再找其他的问题。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

五、Python的语言基础

最后更新于：2022-04-01 21:47:26

## 五、Python的语言基础 ----From a high schoolstudent's view to learn Python 关键字： python 高中生学编程 MIT公开课视频Python语言基础 数据类型 变量 关键字 1.基本的语句和语法规则 （#）表示之后的代码均为注释（在同一行内）。 （\n）表示换行，是行与行之间的分隔符。 （\）表示继续上一行的代码 （；）表示将两句语言连在一起，但通常是一句一行。 （：）表示将一个程序的开头和身体部分连在一起（十分重要） 缩进对齐：这在之前的内容中已经向大家介绍了，这在Python中十分重要，用来表示语句的逻辑关系，稍有不慎就会造成程序无法运行。 2.标识符，变量，关键字 (1)变量：什么是变量呢？变量就是可变的量，也就是说你可以随便改变它们，给它们赋不同的值，而在Python中，你可以通过将两个元素通过“=”来连接，通俗来说也就是把一个旧的东西贴上一个新的标签，但是这个标签可以随时更改。我们来看个例子：

1

2

3

4

5

6

>>>MyExample= 6

>>>print(MyExample)

6

>>>MyExample=7

>>>print(MyExample)

7

 

增量赋值：增量赋值就是把等号和一个算数操作符连在一起，从而将计算结果重新赋给左边的元素。就像：x=x+1，也可以写成：x+=1，这种增量赋值法也被使用在给列表赋值的时候。 多重赋值：多重赋值就是同时把几个变量赋成同一个值。 多元赋值：多元赋值就是同时把多个变量赋成不同的各自的值。 (2) 标识符： 标识符是电脑语言中允许作为名字的有效字符串集合，说白了就是一个名字，一个和身份。其中有一部分是关键字，也就是构成语言的标识符。这种关键字举例来说就是像：and,class, elif, if, while, for, import,not等，虽然这其中有许多大家可能不认识，但是向for这些关键字是在Python中本身就有特殊含义的词，因此不能用于其他用途，否则会引起语法错误（SyntaxError）。除了关键字以外，Python中还有一些被称为“内建”的标识符的集合（built-in）例如：int,float, long, bool,complex等。虽然这些不是关键字，但是我们应该把它们当成关键字，尽量避免来使用它们，因为不这样做的话经常会混淆并产生歧义。 正确的标识符命名方法： υ第一个字符必须是字母或者下划线。 υ剩下的字母可以是数字，字母或者下划线 υ大小写是有区别的 3. 简单的数据类型 首先要向大家介绍的是数字，内容来自[www.python.org](http://www.python.org) (1) Numeric literals There are four types of numericliterals: plain integers, long integers, floating point numbers,and imaginary numbers. There are no complex literals (complexnumbers can be formed by adding a real number and an imaginarynumber). Note that numeric literals donot include a sign; a phraselike -1 is actually an expressioncomposed of the unary operator ‘-‘ and theliteral 1. Integer and long integerliterals Integer and long integerliterals are described by the following lexicaldefinitions: longinteger   ::=  integer ("l"| "L") integer      ::=  decimalinteger | octinteger | hexinteger | bininteger decimalinteger ::=  nonzerodigit digit*| "0" octinteger    ::= "0" ("o" | "O") octdigit+| "0" octdigit+ hexinteger    ::= "0" ("x" | "X") hexdigit+ bininteger    ::= "0" ("b" | "B") bindigit+ nonzerodigit  ::= "1"..."9" octdigit      ::= "0"..."7" bindigit      ::= "0" | "1" hexdigit      ::=  digit |"a"..."f" | "A"..."F" 其中“longinteger”指的是长整型，通常用“l”,“L”来表示，decimalinteger指的是十进制数，也就是我们通常在数学中用到的计算方法。Octinteger指的是八进制数，也就是说从只有0到8，到9之后就会进位。Hexinterger指的是16进制数，也就是各位包含0到15，而在9之后用数字无法表示，就需要用A到F来表示，也就是用1到F来表示。Bininteger表示是二进制数，也应该是大家除了十进制数外最熟悉的计算方式，因为是二进制，所以各位只有0和1两个数，之后就会进位。 关于十进制与其它进制之间的转换方法： 在Python中，进制的转换是不需要人为计算的，只需在打出固定形式的进制数，然后在打印出来，就是十进制的数字了。例如：八进制数：0o+进制数   16进制数：0x+进制数    二进制数0b+进制数。 下面来举几个例子： a=0xff a 255 这是16进制数的转换 a=0o10 a 8 这是8进制数的转换 a=0b00101 a 5      这是2进制数的转换 (2) Floating pointliterals（浮点数） Floating point literals aredescribed by the following lexical definitions: floatnumber  ::=  pointfloat | exponentfloat pointfloat   ::= [intpart] fraction | intpart "." exponentfloat ::= (intpart | pointfloat) exponent intpart      ::=  digit+ fraction     ::= "." digit+ exponent     ::= ("e" | "E") ["+" | "-"] digit+ Note that the integer andexponent parts of floating point numbers can look like octalintegers, but are interpreted using radix 10. Forexample, 077e010 is legal, anddenotes the same number as 77e10. The allowedrange of floating point literals is implementation-dependent. Someexamples of floating point literals: 3.14   10.   .001    1e100   3.14e-10   0e0 Note that numeric literals donot include a sign; a phraselike -1 is actually an expressioncomposed of the unaryoperator - and theliteral 1. (3) Imaginaryliterals（虚数） Imaginary literals aredescribed by the following lexical definitions: imagnumber ::= (floatnumber | intpart)("j" | "J") An imaginary literal yields acomplex number with a real part of 0.0. Complex numbers arerepresented as a pair of floating point numbers and have the samerestrictions on their range. To create a complex number with anonzero real part, add a floating point number to it,e.g., (3+4j). Some examples of imaginaryliterals: 3.14j  10.j    10j    .001j  1e100j  3.14e-10j 当然在认识完数字之后，我们还需要用数字来进行运算，这就不可避免的要介绍一下运算符。运算符分为两类：算术运算符，比较运算符和逻辑运算符两种。 (1)算术运算符：之前给大家大概介绍过算术运算符，这里就在补充几点，就是关于运算的顺序问题，其实这和数学中的运算顺序差不多：()的优先级最高，如果有嵌套的圆括号，则先计算最内层的圆括号内的表达式。如果同一层内有多对并列的而非嵌套的圆括号，则是从左向右计算。*，/，%(求余)的优先级次之，若果有多个，则从左向右计算。+，-的优先级最低，如果有多个，则从左向右计算。虽然这些很基础，但是大家在写程序的时候也要注意。例如：

1

2

3

4

5

6

7

8

>>>(1+3)*4

16

>>>1+3*4

13

>>>3*4/(4*7)

0.42857142857142855

>>>3*4/4*7

21.0

(2)比较运算符：比较运算符在前面也向大家较为详细的讲过了，主要有相等运算符==，! =和关系运算符>< >=<=两种，但是要注意的就是==和=不要相互混淆，=是赋值的意思。 (3) 逻辑运算符：这个也在之前讲过，主要有and, or,not三种。and就是两者全部正确才是true。or就是两者中有一个正确就算true。not就是取非的意思。Python的语言基础 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

四、Python语言简单介绍

最后更新于：2022-04-01 21:47:23

## 四、Python语言简单介绍 ----From a high school student'sview to learn Python 关键字：高中生 学编程 Python语言 Python语言安装 （一）、下载和安装Python 下载Python最直接的方法就是访问它的官网（[www.python.org](http://www.python.org)），然后点击屏幕左侧的 “download”选项。点击之后就会进入如下的界面： [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/d697f9b22a73843d39c21a67e360978b_955x540.jpg "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbGnJAch91&690) 接下来大家就可以根据自己电脑的系统来选取各自的下载资源，在电脑平台中，主要还是针对Win,Unix, Mac OSX这三大平台。但是Python可应用的平台十分广泛，不仅仅是前面所提到的电脑平台，手机平台上也可以进行Python语言的学习与使用，例如：Android,IOS等等。 注意：因为这个教程针对的是Python3.0以下的版本，所以大家最好选择Python 2.7.5来下载。而为什么选择Python2.7.5呢，是因为Python3.0的升级是革命性的，把以前的一些特性抛弃了，当然也引入了很多新的特性，因此并不具备向前的兼容性，而且许多的第三方软件并没有针对Python3.0进行移植，所以还是Python2.7.x更实用。 在下载完成之后就直接进行安装，安装时我们尽量选择按照提示的缺省目录来进行操作，然后我们就可以来运行Python了。 （二）、运行Python 总体来说有三种方法来运行Python，今天先向大家介绍前两种较为简单的运行方法。 (1)     在命令行上启动解释器 按Windows键+R，输入CMD [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8NJzz49&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/fcfb77cec2bdc5ca68dcb8a7f92a5a44_723x364.jpg) 之后找到python目录，运行python [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8RPsx8d&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/a237a696a464a4d7c30d3a269b2ad379_846x690.jpg) 显示如下： [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8Mx8Na5&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/3f965443db4d6cd9a0eddbf7be5cd0ff_846x165.jpg) 我们就可以打开命令行来编写最简单的代码了。但是这种命令行只能每次输入一行代码来执行，效率太低。 (2)    在简单的集成开发环境内运行 这里所说的简单集成环境就是IDLE，它适合去编辑一些简单短小的代码，对于初学者来说是完全够用的。 IDLE在哪呢？如果按照缺省目录安装则在：C:\Python27\Lib\idlelib [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8MW7Qce&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/29f706f87d84713ae38018192d23428d_846x319.jpg) 或者直接在搜索目录中查找IDLE然后运行，就会出现如下窗口： [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8M6R7f5&690) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/76bca3949ab47e7232946f45bd537c8e_846x221.jpg) 接下来点击左上角的File然后选择NewWindow就可以通过新的File来编写代码了。 [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/bfea4b6df70752b35575f7fbed8dfdd8_846x217.jpg "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8VAwJ35&690) 在编写完一个程序后，将文件保存为类型为.py的文件，点击菜单“run”，再点击”RunModule”或者直接按“F5”键运行。 [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/839da6280bc0ae75cd31e5fce148ceb9_846x269.jpg "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8XZog7c&690) 之后，如果运行正常，弹出的窗口中就会显示运行的结果： [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/1fe1aa59209d96ac148aff0adfe50cfc_857x246.jpg "四、Python语言简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbG8WLoE64&690) （3）第三种方法 还有一些第三方的专门的软件可以用来进行Python的开发，而且比上面介绍的两种方法都高级，但是工具的安装比较复杂，我们还是先把精力用在语言学习上吧，等后续有必要的时候在介绍。 作为一门解释性的语言，Python的简洁与纯粹使用提供了一个更加快速的开发环境，Python的语法十分简单，更加易懂，相比于C++和JAVA来说用Python编程可以生许多时间。 并且Python适用范围广泛，它最大的优势就是在网页的编辑上，但是在和计算机的“底层”打交道时（例如直接操控一些硬件），Python的效率就会相当低下，但是它是十分适合没有计算机语言基础的初学者来学习。 （三）、Python的快速介绍 Python包含的主要元素： 1. 输入与输出 一般的，在Python中想要输入一些内容，只需要在平台中打出你想要的内容即可，而输出程序则是用print函数来进行。 2. 注释  注释就是在写代码的过程中，程序员希望用一些语句来帮助他在以后返回看自己所写的程序，而这些语句并不能够出现在真正的代码当中。所以在Python中，语句一般用#标示注释，从#开始到一行结束都是注释。 例：

1

print (“hello”) # commentone

注释还有一种方式就是使用三个”””，在后面的程序中会有使用及说明。 3. 操作符 操作符就是大家日常学习工作中会用到的一些符号，像+、-、*、/、//、**(乘方)、%等标准操作符，还有一些比较操作符，像<  > <= >=  == !=(不等于)<>(判断两个数不相等)。 还有一些逻辑操作符：and or not。这些操作符大家可以在命令行中或者IDLE中自己试一下。 例：

1

2

3

4

5

6

7

8

9

10

>>>3+5

8

>>>3<4

True

>>>3!=4

True

>>>2>4 and 3<4

False

>>>2>4 or 3<4

True

4. 变量和赋值  变量简单来说就是类似于方程中的x,y这一类有名字的元素，变量名就是一些字母开头的标示符，中间可以带有数字，下划线等。变量的赋值就是把变量和数字用等号连接起来，从而给变量一个具体的值。赋的值并不一定要是数字，也可以是字符串（接下来会介绍）。

1

2

3

4

5

6

>>>start=2

>>>start

2

>>>second="two"

>>>second

'two'

5. 数字  Python中支持五中基本数字类型，分别是： 1) 有符号整型：int  如：231   56  -342 2) 长整数

1

2

3

4

5

6

>>>a=1234569l

>>>type(a)

<type'long'>

>>>b=-12345678901234567890123l

>>>type(b)

<type'long'>

>>> 

注意后面有一个“L”跟着。   3) 布尔型：bool  True   False 在这里要说的是布尔型是一个特殊的整型，但是要把它放在一个数字的环境中时，Treu用1表示，而False用0表示 4) 浮点型：float  3.1423 5) 复数：complex  0+73j   -32-549j 6.字符串  在Python中字符串被定义成引号之间字符的集合。Python中可以对字符串进行多种操作，包括索引，切片，串联字符串，重复字符串等等。 [![四、Python语言简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "四、Python语言简单介绍")![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/6c492e551820ebb7686c1d365cb402bb_521x69.jpg)](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101ejcj&url=http://album.sina.com.cn/pic/d6cca93egx6DbIRU3oW66&690) 绿色的部分就是字符串 7. 列表和元组（list andtuple）  列表和元组可以被认为是普通的数组，它能够包含任意数量，任意类型的Python对象，但是列表和元组之间还是有一定的区别。列表用中括号（[]）来包括，列表中元素的个数和元素的值均可以被改变，而元组则用小括号（()）包括，而且元素不可以被更改。下边是列表和元组的例子：

1

2

3

4

5

6

>>>alist=[1, 2, 3, 4, 'hello']

>>>alist

[1, 2, 3, 4,'hello']

>>>atuple=(1, 2, 3, 4, 'hello', 'Python')

>>>atuple

(1, 2, 3, 4, 'hello','Python')

现在看上去似乎列表和元组没有什么区别，但是在之后的内容中我会想大家详细的介绍各种对于列表和元组的操作。 8. 字典  字典是Python中的映射数据类型，其实简单上来说就是把一些对象赋值，这些对象在字典中称为键，而赋的值也可以是任意类型的Python对象，字典元素用大括号（{}）包括,如果要取出一些字典中的键，则用中括号来包裹元素。在接下来的内容中会向大家详细介绍字典。例如：

1

2

3

4

5

>>>first_Dict={ 'Hello': 'Python', 'First': 1}

>>>first_Dict

{'First': 1, 'Hello':'Python'}

>>>first_Dict ['Hello']

'Python'

9. Python语法中的缩进对齐   Python中经常用缩进对齐来表示代码的逻辑，而不是使用大括号。这使得程序的可读性更高，但是对于一个Python的初学者来说，仅使用缩进可能会使他感到奇怪并且十分的困惑，而且会非常的不适应。在我一开始学习的时候就经常因为缩进的距离错误导致程序无法运行。但是在我使用这种方式一段时间以后，我发现其实并不是太困难去接受。 10. if 语句 if语句是Python中最为基础的语句，它的意思简单来说就是如果一个条件被满足，就会向下执行下面的条件，这就相当于是一个条件语句，我们可以来看几个例子：

1

2

3

4

5

>>>x=-1

>>>if x<0:

...  print('hello')

...

hello

 这是一段十分简单的代码，那么大家就可以看到了，if语句就相当一个条件满足了之后就会运行下一层的代码，但是在if语句下的一层代码要注意缩进。 11. while循环  while循环语句的语法与if语句的时分类似，但是while是一个循环语句，它会一直不断的执行循环，直到表达式的值变成0或者False，我们来看下例子：

1

2

3

4

5

6

7

8

9

>>>x=1

>>>while x<5:

...  print('circle#% x' % x)

...  x+=1

...

circle # 1

circle # 2

circle # 3

circle # 4

 这就是最简单的while循环语句，如果不给它一个结束条件的话，循环就会一直进行下去，而且也要注意缩进。接下来的内容会向大家详细介绍while循环。 12. for循环 for循环不同于while循环的是for循环通常是包含一个徐序列，就像是在以区间内执行一个循环一样，例如range(),列表和元组甚至是字典内执行循环，例如：

1

2

3

4

5

6

7

8

>>>alist=[1, 2, 3, 4]

>>>for i in alist:

...  print(i)

...

1

2

3

4

就像上面这个循环中所说的，for循环是在给定的alist之中执行的，而while循环则没有这些条件。 我的更多文章： - Python程序调试的一些体会(2013-10-06 22:57:35) - 十四、Python编程计算24点（之二）(2013-10-03 22:18:28) - 十三、Python编程计算24点（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - 十二、Python简单数据结构应用（之二）(2013-10-02 22:10:41) - 十一、Python简单数据结构应用（之一）(2013-09-23 23:31:49) - 十、Python编程解决组合问题（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - 九、Python编程解决组合问题（之一）(2013-09-21 23:32:54) - 八、Python的函数编程（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - 七、Python的函数编程（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - 高中生如何学编程(2013-09-02 19:26:01)
';

三、计算机语言的介绍

最后更新于：2022-04-01 21:47:21

## 三、计算机语言的介绍 ----From a high school student's view to learnPython 关键字：高中生 学编程 Python语言 计算机语言 初学者如何选择计算机语言  在之前的博文中给大家大概的阐述了一下计算机的组成，可是计算机到底是怎样来执行各种指令的呢，本篇主要介绍这方面的内容。 由于涉及到计算机原理方面的内容都比较高深，我还是采用摘录的方式来进行组织，大部分的内容来源于《**计算机组成与设计:硬件/软件接口**》，第四版，非常非常好的书，很容易看懂。 [第一章](http://images.china-pub.com/ebook190001-195000/194732/ch01.pdf) [第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf) （一）、计算机指令 主要了解计算机是如何运行的： 1、     阅读[第一章](http://images.china-pub.com/ebook190001-195000/194732/ch01.pdf)的1.2小节“从高级语言到硬件语言”，主要明白机器所识别的语言以及高级语言是如何转变为机器能够识别的语言 2、     阅读[第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf)的2.1、2.2明白机器指令的概念，了解一般的机器指令如何分类、作用 3、     阅读[第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf)的2.3小节，明白寄存器、存储器的区别，大致理解高级语言与机器语言的转换 4、     阅读[第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf)的2.4小节，这一节非常的重要，计算机的基础，二进制必须搞明白 5、     [第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf)的2.6小节，介绍计算机如何实现基本的逻辑操作 6、     [第二章](http://images.china-pub.com/ebook190001-195000/194732/ch02.pdf)的2.7小节，介绍计算机的基本结构化指令：判断和决策、循环 这些章节的阅读，对于进一步理解计算的基本原理以及计算机语言的初步了解非常有帮助。 （二）、计算机语言的历史：(Programming Language Cultures) Programs for modern computersconsist of sequences of instructions that are encoded as numericdigits. This encoding system is known as a machine language.Unfortunately, writing programs in a machine language is so tediousthat often leads to errors that must be corrected before the job isfinished. In the 1940s, researcherssimplified the programming process by developing notational systemsby mnemonic instructions. With the development of mnemonic system,a programs called assemblers were developed to convert mnemonicexpressions into machine language instructions. Then computersscientists began developing programming languages that were moreconducive to software development that those assembly languages.The result was the emergence of a third generation of programminglanguages that were both higher level and machine independent (inthat they did not rely on the characteristics of a particularmachine). The third generation of programming languages containFORTRAN, COBOL, and ALGOL.   6 0年代中后期，出现了“软件危机”。软件越来越多，规模越来越大，因为缺乏科学规范的系统规划与测试、评估标准，所以建立起大批耗费巨资的软件系统，这些软件系统含有错误而无法使用，因此给人的感觉是越来越不可靠，以致几乎没有不出错的软件。这时人们认识到大型程序的编制不同于写小程序，它应该是一项新的技术，应该像处理工程一样处理软件研制的全过程。程序的设计应易于保证正确性，也便于验证正确性。后来有人提出了“结构化程序设计方法”。终于，第一个结构化程序设计语言—Pascal语言在1970年出现了，这标志着结构化程序设计时期的开始。 In the beginning of 1980s, therewas a great revolution on the design of software, which was theobject-oriented paradigm, which is associated with the programmingprocess called object-oriented programming. Following thisparadigm, a software system is viewed as a collection of unitscalled objects, each of which is capable of performing the actionsthat are immediately related to itself as well as requestingactions of other objects. Together, these objects interact to solvethe problem at hand. C++, VB, Delphi is the typicalrepresentation. （三）、计算机语言的种类 计算机语言有许多，具有代表性的一些高级语言有FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、C、PROLOG、Ada、C++、VC、VB、Delphi、JAVA等。 下面就向大家介绍几种： 1.BASIC BASIC（Beginners' All-purpose Symbolic InstructionCode，又译培基），意思就是“初学者的全方位符式指令[代码](http://baike.baidu.com/view/41.htm)”，是一种设计给初学者使用的[程序设计语言](http://baike.baidu.com/view/128511.htm)。BASIC是一种直译式的[编程语言](http://baike.baidu.com/view/552871.htm)，在完成编写后不须经由编译及连结等手续即可执行，但如果需要单独执行时仍然需要将其建立成执行档。[BASIC语言](http://baike.baidu.com/view/329004.htm)是由Dartmouth学院JohnG.Kemeny与ThomasE.Kurtz两位教授于1960年代中期所创。由于立意甚佳，BASIC语言简单、易学的基本特性，很快地就普遍流行起来，几乎所有小型、微型家用电脑，甚至部分大型电脑，都有提供使用者以此种语言撰写程式。 2.Visual Basic Visual Basic is anobject-oriented programming language that was developed byMicrosoft as a tool by which users of Microsoft’s Windows operatingsystem could develop their own GUI applications. Actually, VisualBasic is more than a language, it is an entire software developmentpackage that allows a programmer to construct applications frompredefined components and to customize these components bydescribing how they should react to various events. 3.JAVA Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言，是由[SunMicrosystems](http://baike.baidu.com/view/1061350.htm)公司于1995年5月推出的Java程序设计语言和[Java平台](http://baike.baidu.com/view/209634.htm)（即JavaSE,JavaEE, JavaME）的总称。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于个人PC、[数据中心](http://baike.baidu.com/view/754520.htm)、游戏控制台、[科学](http://baike.baidu.com/view/3805.htm)[超级计算机](http://baike.baidu.com/view/296324.htm)、移动电话和[互联网](http://baike.baidu.com/view/6825.htm)，同时拥有全球最大的开发者专业社群。在全球云计算和移动互联网的产业环境下，Java更具备了显著优势和广阔前景。 4.Python Python is programming languagethat was created by Guido van Rossum in the late 1980s. Today it ispopular in developing Web applications, in scientific computationand as an introductory language for students. Python emphasizesreadability, and includes elements of the imperative,object-oriented, and functional programming paradigms. Python isalso an example of a modern language that uses a form of fixedformatting. It uses indentation to denote program blocks, ratherthat punctuation marks or reserved words. 5．C/C++ C语言是在70年代初问世的。一九七八年由美国电话电报公司(AT&T)贝尔实验室正式发表了C语言。同时由B.W.Kernighan和D.M.Ritchit合著了著名的“THEC PROGRAMMING LANGUAGE”一书。通常简称为《K&R》，也有人称之为《K&R》标准。但是，在《K&R》中并没有定义一个完整的标准C语言，后来由美国国家标准协会在此基础上制定了一个C 语言标准，于一九八三年发表。通常称之为ANSI C。 在C的基础上，一九八三年又由贝尔实验室的Bjarne Strou-strup推出了C++。 C++进一步扩充和完善了C语言，成为一种面向对象的程序设计语言。MicrosoftVisualC++ 基本上是windows系统下的最主要开发工具。 C++提出了一些更为深入的概念，它所支持的这些面向对象的概念容易将问题空间直接地映射到程序空间，为程序员提供了一种与传统结构程序设计不同的思维方式和编程方法。因而也增加了整个语言的复杂性，掌握起来有一定难度。 但是，C是C++的基础，C++语言和C语言在很多方面是兼容的。因此，掌握了C语言，再进一步学习C++就能以一种熟悉的语法来学习面向对象的语言，从而达到事半功倍的目的。 同时，现在非常火热的苹果系统（macos以及IOS）都采用Objective C，它也是一个C语言为基础的扩展集。    到底选择一门什么样的语言作为自己第一门入门、学习的语言呢？其实在之前也有过简单的说明，Python作为入门是非常合适的，准备工作非常的简单，所需的软件也都免费，虽然Microsoft也提供免费的基础版本软件，但Microsoft的东西向来以庞大、复杂著称，所以，如果自学，首选还是Python，在有相当的基础之后，我们在开始接触C语言、C++语言或者ObjectiveC，关键还看你准备在哪个操作系统平台上进一步学习。 （四）、结束 这几篇的内容，写起来非常的纠结，都是基础、比较理论，对于大多数的只是我也属于初学者，所以为了不让大家走弯路，引用一些书籍上的内容，当然，更详细的内容还需要大家去进一步的阅读。相关的资料都有链接供大家直接使用。 最后，也添加一个MIT公开课的视频剪辑，也是关于计算机语言方面的。 我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

二、计算机系统的简单介绍

最后更新于：2022-04-01 21:47:19

## 二、计算机系统的简单介绍 ----Froma high school student's view to learn Python 关键字：高中生 学编程 Python语言 计算机系统 计算机架构及原理  本篇主要介绍一下计算机系统的基本构架及简单原理（这是每个ComputerScience初学者的必修课）。大部分的内容摘录自一些教材，由于我们只需要进行初步的了解，所以我发现利用www.china-pub.com网站上，很多经典的计算机教材，都有试读章节，而这些试读章节一般都是前面的1-3章，中文、英文都有，但这些书籍后面的章节讲的都很深，所以我们可以进行充分的利用试读。 本篇的内容是偏向理论的，但我也没有很深入的掌握，所以我还是从搞清楚对计算机的一些模糊认识着手，然后介绍一些基本架构，为了便于直观认识，本篇会多插入一些图片。 （一）认识计算机 计算机对于大家都非常熟悉了，我们主要看看计算机的内部结构，先看看最酷的苹果macbook pro: [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/e48efe6dfc33dfc00fb4d4177afb8d11_900x410.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwlbL1e7&690) [](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwllU541&690) 虽然机器很薄，但是内部该有的东西，一样不少，看看里边的结构吧：[](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwlbL1e7&690) [](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwBfgE1c&690) [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/6854a6d15d7143433aebf1d1c7959e5d_888x667.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwBfgE1c&690) 非常紧凑的结构 [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/99e4c9795c334fcab6c14112b05b89c3_888x667.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwllU541&690) [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/d127da85e261558d3f2f02e9c7a62c6d_888x667.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwuEHW54&690) 这是拆开后的主板正反面，上面有：内存、cpu、各种接口、总线控制器 [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/f303ed83b22e01633d29783a4ea316b9_888x667.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwkSMS0e&690) 这是完全拆解的图，大家有兴趣可以去看看ifixit.com,这家公司只一家专门拆机的公司，只要市面上已发布新产品，不管是计算机还是手机，在别人还没有开始用的时候，他们就开始发拆机图了。 苹果的设计如何好，我们就不在这夸了，再看看我们日常使用的计算机内部的结构，这个就没有那么复杂了，打开机箱就可以看见： [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/4e5ed44a5c6370851f19a9321a0fa6da_788x1112.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6Dbqx4eUdc5&690) 引一大堆线出来的是电源 躺在里面的大板是计算机主板 风扇下面的是CPU 四条蓝色的是内存条 带“GEFORCEGTX”字样的是显卡 红色扁线连着的是计算机的硬盘 有的机器还会插一些其他的接口卡，如：网卡、声卡、蓝牙卡、无线网卡等 好像也就这些了 （二）计算机分类 1. 个人移动设备 个人移动设备(PMD)是指一类带有多媒体用户界面的无线设备,比如手机、平板电脑 等。由于整个产品的零售价格为数百美元,所以成本成为一个关键因素。尽管经常会因为使用电池而需要强调能效,但由于需要使用相对便宜的外壳(由塑料制成),而且缺少冷却风扇,所以也限制了总功耗。PMD上的应用程序经常是基于Web 应用、面向媒体的,比如新浪微博。能耗与尺寸要求决定了要采用闪存而不是磁盘来作为存储方式。 响应性能和可预测性能是多媒体应用程序的关键特性。实时性能需求是指应用程序的一个程序段有一个确定的最大执行时间。例如,在 PMD 上播放一段视频时,由于处理器必须在短时间内接收和处理下一个视频帧,所以对每个视频帧的处理时间是有限的。如果仅仅是偶尔违反一个事件的时间约束条件(而非过多地发生这种情况),就可以采用有时被称为软实时的方法。这个大家感受最深的就是使用手机看视频，如果信号不好的时候就会出现卡顿。 许多 PMD 应用程序中还有其他一些关键特性:需要将存储器占用减至最少,需要高效利用能量。电池容量和散热问题都需要提高能耗效率。存储器可能在系统成本中占有很大的比例, 在这种情况下,存储器优化是非常重要的。由于应用程序已经决定了数据规模,所以重视存储器用量其实就是要重视代码规模。 2. 桌面计算 以资金而论,一级市场(可能仍然是最大的市场)是桌面计算市场。桌面计算覆盖了从低端到高端的整个产品范围,既有售价不到 300 美元的低端上网本,也有售价可能达 2500 美元的高端高配工作站。从 2008 年开始,每年生产的桌面计算机中有一半以上是由电池供电的笔记本计算机。 在整个价格与性能范围内,桌面计算机市场都有优化性价比的趋势。系统的性能(主要以计算性能和图形性能来衡量)和价格对这个市场中的客户来说是最重要的,因此对计算机架构师也是最重要的。结果,最新、最高性能的微处理器和低成本微处理器经常首先出现在桌面系统中。 尽管以 Web 为中心的互动应用日益增多（类似网游这样的应用越来越多，不需要下载很大的文件到本地计算机）,为性能评估带来了新的挑战,但根据应用和基准测试还是能够较好地刻画桌面计算的特征。 3. 服务器 自 20 世纪 80 年代开始转向桌面计算机以来,服务器的角色逐渐变为提供更大规模、更可靠的文件和计算服务。这些服务器已经代替传统的大型机,成为大规模企业计算的中枢。 对服务器而言,所强调的特征不同于桌面计算机。首先,可靠性是至关重要的。考虑一下运行银行 ATM 机或者航班订票系统的服务器。由于这些服务器必须每周 7 天、每天 24 小时不间断工作,所以此类服务器系统发生故障时产生的灾难性后果要远比单个桌面计算机故障严重。 服务器系统的第二个关键特征是可扩展性。服务器系统经常需要扩展,以满足其所支持服务的增长需求,或者对功能的增长需求。因此,服务器扩展计算容量、内存、存储器和 I/O 带宽的能力极为重要。 最后一个特征,服务器的设计应使其具有很高的吞吐能力。也就是说,服务器的整体性能 (每分钟处理的事务数或者每秒提供的网页数)才是最重要的。尽管对单个请求的响应速度依然重要,但总体效率和成本效益(由单位时间内能够处理的请求数决定)才是大多数服务器的关键度量。 4. 集群/仓库级计算机 软件即服务(SaaS)应用(比如搜索、社交网络、视频分享、多人游戏、在线销售等)的发展已经推动了一类被称为集群的计算机的发展。集群是指一组桌面计算机或服务器通过局域网连接在一起,运转方式类似于一个更大型的计算机。每个节点都运行自己的操作系统,节点之间使用网络协议进行通信。最大规模的集群称为仓库级计算机(WSC),它们的设计方式使数万个服务器像一个服务器一样运行。 WSC 与服务器的相通之处在于它们都非常看重可用性。例如,Amazon.com 在 2010 年第四季度的销售额为130 亿美元。一个季度大约有 2200 个小时,每小时的平均收入差不多是 600 万美元。在圣诞节购物的高峰时间,潜在损失可能要多出许多倍。WSC 与服务器的区别在于,WSC 以很多廉价组件为构建模块,依靠软件层来捕获和隔离在这一级别进行计算时发生的许多故障。注意,WSC 的可扩展性是由连接这些计算机的局域网实现的,而不是像服务器那样,通过集成计算机硬件来实现。 WSC重视互动应用程序、大规模存储、可靠性和很高的因特网带宽。 5. 嵌入式计算机 嵌入式计算机在日用电器中随处可见。微波炉、洗衣机、大多数打印机、大多数网络交换机和所有汽车中都有简单的嵌入式微处理器。 PMD 中的处理器经常被看作是嵌入式计算机,但我们仍然把它们看作一个不同类别,这是因为 PMD 是一些可以运行外部开发软件的平台,它们与桌面计算机有许多共同特征。其他嵌入式设备在硬件和软件复杂性方面都有很大的限制。我们以能否运行第三方软件作为区分嵌入式和非嵌入式计算机的分界线。 嵌入式计算机的处理能力和成本差别最大。它们既包括只需要 0.1 美元的 8 位和 16 位处理器,也有可以每秒执行 1 亿条指令、价格低于 5 美元的 32 位微处理器,还有用于网络交换机的高端处理器,它们的售价高达 100 美元,每秒可以执行数十亿条指令。尽管嵌入式计算市场中的计算能力相差很大,但价格仍然是此类计算机设计的关键因素。性能要求当然是的确存在的, 但主要目标通常是以最低价格满足性能需要,而不是以更高的价格来获得更高的性能。 本节的内容主要来源于前面介绍的试读章节（[点击](http://images.china-pub.com/ebook3020001-3025000/3021578/ch01.pdf)），其实有些内容我也是一知半解，慢慢学习吧。 （三）认识计算机系统 计算机系统由硬件和软件两大部分组成. [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6Dbqy6VtL09&690) ![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/74ec0f306274b9bbdfb5e8c18c3dcc67_900x377.jpg "二、计算机系统的简单介绍") 硬件的组成(输入设备,输出设备,存储器,运算器,控制器)
1.输入设备:使计算机从外部获得信息的设备如鼠标,键盘,光笔,扫描仪,话筒,数码相机,摄像头, 手写板 
2.输出设备:把计算机处理信息的结果以人们能够识别的形式表示出来的设备如显示器,打印机,绘图仪,音箱,投影仪 
3.存储器(DataStorage): disk, magnetic tape storage mechanism, CD storage,DVD
4.CPU: the circuitry in a computer that controls themanipulation of data is called central procession unit. CPUconsists of three parts: the arithmetic/logic unit that containcircuitry that performs operations on the data; the control unit,which contains data storage cells; and the registers unit, thatused for temporary storage of information within theCPU. [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/ad3fdcc6fac28fe34d51dbbf46a6c39b_1009x853.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbtxCba61e&690) 软件的组成 
软件定义:程序和有关文档资料的合称 
软件分类:系统软件(使用和管理计算机的软件)和应用软件(专为 
某一应用编制的软件) 硬件和软件合二为一形成一个现在大家所熟知的计算机。软件就像是人们给计算机的指令，而这些指令需要一个平台或者是媒介去表现出来，而这种媒介就是硬件。当然我所要和大家分享的Python语言的学习经验是属于软件学习方面的 下面的这段视频是我摘自于MIT的公开课的内容，其中介绍了一些计算机组成的知识，我觉得还是讲的挺有启发的，大家可以看一下。 [无法嵌入视频，给出链接](http://video.sina.com.cn/api/outPlayRefer.php/vid=115054718/uid=3603736894/pid=346/tid=1/s.swf)  [![](image/d41d8cd98f00b204e9800998ecf8427e.jpg)](http://video.sina.com.cn/api/outPlayRefer.php/vid=115054718/uid=3603736894/pid=346/tid=1/s.swf) [![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2d40350b72329b279f62a8695d020039_130x130.jpg)](http://video.sina.com.cn/api/outPlayRefer.php/vid=115054718/uid=3603736894/pid=346/tid=1/s.swf) （四）各部分的结构原理 储存器： 1.       Magneticdisk: a thin spinning disk with magnetic coating is used to holddata. There is a read head above the disk so that as the diskspins, each head traverses a circle, called a track. 2.       Magnetictape: in these systems, information is recorded on the magneticcoating of a thin plastic tape that is wound on a reel for storage.The tape is mounted in a device called a tape drive that can read,write and rewind the rape to access the data. 3.       CD(compact disk): the information on these CDs is stored on a singletrack that spirals around the CD like a groove in an old-fashionedrecord, however, unlike the old-fashioned, the track spirals fromthe inside out. Also there are DVDs and BDs which have largercapacity. CPU： 由晶体管组成的CPU是作为处理数据和执行程序的核心，其英文全称是:CentralProcessing Unit，即中央处理器。 [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/02b3cbf6ecca3c59dfc5c3f49d4f00e7_550x287.jpg "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6DbqwRjZ973&690) 首先，CPU的内部结构可以分为控制单元，逻辑运算单元和存储单元三大部分。CPU的工作原理就像一个工厂对产品的加工过程:进入工厂的原料(程序指令)，经过物资分配部门(控制单元)的调度分配，被送往生产线(逻辑运算单元)，生产出成品(处理后的数据)后，再存储在仓库(储存单元)中，最后等着拿到市场上去卖(交由应用程序使用)。在这个过程中，我们注意到从控制单元开始，CPU就开始了正式的工作，中间的过程是通过逻辑运算单元来进行运算处理，交到储存单元代表工作的结束。 ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/6778a8a3acddda8b0bf7432702342fbf_919x639.jpg) [![二、计算机系统的简单介绍](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "二、计算机系统的简单介绍")](http://photo.blog.sina.com.cn/showpic.html#blogid=d6cca93e0101egqm&url=http://album.sina.com.cn/pic/d6cca93egx6Dbqx0KhX21&690) Intel Corei7 微处理器晶片的相片。在 45nm 工艺中, 尺寸为 18.9mm×13.6 mm(257mm2) ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/0585f701d7d443201b391b3fe0a43700_938x594.jpg) 左图为  Core i7 晶片的布置图,右图为第二核心布置图的特写 总的来说就是： Step1:get one of the values to be added from memory and place it in aregister.               Step2:get the other value to be added from memory and place it in anotherregister. Step3:the control unit transfers the data from memory into the registers,informs the arithmetic/logic unit which registers hold the data,activates the appropriate circuitry within the arithmetic/logicunit, and tells the arithmetic/logic unit which register shouldreceive the result. Step4:the result will be transferred from registered to a memory cell bythe Bus. 重点就说这么多吧，基本上是一些学习笔记 我的更多文章： - Python程序调试的一些体会(2013-10-06 22:57:35) - 十四、Python编程计算24点（之二）(2013-10-03 22:18:28) - 十三、Python编程计算24点（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - 十二、Python简单数据结构应用（之二）(2013-10-02 22:10:41) - 十一、Python简单数据结构应用（之一）(2013-09-23 23:31:49) - 十、Python编程解决组合问题（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - 九、Python编程解决组合问题（之一）(2013-09-21 23:32:54) - 八、Python的函数编程（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - 七、Python的函数编程（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - 高中生如何学编程(2013-09-02 19:26:01)
';

一、Python语言的入门

最后更新于：2022-04-01 21:47:16

## Python语言的入门 ----From a high school student's view tolearn Python 关键字：高中生学编程 Python语言 计算机语言 一、**学习之前的心理准备** 学习Python或者说其它任何的计算机语言之前应该了解以及具备的能力： 1. 数学基础，其实我发现很多的程序就像是一个个小的算法组合起来的，而且在编程序时对于逻辑思维的能力要求比较高，因为程序是按照人设计的流程来运行的，而且只会遵守代码的真实意图，所以大家在编程时千万不能自己先晕了….. 2. 逻辑思维能力 编写程序的目的，一是解决数学计算，比如象我们使用的计算器就是最简单的例子；二是完成一些事务性的操作，比如我们日常见到的售票系统，银行使用的存取款系统；无论是计算还是事务性流程，都会有因果关系以及各种条件的判断，这些说的高深一点就是逻辑。 3、总结归纳的能力 计算机虽然具有很强的计算能力，可是他并不能够自动的解决我们的问题，比如我们奥数中的“鸡兔同笼”问题，你告诉计算机头多少、腿多少，让它告诉你鸡兔各有多少？除非你百度，计算机自己是不会算的；这就需要我们，通过分析问题，建立相应的数学模型： 1、设头的总数为n1，腿的总数为n2 2、如果按照头的数量，用n2减去n1*2，剩下的都是两条腿的兔子的腿了 3、 所以兔子的数量n3=(n2-2*n1)/2 4、如果n3为整数，那么鸡的数量n4=n1-n3 5、否则无解 我们按照就能够编写出解决问题的程序，然后你只要输入头的数量和腿的数量，现在计算机就可以很智能的替你解决鸡兔同笼的问题了。 二、**为什么选择Python呢** 对于我们初学者来说，最重要的还是简单，当然有技术含量也是必须的（可以显摆J）。简单体现在哪呢？ 1、   Python语言有一个交互式的开发环境，因为Python是解释运行，这大大节省了每次编译的时间，满足我们开始编程时的急迫心态，稍微写点东西就期望马上看到结果。 2、    Python语法简单，且内置有几种高级数据结构，如字典、列表等，使得使用起来特别简单。 3、    Python也被称为是一门清晰的语言。【以下内容体会还不是很深刻J】因为它的作者在设计它的时候，总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。这在由TimPeters写的python格言里面表述为：Thereshould be one-- and preferably only one --obvious way to doit.虽然我不知道其他的语言是什么样子，但是Python确实是一门十分简单的语言，每行代码就几乎和平时说的话没什么区别。 4、    Python语言目前也算比较流行的语言，适用面非常广泛，并非“小语种”，完全可以满足显摆的要求 **** **三、Python语言的局限** 虽然Python语言是一个非常成功的语言，但是也有必要明白它的局限性。 1.       运行效率低下 目前为止，Python语言可以说是所有主流脚本语言中速度最慢的。(是这样么?待考.)这与其脚本引擎的设计思路有关。如果你的应用对于速度有着较高的要求，就要考虑Python是否能满足需要。不过这一点可以通过使用C编写关键模块，然后由Python调用的方式加以部分解决。（……我也不太懂） 2. 独特的语法 这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。在我最开始学习Python的时候，经常是写一大堆的if语句， 而且因为每个语句都需要缩进，导致我经常就把缩进的层级搞混导致程序无法运行。 不过如果在写程序的时候把每个分支和循环的层级都弄懂的话，还是很大程度上可以避免的。 3. 无类型 作为一种动态语言，随时随地创建和使用变量是Python给我们带来的巨大的便利。但是它也会使得程序不严谨，某些错误只有在运行中才可能出现。所以我每次在写完一个小的project的时候都需要运行好几次来进行测试， 从而找出里面的错误 四、**python语言的神奇之处** python语言之所以被大家公认为很cool的一门语言，在于它提供的一些神奇的基础资源库，在后面的介绍中会具体的进行介绍，这里简单的给大家一个简单的例子。 随机产生福利彩票双色球的号码 双色球由红球和蓝球两部份组成，从33个红球号码(01~33)中选择6个，再从16个蓝球号码(01~16)中选择1个。 以下语句就可简洁的实现双色球的选号： import random random.sample(range(1,34),6)+random.sample(range(1,17),1) [16, 22,28, 3, 19, 15, 2] 要是用C语言来实现，你知道会有多复杂吗？ 以下是从百度知道中搜到的一个33选6的实现代码：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

 

#include <stdlib.h>

#include <stdio.h>

##include <stdlib.h>

#include <stdio.h>

#include <time.h> 

#define MAX 6

int main( void)

{

        int number[MAX] = {0};

        int i,j;

        srand()((unsigned)time(NULL)); 

        for(i = 0; i < MAX;i++)

        {

                  number[i] = rand()()% 33; 

                  while(number[i]==0)

                           number[i] = rand()() % 33;

                  //printf("%d ", number[i]);

        }

        while(1)

        {

                  for(i=0;i<6;i++)

                           for(j=i+1;j<6;j++)

                           {

                                    if(number[i]==number[j])

                                    {

                                              number[j]=rand() % 33;

                                              i=-1;

                                    }

                           }

                  if(i==6)

                           break;

        }

for(i= 0; i < MAX;i++)

        printf("%d ", number[i]);

printf("\n");

return 0;

}

 

虽然我们不能够以此而得出结论，但python的便利性确实是公认的。 五、**本篇小结** 总体来说，python是一门全能的语言，如果对于程序的性能没有苛刻的要求，对于除系统底层的操作之外的所有事情都可以处理； 当然，现在还不能够心急，还需要带大家了解一些基本的计算机方面的知识，这样便于后面可以更好地深入学习。 为了便于大家比较系统的学习，我还会推荐一些美国大学的公开课资源，同时，我也会截取其中的一些视频，作为补充。 之后我会详细的介绍如何搭建学习环境，真正的开启我们学习的大门。 有兴趣的话，大家查一查python的英文到底是什么意思，相信大家一定很好奇![一、Python语言的入门](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "一、Python语言的入门")我的更多文章： - [Python程序调试的一些体会](http://blog.sina.com.cn/s/blog_d6cca93e0101ewc9.html)(2013-10-06 22:57:35) - [十四、Python编程计算24点（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euxx.html)(2013-10-03 22:18:28) - [十三、Python编程计算24点（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101eukc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - [十二、Python简单数据结构应用（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101euk8.html)(2013-10-02 22:10:41) - [十一、Python简单数据结构应用（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ep9z.html)(2013-09-23 23:31:49) - [十、Python编程解决组合问题（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101entc.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - [九、Python编程解决组合问题（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ent7.html)(2013-09-21 23:32:54) - [八、Python的函数编程（之二）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwj.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - [七、Python的函数编程（之一）](http://blog.sina.com.cn/s/blog_d6cca93e0101ekwg.html)![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - [高中生如何学编程](http://blog.sina.com.cn/s/blog_d6cca93e0101e8fn.html)(2013-09-02 19:26:01)
';

高中生如何学习编程

最后更新于：2022-04-01 21:47:14

高中生如何学习编程 ----From a high schoolstudent's view to learn Python 关键字： python 高中生学编程 MIT公开课视频 计算机科学及编程导论 无经验学编程  在高中阶段，很多的学生都从以前的学奥数、学英语转向了学一些计算机的知识，一方面是为了将来更好选专业，一方面也是为了适应科技的发展。那么高中生到底适不适合学习编程呢？答案是肯定的。因为高中生已经已经有了比较扎实的学科基础（上大学只是换了个环境），而且已经能够自己对知识进行一定的总结，所以去接触一个完全陌生的知识是完全有能力面对的，但是从何下手实在是一个十分重要的问题。 我从暑假开始学习的Python编程，由于完完全全是新手，所以很多关于计算机的基础知识都一知半解，网上的各种大神所写的编程教程林林总总，而且网上推荐的各种关于Python的编程书籍又是种类繁多，又是核心编程，又是Python2.5编程，又是Python3.0以上最新编程教程，更有Python入门经典教程…… 对于我这个刚入门的高中生来说简直就是眼花缭乱，不知从何下手。我对编程这一对我来说全新的事物完全缺乏概念，有些书上一句带过的知识，我却丝毫摸不着头脑，这种感觉就像小时候学奥数的时候一样，有种小小的绝望感，没办法只好硬着头皮上了。 由于是自学，所以还是想找一些老师讲课的视频教程，特别是针对大学新生的，毕竟再过一年我们也要跨入大学，这些课程的对象和我有差不多的学习基础。最后找到一个MIT的公开课：<<麻省理工学院公开课：计算机科学及编程导论>>的课程十分的适合我这样的初学者。 在这个课程里面，教授不仅仅讲了Python的编程知识，而且还介绍了许多关于计算机的基础知识，使得我对计算机有了一个十分形象的概念。有了这个公开课的帮助，我的Python学习也慢慢步入了正轨，接下来就是安装各种集成的编译环境，然后去书店去从各种各样的书籍中挑选出我能够看懂的书籍，有时候还会在书店里呆一个下午就为了找一本能够解决我问题的书。 随着学习的深入，自己的兴趣也越来越浓厚，从刚开始遇到程序错误时的手足无措，有时候都想放弃的状态，到现在遇到问题反而比较兴奋，从刚开始只能够在命令行状态下键入一些简单的语句，到现在可以解决一些比较复杂的问题，虽然从知识水平上看，我还处于刚入门的阶段，算不上有多专业，但是我觉得我的学习方法还是比较正确，没有走弯路，在我们这个阶段时间比较宝贵的情况下，这一点我认为是非常重要的，看着自己写出来的这些程序，心中也有一些小小的成就感…… 就要开学了，我对假期的学习过程做了些总结，在总结的过程中我突然想到，如果也有像我一样的高中生或初学者需要学习编程的的话，那岂不是也要走一遍我走过的坑？那对于一些没有特别多时间的同学们来说可能很容易就半途而废了，就像我当初也冒出过放弃的念头一样。所以我就想写一个自己的教程，根据我自己的学习经验和经历，来把我认为最适合高中生或初学者的学习内容和学习模式展现出来，让大家不必再纠结于茫茫的资料和所谓的“入门教程”。这就是我想写这个博文的原因。 顺便向大家介绍一下这个教程的主要内容。做为一个初学者，首先了解一下计算机本身是非常重要的，但我们又不可能很深入的学习，所以先看看MIT的公开课视频，我花了些时间做了一些剪辑，然后按照教程中列出的一些参考书籍进行阅读，教程中会给出这些文章的详细链接，主要的目的是了解计算机：它到底是个什么原理？它是怎么发展的？它的结构和组成是什么样的？并且更详细的了解一下我们经常会说的CPU、内存、硬盘等。这一切都是一个学习计算机知识的人的必修课，所以在前几篇的教程中我就向大家详细介绍了计算机的发展历史，计算机的组成并且加上了几段精彩的视频，这些内容虽然和编程看似没有直接的关联，但如果这些基础的知识不先进行一些了解，肯定会阻碍我们将来深入学习编程，正所谓“磨刀不误砍柴工”。 接下来我就开始了编程部分的讲解，在讲Python之前，我先向大家介绍了计算机的语言，这其中就包含了计算机语言的概念，用途以及分类几个重点的内容。大家也知道，计算机编程语言种类繁多，Python就是其中的一种语言，那么我介绍其它的一些计算机语言也是为了让大家更好地了解Python这门语言：了解它的优势和劣势。 在介绍大体的介绍完计算机语言之后，我们就要进入Python语言的具体学习了，那么我把Python的学习教程分成了几个章节，第一个就是Python语言的大体介绍，主要是如何安装，搭建我们的学习环境；然后详细介绍在使用Python编写程序时用到的一些基本元素，例如：字符串，数字等等。接着就是Python的语言基础部分，语言基础就是帮助大家能够更好的书写代码，正确的书写代码的技巧。 在语言基础之后呢，就是关于程序流程的讲解：例如条件，循环等逻辑语句，而这些也是大家在写代码是不可或缺的部分。接着我就会进行Python的函数部分的教程，当然这和我们数学中的函数有很大不同，具体怎样不同呢，就需要大家从教程中寻找答案了。 在这些基础的技巧介绍完了之后，我就会向大家介绍我所写的一些程序，包括组合问题，24点问题，都十分有趣。 这就是我的教程的大体内容，我期望通过我的博客，可以搭建一个和大家沟通交流、共同学习的平台。 我的更多文章： - 十四、Python编程计算24点（之二）(2013-10-03 22:18:28) - 十三、Python编程计算24点（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-10-02 22:15:46) - 十二、Python简单数据结构应用（之二）(2013-10-02 22:10:41) - 十一、Python简单数据结构应用（之一）(2013-09-23 23:31:49) - 十、Python编程解决组合问题（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-21 23:37:27) - 九、Python编程解决组合问题（之一）(2013-09-21 23:32:54) - 八、Python的函数编程（之二）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:39) - 七、Python的函数编程（之一）![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") (2013-09-20 23:09:10) - 二、计算机系统的简单介绍![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含视频") ![](https://docs.gechiui.com/gc-content/uploads/sites/kancloud/2015-10-30_5632e1cc04fc3.gif "此博文包含图片") (2013-09-15 15:23:32) - 一、Python语言的入门(2013-09-08 09:16:19)
';

前言

最后更新于：2022-04-01 21:47:12

> 原文出处：[高中生学编程--Python学习](http://blog.csdn.net/column/details/jackhej.html) 作者：[jackhej](http://blog.csdn.net/jackhej) **本系列文章经作者授权在看云整理发布，未经作者允许，请勿转载！** # 高中生学编程--Python学习 > 高中生完全具备学习计算机编程的能力，关键在于如何选择一门合适的语言来作为入门学习的语言，本篇介绍作为初学者如何从浩瀚的资料中，挑选合适的资料来进行学习，也是博主自己学习过程的总结，希望找到更多的自学者，共同学习进步
';