Python基础笔记2

函数

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

xn都是位置参数,调用函数时按位置传入。

默认参数

能降低调用函数的难度。

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

你可能感兴趣的:(Python基础笔记2)