Python学习笔记（一）

1.十六进制用ox；（十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2）

2.10用e替代；（1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5）

3.Python2 中print可以直接接字符串或者运算。

Python3 中print变成了一个函数，必须用一个括号括起来，否则会报告语法错误。

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出。



4.加注释：# -*- coding:utf-8 -*

5.在Python程序中，变量是用一个变量名表示，变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头。

6.当我们写：a = 'ABC'时，Python解释器干了两件事情：

1）在内存中创建了一个'ABC'的字符串；

2）在内存中创建了一个名为a的变量，并把它指向'ABC'。

7.代码：

a = 'ABC'

b = a

a = 'XYZ'

print b







8.如果字符串本身包含'怎么办？比如我们要表示字符串 I'm OK ，这时，可以用" "括起来表示："I'm OK"

类似的，如果字符串包含"，我们就可以用' '括起来表示：'Learn "Python" in imooc'

如果字符串既包含'又包含"怎么办？这个时候，就需要对字符串的某些特殊字符进行“转义”，Python字符串用\进行转义。

9.如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：r'\(~_~)/ \(~_~)/'

10.如果要表示多行字符串，可以用'''...'''表示：

'''Line 1

Line 2

Line 3'''

11.(1)Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

(2)需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推，例如，L[0]。使用索引时，千万注意不要越界。

我们可以用 -1 这个索引来表示最后一个元素，即L[-1]。

(3)添加新元素:1） append() 方法：例如， L.append('Paul')。append()总是把新的元素添加到 list 的尾部。

                           2） insert()方法它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：例如，L.insert(0, 'Paul')。

(4)从list删除元素：pop()方法:L.pop() 总是删掉list的最后一个元素，并且它还返回这个元素。L.pop(2)删除索引为2的元素。

(5)替换元素:例如，L[2] = 'Paul'

12.(1)tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

(2)创建tuple和创建list唯一不同之处是用( )替代了[ ]。

(3)tuple没有 append()方法，也没有insert()和pop()方法。

(4)包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：t = ()。

(5) Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：t = (1,)

13.注意: Python代码的缩进规则。缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

14.list或tuple可以表示一个有序集合。

15.reak是结束整个循环体，continue是结束单次循环。

16.(1)dict就是通过 key 来查找 value。花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

(2)由于dict也是集合，len() 函数可以计算任意集合的大小。

(3)dict本身提供的一个 get 方法，在Key不存在的时候，返回None。

例如，>>> print d.get('Bart')

59

>>> print d.get('Paul')

None

(4)dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

(5)dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

(6)由于dict是按 key 查找，所以，在一个dict中，key不能重复。

(7)dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。

(8)但是list是可变的，就不能作为 dict的key。不可变这个限制仅作用于key，value是否可变无所谓。

(9)更新dict : ict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：

d = {

    'Adam': 95,

    'Lisa': 85,

    'Bart': 59

}

要把新同学'Paul'的成绩 72 加进去，用赋值语句：

>>> d['Paul'] = 72

(10)由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过 for 循环实现。

直接使用for循环可以遍历 dict 的 key：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

>>> for key in d:

...     print key

... 

Lisa

Adam

Bart

17.set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

>>> s = set(['A', 'B', 'C'])

可以查看 set 的内容：

>>> print s

set(['A', 'C', 'B'])

请注意，上述打印的形式类似 list， 但它不是 list，仔细看还可以发现，打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。

因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？

>>> s = set(['A', 'B', 'C', 'C'])

>>> print s

set(['A', 'C', 'B'])

>>> len(s)

3

结果显示，set会自动去掉重复的元素，原来的list有4个元素，但set只有3个元素。

18.由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。

例如，存储了班里同学名字的set：

>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])

我们可以用 in 操作符判断：

Bart是该班的同学吗？

>>> 'Bart' in s

True

Bill是该班的同学吗？

>>> 'Bill' in s

False

bart是该班的同学吗？

>>> 'bart' in s

False

看来大小写很重要，'Bart' 和 'bart'被认为是两个不同的元素。

19.set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

20.添加元素时，用set的add()方法：

>>> s = set([1, 2, 3])

>>> s.add(4)

>>> print s

set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

>>> s = set([1, 2, 3])

>>> s.add(3)

>>> print s

set([1, 2, 3])

删除set中的元素时，用set的remove()方法：

>>> s = set([1, 2, 3, 4])

>>> s.remove(4)

>>> print s

set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

>>> s = set([1, 2, 3])

>>> s.remove(4)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 4

所以用add()可以直接添加，而remove()前需要判断。

21.在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。return None可以简写为return。

22.返回多值:函数可以返回多个值吗？答案是肯定的。

>>> x, y = move(100, 100, 60, math.pi / 6)

>>> print x, y

151.961524227 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

>>> r = move(100, 100, 60, math.pi / 6)

>>> print r

(151.96152422706632, 70.0)

用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

23.使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

24.假设计算平方的次数最多，我们就可以把 n 的默认值设定为 2：

def power(x, n=2):

    s = 1

    while n > 0:

        n = n - 1

        s = s * x

    return s

这样一来，计算平方就不需要传入两个参数了：

>>> power(5)

由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：

25.定义可变参数:如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):

    print args

可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：

26.对list进行切片:例如，L[0:3]，如果第一个索引是0，还可以省略：L[:3]。

只用一个 : ，表示从头到尾：L[:]

切片操作还可以指定第三个参数： L[::2] ，第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。

27.把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

28.倒序切片：

利用倒序切片对 1 - 100 的数列取出：

* 最后10个数；

* 最后10个5的倍数。

L = range(1, 101)

print L[-10:]

print L[-46::5]

29.对字符串切片：

>>> 'ABCDEFG'[:3]

'ABC'

>>> 'ABCDEFG'[-3:]

'EFG'

>>> 'ABCDEFG'[::2]

'ACEG'

30.注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：

1. 有序集合：list，tuple，str和unicode；

2. 无序集合：set

3. 无序集合并且具有 key-value 对：dict

31.Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？

方法是使用 enumerate() 函数：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> for index, name in enumerate(L):

...     print index, '-', name

... 

0 - Adam

1 - Lisa

2 - Bart

3 - Paul

32.dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

print d.values()

# [85, 95, 59]

for v in d.values():

    print v

# 85

# 95

# 59

33.>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

>>> print d.items()

[('Lisa', 85), ('Adam', 95), ('Bart', 59)]

可以看到，items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

>>> for key, value in d.items():

...     print key, ':', value

... 

Lisa : 85

Adam : 95

Bart : 59

34.生成列表

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：

>>> range(1, 11)

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

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？方法一是循环：

>>> L = []

>>> for x in range(1, 11):

...    L.append(x * x)

... 

>>> L

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：

>>> [x * x for x in range(1, 11)]

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

35.复杂表达式

假设有如下的dict：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

完全可以通过一个复杂的列表生成式把它变成一个 HTML 表格：

tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]

print '<table>'

print '<tr><th>Name</th><th>Score</th><tr>'

print '\n'.join(tds)

print '</table>'

注：字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串。

把打印出来的结果保存为一个html文件，就可以在浏览器中看到效果了：

<table border="1">

<tr><th>Name</th><th>Score</th><tr>

<tr><td>Lisa</td><td>85</td></tr>

<tr><td>Adam</td><td>95</td></tr>

<tr><td>Bart</td><td>59</td></tr>

</table>

36.>>> [x * x for x in range(1, 11) if x % 2 == 0]

[4, 16, 36, 64, 100]

有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。