简单来讲介绍下python中等高校函授数的底蕴语法葡京在线官网,python学习笔记

python 函数

壹.函数是怎样?

定义

函数是指将1组语句的聚合通过三个名字(函数名)封装起来,要想实行那些函数,只需调用其函数名即可。

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

特性

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

二.函数的益处:

函数的创办

python中开创函数,必要使用__def__最主要字,前面写函数的名字,然后是形参列表,大体如下:

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

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

  简化代码

函数的行使

想要调用函数程序,要求以函数名加括号的花样开始展览调用,而括号内能够流传参数,而括号内的参数大家称为__实参列表__,传入的实参会通过形参传递进函数,在函数内部就足以接纳了。如下:

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

# 调用函数
add(10,20)

急需专注的是,python中的实参列表每三个参数在此之前用逗号分割,而向add()括号内的十,20这么的参数大家誉为地点参数(positional
argument)。

这便是说供给留意的是,在python中,函数的实参的个数必须和形参的个数1样,实参个数多于形参大概少于形参都会报错。

  提升代码的复用性

函数的参数

形参也足以叫做形参变量,唯有在被调用时才分配内部存款和储蓄器单元,在调用甘休时,即自由所分配的内部存款和储蓄器单元。所以形参只可以在函数内部生效。函数调用甘休再次回到主调用函数后则不可能再使用该形参变量。

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

葡京在线官网 1

  代码可扩充

暗中认可参数

首先,先来看上面包车型大巴代码:

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

在下面的实例中,每贰个学员登记的国籍都是中华,而在网上的有的网址中,假设不去手动设置,都暗中认可为中国,那就是由此暗中认可参数实现的。

如下,把country变成私下认可参数,

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

那正是说此时再登记学员的时候借使国籍是中华夏族民共和国就足以不必要展开国籍的传参,而是采纳私下认可的参数。

三.python中等高校函授数的定义:

首要参数

葡京在线官网,健康状态下,给函数字传送参数要按顺序,不想按顺序就能够用关键参数,只需点名参数名即可,但切记一个供给就是,关键参数必须放在地方参数之后。

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

  定义函数使用def关键字,后边是函数名,函数名无法再度

非固定参数

假定您的函数中并不是很明确用户会传播多少个参数,那么就能够使用非固定参数。

'''非固定参数'''
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'}
1   def fun():#定义一个函数,后面是函数名
2       print("Hello World")#函数体

有个别变量和全局变量

在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

四.函数的参数

返回值

要想拿到函数的推行结果,就足以用return语句把结果回到

注意:

函数在举行进程中要是境遇return语句,就会终止实施并赶回结果,so
也足以精通为 return 语句代表着函数的竣事
如若未在函数中内定return,那这么些函数的再次回到值为None 。

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

递归函数

在函数内部,能够调用别的函数。假使一个函数在里面调用本身自个儿,那么些函数就是递归函数。

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

calc(10)

输出结果为:

10
5
2
1

递归个性:

  1. 不可能不有1个分明的截止条件

  2. 历次进入更深一层递归时,难题规模相比上次递归都应有所缩短

  3. 递归成效不高,递归层次过多会招致栈溢出(在电脑中,函数调用是透过栈(stack)那种数据结构达成的,每当进入贰个函数调用,栈就会加1层栈帧,每当函数再次回到,栈就会减壹层栈帧。由于栈的尺寸不是极致的,所以,递归调用的次数过多,会促成栈溢出)

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

  形参:

  形参变量唯有在被调用时才被分配内部存款和储蓄器单元,在调用甘休时,马上释放所分配的内部存储器单元。由此,形参只在函数内部有效。

  实参:

  实参能够是常量,变量,表明式,函数等,无论实参是何连串型的量,在展开函数调用时,它们都不可能不有明确的值,以便把这一个值传送给形参。函数调用甘休重回主调用函数后则不能够再使用该形参变量。形参是函数接收的参数,而实参就是你实在传入的参数。

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

  函数的多种形参类型:

  地点参数:

  地方参数,字面意思也正是比照参数的岗位来开始展览传参,比如说上边包车型地铁calc函数,x和y正是岗位参数,地点参数是必传的,有多少个职位参数在调用的时候将要传几个,不然就会报错了,那即使有多个岗位参数的话,记不住哪个岗位传哪个了,能够采取地点参数的名字来钦定调用

譬如说上边的calc函数也足以使用calc(y=一,x=二)那样来调用,那种调用情势叫做关键字传参

  暗中认可参数:

  默许参数正是在概念形参的时候,给函数私下认可赋3个值,比如说数据库的端口这样的,暗中同意给它1个值,这样尽管你在调用的时候没传入这么些参数,它也是有值的;因而,默许参数不是必填的,尽管给暗中认可参数字传送值的话,它就会使用传入的值。倘诺应用私下认可参数的话,必须放在地点参数后边定义。

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)#指定默认值参数的值

  非固定参数:

  下边的二种职位参数和默许参数都以参数个数是定位的,倘诺说作者二个函数,参数不是固定的,作者也不明白以后那几个函数会扩展成啥样,大概参数越多,那一年假设再用固定的参数,那背后程序就倒霉扩充了,那个时候就能够用非固定参数了,非固定参数有三种,一种是可变参数,1种是重点字参数。

  可变参数:

  可变参数用*来收取,前边想传多少个参数就传多少个,假使地方参数,暗许值参数,可变参数壹起使用以来,可变参数必须在职位参数和暗中同意值参数前面,可变参数也是非必传的。

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

  关键字参数:

  关键字参数使用**来接收,前面的参数也是不稳定的,想写多少个写多少个,当然也足以和地点的三种一起来使用,假若要一起使用的话,关键字参数必须在结尾面。

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

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

伍.函数的再次来到值

  每种函数都有重临值,就算未有在函数里面内定重回值的话,在python里面函数执行完现在,暗中同意会再次回到三个None,函数也得以有三个重临值,假设有多少个再次回到值的话,会把返回值都放置八个元组中,再次来到的是二个元组。为啥要有再次来到值呢,是因为在这些函数操作完之后,它的结果在背后的主次里面须求用到。函数中的重临值使用return,函数在遇到return就随即截至。

1 def calc(x,y):#这个就是定义了一个有返回值的函数
2     c = x*y
3     return c,x,y
4 res = calc(5,6)#把函数的返回结果赋值给res
5 print(res)

陆.局部变量和全局变量

  局地变量意思正是在某个生效的,出了那几个变量的效能域,那几个变量就失效了,比如下边的c正是三个局部变量,出了那一个函数之后,就从未有过c这几个值了

  全局变量正是在全部程序里面都见效的,在程序最前边定义的都以全局变量,全局变量如若要在函数中期维修改的话,须要加global关键字表明,假若是list,字典和集合的话,则不须要加global关键字,直接就足以修改。

 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

柒.递归调用

  在函数内部,能够调用其余函数。要是叁个函数在在那之中调用自个儿自身,那些函数就是递归函数。递归调用的意趣正是,在这几个函数内部协调调用自个儿,就有点循环的意思。

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

递归调用的表征:

  壹.必要有1位所共知的甘休条件

  贰.每一遍进入更深1层递归,难题规模比较上次递归都应持有缩减

  三.递归作用不高,递归层次过多会促成栈溢出(在处理器中,函数调用是由此栈那种数据结构完成的,每当进入3个函数调用,栈就会加1层栈帧,每当函数再次回到,栈就会减1层栈帧,由于栈的轻重缓急不是卓殊的,全部,递归调用的次数过多,会造成栈溢出)

八.高阶函数:多个函数的参数是三个函数,那么这么些函数便是三个高阶函数。

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的值,再把上面的那个定义好的函数传进去

 

相关文章