《简明Python教程》 笔记

〇、关于本书

    这本书是印度的一个名为Swaroop, C.H. 的程序要撰写的，主要适用于初学者，是一部很好的Python入门教程。

一、介绍

1、特点

（1）简单：简单主义思想，注重解决问题；

（2）易学：语法简洁、容易上手；

（3）FLOSS（free/libre & open source software）

（4）高层语言：无需担心底层的内存问题。

（5）可移植性：几乎任何平台。

（6）解释性：python解释器——源代码-字节码-机器语言

（7）面向对象：也支持面向过程

（8）可扩展性：python嵌入c、java等语言

（9）可嵌入型：c++、java等语言嵌入Python

（10）丰富的库

（11）其他：动态输入等。

二、安装Python

1、Linux和BSD

一般系统已自带，使用shell python -V进行查询

2、windows

官网下载安装（Python.org/download），建议使用2.*版本。

三、最初的步骤

1、基本的编写、保存、运行

（1）方法一：使用交互式的带提示符的解释器

win中，打开IDLE或者在cmd中输入python；linux中，shell下键入python。

直接输入

print "hello world!"

（2）方法二： 使用源文件

首先要选择合适的编辑器。win下使用python自带的idle或Editplus（用习惯了），linux下使用VIM或者Emacs。

然后，在EditPlus中新建python文件，键入

#!/usr/bin/python   //Python 大小写敏感
# Filename : helloworld.py
print 'Hello World'

保存名为helloworld.py。

最后在idle中打开这个文件，快捷键ctrl+f5运行源码。
2、运行技巧

将常用的源文件放置在统一的目录中，然后将这个目录设置为系统环境变量Path的一部分。这样，在win中，打开cmd，直接键入放入该目录的源文件名称（后缀有.py）就可以直接的运行这个python程序；而在linux中，甚至都不需要添加.py后缀，直接保存为名称即可。

因为在python中，程序、脚本、软件都是指同一个东西。

3、获取帮助

Python内建了help功能，输入help(要查询的内容)，如

help(str)

可以获取str类的相关信息。

按q结束查询。

四、基本概念

1、字面量

只能代表本身的意思，如1、“this is a string”

2、字符串 在Python中的使用

（1）使用单引号和双引

（2）使用三引号'''或者""",可以指示一个多行字符串。（不需要加\n换行）

（3） 转义符：与其他语言基本一致，需要注意的是，在行末添加\，代表在本行继续，而不是换行继续。如：

"This is the first sentence.\
This is the second sentence."

等价于： "This is the first sentence. This is the second sentence."
（4）自然字符串

指示某些不需要如转移字符串那样特别处理的字符串。用于处理正则表达式等，在前面加r或者R，如

r"Newlines are indicated by \n"

（5）Unicode字符串

是书写国际文本的标准方法，前面加上u或者U前缀。

（6）按字面意义级连字符串

Python会自动级连相邻排放的字符串，不需要像java一样用+号。
3、变量

存储信息的一部分内存。

4、标识符

用来标志某样东西的名字，需要遵循的规则如下：

（1）第一字符必须是字母或者_；

（2）其他部分可由字母、_、数字组成；

（3）大小写敏感

5、数据类型

基本类型：数和字符串；特有类型：自己创造的类

6、对象

在程序中用到的任何东西。

7、逻辑行和物理行

逻辑行：Python看见的每个语句

物理行：程序员编辑时看见的语句

python建议每行一个语句，但是也可以用；分开，放置多个语句在同一行中

明确的行连接：\可以使在两行的物理行编译为在一行中的逻辑行，如：

print \
i

与

print i

的效果是一样的
8、缩进：行首的空白

同一层次的语句必须有同样的缩进，同一层次的语句称为一个块

五、运算符与表达式

1、运算符

可以在Python编译器中交互的进行运算

运算符	名称	说明	例子
+	加	两个对象相加	3 + 5得到8。'a' + 'b'得到'ab'。
-	减	得到负数或是一个数减去另一个数	-5.2得到一个负数。50 - 24得到26。
*	乘	两个数相乘或是返回一个被重复若干次的字符串	2 * 3得到6。'la' * 3得到'lalala'。
**	幂	返回x的y次幂	3 ** 4得到81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到1.3333333333333333
//	取整除	返回商的整数部分	4 // 3.0得到1.0
%	取模	返回除法的余数	8%3得到2。-25.5%2.25得到1.5
<<	左移	把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1）	2 << 2得到8。——2按比特表示为10
>>	右移	把一个数的比特向右移一定数目	11 >> 1得到5。——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。
&	按位与	数的按位与	5 & 3得到1。
|	按位或	数的按位或	5 | 3得到7。
^	按位异或	数的按位异或	5 ^ 3得到6
~	按位翻转	x的按位翻转是-(x+1)	~5得到-6。
<	小于	返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	5 < 3返回0（即False）而3 < 5返回1（即True）。比较可以被任意连接：3 < 5 < 7返回True。
>	大于	返回x是否大于y	5 > 3返回True。如果两个操作数都是数字，它们首先被转换为一个共同的类型。否则，它总是返回False。
<=	小于等于	返回x是否小于等于y	x = 3; y = 6; x <= y返回True。
>=	大于等于	返回x是否大于等于y	x = 4; y = 3; x >= y返回True。
==	等于	比较对象是否相等	x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!=	不等于	比较两个对象是否不相等	x = 2; y = 3; x != y返回True。
not	布尔“非”	如果x为True，返回False。如果x为False，它返回True。	x = True; not x返回False。
and	布尔“与”	如果x为False，x and y返回False，否则它返回y的计算值。	x = False; y = True; x and y，由于x是False，返回False。在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。这个现象称为短路计算。
or	布尔“或”	如果x是True，它返回True，否则它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

2、优先级

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments...)	函数调用
(experession,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

3、表达式

六、控制流

1、if。。。elif。。。else

if 判断:

操作；

elif 判断:

操作；

else: # 不要漏掉else后明的冒号：

操作

2、while...else

while 判断:

操作

else: 不符合判断的操作

3、for...in...else...

for 数据变量 in 数据变量的范围（如用range（首数，尾数，步长））

操作

else:

操作

不同于java和c中的for循环

4、break

用于终止循环，终止之后，for或while后面的else不会执行。

5、continue

跳过当前循环块的余下部分，继续进行下一次循环

七、函数

1、定义函数def

格式：def 函数标识符名称():

  函数内容

def sayHello():
    print 'Hello World!' # block belonging to the function

sayHello() # call the function

2、形参

函数名称括号内的参数名称为形参，提供给函数调用的值为实参。

3、局部变量

函数内声明的变量只在函数内有效，如果需要在全局有效，需要在变量前使用关键字global进行声明。

4、默认参数值

可以给形参设置默认的参数值，但是这些形参必须是排在后面的形参。

def say(message, times = 1):
    print message * times

注：一个字符串后面*数值，表示该字符串重复多少次，即'abc*2'等价于'abcabc'
5、关键参数

如某函数中含有多个参数，而只想指定其中的一部分，那么可以通过命名为这些参数赋值。

在调用函数时，可以直接为这些关键参数赋值。

def func(a, b=5, c=10):
    print 'a is', a, 'and b is', b, 'and c is', c

func(3, 7)
func(25, c=24)
func(c=50, a=100)

结果为：

a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

6、return语句

用来跳出函数，或者从函数里返回一个值

跳出函数直接使用return，等价于return None，而每个没有写return的函数都暗含有return None

pass表示空的语句块

7、DocStrings文档字符串——Python的特别之处

可以理解为Python的文档注释。

编写惯例是：1）写在三引号''' '''里； 2）第一行：大写字母开始，句号结束。说明这个函数或者程序段或者类的简介；

  3）第二行空行；4）第三行开始时详细的描述。

在程序中，使用 函数名.__doc__可以调用这个字符串，注意doc两边是 双下划线。

def printMax(x, y):
   <span style="background-color: rgb(255, 204, 153);"> '''Prints the maximum of two numbers.

    The two values must be integers.'''</span>
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'

printMax(3, 5)
print printMax.__doc__

八、模块

1、简介

用于在很多程序中重用函数或者类等，每个模块的文件名必须以.py为扩展名

如，使用sys模块

2、from...import 语句
导入某模块的某个参数

3、模块的__name__

每个模块都有其__name__属性，如主程序的模块名称为__main__

4、创建模块

#!/usr/bin/python
# Filename: mymodule.py

def sayhi():
    print 'Hi, this is mymodule speaking.'

version = '0.1'

# End of mymodule.py

5、dir()

查看文档属性

九、数据结构

1、列表

list，是处理一组有序项目的数据结构，即可以在一个列表中存储一个序列的项目。

操作list的常用方法：append，pop，sort，del，len等

shoplist = ['apple', 'mango', 'carrot', 'banana']

print 'I have', len(shoplist),'items to purchase.'

print 'These items are:', # Notice the comma at end of the line
for item in shoplist:
    print item,

print '\nI also have to buy rice.'
shoplist.append('rice')
print 'My shopping list is now', shoplist

print 'I will sort my list now'
shoplist.sort()
print 'Sorted shopping list is', shoplist

print 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist

2、元组

与列表很相似，只是其中的值一旦设定，就不能更改。通常用在打印语句中。

name = "Li Ming"
age = 24
print 's% is d% years old' % (name, age)
print 'my name is s%' % name

3、字典

形式上类似于js中的json，即键值对的无序组合。可以对字典执行的操作有：增删改查

#!/usr/bin/python
# Filename: using_dict.py

# define a dictionary
ab = {       'Swaroop'   : 'swaroopch@byteofpython.info',
             'Larry'     : 'larry@wall.org',
             'Matsumoto' : 'matz@ruby-lang.org',
             'Spammer'   : 'spammer@hotmail.com'
     }
# get value by key -- use []
print "Swaroop's address is %s" % ab['Swaroop']

# Adding a key/value pair
ab['Guido'] = 'guido@python.org'

# Deleting a key/value pair
del ab['Spammer']

print '\nThere are %d contacts in the address-book\n' % len(ab)

// get all these key/value pairs --- use ab.items(), for and tuple
for name, address in ab.items():
    print 'Contact %s at %s' % (name, address)
// judge if a key in a certain dictionary --- use in or ab.has_key('key')
if 'Guido' in ab: # OR ab.has_key('Guido')
    print "\nGuido's address is %s" % ab['Guido']

4、序列

列表，元组，字符串都是序列。

序列的操作非常简便灵活，这是其他语言不能比拟的。

特点一：索引操作——从序列中抓取特定项目

索引值可正可负，0表示正序第一个值，-1表示最后一个值，以此类推。

特点二：切片操作——获取序列的一部分切片，即一个子序列

切片范围可正可负，格式为[start : end]，表示从start值开始，到 end-1 结束的子序列

[:]为获取当前序列的一个拷贝

#!/usr/bin/python
# Filename: seq.py

shoplist = ['apple', 'mango', 'carrot', 'banana']

# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]

# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]

# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]

5、参考

参考：给对象A赋值一个变量B时，对象A只不过是参考B,而不是B本身。即A在内存中指向了B的存储空间。从而对A或者B的操作，都可以从A和B上同时显示出来。A=B，这只是一个参考

拷贝：使用切片操作符制造一个拷贝，这样A和B的操作就是独立的，即在内存中创建了两块独立的区域。

6、字符串

Python中的字符串都是str类的对象。使用help(str) 查看str类的具体用法

常用的方法有str.jion, str.find等

十、解决问题，编写一个Python脚本

1、问题：编写一个可以为我所有重要文件创建备份的程序

2、分析：

如何确定保存哪些文件，备份保存在哪里，怎样存储备份

3、思路：

（1）需要备份的文件和目录由一个列表制定。

（2）备份应该保存在主备份目录中。

（3）文件备份成一个zip文件。

（4）zip存档的名称是当前的日期和时间。

（5）使用标准zip命令，win用户可以使用win自带makecab或者info-zip程序

4、注意

（1）注意os.sep变量的用法——这会根据你的操作系统给出目录分隔符，即在Linux、Unix下它是/，在win下是\\，在mac os下是：。

（2）实际编写时，可以使用python提供的zipfile库。

5、软件开发过程

软件是长出来的，而不是建造的

1、分析 2、设计 3、实施 4、测试与调试 5、实施或者开发 6、优化

十一、面向对象的编程

1、self

类中的函数与普通函数的特别区别，必须有一个额外的第一参数名称。但是调用方法的时候不必为这个参数赋值，被自动的指向对象变量本身

如， 对象MyObj是类MyClass的一个实例。实例调用方法MyObj.Method(arg1, arg2)会被Python自动的处理为， MyClass.Method(MyObj, arg1, arg2)

也就是说，类中的某个方法，即使不需要传入参数，也要定义这个self参数。

类似于java中的this，却跟this有些差别。

2、类

格式

class MyClass:
      pass #表示空白块

3、对象的方法

class Person:
    def sayHi(<span style="color:#ff0000;">self</span>):
        print 'Hello, how are you?'

p = Person()
p.sayHi()

4、__init__方法

在一个对象被建立时，马上自动运行，即用于初始化。类似于java中的constructor

class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name

p = Person('Swaroop')
p.sayHi()

5、类和对象的变量

类的变量由这个类的所有共享使用

对象的变量由这个每个对象独有。

即，类中的所有成员（数据和方法）都是公共的，所有的方法都是有效的

只有一个例外，如果数据成员以双下划线__为前缀，Python的名称管理系统会对其做私有变量处理。

惯例，类中的成员只想用于类中，以单下划线_为前缀。

6、继承性

————实现代码的重用

父类称为基本类或者超类；

子类称为导出类或者子类。子类可以多重继承。

class Teacher(SchoolMember):

十二、输入/输出文件

1、使用文件

打开：创建对象 写入文件：write 读取：readline 关闭：close

poem = '''\
Programming is fun
When the work is done
if you wanna make your work also fun:
        use Python!
'''

f = <span style="color:#ff6666;">file('poem.txt', 'w')</span> # open for 'w'riting
f.<span style="color:#ff6666;">write(poem)</span> # write text to file
f.<span style="color:#ff6666;">close() </span># close the file

f = file('poem.txt')
# if no mode is specified, <span style="color:#ff6666;">'r'ead mode is assumed by default</span>
while True:
    <span style="color:#ff6666;">line = f.readline()</span>
    if<span style="color:#ff0000;"> len(line) == 0: </span># Zero length indicates EOF
        break
    print line,
    # Notice comma to avoid automatic newline added by Python
f.close() # close the file

2、储存器

Python提供了一个标准模块的pickle：用于在文件中存储、读取任何Python对象，被称为持久的存储对象。

于此同时，还有另外一个模块cPickle，使用C语言编写，速度 快1000倍

这两个模块统称为pickle模块， 这里，使用cPickle。

每个文件只能存储一个对象

操作过程： 储存dump和 取存储load

<span style="background-color: rgb(255, 204, 204);">import cPickle as p</span>
#import pickle as p

shoplistfile = '../datas/shoplist.data' #文件被存储在同级目录内
# the name of the file where we will store the object

shoplist = ['apple', 'mango', 'carrot']

# Write to the file
f = file(shoplistfile, 'w')
p.dump(shoplist, f) # dump the object to a file
f.close()

del shoplist # remove the shoplist

# Read back from the storage
f = file(shoplistfile)
storedlist = p.load(f)
print storedlist

十三、异常

1、异常处理

在形式上与其他的高级程序语言没有什么大的差别

<pre name="code" class="python">try:
    #语句块
except EOFError: #特殊的异常
    #异常处理
except: #一般性异常
    #异常处理

try:
except:
else:

try:
finally:

2、声明自己的异常，使用关键字raise引发

<span style="background-color: rgb(255, 204, 204);">class ShortInputException(Exception): #定义一个自己异常处理
</span>    '''A user-defined exception class.'''
    def __init__(self, length, atleast):
        Exception.__init__(self)
        self.length = length
        self.atleast = atleast

try:
    s = raw_input('Enter something --> ')
    if len(s) < 3:
<span style="background-color: rgb(255, 204, 204);">        raise ShortInputException(len(s), 3) #使用关键字raise引发异常处理
</span>    # Other work can continue as usual here
except EOFError:
    print '\nWhy did you do an EOF on me?'
<span style="background-color: rgb(255, 204, 204);">except ShortInputException, x: #处理自定义的你异常
</span>    print 'ShortInputException: The input was of length %d, \
          was expecting at least %d' % (x.length, x.atleast)
else:
    print 'No exception was raised.'

十四、Python标准库

随Python附带安装，包含大量有用模块

1、sys模块

提供了系统对应的功能

可以对系统提供的参数进行处理

import sys

def readfile(filename):
    '''Print a file to the standard output.'''
    f = file(filename)
    while True:
        line = f.readline()
        if len(line) == 0:
            break
        print line, # notice comma
    f.close()

# Script starts from here
if len(sys.argv) < 2:
    print 'No action specified.'
    sys.exit()

if sys.argv[1].startswith('--'):
    option = sys.argv[1][2:]
    # fetch sys.argv[1] but without the first two characters
    if option == 'version':
        print 'Version 1.2'
    elif option == 'help':
        print '''\
This program prints files to the standard output.
Any number of files can be specified.
Options include:
  --version : Prints the version number
  --help    : Display this help'''
    else:
        print 'Unknown option.'
    sys.exit()
else:
    for filename in sys.argv[1:]:
        readfile(filename)

2、os模块

包含操作系统普遍的功能

常用：os.sep可用于linux和win的路径分隔符

os.name字符串指示你正在使用的平台，比如windows，值为nt，对于linux unix，为posix

os.getcwd()得到当前的工作目录，即当前python工作脚本的路径

os.getenv()和os.putenv()函数分别用来读取和设置环境变量

os.listdir()返回指定目录下的所有文件和目录名

os.remove()用来删除一个文件

os.system()用来运行系统shell命令

os.linesep字符串给出当前平台使用的行终止符，例如，win的'\r\n'，linux的'\n'，mac的'\r'

os.path.split()一个路径的目录名和文件名

os.path.isfile()和os.path.isdir()，用于检验一个给出的路径是一个文件还是目录

os.path.existe()用来检验给出的路径是否真的存在

十五、更多Python的内容

1、类中普遍存在的特殊方法

名称	说明
__init__(self,...)	这个方法在新建对象恰好要被返回使用之前被调用。
__del__(self)	恰好在对象要被删除之前调用。
__str__(self)	在我们对对象使用print语句或是使用str()的时候调用。
__lt__(self,other)	当使用 小于 运算符（<）的时候调用。类似地，对于所有的运算符（+，>等等）都有特殊的方法。
__getitem__(self,key)	使用x[key]索引操作符的时候调用。
__len__(self)	对序列对象使用内建的len()函数的时候调用。

2、列表综合

作用：从一个已有列表导出一个新的列表

如，已知一个数列表，从这个表导出一个列表，使其中所有大于2的 数都是原来的2倍

listone = [2, 3, 4]
listtwo = [2*i for i in listone if i > 2]
print listtwo

条件：if i > 2 操作：2*i

3、在函数中可变数量的参数

在形参前有*前缀的，多余的函数会做为一个元组存储在args中。

在形参前有**前缀的，多余的函数 会被认为是一个字典键值对

>>> def powersum(power, *args):
...     '''Return the sum of each argument raised to specified power.'''
...     total = 0
...     for i in args:
...          total += pow(i, power)
...     return total
...
>>> powersum(2, 3, 4)
25

>>> powersum(2, 10)
100

4、lambda函数

也叫匿名函数，即函数没有具体的名称，在内存中没有缓存。而用def创建的方法是有名称的，在内存中有缓存。

可见，lambda更有效率

格式：lambda [参数1, 参数2... ...]:具体操作

def make_repeater(n):
    return lambda s: s*n

twice = make_repeater(2)

print twice('word')
print twice(5)

5、exce()和eval()

exce()用来执行字符串中的Python语句

eval()用来计算存储在字符串中的有效Python表达式

>>> exec 'print "Hello World"'
Hello World
>>> eval('2*3')
6

6、assert语句

用来声明某个条件是真的。如果失败，抛出AssertionError

>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> assert len(mylist) >= 1
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
AssertionError

7、repr函数

用来取得对象的规范字符串表示，反引号也可以完成相应的功能。

大多数时候有eval(repr(object)) == object

>>> i = []
>>> i.append('item')
>>> `i`
"['item']"
>>> repr(i)
"['item']"

十六、接下来学习什么

1、图形软件

2、fross社区