本文是廖雪峰教程学习记录,廖雪峰链接: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