Python入门学习笔记

1 Python入门教程

我是在慕课网学习的Python课程。基于Python 2.7。这套课程是比较浅显易懂的入门课程，有一点基础的基本上不到一下午就能学完。建议配套廖雪峰的教程一起食用。
本文旨在对之前所学的内容（基本语法）做一个概括性的总结和梳理，并且如果可以的话帮助后来人的学习。不适合没有一点编程基础刚入门的小白。

2 Hello, world!

潜规则，入门的第一件事就是Hello world。Python的hello world是这样的：
print 'Hello, world!'

当然，到了Python 3之后，print函数变成了这样：
print('Hello, world!')
这样就更像一个“正常”的函数了。

在Python中，不是Java和C这样用花括号来分割代码片段，而是使用缩进。例如，在java中定义一个打印hellowolrd的函数，我们会这样写：

public void printHello(boolean shouldPrint){
    if(shouldPrint){
        System.out.println("hello world");
    }
}

而在Python中，这段代码应写为：

def print_hello(should_print):
    if should_print:
        print 'hello world'

通过缩进来控制代码层级，好处是代码显得非常工整，层次结构清晰；缺点是对于缺乏规范代码意识的新手来说，会掉进缩进错误、空格和tab混用等等的坑，并且在代码嵌套过深（虽然这是应该极力避免的）的情况下，可读性将变得比较差。其实对于一个有代码洁癖，严格按照规范编写代码（包括格式和命名等等）的程序员来讲，Python的缩进基本不存在上手难度，因为即使用C，用Java，写出工整、清晰、易读的代码也是日常操作（虽然IDE有一键格式化），个人认为这也是一个合格程序员的基本素质。

print函数可以接受多个参数。在打印时，每个参数直接会用空格隔开。例如：
print 'hello', 'world'
会打印出hello world

3 Python中的数据类型

Python是一种动态类型语言。也就是说，变量的类型是运行时确定的。你可以这么写：

a = 1
print a
a = 'a'
print a

这样是完全没问题的。

同时，Python是一种强类型语言，即不支持或很少支持隐式的类型转换。Python有一个内建函数type(a)，可以返回变量a的类型。常见的基本类型有：
- 整型int
- 浮点型float
- 字符串string
- 布尔型bool
有趣的是，bool类其实是int类的子类。bool只包含True和False两种值，True的int值是1，而False是0。可以调用True == 1和False == 0来进行验证。

Think & Try

• 输入print '123' + 456会打印出什么？
• True < 3的结果是什么？'3' > 2的结果是什么？

4 可迭代对象

可迭代对象（iterable），顾名思义，就是可以通过迭代的方式遍历的对象。看一个对象obj是不是可迭代的，可以通过isinstance(obj, Iterable)。不过首先要导入from collections import Iterable。

4.1 tuple和list

元组：t = (1, 2, 3)
列表：L = [1, 2, 3]
元组tuple和列表list类似，都是一种可迭代对象。不同的是，tuple是不可变的，而list是可变的。
和Java，C中的数组不同的是，tuple和list的元素不需要是相同类型的。例如L = [1, 2.0, '3', (4, 5)]这个list既包含了整型，又包含了浮点型，字符串，元组。
另外，当元组tuple只有一个元素的时候，会返回这个元素本身。例如t = (5)，表示t就是5，即与t = 5等价。

4.2 set和dict

和Java中的Set和Map类似，由于都是基于哈希算法的数据结构，所以查找速度很快。

• set：set = {1, 2, '3', (4, 5)}
  set和list类似，但是他是无序的，并且是无重复的。例如，当输入s = {'a', 'b', 'c'}之后，打印出的结果可能不是{'a', 'b', 'c'}而是{'b', 'c', 'a'}；又如，s = {'a', 'a', 'b', 'c'}，实际上和s = {'a', 'b', 'c'}是等价的，因为set不保存重复的值。另外，set还可以通过传入一个list的方式来获得，即：s = set(['a', 'b', 'c'])。

• dict：dict = {'hello': 'world', 'foo': 'bar', 'fiz': 3, 4: 'buz'}
  dict是通过key-value对来进行数据存储的。每一对key-value通过key: value来定义，并用逗号隔开。当需要取值的时候，通过dict[key]来获取value的值。dict也是无序的。

4.3 range()

range()函数也返回一个可迭代对象。用法是：range(from, to)，其中第一个参数可以省略，默认从0开始，第二个参数不包含在范围内。例如：range(1, 100)代表1~99的范围，range(5)代表0~4的范围。
range()函数返回的就是一个range对象，既不是tuple，也不是list。

4.4 切片

对一个可迭代对象，Python支持对其进行切片。
简单来说，我有一个list比如：L = [1, 2, 3, 4, 5]，想要取其中的一部分，这时候就可以用到切片操作。例如：L[:3]就是取这个列表的前三项。
同时，也可以传入负数，代表倒数的第某项。

切片可以传入3个参数：
第一个参数是开始取值的索引，可省略，默认是0。
第二个参数是结束取值的索引，不包含该项；可省略，默认到结束。
第三个是取值的间隔，可省略，默认挨个取。

还是上面那个列表。例子：
L[1:5:2]表示从L的索引1开始，到索引5结束，每隔一项取值。即[2, 4]
L[:3]表示取L的前三项。即[1, 2, 3]
L[::2]表示取值索引之间差2。即[1, 2, 3]
L[-3:]表示从索引倒数第3项开始取值。即[3, 4, 5]
L[3::]同L[3:]
L[::-2]表示从后往前取整个列表，并且间隔是2。即[5, 3, 1]
'hello world'[1: 10: 3]表示从这个字符串的第二个字母开始，每3个字母取一次值，直到第10个字母。即'eoo'

Think & Try

• 如何打印出1~100范围内的最后20个偶数？（已知list类的构造方法是list(iterable)）
• set和dict真的是“无序的”吗？

5 if-else

如果说一个程序是一栋大厦，那么if和for就是建造这栋大厦的钢筋混凝土。
在Python中，if语句的用法是这样的：

if cond_1:
    do sth
elif cond_2:
    do sth
else:
    do sth

和其他语言如C，Java的if-else一样。

5.1 if后置

if-else还可以后置使用。例如：

def foo(x):
    print 'odd' if x % 2 == 0 else 'even'

这里定义了一个函数foo(x)，如果x是偶数则打印’odd’，奇数则打印’even’。
虽然用法有些不同，但是这跟java和C中的三元运算符是类似的。

public void foo(int x){
    return x % 2 == 0 ? "odd" : "even";
}

5.2 if ‘True’？

if后面不止可以跟bool值。事实上，if后面还可以跟其他值。比如整型，字符串，甚至函数等等。但只有当这个值是False，0，None等极少数情况才会使条件不成立，参见bool的构造函数。例如：

def foo():
    print 'hello'

def bar():
    if foo:
        print 'world'

bar()

最后打印出的结果是world

6 for

Python中的for语句适用于所有可迭代对象。如tuple，list，string，range等。
基本的用法是：

for i in Iter:
    print i

这句代码打印出可迭代对象的每一个元素。

6.1 列表生成式

和if-else相似，for语句也可以后置。例如：
print [i for i in range(1, 100)]
其中[i for i in range(1, 100)]叫做列表生成式，表示生成包含1~99的列表。

6.2 if-for-切片的结合

if、for、切片三者是可以结合使用的。例如：
print [i for i in range(1, 100) if i%3 == 0][1:5:2]这句代码，表示在1~99的范围中，取出所有3的倍数，并从索引1（第2项，即6）开始，到索引4项为止，每2项取一次，构建一个列表，并将其打印出来。等价于：

L = []
for i in range(1, 100):
    if i % 3 == 0:
        L.append(i)

print L[1:5:2]

6.3 遍历dict

直接通过for i in dict的方式遍历一个dict，会得到这个dict的key的集合。而dict中有keys()和values()两个函数，分别返回这个dict的key和value的集合。
另外，dict中还有items()函数，返回这个dict的key-value对集合。每个key-value通过一个两项的元组来保存。例如：

dict = {'hello': 'world', 'foo': 'bar', 'fiz': 3, 4: 'buz'}
for item in dict.items():
    print item

运行结果是

('fiz', 3)
('foo', 'bar')
(4, 'buz')
('hello', 'world')

Think & Try

• 打印出1000以内的所有质数

7 函数

Python定义函数的基本语法是：

def foo():
    do sth
    return result

如果没有返回值，return语句可以省略。另外，函数也可以有多个返回值，例如：

def bar():
    return 1, 2

x, y = bar()

print 'x = ' + x + ', y = ' + y

这个函数有两个返回值1和2。打印出的结果是x = 1, y = 2。事实上，函数返回的是(1, 2)这个元组。即x, y = bar()这句等价于x, y = (1, 2)。

Think & Try

• 用python编写一个对list进行排序的函数

8 其他

join

使用某个字符串把一个序列的所有元素连接起来。
例如：
'-'.join(('136', '1388', '1772'))
运行结果是'136-1388-1772'

with … as …

在操作文件的时候，我们会这样写：

with open(filename) as f:
    print f.read()

这段代码类似于

f = None
try:
    f = open(filename)
    print f.read()
except Exception as e:
    """handle the exception"""
    print e
finally:
    if f:
        f.close()

这个with ... as ...即是类似于try... except... finally...的处理。

事实上，不止是file，对于对于任意一个实现了__enter__()和__exit__()方法的类，都可以跟在with的后面。换句话说，如果需要with... as...来进行处理的类，需要实现__enter__()和__exit__()方法才能正常工作。例如以下类：

class Sample:
    def __enter__(self):
        # return self is important
        print 'enter'
        return self

    def __exit__(self, *args):
        print 'exit'
        for arg in args:
            print 'type:', type(arg), 'arg:', arg

    def run(self):
        print 'run'
        print 1 / 0

当我们调用

with Sample() as s:
    s.run()

时，因为Sample类实现了__enter__()和__exit__()方法，所以流程是：

• 将__enter__()函数的返回值（这个很重要，并不是s = Sample()）赋值给s，即self；
• 然后调用s的run()方法；
• 最后调用s的__exit__()方法。

运行一下，查看打印的内容：

enter
run
exit
type: <type 'type'> arg: <type 'exceptions.ZeroDivisionError'>
type: <type 'exceptions.ZeroDivisionError'> arg: integer division or modulo by zero
type: <type 'traceback'> arg: <traceback object at 0x05617B70>

可以看到，当捕获到异常时，__exit__()中传入的三个参数分别是异常类型，异常对象，异常跟踪。如果没有捕获到异常，那么这三个参数都是None。