python 慕课课程笔记（一）

python 慕课课程笔记

1.python 是动态语言，而 java 是静态语言。动态语言变量本身的类型时不固定的，而静态语言在变量定义时就必须指定变量的类别。
2. 在python 代码中书写 $a =“ABC"$ 时，Python解释器干了两件事情：

1.在内存中创建了一个“ABC”的字符串
2.在内存中创建了一个名为 a 的变量，并把它指向“ABC”

所以在之后进行 $b=a$ 的赋值操作时，b会指向a指向的这个字符串。
3.关于 python 中的字符串表示：

1. $r 'abc'$这种形式，可以不用转义，但不能表示多行和带 ‘’“”的字符创。
2. $''' abc '''$ 这种形式，可以表示多行
3. $r ''' abc '''$这种形式兼具以上两者的功能

4.python 到后来改成 unicode 编码后，可以支持中文的书写。不过形式如下：

$u'中文'$；搭配 r 可以这么使用: $ur''' \^-^/ '''$

5.在 python 编译器中遇到 UnicodeDecodeError 的时候，可以在代码开头加上如下的注释：

# -*- coding: utf-8 -*-

目的是告诉 python 编译器用 UTF-8 编码读取代码。
6.python 中的除法 $/$ 同样为整除。
7.python 中有两个布尔型的变量，True 和 False ，并且它们之间有与(and)、或(or)、非(not)三种运算。
8.python 中的空值处理：python 中将 0，空字符串 $'\ '$，和 None 看做 False，而其他数值和非空字符串则看成 True。
9.python 中的短路规则：

表达式\条件	a==True	a==False
a and b	返回 b	返回 a
a or b	返回 a	返回 b

---

所以在计算的时候，往往采取短路规则，并不是全部计算完毕后才返回结果。
10.python 中的几个基本数据结构：

list 列表 [ ]

• 数学意义上的有序结合。
• 可以使用索引来进行引用 eg. L[1]。 并且 python 中也有倒叙索引，从-1 开始。不管是正序索引还是倒序，都要注意不要越界。
• 列表的插入有两个方法 append() 和 insert()。前者只有一个参数，是插入表尾；后者有两个参数，可以指定插入的位置，第一个参数是索引号。
  eg. append('Xiaoming') insert(0, 'Xiaoming')
• 列表删除元素用 pop()。
  eg. pop(2) 参数是索引号。注意先大后小的原则，避免元素删除造成顺序改变。

tuple 元组 ( )

• 元组也是一种有序的列表，与 list 很类似，但一旦创建完毕，就不能修改了。
• 没有 list 中的 pop,append,insert 方法。
• 获取元素的方法与 list 是一样的。
• 创建单元素 tuple 时，为避免歧义，要这么定义：
  eg. t=(1,) // 不能漏掉这个逗号
• tuple 的不变性是指向的不变，并不是元素内容的不变。
  eg. tuple 的一个元素是一个 list

11.循环控制

• python 缩进最好使用 4个空格，而不用 Tab 键。
• 交互式环境中敲代码要注意缩进问题，退出缩进要多敲一行回车。
• python 中的多条件 if 语句，用的是 elif
• for 循环用于遍历 list, tuple 十分方便，
  eg. for name in L 其中 name 是在 for 循环中定义的，意思是取得 L 的每个元素赋值给 name。

12.python 中的特殊数据结构：

dict 词典 { }

• 词典是一个 key:value 的映射
• len() 函数可以计算任意集合的大小
• 可以通过 d[key] 的方式来查找 value
• 可以用 in 操作符来看看键是否在词典中
  eg. if 'Paul' in d:
• dict 本身也提供一个 get 方法，如果键不存在则返回 None
  eg. d.get('Paul')
• dict 有三个特点
  
  • 查找速度快，占用内存多（与 list 相反）。
  • key 不能重复，key:value 对的顺序是随意的。且 dict 内部是无序的，有随机性。
  • 作为 key 的元素不可变。
• 直接使用 for 循环可以便利词典的 key:
  eg. for key in d: 这样在循环体中就可以取得 相应的 value。

set 集合 ( )

• set 的元素是无序的，而且没有重复。
• 创建 set 的方法是调用 set()，并传入一个 list，list 的元素将作为 set 的元素。
  eg. set=(['xiaoming','aiping','meijuan'])
• 访问：因为是无序的，所以无法用索引访问，但可以用 in 操作符判断是否在 set 中。
• set 的作用特点有点类似于枚举器。 numerator。
• set 的更新操作有两个函数：add() 和 remove()，其参数可以直接是相应的元素。一般后者操作前，一般需要加一个判断，以看元素是否在 set 中。

12.python [内置函数查询]；并且可以通过 help() 命令来查询函数的帮助信息。
13.python 中的函数内部的 return 会使函数立即执行完毕，并返回结果。如果没有 return 语句，函数也会返回结果，不过结果为 None。

return None 可以简写为 return

14.python 函数可以返回多个值，实则是返回一个 tuple。因为语法上，返回 tuple 可以不加括号，所以多个变量可以同时接收一个 tuple，并按位置赋给相应的变量。
15.python 中的递归函数：

1.递归函数定义简单，逻辑清晰。理论上所有的递归函数都可以写成循环的形式。
2.使用递归函数要防止栈溢出。因为：计算机中函数调用是通过 stack 实现的；每进入一个函数，栈就会加一层栈帧；每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出。

16.python 中的默认参数：

1.默认参数的作用是简化调用。
eg.python 自带的 int() 函数就有两个参数，如果如下所示的形式：
int('123',8) 则第二个参数指的是规定的进制。
2.由于函数参数按从左到右的顺序匹配，所以默认参数只能定义在必要参数的后面。
def fn1(a,b=1,c=2)——正确
def fn2(a=1,b)——-错误

17.python 中如果想让一个函数接收任意数量的参数，那么就可以定义一个可变参数，其形式如下：

def fn(*args)
    print args

只需要在参数前加一个*，我们就可以给可变参数传入0个，1个或多个参数。其实原理同返回多个参数相同，python 将这多个参数组合成一个 tuple 传给可变参数。其目的一般也是为了简化调用。
18.python 中的切片操作：

1.取前 n 个元素，一般可用循环来做： for i in range(n)
2.为避免使用循环，对于这种指定索引范围的操作，python 提供了切片（slice）操作。
eg. L[0:3] 表示从索引 0 开始取，直到索引 3 为止，不包括索引 3。即索引 0，1，2，刚好 3 个元素。
3. 几种情况：

• 第一个索引为 0 时，可以省略 L[:3]
• > 只用一个 ： 表示从头到尾 L[:]
• 切片操作还可定义第 3 个参数，表示取数的间隔。L[2::3] 表示的就是取 3 的倍数位置的元素。

4.range 函数可以创建一个数列
eg. range(1:101) 得到的是一个列表 [1,2,3,4,…,100]
5.python 也支持倒序切片。
6.python 没有提供字符串截取函数，但用切片可以进行同类的操作。

19.python 中的迭代：

1.我们可以通过 for 循环来遍历 list 或 tuple，这种遍历操作我们成为迭代。
2.python for 的迭代对象，是一个集合，不管它有序无序，总是可以依次取得该集合中的每一个元素。
3.迭代与按下标访问的不同之处在于，后者是一种具体的迭代实现方式，而前者只关心迭代的结果，并不关心迭代内部是如何实现的。
4.索引迭代：python 中往往都是取出元素的索引，而非元素本身，所以要想取出索引，可以使用 enumerate() 函数，它返回的每个元素实际是一个元组，包含两个元素分别为索引和真正的元素。
它的结构为： [(0,'xiaoming'),(1,'xiaocao')]
具体操作为：for index, name in enumerate(L)
5.zip 函数可以将两个 list 合并为 1个，组合形式类似于 enumerate() 函数的形式，一个典型的代码为：
for index, name in zip(range(1, len(L)+1), L)

---

Note: 集合是包含一组元素的数据结构，它包括：
1.有序的集合：list tuple str unicode
2.无序的集合：set
3.无序的集合，并且有 key-value 对：dict

20.关于 dict 的迭代：

1.直接迭代 dict，取得的是 dict 的 key。
2.运用 values() 或者 itervalues() 函数进行迭代，可以取得 dict 的 value。
eg. for v in d.itervalues():
eg. for v in d.values():
3.以上的两个函数迭代结果是一样的，但是实际机制是不同的。
values() 方法是将 dict 转化为只包含 value 的 list
itervalues() 方法是一次从 dict 中取出 value，所以节省了 list 的内存
4.如果一个对象可以迭代，那么用 for 循环去迭代即可。可见 python 中的迭代是一种更抽象的操作，它不对迭代对象内部的数据有任何的要求。
5.如果运用 items() 函数的话，可以同时迭代 dict 的 key 与 value。此外也有相应的 iteritems()，区别同前。
eg.for key，value in d.items():

21.python 生成列表：

1.列表生成式用于在不用循环的情况下，生成 list
eg.[x * x for x in range(1, 11)]
其结果为：[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2.包含 dict 的复杂生成列表：
eg. 用复杂生成列表生成 html 表格：
d = { ‘Adam’: 95, ‘Lisa’: 85, ‘Bart’: 59 }

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 拼接成一个字符串。`这里写代码片`

我们还可以用一个函数来替换字符串的格式化代码，这样逻辑更清晰。

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

在此基础上我们可以结合 html 代码的特点，添加相应的格式控制，如下实例:

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def generate_tr(name, score):
    if score < 60:
        return '<tr><td>%s</td><td style="color:red">%s</td></tr>' % (name, score)
    return '<tr><td>%s</td><td>%s</td></tr>' % (name, score)
tds = [generate_tr(name, score) for name, score in d.iteritems()]
print '<table border="1">'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'

3.带条件的复杂生成类表：如下示例：

def toUppers(L):
    return [x.upper() for x in L if isinstance(x, str)]
print toUppers(['Hello', 'world', 101])

添加 if 语句即可，并且 isinstance(x,str) 是用来判断 x 是否是字符串。

4.多层表达式
for 循环是可以嵌套的，所以如下示例：
print [100 * n1 + 10 * n2 + n3 for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) if n1==n3]
输出的就是1000以内，个位数和百位数字相等的三位数。