Search for notes by fellow students, in your own course and all over the country.
Browse our notes for titles which look like what you need, you can preview any of the notes via a sample of the contents. After you're happy these are the notes you're after simply pop them into your shopping cart.
Title: python basics
Description: with this course you'll learn the basics of python
Description: with this course you'll learn the basics of python
Document Preview
Extracts from the notes are below, to see the PDF you'll receive please use the links above
零基础学Python
目錄
第零部分 独上高楼，望尽天涯路
0
唠叨一些关于python的事情
0
...
1
集成开发环境（IDE）
1
...
3
啰嗦的除法
1
...
5
初识永远强大的函数
1
...
7
玩转字符串(2)
1
...
9
眼花缭乱的运算符
1
...
11
一个免费的实验室
1
...
13
有容乃大的list(2)
1
...
15
有容乃大的list(4)
1
...
17
画圈还不简单吗
1
...
19
字典，你还记得吗？
1
...
21
有点简约的元组
1
...
23
集合的关系
1
...
25
深入变量和引用对象
1
...
27
2
零基础学Python
坑爹的字符编码
1
...
29
不要红头文件(1): open, write, close
1
...
stat, closed, mode, read, readlines, readline
1
...
com/qiwsir
我：Looly
我的Github：https://github
...
com
为什么要开设此栏目
这个栏目的名称叫做“零基础学Python”。
现在网上已经有不少学习python的课程，其中也不乏精品。按理说，不缺少我这个基础类型
的课程了。但是，我注意到一个问题，不管是课程还是出版的书，大多数是面向已经有一定
编程经验的人写的或者讲的，也就是对这些朋友来讲，python已经不是他们的第一门高级编
程语言。据我所知，目前国内很多大学都是将Ｃ之类的做为学生的第一门语言。
然而，在我看来，python是非常适合做为学习高级语言编程的第一门语言的。有一本书，名
字叫《与孩子一起学编程》，这本书的定位，是将python定位为学习者学习的第一门高级编
程语言。然而，由于读者对象是孩子，很多“成年人”不屑一顾，当然，里面的讲法与“实战”有
第零部分 独上高楼，望尽天涯路
4
零基础学Python
点距离，导致以“找工作”、“工作需要”为目标的学习者，认为这本书跟自己要学的方向相差甚
远。
为了弥补那本书的缺憾，我在这里推出面向成年人——大学生、或者其他想学习程序但是没
有任何编程基础的朋友——学习第一门编程高级语言的教程。将Python做为学习高级语言编
程的第一门语言，其优势在于：
入门容易，避免了其它语言的繁琐。
更接近我们的自然语言和平常的思维方法。
学习完这门语言之后，能够直接“实战”——用在工作上。
学习完这门语言之后，能够顺利理解并学习其它语言。
python本身功能强大，一门语言也可以打天下，省却了以后的学习成本。
下面的图示统计显示：Python现在成为美国名校中最流行的编程入门语言。
点击这里看上图来源
综上，我有了这样一个冲动，做一个栏目，面对零基础要学习Python的朋友，面对将python
做为第一门高级语言的朋友。这就是开始本栏目的初衷。
第零部分 独上高楼，望尽天涯路
5
零基础学Python
Then God said: "Let there be light"; and there was light
...
唠叨一些关于Python的事情
如同学习任何一种自然语言比如英语、或者其它编程语言比如汇编（这个我喜欢，可惜多年
之后，已经好久没有用过了）一样，总要说一说有关这种语言的事情，有的可能就是八卦，
越八卦的越容易传播。当然，以下的所有说法中，难免充满了自恋，因为你看不到说Python
的坏话。这也好理解，如果要挑缺点是比较容易的事情，但是找优点，不管是对人还是对其
它事务，都是困难的。这也许是人的劣根之所在吧，喜欢挑别人的刺儿，从而彰显自己在那
方面高于对方。特别是在我们这个麻将文化充斥的神奇地方，更多了。
废话少说点（已经不少了），进入有关python的话题。
Python的昨天今天和明天
这个题目有点大了，似乎回顾过去、考察现在、张望未来，都是那些掌握方向的大人物（司
机吗？）做的。那就让我们每个人都成为大人物吧。因为如果不回顾一下历史，似乎无法满
足学习者的好奇心；如果不考察一下现在，学习者不放心（担心学了之后没有什么用途）；
如果不张望一下未来，怎么能吸引（也算是一种忽悠吧）学习者或者未来的开发者呢？
Python的历史
Python的创始人为吉多·范罗苏姆（Guido van Rossum）。关于这个人开发这种语言的过程，
很多资料里面都要记录下面的故事：
1989年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新
的脚本解释程序，作为ABC语言的一种继承。之所以选中Python作为程序的名字，
是因为他是一个蒙提·派森的飞行马戏团的爱好者。ABC是由吉多参加设计的一种教
学语言。就吉多本人看来，ABC这种语言非常优美和强大，是专门为非专业程序员
设计的。但是ABC语言并没有成功，究其原因，吉多认为是非开放造成的。吉多决
心在Python中避免这一错误，并取得了非常好的效果，完美结合了C和其他一些语
言。
这个故事我是从维基百科里面直接复制过来的，很多讲python历史的资料里面，也都转载这
段。但是，在我来看，这段故事有点忽悠人的味道。其实，上面这段中提到的，吉多为了打
发时间而决定开发python的说法，来自他自己的这样一段自述：
唠叨一些关于python的事情
6
零基础学Python
Over six years ago, in December 1989, I was looking for a "hobby" programming
project that would keep me occupied during the week around Christmas
...
I decided to write an interpreter for the
new scripting language I had been thinking about lately: a descendant of ABC that
would appeal to Unix/C hackers
...
(原文地址：https://www
...
org/doc/essays/foreword/)
首先，必须承认，这个哥们儿是一个牛人，非常牛的人。此处献上我的崇拜。
其次，做为刚刚开始学习python的朋友，可千万别认为python就是一个随随便便就做出来的
东西，就是一个牛人一冲动搞出来的东西。人家也是站在巨人的肩膀上的。
第三，牛人在成功之后，往往把奋斗的过程描绘的比较简单，或者是谦虚？或者是让人听起
来他更牛？反正，我们看最后结果的时候，很难感受过程中的酸甜苦辣。
不管怎么样，牛人在那时刻开始创立了python，而且，他更牛的在于具有现代化的思维：开
放。通过Python社区，吸引来自世界各地的开发者，参与python的建设。在这里，请读者一
定要联想到Linux和它的创始人芬兰人林纳斯·托瓦兹。两者都秉承“开放”思想，得到了来自世
界各地开发者和应用者的欢呼和尊敬。也请大家再联想到另外一个在另外领域秉承开放思想
的人——邓小平先生，他让一个封闭的破旧老水车有了更新。
请列位多所有倡导“开放”的牛人们表示敬意，是他们让这个世界更美好了。他们以行动诠释了
热力学第二定律——“熵增原理”。
Python的现在
有一次与某软件公司一个号称是CTO的人谈话，他问我用什么语言开发，我说用Python，估
计是我的英语发音不好吧（我这回真的谦虚了一把），他居然听成了Pascal（也是一种高级
语言，现在很少用了，曾经是比较流行的教学语言）。呜呼，Python是小众吗？不是，是那
家伙眼界不开阔！接触过不少号称CTO的，多数是有几年经验的程序员，并没有以国际视野
来看待技术，当然，大牛的CTO还是不少的。总之，不要被外表忽悠了，“不看广告，看疗
效”。
首先看一张最近一期的编程语言排行
唠叨一些关于python的事情
7
零基础学Python
python在这个榜单中第8，也许看官心理在想：为什么我不去学那个排第一呢？如果您是一个
零基础的学习者，我以多年的工作和教学经验正告：还是从入门比较容易的开始吧，python
是这样的。等以后，完全可以拓展到其它语言。或许你又问了，php和vb是不是可以呢？他们
排名比python靠前。回答是：当然可以。但是，学习一种入门的语言，要多方考虑，或许以
后你就不想学别的，想用这个包打天下了，那就只有python。并且，还得看下面的信息：
根据Dice
...
Explicit is better than implicit
...
Complex is better than complicated
...
Sparse is better than dense
...
Special cases aren't special enough to break the rules
...
Errors should never pass silently
...
In the face of ambiguity, refuse the temptation to guess
...
Although that way may not be obvious at first unless you're Dutch
...
Although never is often better than *right* now
...
If the implementation is easy to explain, it may be a good idea
...
python
...
python
...
x
...
7
...
7有进步。但是，现在，还有很多东西
没有完全兼容python3。更何况，如果学了python2
...
7为例子来讲授的。
Linux系统的安装
看官所用的计算机是什么操作系统的？自己先弄懂。如果是Linux某个发行版，就跟我同道
了。并且我恭喜你，因为以后会安装更多的一些python库（模块），在这种操作系统下，操
作非常简单，当然，如果是iOS，也一样，因为都是UNIX下的蛋。只是widows有点另类了。
不过，没关系，python就是跨平台的。
我以ubutu 12
...
7
...
python
...
7
...
7
...
tgz
#解压源码包
tar -zxvf Python-2
...
8
...
7
...
/configure --prefix=/usr/local #指定了目录
make&&make install
以上步骤，是我从网上找来的，供参考。因为我的机器早就安装了，不想折腾。安装好之
后，进入shell，输入python，会看到如下：
qw@qw-Latitude-E4300:~$ python
Python 2
...
6 (default, Nov 13 2013, 19:24:16)
[GCC 4
...
3] on linux2
Type "help", "copyright", "credits" or "license" for more information
...
7
...
7
...
msi。然
后就是不断的“下一步”，即可完成安装。
特别注意，安装完之后，需要检查一下，在环境变量是否有python。
如果还不知道什么是windows环境变量，以及如何设置。不用担心，请google一
下，搜索："windows 环境变量"就能找到如何设置了。
以上搞定，在cmd中，输入python，得到跟上面类似的结果，就说明已经安装好了。
Mac OS X系统的安装
其实根本就不用再写怎么安装了，因为用Mac OS X 的朋友，肯定是高手中的高高手了，至少
我一直很敬佩那些用Mac OS X 并坚持没有更换为windows的。麻烦用Mac OS X 的朋友自己
网上搜吧，跟前面unbutu差不多。
如果按照以上方法，顺利安装成功，只能说明幸运，无它。如果没有安装成功，这是提高自
己的绝佳机会，因为只有遇到问题才能解决问题，才能知道更深刻的道理，不要怕，有
google，它能帮助列为看官解决所有问题。当然，加入ＱＱ群或者通过微博，问我也可以。
就一般情况而言，Linux和Mac OS x系统都已经安装了某种python的版本，打开就可以使用。
但是windows是肯定不安装的。除了可以用上面所说的方法安装，还有一个更省事的方法，就
是安装：ActivePython
用ActivePython安装
这个ActivePython是一个面向好多种操作系统的Python 套件,它包含了一个完整的 Python 发
布、一个适用于 Python 编程的 IDE 以及一些 Python的。有兴趣的看官可以到其官网浏
览：http://www
...
com
用源码安装
python是开源的，它的源码都在网上。有高手朋友，如果愿意用源码来安装，亦可，请
到：https://www
...
org/ftp/python/，下载源码安装。
简单记录一下我的安装方法（我是在linux系统中做的）：
1
...
到上述地址下载某种版本的python: wget https://www
...
org/ftp/python/2
...
8/Python-
Python环境安装
15
零基础学Python
2
...
8
...
解压缩：tar xfz Python-2
...
8
...
进入该目录：cd Python-2
...
8
5
...
在上述文件夹内运行：make，然后运行：make install
7
...
安装完毕
OK!已经安装好之后，马上就可以开始编程了。
最后喊一句在一个编程视频课程广告里面看到的口号，很有启发：“我们程序员，不求通过，
但求报错”。
Python环境安装
16
零基础学Python
集成开发环境(IDE)
当安装好python之后，其实就已经可以进行开发了。下面我们开始写第一行python代码。
值得纪念的时刻：Hello world
如果是用windows，请打开CMD，并执行python。
如果是UNIX类的，就运行shell，并执行python。
都会出现如下内容：
Python 2
...
6 (default, Nov 13 2013, 19:24:16)
[GCC 4
...
3] on linux2
Type "help", "copyright", "credits" or "license" for more information
...
com 在这里可以提
问，可以查看答案。一般如果有问题，先在这里查找，多能找到非常满意的结果，
至少有很大启发。 在某国有时候有地方可能不能访问，需要科学上网。好东西，一
定不会让你容易得到，也不会让任何人都得到。
那么做为零基础的学习者，用什么好呢？
集成开发环境（IDE）
20
零基础学Python
既然是零基础，就别瞎折腾了，就用Python自带的IDLE。原因就是：简单。
Windows的朋友操作：“开始”菜单->“所有程序”->“Python 2
...
For in it the righteousness of God
is revealed through faith for faith; s it is written,"The one who is righteous will live by
faith"
用Python计算
一提到计算机，当然现在更多人把她叫做电脑，这两个词都是指computer。不管什么，只要
提到她，普遍都会想到她能够比较快地做加减乘除，甚至乘方开方等。乃至于，有的人在口
语中区分不开计算机和计算器。
那么，做为零基础学习这，也就从计算小学数学题目开始吧。因为从这里开始，数学的基础
知识列为肯定过关了。
复习
还是先来重温一下伟大时刻，打印hello world
...
0 + 2
4
...
0
看官可能愤怒了，这么简单的题目，就不要劳驾计算机了，太浪费了。
别着急，还是要在ide中运算一下，然后看看结果，有没有不一样？要仔细观察哦。
>>> 4+2
6
>>> 4
...
0
>>> 4
...
0
6
...
0。
现在我们就要引入两个数据类型：整数和浮点数
数的类型和四则运算
23
零基础学Python
对这两个的定义，不用死记硬背，google一下。记住爱因斯坦说的那句话：书上有的我都不
记忆（是这么的说？好像是，大概意思，反正我也不记忆）。后半句他没说，我补充一下：
忘了就google。
定义1：类似4、-2、129486655、-988654、0这样形式的数，称之为整数 定义2：
类似4
...
0、2344
...
1415926这样形式的数，称之为浮点数
比较好理解，整数，就是小学学过的整数；浮点数，就是小数。如果整数写成小数形式，比
如4写成4
...
0)
...
2)
1
...
234)
1
...
234,2)
1
...
)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits)
...
Precision may be negative
...
floor(32
...
0
>>> math
...
0
总结
python里的加减乘除按照小学数学规则执行
不用担心大整数问题，python会自动处理
type(object)是一个有用的东西
数的类型和四则运算
26
零基础学Python
"I give you a new commandment, that you love one another
...
By this everyone will know that you are my disciples,
if you have love for one another
...
0/5
0
...
0
0
...
0/5
...
4
看到没有？麻烦出来了（这是在python2
...
4。但我们看到的后三个符合，第一个居然结果是0。why?
因为，在python（严格说是python2
...
5进行四舍五入。
浮点数与整数相除
列位看官注意，这个标题和上面的标题格式不一样，上面的标题是“整数除以整数”，如果按照
风格一贯制的要求，本节标题应该是“浮点数除以整数”，但没有，现在是“浮点数与整数相
除”，其含义是：
假设：x除以y。其中 x 可能是整数，也可能是浮点数；y可能是整数，也可能是浮点数。
出结论之前，还是先做实验：
>>> 9
...
5
>>> 9/2
...
5
>>> 9
...
0
4
...
0/2
4
...
0
4
...
0/2
...
0
归纳，得到规律：不管是被除数还是除数，只要有一个数是浮点数，结果就是浮点数。所
以，如果相除的结果有余数，也不会像前面一样了，而是要返回一个浮点数，这就跟在数学
上学习的结果一样了。
啰嗦的除法
28
零基础学Python
>>> 10
...
3333333333333335
这个是不是就有点搞怪了，按照数学知识，应该是3
...
，后面是3的循环了。那么你的
计算机就停不下来了，满屏都是3。为了避免这个，python武断终结了循环，但是，可悲的是
没有按照“四舍五入”的原则终止。
关于无限循环小数问题，小学都学习了，但是这可不是一个简单问题，看看维基百科的词
条：0
...
，会不会有深入体会呢？
总之，要用python，就得遵循她的规定，前面两条规定已经明确了。
补充一个资料，供有兴趣的朋友阅读：浮点数算法：争议和限制
说明：以上除法规则，是针对python2，在python3中，将5/2和5
...
>>> 9/2
4
>>> 9//2
4
python总会要提供多种解决问题的方案的，这是她的风格。
引用模块解决除法--启用轮子
python之所以受人欢迎，一个很重重要的原因，就是轮子多。这是比喻啦。就好比你要跑的
快，怎么办？光天天练习跑步是不行滴，要用轮子。找辆自行车，就快了很多。还嫌不够
快，再换电瓶车，再换汽车，再换高铁
...
5
>>> 9/2
4
...
0/2
4
...
0
4
...
实验下面的操作：
>>> 5%2
1
>>> 9%2
1
>>> 7%3
1
>>> 6%4
2
>>> 5
...
0
符号：%，就是要得到两个数（可以是整数，也可以是浮点数）相除的余数。
前面说python有很多人见人爱的轮子（模块），她还有丰富的内建函数，也会帮我们做不少
事情。例如函数 divmod()
>>> divmod(5,2) #表示5除以2，返回了商和余数
(2, 1)
>>> divmod(9,2)
(4, 1)
>>> divmod(5
...
0, 1
...
234567,2)
1
...
234567,3)
1
...
0/3,4)
3
...
2345,3)
1
...
235
>>> round(2
...
23 #应该是：2
...
675, 2)
gives 2
...
68
...
See Floating Point
Arithmetic: Issues and Limitations for more information
...
[1] A computer requires programs to function, typically
executing the program's instructions in a central processor
...
The
same program in its human-readable source code form, from which executable
programs are derived (e
...
, compiled), enables a programmer to study and develop its
algorithms
...
Computer source code is typically written by computer programmers
...
Source code may be converted into an
executable file (sometimes called an executable program or a binary) by a compiler and
later executed by a central processing unit
...
Computer programs may be ranked along functional lines: system software and
application software
...
计算机程序
开始真正编程
32
零基础学Python
计算机程序（Computer Program）是指一组指示计算机或其他具有信息处理能力装置每
一步动作的指令，通常用某种程序设计语言编写，运行于某种目标体系结构上。打个比
方，一个程序就像一个用汉语（程序设计语言）写下的红烧肉菜谱（程序），用于指导
懂汉语和烹饪手法的人（体系结构）来做这个菜。 通常，计算机程序要经过编译和链接
而成为一种人们不易看清而计算机可解读的格式，然后运行。未经编译就可运行的程
序，通常称之为脚本程序（script）。
碧螺春，是我最喜欢的了。有人要送礼给我，请别忘记了。难道我期望列位看官会送吗？哈
哈哈
废话少说，开始说程序。程序，简而言之，就是指令的集合。但是，有的程序需要编译，有
的不需要。python编写的程序就不需要，因此她也被称之为脚本程序。特别提醒列位，不要
认为编译的就好，不编译的就不好；也不要认为编译的就“高端”，不编译的就属于“低端”。有
一些做了很多年程序的程序员或者其它什么人，可能会有这样的想法，这是毫无根据的。
不争论。用得妙就是好。
用IDLE的编程环境
操作：File->New window
这样，就出现了一个新的操作界面，在这个界面里面，看不到用于输入指令的提示符：>>>，
这个界面有点像记事本。说对了，本质上就是一个记事本，只能输入文本，不能直接在里面
贴图片。
开始真正编程
33
零基础学Python
写两个大字：Hello,World
Hello,World
...
py为扩展名的。
都做好之后，点击确定按钮，就会发现在另外一个带有>>>的界面中，就自动出来了
Hello,World两个大字。
成功了吗？成功了也别兴奋，因为还没有到庆祝的时候。
在这种情况系，我们依然是在IDLE的环境中实现了刚才那段程序的自动执行，如果脱离这个
环境呢？
下面就关闭IDLE，打开shell(如果看官在使用苹果的 Mac OS 操作系统或者某种linux发行版的
操作系统，比如我使用的是ubuntu)，或者打开cmd(windows操作系统的用户，特别提醒用
windows的用户，使用windows不是你的错，错就错在你只会使用鼠标点来点去，而不想也不
会使用命令，更不想也不会使用linux的命令，还梦想成为优秀程序员。)，通过命令的方式，
进入到你保存刚才的文件目录。
下图是我保存那个文件的地址，我把那个文件命名为105
...
py
上面这句话的含义就是告诉计算机，给我运行一个python语言编写的程序，那个程序文件的
名称是105
...
py)。
在shell或者cmd中，执行：python (文件名
...
，
甚至用alpha,beta,qiwei,qiwsir这样的字母组合也可以。
变量在本质上就是一个占位符。这是一针见血的理解。什么是占位符？就是先把那个位置用
变量占上，表示这里有一个东西，至于这个位置放什么东西，以后再说，反正先用一个符号
占着这个位置（占位符）。
其实在高级语言编程中，变量比我们在初中数学中学习的要复杂。但是，现在我们先不管那
些，复杂东西放在以后再说了。现在，就按照初中数学来研究python中的变量
通常使小写字母来命名python中的变量，也可以在其中加上下划线什么的，表示区别。
比如：alpha,x,j,p_beta，这些都可以做为python的变量。
给变量赋值
打开IDLE，实验操作如下：
初识永远强大的函数
38
零基础学Python
>>> a = 2 #注1
>>> a #注2
2
>>> b = 3 #注3
>>> c = 3
>>> b
3
>>> c
3
>>>
说明：
注1：a=2的含义是将一个变量a指向了2这个数，就好比叫做a是的钓鱼的人，通过鱼线，
跟一条叫做2的鱼连接者，a通过鱼线就可以导到2
注2：相当于要a这个钓鱼的人，顺着鱼线导出那条鱼，看看连接的是哪一条，发现是叫
做2的那条傻鱼
注3：b=3，理解同上。那么c=3呢？就是这条叫做3的鱼被两个人同时钓到了。
建立简单函数
>>> a = 2
>>> y=3*a+2
>>> y
8
这种方式建立的函数，跟在初中数学中学习的没有什么区别。当然，这种方式的函数，在编
程实践中的用途不大，一般是在学习阶段理解函数来使用的。
别急躁，你在输入a=3,然后输入y，看看得到什么结果呢？
>>> a=2
>>> y=3*a+2
>>> y
8
>>> a=3
>>> y
8
是不是很奇怪？为什么后面已经让a等于3了，结果y还是8。
用前面的钓鱼理论就可以解释了。a和2相连，经过计算，y和8相连了。后面a的连接对象修改
了，但是y的连接对象还没有变，所以，还是8。再计算一次，y的连接对象就变了：
初识永远强大的函数
39
零基础学Python
>>> a=3
>>> y
8
>>> y=3*a+2
>>> y
11
特别注意，如果没有先a=2，就直接下函数表达式了，像这样，就会报错。
>>> y=3*a+2
Traceback (most recent call last):
File "
NameError: name 'a' is not defined
注意看错误提示，a是一个变量，提示中告诉我们这个变量没有定义。显然，如果函数中要使
用某个变量，不得不提前定义出来。定义方法就是给这个变量赋值。
建立实用的函数
上面用命令方式建立函数，还不够“正规化”，那么就来写一个
...
py，你根据自己的喜好取个名字。
然后我就进入到那个文件夹，运行这个文件，出现下面的结果，如图：
你运行的结果是什么？如果没有得到上面的结果，你就非常认真地检查代码，是否跟我写的
完全一样，注意，包括冒号和空格，都得一样。冒号和空格很重要。
初识永远强大的函数
40
零基础学Python
下面开始庖丁解牛：
#coding:utf-8声明本 文件中代码的字符集类型是utf-8格式。初学者如果还不理解，一方
面可以去google，另外还可放一放，就先这么抄写下来，以后会讲解。
def add_function(a,b): 这里是函数的开始。在声明要建立一个函数的时候，一定要使用
def（def 就是英文define的前三个字母），意思就是告知计算机，这里要声明一个函数；
add_function是这个函数名称，取名字是有讲究的，就好比你的名字一样。在python中取
名字的讲究就是要有一定意义，能够从名字中看出这个函数是用来干什么的。从
add_function这个名字中，是不是看出她是用来计算加法的呢？(a,b)这个括号里面的是这
个函数的参数，也就是函数变量。冒号，这个冒号非常非常重要，如果少了，就报错
了。冒号的意思就是下面好开始真正的函数内容了。
c=a+b 特别注意，这一行比上一行要缩进四个空格。这是python的规定，要牢记，不可
丢掉，丢了就报错。然后这句话就是将两个参数(变量)相加，结果赋值与另外一个变量
c。
print c 还是提醒看官注意，缩进四个空格。将得到的结果c的值打印出来。
if name=="main": 这句话先照抄，不解释。注意就是不缩进了。
add_function(2,3) 这才是真正调用前面建立的函数，并且传入两个参数：a=2,b=3。仔细
观察传入参数的方法，就是把2放在a那个位置，3放在b那个位置（所以说，变量就是占
位符)
...
，参数n)：
函数体
是不是样式很简单呢？
取名字的学问
有的大师，会通过某个人的名字来预测他/她的吉凶祸福等。看来名字这玩意太重要了。取个
好名字，就有好兆头呀。所以孔丘先生说“名不正，言不顺”，歪解：名字不正规化，就不顺。
这是歪解，希望不要影响看官正确理解。不知道大师们是不是能够通过外国人名字预测外国
人大的吉凶祸福呢？
不管怎样，某国人是很在意名字的，旁边有个国家似乎就不在乎。
初识永远强大的函数
41
零基础学Python
python也很在乎名字问题，其实，所有高级语言对名字都有要求。为什么呢？因为如果命名
乱了，计算机就有点不知所措了。看python对命名的一般要求。
文件名:全小写,可使用下划线
函数名:小写，可以用下划线风格单词以增加可读性。如：myfunction，
my_example_function。注意：混合大小写仅被允许用于这种风格已经占据优势的时候，
以便保持向后兼容。
函数的参数:如果一个函数的参数名称和保留的关键字(所谓保留关键字，就是python语言
已经占用的名称，通常被用来做为已经有的函数等的命名了，你如果还用，就不行了。)
冲突，通常使用一个后缀下划线好于使用缩写或奇怪的拼写。
变量:变量名全部小写，由下划线连接各个单词。如color = WHITE，this_is_a_variable =
1。
其实，关于命名的问题，还有不少争论呢？最典型的是所谓匈牙利命名法、驼峰命名等。如
果你喜欢，可以google一下。以下内容供参考：
匈牙利命名法
驼峰式大小写
帕斯卡命名法
python命名的官方要求，如果看官的英文可以，一定要阅读。如果英文稍逊，可以来阅
读中文,不用梯子能行吗？看你命了。
初识永远强大的函数
42
零基础学Python
And since they did not see fit to acknowledge God, God gave them up to a debased
mind and things that should no be done
...
Full of envy, murder, strife, deceit, craftiness, they are
gossips, slanderers, God-haters, insolent, haughty, boastful, inventors of evil, rebellious
toward parents, foolish,faithless, heartless, ruthless
...
(ROMANS 1:28-32)
玩转字符串(1)
如果对自然语言分类，有很多中分法，比如英语、法语、汉语等，这种分法是最常见的。在
语言学里面，也有对语言的分类方法，比如什么什么语系之类的。我这里提出一种分法，这
种分法尚未得到广大人民群众和研究者的广泛认同，但是，我相信那句“真理是掌握在少数人
的手里”，至少在这里可以用来给自己壮壮胆。
我的分法：一种是语言中的两个元素（比如两个字）和在一起，出来一个新的元素（比如新
的字）；另外一种是两个元素和在一起，知识两个元素并列。比如“好”和“人”，两个元素和在
一起是“好人”，而3和5和在一起是8，如果你认为是35，那就属于第二类和法了。
把我的这种分法抽象一下：
一种是：△ +□ = ○
另外一种是：△ +□ = △ □
我们的语言中，离不开以上两类，不是第一类就是第二类。
太天才了。请鼓掌。
字符串
在我洋洋自得的时候，我google了一下，才发现，自己没那么高明，看维基百科的字符串词
条是这么说的：
字符串（String），是由零个或多个字符组成的有限串行。一般记为s=a[1]a[2]
...
When should i use str() and when should i use repr() ?
Almost always use str when creating output for end users
...
For example, if you suspect a string
has non printing characters in it, or a float has a small rounding error, repr will show
you; str may not
...
It can
also be used for persistence (with ast
...
2
...
You shouldn't generally use them except as
described above
...
What can str() do which repr() can't ?
Give you output fit for end-user consumption--not always (e
...
, str(['spam', 'eggs']) isn't
likely to be anything you want to put in a GUI), but more often than repr
...
What can repr() do which str() can't
Give you output that's useful for debugging--again, not always (the default for instances
of user-created classes is rarely helpful), but whenever possible
...
以上英文内容来源：http://stackoverflow
...
I am qiwsir
...
My website is 'http://qiwsir
...
io'
...
I am qiwsir
...
github
...
>>> print "you can connect me by qq\\weibo\\gmail" #\\是为了要后面那个\
you can connect me by qq\weibo\gmail
看官自己试试吧。如果有问题，可以联系我解答。
玩转字符串(1)：基本概念、字符转义、字符串连接、变量与字符串关系
48
零基础学Python
玩转字符串(2)
上一章中已经讲到连接两个字符串的一种方法。复习一下：
>>> a= 'py'
>>> b= 'thon'
>>> a+b
'python'
既然这是一种方法，言外之意，还有另外一种方法。
连接字符串的方法2
在说方法2之前，先说明一下什么是占位符，此前在讲解变量（参数）的时候，提到了占位
符，这里对占位符做一个比较严格的定义：
来自百度百科的定义：
顾名思义，占位符就是先占住一个固定的位置，等着你再往里面添加内容的符号。
根据这个定义，在python里面规定了一些占位符，通过这些占位符来说明那个位置应该填写
什么类型的东西，这里暂且了解两个占位符：%d——表示那个位置是整数，%s——表示那个
位置应该是字符串。下面看一个具体实例：
>>> print "one is %d"%1
one is 1
要求打印(print)的内容中，有一个%d占位符，就是说那个位置应该放一个整数。在第二个%
后面，跟着的就是那个位置应该放的东西。这里是一个整数1。我们做下面的操作，就可以更
清楚了解了：
>>> a=1
>>> type(a)
>>> b="1"
>>> type(b)
>>> print "one is %d"%a
one is 1
>>> print "one is %d"%b #报错了，这个占位符的位置应该放整数，不应该放字符串。
Traceback (most recent call last):
File "
TypeError: %d format: a number is required, not str
玩转字符串(2)
49
零基础学Python
同样道理，%s对应的位置应该放字符串，但是，如果放了整数，也可以。只不过是已经转为
字符串对待了。但是不赞成这么做。在将来，如果使用mysql（一种数据库）的时候，会要求
都用%s做为占位符，这是后话，听听有这么回事即可。
>>> print "one is %s"%b
one is 1
>>> print "one is %s"%a #字符串是包容的
one is 1
好了。啰嗦半天，占位符是不是理解了呢？下面我们就用占位符来连接字符串。是不是很有
意思？
>>> a = "py"
>>> b = "thon"
>>> print "%s%s"%(a,b) #注
python
注：仔细观察，如果两个占位符，要向这两个位置放东西，代表的东西要写在一个圆括号
内，并且中间用逗号（半角）隔开。
字符串复制
有一个变量，连接某个字符串，也想让另外一个变量，也连接这个字符串。一种方法是把字
符串再写一边，这种方法有点笨拙，对于短的到无所谓了。但是长的就麻烦了。这里有一种
字符串复制的方法：
>>> a = "My name is LaoQi
...
"
>>> print a
My name is LaoQi
...
>>> b = a
>>> print b
My name is LaoQi
...
>>> print a
My name is LaoQi
...
复制非常简单，类似与赋值一样。可以理解为那个字符串本来跟a连接着，通过b=a，a从自己
手里分处一股绳子给了b，这样两者都可以指向那个字符串了。
字符串长度
玩转字符串(2)
50
零基础学Python
要向知道一个字符串有多少个字符，一种方法是从头开始，盯着屏幕数一数。哦，这不是计
算机在干活，是键客在干活。键客，不是剑客。剑客是以剑为武器的侠客；而键客是以键盘
为武器的侠客。当然，还有贱客，那是贱人的最高境界，贱到大侠的程度，比如岳不群之
流。
键客这样来数字符串长度：
>>> a="hello"
>>> len(a)
5
使用的是一个函数len(object)。得到的结果就是该字符串长度。
>>> m = len(a) #把结果返回后赋值给一个变量
>>> m
5
>>> type(m) #这个返回值（变量）是一个整数型
字符大小写的转换
对于英文，有时候要用到大小写转换。最有名驼峰命名，里面就有一些大写和小写的参合。
如果有兴趣，可以来这里看自动将字符串转化为驼峰命名形式的方法。
在python中有下面一堆内建函数，用来实现各种类型的大小写转化
S
...
lower() #S中的字母小写
S
...
istitle() #单词首字母是否大写的，且其它为小写，注网友白羽毛指出，这里表述不准
确。非常感谢他。为了让看官对这些大小写问题有更深刻理解，我从新写下面的例子，
请看官审查。再次感谢白羽毛。
S
...
islower() #S中的字母是否全是小写
看例子：
玩转字符串(2)
51
零基础学Python
>>> a = "qiwsir,python"
>>> a
...
upper()
>>> b
'QIWSIR,PYTHON'
>>> c = b
...
capitalize() #把字符串的第一个字母变成大写
'Qiwsir,python'
>>> a #原数据对象没有改变
'qiwsir,python'
>>> b = a
...
istitle()
False
>>> a = "QIWSIR" #当全是大写的时候，返回False
>>> a
...
istitle()
False
>>> a = "Qiwsir,github" #如果这样，也返回False
>>> a
...
istitle()
True
>>> a = 'Qiwsir,Github' #这样也是True
>>> a
...
isupper()
False
>>> a
...
isupper()
True
>>> a
...
lower()
...
istitle()
False
>>> b = a
...
istitle() #判断每个单词的第一个字母是否为大写
False
字符串问题，看来本讲还不能结束。下一讲继续。有看官可能要问了，上面这些在实战中怎
么用？我正想为你的，请键客设计一种实战情景，能不能用上所学。
玩转字符串(2)
53
零基础学Python
玩转字符串(3)
字符串是一个很长的话题，纵然现在开始第三部分，但是也不能完全说尽。因为字符串是自
然语言中最复杂的东西，也是承载功能最多的，计算机高级语言编程，要解决自然语言中的
问题，让自然语言中完成的事情在计算机上完成，所以，也不得不有更多的话题。
字符串就是一个话题中心。
给字符串编号
在很多很多情况下，我们都要对字符串中的每个字符进行操作（具体看后面的内容），要准
确进行操作，必须做的一个工作就是把字符进行编号。比如一个班里面有50名学生，如果这
些学生都有学号，老师操作他们将简化很多。比如不用专门找每个人名字，直接通过学号知
道谁有没有交作业。
在python中按照这样的顺序对字符串进行编号：从左边第一个开始是0号，向下依次按照整数
增加，为1、2
...
这样截
取到的就是上面所要求的了。
试一试，怎么截取到",wor"
也就是说，截取a[n,m]，其中n
>>> a[:] #表示截取全部
'Hello,wor ld'
>>> a[3:] #表示从a[3]开始，一直到字符串的最后
'lo,wor ld'
>>> a[:4] #表示从字符串开头一直到a[4]前结束
'Hell'
去掉字符串两头的空格
玩转字符串(3)
55
零基础学Python
这个功能，在让用户输入一些信息的时候非常有用。有的朋友喜欢输入结束的时候敲击空
格，比如让他输入自己的名字，输完了，他来个空格。有的则喜欢先加一个空格，总做的输
入的第一个字前面应该空两个格。
好吧，这些空格是没用的。python考虑到有不少人可能有这个习惯，因此就帮助程序员把这
些空格去掉。
方法是：
S
...
lstrip() 去掉字符串的左边空格
S
...
strip()
'hello'
>>> b
' hello '
>>> b
...
rstrip()
' hello'
练习
学编程，必须做练习，通过练习熟悉各种情况下的使用。
下面共同做一个练习：输入用户名，计算机自动向这个用户打招呼。代码如下：
#coding:utf-8
print "please write your name:"
name=raw_input()
print "Hello,%s"%name
这段代码中的raw_input()的含义，就是要用户输入内容，所输入的内容是一个字符串。
其实，上面这段代码存在这改进的地方，比如，如果用户输入的是小写，是不是要将名字的
首字母变成大写呢？如果有空格，是不是要去掉呢？等等。或许还有别的，看看能不能在这
个练习中，将以前学习过的东西综合应用一下？
玩转字符串(3)
56
零基础学Python
眼花缭乱的运算符
在计算机高级中语言，运算符是比较多样化的。其实，也都源于我们日常的需要。
算术运算符
前面已经讲过了四则运算，其中涉及到一些运算符：加减乘除，对应的符号分别是：+ - * /，
此外，还有求余数的：%。这些都是算术运算符。其实，算术运算符不止这些。根据中学数学
的知识，看官也应该想到，还应该有乘方、开方之类的。
下面列出一个表格，将所有的运算符表现出来。不用记，但是要认真地看一看，知道有那
些，如果以后用到，但是不自信能够记住，可以来查。
运算
符
描述
实例
+
加 - 两个对象相加
10+20 输出结果 30
-
减 - 得到负数或是一个数减去另一个数
10-20 输出结果 -10
*
乘 - 两个数相乘或是返回一个被重复若干次
的字符串
10 * 20 输出结果 200
/
除 - x除以y
20/10 输出结果 2
%
取余 - 返回除法的余数
20%10 输出结果 0
**
幂 - 返回x的y次幂
10**2 输出结果 100
//
取整除 - 返回商的整数部分
9//2 输出结果 4 , 9
...
0 输出结
果 4
...
>
大于 - 返回x是否大于y
(a > b) 返回 False。
<
小于 - 返回x是否小于y
(a < b) 返回 true。
>=
大于等于 - 返回x是否大于等于y。
(a >= b) 返回 False。
<=
小于等于 - 返回x是否小于等于y。
(a <= b) 返回 true。
上面的表格实例中，显示比较的结果就是返回一个true或者false，这是什么意思呢。就是在告
诉你，这个比较如果成立，就是为真，返回True，否则返回False，说明比较不成立。
请按照下面方式进行比较操作，然后再根据自己的想象，把比较操作熟练熟练。
>>> a=10
>>> b=20
>>> a>b
False
>>> a
>>> a==b
False
>>> a!=b
True
>>> a>=b
False
>>> a<=b
True
>>> c="5" #a、c是两个不同类型的量，能比较，但是不提倡这么做。
>>> a>c
False
>>> a
眼花缭乱的运算符
58
零基础学Python
逻辑运算符
首先谈谈什么是逻辑，韩寒先生对逻辑有一个分类：
逻辑分两种，一种是逻辑，另一种是中国人的逻辑。————韩寒
这种分类的确非常精准。在很多情况下，中国人是有很奇葩的逻辑的。但是，在python中，
讲的是逻辑，不是中国人的逻辑。
逻辑（logic），又称理则、论理、推理、推论，是有效推论的哲学研究。逻辑被使用在
大部份的智能活动中，但主要在哲学、数学、语义学和计算机科学等领域内被视为一门
学科。在数学里，逻辑是指研究某个形式语言的有效推论。
关于逻辑问题，看官如有兴趣，可以听一听《国立台湾大学公开课：逻辑》
下面简单理解一下逻辑问题。
布尔类型的变量
在所有的高级语言中，都有这么一类变量，被称之为布尔型。从这个名称，看官就知道了，
这是用一个人的名字来命名的。
乔治·布尔（George Boole，1815年11月－1864年，)，英格兰数学家、哲学家。
乔治·布尔是一个皮匠的儿子，生于英格兰的林肯。由于家境贫寒，布尔不得不在协助养
家的同时为自己能受教育而奋斗，不管怎么说，他成了19世纪最重要的数学家之一。尽
管他考虑过以牧师为业，但最终还是决定从教，而且不久就开办了自己的学校。
在备课的时候，布尔不满意当时的数学课本，便决定阅读伟大数学家的论文。在阅读伟
大的法国数学家拉格朗日的论文时，布尔有了变分法方面的新发现。变分法是数学分析
的分支，它处理的是寻求优化某些参数的曲线和曲面。
1848年，布尔出版了《The Mathematical Analysis of Logic》，这是他对符号逻辑诸多
贡献中的第一次。
1849年，他被任命位于爱尔兰科克的皇后学院（今科克大学或UCC）的数学教授。1854
年，他出版了《The Laws of Thought》，这是他最著名的著作。在这本书中布尔介绍了
现在以他的名字命名的布尔代数。布尔撰写了微分方程和差分方程的课本，这些课本在
英国一直使用到19世纪末。 由于其在符号逻辑运算中的特殊贡献，很多计算机语言中将
逻辑运算称为布尔运算，将其结果称为布尔值。
请看官认真阅读布尔的生平，立志呀。
布尔所创立的这套逻辑被称之为“布尔代数”。其中规定只有两种值，True和False，正好对应
这计算机上二进制数的1和0。所以，布尔代数和计算机是天然吻合的。
眼花缭乱的运算符
59
零基础学Python
所谓布尔类型，就是返回结果为1(True)、0(False)的数据变量。
在python中（其它高级语言也类似，其实就是布尔代数的运算法则），有三种运算符，可以
实现布尔类型的变量间的运算。
布尔运算
看下面的表格，对这种逻辑运算符比较容易理解：
（假设变量a为10，变量b为20）
运算
符
描述
实例
and
布尔"与" - 如果x为False，x and y返回False，否则它返
回y的计算值。
(a and b) 返回
true。
or
布尔"或" - 如果x是True，它返回True，否则它返回y的计
算值。
(a or b) 返回 true。
not
布尔"非" - 如果x为True，返回False。如果x为False，它
返回True。
not(a and b) 返回
false。
and
and，翻译为“与”运算，但事实上，这种翻译容易引起望文生义的理解。先说一下正确的理
解。A and B，含义是：首先运算A，如果A的值是true，就计算B，并将B的结果返回做为最终
结果，如果B是False，那么A and B的最终结果就是False,如果B的结果是True，那么A and B
的结果就是True；如果A的值是False ,就不计算B了，直接返回A and B的结果为False
...
>>> 4>3 and 4<9
True
4>3 and 4<2 ，先看
4>3 ，返回
True ，再看
4<2 ，返回的是
False ，那么最终结果
是 False
...
py的文件，这些文件可以用python来运行。那些文件，就是由语
句组成的程序。
为了能够严谨地阐述这个概念，我还是要抄一段维基百科中的词条：命令式编程
命令式编程（英语：Imperative programming），是一种描述电脑所需作出的行为的编
程范型。几乎所有电脑的硬件工作都是指令式的；几乎所有电脑的硬件都是设计来运行
机器码，使用指令式的风格来写的。较高级的指令式编程语言使用变量和更复杂的语
句，但仍依从相同的范型。
运算语句一般来说都表现了在存储器内的数据进行运算的行为，然后将结果存入存储器
中以便日后使用。高级命令式编程语言更能处理复杂的表达式，可能会产生四则运算和
函数计算的结合。
一般所有高级语言，都包含如下语句，Python也不例外：
循环语句:容许一些语句反复运行数次。循环可依据一个默认的数目来决定运行这些语句
的次数；或反复运行它们，直至某些条件改变。
条件语句:容许仅当某些条件成立时才运行某个区块。否则，这个区块中的语句会略去，
然后按区块后的语句继续运行。
无条件分支语句容许运行顺序转移到程序的其他部分之中。包括跳跃（在很多语言中称
为Goto）、副程序和Procedure等。
循环、条件分支和无条件分支都是控制流程。
if语句
谈到语句，不要被吓住。看下面的例子先：
从if开始语句的征程
63
零基础学Python
if a==4:
print "it is four"
else:
print "it is no four"
逐句解释一番，注意看注释。在这里给列为看官提醒，在写程序的是由，一定要写必要的注
释，同时在阅读程序的时候，也要注意看注释。
if a==4: #如果变量a==4是真的，a==4为True，就
print "it is four" #打印“it is four”。
else: #否则，即a==4是假的，a==4为False，就
print "it is not four" #打印“it is not four”。
以上几句话，就完成了一个条件判断，在不同条件下做不同的事情。因此，if语句，常被翻译
成“条件语句”。
条件语句的基本样式结构：
if 条件1:
执行的内容1
elif 条件2:
执行的内容2
elif 条件3：
执行的内容3
else:
执行的内容4
执行的内容1、内容2，等，称之为语句块。elif用于多个条件时使用，可以没有。另外，也可
以只有if，而没有else。
提醒：每个执行的内容，均以缩进四个空格方式。
例1：输入一个数字，并输出输入的结果，如果这个数字大于10，那么同时输出大于10,如果
小于10，同时输出提示小于10,如果等于10,就输出表扬的一句话。
从这里开始，我们的代码就要越来越接近于一个复杂的判断过程了。为了让我们的思维能够
更明确上述问题的解决流程，在程序开发过程中，常常要画流程图。什么是流程图，我从另
外一个角度讲，就是要让思维过程可视化，简称“思维可视化”。顺便自吹自擂一下，我从2004
年就开始在我朝推广思维导图，这就是一种思维可视化工具。自吹到此结束。看这个问题的
流程图：
从if开始语句的征程
64
零基础学Python
理解了流程图中的含义，就开始写代码，代码实例如下：
#! /usr/bin/env python
#coding:utf-8
print "请输入任意一个整数数字："
number = int(raw_input()) #通过raw_input()输入的数字是字符串
#用int()将该字符串转化为整数
if number == 10:
print "您输入的数字是：%d"%number
print "You are SMART
...
"
elif number < 10:
print "您输入的数字是：%d"%number
print "This number is less than 10
...
建议看官实验一下。
上述程序的后面，就是依据条件进行判断，不同条件下做不同的事情了。需要提醒的是在条
件中：number == 10，为了阅读方便，在number和==之间有一个空格最好了，同理，后面也
有一个。这里的10,是int类型，number也是int类型
...
github
...
github
...
github
...
print "I like python"
...
7，的确需要缩进。上面的例子就看出来了。
看官在自己的机器上测试一下，是不是需要缩进？
报错
在一个广告中看到过这样一句话：程序员的格言，“不求最好，只求报错”。报错，对编程不是
坏事。如何对待报错呢？
一定要认真阅读所提示的错误信息。
还是上面那个例子，我如果这样写：
>>> if bool(a):
...
表示当前指令没有结束。要结束并执
行，需要敲击两次回车键。
探索
如果看官对某个指令不了解，或者想试试某种操作是否可行，可以在交互模式下进行探索，
这种探索的损失成本非常小，充其量就是报错。而且从报错信息中，我们还能得到更多有价
值的内容。
例如，在《眼花缭乱的运算符》中，提到了布尔运算，其实，在变量的类型中，除了前面提
到的整数型、字符串型，布尔型也是一种，那么布尔型的变量有什么特点呢？下面就探索一
下：
>>> a
'http://qiwsir
...
io'
>>> bool(a) #布尔型,用bool()表示，就类似int(),str()，是一个内置函数
True
>>> b=""
>>> bool(b)
False
>>> bool(4>3)
True
>>> bool(4<3)
False
>>> m=bool(b)
>>> m
False
>>> type(m)
>>>
从上面的实验可以看出，如果对象是空，返回False，如果不是，则返回True；如果对象是
False，返回False。上面探索，还可以扩展到其它情况。看官能不能通过探索，总结出bool()
的特点呢？
一个免费的实验室
70
零基础学Python
有容乃大的list(1)
前面的学习中，我们已经知道了两种python的数据类型：int和str。再强调一下对数据类型的
理解，这个世界是由数据组成的，数据可能是数字（注意，别搞混了，数字和数据是有区别
的），也可能是文字、或者是声音、视频等。在python中（其它高级语言也类似）把状如2,3
这样的数字划分为一个类型，把状如“你好”这样的文字划分一个类型，前者是int类型，后者是
str类型（这里就不说翻译的名字了，请看官熟悉用英文的名称，对日后编程大有好处，什么
好处呢？谁用谁知道！）。
前面还学习了变量，如果某个变量跟一个int类型的数据用线连着（行话是：赋值），那么这
个变量我们就把它叫做int类型的变量；有时候还没赋值呢，是准备让这个变量接收int类型的
数据，我们也需要将它声明为int类型的变量。不过，在python里面有一样好处，变量不用提
前声明，随用随命名。
这一讲中的list类型，也是python的一种数据类型。翻译为：列表。下面的黑字，请看官注意
了：
LIST在python中具有非常强大的功能。
定义
在python中，用方括号表示一个list，[ ]
在方括号里面，可以是int，也可以是str类型的数据，甚至也能够是True/False这种布尔值。看
下面的例子，特别注意阅读注释。
>>> a=[] #定义了一个变量a，它是list类型，并且是空的。
>>> type(a)
>>> bool(a) #用内置函数bool()看看list类型的变量a的布尔值，因为是空的，所以为False
False
>>> print a #打印list类型的变量a
[]
不能总玩空的，来点实的吧。
有容乃大的list(1)
71
零基础学Python
>>> a=['2',3,'qiwsir
...
io']
>>> a
['2', 3, 'qiwsir
...
io']
>>> type(a)
>>> bool(a)
True
>>> print a
['2', 3, 'qiwsir
...
io']
用上述方法，定义一个list类型的变量和数据。
本讲的标题是“有容乃大的list”，就指明了list的一大特点：可以无限大，就是说list里面所能容
纳的元素数量无限，当然这是在硬件设备理想的情况下。
list索引
尚记得在《玩转字符串(3)》中，曾经给字符串进行编号，然后根据编号来获取某个或者某部
分字符，这样的过程，就是“索引”(index)。
>>> url = "qiwsir
...
io"
>>> url[2]
'w'
>>> url[:4]
'qiws'
>>> url[3:9]
'sir
...
github
...
github
...
github
...
github
...
strip()，这是去掉左右空格的内置函
数，也是str的方法。按照一贯制的对称法则，对list也会有一些操作方法。
追加元素
>>> a = ["good","python","I"]
>>> a
['good', 'python', 'I']
>>> a
...
append(100) #向list中添加int类型100
>>> a
['good', 'python', 'I', 'like', 100]
官方文档这样描述list
...
append(x)
Add an item to the end of the list; equivalent to a[len(a):] = [x]
...
append(x)的含义呢？即将
新的元素x追加到list的尾部。
列位看官，如果您注意看上面官方文档中的那句话，应该注意到，还有后面半句： equivalent
to a[len(a):] = [x]，意思是说list
...
append(x)，也就是将某个元素x 追加到已知
的一个list后边。
除了将元素追加到list中，还能够将两个list合并，或者说将一个list追加到另外一个list中。按照
前文的惯例，还是首先看官方文档中的描述：
有容乃大的list(2)
75
零基础学Python
list
...
向所有正在学习本内容的朋友提供一个成为优秀程序员的必备：看官方文档，是必须的。
官方文档的这句话翻译过来：
通过将所有元素追加到已知list来扩充它，相当于a[len(a)]= L
英语太烂，翻译太差。直接看例子，更明白
>>> la
[1, 2, 3]
>>> lb
['qiwsir', 'python']
>>> la
...
extend(b)
>>> la
[1, 2, 3, 'a', 'b', 'c']
>>> c = 5
>>> la
...
extend(L) 等效于 list[len(list):] = L，L是待并入的list
联想到到上一讲中的一个list函数list
...
append(["qiwsir","github"])
>>> lst
[1, 2, 3, ['qiwsir', 'github']] #append的结果
>>> len(lst)
4
>>> lst2 = [1,2,3]
>>> lst2
...
count(x)
Return the number of times x appears in the list
...
count(1)
3
>>> la
...
append('a')
>>> la
[1, 2, 1, 1, 3, 'a', 'a']
>>> la
...
count(2)
1
>>> la
...
index(3)
2
>>> la
...
index(1)
0
>>> la
...
index('qiwsir')
6
有容乃大的list(2)
78
零基础学Python
list
...
index(x)
Return the index in the list of the first item whose value is x
...
是不是说的非常清楚明白了？
先到这里，下讲还继续有容乃大的list
...
append("io")
>>> all_users
['qiwsir', 'github', 'io']
从这个操作，就可以说明list是可以随时改变的。这种改变的含义只它的大小即所容纳元素的
个数以及元素内容，可以随时直接修改，而不用进行转换。这和str有着很大的不同。对于
str，就不能进行字符的追加。请看官要注意比较，这也是str和list的重要区别。
与list
...
insert(i,x)也是对list元素的增加。只不过是可以在任何位置增加一个
元素。
我特别引导列为看官要通过官方文档来理解：
list
...
The first argument is the index of the element
before which to insert, so a
...
insert(len(a), x) is equivalent to a
...
这次就不翻译了。如果看不懂英语，怎么了解贵国呢？一定要硬着头皮看英语，不仅能够学
好程序，更能
...
insert("python") #list
...
insert(0,"python")
>>> all_users
['python', 'qiwsir', 'github', 'io']
>>> all_users
...
insert(length,"algorithm")
>>> all_users
['python', 'http://', 'qiwsir', 'github', 'io', 'algorithm']
小结：
list
...
append(x)
删除list中的元素
list中的元素，不仅能增加，还能被删除。删除list元素的方法有两个，它们分别是：
list
...
It is an error if there is no such
item
...
pop([i])
Remove the item at the given position in the list, and return it
...
pop() removes and returns the last item in the list
...
You will see this
notation frequently in the Python Library Reference
...
remove(x)，注意看上面的描述。这是一个能够删除list元素的方法，同时上面说明
告诉我们，如果x没有在list中，会报错。
>>> all_users
['python', 'http://', 'qiwsir', 'github', 'io', 'algorithm']
>>> all_users
...
remove("tianchao") #原list中没有“tianchao”，要删除，就报错。
Traceback (most recent call last):
File "
ValueError: list
...
all_users
...
print all_users
...
print "'python' is not in all_users"
...
all_users
...
print all_users
...
print "'python' is not in all_users"
...
pop([i])会怎么样呢？看看文档，做做实验。
有容乃大的list(3)
82
零基础学Python
>>> all_users
['qiwsir', 'github', 'io', 'algorithm']
>>> all_users
...
pop([i]),圆括号里面是[i]，表示这个序号是可选的
'algorithm' #如果不写，就如同这个操作，默认删除最后一个，并且将该结果返回
>>> all_users
['qiwsir', 'github', 'io']
>>> all_users
...
pop()
'io'
>>> all_users #只有一个元素了，该元素编号是0
['qiwsir']
>>> all_users
...
范围；幅度；排；山脉 vi
...
漫游；放牧；使并列；归类于；来回走动
在具体实验之前，还是按照管理，摘抄一段官方文档的原话，让我们能够深刻理解之：
This is a versatile function to create lists containing arithmetic progressions
...
The arguments must be plain integers
...
If the start argument is omitted, it defaults to 0
...
If step is positive, the
last element is the largest start + i step less than stop; if step is negative, the last
element is the smallest start + i * step greater than stop
...
从这段话，我们可以得出关于range()函数的以下几点：
这个函数可以创建一个数字元素组成的列表。
这个函数最常用于for循环（关于for循环，马上就要涉及到了）
函数的参数必须是整数，默认从0开始。返回值是类似[start, start + step, start + 2*step,
...
list中的第一个值是start=0,第二个值是start+1step=2（注意，这里
是1，不是2，不要忘记，前面已经讲过，不论是list还是str，对元素进行编号的时候，都
是从0开始的），第n个值就是start+(n-1)step。直到小于stop前的那个值。
熟悉了上面的计算过程，看看下面的输入谁是什么结果？
>>> range(-9)
我本来期望给我返回[0,-1,-2,-3,-4,-5,-6,-7,-8],我的期望能实现吗？
分析一下，这里start=0,step=1,stop=-9
...
sort(cmp=None, key=None, reverse=False)
sorted(iterable[, cmp[, key[, reverse]]])
通过下面的实验，可以理解如何排序的方法
>>> number = [1,4,6,2,9,7,3]
>>> number
...
sort(reverse=True) #开始实现倒序
>>> number
[9, 7, 6, 4, 3, 2, 1]
>>> number = [1,4,6,2,9,7,3]
>>> number
[1, 4, 6, 2, 9, 7, 3]
>>> sorted(number,reverse=True)
[9, 7, 6, 4, 3, 2, 1]
其实，在高级语言中，排序是一个比较热门对的话题，如果有兴趣的读者，可以到我写的有
关算法中查看有关排序的话题。
至此，有关list的基本操作的内置函数，就差不多了。不过最后，还要告诉看官们一个学习方
法。因为python的内置函数往往不少，有时候光凭教程，很难学到全部，那么，最关键地是
要自己会查找都有哪些函数可以用。怎么查找呢？
一个非常重要的方法
假设有一个list，如何知道它所拥有的内置函数呢？请用help()，帮助我吧。
>>> help(list)
就能够看到所有的关于list的函数，以及该函数的使用方法。
有容乃大的list(4)
87
零基础学Python
list和str比较
list和str两种类型数据，有不少相似的地方，也有很大的区别。本讲对她们做个简要比较，同
时也是对前面有关两者的知识复习一下，所谓“温故而知新”。
相同点
都属于序列类型的数据
所谓序列类型的数据，就是说它的每一个元素都可以通过指定一个编号，行话叫做“偏移量”的
方式得到，而要想一次得到多个元素，可以使用切片。偏移量从0开始，总元素数减1结束。
例如：
>>> welcome_str = "Welcome you"
>>> welcome_str[0]
'W'
>>> welcome_str[1]
'e'
>>> welcome_str[len(welcome_str)-1]
'u'
>>> welcome_str[:4]
'Welc'
>>> a = "python"
>>> a*3
'pythonpythonpython'
>>> git_list = ["qiwsir","github","io"]
>>> git_list[0]
'qiwsir'
>>> git_list[len(git_list)-1]
'io'
>>> git_list[0:2]
['qiwsir', 'github']
>>> b = ['qiwsir']
>>> b*7
['qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir', 'qiwsir']
对于此类数据，下面一些操作是类似的：
list和str比较
88
零基础学Python
>>> first = "hello,world"
>>> welcome_str
'Welcome you'
>>> first+","+welcome_str #用+号连接str
'hello,world,Welcome you'
>>> welcome_str #原来的str没有受到影响，即上面的+号连接后从新生成了一个字符串
'Welcome you'
>>> first
'hello,world'
>>> language = ['python']
>>> git_list
['qiwsir', 'github', 'io']
>>> language + git_list #用+号连接list，得到一个新的list
['python', 'qiwsir', 'github', 'io']
>>> git_list
['qiwsir', 'github', 'io']
>>> language
['python']
>>> len(welcome_str) #得到字符数
11
>>> len(git_list) #得到元素数
3
区别
list和str的最大区别是：list是可以改变的，str不可变。这个怎么理解呢？
首先看对list的这些操作，其特点是在原处将list进行了修改：
list和str比较
89
零基础学Python
>>> git_list
['qiwsir', 'github', 'io']
>>> git_list
...
com'
>>> git_list
['qiwsir', 'github
...
insert(1,"algorithm")
>>> git_list
['qiwsir', 'algorithm', 'github
...
pop()
'python'
>>> del git_list[1]
>>> git_list
['qiwsir', 'github
...
append("E")
Traceback (most recent call last):
File "
AttributeError: 'str' object has no attribute 'append'
如果要修改一个str，不得不这样。
list和str比较
90
零基础学Python
>>> welcome_str
'Welcome you'
>>> welcome_str[0]+"E"+welcome_str[2:] #从新生成一个str
'WElcome you'
>>> welcome_str #对原来的没有任何影响
'Welcome you'
其实，在这种做法中，相当于从新生成了一个str。
多维list
这个也应该算是两者的区别了，虽然有点牵强。在str中，里面的每个元素只能是字符，在list
中，元素可以是任何类型的数据。前面见的多是数字或者字符，其实还可以这样：
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix[0][1]
2
>>> mult = [[1,2,3],['a','b','c'],'d','e']
>>> mult
[[1, 2, 3], ['a', 'b', 'c'], 'd', 'e']
>>> mult[1][1]
'b'
>>> mult[2]
'd'
以上显示了多维list以及访问方式。在多维的情况下，里面的list也跟一个前面元素一样对待。
list和str转化
str
...
split)
得到了对这个内置函数的完整说明。特别强调：这是一种非常好的学习方法
list和str比较
91
零基础学Python
split(
...
split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the delimiter string
...
If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed from the result
...
I am qiwsir
...
"
>>> line
...
") #以英文的句点为分隔符，得到list
['Hello', 'I am qiwsir', 'Welcome you', '']
>>> line
...
",1) #这个1,就是表达了上文中的：If maxsplit is given, at most maxsplit splits are done
['Hello', 'I am qiwsir
...
']
>>> name = "Albert Ainstain" #也有可能用空格来做为分隔符
>>> name
...
split() #用split(),但是括号中不输入任何参数
['I', 'am,', 'writing', 'python', 'book', 'on', 'line']
如果split()不输入任何参数，显示就是见到任何分割符号，就用其分割了。
"[sep]"
...
join(name) #将list中的元素连接起来，但是没有连接符，表示一个一个紧邻着
'AlbertAinstain'
>>> "
...
Ainstain'
>>> " "
...
list和str比较
92
零基础学Python
>>> s = "I am, writing\npython\tbook on line"
>>> print s
I am, writing
python book on line
>>> s
...
join(s
...
github
...
print i
...
hello这个变量引用的是"world"这个str类型的数据
2
...
当 i="w"的时候，执行print i，打印出了字母w，结束之后循环第二次，让 i="e"，然后执
行print i,打印出字母e，如此循环下去，一直到最后一个字符被打印出来，循环自动结束
顺便补充一个print的技巧，上面的打印结果是竖着排列，也就是每打印一个之后，就自动换
行。如果要让打印的在一行，可以用下面的方法，在打印的后面加一个逗号（英文）
>>> for i in hello:
...
w o r l d
>>> for i in hello:
...
w, o, r, l, d,
>>>
因为可以通过使用索引编号（偏移量）做为下表，得到某个字符。所以，还可以通过下面的
循环方式实现上面代码中同样功能：
画圈还不简单吗
94
零基础学Python
>>> for i in range(len(hello)):
...
w
o
r
l
d
其工作方式是：
1
...
range(len(hello),就是range(5),也就是[0, 1, 2, 3, 4],对应这"world"每个字母的编号，即偏
移量。
3
...
print word
...
print ls_line[i]
...
那么如何得到n呢，就是要用for循环。
以上做了简单分析，要实现流程，还需要细化一下。按照前面曾经讲授过的一种方法，要画
出问题解决的流程图。
下面写代码就是按图索骥了。
代码：
画圈还不简单吗
96
零基础学Python
#! /usr/bin/env python
#coding:utf-8
aliquot = []
for n in range(1,100):
if n%3 == 0:
aliquot
...
list解析
先看下面的例子，这个例子是想得到1到9的每个整数的平方，并且将结果放在list中打印出来
>>> power2 = []
>>> for i in range(1,10):
...
append(i*i)
...
Common applications are to
make new lists where each element is the result of some operations applied to each
member of another sequence or iterable, or to create a subsequence of those elements
that satisfy a certain condition
...
append(n)
print aliquot
好了。现在用list解析重写，会是这样的：
>>> aliquot = [n for n in range(1,100) if n%3==0]
>>> aliquot
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78,
震撼了。绝对牛X！
再来一个，是网友ccbikai提供的，比牛X还牛X。
>>> print range(3,100,3)
[3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78,
这就是python有意思的地方，也是计算机高级语言编程有意思的地方，你只要动脑筋，总能
找到惊喜的东西。
其实，不仅仅对数字组成的list，所有的都可以如此操作。请在平复了激动的心之后，默默地
看下面的代码，感悟一下list解析的魅力。
>>> mybag = [' glass',' apple','green leaf '] #有的前面有空格，有的后面有空格
>>> [one
...
print week[i]+' is '+str(i) #注意，i是int类型，如果和前面的用+连接，必须是str类型
...
print day+' is '+str(i)
...
sequence must be a sequence, an iterator, or some other
object which supports iteration
...
return "%d: %s"%(pos,element)
...
github
...
github
...
github
...
github
...
values)
字典，你还记得吗？
102
零基础学Python
然后出现：
Help on method_descriptor:
values(
...
values() -> list of D's values
(END)
也就是在这里显示出了values这个内置函数的使用方法。敲击键盘上的q键退回。
概述
python中的dict具有如下特点：
dict是可变的
dict可以存储任意数量的Python对象
dict可以存储任何python数据类型
dict以：key:value，即“键：值”对的形式存储数据，每个键是唯一的。
dict也被称为关联数组或哈希表。
以上诸条，如果还不是很理解，也没有关系，通过下面的学习，特别是通过各种实验，就能
理解了。
创建dict
话说创建dict的方法可是远远多于前面的int/str/list，为什么会多呢？一般规律是复杂点的东西
都会有多种渠道生成，这也是从安全便捷角度考虑吧。
方法1:
创建一个空的dict，这个空dict，可以在以后向里面加东西用。
>>> mydict = {}
>>> mydict
{}
创建有内容的dict。
>>> person = {"name":"qiwsir","site":"qiwsir
...
io","language":"python"}
>>> person
{'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir
...
io'}
字典，你还记得吗？
103
零基础学Python
"name":"qiwsir"就是一个键值对，前面的name叫做键（key），后面的qiwsir是前面的键所对
应的值(value)。在一个dict中，键是唯一的，不能重复；值则是对应于键，值可以重复。键值
之间用(:)英文的分号，每一对键值之间用英文的逗号(,)隔开。
>>> person['name2']="qiwsir" #这是一种向dict中增加键值对的方法
>>> person
{'name2': 'qiwsir', 'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir
...
io'}
如下，演示了从一个空的dict开始增加内容的过程：
>>> mydict = {}
>>> mydict
{}
>>> mydict["site"] = "qiwsir
...
io"
>>> mydict[1] = 80
>>> mydict[2] = "python"
>>> mydict["name"] = ["zhangsan","lisi","wangwu"]
>>> mydict
{1: 80, 2: 'python', 'site': 'qiwsir
...
io', 'name': ['zhangsan', 'lisi', 'wangwu']}
>>> mydict[1] = 90 #如果这样，则是修改这个键的值
>>> mydict
{1: 90, 2: 'python', 'site': 'qiwsir
...
io', 'name': ['zhangsan', 'lisi', 'wangwu']}
方法2:
>>> name = (["first","Google"],["second","Yahoo"]) #这是另外一种数据类型，称之为元组，后面会讲到
>>> website = dict(name)
>>> website
{'second': 'Yahoo', 'first': 'Google'}
方法3:
这个方法，跟上面的不同在于使用fromkeys
>>> website = {}
...
github
...
github
...
print name
...
github
...
print person[key]
...
github
...
向关联数组添加配对 2
...
修改关联数组内的配对 4
...
com"}
>>> a_dict
{1: {'name': 'qiwsir'}, 2: 'python', 'email': 'qiwsir@gmail
...
keys()的方法得到dict的所有键，结果是list
>>> website
...
values()的方法得到dict的所有值，如果里面没有嵌套别的dict，结果是list
>>> website
...
items()
[(1, 'google'), ('second', 'baidu'), (3, 'facebook'), ('twitter', 4)]
从上面的结果中，我们就可以看出，还可以用for语句循环得到相应内容。例如：
字典的操作方法
107
零基础学Python
>>> for key in website
...
print key,type(key)
...
print key,type(key)
...
values():
...
baidu
4
>>> for key in website:
...
baidu
4
下面的方法又是等效的：
字典的操作方法
108
零基础学Python
>>> for k,v in website
...
print str(k)+":"+str(v)
...
print str(k)+":"+str(website[k])
...
get(1)
'google'
>>> website
...
copy() #拷贝一份，这个拷贝也叫做浅拷贝，对应着还有深拷贝。
>>> new_web #两者区别，可以google一下。
{1: 'google', 'second': 'baidu', 3: 'facebook', 'twitter': 4}
删除键值对的方法有两个，但是两者有一点区别
字典的操作方法
109
零基础学Python
>>>#d
...
pop('second')
'baidu'
>>> del new_web[3] #没有返回值，如果删除键不存在，返回错误
>>> new_web
{1: 'google', 'twitter': 4}
>>> del new_web[9]
Traceback (most recent call last):
File "
KeyError: 9
用d
...
github
...
update(cnweb) #把cnweb合并到website内
>>> website #变化了
{'qq': 'first in cn', 1: 'google', 'second': 'baidu', 3: 'facebook', 'python': 'qiwsir
...
io', 't
>>> cnweb #not changed
{'qq': 'first in cn', 'python': 'qiwsir
...
io', 'alibaba': 'Business'}
在本讲最后，要提醒看官，在python3中，dict有不少变化，比如能够进行字典解析，就类似
列表解析那样，这可是非常有意思的东西哦。
字典的操作方法
110
零基础学Python
有点简约的元组
关于元组，上一讲中涉及到了这个名词。本讲完整地讲述它。
先看一个例子：
>>>#变量引用str
>>> s = "abc"
>>> s
'abc'
>>>#如果这样写，就会是
...
append("no")
Traceback (most recent call last):
File "
AttributeError: 'tuple' object has no attribute 'append'
>>>
从上面的简单比较似乎可以认为，tuple就是一个融合了部分list和部分str属性的杂交产物。此
言有理。
像list那样访问元素和切片
有点简约的元组
111
零基础学Python
先复习list中的一点知识：
>>> one_list = ["python","qiwsir","github","io"]
>>> one_list[2]
'github'
>>> one_list[1:]
['qiwsir', 'github', 'io']
>>> for word in one_list:
...
python
qiwsir
github
io
>>> len(one_list)
4
下面再实验一下，上面的list如果换成tuple是否可行
>>> t
(1, '23', [123, 'abc'], ('python', 'learn'))
>>> t[2]
[123, 'abc']
>>> t[1:]
('23', [123, 'abc'], ('python', 'learn'))
>>> for every in t:
...
1
23
[123, 'abc']
('python', 'learn')
>>> len(t)
4
>>> t[2][0] #还能这样呀，哦对了，list中也能这样
123
>>> t[3][1]
'learn'
所有在list中可以修改list的方法，在tuple中，都失效。
分别用list()和tuple()能够实现两者的转化:
有点简约的元组
112
零基础学Python
>>> t
(1, '23', [123, 'abc'], ('python', 'learn'))
>>> tls = list(t) #tuple-->list
>>> tls
[1, '23', [123, 'abc'], ('python', 'learn')]
>>> t_tuple = tuple(tls) #list-->tuple
>>> t_tuple
(1, '23', [123, 'abc'], ('python', 'learn'))
tuple用在哪里？
既然它是list和str的杂合，它有什么用途呢？不是用list和str都可以了吗？
在很多时候，的确是用list和str都可以了。但是，看官不要忘记，我们用计算机语言解决的问
题不都是简单问题，就如同我们的自然语言一样，虽然有的词汇看似可有可无,用别的也能替
换之,但是我们依然需要在某些情况下使用它们
...
不过,python是一个发展的语言,没准以后还出别的呢
...
不要担心记不住,你只要记住爱因斯坦说的就好了
...
那么,上面那么多数据类型的各种方法,都不需要记忆了,因为它们都可以通过下述方法但不限于
这些方法查到(这句话的逻辑还是比较严密的,包括但不限于
...
其中序列类型的包括str/list/tuple
2
...
能
够原处修改的是list/dict(特别说明,dict的键必须是不可修改的,dict的值可原处修改)
什么原处修改?看官能不能在交互模式下通过实例解释一下?
到这里,看官可千万不要以为本讲是复习课
...
彻底晕倒了,到底python有多少个数据类型呢?又多出来了一个
...
但
是,python官方认可或者说内置的数据类型,就那么几种了
...
在
以后的开发过程中,包括今天和以往介绍的数据类型,是常用的
...
创建set
一二三,集合了
114
零基础学Python
tuple算是list和str的杂合(杂交的都有自己的优势,上一节的末后已经显示了),那么set则可以堪
称是list和dict的杂合
...
set也有继承了一点list的特点:如可以原处修改(事实上是一种类别的set可以原处修改,另外一种
不可以)
...
特别注意观察:qiwsir中有两个i
>>> s1 #但是在s1中,只有一个i,也就是不能重复
set(['q', 'i', 's', 'r', 'w'])
>>> s2 = set([123,"google","face","book","facebook","book"]) #通过list创建set
...
继续探索一个情况:
一二三,集合了
115
零基础学Python
>>> s1
set(['q', 'i', 's', 'r', 'w'])
>>> s1[1] = "I"
Traceback (most recent call last):
File "
TypeError: 'set' object does not support item assignment
>>> s1
set(['q', 'i', 's', 'r', 'w'])
>>> lst = list(s1)
>>> lst
['q', 'i', 's', 'r', 'w']
>>> lst[1] = "I"
>>> lst
['q', 'I', 's', 'r', 'w']
上面的探索中,将set和list做了一个对比,虽然说两者都能够做原处修改,但是,通过索引编号(偏
移量)的方式,直接修改,list允许,但是set报错
...
>>> dir(set)
['__and__', '__class__', '__cmp__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__',
为了看的清楚,我把双划线__开始的先删除掉(后面我们会有专题讲述这些):
'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection',
'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove',
'symmetric_difference', 'symmetric_difference_update', 'union', 'update'
然后用help()可以找到每个函数的具体使用方法,下面列几个例子:
增加元素
一二三,集合了
116
零基础学Python
>>> help(set
...
)
Add an element to a set
...
下面在交互模式这个最好的实验室里面做实验:
>>> a_set = {} #我想当然地认为这样也可以建立一个set
>>> a_set
...
看看错误信息,居然告诉我dict没有add
...
Traceback (most recent call last):
File "
AttributeError: 'dict' object has no attribute 'add'
>>> type(a_set) #type之后发现,计算机认为我建立的是一个dict
特别说明一下,{}这个东西,在dict和set中都用
...
这是
python规定的
...
>>> a_set = {'a','i'} #这回就是set了吧
>>> type(a_set)
>>> a_set
...
add("qiwsir")
>>> b_set
set(['h', 'o', 'n', 'p', 't', 'qiwsir', 'y'])
>>> b_set
...
Traceback (most recent call last):
File "
TypeError: unhashable type: 'list'
>>> b_set
...
update(s2)
一二三,集合了
117
零基础学Python
>>> help(set
...
)
Update a set with the union of itself and others
...
update(s2) #把s2的元素并入到s1中
...
pop)
pop(
...
Raises KeyError if the set is empty
...
pop() #从set中任意选一个删除,并返回该值
'[1,2,3]'
>>> b_set
...
pop()
'o'
>>> b_set
set(['n', 'p', 't', 'qiwsir', 'y'])
>>> b_set
...
Traceback (most recent call last):
File "
TypeError: pop() takes no arguments (1 given)
set
...
报错信
息中就告诉我们了,pop()不能有参数
...
这条是帮助信息告诉我们
的,看官可以试试
...
remove)
remove(
...
If the element is not a member, raise a KeyError
...
remove(obj)中的obj,必须是set中的元素,否则就报错
...
remove("i")
>>> a_set
set(['a', 'qiwsir'])
>>> a_set
...
discard)
discard(
...
If the element is not a member, do nothing
...
remove)的信息对比,看看有什么不同
...
>>> a_set
...
discard('b')
>>>
在删除上还有一个绝杀,就是set
...
(看官自
己在交互模式下help(set
...
clear()
>>> a_set
set([])
>>> bool(a_set) #空了,bool一下返回False
...
是的,所以本讲仅仅是对集合有一个入门
...
add("python") #报错
Traceback (most recent call last):
File "
AttributeError: 'frozenset' object has no attribute 'add'
>>> a_set = set("github") #对比看一看，这是一个可以原处修改的set
>>> a_set
set(['b', 'g', 'i', 'h', 'u', 't'])
>>> a_set
...
issubset(a) #或者用这种方法，判断c是否是a的子集
True
>>> a
...
issubset(b) #或者这样做
False
A、B的并集，即A、B所有元素，如下图所示
集合的关系
122
零基础学Python
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a | b #可以有两种方式，结果一样
set(['a', 'i', 'l', 'o', 'q', 's', 'r', 'w'])
>>> a
...
intersection(b)
set(['q', 'i'])
我在实验的时候，顺手敲了下面的代码，出现的结果如下，看官能解释一下吗？（思考题）
>>> a and b
set(['a', 'q', 'i', 'l', 'o'])
A相对B的差（补），即A相对B不同的部分元素，如下图所示
>>> a
set(['q', 'i', 's', 'r', 'w'])
>>> b
set(['a', 'q', 'i', 'l', 'o'])
>>> a - b
set(['s', 'r', 'w'])
>>> a
...
symmetric_difference(b)
set(['a', 'l', 'o', 's', 'r', 'w'])
以上是集合的基本运算。在编程中，如果用到，可以用前面说的方法查找。不用死记硬背。
集合的关系
124
零基础学Python
Python的数据类型总结
前面已经洋洋洒洒地介绍了不少数据类型。不能再不顾一切地向前冲了，应当总结一下。这
样让看官能够从总体上对这些数据类型有所了解，如果能够有一览众山小的感觉，就太好
了。
下面的表格中列出了已经学习过的数据类型，也是python的核心数据类型之一部分，这些都
被称之为内置对象。
对象，就是你面对的所有东西都是对象，看官要逐渐熟悉这个称呼。所有的数据类型，
就是一种对象。英文单词是object，直接的汉语意思是物体，这就好像我们在现实中一
样，把很多我们看到和用到的都可以统称为“东西”一样。“东西”就是“对象”，就是object。
在编程中，那个所谓面向对象，也可以说成“面向东西”，是吗？容易有歧义吧。
对象类型
举例
int/float
123, 3
...
github
...
pop)的方式获得。这是前面说过的，再说一遍，加深印象。
我的观点：学习，重要的是学习方法，不是按部就班的敲代码。
Python数据类型总结
125
零基础学Python
今天既然是复习，就要在原来基础上提高一点。所以，也要看看上面那些以双下划线_开头的
东西，请看官找一下，有没有发现这个："\_doc__"。这是什么，它是一个文件，里面记录了
对当前所查看的对象的详细解释。可以在交互模式下这样查看：
>>> dict
...
For example: dict(one=1,
two=2)"
注意看上面乱七八糟的英文中，是不是有\n符号，这是什么？前面在讲述字符串的时候提到了
转义符号\，这是换一行。也就是说，如果上面的文字，按照排版要求，应该是这样的（当
然，在文本中，如果打开，其实就是排好版的样子）。
"dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a
mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d
= {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the
name=value pairs in the keyword argument list
...
__doc__文件来看。
嘿嘿，其实有一种方法，可以看到排版的结果的：
>>> print dict
...
For example: dict(one=1, two=2)
上面那么折腾一下，就是为了凑篇幅，不然这个总结的东西太少了。
总之，只要用这种方法，你就能得到所有帮助文档，随时随地。如果可以上网，到官方网
站，是另外一种方法。
Python数据类型总结
126
零基础学Python
还需要再解释别的吗？都多余了。唯一需要的是看官要能会点英语。不过我相信看官能够读
懂，我这个二把刀都不如的英语水平，还能凑合看呢，何况看官呢？
总结不是意味着结束，是意味着继往开来。精彩还在后面，这里只是休息。今天还是周日。
主日崇拜
腓立比書 Philippians（3:13-14)
Brethren, I count not myself to have apprehended: but this one thing I do, forgetting
those things which are behind, and reaching forth unto those things which are before, I
press toward the mark for the prize of the high calling of God in Christ Jesus
...
github
...
linuxidc
...
htm）
>>> a = 100 #完成了变量a对内存空间中的对象100的引用
如下图所示：
然后，又操作了：
>>> a = "hello"
深入变量和引用对象
129
零基础学Python
如下图所示：
原来内存中的那个100就做为垃圾被收集了。而且，这个收集过程是python自动完成的，不用
我们操心。
那么，python是怎么进行垃圾收集的呢？在Quora上也有人问这个问题，我看那个回答很精
彩，做个链接，有性趣的读一读吧。Python (programming language): How does garbage
collection in Python work?
is和==的效果
以上过程的原理搞清楚了，下面就可以深入一步了。
>>> l1 = [1,2,3]
>>> l2 = l1
这个操作中，l1和l2两个变量，引用的是一个对象，都是[1,2,3]。何以见得？如果通过l1来修
改[1,2,3]，l2引用对象也修改了，那么就证实这个观点了。
>>> l1[0] = 99 #把对象变为[99,2,3]
>>> l1 #变了
[99, 2, 3]
>>> l2 #真的变了吔
[99, 2, 3]
再换一个方式：
>>> l1 = [1,2,3]
>>> l2 = [1,2,3]
>>> l1[0] = 99
>>> l1
[99, 2, 3]
>>> l2
[1, 2, 3]
l1和l2貌似指向了同样的一个对象[1,2,3]，其实，在内存中，这是两块东西，互不相关。只是
在内容上一样。就好像是水里长的一样的两条鱼，两个人都钓到了，但不是同一条。所以，
当通过l1修改引用对象的后，l2没有变化。
进一步还能这么检验：
深入变量和引用对象
130
零基础学Python
>>> l1
[1, 2, 3]
>>> l2
[1, 2, 3]
>>> l1 == l2 #两个相等，是指内容一样
True
>>> l1 is l2 #is 是比较两个引用对象在内存中的地址是不是一样
False #前面的检验已经说明，这是两个东东
>>> l3 = l1 #顺便看看如果这样，l3和l1应用同一个对象
>>> l3
[1, 2, 3]
>>> l3 == l1
True
>>> l3 is l1 #is的结果是True
True
某些对象，有copy函数，通过这个函数得到的对象，是一个新的还是引用到同一个对象呢？
看官也可以做一下类似上面的实验，就晓得了。比如：
>>> l1
[1, 2, 3]
>>> l2 = l1[:]
>>> l2
[1, 2, 3]
>>> l1[0] = 22
>>> l1
[22, 2, 3]
>>> l2
[1, 2, 3]
>>> adict = {"name":"qiwsir","web":"qiwsir
...
io"}
>>> bdict = adict
...
github
...
com"
>>> adict
{'web': 'qiwsir
...
io', 'name': 'qiwsir', 'email': 'qiwsir@gmail
...
github
...
False
>>> x = 'hello'
>>> y = 'hello'
>>> x is y
True
>>> x = "what is you name?"
>>> y = "what is you name?"
>>> x is y #不光小的数字，短的字符串也是
False
赋值是不是简单地就是等号呢？从上面得出来，=的作用就是让变量指针指向某个对象。不
过，还可以再深入一些。走着瞧吧。
深入变量和引用对象
132
零基础学Python
赋值，简单也不简单
变量命名
在《初识永远强大的函数》一文中，有一节专门讨论“取名字的学问”，就是有关变量名称的问
题，本温故而知新的原则，这里要复习：
名称格式：（下划线或者字母）+（任意数目的字母，数字或下划线）
注意：
1
...
禁止使用保留字
3
...
以单一下划线开头的变量名（_X)不会被from module import *语句导入的。
5
...
以两个下划线开头，但结尾没有两个下划线的变量名（__X)是类本地（压缩）变量。
7
...
github
...
github
...
github
...
github
...
github
...
github
...
github
...
split("
...
split("
...
split(
>>> name
'qiwsir'
>>> main
'github'
增强赋值
这个东西听名字就是比赋值强的。
在python中，将下列的方式称为增强赋值：
赋值，简单也不简单
135
零基础学Python
增强赋值语句
等价于语句
x+=y
x = x+y
x-=y
x = x-y
x*=y
x = x*y
x/=y
x = x/y
其它类似结构：x&=y x|=y x^=y x%=y x>>=y x<<=y x**=y x//=y
看下面的例子，有一个list，想得到另外一个列表，其中每个数比原来list中的大2。可以用下
面方式实现：
>>> number
[1, 2, 3, 4, 5]
>>> number2 = []
>>> for i in number:
...
number2
...
>>> number2
[3, 4, 5, 6, 7]
如果用上面的增强赋值，i = i+2可以写成 i +=2，试一试吧：
>>> number
[1, 2, 3, 4, 5]
>>> number2 = []
>>> for i in number:
...
number2
...
>>> number2
[3, 4, 5, 6, 7]
这就是增强赋值。为什么用增强赋值？因为i +=2，比i = i+2计算更快，后者右边还要拷贝一
个i。
上面的例子还能修改，别忘记了list解析的强大功能呀。
>>> [i+2 for i in number]
[3, 4, 5, 6, 7]
赋值，简单也不简单
136
零基础学Python
坑爹的字符编码
字符编码，在编程中，是一个让学习者比较郁闷的东西，比如一个str，如果都是英文，好说
多了。但恰恰不是如此，中文是我们不得不用的。所以，哪怕是初学者，都要了解并能够解
决字符编码问题。
>>> name = '老齐'
>>> name
'\xe8\x80\x81\xe9\xbd\x90'
在你的编程中，你遇到过上面的情形吗？认识最下面一行打印出来的东西吗？看人家英文，
就好多了
>>> name = "qiwsir"
>>> name
'qiwsir'
难道这是中文的错吗？看来投胎真的是一个技术活。是的，投胎是技术活，但上面的问题不
是中文的错。
编码
什么是编码？这是一个比较玄乎的问题。也不好下一个普通定义。我看到有的教材中有定
义，不敢说他的定义不对，至少可以说不容易理解。
古代打仗，击鼓进攻、鸣金收兵，这就是编码。吧要传达给士兵的命令对应为一定的其它形
式，比如命令“进攻”，经过如此的信息传递：
1
...
鼓声在空气中传播，比传令员的嗓子吼出来的声音传播的更远，士兵听到后也不会引起
歧义，一般不会有士兵把鼓声当做打呼噜的声音。这就是“进攻”命令被编码成鼓声之后的
优势所在。
3
...
）、划（-）、每个字符间短的停顿（在点和划之间
的停顿）、每个词之间中等的停顿、以及句子之间长的停顿
看来电报员是一个技术活，不同长短的停顿都代表了不同意思。哦，对了，有一个老片子
《永不消逝的电波》，看完之后保证你才知道，里面根本就没有讲电报是怎么编码的。
坑爹的字符编码
138
零基础学Python
摩尔斯电码在海事通讯中被作为国际标准一直使用到1999年。1997年，当法国海军停止
使用摩尔斯电码时，发送的最后一条消息是：“所有人注意，这是我们在永远沉寂之前最
后的一声呐喊！”
我瞪着眼看了老长时间，这两行不是一样的吗？
不管这个了，总之，这就是编码。
计算机中的字符编码
先抄一段维基百科对字符编码的解释：
字符编码（英语：Character encoding）、字集码是把字符集中的字符编码为指定集合中
某一对象（例如：比特模式、自然数串行、8位组或者电脉冲），以便文本在计算机中存
储和通过通信网络的传递。常见的例子包括将拉丁字母表编码成摩斯电码和ASCII。其
中，ASCII将字母、数字和其它符号编号，并用7比特的二进制来表示这个整数。通常会
额外使用一个扩充的比特，以便于以1个字节的方式存储。
在计算机技术发展的早期，如ASCII（1963年）和EBCDIC（1964年）这样的字符集逐
渐成为标准。但这些字符集的局限很快就变得明显，于是人们开发了许多方法来扩展它
们。对于支持包括东亚CJK字符家族在内的写作系统的要求能支持更大量的字符，并且
需要一种系统而不是临时的方法实现这些字符的编码。
在这个世界上，有好多不同的字符编码。但是，它们不是自己随便搞搞的。而是要有一定的
基础，往往是以名叫ASCII的编码为基础，这里边也应该包括北朝鲜吧（不知道他们用什么字
符编码，瞎想的，别当真，不代表本教材立场，只代表瞎想）。
ASCII（pronunciation: 英语发音：/ˈæski/ ASS-kee[1]，American Standard Code for
Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系
统。它主要用于显示现代英语，而其扩展版本EASCII则可以部分支持其他西欧语言，并
等同于国际标准ISO/IEC 646。由于万维网使得ASCII广为通用，直到2007年12月，逐渐
被Unicode取代。
上面的引文中已经说了，现在我们用的编码标准，已经不是ASCII了，我上大学那时候老师讲
的还是ASCII呢(最坑爹的是贵国的大学教育，前几天面试一个大学毕业生，计算机专业的，
他告诉我他的老师给他们讲的就是ASCII为编码标准呢，我说你别埋汰老师了，你去看看教
坑爹的字符编码
139
零基础学Python
材，今天这哥们真给我发短信了，告诉我教材上就是这么说的。)，时代变迁，现在已经变成
了Unicode了，那么什么是Unicode编码呢？还是抄一段来自维基百科的说明（需要说明一
下，本讲不是我qiwsir在讲，是维基百科在讲，我只是一个配角，哈哈）
Unicode（中文：万国码、国际码、统一码、单一码）是计算机科学领域里的一项业界标
准。它对世界上大部分的文字系统进行了整理、编码，使得电脑可以用更为简单的方式
来呈现和处理文字。
Unicode伴随着通用字符集的标准而发展，同时也以书本的形式对外发表。Unicode至今
仍在不断增修，每个新版本都加入更多新的字符。目前最新的版本为7
...
0，已收入超过
十万个字符（第十万个字符在2005年获采纳）。Unicode涵盖的数据除了视觉上的字
形、编码方法、标准的字符编码外，还包含了字符特性，如大小写字母。
听这名字：万国码，那就一定包含了中文喽。的确是。但是，光有一个Unicode还不行，因
为
...
encode(obj[, encoding[, errors]]):Encodes obj using the codec registered for
encoding
...
decode(obj[, encoding[, errors]]):Decodes obj using the codec
registered for encoding
...
decode()
>>> b
u'\u4e2d'
>>> type(b)
>>> len(b)
1
这个实验不做之前，或许看官还不是很迷茫（因为不知道，知道的越多越迷茫），实验做完
了，自己也迷茫了。别急躁，对编码问题的理解，要慢慢来，如果一时理解不了，也肯定理
解不了，就先注意按照要求做，做着做着就豁然开朗了。
上面试验中，变量a引用了一个字符串，所谓字符串(str)，严格地将是字节串，它是经过编码
后的字节组成的序列。也就是你在上面的实验中，看到的是“中”这个字在计算机中编码之后的
字节表示。（关于字节，看官可以google一下）。用len(a)来度量它的长度，它是由三个字节
组成的。
然后通过decode函数，将字节串转变为字符串，并且这个字符串是按照unicode编码的。在
unicode编码中，一个汉字对应一个字符，这时候度量它的长度就是1
...
encode('utf-8')
>>> c
'\xe4\xb8\xad'
>>> type(c)
>>> c == a
True
关于编码问题，先到这里，点到为止吧。因为再扯，还会扯出问题来。看官肯定感到不满
意，因为还没有知其所以然。没关系，请尽情google，即可解决。
python中如何避免中文是乱码
这个问题是一个具有很强操作性的问题。我这里有一个经验总结，分享一下，供参考：
坑爹的字符编码
141
零基础学Python
首先，提倡使用utf-8编码方案，因为它跨平台不错。
经验一：在开头声明：
# -*- coding: utf-8 -*-
有朋友问我-*-有什么作用，那个就是为了好看，爱美之心人皆有，更何况程序员？当然，也
可以写成：
# coding:utf-8
经验二：遇到字符（节）串，立刻转化为unicode，不要用str()，直接使用unicode()
unicode_str = unicode('中文', encoding='utf-8')
print unicode_str
...
open，替代open(这个后面会讲
到，先放在这里)
import codecs
codecs
...
x的中文显示方法
最后告诉给我，如果用python3，坑爹的编码问题就不烦恼了。
坑爹的字符编码
142
零基础学Python
做一个小游戏
在讲述有关list的时候，提到做游戏的事情,后来这个事情一直没有接续。不是忘记了，是在想
在哪个阶段做最合适。经过一段时间学习，看官已经不是纯粹小白了，已经属于python初级
者了。现在就是开始做那个游戏的时候了。
游戏内容：猜数字游戏
太简单了吧。是的，游戏难度不大，不过这个游戏中蕴含的东西可是值得玩味的。
游戏过程描述
1
...
提示用户输入数字，也就是猜程序随即选的那个数字。
3
...
分析
在任何形式的程序开发之前，不管是大还是小，都要进行分析。即根据功能需求，将不同功
能点进行分解。从而确定开发过程。我们现在做一个很小的程序，也是这样来做。
随机选择一个数
要实现随机选择一个数字，可以使用python中的一个随机函数：random。下面对这个函数做
简要介绍，除了针对本次应用之外，还扩展点，也许别处看官能用上。
还是要首先强化一种学习方法，就是要学会查看帮助文档。
>>> import random #这个是必须的，因为不是内置函数
>>> dir(random)
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', 'Wi
>>> help(random
...
Random instance
Return random integer in range [a, b], including both end points
...
randint(0,99)
21
随机选取0到100间的偶数：
>>> import random
>>> random
...
random()
0
...
uniform(1, 10)
5
...
choice('qiwsir
...
io')
'g'
多个字符中选取特定数量的字符：
>>> import random
random
...
github
...
choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
'lemon'
洗牌：把原有的顺序打乱，按照随机顺序排列
做一个小游戏
144
零基础学Python
>>> import random
>>> items = [1, 2, 3, 4, 5, 6]
>>> random
...
randint()即可。多出来是买一送一的（哦。
忘记了，没有人买呢，本课程全是白送的）。
关键技术点之一已经突破。可以编程了。再梳理一下流程。画个图展示：
（备注：这里我先懒惰一下吧，看官能不能画出这个程序的流程图呢？特别是如果是一个初
学者，流程图一定要自己画哦。刚才看到网上一个朋友说自己学编程，但是逻辑思维差，所
以没有学好。其实，画流程图就是帮助提高逻辑思维的一种好方式，请画图吧。）
图画好了，按照直观的理解，下面的代码是一个初学者常常写出来的（老鸟们不要喷，因为
是代表初学者的）。
#!/usr/bin/env python
#coding:utf-8
import random
number = random
...
randint(1,100)
print "请输入一个100以内的自然数："
input_number = raw_input()
if number == int(input_number):
print "猜对了，这个数是："
print number
elif number > int(input_number):
print "小了"
input_number = raw_input()
elif number < int(input_number):
print "大了"
input_number = raw_input()
else:
print "错了。"
嗯，似乎比原来进步一点点，因为允许用户输入第二次了。同时也告诉用户输入的是大还是
小了。但，这也不行呀。应该能够输入很多次，直到正确为止。
是的。这就要用到一个新的东西：循环。如果看官心急，可以google一下while或者for循环，
来进一步完善这个游戏，如果不着急，可以等等，随后我也会讲到这部分。
这个游戏还没有完呢，及时用了循环，后面还会继续。
做一个小游戏
146
零基础学Python
不要红头文件(1)
这两天身体不给力，拖欠了每天发讲座的约定，看官见谅。
红头文件，是某国特别色的东西，在python里不需要，python里要处理的是计算机中的文
件，包括文本的、图片的、音频的、视频的等等，还有不少没见过的扩展名的，在linux中，
不是所有的东西都被保存到文件中吗？文件，在python中，是一种对象，就如同已经学习过
的字符串、数字等一样。
先要在交互模式下查看一下文件都有哪些属性：
>>> dir(file)
['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '_
然后对部分属性进行详细说明，就是看官学习了。
打开文件
在某个文件夹下面建立了一个文件，名曰：130
...
github
...
com
此文件以供三行。
下图显示了这个文件的存储位置：
在上面截图中，我在当前位置输入了python（我已经设置了环境变量，如果你没有，需要写
全启动python命令路径），进入到交互模式。在这个交互模式下，这样操作：
不要红头文件(1): open, write, close
147
零基础学Python
>>> f = open("130
...
print line
...
github
...
com
将打开的文件，赋值个变量f，这样也就是变量f跟对象文件130
...
txt')
>>> for line in f:
...
learn python
http://qiwsir
...
io
qiwsir@gmail
...
txt')
>>> for line in f:
...
learn python
http://qiwsir
...
io
qiwsir@gmail
...
print line2 #然后打印，结果就什么也显示，这是什么问题？
...
txt是同一个目录，这时候我们打开文件130
...
txt文件。
>>> f = open("130
...
txt'
>>> f = open("
...
txt") #必须得写上路径了（注意，windows的路径是\隔开，需要转义。对转义符，看官看以前
>>> for line in f:
...
learn python
http://qiwsir
...
io
qiwsir@gmail
...
txt","w")
>>> nf
...
txt")
>>> f
txt","r")
>>> f
txt这个文件是存在的，前面建立的，并且在里面写了一句话：This is a file
>>> fp = open("131
...
print line
...
txt","w") #这时候再看看这个文件，里面还有什么呢？是不是空了呢？
>>> fp
...
\nMy website is qiwsir
...
io") #再查看内容
>>> fp
...
txt #cat是linux下显示文件内容的命令，这里就是要显示131
...
My website is qiwsir
...
io
"a":以追加模式打开文件（即一打开文件，文件指针自动移到文件末尾），如果文件不存在则
创建
>>> fp = open("131
...
write("\nAha,I like program\n") #向文件中追加
>>> fp
...
txt
My name is qiwsir
...
github
...
txt","a")
>>> f
...
txt'
>>> f
...
closed #文件是否关闭，如果关闭，返回True；如果打开，返回False
False
>>> f
...
closed
True
文件的有关状态
很多时候，我们需要获取一个文件的有关状态（有时候成为属性，但是这里的文件属性和上
面的文件属性是不一样的，可是，我觉得称之为文件状态更好一点），比如创建日期，访问
日期，修改日期，大小，等等。在os模块中，有这样一个方法，能够解决此问题：
>>> import os
>>> file_stat = os
...
txt") #查看这个文件的状态
>>> file_stat #文件状态是这样的。从下面的内容，有不少从英文单词中可以猜测出来。
posix
...
st_ctime #这个是文件创建时间
1407734600
...
localtime(file_stat
...
struct_time(tm_year=2014, tm_mon=8, tm_mday=11, tm_hour=13, tm_min=23, tm_sec=20, tm_wday=0, tm_
不要红头文件(2): os
...
closed这个属性来判断了。
文件的内置函数
>>> dir(file)
['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '_
>>>
这么多内置函数，不会都讲述，只能捡着重点的来实验了。
>>> f = open("131
...
read()
'My name is qiwsir
...
github
...
read()能够将文件中的内容全部读取过来。特别注意，这是返回一个字符串，而且是将文
件中的内容全部读到内存中。试想，如果内容太多是不是就有点惨了呢？的确是，千万不要
去读大个的文件。
>>> contant = f
...
txt","r")
>>> f
...
\n'
>>> f
...
github
...
readline()
'Aha,I like program\n'
>>> f
...
stat, closed, mode, read, readlines, readline
153
零基础学Python
>>> f = open("131
...
readlines()
>>> cont
['My name is qiwsir
...
github
...
print line
...
My website is qiwsir
...
io
Aha,I like program
从实验中我们可以看到，readlines和read有一样之处，都是将文件内容一次性读出来，存放
在内存，但是两者也有区别，read返回的是str类型，readlines返回的是list，而且一行一个元
素，因此，就可以通过for逐行打印出来了。
在print line中，注意观察list里面的每个元素，最后都是一个\n结尾，所以打印的结果会有空
行。其原因前面已经介绍过了，忘了的朋友请回滚到上一讲
不过，还是要提醒列位，太大的文件不用都读到内存中。对付大点的文件，还是推荐这么
做：
>>> f = open("131
...
txt', mode 'r' at 0xb757c230>
>>> type(f)
>>> for line in f:
...
My name is qiwsir
...
github
...
txt","a") #因为这个文件已经存在，我又不想清空，用追加的模式
>>> f
...
") #这句话应该放到文件最后
>>> f
...
stat, closed, mode, read, readlines, readline
154
零基础学Python
看看写的效果：
>>> f = open("131
...
readlines():
...
My name is qiwsir
...
github
...
#果然增加了这一行
以上是关于文件的基本操作。其实对文件远远不知这些，有兴趣的看官可以google一下pickle
这个模块，是一个很好用的东西。
不要红头文件(2): os
Title: python basics
Description: with this course you'll learn the basics of python
Description: with this course you'll learn the basics of python