python程序设计——函数设计与调用

一、函数定义与调用

def 函数名([参数列表]):
    ‘‘‘注释‘‘‘
    函数体
# 输出小于n的斐波那契数
>>def fib(n):
    a,b=1,1
    while a < n:
        print(a,end=‘ ‘)
        a,b=b,a+b
    print()

>>fib(3)
1 1 2

二、形参与实参

在绝大多数情况下,在函数内部直接修改形参的值不会影响实参

def addOne(a):
    print(a)
    a+=1
    print(a)

>>a=3
>>addOne(a)
3
4

>>a
3

修改函数参数值的方式:

如果传递给函数的是可变序列,

并且在函数内部使用下标或其他方式为课表序列增加、删除、修改元素值时,

修改后的结果可以反映到函数之外,即实参得到相应修改

# 修改列表元素的值def modify(v):
    v[0] = v[0] + 1

>>a=[2]
>>print(a)
[2]
>>modify(a)
>>print(a)
[3]
# 为列表增加元素
def addList(v,item):
    v.append(item)

>>a=[2]
>>addList(a,3)
>>print(a)
[2,3]

三、参数类型

python函数参数主要分为:普通参数、默认值参数、关键参数、可变长度参数等

在定义函数时不需要指定参数的类型,形参类型由实参类型以及python解释器的理解和推断决定

同样,不需要指定函数的返回值类型,由return语句返回值的类型决定

缺少return语句或没有执行return语句时,默认返回空值None

1. 默认值参数

调用带有默认值的函数时,可以不对默认值参数赋值,也可以通过显示赋值来替换其默认值

在定义带有默认值的函数时,默认值参数必须出现在函数形参列表的最右端,且任何一个默认值参数右边都不能再出现非默认值参数

def 函数名(..., 形参名=默认值 ):
    函数体

def say(message, time=1):
    print((message+‘ ‘)*times)

>>say.__defaults__(1,)

2.关键参数

指调用函数时的参数传递方式,而与函数定义无关

通过关键参数可以按名字传递值,实参顺序可以和形参不一致

def demo(a,b,c=5):
    print(a,b,c)

>>demo(3,7)
3 7 5

>>demo(c=8,a=9,b=0)
9 0 8

3.可变长度参数

*parameter 用来接收任意多个实参并将其放在一个元组中

**parameter 用来接收类似于关键参数一样显示赋值形式的多个实参并将其放入字典中

def demo(*P):
    print(P)

# 将实参放入元组
>>demo(1,2,3)
(1,2,3)

# 在调用函数时,自动将接收参数转换为字典
def demo(**p):
        for item in p.items():
            print(item)

>>demo(x=1,y=2,z=3)
(‘x‘, 1)
(‘y‘, 2)
(‘z‘, 3)

4.参数传递时的序列解包

可以使用列表、元组、集合、字典及其他可迭代对象作为实参,

并在实参名称前加一个星号,解释器自动进行解包,并传递给多个单变量形参

要保证实参中元素个数与形参个数相等

def demo(a,b,c):
    print(a+b+c)

>>seq = [1,2,3]
>>demo(*seq)
6

# 字典型,默认按照键解包
>>dic={1:‘a‘,2:‘b‘,3:‘c‘}
>>demo(*dic)
6

# 指定按照值解包
>>demo(*dic.values())
abc

四、变量作用域

函数内部定义的变量一般为局部变量,不属于任何函数的变量一般为全局变量

应尽量避免使用全局变量,引用速度慢,增加不同函数之间的隐式耦合度

如果想在函数内部修改一个定义在函数外的变量值,那么这个变量就不能是局部的

def demo():
    global x    # 声明全局变量
    x=3         # 修改全局变量的值
    y=4         # 局部变量
    print(x,y)

x=5   # 在函数外定义全局变量
demo()  # 调用函数,修改全局变量的值
print(x)
out: 5

print(y)    # 函数结束后,局部变量自动删除
out: NameError: name ‘y‘ is not defined

del x  # 删除全局变量

不同模块间共享全局变量,定义单独的模块,传递全局变量

# 定义模块 A.py
global_var = 0

# 在模块 B.py中
import A
A.global_var = 1

# 在模块C.py中
import A
A.global_var = 2

 函数实例:

1、编写函数,接收字符串参数,返回一个元组,其中第一个元素为大写字母个数,第二个为小写字母个数

def countStr(s):
    result = [0,0]
    for ch in s:
        if ‘a‘<= ch <= ‘z‘:
            result[1] += 1
        elif ‘A‘ <= ch <= ‘Z‘:
            result[0] += 1
    return result

tmpStr = ‘abANV‘
bigN,littleN = countStr(tmpStr)
print(bigN,littleN)

out:
3 2

2、编写函数,接收一个所有元素值互不相等的整数列表x和一个整数n,要求将值为n的元素作为支点,

将列表中所有小于n的元素全部放在n的前面,所有值大于n的元素放在n后面

 1 import random
 2 def sortN(x,n):
 3     if n not in x:
 4         print(n,‘ is not an element of ‘,x)
 5         return
 6
 7     i = x.index(n)  # 获取指定元素在列表中的索引
 8     x[0],x[i] = x[i],x[0]  # 与第0个元素交换
 9     key = x[0]
10
11     i = 0
12     j = len(x)-1
13     while i<j:
14         while i < j and x[j] >= key:
15             j-=1
16         x[i]=x[j]    # 从后向前找第一个比指定元素小的元素
17
18         while i < j and x[i] <= key:
19             i+=1
20         x[j]=x[i]   # 从前向后找第一个比指定元素小的元素
21
22     x[i] = key
23
24     return x
1 x=list(range(1,10))
2 random.shuffle(x)
3 print(x)
4 sortN(x,4)
5 print(x)

原文地址:https://www.cnblogs.com/feinaio2017/p/8799216.html

时间: 2024-10-30 11:24:26

python程序设计——函数设计与调用的相关文章

[C++程序设计]函数的递归调用

在调用一个函数的过程中又出现直接或间接地调用 该函数本身,称为函数的递归(recursive)调用. 包含递归调用的函数称为递归函数. 在实现递归时,在时间和空间上的开销比较大 求n! 1 #include <iostream> 2 using namespace std; 3 4 long func(int n); 5 6 int main() 7 { 8 long c; 9 int x; 10 cout << "please enter a integer numbe

Python函数设计原则

在任何编程语言中,函数的应用主要出于以下两种情况: 代码块重复,这时候必须考虑用到函数,降低程序的冗余度 代码块复杂,这时候可以考虑用到函数,增强程序的可读性 当流程足够繁杂时,就要考虑函数,及如何将函数组合在一起.在Python中做函数设计,主要考虑到函数大小.聚合性.耦合性三个方面,这三者应该归结于规划与设计的范畴.高内聚.低耦合则是任何语言函数设计的总体原则. 如何将任务分解成更有针对性的函数从而导致了聚合性 如何设计函数间的通信则又涉及到耦合性 如何设计函数的大小用以加强其聚合性及降低其

Python中将函数作为另一个函数的参数传入并调用

在Python中,函数本身也是对象,所以可以将函数作为参数传入另一函数并进行调用 在旧版本中,可以使用apply(function, *args, **kwargs)进行调用,但是在新版本中已经移除,以function(*args, **kwargs)进行替代,所以也不应该再使用apply方法 示例代码: def func_a(func, *args, **kwargs): print(func(*args, **kwargs)) def func_b(*args): return args i

Lua程序设计 函数 正确的尾调用

Lua中的"尾调用"就是一种类似于goto的函数调用,当一个函数调用是另一个函数的最后一个动作时,该调用才算是一条"尾调用".[一个函数在调用完另一个函数之后,是否就无其他事情需要做了] function f(x) return g(x) end   也就是说,当f调用完g之后,f所代表的整个函数的调用才算执行完成也就无其他事情可做了.因此,这种情况中,程序就不需要返回那个"尾调用"所在的函数了. 所以在"尾调用"之后,程序也

C 语言调用python 脚本函数

刚好几个月前做过,C++ 函数里面先加载python 脚本,再调用 里面的 def 函数,我把代码贴出来,你在main 函数里面,调用getDataByScript 函数,另外相同目录下放一个 fuckTest.py ,我是centos6.7   编译 g++ -o test test.cpp -lpython2.7      callPython.h #include<Python.h> #include<string> using namespace std;   char*

Python函数的循环调用

1 def foo (): 2 print 'runing foo' 3 bar () 4 5 def bar (): 6 print 'runing bar' 7 foo () 8 9 bar() 直接上脚本,上面的脚本如果换成C语言代码的话,foo函数前面肯定是要加一个bar函数的声明的,但是在Python中不需要,因为foo函数在未被调用前,不会判断bar函数是否合法,等到bar函数被调用的时候,bar函数已经被声明了,所以能找到. 因此Python也是支持循环调用的,A call B,

Python中函数、类、模块和包的调用

初学python阶段,大多数人对函数.类.模块和包的调用都搞得不是很清楚,这篇随笔就简单的进行说明. ?(1)函数 当函数定义好之后,可以直接调用. 比如:def summ(add1,add2),那么可以直接调用,即:summ(1,2) (2) 类 类定义好之后,不能像函数一样直接调用,而需要间接调用. 比如:class people,那么调用时,a=people(对象),之后,a.age()等等 (3) 模块 将多个类放在同一个py下,比如放在model.py中,则import model即可

python入门(13)获取函数帮助和调用函数

Python内置了很多有用的函数,我们可以直接调用. 要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数abs,只有一个参数.可以直接从Python的官方网站查看文档: http://docs.python.org/2/library/functions.html#abs 也可以在交互式命令行通过help(abs)查看abs函数的帮助信息. 调用abs函数: >>> abs(100) 100 >>> abs(-20) 20 >>> abs(1

[C++程序设计]用函数指针变量调用函数

指针变量也可以指向一个函数.一个函数在编译时被分配给一个入口地址.这个函数入口地址就称为函数的指针.可以用一个指针变量指向函数,然后通过该指针变量调用此函数 1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 int max(int,int); 7 int (*p)(int,int); 8 p = max; 9 int m, a, b; 10 cin >> a >> b; 11 m = p(