1.函数是如何,前边写函数的名字

定义

函数是指将一组语句的集纳通过多少个名字(函数名)封装起来,要想举行这些函数,只需调用其函数名即可。

  3.递归功效不高,递归层次过多会招致栈溢出(在电脑中,函数调用是透过栈那种数据结构完结的,每当进入二个函数调用,栈就会加一层栈帧,每当函数再次回到,栈就会减一层栈帧,由于栈的分寸不是极其的,全数,递归调用的次数过多,会促成栈溢出)

函数的始建

python中开创函数,需求使用__def__重在字,前边写函数的名字,然后是形参列表,大体如下:

def 函数名(形参列表):
    函数体......
    return 返回值

其中形参列表和 return再次回到值并不是必须的。

  2.老是进入更深一层递归,难点规模相比上次递归都应拥有回落

一对变量和全局变量

在python中,函数外部注明的变量大家称为全局变量,在函数内部宣称的变量是局部变量。

全局变量可以在变量申明之后的别的岗位拔取,而有个别变量只好够在函数内部使用。

'''全局变量和局部变量'''
name = '李白' # 函数外部声明 ,称之为全局变量

def test():
    age = 20 # 函数内部声明,称之为局部变量
    print(age) # 局部变量只能够在函数内部使用
    print(name) # 全局变量可以在函数内部使用
test()
# print(age) 在函数外部没有办法使用局部变量

__tip:函数内部宣称全局变量__

比方想要在函数内部宣称全局变量,需求利用global关键字

def test():
    global test
    test = '李白斗酒诗百篇'
test()
print(test) # 李白斗酒诗百篇

透过global关键字就可以在函数内部创建全局变量,不过这种写法是不引进应用的,有或者导致变量污染。

还有某个急需专注,看下边的代码:

name = '艳艳'

def test():
    # 在函数中更改全局变量name的值
    name = 'hello,world'
    print(name) # hello,world
test()
print(name) # 艳艳

上述代码中,在函数中对全局变量进行了变动,并且打印更改之后的变量,那么打印的结果是更改的结果,不过在函数的外围再度打印在函数中改变的全局变量,发现结果并从未被更改,因为在函数中改变全局变量,那么更改过后的值作用域仅停留在函数当中。

那就是说怎么样在函数中对全局变量更改并且在函数外部调用结果为转移之后的值吗?同样可以接纳global关键字来贯彻。

name = '艳艳'

def test():
    global name
    # 在函数中更改全局变量name的值
    name = 'hello,world'
    print(name) # hello,world
test()
print(name) # hello,world
 1 name='marry'#字符串全局变量
 2 names=[]#list全局变量
 3 print(name)
 4 print(names)
 5 def test():
 6     global name #修改name的值就需要用global关键字
 7     name='Sriba'
 8     names.append(name)#修改全局变量names的值
 9     return names
10 test()#调用函数
11 print('修改后',name)
12 print('修改后names',names)

 1 a=100#全局变量
 2 def test():
 3     a=5
 4     print('里面的',a)
 5 def test2():
 6     b=1
 7     print(a)
 8 test()
 9 test2()
10 print('外面的',a)
11 #打印结果:
12 #里面的 5
13 #100
14 #外面的 100

 1 a=100#全局变量
 2 def test():
 3     global a #声明全局变量
 4     a=5#修改全局变量
 5     print('里面的',a)
 6 def test2():
 7     b=1
 8     print(a)
 9 test()
10 test2()
11 print('外面的',a)
12 #打印结果:里面的 5
13 #               5
14 #             外面的 5    

1 def test():
2     global a
3     a=5
4 def test1():
5     c=a+5
6     return c
7 test()
8 res=test1()
9 print(res)#打印结果:10

非固定参数

假定你的函数中并不是很显然用户会流传几个参数,那么就可以动用非固定参数。

'''非固定参数'''
def test01(x,y,*args):
    print(x,y)
    print(args)

test01('李白','艳艳',12,3,4)

输出结果为:

李白 艳艳
(12, 3, 4)

急需小心的是,当使用了*args的时候,会发觉传入的参数全体被放在了二个元组中。那么只要想要操作的话只需听从元组的操作方法操作即可。

非固定参数除了可以变换来元组以外,还足以将盛传的数目转换来字典,须要动用**kwargs,代码如下:

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式
    print(name,age,args,kwargs)

stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空

stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

  全局变量就是在方方面面程序里面都见效的,在先后最前方定义的都以全局变量,全局变量假设要在函数中修改的话,需求加global关键字注脚,固然是list,字典和聚合的话,则不需求加global关键字,直接就可以修改。

暗中同意参数

先是,先来看下边的代码:

def stu_register(name,age,country,course):
    print('------注册学生信息--------')
    print('学员姓名:',name)
    print('学员年龄:',age)
    print('学员国籍:',country)
    print('学员选择课程:',course)

stu_register('小明',19,'中国','web前端')
stu_register('小红',20,'中国','linux')
stu_register('李白',25,'中国','python')

在上头的实例中,每1个学童登记的国籍都以华夏,而在网上的部分网站中,假设不去手动设置,都暗中认同为中国,那就是透过暗中认可参数完成的。

一般来说,把country变成默许参数,

def stu_register(name,age,course,country='中国')

那就是说此时再登记学员的时候就算国籍是炎黄就足以不须要实行国籍的传参,而是拔取暗许的参数。

4.函数的参数

python 函数

1 def s_int(n):
2     #这个函数的作用是把传入的参数类型转换成int类型
3     return int(n)
4 def add(x,y,z):
5     #这个函数的意思,接收3个参数,x,y,z,z是一个函数
6     print(z(x)+z(y))#这个执行过程是这样的,z是一个函数,把x和y的值传给z,然后用z函数的返回值把两个值相加
7 add('8','9',s_int)#调用,传入x和y的值,再把上面的那个定义好的函数传进去

重中之重参数

好端端情状下,给函数传参数要按梯次,不想按顺序就能够用关键参数,只需点名参数名即可,但切记多少个渴求就是,关键参数必须放在位置参数之后。

# 使用关键字参数
stu_register(name='小明',country='中国',age=19,course='linux')
'''关键字参数必须放在位置参数之后'''
stu_register('小红',country='中国',age=19,course='linux')

  简化代码

返回值

要想拿到函数的施行结果,就足以用return语句把结果重返

注意:

函数在实施进度中倘若遭逢return语句,就会终止实施并重返结果,so
也能够知道为 return 语句代表着函数的完工
假使未在函数中指定return,那那些函数的重返值为None 。

  关键字参数使用**来采取,前边的参数也是不稳定的,想写多少个写多少个,当然也可以和方面的两种一起来使用,若是要一起利用以来,关键字参数必须在结尾面。

函数的行使

想要调用函数程序,必要以函数名加括号的方式开展调用,而括号内可以流传参数,而括号内的参数大家誉为__实参列表__,传入的实参会通过形参传递进函数,在函数内部就足以使用了。如下:

def add(x,y):
    return x + y

# 调用函数
add(10,20)

亟需专注的是,python中的实参列表每壹个参数从前用逗号分割,而向add()括号内的10,20这么的参数我们誉为地点参数(positional
argument)。

那就是说必要留意的是,在python中,函数的实参的个数必须和形参的个数一样,实参个数多于形参可能少于形参都会报错。

  函数在调用的时候,能够流传参数,有形参和实参

递归函数

在函数内部,能够调用其余函数。假若1个函数在里边调用自小编本身,那个函数就是递归函数。

'''创建一个递归,将传入的参数不断的除以2,到0为止'''
def calc(n):
    print(n)
    if int(n/2) > 0 :
        return calc( int(n/2) )

calc(10)

出口结果为:

10
5
2
1

递归本性:

  1. 非得有三个肯定的完成条件

  2. 历次进入更深一层递归时,难点规模比较上次递归都应具备减弱

  3. 递归效用不高,递归层次过多会招致栈溢出(在电脑中,函数调用是经过栈(stack)那种数据结构完结的,每当进入二个函数调用,栈就会加一层栈帧,每当函数重临,栈就会减一层栈帧。由于栈的高低不是极其的,所以,递归调用的次数过多,会招致栈溢出)

堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

  可变参数用*来接过,前面想传多少个参数就传多少个,如若地点参数,私自认同值参数,可变参数一起利用以来,可变参数必须在职责参数和暗中同意值参数前面,可变参数也是非必传的。

函数的参数

形参也足以叫做形参变量,唯有在被调用时才分配内存单元,在调用截至时,即自由所分配的内存单元。所以形参只好在函数内部生效。函数调用为止再次来到主调用函数后则不可以再使用该形参变量。

实参能够是常量、变量、表明式、函数等,无论实参是何种类型的量,在开展函数调用时,它们都不可以不有显然的值,以便把那几个值传送给形参。由此应优先用赋值,输入等形式使参数拿到鲜明值

图片 1

  1.须要有贰个远近出名的截至条件

特性

  1. 缩减代码重复
  2. 使程序变得可扩张
  3. 使程序变得简单维护

  定义函数使用def关键字,后边是函数名,函数名不可以再度

5.函数的重返值

  可变参数:

1.函数是何许?

  局地变量意思就是在一部分生效的,出了那几个变量的成效域,这几个变量就失效了,比如下面的c就是三个有个别变量,出了那么些函数之后,就不曾c那一个值了

  暗许参数:

1 def test1():
2     num = int(input('please enter a number:'))
3     if num%2==0:#判断输入的数字是不是偶数
4        return True #如果是偶数的话,程序就退出了,返回true
5     print('不是偶数请重新输入!')
6     return test1()#如果不是偶数的话继续调用自己,输入值
7 print(test1())#调用test

3.python中函数的概念:

  提升代码的复用性

1 del calc(x,y)#定义一个函数,参数有下x和y,x和y就是形参
2     print(x*y)#输出x乘以y的值
3 calc(5,2)#调用上面定义的函数,5和2就是实参

  下边的三种职位参数和专断认同参数都以参数个数是原则性的,若是说作者3个函数,参数不是定点的,作者也不知情未来这几个函数会增加成啥样,大概参数越多,那些时候假诺再用固定的参数,那背后程序就不佳扩充了,那些时候就可以用非固定参数了,非固定参数有三种,一种是可变参数,一种是最主要字参数。

  暗中同意参数就是在概念形参的时候,给函数默许赋3个值,比如说数据库的端口那样的,暗中认可给它三个值,那样即使你在调用的时候没传入那个参数,它也是有值的;由此,默许参数不是必填的,尽管给暗中承认参数传值的话,它就会接纳传入的值。若是利用默许参数的话,必须放在地点参数前边定义。

  形参变量唯有在被调用时才被分配内存单元,在调用为止时,马上释放所分配的内存单元。由此,形参只在函数内部有效。

  形参:

8.高阶函数:二个函数的参数是1个函数,那么这一个函数就是贰个高阶函数。

  逐个函数都有返回值,借使没有在函数里面指定重返值的话,在python里面函数执行完未来,默许会重返三个None,函数也得以有八个重返值,若是有八个重临值的话,会把再次来到值都停放1个元组中,再次来到的是3个元组。为啥要有再次回到值呢,是因为在那一个函数操作完之后,它的结果在后面的程序里面须求用到。函数中的重返值使用return,函数在遭逢return就登时终止。

  代码可增加

  地方参数:

 

  非固定参数:

1 def test2(a,**kwargs):
2     print(kwargs)#字典类型
3     print(a,kwargs)
4 test2(a=1,name='hhhh',sex='nv')#{'sex': 'nv', 'name': 'hhh'}
5                                 #1 {'sex': 'nv', 'name': 'hhh'}        

2.函数的功利:

递归调用的特征:

  定义:函数是指一组语句的集合通过二个名字(函数名)封装起来,只需调用函数名即可。

  地点参数,字面意思也等于坚守参数的地方来展开传参,比如说上边的calc函数,x和y就是岗位参数,地点参数是必传的,有多少个职务参数在调用的时候将要传多少个,否则就会报错了,那借使有多个职位参数的话,记不住哪个岗位传哪个了,可以利用地点参数的名字来指定调用

  关键字参数:

1   def fun():#定义一个函数,后面是函数名
2       print("Hello World")#函数体

  实参可以是常量,变量,表达式,函数等,无论实参是何系列型的量,在开展函数调用时,它们都无法不有规定的值,以便把那么些值传送给形参。函数调用停止再次来到主调用函数后则不可以再使用该形参变量。形参是函数接收的参数,而实参就是您实际传入的参数。

1 def conn_mysql(user,passwd,port=3306):#定义一个连接mysql的方法,虽然这个方法并没有连接mysql,我只是举个默认值参数的例子,port就是一个默认值参数
2     print(user,passwd,port)
3 coon_mysql('root','123456')#没指定默认值
4 coon_mysql('root','123456',port=3307)#指定默认值参数的值

  在函数内部,可以调用其余函数。假如贰个函数在其中调用小编本人,这些函数就是递归函数。递归调用的情致就是,在这些函数内部团结调用自个儿,就有点循环的情趣。

6.局地变量和全局变量

运用首要字参数的话,调用的时候必须使用首要字传参。关键字参数也是非必传的。

1 def calc(x,y):#这个就是定义了一个有返回值的函数
2     c = x*y
3     return c,x,y
4 res = calc(5,6)#把函数的返回结果赋值给res
5 print(res)
 1 def test (a,b=1,*args):
 2     print('a',a)
 3     print('b',b)
 4     print('args',args)
 5     print(args[0])
 6 
 7 test('hahaha')#a hahahha  b 1  args ()
 8 test('hahahha',2,'123','456','789')#a hahahha b 2 args ('123', '456', '789') 位置调用
 9 
10 test(b=5,a=10)#关键字调用 a 10   b 5  args ()

  函数的三种形参类型:

例如下面的calc函数也能够利用calc(y=1,x=2)这样来调用,那种调用方式叫做关键字传参

  实参:

7.递归调用

相关文章

网站地图xml地图