python sum函数用法-sas sum函数用法

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即函数体，是每次调用函数时执行的一组语句，可以由一条语句或多条语句组成。 包含多个语句的函数体必须缩进。

函数通常使用三个单引号 '''...''' 来注释和描述函数； 函数体的内容不能为空python sum函数用法，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.位置参数

函数调用中的参数通常是按位置匹配的python sum函数用法，即在相应的位置依次将实参传递给形参。 这些实际参数的数量应该与形式参数完全匹配。

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.关键字参数

虽然一个可变参数可以接受多个实参，但是这些实参被捆绑成元组，具体的实参不能赋值给具体的形参，那么有没有一个参数可以接受多个实参呢？ 参数，是否可以将多个实参赋值给各自的实参名？

答案是一个关键字参数，这个参数会把参数值和参数名组装成一个字典，key是具体的实参名，value是传入的参数值

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')

姓名：Michael 年龄：30 其他：{}

姓名：Bob 年龄：35 其他：{'city': '北京'}

姓名：Adam 年龄：45 其他：{'gender': 'M', 'job': 'Engineer'}

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

调用该函数时，name和age这两个参数必须传入相应的值，而其他参数则由用户任意填写，关键字参数会将这些任意填写的信息组装成一个字典。

要在 Python 中定义一个函数，您可以使用位置参数、默认参数、可变参数和关键字参数，所有这些都可以组合使用。

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

参数传递

1.参数传递方式

大多数编程语言都有两种常见的参数传递方式：传值调用和传引用调用。

(1) 传值调用：是指函数被调用时，实参的值会被一个一个复制到函数的参数中，函数中对参数值的任何修改都不会影响原实参价值。

(2) 引用传递调用：是指在调用函数时，传递的函数的参数值是变量的内存地址，参数值的改变也会影响原自变量值。

在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，则在左边补空。

d，与%2d类似，只是左边加了0

%.2d 输出整形时至少输出2位，不够就在前面放0。比如输出2时，就变成02。输出200时，只输出200； 输出浮点型(%.2f)时，小数点后强制输出2位

2.复合数据拆包传参

传递参数时，可以使用Python列表、元组、集合、字典等可迭代对象作为实参，并在实参名前加星号，Python解释器会自动解包，然后传递给多个单可变参数。

但需要注意的是，如果使用字典作为实参，则默认使用字典的key。 如果需要使用字典中的键值对作为参数，需要使用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

下次我们会讲两个特殊的函数，一个是匿名的，一个是递归的。 感谢阅读，记得关注。