Python之函数、参数、局部全局变量、前向引用、递归

函数

函数:实现某种功能(数学形式、python def函数式编程)

过程:就是函数没有返回值

参数

1、形参 实参 位置参数 关键字参数 默认参数

 1 # 形参x,y不分配内存空间  实参2,3在调用的时候才分配空间,调用完毕就释放空间
 2 def calc(x, y):
 3     res = x ** y
 4     return res
 5
 6
 7 c = calc(2, 3)
 8 print(c)
 9
10
11 def test(x, y, z):
12     print(x)
13     print(y)
14     print(z)
15
16
17 # 位置参数(一一对应,缺一不行,多一不行)
18 test(1, 2, 3)
19 # 关键字参数(位置不固定,缺一不行,多一不行)
20 test(x=1, y=2, z=3)
21 # 混合使用:位置参数必须在关键字参数左边
22 test(1, 2, z=3)
23 # test(1, 2, z=3, y=4) # 特殊情况仍然要报错
24
25
26 # 默认参数
27 def handle(x, y=‘mysql‘):
28     print(x)
29     print(y)
30
31
32 handle(‘hello‘)
33 handle(‘hello‘, ‘sqlite‘)

2、参数组 *args(列表) **kwargs  (字典)

 1 # 参数组 **字典 *列表
 2
 3
 4 # def test(x, *args):
 5 #     print(x)
 6 #     print(args)
 7 #     print(args[0])
 8
 9
10 # test(1, 2, 3, 4, 5, 6)
11 # test(1, *[‘x‘, ‘y‘, ‘z‘])  # (‘x‘, ‘y‘, ‘z‘)
12 # test(1, [‘x‘, ‘y‘, ‘z‘])   # ([‘x‘, ‘y‘, ‘z‘],)
13
14 # def test(x, **kwargs):
15 #     print(x)
16 #     print(kwargs)
17 #
18 #
19 # test(1, y=2, z=3)   # {‘y‘: 2, ‘z‘: 3}
20
21
22 # def test(x, *args, **kwargs):
23 #     print(x)
24 #     print(args)
25 #     print(kwargs)
26 #
27 #
28 # test(1, 2, 3, 4, 5, y=1, z=2)
29 # test(1, *[1, 2, 3], **{‘y‘: 1})

局部变量与全局变量

1、局部变量:子程序中的变量(有缩进)

2、全局变量:没有缩进,在全局都可以使用

 1 # 局部与全局变量
 2 # name = "火爆哥"
 3 #
 4 #
 5 # def change_name():
 6 #     global name  # ------>其实是指针指向全局变量name的值
 7 #     name = "帅的一比"
 8 #     print(‘change_name‘, name)
 9 #
10 #
11 # change_name()
12 # print(name)
13
14 # name = "刚娘"
15 #
16 #
17 # def weihou():
18 #     name = "陈卓"
19 #
20 #     def weiweihou():
21 #         nonlocal name  # ----->nonlocal指针指向name="陈卓"(上一级) global是指向全局的变量name = "刚娘"
22 #         name = "冷静"
23 #     weiweihou()
24 #     print(name)
25 #
26 #
27 # print(name)  # 刚娘
28 # weihou()     # 冷静
29 # print(name)  # 刚娘

前向引用

 1 # def bar():
 2 #     print(‘from bar‘)
 3 #
 4 #
 5 # def foo():
 6 #     print(‘from foo‘)
 7 #     bar()
 8 #
 9 #
10 # foo()
11
12
13 # def foo():
14 #     print(‘from foo‘)
15 #     bar()
16 #
17 #
18 # def bar():
19 #     print(‘from bar‘)
20 #
21 #
22 # foo()
23 # 从这里可以说明函数即变量
24 # foo = ‘函数体‘

函数递归(先搞个简单的例子,后期持续更新中)

记住:一层层的进去然后再一层层的返回来(要有点节制,不能无穷无尽,官方说1300多层左右貌似)

递归:函数自己调用自己,且有终止条件即可

1 def clac(n):
2     print(n)
3     if int(n / 2) == 0:
4         return n
5     return clac(int(n / 2))
6
7
8 res = clac(10)
9 print(res)

上图来说

 



原文地址:https://www.cnblogs.com/Alexephor/p/11188277.html

时间: 2024-10-12 01:00:03

Python之函数、参数、局部全局变量、前向引用、递归的相关文章

python中函数参数的引用方式

值传递和引用传递时C++中的概念,在python中函数参数的传递是变量指向的对象的物理内存地址!!! python不允许程序员选择采用传值还是传引用.Python参数传递采用的肯定是"传对象引用"的方式.这种方式相当于传值和传引用的一种综合.如果函数收到的是一个可变对象(比如字典或者列表)的引用,就能修改对象的原始值--相当于通过"传引用"来传递对象.如果函数收到的是一个不可变对象(比如数字.字符或者元组)的引用,就不能直接修改原始对象--相当于通过"传值

python下函数参数的传递(*和**)

1.F(arg1,arg2,...) 这 是最常见的定义方式,一个函数可以定义任意个参数,每个参数间用逗号分割,用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等的 值(实际参数),而且顺序必须相同,也就是说在这种调用方式中,形参和实参的个数必须一致,而且必须一一对应,也就是说第一个形参对应这第一个实参.例 如: def a(x,y): print x,y 调用该函数,a(1,2)则x取1,y取2,形参与实参相对应,如果a(1)或者a(1,2,3)则会报错. 2.F(arg

Python的函数参数

前言 python中 函数的参数可以分为两大类形参和实参~ def func(x, y): # x, y 就是形参 print(x, y) func(2, 3) # 2, 3 就是实参 - 形参 形参(如上面的x, y)仅在定义的函数中有效,函数调用结束后,不能再使用该形参变量.在调用函数时,该函数中的形参才会被分配内存,并赋值:函数调用结束,分配的内存空间也随即释放~ - 实参 即在调用函数时,向该函数的形参传递确定的值(必须是确定的值).传递的值可以是常量.变量.表达式.函数等形式~ 在形参

python的函数参数基础(一)(可能和别人讲的不一样,稍微深入一点)

先让我说几句废话,函数(java里面叫方法)可能是我们了解python以后最基础的东西了(除了数据结构),写了无数个函数,你真的了解python的函数的设计逻辑以及思想吗? 先上一小段我们最经常写的代码,我简单剖析一下: 1 def func_test(x,y,z): 2 print(x,y,z) 3 return None 4 5 if __name__ == '__main__': 6 func_test(1,y=2,z=3) 上面这个代码很简单,就是定义了一个函数,让这个函数打印传入的三个

JavaScript中函数参数的值传递和引用传递

结论:对于数字.字符串等是将它们的值传递给了函数参数,函数参数的改变不会影响函数外部的变量. 对于数组和对象等是将对象(数组)的变量的值传递给了函数参数,这个变量保存的指向对象(数组)的地址.当函数改变这个地址指向的对象(数组)的内容时,同时也改变了函数外部变量指向的对象(数组)的内容:当函数改变的是变量的地址时,实际就与函数外部的变量失去了联系,变成了完全不同的对象了,不会对函数外部对象造成改变. 很多人认为 JS 中参数有两种传递方式:数字.字符串等按值传递:数组.对象等按地址(引用)传递.

Python的函数参数问题

先定义一个带默认参数的函数: def add_end(L=[]): L.append('END') return L 使用下面的代码调用该函数: print(add_end([1,2,3])) print(add_end()) print(add_end([1,2,3])) print(add_end()) 结果: 为什么第四行输出会是这样呢?看了廖雪峰老师的教程后,对此问题的理解为: 在定义完函数后,参数L的值就被计算出来了,并成为了一个类似于“全局变量”的东西,也就是说,一次调用函数完了之后

Python的函数参数和递归参数

位置参数 def power(x): return x*x; 默认参数 指的是在函数定义的时候,就赋予一些参数默认值,在调用这个函数的时候不必多次传入重复的参数值. 如定义一个多次输出同一个年龄阶段和同一个城市的学生的姓名和性别. def info(name,gender,age=20,city='sichuan'): print('name:', name) print('gender:', gender) print('age',age) print('city',city) info("x

python中函数参数*args和**kw的区别

1.函数与参数(实参) 在python中创建函数是def,创建函数名是def f(),f函数名字,def f(a,b),这里的a,b是两个参数,函数名是自定义的,参数也是自定义,随意就好.看图如下效果: 这里f(1,2)是实参,然后调用上面的函数. 下面讲解下*args和**kw的区别. 2.*args 这里的*后面的值是自定义的,只要不是数字就行,定义成*abc,*ccc都可以,len()是函数,它的意思是返回字符串长度.然后前面的a,b是普通参数,print a print b就是回显1,2

Python之函数参数介绍

Python的参数类型: 普通参数 默认参数 动态参数 普通参数 包括:形参和实参 形参就是形式参数,仅仅是写在函数中,并没有赋值和调用它 实参则是执行函数时用到的参数,它在内存中有赋值 例子: test(txt):     txt,test() 输出结果:hello this is a test 这里txt就是形参,'hello'则是实参 默认参数: 默认参数的要求: 1.不传,则使用默认值, 2.默认参数必须放在参数列表最后 calculation(x,y,z=):     x+y+z ca

【Python】函数参数类型及用法

 一.函数的参数类型 def hs(a1,a2,a3,...): ****statements 其中a1,a2,a3是函数的参数,函数的参数类型可分为:必须参数.默认参数.可变参数(不定长参数).关键字参数.组合参数,总共5种. 二.必须参数 其实我们之前举得例子就是必须参数,以下例子必须参数: >>>def hello(str): .... print('必须参数是:',str) >>>hello('hello,world') 我们可以看到在函数hello中,str作