python基本函数使用汇总

python基本函数使用
先来看一下我们常用的python函数

print(abs(-3))
#返回-3的绝对值
print(pow(2,3))
#返回2的3次幂
print(round(71.1425,2))
#返回71.1425的四舍五入的值,参数2指定保留的小数位数
print(divmod(5,3))
#返回5除以3的商和余数，返回一个元组。
str = "I am a student"
print(str.lower())
#将字符串str中的所有字母转换为小写字母
print(str.upper())
#将字符串str中的所有字母转换为大写字母
print(str.swapcase())
#将字符串str中的所有字母大小写互换
print(str.capitalize())
#字符串str中的首字母大写，其余字母小写
print(str.title())
#将字符串str中的每个单词的首字母大写，其余为小写
print(str.ljust(20,"*"))
#将str左对齐输出，字符串的总宽度为20，不足的部分以*填充
print(str.rjust(20,"*"))
#将str右对齐输出，字符串的总宽度为20，不足的部分以*填充
print(str.center(20,"*"))
#将str居中输出，字符串的总宽度为20，不足的部分以*填充
print(str.zfill(20))
#将字符串的宽度填充为20，并且右对齐，不足的部分用0补充
print(str.find("s"))
#从str字符串中检索是否存在s，如果存在，则返回出现s的第一个字母的位置；如果str中没有s，则返回-1
print(str.index("u"))
#与find()函数相同，只是在str中没有u时，返回一个运行时的错误
print(str.rfind("s"))
#从str字符串右侧检索是否存在s，如果存在则返回出现字串s的第一个字母的位置；如果str中没有s，则返回-1
print(str.rindex("u"))
#与rfind()函数相同，如果没有u时，返回一个运行时错误
print(str.count("s"))
#计算s在str中出现的次数
print(str.replace(" ","*"))
#把str中的空格位置替换为*
list = str.split(" ")
print(list)
#以空格为分隔符，把str分割成一个列表
strl = "*"
print(strl.join(list))
#把list代表的字符串序列，用*连接起来

  为了增加代码的可重用性、可读性和可维护性，程序设计语言一般都提供函数这种机制来组织代码。
  Python函数包括内置函数和第三方模块函数，对于这些现成的函数用户可以直接拿来使用。另外，有一类函数是用户自己编写的，通常称为自定义函数。
Python中自定义函数的语法如下：

def functionName(formalParameters)：

     functionBody

  （1）functionName是函数名，可以是任何有效的Python标识符。

  （2）formalParameters是形式参数（简称形参）列表，在调用该函数时通过给形参赋值来传递调用值，形参可以有多个、一个或零个参数组成，当有多个参数时各个参数由逗号分隔；圆括号是必不可少的，即使没有参数也不能没有它。括号外面的冒号也不能少。

  （3）functionBody是函数体，是函数每次被调用时执行的一组语句，可以由一个语句或多个语句组成。多个语句的函数体一定要注意缩进。

  函数通常使用三个单引号’‘’…‘’'来注释说明函数；函数体内容不可为空，可用pass来表示空语句。

  在函数调用时，函数名后面括号中的变量名称称为实际参数（简称实参）。定义函数时需要注意以下两点：

  （1）函数定义必须放在函数调用前，否则编译器会由于找不到该函数而报错。

  （2）返回值不是必需的，如果没有return语句，则Python默认返回值None。

先定义求n的阶乘的函数，再调用求5的阶乘 。

def factorial(n):
    r = 1
    while n > 1: r *= n; n -= 1
    return r

print(factorial(5))

结果为120

自定义函数的四种参数

  Python的自定义函数有位置参数、默认参数、可变参数和关键字参数四类参数。

  1.位置参数

  函数调用时的参数通常采用按位置匹配的方式，即实参按顺序传递给相应位置的形参。这些实参的数目应与形参完全匹配。

  2.默认参数

  默认参数是指在构造自定义函数的时候已经给某些参数赋予了各自的初值，当调用函数时，这样的参数可以不用传值，默认参数必须指向不变对象。

例如计算1到n的p次方和

def square_sum(n, p=2):
    result=sum([i**p for i in range(1, n+1)])
    return (n, p, result)
print("1到%d的%d次方和为%d"%square_sum(10))
print("1到%d的%d次方和为%d"%square_sum(10,3))

  3.可变参数

  上面的必选参数和默认参数都是在已知这个自定义函数需要多少个形参的情况下构建的，如果不确定该给自定义函数传入多少个参数值时，就需要Python提供可变参数。

例如两个数的求和函数：

def add(a,b): s=sum([a,b]); return (a,b,s)
print("%d加%d的和为%d"%add(10,13))  #输出：10加13的和为23

  如果要求任意个数的和，必须使用可变参数，可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个元组。

def add(*args): print(args, end=''); s=sum(args); return(s)
print("的和为%d"%add(10,12,6,8))

(10, 12, 6, 8)的和为36

  如上自定义函数中，参数args前面加了一个星号*，这样的参数就是可变参数，该参数是可以接纳任意多个实参的。
  之所以能够接纳任意多个实参，是因为该类型的参数将这些输入的实参进行了捆绑，并且组装到元组中，就是自定义函数中print(args)语句的效果。

  4.关键字参数
  虽然一个可变参数可以接受多个实参，但是这些实参都被捆绑为元组了，而且无法将具体的实参指定给具体的形参，那么有没有一种参数既可以接受多个实参，又可以把多个实参指定给各自的实参名呢？

  答案是关键字参数，而且这种参数会把带参数名的参数值组装到一个字典中，键就是具体的实参名，值就是传入的参数值

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
person('Michael', 30) 
person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')

name: Michael age: 30 other: {}
name: Bob age: 35 other: {‘city’: ‘Beijing’}
name: Adam age: 45 other: {‘gender’: ‘M’, ‘job’: ‘Engineer’}

  如上面程序所示，在自定义函数person中，name和age是位置参数，kw为关键字参数。

  当调用函数时，name和age两个参数必须要传入对应的值，而其他的参数都是用户任意填写的，并且关键字参数会把这些任意填写的信息组装为字典。

  在Python中定义函数，可以用位置参数、默认参数、可变参数、关键字参数，这4种参数都可以组合使用。

  但是请注意，参数定义的顺序必须是：位置参数、默认参数、可变参数、关键字参数。

参数传递

  1.参数传递方式

  大多数程序设计语言有两种常见的参数传递方式：传值调用和传址调用。

  （1）传值（call by value）调用：表示在调用函数时，会将自变量的值逐个复制给函数的参数，在函数中对参数值所做的任何修改都不会影响原来的自变量值。

  （2）传址（pass by reference）调用：表示在调用函数时，所传递函数的参数值是变量的内存地址，参数值的变动连带着也会影响原来的自变量值。
  在Python语言中，当传递的数据是不可变对象（如数值、字符串）时，在传递参数时，会先复制一份再进行传递。

  但是，如果所传递的数据是可变对象（如列表），Python在传递参数时，会直接以内存地址来传递。

  简单地说，如果可变对象在函数中被修改了内容值，因为占用的是同一个地址，所以会连带影响函数外部的值。

  以下是函数传值调用的范例。

def fun(a,b):
    a, b = b, a;
    print("函数内交换数值后：a=%d,\tb=%d"%(a,b))
a=10; b=15
print("调用函数前的数值：a=%d,\tb=%d"%(a,b))
print("-----------------------------------")
fun(a,b)   #调用函数
print("-----------------------------------")
print("调用函数后的数值：a=%d,\tb=%d"%(a,b))

调用函数前的数值：a=10, b=15

函数内交换数值后：a=15, b=10

调用函数后的数值：a=10, b=15

下面再举一个传址调用的范例，参数为列表，是一种可变对象。

def change(data):
    data[0], data[1] = data[1], data[0]
    print("函数内交换位置后：",end='')
    for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t')
data=[16, 25]    #主程序
print("原始数据为：",end='')
for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t')
print("\n-------------------------------------------------------")
change(data)
print("\n-------------------------------------------------------")
print("排序后数据为：",end='')
for i in range(2): print("data[%d]=%2d"%(i,data[i]),end='\t')

原始数据为：data[0]=16 data[1]=25
函数内交换位置后：data[0]=25 data[1]=16
排序后数据为：data[0]=25 data[1]=16

  %d就是普通的输出了

  % 2d是将数字按宽度为2，采用右对齐方式输出，若数据位数不到2位，则左边补空格。

  % 02d，和% 2d差不多，只不过左边补0

  %.2d 输出整形时最少输出2位，如不够前面以0占位。如输出2时变成02。200时只输出200；输出浮点型时（%.2f）小数点后强制2位输出

  2.参数传递的复合数据解包
传递参数时，可以使用Python列表、元组、集合、字典以及其他可迭代对象作为实参，并在实参名称前加一个星号，Python解释器将自动进行解包，然后传递给多个单变量形参。

  但需要注意的是，如果使用字典作为实参，则默认使用字典的键，如果需要将字典中的键-值对作为参数则需要使用items()方法，如果需要将字典的值作为参数则需要调用字典的values()方法。

  最后，请保证实参中元素个数与形参个数相等，否则出现错误。

def fun(a,b,c): print("三个数的和为：",a+b+c)
seq=[1,2,3]; fun(*seq)                 #输出：三个数的和为： 6
tup=(1,2,3); fun(*tup)                 #输出：三个数的和为： 6
dic={1:'a', 2:'b', 3:'c'}; fun(*dic)          #输出：三个数的和为： 6
set={1,2,3}; fun(*set)                  #输出：三个数的和为： 6

下一次我们讲两个特殊函数，一个是匿名函数，另一个为递归函数。谢谢大家的阅读，记得关注哦。