python与c的比较学习

函数

你们要的函数库

或者用help(abs)查看函数信息

定义函数

  • def function(x):… －定义一个函数
  • from (文件名，不含.py) import function －从本地导入函数

  • 定义一个空函数

    1
    2
    def nop():
        pass

  • pass可以用来作为占位符

    1
    2
    if age >= 18:
        pass

  • 数据类型检查可以用内置函数isinstance()实现：

    1
    2
    3
    4
    5
    6
    7
    def my_abs(x):
        if not isinstance(x, (int, float)):
            raise TypeError('bad operand type')
        if x >= 0:
            return x
        else:
            return -x

  • 函数可以同时返回多个值，但其实就是一个tuple

函数参数

  • 默认参数

    1
    2
    3
    4
    5
    6
    def power(x, n=2):
        s = 1
        while n > 0:
            n = n - 1
            s = s * x
        return s

  • 定义默认参数要牢记一点：默认参数必须指向不变对象,不能有[　],可以这样操作一波

    1
    2
    3
    4
    5
    def add_end(L=None):
        if L is None:
            L = []
        L.append('END')
        return L

  • 可变参数(参数numbers接收到的是一个tuple)

    1
    2
    3
    4
    5
    def calc(*numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum

  • 关键字参数(关键字参数在函数内部自动组装为一个dict)

    1
    2
    3
    def person(name, age, **kw):
        print('name:', name, 'age:', age, 'other:', kw)
    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

kw获得的dict是一份拷贝，对函数外的kw没有影响　

  • 命名关键字参数　－限制关键字参数的名字
    1
    2
    def person(name, age, *, city, job):
        print(name, age, city, job)

参数组合（必选参数、默认参数、可变参数、关键字参数和命名关键字参数）

1
2
3
4
5
def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
  • 对于任意函数，都可以通过类似func(*args,**kw)的形式调用它，无论它的参数是如何定义的
  • *args是可变参数，args接收的是一个tuple；
  • **kw是关键字参数，kw接收的是一个dict。

递归函数

  • 使用递归函数需要注意防止栈溢出，下面的函数n最大为998,亲测

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

  • 尾递归，在函数返回的时候，调用自身本身

1
2
3
4
5
6
7
def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)
  • 尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
  • 大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
    综上，尾递归这一节说的都是屁话

递归实现汉罗塔
感觉有一点动态规划的感觉