本文是廖雪峰教程学习记录，廖雪峰链接：http://blog.csdn.net/GarfieldEr007/article/details/52422494?locationNum=1&fps=1
range、raw_input、list、tuple、dict、set、
一、列表：list
>>> fruit
['apple', 'pear', 'banana']
>>> len(fruit)
3
列表的索引可以是0,1,2；也可以是倒着数-1，-2，-3
>>> fruit[1]
'pear'
>>> fruit[-1]
'banana'
列表的添加、插入、删除元素
>>> fruit.append('grape')#添加到末尾
>>> fruit
['apple', 'pear', 'banana', 'grape']
>>> fruit.insert(1,'tomato')#某个索引处插入
>>> fruit
['apple', 'tomato', 'pear', 'banana', 'grape']
>>> fruit.pop()#移除末尾元素
'grape'
>>> fruit
['apple', 'tomato', 'pear', 'banana']
>>> fruit.pop(1) #移除某索引元素
'tomato'
>>> fruit
['apple', 'pear', 'banana']
>>> fruit[1]='hello'#替换某索引处元素
>>> fruit
['apple', 'hello', 'banana']
元素也可以是列表，使用类似于数组；
元素可以是不同数据类型；
列表可以是空；
二、另一种列表：元组tuple
tuple和list类似，但是tuple一旦初始化就不能修改，读取元素的方法一样：
>>> fruit=('apple','pear','banana')
>>> fruit
('apple', 'pear', 'banana')
>>> fruit[0]
'apple'
>>>
>>> fruit[-1]
'banana'
>>> fruit=(1)
>>> fruit
1
定义只有一个元素的tuple时，() 既可以表示tuple，又可以表示数学公式中的小括号，这就产生了 歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是 1 。
所以，只有1个元素的tuple定义时必须加一个逗号 , ，来消除歧义：
>>> fruit=(1)
>>> fruit
1
>>> fruit=(1,)
>>> fruit
(1,)
一个特殊的可变的tuple：
>>> t=('a','b',['A','B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向
的list并没有改成 别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指
向 'a' ，就不能改成指向 'b' ，指 向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
三、条件判断
if xxx:
do sth2
elif yyy:
do sth2
else:
do sth3
四、循环
for……in……循环
sum=0
range(5)
for i in range(5):
sum=sum+i
print sum
for i in [1,2,3,4,5]: \
print i
while 循环
sum=0
n=100
while n > 0:
sum=sum+n
n=n-1
print sum
从 raw_input() 读取的内容永远以字符串的形式返回，把字符串和整数比较就不会得到期待的结 果，必须先用 int() 把字符串转换为我们想要的整型。
故若要用raw_input输入，需把类型转化为整型
birth=int(raw_input('birth:'))
if birth < 2000:
print u'00前'
else:
print u'00后'
五、dict
字典dictionary，可按照key-value的形式存储，实现快速查找
>>> score = {'AA':100,'BB':99,'CC':98}
>>> score['BB']
99
>>> score
{'AA': 100, 'CC': 98, 'BB': 99} #，dict内部存放的顺序和key放入的顺序是没有关系的
>>> score['BB']=88 #可通过key修改value值
>>> score
{'AA': 100, 'CC': 98, 'BB': 88}
判断key值是否在dict中有两种方法：
>>> 'BB' in score#方法一
True
>>> 'DD' in score
False
方法二：是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value
>>> score.get('DD')
>>>
>>> score.get('BB')
88
>>> score.get('DD',-1)
-1
可通过pop来移除元素
>>> score.pop('BB')
88
>>> score
{'AA': 100, 'CC': 98}
六、set
set和dict类似，也是一组key的集合，但不存储value，set中没有重复的key。
>>> s=set([1,2,3])
>>> s
set([1, 2, 3])
>>>
>>> s=set([1,1,2,2,3,3]) #set没有重复元素
>>> s
set([1, 2, 3])
>>> s.add(4) #给set加元素
>>> s
set([1, 2, 3, 4])
>>> s.remove(4) #删除set元素
>>> s
set([1, 2, 3])
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
>>> s=set([1,2,3])
>>> s2=set([2,3,4])
>>> s & s2
set([2, 3])
>>>
>>> s | s2
set([1, 2, 3, 4])
七、不可变对象
字符串是不可变对象，list是可变对象。dict和set的key只能是不可变对象。
>>> a=['a','b','c']
>>> a
['a', 'b', 'c'] #list的内容可变
>>> a.sort()
>>> a
['a', 'b', 'c']
>>> d='abc'
>>> d.replace('a','A') #变量d指向的对象仍是abc未变，replace创建了个新的对象Abc
'Abc'
>>> a
['a', 'b', 'c']
八、xxx
可通过help（函数名）查看函数
abs（a）绝对值
cmp（a，b）
数据类型转换
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> unicode(100)
u'100'
>>> bool(1)
True
>>> bool('')
False
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
九、自定义函数
①定义函数
def my_abs(x): #def fun_name(argument)
if not isinstance(x, (int, float)): #数据类型检查函数isinstance
raiseTypeError('bad operand type')
if x >= 0:
return x#一旦执行到return时，函数即返回
else:
return -x
定义一个什么都不做的函数
def nop():
pass#pass语句什么都不做
②函数返回多个值
import math
def move(x,y,step,angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx,ny
x,y = move(100, 100, 60, math.pi/6)
r = move(100, 100, 60, math.pi/6)
print x,y
print r
输出结果为：
151.961524227 70.0
(151.96152422706632, 70.0) #可看出返回的实际是个tuple，实际返回值只有一个
③函数参数
一）默认参数
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
该函数定义了x的n次方的函数，使用时可power(5,3)，但因x的平时使用比较多，n取默
认值2，当power(5)时，默认计算5的平方。
默认参数可简化函数调用。但：
（一）默认参数需放在必选参数后面；
（二）当有多个默认参数而其中某个要赋值时时，如F(a,b,c=xx,d=yy)调用时可F(A,B,C)或F(A,B,d=zz)；
（三）默认参数必须指向不变对象。
eg:
定义了一个函数
def add_end(L=[]):
L.append('END')
return L
当在Python交互命令行调用add_end()函数时，每次执行结果不一样
>>> import a#在cmd里执行文件中定义的函数：①import mypy
>>> a.add_end() #②mypy.funname(xxx)
['END']
>>> a.add_end()
['END', 'END']
>>> a.add_end()
['END', 'END', 'END']
Python函数在定义的时候，默认参数 L 的值就被计算出来了，即 [] ，因为默认参数 L 也是一个变量，
它指向对 象 [] ，每次调用该函数，如果改变了 L 的内容，则下次调用时，默认参数的内容就变了，
不再是函数定义时 的 [] 了。
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
可用None这个不变对象来修改上面函数：
def add_end(L=None):
if L is None:
L=[]
L.append('END')
return L
二）个数可变参数
def calc(*num): #在参数num前加一个*号，即可传入任意个参数，包括0个
sum=0
for n in num:
sum=sum+n*n
return sum
调用时
>>> import a
>>> a.calc(1,2,3)
14
>>> a.calc()
0
若是已有一个list：number=[1,2,3]或tuple，想调用参数可变函数时，可以calc(*number)，把元素变成可变参数传进去；
若num前无*号，可以通过list或tuple传参，calc([1,2,3])或calc((1,2,3))；
三）关键字参数
可变参数允许传入0或任意个参数，这些可变参数在调用时自动组装成一个tuple。
关键字参数允许传入0或人一个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict。
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other', kw
>>> import a
>>> a.person('Jim',30)
name: Jim age: 30 other {}
>>> a.person('Jim',30,city='beijing')
name: Jim age: 30 other {'city': 'beijing'}
>>> a.person('Jim',30,city='beijing',gender='M')
name: Jim age: 30 other {'city': 'beijing', 'gender': 'M'}
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
>>> a.person('Jack',24, **hello)#简单
name: Jack age: 24 other {'city': 'nanjing', 'job': 'Engineer'}
>>> a.person('Jack',24, city=hello['city'], job=hello['job'])#麻烦
name: Jack age: 24 other {'city': 'nanjing', 'job': 'Engineer'}
四）参数组合
必选参数、默认参数、可变参数、关键字参数可任意组合，但必须
注意
顺序：必选参数、默认参数、可变参数、关键字参数
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
>>> import a
>>> a.func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> a.func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> a.func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> a.func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
神奇的是通过一个tuple和dict，也可以调用该函数：
>>> args=(1,2,3,4)
>>> kw={'x': 99}
>>> a.func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
①默认参数必须用不可变对象；
②*args是可变参数，args接收的是一个tuple；**kw是关键字参数，kw接收的是一个dict；
③可变参数既可以直接传入：func(1,2,3)，也可以先组装list或tuple，再通过*args传入：func(*(1,2,3));
关键字参数既可以直接传入：func(a=1,b=2)，又可以先组装dict，再通过**kw传入：func(**{'a':1,'b':2});
十、递归函数
在函数内部调用函数本身
eg:阶乘n! = 1 x 2 x 3 x ... x n ，用函数 fact(n) 表示；
可知fact(n)=fact(n-1)*n，
用递归方式写出来就是：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
每当进入一个 函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不
是无限的，所以，递归调用的 次数过多，会导致栈溢出。
在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，，使递归本身无论调
用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact(n):
return fact_tmp(n,1)
def fact_tmp(num, tmp):
if num == 1:
return tmp
return fact_tmp(num-1, num*tmp)
http://blog.csdn.net/GarfieldEr007/article/details/52422494?locationNum=1&fps=1
range、raw_input、list、tuple、dict、set、
一、列表：list
>>> fruit
['apple', 'pear', 'banana']
>>> len(fruit)
3
列表的索引可以是0,1,2；也可以是倒着数-1，-2，-3
>>> fruit[1]
'pear'
>>> fruit[-1]
'banana'
列表的添加、插入、删除元素
>>> fruit.append('grape')#添加到末尾
>>> fruit
['apple', 'pear', 'banana', 'grape']
>>> fruit.insert(1,'tomato')#某个索引处插入
>>> fruit
['apple', 'tomato', 'pear', 'banana', 'grape']
>>> fruit.pop()#移除末尾元素
'grape'
>>> fruit
['apple', 'tomato', 'pear', 'banana']
>>> fruit.pop(1) #移除某索引元素
'tomato'
>>> fruit
['apple', 'pear', 'banana']
>>> fruit[1]='hello'#替换某索引处元素
>>> fruit
['apple', 'hello', 'banana']
元素也可以是列表，使用类似于数组；
元素可以是不同数据类型；
列表可以是空；
二、另一种列表：元组tuple
tuple和list类似，但是tuple一旦初始化就不能修改，读取元素的方法一样：
>>> fruit=('apple','pear','banana')
>>> fruit
('apple', 'pear', 'banana')
>>> fruit[0]
'apple'
>>>
>>> fruit[-1]
'banana'
>>> fruit=(1)
>>> fruit
1
定义只有一个元素的tuple时，() 既可以表示tuple，又可以表示数学公式中的小括号，这就产生了 歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是 1 。
所以，只有1个元素的tuple定义时必须加一个逗号 , ，来消除歧义：
>>> fruit=(1)
>>> fruit
1
>>> fruit=(1,)
>>> fruit
(1,)
一个特殊的可变的tuple：
>>> t=('a','b',['A','B'])
>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向
的list并没有改成 别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指
向 'a' ，就不能改成指向 'b' ，指 向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
三、条件判断
if xxx:
do sth2
elif yyy:
do sth2
else:
do sth3
四、循环
for……in……循环
sum=0
range(5)
for i in range(5):
sum=sum+i
print sum
for i in [1,2,3,4,5]: \
print i
while 循环
sum=0
n=100
while n > 0:
sum=sum+n
n=n-1
print sum
从 raw_input() 读取的内容永远以字符串的形式返回，把字符串和整数比较就不会得到期待的结 果，必须先用 int() 把字符串转换为我们想要的整型。
故若要用raw_input输入，需把类型转化为整型
birth=int(raw_input('birth:'))
if birth < 2000:
print u'00前'
else:
print u'00后'
五、dict
字典dictionary，可按照key-value的形式存储，实现快速查找
>>> score = {'AA':100,'BB':99,'CC':98}
>>> score['BB']
99
>>> score
{'AA': 100, 'CC': 98, 'BB': 99} #，dict内部存放的顺序和key放入的顺序是没有关系的
>>> score['BB']=88 #可通过key修改value值
>>> score
{'AA': 100, 'CC': 98, 'BB': 88}
判断key值是否在dict中有两种方法：
>>> 'BB' in score#方法一
True
>>> 'DD' in score
False
方法二：是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value
>>> score.get('DD')
>>>
>>> score.get('BB')
88
>>> score.get('DD',-1)
-1
可通过pop来移除元素
>>> score.pop('BB')
88
>>> score
{'AA': 100, 'CC': 98}
六、set
set和dict类似，也是一组key的集合，但不存储value，set中没有重复的key。
>>> s=set([1,2,3])
>>> s
set([1, 2, 3])
>>>
>>> s=set([1,1,2,2,3,3]) #set没有重复元素
>>> s
set([1, 2, 3])
>>> s.add(4) #给set加元素
>>> s
set([1, 2, 3, 4])
>>> s.remove(4) #删除set元素
>>> s
set([1, 2, 3])
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
>>> s=set([1,2,3])
>>> s2=set([2,3,4])
>>> s & s2
set([2, 3])
>>>
>>> s | s2
set([1, 2, 3, 4])
七、不可变对象
字符串是不可变对象，list是可变对象。dict和set的key只能是不可变对象。
>>> a=['a','b','c']
>>> a
['a', 'b', 'c'] #list的内容可变
>>> a.sort()
>>> a
['a', 'b', 'c']
>>> d='abc'
>>> d.replace('a','A') #变量d指向的对象仍是abc未变，replace创建了个新的对象Abc
'Abc'
>>> a
['a', 'b', 'c']
八、xxx
可通过help（函数名）查看函数
abs（a）绝对值
cmp（a，b）
数据类型转换
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> unicode(100)
u'100'
>>> bool(1)
True
>>> bool('')
False
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
九、自定义函数
①定义函数
def my_abs(x): #def fun_name(argument)
if not isinstance(x, (int, float)): #数据类型检查函数isinstance
raiseTypeError('bad operand type')
if x >= 0:
return x#一旦执行到return时，函数即返回
else:
return -x
定义一个什么都不做的函数
def nop():
pass#pass语句什么都不做
②函数返回多个值
import math
def move(x,y,step,angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx,ny
x,y = move(100, 100, 60, math.pi/6)
r = move(100, 100, 60, math.pi/6)
print x,y
print r
输出结果为：
151.961524227 70.0
(151.96152422706632, 70.0) #可看出返回的实际是个tuple，实际返回值只有一个
③函数参数
一）默认参数
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
该函数定义了x的n次方的函数，使用时可power(5,3)，但因x的平时使用比较多，n取默
认值2，当power(5)时，默认计算5的平方。
默认参数可简化函数调用。但：
（一）默认参数需放在必选参数后面；
（二）当有多个默认参数而其中某个要赋值时时，如F(a,b,c=xx,d=yy)调用时可F(A,B,C)或F(A,B,d=zz)；
（三）默认参数必须指向不变对象。
eg:
定义了一个函数
def add_end(L=[]):
L.append('END')
return L
当在Python交互命令行调用add_end()函数时，每次执行结果不一样
>>> import a#在cmd里执行文件中定义的函数：①import mypy
>>> a.add_end() #②mypy.funname(xxx)
['END']
>>> a.add_end()
['END', 'END']
>>> a.add_end()
['END', 'END', 'END']
Python函数在定义的时候，默认参数 L 的值就被计算出来了，即 [] ，因为默认参数 L 也是一个变量，
它指向对 象 [] ，每次调用该函数，如果改变了 L 的内容，则下次调用时，默认参数的内容就变了，
不再是函数定义时 的 [] 了。
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！
可用None这个不变对象来修改上面函数：
def add_end(L=None):
if L is None:
L=[]
L.append('END')
return L
二）个数可变参数
def calc(*num): #在参数num前加一个*号，即可传入任意个参数，包括0个
sum=0
for n in num:
sum=sum+n*n
return sum
调用时
>>> import a
>>> a.calc(1,2,3)
14
>>> a.calc()
0
若是已有一个list：number=[1,2,3]或tuple，想调用参数可变函数时，可以calc(*number)，把元素变成可变参数传进去；
若num前无*号，可以通过list或tuple传参，calc([1,2,3])或calc((1,2,3))；
三）关键字参数
可变参数允许传入0或任意个参数，这些可变参数在调用时自动组装成一个tuple。
关键字参数允许传入0或人一个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict。
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other', kw
>>> import a
>>> a.person('Jim',30)
name: Jim age: 30 other {}
>>> a.person('Jim',30,city='beijing')
name: Jim age: 30 other {'city': 'beijing'}
>>> a.person('Jim',30,city='beijing',gender='M')
name: Jim age: 30 other {'city': 'beijing', 'gender': 'M'}
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
>>> a.person('Jack',24, **hello)#简单
name: Jack age: 24 other {'city': 'nanjing', 'job': 'Engineer'}
>>> a.person('Jack',24, city=hello['city'], job=hello['job'])#麻烦
name: Jack age: 24 other {'city': 'nanjing', 'job': 'Engineer'}
四）参数组合
必选参数、默认参数、可变参数、关键字参数可任意组合，但必须
注意
顺序：必选参数、默认参数、可变参数、关键字参数
def func(a, b, c=0, *args, **kw):
print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
>>> import a
>>> a.func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> a.func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> a.func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> a.func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
神奇的是通过一个tuple和dict，也可以调用该函数：
>>> args=(1,2,3,4)
>>> kw={'x': 99}
>>> a.func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}
①默认参数必须用不可变对象；
②*args是可变参数，args接收的是一个tuple；**kw是关键字参数，kw接收的是一个dict；
③可变参数既可以直接传入：func(1,2,3)，也可以先组装list或tuple，再通过*args传入：func(*(1,2,3));
关键字参数既可以直接传入：func(a=1,b=2)，又可以先组装dict，再通过**kw传入：func(**{'a':1,'b':2});
十、递归函数
在函数内部调用函数本身
eg:阶乘n! = 1 x 2 x 3 x ... x n ，用函数 fact(n) 表示；
可知fact(n)=fact(n-1)*n，
用递归方式写出来就是：
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，
每当进入一个 函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不
是无限的，所以，递归调用的 次数过多，会导致栈溢出。
在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，，使递归本身无论调
用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
def fact(n):
return fact_tmp(n,1)
def fact_tmp(num, tmp):
if num == 1:
return tmp
return fact_tmp(num-1, num*tmp)
http://blog.csdn.net/GarfieldEr007/article/details/52422494?locationNum=1&fps=1
1647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
