python常用函数总结

字符串函数

关于字符串函数的内容，之后会详细的总结并整理

数值函数

round(number,digits)

digits>0,四舍五入到指定的小数位
digits<0,在小数点左侧进行四舍五入
digits=0，四舍五入到最接近的整数。

四舍五入规则：

要求保留位数的后一位<=4,则不进位，如round（5.214,2）--> 5.21
要求保留位数的后一位=5，且该位后面没有数字，则不进位，如round（5.215，2） --> 5.21
要求保留位数的后一位=5，且该位数后面有数字，则进位，如round（5.2151，2）--> 5.22
要求保留位数的后一位>=6,则进位，如round(5.216,2) -->5.22

函数

python中的函数形参

位置参数

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

默认参数

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

必选参数在前，默认参数放在后面，否则编译器会出错

当函数有多个参数的时候，把变化大的参数放前面，变化下的参数放在后面，变化小的参数作为默认参数 note: 默认参数有一个最大的坑

def add_end(L=[])
  L.append('END')
  return L

>>>add_end([1,2,3])
[1,2,3,'END']

>>>add_end(['x','y','z'])
['x','y','z','END']

上面结果看似正确，但是如果采用下面的例子：

add_end()
>>>['END']

add_end()
>>>['END','END']

此时发现第二次调用add_end()返回值并不是[END]，这是因为在第一次调用add_end()时函数记住了第一次的结果。 python函数在定义的时候，默认参数L的值被计算出来，也就是说默认参数名义上是形参，但实际上是一个变量指向了对象[],每次调用函数如果改变了L的内容，则下次嗲用时默认参数的内容就变了，不再是函数定义时的[]

定义默认参数的时候要注意默认参数必须指向不变对象。

要修改上面的例子，可以使用None这个不变对象来实现：

def add_end(L=None):
  if L is None       ## None 是python中的一个数据类型NoneType
    L=[]
  L.append('END')
  return L

可变参数

def calc(numbers):
  sum=0
  for n in numbers:
    sum=sum+n*n
  return sum

如果一开始想计算 ,之后想计算1^2+2^2+3^2,可以将numbers定义为一个list或turple. 调用函数如下：

calc([1,2,3,4])

calc((1,2,3))

其中也可以使用可变参数，可变参数其实接收的是一个tuple，格式如下：

def calc(*numbers):
  sum=0
  for n in numbers:
    sum=sum+n*n
  return sum

调用函数是可以采用calc(1,2,3)或nums=[1,2,3], calc(*nums)

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用的时候自动组装成一个turple,关键字参数允许你传入0个或者任意个含参数名的参数，这些关键字参数在函数内部自动组装成一个dict。

def person(name,age,**kw):
  print('name:',name,'age:',age,'other:',kw)
  //kw 是一个字典

>>> person('Adam',45, gender='M',job='Engineering')
name: Adam age:45 other:{'gender':'M','job':'Engineering'}
// 也可以先组装成字典，然后把字典当参数传进去。
>>> extra={'city':'Beijing','job':'Engineering'}
>>> person('Jack',25,**extra)

命令关键字参数

在关键字参数可以传入不受约束的关键字，可以采用命名关键字限制要输入的参数,命名关键字参数前需要特殊的分隔符*,如果前面已经有了一个可变参数*para,那么后面跟着的参数被自动理解为命名关键字参数，此时不在需要*：

def person(name,age,*,city,job)
   print(name,age,city,job)
   
调用方式如下：
person('Jack',24,city='Beijing',job='Beijing')

//命名关键字前有可变参数
def person(name,age,*args,city,job):
  print(name,age,args,city,job)

//命名关键字参数有缺省值
def person(name,age,*,city='Beijing',job)
  print(name,age,city,job)

>>> person('Jack',24,job='Engineer')
Jack 24 Beijing Engineer

组合参数

python中可以混合使用位置参数，默认参数，可变参数，关键字参数，命名关键字参数。

def f1(a,b,c=0,*args,**kw):
  print('a=',a 'b=',b,'c=',c,'args=',arg,'kw=',kw)
  
>>> f1(1,2,c=3)
a=1 b=2 c=3 args=() kw={}
>>>f1(1,2,3,'a','b',x=99)
a=1 b=2 c=3 args=('a','b'),kw={'x':99}

>>> args=(1,2,3,4)
>>> kw={'d:'99, 'x:''#'}
>>> f1(*args,**kw)
a=1 b=2 c=3 args=(4,) kw={'d:' 99 'x:' '#'}

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

python函数中的类型提示

在刷leetcode的时候发现了这样的写法：def twosum(self,nums:List[int], target:int)->List[int]

这是所谓的类型提示，指出函数的返回值是List[int],参数nums是List[int],target是int。这种提示只是给程序员看的，在运行的时候完全可以输入不同的参数类型，并且输出的结果也不一定是List[int].