python入门-函数、切片、迭代

1.1.函数：一种代码抽象的方式

要调用一个函数，需要知道函数的名称和参数

调用abs函数
abs(100)
100
abs(-20)
20
abs(12.34)
12.34

注：如果传入的参数数量不对或参数类型不对，会报typeError的错误

abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)

abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

比较函数cmp(x,y)
cmp(1, 2)
-1 #小于返回-1
cmp(2, 1)
1 #大于返回1
cmp(3, 3)
0 #等于返回0

python内置的常用函数int()函数：将其他类型转换为整数，str()函数：将其他类型转换为str

1.2.编写函数

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

例：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

注意：函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。

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

1.3.函数之返回多值

函数返回多个值

例：

import math  #math包提供了sin()和cos()函数，使用import引用它
def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
x, y = move(100, 100, 60, math.pi / 6) #调用函数move()
print x, y
151.961524227 70.0
r = move(100, 100, 60, math.pi / 6)
print r
(151.96152422706632, 70.0) #注意:返回值是一个tuple

总结：python的函数返回多值其实就是返回一个tuple

1.4.递归函数

如果一个函数在内部调用自身，这个函数就是递归函数

例：

fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1)*n
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

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

1.5.定义默认参数

定义函数的时候，可以有默认参数

例：int()函数，有两个参数，既可以传一个参数，也可以传入两个参数

int('123') #不传入，默认为十进制
123
int('123', 8)
83

函数的默认参数的作用是简化调用，只需要把必须的参数传进去。在需要的时候有可以传入额外的参数来覆盖默认参数值

def power(x, n=2):  #默认参数为2
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

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

# OK:
def fn1(a, b=1, c=2):
    pass
# Error:
def fn2(a=1, b):
    pass

1.6.定义可变参数

让一个函数能接受任意个参数，我们可以定义一个可变参数

def fn(*args):  # *号表示我们可以传入0个、1个或多个参数给可变参数  
    print args
fn()
()
fn('a')
('a',)
fn('a', 'b')
('a', 'b')
fn('a', 'b', 'c')
('a', 'b', 'c')

说明：可变参数中，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

2.1切片

取出指定索引范围的操作，不用for循环，使用切片操作符

L = ['Adam', 'Lisa', 'Bart', 'Paul']
L[0:3] #表示从索引0开始取，直到索引3为止，但不包括索引3
['Adam', 'Lisa', 'Bart']
L[:3] #第一个索引是0，可以省略
['Adam', 'Lisa', 'Bart']
L[:] #只用一个 : ，表示从头到尾
['Adam', 'Lisa', 'Bart', 'Paul']
L[::2] #表示每2个元素取一个
['Adam', 'Bart']

list和tuple的切片操作完全相同

2.2倒序切片

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

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

>>> L[-3:-1]
['Lisa', 'Bart']

>>> L[-4:-1:2]
['Adam', 'Bart']

2.3对字符串切片

字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串

例：

ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'

Python没有针对字符串的截取函数，只需要切片一个操作就可以完成

3.1迭代

给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历就叫迭代(iteration)

在Python中，迭代是通过 for ... in 来完成的。 Python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。

总结：迭代操作就是对于一个集合，无论该集合是有序还是无序，我们总是可以用for循环一次取出集合的每一个元素。

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

迭代与按下标访问数组最大的不同是：后者是一种具体的迭代实现方式，而前者只关心迭代结果，根本不关心迭代内部是如何实现的。

3.2索引迭代

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

对于有序集合，元素确实是有索引的，我们可以使用enumerate()函数在for循环中拿到索引

例：

L = ['Adam', 'Lisa', 'Bart', 'Paul']
 for index, name in enumerate(L):
     print index, '-', name
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

说明：使用 enumerate() 函数，我们可以在for循环中同时绑定索引index和元素name

原理:

实际上，enumerate() 函数把：['Adam', 'Lisa', 'Bart', 'Paul']变成了类似[(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]，这样迭代的每个元素其实是一个tuple

for t in enumerate(L):
    index = t[0]
    name = t[1]
    print index, '-', name

总结：索引迭代不是真的按索引访问，而是由 enumerate() 函数自动把每个元素变成 (index, element) 这样的tuple，再迭代，就同时获得了索引和元素本身。

zip函数可以把两个list变成一个list：

>>> zip([10, 20, 30], ['A', 'B', 'C'])
[(10, 'A'), (20, 'B'), (30, 'C')]

3.3迭代dict的value

dict对象本身就是可迭代对象，用for循环直接迭代dict，可以每次拿到dict的一个key。

方法一：dict对象有一个values()方法，这个方法把dict转换成一个包含所有value的list

例：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59

方法二：使用itervalues()方法，和values()迭代效果一样

例：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.itervalues()
# <dictionary-valueiterator object at 0x106adbb50>
for v in d.itervalues():
    print v
# 85
# 95
# 59

values()和itervalues的不同之处：

1.values()实际上是把一个dict转换成包含value的list

2.itervalues()不会转换，它会在迭代过程中一次从dict中取出value，所以itervalues()节省了list所需内存

3.打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

总结：只要一个对象是可迭代的，则就可以直接用for循环去迭代它，由此可见，迭代是一种抽象的数据操作，不对迭代对象内部的数据有任何要求。

3.4迭代dict的key和value

迭代dict中的key和value

方法一：调用dict的items()方法，然后对包含tuple的list进行迭代

例：

>>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
>>> print d.items()
[('Lisa', 85), ('Adam', 95), ('Bart', 59)]
>>> for key, value in d.items():
...     print key, ':', value
... 
Lisa : 85
Adam : 95
Bart : 59

方法二：使用dict的iteritems()方法

说明：iteritems()不把dict转换成list，而是在迭代过程中不断给出tuple。所以iteritems()不占用额外的内存。

例：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for k, v in d.iteritems():
  sum = sum + v
  print k,':',v
print 'average', ':', sum/len(d)

译者介绍：家华，从事mysqlDBA的工作，记录自己的一些总结