Python入门基础之函数、切片

Python入门基础之函数、切片
Python之函数

Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

Python之调用函数

Python内置了很多有用的函数，我们可以直接调用。

要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。

可以直接从Python的官方网站查看文档：

http://docs.python.org/2/library/functions.html#abs

也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。

调用 abs 函数：
```
>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34
```
调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个：
```
>>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)
```
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型：
```
>>> abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'
```
而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1：
```
>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0
```
Python内置的常用函数还包括数据类型转换函数，比如 int()函数可以把其他数据类型转换为整数：
```
>>> int('123')
123
>>> int(12.34)
12
```
str()函数把其他类型转换成 str：
```
>>> str(123)
'123'
>>> str(1.23)
'1.23'
```
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之编写函数

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

我们以自定义一个求绝对值的 my_abs 函数为例：
```
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
```
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。

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

return None可以简写为return。

Python函数之返回多值

数可以返回多个值吗？答案是肯定的。

比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：

# math包提供了sin()和 cos()函数，我们先用import引用它：
```
import math
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)
>>> print x, y
151.961524227 70.0
```
但其实这只是一种假象，Python函数返回的仍然是单一值：
```
>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)
```
用print打印返回结果，原来返回值是一个tuple！

但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

Python之递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n，用函数 fact(n)表示，可以看出：
```
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
```
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

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

Python之定义默认参数

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

例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：
```
>>> int('123')
123
>>> int('123', 8)
83
```
int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。

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

我们来定义一个计算 x 的N次方的函数:
```
def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
```
假设计算平方的次数最多，我们就可以把 n 的默认值设定为 2：
```
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
```
这样一来，计算平方就不需要传入两个参数了：
```
>>> power(5)
25
```
由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
```
# OK:
def fn1(a, b=1, c=2):
    pass
# Error:
def fn2(a=1, b):
    pass
```
Python之定义可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：
```
def fn(*args):
    print args
```
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数：
```
>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')
```
可变参数也不是很神秘，Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 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)
```
这样，在调用的时候，可以这样写：
```
>>> average()
0
>>> average(1, 2)
1.5
>>> average(1, 2, 2, 3, 4)
2.4
```
对list进行切片

取一个list的部分元素是非常常见的操作。比如，一个list如下：
```
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
```
取前3个元素，应该怎么做？

笨办法：
```
>>> [L[0], L[1], L[2]]
['Adam', 'Lisa', 'Bart']
```
之所以是笨办法是因为扩展一下，取前N个元素就没辙了。

取前N个元素，也就是索引为0-(N-1)的元素，可以用循环：
```
>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
... 
>>> r
['Adam', 'Lisa', 'Bart']
```
对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：
```
>>> L[0:3]
['Adam', 'Lisa', 'Bart']
```
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。

如果第一个索引是0，还可以省略：
```
>>> L[:3]
['Adam', 'Lisa', 'Bart']
```
也可以从索引1开始，取出2个元素出来：
```
>>> L[1:3]
['Lisa', 'Bart']
```
只用一个 : ，表示从头到尾：
```
>>> L[:]
['Adam', 'Lisa', 'Bart', 'Paul']
```
因此，L[:]实际上复制出了一个新list。

切片操作还可以指定第三个参数：
```
>>> L[::2]
['Adam', 'Bart']
```
第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个。（每N个取一个，取的是每N个的第一个元素）

把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

例子：

range()函数可以创建一个数列：
```
>>> range(1, 101)
[1, 2, 3, ..., 100]
```
请利用切片，取出：

1. 前10个数；
2. 3的倍数；
3. 不大于50的5的倍数。
```
L = range(1, 101)

print L[:10]
print L[2::3]
print L[4:50:5]
```
倒序切片

对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：
```
>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

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

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

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

>>> L[-4:-1:2]
['Adam', 'Bart']
```
记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

注意：-4要在-1前面；同样地，-3也得在-1前面。即使是倒序切片，排倒数第一的依旧在后面。

对字符串切片

字符串 'xxx'和 Unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
```
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[-3:]
'EFG'
>>> 'ABCDEFG'[::2]
'ACEG'
```
在很多编程语言中，针对字符串提供了很多各种截取函数，其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

例子：
```
>>> 'abc'.upper()
'ABC'
```
但它会把所有字母都变成大写。请设计一个函数，它接受一个字符串，然后返回一个仅首字母变成大写的字符串。

提示：利用切片操作简化字符串操作。
```
def firstCharUpper(s):
    return s[0].upper() + s[1:]
```
参考慕课网课程：http://www.imooc.com/learn/177
相关阅读:
浏览器切换窗口事件
 icheck的使用
 datetimepicker —— 日期选择控件
 apktool
生成证书
 Jadx
js call、apply和bind
1号台风来了
 Linux内核编译和测试
 华中科技大学电子地图
原文地址：https://www.cnblogs.com/dudududu/p/8721237.html

Python入门基础之函数、切片

Python之函数

Python之调用函数

Python之编写函数

Python函数之返回多值

Python之递归函数

Python之定义默认参数

Python之定义可变参数

对list进行切片

倒序切片

对字符串切片