05-python中函数的使用分分快三计划

作者:编程技术

这样会不会有点太死板了,我们希望能够从键盘输入a和b去获取这两个数的总和,那么需要怎么做呢?

2.printf函数

你可能已经注意到,平时一直在使用的printf其实也是一个函数,这是系统自带的函数

1 #include <stdio.h>  2   3 int main()  4 {  5       6     printf("我要学习iOS开发");  7       8     return 0;  9 }
  • 在第6行调用了printf函数,传入的参数是一个字符串常量:"我要学习iOS开发"
  • printf函数的作用是在屏幕上输出内容
  • 注意第1行代码,如果你使用了printf函数,就要加上这一句,至于原因,会在后面的章节详细介绍

 


def print_fozhu():  #首先在开始定义打印佛主的函数,函数名为print_fozhu
    print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\ = /O  ")
    print("                        ____/`---'\____  ")
    print("                      .   ' \| |// `.  ")
    print("                       / \||| : |||// \  ")
    print("                     / _||||| -:- |||||- \  ")
    print("                       | | \\\ - /// | |  ")
    print("                     | \_| ''\---/'' | |  ")
    print("                      \ .-\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\ `. . __  ")
    print("                ."" '< `.___\_<|>_/___.' >'"".  ")
    print("               | | : `- \`.;`\ _ /`;.`/ - ` : | |  ")
    print("                 \ \ `-. \_ __\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖镇楼                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  写字楼里写字间,写字间里程序员;  ")
    print("                  程序人员写程序,又拿程序换酒钱。  ")
    print("                  酒醒只在网上坐,酒醉还来网下眠;  ")
    print("                  酒醉酒醒日复日,网上网下年复年。  ")
    print("                  但愿老死电脑间,不愿鞠躬老板前;  ")
    print("                  奔驰宝马贵者趣,公交自行程序员。  ")
    print("                  别人笑我忒疯癫,我笑自己命太贱;  ")
    print("                  不见满街漂亮妹,哪个归得程序员?")

print_fozhu()    #然后在下面调用print_fozhu函数
print_fozhu()

五、return

带有参数的函数

1.返回值就是函数调用完后,返回给函数调用者的结果,用return关键字进行返回。定义函数时,要指明函数的返回值类型

 1 double pi()   2 {   3     return 3.4;   4 }   5    6 int main()   7 {   8     double a = pi();   9     return 0;  10 }
  • 第1行定义了一个pi函数,返回值类型是double,因此用return返回的数值应该是double类型的,这里返回的是3.14
  • 第8行pi函数调用完毕后,函数调用者得到的值就是3.14,因此,变量a的值是3.14

 

def get_wendu():    #这里定义一个获取温度的函数get_wendu
    wendu = 22    #定义一个wendu变量
    print("当前的室温是%d"%wendu)

def get_wendu_huashi():  #定义一个获取华氏温度的函数get_wendu_huashi
    wendu = wendu   2  #假设华氏温度=温度 2
    print("当前的室温(华氏)是%d"%wendu)

get_wendu_huashi()  #调用刚刚定义的函数,get_wendu_huashi

让我们看一下运行结果:
Traceback (most recent call last):
  File "02-获取温度.py", line 10, in <module>
    get_wendu_huashi()
  File "02-获取温度.py", line 7, in get_wendu_huashi
    wendu = wendu   2
UnboundLocalError: local variable 'wendu' referenced before assignment  #这句话表示在声明变量wendu之前就已经对其调用,定位到错误的地方了

1.return语句可以在函数内部返回一个值给函数调用者

 1 int sum(int a, int b)   2 {   3     return a   b;   4 }   5    6 int main()   7 {   8     int c = sum(5, 8);   9     return 0;  10 }

第3行使用了return语句,将a b的值返回给了函数调用者,因此第8行变量c的值是13

 

让我们来看一下修改后的代码:

1.函数名不能重复

默认情况下,函数的名字必须唯一。下面的写法是错误的:

1 void test(int a)  2 {  3   4 }  5   6 int test()  7 {  8     return 10;  9 }

第1、6行定义的函数的名称都是test,编译器会直接报错

 

6.到了b = test(),进入函数,a = 11,b = 22,然后return a,结果被赋值给了b,此时b等于11,所以a和b的结果是一样的

一、基本概念

In [1]: def test():    #定义一个test函数
   ...:     a = 11     #变量a
   ...:     b = 22     #变量b
   ...:     return a  
   ...:     return b
   ...: 

In [2]: a = test()  #调用test函数,并把它的结果赋值给a

In [3]: a
Out[3]: 11

In [4]: b = test()  #调用test函数,并把他的结果赋值给b

In [5]: b
Out[5]: 11

2.函数名

一般来说,我们会将不同的功能交给不同的函数去实现。比如,将暂停播放MP3的代码写到一个函数中,将停止播放MP3的代码写到另一个函数中。因此,一个C程序中可能会有很多的函数。为了方便调用和区分这些函数,我们需要为每一个函数都起一个唯一的名称,函数的命名必须按照标识符命名规则。利用函数名就可以调用到对应的函数。

 

那么为什么a和b的值是一样的呢?我们来看一下流程:

1.main函数

从第一个C语言程序开始,就认识了这个main函数。main函数是整个C程序的入口,有了main函数,C程序才能运行成功,而且整个C程序中只能有一个main函数。

main函数的简单定义如下:

1 int main()  2 {  3       4     return 0;  5 }

它可以没有形式参数,返回值是int类型。它的返回值用于说明程序的退出状态:如果返回0,则代表程序正常退出,否则代表程序异常退出

 

In [1]: name = input("Name:")
Name:laowang

In [2]: name
Out[2]: 'laowang'  #相当于才从键盘获取了一个值,然后拿给了name

三、形式参数和实际参数

 

2.举例

比如定义一个函数用来计算两个整数的和。那么可以写成下面这样:

 1 #include <stdio.h>   2    3 int sum(int a, int b)   4 {   5     int c = a   b;   6     return c;   7 }   8    9 int main()  10 {  11     int d = sum(10, 11);  12       13     printf("d is %d", d);  14     return 0;  15 }
  • 分别在第3行、第9行定义了sum函数、main函数,其中sum函数的作用是计算两个整数的和。
  • 函数定义好后,并不会马上执行函数内部的代码,要有人调用它才会执行内部的代码。就好像你的手机虽然有打电话的功能,但是只有按了拨号键,才会执行打电话的功能。
  • 程序运行时就会先调用main函数,按顺序执行第11~14行代码,因为main函数是程序的入口
  • 第11行的sum(10, 11)是调用sum函数,sum函数被调用了,就会分配存储空间给形式参数列表中的所有参数,也就是第3行中的变量a和变量b,它们都是“形式参数”
  • 第11行中的10、11称为“实际参数”,它们将分别赋值给变量a、变量b,也就是相当于

    1 int a = 10; 2 int b = 11;

  • 既然调用了sum函数,就会按顺序执行sum函数中的代码,也就是第5~6行代码。

  • 第5行将a b的值21赋值给了变量c,第6行使用return关键字将变量c返回给了函数调用者,也是说,第11行sum(10, 11)的值是21。那么变量d的值就是21。
  • 第13行的输出结果为:

    d is 21

  • 第3~7行中的变量a、b、c都只有在调用sum函数时,才会分配存储空间,当sum函数执行完毕后,变量a、b、c就会被释放存储空间。因此,它们的作用域仅限于sum函数内部。

  • 第3行sum左边的int称为“返回值类型”,第6行return关键字后面跟着的数值称为“返回值”,因此第6行的变量c就是返回值,返回值的数据类型应该跟“返回值类型”保持一致。

 

那么,我们现在来举一个例子来说明return的作用:

四、返回值类型

3.使用return返回a的值和b的值

2.一个函数内部可以多次使用return语句,使用了return语句后,函数就会马上停止执行,return语句后面的代码就不再被执行

1 int max(int a, int b)  2 {  3     if (a>b)  4     {  5         return a;  6     }  7       8     return b;  9 }
  • 这个max函数可以用来求出两个整数中的最大值
  • 如果a大于b,就执行第5行代码,直接将a返回,函数就会停止执行。也就是说,后面的第8行代码就不会被执行
  • 如果a不大于b,就执行第8行代码,将b返回

 

return的作用:所谓“返回值”,就是程序中函数完成一件事情后,最后给调用者的结果

2.每一个函数都应该独立定义,不能嵌套定义

下面的写法是错误的:

1 int main()  2 {  3     void test()  4     {  5       6     }  7       8     return 0;  9 }

在第3行把test函数定义在了main函数内部,这是错误的写法

 

那么这个时候我们想打印很多遍佛主的话,总不能一直复制粘贴,所以我们需要定义一个打印佛主函数:

3.当使用基本数据类型(char、int、float等)作为实参时,实参和形参之间只是值传递,修改形参的值并不影响到实参

 1 #include <stdio.h>   2    3 int test(char a)   4 {   5     a = 10;   6        7     return 0;   8 }   9   10 int main()  11 {  12     char b = 5;  13       14     test(b);  15       16     printf("b的值是%d", b);  17       18     return 0;  19 }
  • 在第3行定义了test函数,只有一个形参a
  • 在第14行调用了test函数,接着就会分配内存给变量a。这里将变量b当做实参,那么变量b的值将传递给变量a。这个时候,内存中大致如下图所示:

分分快三计划 1

(其实在内存中存储的是二进制数据,这里我写成10进制是为了直观性)

  • 执行完第5行代码后,变量a的值变成了10,但是变量b的值依然是5

分分快三计划 2

  • 第16行代码的输出结果是:

    b的值是5

因此,在函数内部修改了形参的值,并不会影响到外面的实参。

 

 

2.调用函数时传递的实参个数 必须和 函数的形参个数必须保持一致

 1 int sum(int a, int b, int c)   2 {   3     return a   b   c;   4 }   5    6 int main()   7 {   8     sum(10, 9, 7);   9     return 0;  10 }

第1行中sum函数中有3个形参,因此在第8行调用sum函数时,需要传入3个实参

 

 

1.任何一个函数在使用之前都必须进行定义

定义函数的目的就是为了写清楚你这个函数是干啥用的,里面包含了哪些代码。函数的定义格式如下:

1 返回值类型  函数名(形式参数列表)  2 {  3     函数体  4 }

 

函数:就是让程序模块化,把具有独立功能的代码块当成一个整体封装成一个函数

1.什么是函数

任何一个C语言程序都是由一个或者多个程序段(小程序)构成的,每个程序段都有自己的功能,我们一般称这些程序段为“函数”。所以,你可以说C语言程序是由函数构成的。

比如你用C语言编写了一个MP3播放器程序,那么它的程序结构如下图所示:

分分快三计划 3

  • 从上图可以看出:函数就是用来实现某个功能的程序段,每一个函数都有自己的功能。因此,你应该把实现某个功能所需的代码都写在函数中。比如,有个函数的功能是播放MP3,那么播放MP3的代码都应该写到这个函数中。
  • 当调用(执行)一个函数时,计算机就会按顺序执行函数中的所有代码,从而展示函数所实现的功能。

 

为什么呢?因为在函数中,每调用一次函数就从函数从头开始做,可以写多个return,但是当进入函数时,一看见return程序就会结束,所以a和b的结果是一样的了

二、函数的定义

2.在test函数中定义了两个变量a和b,并分别复制a = 11,b = 22

3.如果一个函数没有返回值,最后面的return语句可以省略

所以,上面的test函数可以简化成:

1 void test()  2 {  3     printf("调用了test函数");  4 }

 

首先我们来定义一个函数来计算两个数的总和:

六、函数定义的注意

5.然后开始进入函数,a = 11,b = 22,然后return a,结果赋值给了a,此时的a等于11,程序结束

4.函数可以没有形参

定义一个函数时是可以没有形参的,比如下面的函数

 1 #include <stdio.h>   2    3 int test()   4 {   5     printf("调用了test函数");   6     return 0;   7 }   8    9 int main()  10 {  11     test();  12     return 0;  13 }
  • 在第3行定义了test函数,可以发现,它的形参列表是空的,也就是没有形参
  • 那么在第11行调用test函数时,就不用传递任何实参
  • 其实,第9行定义的main函数也是没有形参的

 

函数的嵌套使用

指在一个函数被调用的过程里,又调用了一个函数,举例说明一下:

def test1():
    pass

def test2():
    print("-----2-1-----")
    print("-----2-2-----")

def test3():
    print("-----3-1-----")
    test2()  #在函数里面调用test2函数
    print("-----3-2-----")

test3()  #调用test3函数

程序运行结果如下:
-----3-1-----
-----2-1-----
-----2-2-----
-----3-2----

def print_line():  #定义一个函数,打印40个*
    print("*"*40)  

def print_5_lines():  #定义一个函数,打印5行
    i = 0
    while i<5:
        print_line()  #又签到调用了print_line函数
        i  = 1
print_5_lines()

程序运行结果如下:

root@test:~/codes# python3 04-函数的嵌套调用2.py 
****************************************
****************************************
****************************************
****************************************
***************************************

 

4.如果一个函数没有明确写出返回值类型,那么代表这个函数的返回值类型是int

1 sum(int a, int b)  2 {  3     return a   b;  4 }

可以看到,第1行定义的sum函数没有明确写出返回值类型,那么这个sum函数的返回值类型就是int。因此,第3行return后面跟随的是int类型数据

 

def sum():  #表示定义一个函数,函数名为sum
    a = 20
    b = 30
    sum = a b
    print("%d %d=%d"%(a,b,sum))

sum()  #在下面调动这个函数

七、常见函数

1.定义了一个test函数

前面已经讲完了C语言中的基本语句和基本运算了,这讲呢,介绍C语言中的重头戏---函数。其实函数这个概念,在大部分高级语言中都是非常重要的,我也已经在《第一个C语言程序》一讲中对函数作了一个简单介绍。

In [6]: def test():
   ...:     a = 11
   ...:     b = 22
   ...:     return a,b
   ...: 

In [7]: a,b = test()

In [8]: print(a)
11

In [9]: print(b)
22

2.一个函数可以没有返回值,如果没有返回值,应该用void表示返回值类型

 1 #include <stdio.h>   2    3 void test()   4 {   5     printf("调用了test函数");   6     return;   7 }   8    9 int main()  10 {  11     test();  12     return 0;  13 }
  • 在第3行定义了一个test函数,它是没有返回值的,所以第6行的return后面没有跟上任何数值
  • 在第11行调用了test函数

 

总结:如果在一个函数中有了return,那么就意味着这个函数可以把一个值,一个结果返回到调用的地方,return时需要有个东西把结果存放起来,然后在传入时把这个东西存进去

1.基本概念

1> 形式参数:在定义函数时,函数名后面的小括号()中定义的变量称为形式参数,简称形参

2> 实际参数:在调用函数时传入的值称为实际参数,简称实参

 

比如:我给了我的朋友22块钱,让他帮我去买一包烟,然后朋友买完回来了把烟交给我,这个烟就是返回值

def sum(a,b):  #在上面定义搞一个函数,函数名为sum,并且携带两个参数a,b,用来接收的叫做形参
    sum = a b
    print("%d %d=%d"%(a,b,sum))

num1 = int(input("第1个值:"))    #input键盘输入的值是字符串类型,需要用int()转换成整形
num2 = int(input("第2个值:"))
sum(num1,num2)  #在调用sum函数时,等于把num1和num2传到sum()函数里去,调用时的传的参数叫做实参

root@test:~/codes# python3 01-带有参数的函数-input.py 
第1个值:    10
第2个值:50
10 50=60

首先打印一个佛主看看:

函数的类型

函数可以根据有没有参数,有没有返回值,可以相互结合

(1)无参数,无返回值

(2)无参数,有返回值

(3)有参数,无返回值

(4)有参数,有返回值

如果一个函数想要有多个return,可以写多个return,但是函数一旦运行到return,函数就会结束,如下:

4.调用test函数,并把它赋值给了a

其次,在获取键盘输入时,也是这种道理:

def get_wendu():
    wendu = 22
    print("当前的室温是%d"%wendu)
    return wendu  #在这里我们使用了return函数,那么意味着我们可以把这个值、这个结果返回到调用的地方

def get_wendu_huashi(wendu):  #wendu是形参,用来接收的
    wendu = wendu   2
    print("当前的室温(华氏)是%d"%wendu)
result = get_wendu()  #return时需要有个容器来把结果存放起来,然后再传入时,把这个结果给存进去
get_wendu_huashi(result)  #在调用get_wendu_huashi函数时,把result这个变量作为实参给传送到函数里去

运行结果如下:
root@test:~/codes# python3 !$
python3 02-获取温度.py
当前的室温是22
当前的室温(华氏)是24

大功告成.....

让我来解释一下:在函数中定义的变量,只允许在当前函数中使用,在其他函数里不能用,而且函数中不允许直接调用结果那么意思就是在get_wendu中定义的变量wendu,到了get_wendu_huashi中却不认识这个wendu变量

print("                            _ooOoo_  ")
print("                           o8888888o  ")
print("                           88  .  88  ")
print("                           (| -_- |)  ")
print("                            O\ = /O  ")
print("                        ____/`---'\____  ")
print("                      .   ' \| |// `.  ")
print("                       / \||| : |||// \  ")
print("                     / _||||| -:- |||||- \  ")
print("                       | | \\\ - /// | |  ")
print("                     | \_| ''\---/'' | |  ")
print("                      \ .-\__ `-` ___/-. /  ")
print("                   ___`. .' /--.--\ `. . __  ")
print("                ."" '< `.___\_<|>_/___.' >'"".  ")
print("               | | : `- \`.;`\ _ /`;.`/ - ` : | |  ")
print("                 \ \ `-. \_ __\ /__ _/ .-` / /  ")
print("         ======`-.____`-.___\_____/___.-`____.-'======  ")
print("                            `=---='  ")
print("  ")
print("         .............................................  ")
print("                  佛祖镇楼                  BUG辟易  ")
print("          佛曰:  ")
print("                  写字楼里写字间,写字间里程序员;  ")
print("                  程序人员写程序,又拿程序换酒钱。  ")
print("                  酒醒只在网上坐,酒醉还来网下眠;  ")
print("                  酒醉酒醒日复日,网上网下年复年。  ")
print("                  但愿老死电脑间,不愿鞠躬老板前;  ")
print("                  奔驰宝马贵者趣,公交自行程序员。  ")
print("                  别人笑我忒疯癫,我笑自己命太贱;  ")
print("                  不见满街漂亮妹,哪个归得程序员?")

修改程序如下:

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划