Python基础笔记2

╰半橙微兮° 2021-11-01 07:12 343阅读 0赞

## 函数 ##

### 1.调用函数 ###

abs(100)
    abs(-20)
    
    max(1,2,-3)

**数据类型转换**

int('123')
    int(12.34)
    str(123)
    bool(1)
    bool('')

函数调用: 根据函数定义，传入正确的参数

a = abs
    a(-1)

### 2.定义函数 ###

# _*_ coding: utf-8 _*_
    def my_abs(x):
        if x>=0:
            return x
        else:
            return -x

一旦执行到return函数就执行完毕，并将结果返回。若没有return将返回None。

将以上函数保存为`abstest.py`文件，可以在当前目录下启动Python解释器，用`from abstest import my_abs`来导入`my_abs()`函数。

**空函数**

def nop():
        pass

`pass`啥也不做，常用做占位符，先让代码运行再说。

**参数检查**

my_abs(1,2) #参数个数不对
    my_abs('A') #参数类型不对
    
    #优化代码做参数检查
    def my_abs():
        if not isinstance(x, (int, float): #只允许整数和浮点
            raise TypeError('bad operand type')
        if x>= 0:
            return x
        else:
            return -x

**返回多个值**

import math
    def move(x, y, step, angle=0):
        nx=x+step*math.cos(angle)
        ny=y-step*math.sin(angle)
        return nx, ny
    
    r = move(100,100,60,math.pi/6)
    print(r)
    
    #返回多值是一个元组tuple，多变量也可以按位置接收一个元组。

### 3.函数的参数 ###

**位置参数**

def power(x,n):
        s=1
        while n>0:
            n=n-1
            s=s*x
        return s

`x`和`n`都是位置参数，调用函数时按位置传入。

**默认参数**

能降低调用函数的难度。

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

`power(5)`和`power(5,2)`一样。

原则：必选参数在前，默认参数在后；变化大的参数放前，变化小的参数放后；默认参数必须指向不变对象！

def add_end(L=None): #指定None不变对象，不能直接用[]
        if L is None:
            L = []
        L.append('END')
        return L

**可变参数**

可变参数允许传入0个或任意个参数，在函数调用时自动组装为一个tuple，定义函数参数前加`*`

def calc(*numbers): #参数numbers接收到的是一个tuple
        sum=0
        for n in numbers:
            sum=sum+n*n
        return sum
     
    #调用：   
    calc(1,2)
    calc()

可以把list或tuple的所有元素作为可变参数传入进去：

nums=[1,2,3]
    calc(*nums)

**关键字参数**

关键字参数允许传入0个或任意个含参数名的参数，在函数内部自动组装为一个dict，定义函数参数前加`**`

def person(name, age, **kw):
        print('name:', name, 'age:', age, 'other:', kw)
        
    #调用：
    person('Michael', 30)
    person('Adam', 45, gender='M', job='Engineer')

可以先组装出一个dict，然后把该dict转换为关键字参数传进去：

extra = {'city': 'Beijing', 'job': 'Engineer'}
    person('Jack', 24, city=extra['city'], job=extra['job'])
    
    #以上调用可简化为：
    extra = {'city': 'Beijing', 'job': 'Engineer'}
    person('Jack', 24, **extra)

**命名关键字参数**  
关键字参数的传入不受限制。如果要限制关键字参数的名字，就可以用命名关键字参数。命名关键字参数必须传入参数名。

命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数，否则将无法与位置参数区分。

def person(name,age,*,city,job):
        print(name,age,city,job)
        
    #调用
    person('Jack',24,city='Beijing',job='Engineer')

命名关键字参数可以有默认值：

def person(name,age,*,city='beijing',job):
        print(name,age,city,job)
        
    #调用：
    person('jack',24,job='engineer')

**参数组合**

定义函数时5种参数可以组合使用，但参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a,b,c=0,*args,**kw):
        print(a,b,c,args,kw)
        
    def f2(a,b,c=0,*,d,**kw):
        print(a,b,c,d,kw)
        
    #调用：
    f1(1,2)
    f1(1,2,c=3)
    f1(1,2,3,'a','b')
    f1(1,2,3,'a','b',x=99)
    f2(1,2,d=99,ext=None)

通过一个tuple和dict也可调用上述函数：

args=(1,2,3,4)
    kw={'d':99,'x':'#'}
    f1(*args,**kw)
    
    args = (1, 2, 3)
    kw = {'d': 88, 'x': '#'}
    f2(*args,**kw)

所以对于任意函数，都可以通过类似func(\*args, \*\*kw)的形式调用它，无论它的参数是如何定义的。

### 4.递归函数 ###

一个函数在内部调用自身。  
如n阶乘：

def fact(n):
        if n==1:
            return 1
        return n*fact(n-1) #返回表达式

递归函数的优点是定义简单，逻辑清晰。缺点是过深的调用会导致栈溢出，针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，尾递归是指在函数返回的时候调用自身，并且return语句不能包含表达式。

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标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

转载于:https://www.cnblogs.com/jessepeng/p/11221872.html