大家好，欢迎来到IT知识分享网。

【Python 第0课】Why Python？

为什么用Python作为编程入门语言？

原因很简单。

每种语言都会有它的支持者和反对者。去Google一下“why python”，你会得到很多结果，诸如应用范围广泛、开源、社区活跃、丰富的库、跨平台等等等等，也可能找到不少对它的批评，格式死板、效率低、国内用的人很少之类。不过这些优缺点的权衡都是程序员们的烦恼。作为一个想要学点编程入门的初学者来说，简单才是最重要的。当学C++的同学还在写链表，学Java的同学还在折腾运行环境的时候，学Python的你已经像上图一样飞上天了。

当然，除了简单，还有一个重要的原因：因为我现在每天都在写Python。虽然以后可能会讲些手机编程之类（如果真的有那么一天π_π），但目前这时候，各位也就看菜吃饭，有啥吃啥了。每天5分钟，先别计较太多。况且Python还是挺有利于形成良好编程思维的一门语言。

推荐两本我个人比较喜欢的Python入门书籍，一本是《简明Python教程》，我自己最开始就是看着它学的，接下来也会大体参考里面的内容讲。另一本是《Head First Python》，Head First系列都是非常浅显易懂的入门类书籍，虽然我只瞄过几眼，但感觉还是不错的。

【Python 第1课】安装

进入Python的官方下载页面
http://www.python.org/download/

你会看到一堆下载链接。我们就选“Python 2.7.5 Windows Installer”，如果是64位系统的同学选下面那个“Python 2.7.5 Windows X86-64 Installer”。为什么不选最上面那个3.3.2的新版本？因为我在用python2.7.x，python3改了不少地方，不熟。

下载之后，就和装其他软件一样，双击，一路Next，想换安装路径的同学可以换个位置。但不管换不换，请把这个路径复制下来，比如我的是“C：\python27\”，后面要用到它。

安装结束还没完，我们还差最后一步：设置环境变量。这是什么东西我暂时先不解释，大家照着做就好。右键单击我的电脑（不，是你的电脑），依次点击”属性”->”高级”->”环境变量”，在“系统变量”表单中点击叫做Path的变量，然后编辑这个变量，把“;C:\Python27\”，也就是你刚才复制的安装路径，加到它的结尾。注意！要用英文分号和前面已有的内容隔开。然后点确定，点确定，再点确定。完成。

怎么知道你已经成功安装了Python呢？这时候你需要打开命令行，或者叫命令提示符、控制台。方法是：点击开始菜单->程序->附件->命令提示符；或者直接在桌面按快捷键“Win+r”，Win键就是Ctrl和Alt旁边那个有windows图标的键，输入cmd，回车。这时候你就看到可爱的黑底白字了。

在命令行里输入python，回车。如果看到诸如：
Python 2.7.5 (default, May 15 2013, 22:43:36) [MSC v.1500 32 bit (Intel)] on win32
的提示文字，恭喜你！否则，请重新检查你哪里的打开方式不对，或者直接给我留言。

接下来，你就可以输入那句程序员最爱的
print “Hello World”
向Python的世界里发出第一声啼哭。

嗯。。。如果这么几步你还是被绕晕了，没关系，我还留了一手：打开你的浏览器，Google一下“python online”，点击第一条结果“Execute Python Script Online”；或者直接打开compileonline.com，找到Python点进去。
http://www.compileonline.com/execute_python_online.php
这是一个在线的python运行环境，你可以在这里练习，无需任何下载安装配置。左边页面是写代码的地方，点击左上角的“Execute Sctipt”，就可以在右边页面看到输出结果。

那Mac的同学怎么办？Mac上叫“终端”，英文版叫Terminal，可以在“应用程序”里找到，也可以直接在你的Mac上搜索“终端”或者“Terminal”找到。打开之后输入“python”，回车，就可以进入python了。

好了，今天就这么多，快去试试你的python，输出一行“Hello World”吧。完成的同学可以截个屏发给我。欢迎各种建议、讨论和闲聊，当然更欢迎你把这里分享给更多的朋友。

我今天发现昨天提供的compileonline.com网站有时候会很慢，甚至无法正常运行，于是我又找了一个：
http://www.pythonfiddle.com
似乎要快一点，不过好像只能在电脑上的浏览器打开。另外就是，昨天忘了给Mac的同学们说一下怎么打开命令行。Mac上叫做“终端”或者“Terminal”，可以在“应用程序”里找到，也可以直接在“spotlight”里直接输入“Terminal”打开。打开后就可以通过“python”命令进入开发环境了。

【Python 第2课】print

print，中文意思是打印，在python里它不是往纸上打印，而是打印在命令行，或者叫终端、控制台里面。print是python里很基本很常见的一个操作，它的操作对象是一个字符串（什么是字符串，此处按住不表，且待日后慢慢道来）。基本格式是： print 你要打印的东西或者 print(你要打印的东西)这里一定要英文字符的括号，所有程序中出现的符号都必须是英文字符，注意别被你的输入法坑了。

各位同学可以在自己的python环境中试着输出以下内容（这里是命令行下的效果，使用在线编辑器或者IDE的同学，只需要输入“>>>”后面的内容就可以了）：

>>> print “hello”
hello
>>> print ‘world’
world
>>> print 1
1
>>> print 3.14
3.14
>>> print 3e30
3e+30
>>> print 1 + 2 * 3
7
>>> print 2 > 5
False

直接在print后面加一段文字来输出的话，需要给文字加上双引号或者单引号。大家发现，print除了打印文字之外，还能输出各种数字、运算结果、比较结果等。你们试着自己print一些别的东西，看看哪些能成功，哪些会失败，有兴趣的话再猜一猜失败的原因。

其实在python命令行下，print是可以省略的，默认就会输出每一次命令的结果。就像这样：
>>> ‘Your YiDa!’
‘Your YiDa!’
>>> 2+13+250
265
>>> 5<50
True

今天内容就这么多。没听出个所以然？没关系，只要成功print出来结果就可以，我们以后还有很多时间来讨论其中的细节。

这个短期目标就是一个很简单很弱智的小游戏：

COM: Guess what I think?
5
COM: Your answer is too small.
12
COM: Your answer is too large.
9
COM: Your answer is too small.
10
COM: BINGO!!!

解释一下：首先电脑会在心中掐指一算，默念一个数字，然后叫你猜。你猜了个答案，电脑会厚道地告诉你大了还是小了，直到最终被你果断猜中。

这是我十几年前刚接触编程时候写的第一个程序，当时家里没有电脑，在纸上琢磨了很久之后，熬到第二个星期的电脑课才在学校的486上run起来。后来我还写过一个windows下的窗口版本。现在就让它也成为你们第一个完整的程序吧。照我们每天5分钟的进度，初步估计半个月后大约能完成了。

【Python 第3课】IDE

打个不恰当的比方，如果说写代码是制作一件工艺品，那IDE就是机床。再打个不恰当的比方，PS就是图片的IDE，Word就是doc文档的IDE，PowerPoint就是ppt文件的IDE。python也有自己的IDE，而且还有很多。

python自带了一款IDE，叫做IDLE。先说Windows，Windows上安装了之后，可以在“开始菜单”->“程序”->“Python 2.7”里找到它。打开后之后很像我们之前用过的命令行。没错，它就是的，在里面print一下试试。不知之前用命令行的同学有没有注意到，命令行输一行命令就会返回结果，而且之前print了那么多，关掉之后也不知道到哪里去了。所以它没法满足我们编写弱智小游戏的大计划。我们需要用新的方法！

点击窗口上方菜单栏的“File”->“New Window”，会打一个长得很像的新窗口，但里面什么也没有。这是一个文本编辑器，在这里面就可以写我们的python程序了。继续print几行，这次可以多print一点：

print ‘Hello’
print ‘IDE’
print ‘Here I am.’

现在是，见证奇迹的时刻！点击“Run”->“Run Module”，或者直接按快捷键F5。会提示你保存刚才文件，随便取个名字，比如“lesson3.py”。（.py是python代码文件的类型，虽然不指定.py也是可以的，但建议还按规范来）保存完毕后，之前那个控制台窗口里就会一次性输出你要的结果。

以后想再次编辑或运行刚才的代码，只要在IDLE里选择“File”->“Open…”，打开刚才保存的.py文件就可以了。

Mac上的IDLE是预装好了，在“终端”里输入“IDLE”就可以启动，使用方法同Windows。也可以在文件夹/usr/bin里可以找到IDLE。如果是重新下载安装了python，似乎是可以在“应用程序”里找到IDLE的，Mac的同学可以验证下。

另外，Windows下有一个第三方的免费IDE，叫PyScripter，把文件目录、文本编辑器、命令行都整合到了一起，还增加了很多辅助功能。有兴趣的同学也可以去找来试试看。地址：
http://code.google.com/p/pyscripter/
用起来应该比IDLE方便，但有一点要注意，它的安装位置和.py文件的保存位置都不要有中文，不然可能会有问题。

今天的内容有点长。配置开发环境这种事最麻烦了，大家耐心一点，毕竟一次投入，长期受益。以后我们的课程都会在IDE中进行，基本不再往命令行里直接敲代码了。

最后说下，有很多python程序员都不使用任何IDE。至于原因嘛，可能就像优秀的手工艺人是不会用机床来加工艺术品的吧。

【Python 第4课】输入

前print了那么多，都是程序在向屏幕“输出”。那有来得有往，有借得有还，有吃。。。咳咳！那啥，我们得有向程序“输入”信息的办法，才能和程序对话，进行所谓的“人机交互”。

python有一个接收命令行下输入的方法：
input()
注意，和print不同的是，这次我们必须得加上()了，而且得是英文字符的括号。

好了，终于可以搬出那个弱智小游戏了，耶！游戏里我们需要跟程序一问一答，所以我们先把话给说上。

打开我们的python编辑器，不管是IDLE，在线编辑器，还是其他的IDE。在代码编辑器中输入下面几句代码：

print “Who do you think I am?”
input()
print “Oh, yes!”

然后，Run！（Forrest Run！）你会在命令行中看到，程序输出了第一句之后就停住了，这是input在等待你的输入。

输入你的回答，回车。你会看到程序的回答。注意！引号！！又是引号！！！和print一样，如果你输的是一串文字，要用引号”或者””引起来，如果是数字则不用。

（插一句，python还有一个输入的方法：raw_input()，它把所有的输入都直接当作一串字符，于是就可以不用加引号，有兴趣的同学可以试一试，体会一下两者的不同。关于这个令人纠结的引号，我们以后会再讨论它。）

看上去不错哦，似乎就这么对上话了。是不是觉得离小游戏的完成迈进了一大步？可是大家发现没有，即使你说”Idiot！”，程序仍然会淡定地回答”Oh, yes!”因为它左耳进右耳出，根本就没听进去我们到底说了啥。那怎么才能让它认真听话呢？啪！且听下回分解。

回顾一下我们之前几节课。我们到现在一共提到了三种可以运行print的方式：

1. 命令行，包括Win下的控制台（CMD）和Mac下的终端（Terminal）。
它可以帮我们确认自己电脑上的python是不是正常。但是这种方法很难帮我们实现写一个完整小程序的目标。

2. IDE，包括python自带的IDLE和其他第三方的IDE。
不知道大家是不是都顺利搞定，并且能顺利保存并打开py文件了呢？以后我们课程里的内容，你都可以在这里面进行。

3. 在线编辑器，compileonline或者pythonfiddle。
他们同样包括代码编辑器（写代码的地方）和控制台（输出结果的地方）两部分。所以我们在本地IDE里的操作都可以在其中实现。只不过保存文件会有些复杂，compileonline是点击download files打包下载，pythonfiddle需要注册一下。当然，你也可以直接把你写好的代码复制下来，保存在本地，下次再粘贴上去接着写。

【Python 第5课】变量

昨天说到，需要让程序理解我们输入的东西。那首先，就需要有东西把我们输入的内容记录下来，好为接下来的操作做准备。Python之神说，要有变量！于是就有了变量。

变量，望文生义，就是变化的量。python里创建一个变量的方法很简单，给它起个名字，然后给它一个值。举起几个栗子:

name = ‘Crossin’
myVar = 123
price = 5.99
visible = True

“=”的作用是把右边的值赋予给左边的变量。

这里说一下另外一个概念，叫做“数据类型”，上面4颗栗子分别代表了python中较常见的四种基本类型：

字符串 – 表示一串字符，需要用”或””引起来

整数

浮点数 – 就是小数

bool（布尔） – 这个比较特殊，是用来表示逻辑“是”“非”的一种类型，它只有两个值，True和False。（注意这里没有引号，有了引号就变成字符串了）

再次用到我们熟悉的print。这次，我们升级了，要用print输出一个“变量”：

name = ‘Crossin’
print name

看到结果了吗？没有输出“name”，也没有报错，而是输出了“Crossin”。现在是不是能想明白一些，为什么之前print一段文字没加引号就会报错，而print一个数字就没有问题呢？

它叫变量，那就是能变的。所以在一次“赋值”操作之后，还可以继续给它赋予新的值，而且可以是不同类型的值。

a = 123
print a
a = ‘hi’
print a

“=”的右边还可以更复杂一点，比如是一个计算出的值:

value = 3 * 4
print value
value = 2 < 5
print value

甚至，也可以是input():

name = input()
print name

于是，我们又可以进化一下我们的小游戏了。把上次写的内容稍微改一下，加上变量：

print “Who do you think I am?”
you = input()
print “Oh, yes! I am a”
print you

看来程序已经知道我们的输入了。接下来，就要让它学会对不同的答案做出判断。这个我们留到下次再说。

今天是周五。我觉得吧，到周末了，大家应该远离一下电脑，多陪陪家人朋友，吃吃饭，出去走走。祝大家周末愉快！

【Python 第6课】bool

昨天说到了python中的几个基本类型，字符串、整数、浮点数都还算好理解，关于剩下的那个bool（布尔值）我要稍微多说几句。

逻辑判断在编程中是非常重要的。大量的复杂程序在根本上都是建立在“真”与“假”的基本逻辑之上。而bool所表示的就是这种最单纯最本质的True / Flase，真与假，是与非。

来看下面的例子：

a = 1 < 3
print a
b = 1
c = 3
print b > c

通过用“>”“<”来比较两个数值，我们就得到了一个bool值。这个bool值的真假取决于比较的结果。

“>”“<”在编程语言中被成为逻辑运算符，常用的逻辑运算符包括：

>：大于
<：小于
>=：大于等于
<=：小于等于
==：等于。比较两个值是否相等。之所以用两个等号，是为了和变量赋值区分开来。
!=：不等与
not：逻辑“非”。如果x为True，则not x为False
and：逻辑“与”。如果x为True，且y为True，则x and y为True
or：逻辑“或”。如果x、y中至少有一个为True，则x or y为True

关于bool值和逻辑运算其实远不止这些，但现在我们暂时不去考虑那么多，以免被绕得找不到北。最基本的大于、小于、等于已经够我们先用一用的了。

试试把bool加到我们的小游戏里：

num = 10
print ‘Guess what I think?’
answer = input()

result = answer<num
print ‘too small?’
print result

result = answer>num
print ‘too big?’
print result

result = answer==num
print ‘equal?’
print result

代码比之前稍微多了一点，解释一下。
第一段代码：先创建一个值为10的变量num，输出一句提示，然后再输入一个值给变量answer。
第二段代码：计算answer<num的结果，记录在result里，输出提示，再输出结果。
第三段、第四段都与第二段类似，只是比较的内容不一样。

看看结果是不是跟你预期的一致？虽然看上去还是有点傻，但是离目标又进了一步。

现在数数你手上的工具：输入、输出，用来记录数值的变量，还有可以比较数值大小的逻辑运算。用它们在你的python里折腾一番吧。

【Python 第7课】if

继续上次的程序。我们已经能让判断我们输入的值了，但这程序还是有点呆，不过怎样都要把话说三遍。因为到目前为止，我们的程序都是按照顺序从上到下一行接一行地执行。有同学发来问题了：怎么能让它根据我们输入的结果来选择执行呢？答案就是 – if

来看一张图（纯手绘，渣画质）

解释一下，程序顺序往下执行遇到if语句的时候，会去判断它所带条件的真假。

“如果”为True，就会去执行接下来的内容。“如果”为False，就跳过。

语法为：

if 条件:
选择执行的语句

特别说明：条件后面的冒号不能少，同样必须是英文字符。
特别特别说明：if内部的语句需要有一个统一的缩进，一般用4个空格。python用这种方法替代了其他很多编程语言中的{}。你也可以选择1/2/3…个空格或者按一下tab键，但必须整个文件中都统一起来。千万不可以tab和空格混用，不然就会出现各种莫名其妙的错误。所以建议都直接用4个空格。

上栗子：

thisIsLove = input()
if thisIsLove:
print “再转身就该勇敢留下来”

试试看？输入True，就会得到回答。输入False，什么也没有。（如果你那里输出中文有问题，请自行改成英文）

所以，我们的游戏可以这样改写：

num = 10
print ‘Guess what I think?’
answer = input()
if answer<num:
print ‘too small!’

if answer>num:
print ‘too big!’
if answer==num:
print ‘BINGO!’

if在编程语言中被称为“控制流语句”，用来控制程序的执行顺序。还有其他的控制流语句，后面我们会用到。

重新发一下代码

thisIsLove = input()
if thisIsLove:
　print “再转身就该勇敢留下来”

========

num = 10
print ‘Guess what I think?’
answer = input()
if answer<num:
　print ‘too small!’
if answer>num:
　print ‘too big!’
if answer==num:
　print ‘BINGO!’

【Python 第8课】while

先介绍一个新东西：注释。
python里，以“#”开头的文字都不会被认为是可执行的代码。
　print “hello world”
和
　print “hello world” #输出一行字
是同样的效果。但后者可以帮助开发者更好地理解代码。

在接下来的课程中，我会经常用注释来解释代码。

用if改进完我们的小游戏后，功能已经基本实现了。很多同学做完后纷纷表示，每次只能猜一次，完了之后又得重新run，感觉好麻烦。能不能有办法让玩家一直猜，直到猜中为止？答案很显然，如果这种小问题都解决不了，那python可就弱爆了。

最简单的解决方法就是while。

同if一样，while也是一种控制流语句，另外它也被称作循环语句。继续来看渣画质手绘流程图：

程序执行到while处，“当”条件为True时，就去执行while内部的代码，“当”条件为False时，就跳过。

语法为：

while 条件:
　循环执行的语句

同if一样，注意冒号，注意缩进。

今天的栗子：

a = 1 #先a设为1
while a != 0: #a不等于0就一直做
　print “please input”
　a = input()
print “over”

想想怎么用while改进小游戏？有多种写法，大家自己思考下，我不多做说明了。下图给出一种方法。

注意，这里出现了两层缩进，要保持每层缩进的空格数相同。

到此为止，小游戏已经基本成型了。不过好像还差一点：每次自己都知道答案，这玩起来有神马意思。
明天来讲，怎么让你不知道电脑的答案。

【Python 第9课】random

之前我们用了很多次的print和input方法，它们的作用是实现控制台的输入和输出。除此之外，python还提供了很多模块，用来实现各种常见的功能，比如时间处理、科学计算、网络请求、随机数等等等等。今天我就来说说，如何用python自带的随机数模块，给我们的小游戏增加不确定性。

引入模块的方法：

from 模块名 import 方法名

看不懂没关系，这东西以后我们会反复用到。今天你只要记住，你想要产生一个随机的整数，就在程序的最开头写上：

from random import randint

之后你就可以用randint来产生随机数了。

还记得input后面的()吗，我们使用randint的时候后面也要有()。而且，还要在括号中提供两个数字，先后分别是产生随机整数范围的下限和上限。例如：

randint(5, 10)

这样将会产生一个5到10之间（包括5和10）的随机整数。

放到我们的小游戏里，用
answer = randint(1, 100)
替代
answer = 10

程序在运行时候，会产生一个1到100的随机整数，存在answer里，我们也不知道是多少，真的全靠猜了。

好了，觉得还有点意思么？我们终于一步步把这个弱智小游戏给做出来了，有没有一丁点的成就感呢？

如果你对其中的某些细节还不是很理解，恭喜你，你已经开始入门了。相信你会带着一颗追求真相的心，在编程这条路上不断走下去。

我们的课程，也才刚刚开始。

【Python 第10课】 变量2

变量这东西，我们已经用过。有了变量，就可以存储和计算数据。今天来讲点变量的细节。

#==== 变量命名规则 ====#
变量名不是你想起就能起的：

第一个字符必须是字母或者下划线“_”

剩下的部分可以是字母、下划线“_”或数字（0-9）

变量名称是对大小写敏感的，myname和myName不是同一个变量。
几个有效的栗子：
i
__my_name
name_23
a1b2_c3

几个坏掉的栗子（想一下为什么不对）：
2things
this is spaced out
my-name

#==== 变量的运算 ====#

我们前面有用到变量来存储数据： num = 10
answer = input()

也有用到变量来比较大小： answer < num

除此之外，变量还可以进行数学运算： a = 5 b = a + 3 c = a + b

python中运算的顺序是，先把“=”右边的结果算出了，再赋值给左边的变量。下面这个例子： a = 5 a = a + 3 print a
你会看到，输出了8，因为先计算出了右边的值为8，再把8赋给左边的a。
通过这种方法，可以实现累加求和的效果。它还有个简化的写法：
a += 3这个和a = a + 3是一样的。

于是，利用变量、循环、累加，可以写一个程序，来完成传说中高斯大牛在小时候做过的题：1+2+3+…+100=?从1加到100等于多少？

提示：你可以用一个变量记录现在加到几了，再用一个变量记录加出来的结果，通过while来判断是不是加到100了。

【Python 第11课】 逻辑判断

之前粗略地提到bool类型的变量，又说到if和while的判断条件。有些同学反馈说没怎么理解，为什么一会儿是bingo=False，一会又是bingo==False，一会儿是while在条件为True的时候执行，一会儿又是while在bingo==False的时候执行。别急，你听我说。

首先，要理解，一个逻辑表达式，其实最终是代表了一个bool类型的结果，比如：

1 < 3
这个就像当于是一个True的值

2 == 3
这个就是False

把它们作为判断条件放到if或者while的后面，就是根据他们的值来决定要不要执行。

同样的栗子再来几颗：

a = 1print a>3 #Falseprint a==2-1 #Trueb = 3
print a+b==2+2 #True

比较容易搞混的，是bool变量的值和一个逻辑表达式的值，比如：

a = Falseprint a #False
print a==False #True

虽然a本身的值是False，但是a==False这个表达式的值是True。（说人话！）“a”是错的，但“a是错的”这句话是对的。

回到上面那几个概念：

bingo=False
把bingo设为一个值为False的变量

bingo==False
判断bingo的值是不是False，如果是，那么这句话就是True

while在判断条件条件为True时执行循环，所以当bingo==False时，条件为True，循环是要执行的。

晕了没？谁刚学谁都晕。不晕的属于骨骼惊奇百年一遇的编程奇才，还不赶紧转行做程序员！

逻辑这东西是初学编程的一大坑，我们后面还要在这个坑里挣扎很久。

留个习题：a = True
b = not a #不记得not请回复6想想下面这些逻辑运算的结果，然后用print看看你想的对不对：bnot ba == ba != ba and ba or b1<2 and b==True

【Python 第12课】 for循环

大家对while循环已经有点熟悉了吧？今天我们来讲另一种循环语句：

for … in …

同while一样，for循环可以用来重复做一件事情。在某些场景下，它比while更好用。
比如之前的一道习题：输出1到100（回复903可看详细内容）。
我们用while来做，需要有一个值来记录已经做了多少次，还需要在while后面判断是不是到了100。
如果用for循环，则可以这么写：

for i in range(1, 101):
　print i

解释一下，range(1, 101)表示从1开始，到101为止（不包括101），取其中所有的整数。for i in range(1, 101)就是说，把这些数，依次赋值给变量i。相当于一个一个循环过去，第一次i = 1，第二次i = 2，……，直到i = 100。当i = 101时跳出循环。所以，当你需要一个循环10次的循环，你就只需要写：

for i in range(1, 11)

或者

for i in range(0, 10)

区别在于前者i是从1到10，后者i是从0到9。当然，你也可以不用i这个变量名。
比如一个循环n次的循环：

for count in range(0, n)

for循环的本质是对一个序列中的元素进行递归。什么是序列，以后再说。先记住这个最简单的形式：

for i in range(a, b)

从a循环至b-1

现在，你可以用for循环来改写习题903,904,905,906了。

【Python 第13课】 字符串

字符串就是一组字符的序列（序列！又见序列！还记得我说过，range就是产生一组整数序列。今天仍然不去细说它。），它一向是编程中的常见问题。之前我们用过它，以后我们还要不停地用它。

python中最常用的字符串表示方式是单引号（‘’）和双引号（””）。我还是要再说：一定得是英文字符！

‘string’和“string”的效果是一样的。

可以直接输出一个字符串print ‘good’

也可以用一个变量来保存字符串，然后输出str = ‘bad’print str

如果你想表示一段带有英文单引号或者双引号的文字，那么表示这个字符串的引号就要与内容区别开。

内容带有单引号，就用双引号表示”It’s good”
反之亦然
‘You are a “BAD” man’

python中还有一种表示字符串的方法：三个引号（‘’‘）或者（”””）

在三个引号中，你可以方便地使用单引号和双引号，并且可以直接换行
”’
“What’s your name?” I asked.
“I’m Han Meimei.”
”’

还有一种在字符串中表示引号的方法，就是用\，可以不受引号的限制

\’表示单引号，\”表示双引号
‘I\’m a \”good\” teacher’

\被称作转译字符，除了用来表示引号，还有比如用
\\表示字符串中的\
\n表示字符串中的换行

\还有个用处，就是用来在代码中换行，而不影响输出的结果：
“this is the\
same line”

这个字符串仍然只有一行，和
“this is thesame line”
是一样的，只是在代码中换了行。当你要写一行很长的代码时，这个会派上用场。

作业时间】用print输出以下文字：

1.
He said, “I’m yours!”

2.
\\_v_//

3.
Stay hungry,
stay foolish.
— Steve Jobs

4.
*
***
*****
***
*

【Python 第14课】 字符串格式化

我们在输出字符串的时候，如果想对输出的内容进行一些整理，比如把几段字符拼接起来，或者把一段字符插入到另一段字符中间，就需要用到字符串的格式化输出。

先从简单的开始，如果你想把两段字符连起来输出
str1 = ‘good’
str2 = ‘bye’

你可以
print str1 + str2

或者还可以把字符变量一个字符串相加
print ‘very’ + str1
print str1 + ‘ and ‘ + str2

但如果你想要把一个数字加到文字后面输出，比如这样
num = 18
print ‘My age is’ + num
程序就会报错。因为字符和数字不能直接用+相加。

一种解决方法是，用str()把数字转换成字符串
print ‘My age is’ + str(18)
或
num = 18
print ‘My age is’ + str(num)

还有一种方法，就是用%对字符串进行格式化
num = 18
print ‘My age is %d’ % num
输出的时候，%d会被%后面的值替换。输出
My age is 18

这里，%d只能用来替换整数。如果你想格式化的数值是小数，要用%f
print ‘Price is %f’ % 4.99
输出
Price is 4.

如果你想保留两位小数，需要在f前面加上条件：%.2f
print ‘Price is %.2f’ % 4.99
输出
Price is 4.99

另外，可以用%s来替换一段字符串
name = ‘Crossin’
print ‘%s is a good teacher.’ % name
输出
Crossin is a good teacher.

或者
print ‘Today is %s.’ % ‘Friday’
输出
Today is Friday.

注意区分：有引号的表示一段字符，没有引号的就是一个变量，这个变量可能是字符，也可能是数字，但一定要和%所表示的格式相一致。

现在，试试看用字符串格式化改进一下之前你写的小游戏。比如你输了一个数字72，程序会回答你
72 is too small.
或者
Bingo, 72 is the right answer!

【Python 第15课】 循环的嵌套

设想一样，如果我们要输出5个*，用for循环要这么写
for i in range(0, 5):
　print ‘*’

如果想让这5个*在同一行，就在print语句后面加上逗号
for i in range(0, 5):
　print ‘*’,

但如果我想要这样一个图形，怎么办？
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

当然，你可以循环5次，每次输出一行“* * * * *”。那如果再进一步，这样呢？
*
**
***
****
*****

除了你自己动手打好一个多行字符串外，也可以让程序帮我们解决这种问题，我们需要的是两个嵌套在一起的循环：
for i in range(0, 5):
　for j in range(0, 5):
　　print i, j

第二个for循环在第一个for循环的内部，表示每一次外层的循环中，都要进行一遍内层的循环。
看一下输出的结果：
0 0
0 1
0 2
0 3
0 4
1 0
…
4 4
内层循环中的print语句一共被执行了25次。
i从0到4循环了5次。对应于每一个i的值，j又做了从0到4五次循环。所以5*5一共25次。

所以如果要输出一个5*5的方阵图案，我们可以
for i in range(0, 5):
　for j in range(0, 5):
　　print ‘*’,
　print

注意：第二个print的缩进和内层的for是一样的，这表明它是外层for循环中的语句，每次i的循环中，它会执行一次。
print后面没有写任何东西，是起到换行的作用，这样，每输出5个*，就会换行。

要输出第二个三角图案时，我们需要根据当前外层循环的序数，设置内层循环应当执行的次数。
for i in range(0, 5):
　for j in range(0, i+1):
　　print ‘*’,
　print

内层的j每次从0到i+1进行循环。
这样，当第一次i=0时，j就是range(0,1)，只输出1个*。
而当最后一次i=4时，j就是range(0,5)，输出5个*。

最后顺便说下，如果有同学用的是PyScripter，或者其他第三方IDE，可以通过debug中的step，查看程序是怎样一行一行运行的。IDLE在这方面做得不太好，虽然也可以步进调试，但是很麻烦且不直观，所以就不推荐去用了。

【Python 第16课】 字符串格式化2

之前我们说到，可以用%来构造一个字符串，比如
print ‘%s is easy to learn’ % ‘Python’

有时候，仅仅代入一个值不能满足我们构造字符串的需要。假设你现在有一组学生成绩的数据，你要输出这些数据。在一行中，既要输出学生的姓名，又要输出他的成绩。例如
Mike‘s score is 87.
Lily‘s score is 95.

在python中，你可以这样实现：
print “%s’s score is %d” % (‘Mike’, 87)

或者

name = ‘Lily’
score = 95
print “%s’s score is %d” % (name, score)

无论你有多少个值需要代入字符串中进行格式化，只需要在字符串中的合适位置用对应格式的%表示，然后在后面的括号中按顺序提供代入的值就可以了。占位的%和括号中的值在数量上必须相等，类型也要匹配。

(‘Mike’, 87)这种用()表示的一组数据在python中被称为元组（tuple），是python的一种基本数据结构，以后我们还会用到。

【Python 第17课】 类型转换

python的几种最基本的数据类型，我们已经见过：

字符串
整数
小数 （浮点数）
bool类型

python在定义一个变量时不需要给它限定类型。变量会根据赋给它的值，自动决定它的类型。你也可以在程序中，改变它的值，于是也就改变了它的类型。例如

a = 1
print a
a = ‘hello’
print a
a = True
print a

变量a先后成为了整数、字符串、bool类型。

虽然类型可以随意改变，但当你对一个特定类型的变量进行操作时，如果这个操作与它的数据类型不匹配，就会产生错误。比如以下几行代码

print ‘Hello’+1
print ‘hello%d’ % ‘123’

程序运行时会报错。因为第一句里，字符串和整数不能相加；第二句里，%d需要的是一个整数，而’123’是字符串。

这种情况下，python提供了一些方法对数值进行类型转换：

int(x) #把x转换成整数
float(x) #把x转换成浮点数
str(x) #把x转换成字符串
bool(x) #把x转换成bool值

上述两个例子就可以写成：

print ‘Hello’+str(1)
print ‘hello%d’ % int(‘123’)

以下等式的结果均为真：

int(‘123’) == 123
float(‘3.3’) == 3.3
str(111) == ‘111’
bool(0) == False

并不是所有的值都能做类型转换，比如int(‘abc’)同样会报错，python没办法把它转成一个整数。

另外关于bool类型的转换，我们会专门再详细说明。大家可以先试试以下结果的值，自己摸索一下转换成bool类型的规律：

bool(-123)
bool(0)
bool(‘abc’)
bool(‘False’)
bool(”)

【Python 第18课】 bool类型转换

昨天最后留的几句关于bool类型的转换，其中有一行：
bool(‘False’)
print一下结果，会发现是True。这是什么原因？

因为在python中，以下数值会被认为是False：
为0的数字，包括0，0.0
空字符串，包括”，””
表示空值的None
空集合，包括()，[]，{}
其他的值都认为是True。

None是python中的一个特殊值，表示什么都没有，它和0、空字符、False、空集合都不一样。关于集合，我们后面的课程再说。

所以，‘False’是一个不为空的字符串，当被转换成bool类型之后，就得到True。
同样bool(‘ ‘)的结果是True，一个空格也不能算作空字符串。
bool(”)才是False。

在if、while等条件判断语句里，判断条件会自动进行一次bool的转换。比如
a = ‘123’
if a:
　print ‘this is not a blank string’

这在编程中是很常见的一种写法。效果等同于
if bool(a)
或者
if a != ”

【Python 第19课】 函数

数学上的函数，是指给定一个输入，就会有唯一输出的一种对应关系。编程语言里的函数跟这个意思差不多，但也有不同。函数就是一块语句，这块语句有个名字，你可以在需要时反复地使用这块语句。它有可能需要输入，有可能会返回输出。

举一个现实中的场景：我们去餐厅吃饭，跟服务员点了菜，过了一会儿，服务员把做好的菜端上来。餐厅的厨房就可以看作是一个函数，我们点的菜单，就是给这个函数的参数；厨师在厨房里做菜的过程就是这个函数的执行过程；做好的菜是返回结果，返回到我们的餐桌上。

我们之前已经用到过python里内建的函数，比如input和range。

以range(1,10)为例，range是这个函数的名称，后面括号里的1和10是range需要的参数。它有返回结果，就是一个从1到9的序列。

再来看input()，括号里面没有，表示我们没有给参数。函数执行过程中，需要我们从控制台输入一个值。函数的返回结果就是我们输入的内容。

PS：range还可以接受1个或3个参数，input也可以接受1个字符串参数。可以等我以后讲，或去查阅相关资料了解详细。

如果我们要自己写一个函数，就需要去 定义 它。python里的关键字叫def（define的缩写），格式如下：

def sayHello():

print ‘hello world!’

sayHello是这个函数的名字，后面的括号里是参数，这里没有，表示不需要参数。但括号和后面的冒号都不能少。下面缩进的代码块就是整个函数的内容，称作函数体。

然后我们去调用这个函数：

sayHello()

得到和直接执行print ‘hello world!’一样的结果。

【Python 第20课】 命令行常用命令

今天茬开话题，说一下命令行（Windows下叫“命令提示符”，Mac下叫“终端”）里的常用命令。已经熟悉同学可略过。

打开命令行，我们会看到每行前面都有诸如

C:\Documents and Settings\Crossin>

或者

MyMacBook:~ crossin$

之类的。

这个提示符表示了当前命令行所在目录。

在这里，我们输入python就可以进入python环境了。但今天我们暂时不这么做。

第一个常用的命令是：

dir （windows环境下）

ls （mac环境下）

dir和ls的作用差不多，都是显示出当前目录下的文件和文件夹。

具体效果可参见文末的附图。

第二个常用命令是：

cd 目录名

通过dir或ls了解当前目录的结构之后，可以通过“cd 目录名”的方式，进入到当前目录下的子目录里。

如果要跳回到上级目录，可以用命令：

cd ..

另外，Windows下如果要写换盘符，需要输入

盘符:

比如从c盘切换到d盘

C:\Documents and Settings\Crossin>d:

有了以上两个命令，就可以在文件目录的迷宫里游荡了。虽然没可视化的目录下的操作那么直观，但是会显得你更像个程序员。。。

于是乎，再说个高阶玩法：现在你可以不用idle那套东西了，随便找个顺手的文本软件，把你的代码写好，保存好，最好是保存成py文件。

然后在命令行下进入到py文件保存的目录，使用命令：

python 你把程序保存的文件名

就可以运行你写的程序了。

嗯，这才像个python程序员的样！

其他常用命令，诸如拷贝文件、删除文件、新建文件夹之类的，请自行搜索相关资料。很容易的，比如你搜“mac 终端 常用命令”，就可以找到很多了。

PS：贴吧里转了一篇关于怎么把py文件转成别人电脑上也可执行的exe文件，稍稍有点复杂，想挑战的可以去试试。

【Python 第21课】 函数的参数

今天发现了一个iPad上的游戏，叫Cargo-Bot。这个游戏需要你用指令控制一个机械臂去搬箱子。游戏里蕴含了很多编程的思想，包括循环、函数调用、条件判断、寄存器、递归等等，挺有意思的。更厉害的是，这个游戏是用一个叫Codea的app直接在iPad上编写出来的。有iPad的同学不妨玩玩看，挑战一下你的“程商”。

言归正传，在19课里，我们讲了怎样定义一个自己的函数，但我们没有给他提供输入参数的功能。不能指定参数的函数就好比你去餐厅吃饭，服务员告诉你，不能点菜，有啥吃啥。这显然不能满足很多情况。

所以，如果我们希望自己定义的函数里允许调用者提供一些参数，就把这些参数写在括号里，如果有多个参数，用逗号隔开，如：

def sayHello(someone):

print someone + ‘ says Hello!’

或者

def plus(num1, num2):

print num1+num2

参数在函数中相当于一个变量，而这个变量的值是在调用函数的时候被赋予的。在函数内部，你可以像过去使用变量一样使用它。

调用带参数的函数时，同样把需要传入的参数值放在括号中，用逗号隔开。要注意提供的参数值的数量和类型需要跟函数定义中的一致。如果这个函数不是你自己写的，你需要先了解它的参数类型，才能顺利调用它。

比如上面两个函数，我们可以直接传入值：

sayHello(‘Crossin’)

还是注意，字符串类型的值不能少了引号。

或者也可以传入变量：

x = 3

y = 4

plus(x, y)

在这个函数被调用时，相当于做了num1=x, num2=y这么一件事。所以结果是输出了7。

【Python 第22课】 函数应用示例

前两课稍稍介绍了一下函数，但光说概念还是有些抽象了，今天就来把之前那个小游戏用函数改写一下。

我希望有这样一个函数，它比较两个数的大小。

如果第一个数小了，就输出“too small”

如果第一个数大了，就输出“too big”

如果相等，就输出“bingo”

函数还有个返回值，当两数相等的时候返回True，不等就返回False。

于是我们来定义这个函数：

def isEqual(num1, num2):

if num1<num2:

print ‘too small’

return False;

if num1>num2:

print ‘too big’

return False;

if num1==num2:

print ‘bingo’

return True

这里说一下，return是函数的结束语句，return后面的值被作为这个函数的返回值。函数中任何地方的return被执行到的时候，这个函数就会结束。

然后在我们的小游戏里使用这个函数：

from random import randint

num = randint(1, 100)

print ‘Guess what I think?’

bingo = False

while bingo == False:

answer = input()

bingo = isEqual(answer, num)

在isEqual函数内部，会输出answer和num的比较结果，如果相等的话，bingo会得到返回值True，否则bingo得到False，循环继续。

函数可以把某个功能的代码分离出来，在需要的时候重复使用，就像拼装积木一样，这会让程序结构更清晰。

【Python 第23课】 if, elif, else

今天补充之前讲过的一个语句：if。为什么我跳要着讲，因为我的想法是先讲下最最基本的概念，让你能用起来，之后你熟悉了，再说些细节。

关于if，可以发送数字『7』回顾之前的课程。它除了我们之前讲的用法外，还可以配合elif和else使用，使程序的运行顺序更灵活。

之前说的if，是：“如果”条件满足，就做xxx，否则就不做。

else顾名思义，就是：“否则”就做yyy。

当if后面的条件语句不满足时，与之相对应的else中的代码块将被执行。

if a == 1:

print ‘right’

else

print ‘wrong’

elif意为else if，含义就是：“否则如果”条件满足，就做yyy。elif后面需要有一个逻辑判断语句。

当if条件不满足时，再去判断elif的条件，如果满足则执行其中的代码块。

if a == 1:

print ‘one’

elif a == 2:

print ‘two’

if, elif, else可组成一个整体的条件语句。

if是必须有的；

elif可以没有，也可以有很多个，每个elif条件不满足时会进入下一个elif判断；

else可以没有，如果有的话只能有一个，必须在条件语句的最后。

if a == 1:

print ‘one’

elif a == 2:

print ‘two’

elif a == 3:

print ‘three’

else:

print ‘too many’

我们昨天刚改写的小游戏中的函数isEqual，用了三个条件判断，我们可以再改写成一个包含if…elif…else的结构：

def isEqual(num1, num2):

if num1<num2:

print ‘too small’

return False;

elif num1>num2:

print ‘too big’

return False;

else:

print ‘bingo’

return True

【Python 第24课】 if的嵌套

和for循环一样，if也可以嵌套使用，即在一个if/elif/else的内部，再使用if。这有点类似于电路的串联。

if 条件1:

if 条件2:

语句1

else:

语句2

else:

if 条件2:

语句3

else:

语句4

在上面这个两层if的结构中，当

条件1为True，条件2为True时，

执行语句1；

条件1为True，条件2为False时，

执行语句2；

条件1为False，条件2为True时，

执行语句3；

条件1为False，条件2为False时，

执行语句4。

假设需要这样一个程序：

我们先向程序输入一个值x，再输入一个值y。(x,y)表示一个点的坐标。程序要告诉我们这个点处在坐标系的哪一个象限。

x>=0，y>=0，输出1；

x<0，y>=0，输出2；

x<0，y<0，输出3；

x>=0，y<0，输出4。

你可以分别写4个if，也可以用if的嵌套：

if y >= 0:

if x >= 0:

print 1

else:

print 2

else:

if x < 0:

print 3

else:

print 4

从流程图上来看，应该是这样。

【Python 第25课】 初探list

昨天课程里的例子有点没说清楚，有同学表示写在程序里发生了错误。因为我当时写这个代码片段时，心里假想着这是在一个函数的内部，所以用了return语句。如果你没有把它放在函数里，那return的话就会出错，你可以换成print。

今天要说一个新概念–list，中文可以翻译成列表，是用来处理一组有序项目的数据结构。想象一下你的购物清单、待办工作、手机通讯录等等，它们都可以看作是一个列表。说它是新概念也不算确切，因为我们之前已经用过它，就在这个语句里：

for i in range(1, 10):

#此处略过数行代码

看出来list在哪里了吗？你试一下：

print range(1,10)

得到的结果是：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

这就是一个list。它由range产生。把上面那个for循环语句写成：

l = range(1, 10)

for i in l:

效果是一样的。

于是可以看出，for循环做的事情其实就是遍历一个列表中的每一项，每次循环都把当前项赋值给一个变量（这里是i），直到列表结束。

我们也可以定义自己的列表，格式就是用中括号包围、逗号隔开的一组数值：

l = [1, 1, 2, 3, 5, 8, 13]

可以用print输出这个列表：

print l

同样也可以用for…in遍历这个列表，依次输出了列表中的每一项：

for i in l:

print l,

列表中的元素也可以是别的类型，比如：

l = [‘meat’, ‘egg’, ‘fish’, ‘milk’]

甚至是不同类型的混合：

l = [365, ‘everyday’, 0.618, True]

l身为一个列表，有一些特有的功能，这个我们下回再说。

【Python 第26课】 操作list

上周给list开了个头，知道了什么是list。假设我们现在有一个list：

l = [365, ‘everyday’, 0.618, True]

除了用for…in遍历l中的元素，我们还能做点啥？

1. 访问list中的元素

list中的每个元素都对应一个递增的序号。与现实中习惯的序号不同在于，计算机中的计数通常都是从0开始，python也不例外。如果你记不清这个而导致了错误，请去听一下孙燕姿的《爱从零开始》。

要访问l中的第1个元素365，只要用l[0]就可以了。依次类推，

print l[1]

就会输出’everyday’

注意，你不能访问一个不存在的元素，比如l[10]，程序就会报错，提示你index越界了。

2. 修改list中的元素

修改list中的某一个元素，只需要直接给那个元素赋值就可以了：

l[0] = 123

输出l，得到[123, ‘everyday’, 0.618, True]，第1个元素已经从365被改成了123。

3. 向list中添加元素

list有一个append方法，可以增加元素。以l这个列表为例，调用的方法是：

l.append(1024)

输出l，你会看到[123, ‘everyday’, 0.618, True, 1024]，1024被添加到了l，成为最后一个元素。（第一个元素在上一步被改成了123）

然后同样可以用l[4]得到1024。

4. 删除list中的元素

删除list中的某一个元素，要用到del：

del l[0]

输出l，得到[‘everyday’, 0.618, True, 1024]。这时候再调用l[0]，会得到’everyday’，其他元素的序号也相应提前。

以上这些命令，你可以直接在python shell中尝试。

#==== 点球小游戏 ====#

我打算从今天开始，每天说一点这个小游戏的做法。方法有很多种，我只是提供一种参考。你可以按照自己喜欢的方式去做，那样她才是属于你的游戏。

先说一下方向的设定。我的想法比较简单，就是左中右三个方向，用字符串来表示。射门或者扑救的时候，直接输入方向。所以这里我准备用raw_input。有同学是用1-8的数字来表示八个方向，每次输入一个数字，这也是可以的。不过这样守门员要扑住的概率可就小多了。

至于电脑随机挑选方向，如果你是用数字表示，就用我们之前讲过的randint来随机就行。不过我这次打算用random的另一个方法：choice。它的作用是从一个list中随机挑选一个元素。

于是，罚球的过程可以这样写：

from random import choice

print ‘Choose one side to shoot:’

print ‘left, center, right’

you = raw_input()

print ‘You kicked ‘ + you

direction = [‘left’, ‘center’, ‘right’]

com = choice(direction)

print ‘Computer saved ‘ + com

if you != com:

print ‘Goal!’

else:

print ‘Oops…’

反之亦然，不赘述。

list有两类常用操作：索引(index)和切片(slice)。

昨天我们说的用[]加序号访问的方法就是索引操作。

除了指定位置进行索引外，list还可以处理负数的索引。继续用昨天的例子：

l = [365, ‘everyday’, 0.618, True]

l[-1]表示l中的最后一个元素。

l[-3]表示倒数第3个元素。

切片操作符是在[]内提供一对可选数字，用:分割。冒号前的数表示切片的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从0开始。

注意，开始位置包含在切片中，而结束位置不包括。

l[1:3]

得到的结果是[‘everyday’, 0.618]。

如果不指定第一个数，切片就从列表第一个元素开始。

如果不指定第二个数，就一直到最后一个元素结束。

都不指定，则返回整个列表的一个拷贝。

l[:3]

l[1:]

l[:]

同索引一样，切片中的数字也可以使用负数。比如：

l[1:-1]

得到[‘everyday’, 0.618]

#==== 点球小游戏 ====#

昨天有了一次罚球的过程，今天我就让它循环5次，并且记录下得分。先不判断胜负。

用score_you表示你的得分，score_com表示电脑得分。开始都为0，每进一球就加1。

from random import choice

score_you = 0

score_com = 0

direction = [‘left’, ‘center’, ‘right’]

for i in range(5):

print ‘==== Round %d – You Kick! ====’ % (i+1)

print ‘Choose one side to shoot:’

print ‘left, center, right’

you = raw_input()

print ‘You kicked ‘ + you

com = choice(direction)

print ‘Computer saved ‘ + com

if you != com:

print ‘Goal!’

score_you += 1

else:

print ‘Oops…’

print ‘Score: %d(you) – %d(com)\n’ % (score_you, score_com)

print ‘==== Round %d – You Save! ====’ % (i+1)

print ‘Choose one side to save:’

print ‘left, center, right’

you = raw_input()

print ‘You saved ‘ + you

com = choice(direction)

print ‘Computer kicked ‘ + com

if you == com:

print ‘Saved!’

else:

print ‘Oops…’

score_com += 1

print ‘Score: %d(you) – %d(com)\n’ % (score_you, score_com)

注意：手机上代码有可能会被换行。

这段代码里有两段相似度很高，想想是不是可以有办法可以用个函数把它们分离出来。

【Python 第28课】 字符串的分割

字符串和list之间有很多不得不说的事。比如有同学想要用python去自动抓取某个网页上的下载链接，那就需要对网页的代码进行处理。处理的过程中，免不了要在字符串和list之间进行很多操作。

我们先从最基本的开始。假设你现在拿到了一个英语句子，需要把这个句子中的每一个单词拿出来单独处理。

sentence = ‘I am an Englist sentence’

这时就需要对字符串进行分割。

sentence.split()

split()会把字符串按照其中的空格进行分割，分割后的每一段都是一个新的字符串，最终返回这些字符串组成一个list。于是得到

[‘I’, ‘am’, ‘an’, ‘Englist’, ‘sentence’]

原来字符串中的空格不再存在。

除了空格外，split()同时也会按照换行符\n，制表符\t进行分割。所以应该说，split默认是按照空白字符进行分割。

之所以说默认，是因为split还可以指定分割的符号。比如你有一个很长的字符串

section = ‘Hi. I am the one. Bye.’

通过指定分割符号为’.’，可以把每句话分开

section.split(‘.’)

得到

[‘Hi’, ‘ I am the one’, ‘ Bye’, ”]

这时候，’.’作为分割符被去掉了，而空格仍然保留在它的位置上。

注意最后那个空字符串。每个’.’都会被作为分割符，即使它的后面没有其他字符，也会有一个空串被分割出来。例如

‘aaa’.split(‘a’)

将会得到[”, ”, ”, ”]，由四个空串组成的list。

既然有把字符串分割成list，那也相应就有把list连接成字符串，这个明天说。

#==== 点球小游戏 ====#

在昨天代码的基础上，我们加上胜负判断，如果5轮结束之后是平分，就继续踢。

所以我们把一轮的过程单独拿出来作为一个函数kick，在5次循环之后再加上一个while循环。

另外，这里把之前的score_you和score_com合并成了一个score数组。这里的原因是，要让kick函数里用到外部定义的变量，需要使用全局变量的概念。暂时想避免说这个，而用list不存在这个问题。

from random import choice

score = [0, 0]

direction = [‘left’, ‘center’, ‘right’]

def kick():

print ‘==== You Kick! ====’

print ‘Choose one side to shoot:’

print ‘left, center, right’

you = raw_input()

print ‘You kicked ‘ + you

com = choice(direction)

print ‘Computer saved ‘ + com

if you != com:

print ‘Goal!’

score[0] += 1

else:

print ‘Oops…’

print ‘Score: %d(you) – %d(com)\n’ % (score[0], score[1])

print ‘==== You Save! ====’

print ‘Choose one side to save:’

print ‘left, center, right’

you = raw_input()

print ‘You saved ‘ + you

com = choice(direction)

print ‘Computer kicked ‘ + com

if you == com:

print ‘Saved!’

else:

print ‘Oops…’

score[1] += 1

print ‘Score: %d(you) – %d(com)\n’ % (score[0], score[1])

for i in range(1):

print ‘==== Round %d ====’ % (i+1)

kick()

while(score[0] == score[1]):

i += 1

print ‘==== Round %d ====’ % (i+1)

kick()

if score[0] > score[1]:

print ‘You Win!’

else:

print ‘You Lose.’

【Python第29课】连接list

今天要说的方法是join。它和昨天说的split正好相反：split是把一个字符串分割成很多字符串组成的list，而join则是把一个list中的所有字符串连接成一个字符串。

join的格式有些奇怪，它不是list的方法，而是字符串的方法。首先你需要有一个字符串作为list中所有元素的连接符，然后再调用这个连接符的join方法，join的参数是被连接的list：

s = ‘;’
li = [‘apple’, ‘pear’, ‘orange’]
fruit = s.join(li)
print fruit

得到结果’apple;pear;orange’。
从结果可以看到，分号把list中的几个字符串都连接了起来。

你也可以直接在shell中输入：

‘;’.join([‘apple’, ‘pear’, ‘orange’])

得到同样的结果。

用来连接的字符串可以是多个字符，也可以是一个空串：

”.join([‘hello’, ‘world’])

得到’helloworld’，字符串被无缝连接在一起。

#==== 点球小游戏 ====#

昨天的代码已经能实现一个完整的点球比赛过程，但有同学提出：这不符合真实比赛规则，说好的提前结束比赛呢？！

关于这个，我想了下，可以有好几种解决方法，但似乎都有些绕。所以放到明天单独来讲，把这个小游戏收尾。

【Python 第30课】 字符串的索引和切片

之前说了，字符串和list有很多不得不说的事。今天就来说说字符串的一些与list相似的操作。

1. 遍历
通过for…in可以遍历字符串中的每一个字符。
word = ‘helloworld’
for c in word:
　print c

2. 索引访问
通过[]加索引的方式，访问字符串中的某个字符。
print word[0]
print word[-2]

与list不同的是，字符串能通过索引访问去更改其中的字符。
word[1] = ‘a’
这样的赋值是错误的。

3. 切片
通过两个参数，截取一段子串，具体规则和list相同。
print word[5:7]
print word[:-5]
print word[:]

4. 连接字符
join方法也可以对字符串使用，作用就是用连接符把字符串中的每个字符重新连接成一个新字符串。不过觉得这个方法有点鸡肋，不知道在什么场景下会用到。
newword = ‘,’.join(word)