Python学习笔记
一、数据类型
1、整数 2、浮点数 3、字符串 4、布尔值 5、空值
二、print语句
链接 >>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog
三、raw字符串与多行字符串
print '\"To be, or not to be\": that is the question.\nWhether it\'s nobler in the mind to suffer.'
print r'''"To be, or not to be": that is the question.Whether it's nobler in the mind to suffer.'''
四、Unicode字符串
# -*- coding: utf-8 -*- print u'中文'
五、List（列表）的操作
定义：>>> classmates = ['Michael', 'Bob', 'Tracy'] print classmates
顺序访问：L = [95.5,85,59,59] print L[0] 95.5
倒序访问：L = [95.5,85,59] print L[-1] 59
添加：1、append（）方法，追加到list的末尾
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>> print L
['Adam', 'Lisa', 'Bart', 'Paul']
2、insert（）方法，可以最近到指定地点
>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']
删除：1、pop（）方法默认从list尾部删除一个元素
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']
2、>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']
>>> L.pop(2)
'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']
替换：>>> L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
L = ['Adam', 'Lisa', 'Paul']
六、创建tuple（元组）
tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
创建tuple和创建list唯一不同之处是用( )替代了[ ]，其他操作基本都一致。
单元素tuple为了避免歧义，规定定义 >>> t = (1,) >>> print t (1,)
可变tuple >>> t = ('a', 'b', ['A', 'B']) 注意到 t 有 3 个元素：'a'，'b'和一个
list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：>>> L = t[2]
七、if语句
Python代码的缩进非常严格，具有相同缩进的代码被视为代码块，
缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
if 语句后接表达式，然后用:表示代码块开始。
如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车：
age = 20
if age >= 18:
print 'your age is', age
print 'adult'
print 'END'
If-else语句
if age >= 18:
print 'adult'
else:
print 'teenager'
If-elif-else语句
score = 85
if score>=90:
print 'excellent'
elif score>=80:
print 'good'
elif score>=60:
print 'passed'
else:
print 'failed'
八、for循环
L = [75, 92, 59, 68]
sum = 0.0
for score in L:
sum = sum + score
print sum / 4
九、while循环
和 for 循环不同的另一种循环是 while 循环，while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。
利用while循环计算100以内奇数的和
sum = 0
x = 1
while x < 100:
sum = sum + x
x = x + 2
print sum
十、break退出循环
用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。
利用 while True 无限循环配合 break 语句，计算 1 + 2 + 4 + 8 + 16 + ... 的前20项的和。
sum = 0
x = 1
n = 1
while True:
sum = sum + x
x = x * 2
n = n + 1
if n > 20:
break
print sum
十一、Continue
对已有的计算 0 - 100 的while循环进行改造，通过增加 continue 语句，使得只计算奇数的和：
sum = 0
x = 0
while True:
x = x + 1
if x > 100:
break
if x % 2 == 0:
continue
sum = sum + x
print sum
十二、多重循环
对100以内的两位数，请使用一个两重循环打印出所有十位数数字比个位数数字小的数，例如，23（2 < 3）
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
for y in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
if x < y:
print x * 10 + y
十三、Dict
我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。
由于dict也是集合，len() 函数可以计算任意集合的大小：
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
十四、访问dict
1、if 'Paul' in d:
print d['Paul'] 通过key访问，返回value值
2、通过dict本身提供的get方法
>>> print d.get('Bart')
59
>>> print d.get('Paul')
None 没有key值时，返回None
十五、dict的特点
1、查找速度快
无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
2、存储的key-value序对是没有顺序的
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
当我们试图打印这个dict时：
>>> print d
{'Lisa': 85, 'Adam': 95, 'Bart': 59}
打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。
3、作为 key 的元素必须不可变
Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
十六、更新dict
1、key值不同，新添加，用赋值语句：>>> d['Paul'] = 72
2、如果key值已有，则更新，覆盖原有
十七、遍历dict
d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59
}
for key in d:
print key + ':', d.get(key)
十八、Set
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
打印的顺序和原始 list 的顺序有可能是不同的，因为set内部存储的元素是无序的。
因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？
十九、访问set
由于set存储的是无序集合，所以我们没法通过索引来访问。
访问 set中的某个元素实际上就是判断一个元素是否在set中。
>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
>>> 'Bart' in s
True
>>> 'Bill' in s 大小写敏感
False
二十、set的特点
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
最后，set存储的元素也是没有顺序的。
months = set(['Jan','Feb','Mar','Apr','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
x1 = 'Feb'
x2 = 'Sun'
if x1 in months:
print 'x1: ok'
else:
print 'x1: error'
if x2 in months:
print 'x2: ok'
else:
print 'x2: error'
二十一、遍历set
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
print x[0] + ':', x[1]
Lisa: 85
Adam: 95
Bart: 59
二十二、更新set
1、添加新的元素
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])
2、删除set中的元素 如果删除的元素不存在set中，remove()会报错：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])
二十三、函数
写一次，多次调用
调用函数 绝对值的函数 abs
比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1
int()函数可以把其他数据类型转换为整数
str()函数把其他类型转换成 str
sum()函数接受一个list作为参数，并返回list所有元素之和。请计算 1*1 + 2*2 + 3*3 + ... + 100*100。
L = []
x = 1
while x <= 100:
L.append(x * x)
x = x + 1
print sum(L)
二十四、编写函数
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
请定义一个 square_of_sum 函数，它接受一个list，返回list中每个元素平方的和
def square_of_sum(L):
sum = 0
for x in L:
sum = sum + x * x
return sum
print square_of_sum([1, 2, 3, 4, 5])
print square_of_sum([-5, 0, 5, 15, 25])
返回多值
用print打印返回结果，原来返回值是一个tuple！
但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起
来更方便。一元二次方程的定义是：ax2 + bx + c = 0
请编写一个函数，返回一元二次方程的两个解。
注意：Python的math包提供了sqrt()函数用于计算平方根。
import math
def quadratic_equation(a, b, c):
t = math.sqrt(b * b - 4 * a * c)
return (-b + t) / (2 * a),( -b - t )/ (2 * a)
print quadratic_equation(2, 3, 0)
print quadratic_equation(1, -6, 5)
二十五、递归函数
汉诺塔 (http://baike.baidu.com/view/191666.htm) 的移动也可以看做是递归函数。
我们对柱子编号为a, b, c，将所有圆盘从a移到c可以描述为：
如果a只有一个圆盘，可以直接移动到c；
如果a有N个圆盘，可以看成a有1个圆盘（底盘） + (N-1)个圆盘，首先需要把 (N-1) 个圆盘移动到 b，然后，将 a的最后一个圆盘移动到c，再将b的(N-1)个圆盘移动到c。
请编写一个函数，给定输入 n, a, b, c，打印出移动的步骤：
move(n, a, b, c)
例如，输入 move(2, 'A', 'B', 'C')，打印出：
A --> B
A --> C
def move(n, a, b, c):
if n == 1:
print a,'-->',c
return
move(n-1,a,c,b)
print a,'-->',c
move(n-1,b,a,c)
move(4, 'A', 'B', 'C')
B --> C
定义默认参数
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
# OK:
def fn1(a, b=1, c=2):
pass
# Error:
def fn2(a=1, b):
Pass
def greet(name='world'):
print 'Hello,' + name + '.'
greet()
greet('Bart')
Hello,world.
Hello,Bart.
定义可变参数
可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
可变参数 args 是一个tuple，当0个参数传入时，args是一个空tuple。
参考代码:
def average(*args):
sum = 0.0
if len(args) == 0:
return sum
for x in args:
sum = sum + x
return sum / len(args)
print average()
print average(1, 2)
print average(1, 2, 2, 3, 4)
二十六、对list进行切片Slice
取前3个元素，用一行代码就可以完成切片：
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
只用一个 : ，表示从头到尾：
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
请利用切片，取出：
1. 前10个数；
2. 3的倍数；
3. 不大于50的5的倍数。
L = range(1, 101)
print L[:10]
print L[2::3]
print L[4:50:5]
倒序切片
5的倍数可以用 ::5 取出，要确定起始索引。
参考代码:
L = range(1, 101)
print L[-10:]
print L[-46::5]
二十七、对字符串切片
但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。
def firstCharUpper(s):
return s[0].upper() + s[1:]
print firstCharUpper('hello')
print firstCharUpper('sunday')
print firstCharUpper('september')
Hello
Sunday
September
二十八、迭代
因为 Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。
因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。
注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict
而迭代是一个动词，它指的是一种操作，在Python中，就是 for 循环。
迭代与按下标访问数组最大的不同是，后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。
请用for循环迭代数列 1-100 并打印出7的倍数。
for i in range(1,101):
if i % 7 == 0:
print i
