Python基础笔记2如何深入理解？

本文共计1380个文字，预计阅读时间需要6分钟。

函数+1.%20调用函数+abs(100)+abs(-20)+max(1,2,-3)+数据类型转换+int('123')+int(12.34)+str(123)+bool(1)+bool('')+函数调用：+根据函数定义，传入正确的参数+a=abs(a(-1))+2.%20定义函数+

函数

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_*_
defmy_abs(x):
ifx>=0:
returnx
else:
return-x

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

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

空函数

defnop():
pass

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

参数检查

my_abs(1,2)#参数个数不对
my_abs('A')#参数类型不对

#优化代码做参数检查
defmy_abs():
ifnotisinstance(x,(int,float):#只允许整数和浮点
raiseTypeError('badoperandtype')
ifx>=0:
returnx
else:
return-x

返回多个值

importmath
defmove(x,y,step,angle=0):
nx=x+step*math.cos(angle)
ny=y-step*math.sin(angle)
returnnx,ny

r=move(100,100,60,math.pi/6)
print(r)

#返回多值是一个元组tuple，多变量也可以按位置接收一个元组。

3.函数的参数

位置参数

defpower(x,n):
s=1
whilen>0:
n=n-1
s=s*x
returns

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

默认参数

能降低调用函数的难度。

defpower(x,n=2):
s=1
whilen>0:
n=n-1
s=s*x
returns

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

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

defadd_end(L=None):#指定None不变对象，不能直接用[]
ifLisNone:
L=[]
L.append('END')
returnL

可变参数

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

defcalc(*numbers):#参数numbers接收到的是一个tuple
sum=0
forninnumbers:
sum=sum+n*n
returnsum

#调用：
calc(1,2)
calc()

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

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

关键字参数

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

defperson(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)

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

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

defperson(name,age,*,city,job):
print(name,age,city,job)

#调用
person('Jack',24,city='Beijing',job='Engineer')

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

defperson(name,age,*,city='beijing',job):
print(name,age,city,job)

#调用：
person('jack',24,job='engineer')

参数组合

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

deff1(a,b,c=0,*args,**kw):
print(a,b,c,args,kw)

deff2(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阶乘：

deffact(n):
ifn==1:
return1
returnn*fact(n-1)#返回表达式

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

deffact(n):
returnfact_iter(n,1)

deffact_iter(num,product):
ifnum==1:
returnproduct
returnfact_iter(num-1,num*product)

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

作者：Bioinfarmer

若要及时了解动态信息，请关注同名微信公众号：Bioinfarmer。