Python3基础-函数

Q什么是函数？

函数是组织好的，模块化，可以重复利用的代码片段

定义一个函数：

函数代码片段以def开头，函数名加（）括号：=== def fun_num():
可以传入参数和自定义变量，写在括号内部：===def fun_num(name,age)
函数第一行可以放置文档说明：
开始函数体内容
return【表达式】返回值不带表达式函数返回None
执行到return语句时，会退出函数

>>>def fun_num(name):
>>>    print('hello world %s'%name)
>>>    return 'ok'
>>>fun_num('Ronny')
hello world Ronny

函数的参数

必需参数
关键字参数
默认参数
不定长参数

形参

在调用的时候才被分配内存，调用结束后释放内存

实参

可以是变量／常量／表达式／函数等，必须有值传给形参

def name():
    print('Ronny')
    return 0
def name_c(name):#形参
    print('name is %s'%name)

name()
name_c('Ronny')#实参

必需参数

必需参数只能通过顺序传入形参，并调用的数量和声明时的数量一致

def stu_register(name,age,course,country):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
stu_register('ronny',22,'english','中国')

默认参数

在形参中声明变量默认值，在调用时如果没有传递参数则使用默认的值

默认参数必须放置形参最后

def stu_register(name,age,course,country='中国'):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

stu_register('ronny',22,'english')

关键字参数　

函数调用时，使用关键字参数来对应形参，并传入值；关键字参数可以不按照形参的顺序，关键字名称必须与声明的一致

如调用时不全是关键字参数，关键词参数必须从后开始放置

def stu_register(name,age,course,country):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
stu_register(name='ronny',course='english',country='中国',age=22)

不定长参数

#若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
#*args **kwargs
def stu_register(name,age,course,country,*args):#*args会把多传入多参数变成一个元祖
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
    print(args)

stu_register('ronny',22,'english','中国','python',2017)

def stu_register(name,age,course,country,**kwargs):#**kwargs会把多传入多参数变成一个字典
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
    print(kwargs)

stu_register('ronny',22,'english','中国',mum='python', mouth=2017)

全局变量和局部变量

定义在函数内部的变量只有局部的作用域，定义在函数外的拥有全局作用域

global 定义全局变量

name='Ronny'#这是一个全局变量
def stu_register(age,course,country):
    global name #声明转为全局变量
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
    name='Roman' #局部变量
stu_register(22,'english','中国')
print("在外面看看name改了么?",name)

----注册学生信息------
姓名: Ronny
age: 25
国籍: 中国
课程: english
在外面看看name改了么? Roman

可更改(mutable)与不可更改(immutable)对象

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

　　python 函数的参数传递：

不可变类型：如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

print('字符串局部变量'.center(30,'-'))
name_1='Ronny'
def stu_1():
    print(name_1)
    name_1='Roman'
stu_1()

-----------字符串局部变量------------
Ronny

print('列表／字典／集合局部变量'.center(30,'-'))
name_2=['Ronny','Roman','Tony']
def stu_2():
    print(name_2)
    name_2.append('Kim')
stu_2()
print(name_2)
---------列表／字典／集合局部变量---------
['Ronny', 'Roman', 'Tony']
['Ronny', 'Roman', 'Tony', 'Kim']

匿名函数

python使用lambde来创建函数

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

#返回多个值
key=lambda x:(x.isdigit(),x.isupper(),x.isdigit() and int(x)%2==0)
print(key('10'))
结果：(True, False, True)

#三元运算
key=lambda x,y:'都大于0' if x<0 and y<0 else '都小于0'
print(key(10,-1))
结果：都小于0

递归函数

函数内部调用自身函数

递归特性:

必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def sum(n):
    print(n)
    if int(n/2)>0:
        return sum(int(n/2))
sum(10)


结果：
10
5
2
1

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):
    return f(x) + f(y)
 
 
res = add(3,-6,abs)
print(res)
#abs()求绝对值

posted @ 2017-08-09 09:30 Ronny_bin 阅读(100) 评论(0) 收藏举报

刷新页面返回顶部

Ronny_罗尼彬

Python3基础-函数

全局变量和局部变量

公告