第一章 基础知识

1：Linux中安装 $apt-get install python ($为bash提示符)

2：数字和表达式：1/2 结果为0。from _future_ import division 加入此语句，则只执行普通除法（3.0之前是这样）。
十六进制和八进制，首位数都是0

3：操作符：*，**（幂运算），/，//（整除），%（取余）
-3**2=-(3**2),因为幂运算比取反（一元减法运算符）优先级高

4：赋值： x=3

5：语句、表达式：表达式是某事，语句是做某事

6：获取用户输入： input("your input is:")

7：条件语句:  if 1==2 : print('yes')

8：函数
pow(2,3)==2**3  幂运算
10+pow(2,3*5)/3.0
取正：abs(-10)
四舍五入:round(3.6)

9:模块（可以想象其为导入到python中以增强其功能的扩展）
import math
math.floor(32.9)=>32.0 （向下取整）    math.ceil(32.2)=>33（向上取整）
取整：int(math.floor(32.9))（floor此处多余）（去除小数点后的）

使用from模块import函数这种形式的import命令之后，可以直接使用函数，不需要模块作为函数前缀：foo=math.sqrt   foo(4)=2.0

10：cmath和复数：
sqrt函数用于计算一个数的平方根，但只能处理浮点数，sqrt(-9)时出差，负数的平方根是虚数。
import cmath
cmath.sqrt(-9)=>3j
这里没有使用from...import...语句是因为一旦使用就没法使用普通的sqrt函数了

注意：nan是一个特殊值的简写，意思是“not a number”（非数值）

11：_future_    通过它可以导入那些在未来会成为标准的Python组成部分的新特性

12：保存并执行程序
File->New Window创建一个新的编辑窗口，在此写代码，然后F5运行

13：在命令提示行中运行程序
windows：C:\>E:\Tools\Python32\python Hello.py（E:\Tools\Python32\python为python.exe所在，假设hello.py已放在此文件夹）
UNIX：$python hello.py

14：让脚本像普通程序一样运行，而不需要显式使用python解释器
UNIX：在脚本首行加上#!(叫做pound bang或shebang)，如：#! /user/bin/env python。则不管python二进制文件在哪里，程序都会自动执行
input("Press <enter>")

15：转义字符\，字符串拼接+

16：str和repr
str会把值转换为合理形式的字符串，而repr会创建一个字符串，以合法的python表达式的形式来表示值。repr(x)等于`x`（2.x，反引号）
如：temp = 42
print "the temp is " + repr(temp)

16：长字符串、原始字符串、Unicode
A： 如果要写一个很长的字符串，它需要跨多行，则可使用三个引号来代替普通引号
print('''this is
very long string
and she said 'why not?'. Yes!''')
普通字符也可以换行，在字符后加\
print('hello,\
world!')=>hello,world

B 原始字符串

可以使用转义字符：print("c:\\now\\test.txt")，但是路径比较深，需要使用很多\\
原始字符以r开头，如
print(r'c:\now\test.txt') =>c:\now\test.txt

如果要在字符后加\，则
print(r'c:\now\test' '\\') => c:\now\test\
注：不能再原始字符串结尾输入反斜线，除非对其转义之后（原始字符串在写正则时尤其有用）

C：Unicode字符串（或称之为Unicode对象——与字符串不是同一个类型）
u'Hello,World!' —— Unicode字符串使用u前缀，就像原始字符串使用r一样

注意：在python3中所有字符串都是Unicode字符

小结

算法：算法是描述如何完成一项任务的方法

表达式、变量、函数、模块

第二章  列表和元组

1：数据结构：数据结构是通过某种方式（例如对元素进行编号）组织在一起的数据元素的集合。可以是数字或者字符，也可以是其他的数据结构。

2：在python中，最基本的数据结构是序列（sequence）。序列中得每个元素被分配一个序列号——即元素的位置，也称为索引。第一个索引为0

2.1：python包含6中内建的序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象（列表和元组的主要区别：列表可以修改，元组则不能）。列表各个元素通过逗号分割，写在方括号中：

edward=['Edward Gumby',42]。同时，序列也可以包含其他的序列，如构建一个人员信息的列表，这个列表就是你的数据库：

edward=['Edward Gumby',42]
john=['John Smith',50]
database=[edward,john]

注：python还有一个名为容器(container)的数据结构。是包含其他对象的任意对象。
序列（如列表和元组）和映射（例如字典）是两类主要的容器。序列中得每个元素都有自己的编号，而映射中的每个元素则有一个名字（称为键）。
总结：序列有序，映射无序（有序则可通过序号访问，无序无法通过序号访问，只能通过键）。
集合（set）是一个既不是序列也不是映射的容器类型

2.2：通用序列操作

操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）、迭代（iteration）以及检查某个元素是否属于序列的成员（成员资格）。还有计算序列长度，找出最大、最小元素的内建函数

1）索引：
s='hello!'     s[0] => 'h'    s[-1]  => '!'(当为负数时，从右边开始获取元素)
注：字符串就是一个由字符组成的序列。

字符串字面值（其他序列字面量亦可）能直接使用索引，而不需要一个变量引用他们

'hello!'[1]  =>  'e'。如果一个函数调用返回一个序列，则可以直接对返回结果进行索引操作。如

fourth=input('Year: ')[3]
Year: 2005
fourth
'5'

实例：

View Code

#根据给定的年月日以数字形式打印出日期
months = ['January','February','March','April','May','June','July','August','September','October','November','December']#以1~31的数字作为结尾的列表
endings = ['st','nd','rd'] + 17 * ['th'] \+ ['st','nd','rd'] + 7 * ['th'] \+ ['st']year = input('Year: ')
month = input('Month(1-12): ')
day = input('Day(1-31): ')month_number = int(month)
day_number = int(day)#记得要将月份和天数减1,以获得正确的索引
month_name = months[month_number-1]
ordinal = day + endings[day_number-1]print(month_name + ' ' + ordinal + ' ' + year)

2）：分片

与使用索引来访问单个元素相类似，可以使用分片操作来访问一定范围内的元素，分片通过冒号相隔的两个索引来实现：第一个索引是需要提取部分的第一个元素的编号，而最后的索引则是分片之后剩下部分的第一个元素的编号
简而言之，分片操作的实现需要提供两个索引作为边界，第1个索引的元素是包含在分片内的，而第2个则不包含在分片内。

>>> tag='<a href="http://python.org">Python web site</a>'
>>> tag[9:30]
'http://python.org">Py'
>>> tag[32:-4]
'on web site'

>>> numbers=[1,2,3,4,5,6,7,8,9,10]
>>> numbers[3:6]
[4, 5, 6]
>>> numbers[0:1]
[1]

A:优雅的设计：

>>> number = [0,1,2,3,4,5,6,7,8,9]
>>> number[7:10]输出[7, 8, 9]（索引10指向的是第11个元素——此元素并不存在，却在最后一个元素之后。注：为了让分片部分能够包含列表的最后一个元素，必须提供最后一个元素的下一个元素所对应的索引作为边界）。

如果要从列表的结尾开始计数，则：

>>> number[-3:-1]
[7, 8]
>>> number[-3:0]
[]（见注）
>>> number[-3:]
[7, 8, 9]

注：只要分片中得最左边的索引比它右边的晚出现在序列中，结果就是一个空的序列（如果是从左边-即正数开始是索引1>索引2，如果从右边则是索引1<索引2）。
如果分片所得部分包括序列结尾的元素，则只需要置空最后一个索引即可。此方法适用于序列开始的元素：

>>> number[:3]
[0, 1, 2]

如果要复制整个序列，可以将两个索引都置空

>>> number[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

B:更大的步长

分片的开始和结束点都需要进行指定（不管是直接还是间接）。而另外一个参数——步长，通常隐式设置。如果步长被设置为必1大的数，那么就会跳过某些元素。例如，步长为2的分片包括的是从开始到结束每隔1个的元素

>>> number[0:10:1]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> number[0:10:2]
[0, 2, 4, 6, 8]

>>> number[3:6:3]
[3]

如果需要将每四个元素中得第一个元素提取出来，则只要将步长设置为4

>>> number[::4]
[0, 4, 8]

注：步长不能为0，那不会向下执行，但可以为负数，即从右到左提取元素。

>>> number[8:3:-1]
[8, 7, 6, 5, 4]

number[10:0:-2]
[9, 7, 5, 3, 1]

number[0:10:-2]
[]

>>> number[::-2]
[9, 7, 5, 3, 1]
>>> number[5::-2]
[5, 3, 1]
>>> number[:5:-2]
[9, 7]

3）：序列相加——列表和字符串是无法连接在一起的，尽管他们都是序列。简单的说，两种相同类型的序列才能进行连接操作。

>>> [1,2,3]+[1,2,3]
[1, 2, 3, 1, 2, 3]
>>> 'hello,'+'world'
'hello,world'

4）：乘法——用数字x乘以一个序列会生成新的序列，而在新的序列中，原来的序列将被重复x次
'python' * 5 ——python这个序列会被重复5次变成新的序列

5）：None、空列表和初始化——None是Python的内建值，意味着没有在里面放置任何元素

空列表可以用[]来表示。但是要生成有10个元素的空列表则需要用None——sequence = [None]*10

View Code

 1 #以正确的宽度在居中的“盒子”内打印一个句子
 2 #注意，整数除法运算符(//)只能用在Python2.2及后续版本，之前只能用/
 3
 4 sentence = input("Sentence: ")
 5 screen_width = 80
 6 text_width = len(sentence)
 7 box_width = text_width + 6
 8 left_margin = (screen_width - box_width)//2
 9
10 print()
11 print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')
12 print(' ' * left_margin + '|' + ' ' * text_width +     ' |')
13 print(' ' * left_margin + '|' +       sentence   +     ' |')
14 print(' ' * left_margin + '|' + ' ' * text_width +     ' |')
15 print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')
16 print()

6）：成员资格——为检查一个值是否在序列中，可以使用in运算符（布尔运算符，真值则叫布尔值）

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False（UNIX系统中，这两型代码可以作为查看文件可写和可执行权限的脚本）
>>> users = ['mlh', 'foo', 'bar']
>>> input('Enter your user name: ') in users
Enter your user name: mlh
True（检查所提供的用户名mlh是否在用户列表中。如果程序需要执行某些安全策略，就可以用这个，也可能需要使用密码）
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True（可作为垃圾邮件过滤器的一般分）

View Code

View Code #检查用户名和PIN码
 database = [['albert', '1234'],['dilbert', '4242'],['smith', '7524'],['jones', '9825']]username = input('User name: ')pin = input('PIN code: ')if[username, pin] in database : print('Access!')

7）：长度、最小值和最大值
内建函数：len、min、max

3：列表——列表是可变的(mutable)

3.1：list 函数——因为字符串不能像列表一样被修改，所以有时候根据字符串创建列表会很有用，另外list函数适用于所有类型的序列，不只是字符串：

seq=list('Hello')
['H', 'e', 'l', 'l', 'o'] #输出内容
seq[2] = 'x'

可以使用''.join(somelist) 表达式将一个由字符组成的列表转换成字符串

>>> ''.join(hello)
'hexlo'

3.2：基本的列表操作
1）改变列表：元素赋值—— x[1]=2
注意：不能为一个位置不存在的元素进行赋值。

2）删除元素——使用del语句

>>> del hello[2]
>>> hello
['h', 'e', 'l', 'o']

3）分片赋值——分片是一个非常强大的特性，分片赋值操作则更加显现它的强大：程序可以一次为多个元素赋值

>>> name=list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']

还可以使用与原序列不等长得序列将分片替换

>>> name=list('Perl')
>>> name[1:]=list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']

分片赋值语句还可以在不需要替换任何原有元素的情况下插入新的元素

>>> numbers=[1,5]
>>> numbers[1:1]
[]
>>> numbers[1:1]=[2,3,4]
>>> numbers
[1, 2, 3, 4, 5]

上面代码”替换“了一个空的分片，因此实际的操作是插入了一个序列（1:1表示在下标1后，0:0表示在下标0后）。以此类推，通过分片赋值来删除元素也是可以的

>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4]=[]
>>> numbers
[1, 5]

3.3：列表方法——方法是一个与某些对象有紧密联系的函数，对象可能是列表、数字，也有可能是字符串或者其他类型的对象。调用：
对象.方法(参数)
1）append 方法：用于在列表末尾追加新的对象

>>> lst=[1,2,3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

list是一个内建函数，但是像lst这样的变量名是非常糟糕的，以为它毫无意义。所以，如果需要定义一个价格列表，那么就应该使用prices、prices_of_eggs或者pricesOfEggs作为变量名
注意：append方法和其他一些方法类似，只是在恰当的位置修改原来的列表。这意味着，它不是简单的返回一个修改过的新列表——而是直接修改原来的列表

2）count 方法——统计某个元素在列表中出现的次数

>>> ['to','be','or','not','to','be'].count('to')
2
>>> x=[[1,2],1,1,[2,1,[1,2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1

3）extend方法——在列表的末尾一次性追加另一个序列中的多少个值，即可以用新列表扩展原有的列表

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

这个方法看起来很像连接操作，两者区别：extend方法修改了被扩展的序列（a），而原始的连接操作它返回一个全新的列表。原始的连接操作创建了一个包含了a和b副本的新列表，如果需要a=a+b 这样的操作，那么连接操作的效率会比extend低

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a+b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]

注意：实际从python2.2开始，list就是一个类型而不是一个函数了。(tuple和str也是如此)
可以使用分片赋值来实现相同的结果，但代码可读性不如extend方法

>>> a=[1,2,3]
>>> b=[4,5,6]
>>> a[len(a):] = b
>>> a
[1, 2, 3, 4, 5, 6]

4）index方法——用于从列表中找出某个值在第一个匹配项的索引位置，如果没有找到则会引发一个异常：

>>> knights = ['we','are','the','knights','who','say','in']
>>> knights.index('who')
4
>>> knights[5]
'say'

5）insert方法——用于将对象插入到列表中：

>>> numbers=[1,2,3,5,6,7]
>>> numbers.insert(3,'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

也可以用分片来实现，但可读性不如insert

>>> numbers=[1,2,3,5,6,7]
>>> numbers[3:3]=['four']
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

6）pop 方法——移除列表中的一个元素（默认是最后一个），并且返回该元素的值

>>> x=[1,2,3]
>>> x.pop()
3

注意：pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法——列表如果为空列表，调用pop方法会引发异常

使用pop 方法可以实现一种常见的数据结构——栈（LIFO，后进先出）。
栈的两个操作：入栈（push）和出栈（pop）。Python没有入栈方法，但可以使用append方法来代替。如果入栈（或追加）刚出栈的值，结果还是原来的栈

>>> x=[1,2,3]
>>> x.append(x.pop())
>>> x
[1, 2, 3]

如果要实现一个先进先出（FIFO）的队列（queue），可以使用insert(0,...)来代替append方法，也可以继续使用append方法，但必须用pop(0)来代替pop()，更好的解决方案是使用collection模块中的deque对象

7）remove 方法——用于移除列表中某个值的第一个匹配项

>>> x=['to','be','or','not','to','be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']

可以看到：只有第一次出现的值被移除了。如果值不存在，则引发异常。
注意：remove方法是一个没有返回值的原位置改变方法。它修改了列表却没有返回值，与pop相反

8）reverse 方法——将列表中的元素反转。该方法也改变了列表但不返回值（就像remove和sort）

>>> x=[1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]

如果要对一个序列进行反向迭代，可以使用reversed 函数。此函数并不返回一个列表，而是返回一个迭代器（iterator）对象。然后使用list函数把返回的对象转换成列表：

>>> x=[1,2,3]
>>> list(reversed(x))
[3, 2, 1]

9）sort 方法——用于在原位置对列表进行排序。在”原位置排序“意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单的返回一个已排序的列表副本

>>> x=[4,6,2,1,7,9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

当用户需要一个排好序的列表副本，同时又保留原有列表不变的时候，使用：
y=x.sort() 这样的方式实现是错误的。因为sort方法修改了x却返回空值，最后得到的是已排序的x以及值为None的y。
实现这个功能正确方法是，首先把x的副本赋值给y，然后对y进行排序

>>> x=[4,6,2,1,7,9]
>>> y=x[:]
>>> y.sort()
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]

另一种获取已排序的列表副本的方法是，使用sorted函数：

>>> x=[4,6,2,1,7,9]
>>> y=sorted(x)

这个函数可以用于任何序列（可用于任何可迭代对象），却总是返回一个列表

>>> sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']

如果想把一些元素按相反的顺序排列，可以先使用sort（或sorted），然后再调用reverse方法，也可以使用reverse参数

10）高级排序——可实现类似compare(x,y)比较函数：x<y 返回负数，x>y返回正数，x=y返回0。内建函数：cmp(x,y)
注意：cmp（）函数不再存在，__cmp__()已经不支持了，被一些比较函数替代，比如__lt__(),__eq__()等。如果需要使用cmp（），可以使用（a>b）-（a<b）替代。

sort 方法有另外两个可选的参数——key和reverse。如果要使用它们，那么就要通过名字来指定（这叫关键字参数）。参数key——必须提供一个在排序过程中使用的函数。该函数并不是直接用来确定对象的大小，而是为每个元素创建一个键，然后所有元素根据键来排序。因此如果要根据元素的长度来排序，可以使用len作为键函数

>>> x=['aardvark','abalone','acme','add','aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

另外一个关键字reverse 是简单的布尔值（true或false），用来指明列表是否要进行反向排序

>>> x=[4,6,2,1,7,9]
>>> x.sort(reverse=True) #注意True是大写T
>>> x
[9, 7, 6, 4, 2, 1]

cmp、key、reverse参数都可以用于sorted函数

4：元组：不可变序列（字符串也不可变）。创建元组很简单，用逗号分隔一些值，就自动创建了元组:

>>> 1,2,3
(1, 2, 3)

元组也是（大部分是）通过圆括号括起来的：

>>> (1,2,3)
(1, 2, 3)

空元组——()

包括一个值的元组，必须加个逗号

>>> 42
42
>>> 42,
(42,)

注意：元组和列表在技术实现上有一些不同，而且元组没有像列表一样的方法

>>> 3*(42+2,)#有逗号才是元组
(44, 44, 44)

1）tuple（n. 元组, 数组, 重数） 函数（tuple并不是真正的函数，而是一种类型）——功能与list函数基本上一样：以一个序列作为参数并把它转换成元组。如果参数就是元组，则该参数被原样返回：

>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1,2,3))
(1, 2, 3)

2）基本元组操作——创建元组和访问元组元素

>>> x=1,2,3
>>> x[1]
2
>>> x[0:2]
(1, 2)

元组的分片还是元组，就像列表的分片还是列表一样

3）元组的意义
A：元组可以在映射（和集合的成员）中当做键使用——list则不行
B：元组作为很多内建函数和方法的返回值存在

5：小结

序列：序列是一种数据结构，它包含的元素都进行了编号（从0开始）。典型的序列包括列表、字符串和元组。其中列表是可变的（可修改），而元组和字符串是不可变的（一旦创建就是固定的）。通过分片操作可以访问序列的一部分，其中分片需要两个索引号来指出分片的起始和结束为止。要想改变列表，则要对相应的位置进行赋值，或者使用赋值语句重写整个分片

成员资格：in 操作符可以检查一个值是否存在于序列（或其他容器）。对字符串使用in 操作符是一个特例——它可以查找子字符串

方法：一些内建类型（例如列表和字符串，元组则不在其中）具有很多有用的方法。