标签：字典 双星 方法 创建 全局变量 ice sum 执行 面向
1、关键字参数
def print_area(width,height):
are=width*height
print("{0}*{1}长方形的面积{2}".format(width,height,are))
print_area(320,100)
print_area(width=300,height=200)
print_area(45,height=100)
# print_area(width=56,89)
#发生错误。调用函数时，一旦其中一个参数用了关键字形式传递，那么其后的
#所以参数都必须采用关键字参数形式传递。
print_area(height=100,width=200)
2、默认参数
def mack_coffice(name="卡布基罗"):
return "制作一{}杯咖啡".format(name)
coffice1=mack_coffice("巴西咖啡") （1）
cofice2=mack_coffice() （2）
print(coffice1)
print(cofice2)
输出结果：
制作一巴西咖啡杯咖啡
制作一卡布基罗杯咖啡
其中（1）传递了参数没有使用默认参数。（2）使用默认参数
3、可变参数（python可变参数有两种，在参数前面加*或者**，*可变参数在函数中被组装成一个元组，**可变参数在函数中被组装为一个字典）
def sum(*numbers,multiple=1):
total=0
for number in numbers:
total+=number
return total*multiple
print(sum(100,200,300))
print(sum(200,100))
print(sum(200,100,multiple=2))（1）
double_tuple=(100,200) #元组或者列表（2）
print(sum(300,*double_tuple)) （3）
输出结果：
600
300
600
600
注意：1、如果已经有一个元组变量（2），能否传递给可变变量？这需要使用对元组撤包（3）在元组前面加上（*）
这里将（2）撤包为100,200形式。另外（2）也可以是列表；
2、*可变参数不会最后一个参数时，后面的参数需要采用关键字参数形式传递（1）
**可变参数
def show_info(sep=":",**info):
print("-----info----")
for key,value in info.items():
print("{0}{2}{1}".format(key,value,sep))
print(show_info(‘->‘,name=‘fkk‘,age=18,sex=True))（1）
print(show_info(name=‘fcc‘,student_on=12,sep="-"))（2）
stu_dict={‘name‘:‘fkk‘,‘age‘:18} #创建字典
print(show_info(**stu_dict,sex=True,sep=‘,‘)) （3）
输出结果：
-----info----
name->fkk
age->18
sex->True
None
-----info----
name-fcc
student_on-12
None
-----info----
name,fkk
age,18
sex,True
None
注意：1、**可变参数，必须在正规参数之后，如果本列函数定义改为shpw_info(**info,sep=‘:‘)形式会发生错误
2、（1）第一个参数‘->’是传递给sep，其后的参数name=‘fkk‘,age=18,sex=True，是传递给info。这种参数形式事事上就是关键字参数
，注意建不要用引号包裹起来。
3、（2）sep也采用关键字参数传递，这种sep参数可以放在参数列表的任何位子。其中的关键字参数被收集到info的字典中
4、（3）其中字典对象stu_dict，传递时stu_dict前面加上（**）双星号在这里表示将stu_dict撤包为key=value对的形式
函数返回
python函数返回值也比较灵活，主要有三个形式，无返回，单一返回，多返回
无返回值函数
所谓无返回值，事试实上是返回None None表示没有意义的依据
def show_info(sep=":",**info): （1）
print("-----info----")
for key,value in info.items():
print("{0}{2}{1}".format(key,value,sep))
return #return None或省略 （2）
注意：（1）中只是为了输出一些信息，不需要返回数据，因此可以省略return。如果一定要使用return 见（2）使用return 或return None。
本列中加return 是多此一举。但是有，return或，return None是必要的。
def sum(*numbers,multiple=1):
if len(numbers)==0:
return #return None 或省略
total=0
for number in numbers:
total+=number
return total*multiple
print(sum(10,20))
print(sum(multiple=2))
输出好结果：
30
None
多返回值函数
def positi(dt,spend):
posx=spend[0]*dt
posy=spend[1]*dt
return (posx,posy)
move=positi(60,(12,13))
print("物体移动{0},{1}".format(move[0],move[1]))
输出
物体移动720,780
函数变量作用域
1、变量可以在模块中创建，作用域是整个模块，称为全局变量。
2、变量也可以在函数中创建，默认情况下作用域是整个函数，称为局部变量
x=2 （1）
def print_value():
print("函数中x={}".format(x))（2）
print_value()
print("全局变量x={0}".format(x))
函数中x=2
全局变量x=2
注意：（1）创建全局变量x，全局变量作用域是整个模块，所以在print_value函数中也可以访问变量x见（2）
#创建全局变量
x=2
def print_value():
#创建局部变量
x=10 （1）
print("函数中x={}".format(x))
print_value()
print("全局变量x={0}".format(x))
输出
函数中x=10
全局变量x=2
注意：（1）这会函数中创建x变量，函数中的x变量与全局变量x命名相同，在函数作用域内会屏蔽全局x变量
--------------------------------------------------------------------------------------------------------------------------------------------------------
python 提供这种可能，通过在函数中将变量声明为global的，可以把变量作用域变成全局的
#创建全局变量
x=2
def print_value():
global x
x=10
print("函数中x={}".format(x))
print_value()
print("全局变量x={0}".format(x))
输出
函数中x=10
全局变量x=10
---------------------------------------------------------------------------------------------------
生成器
在一个函数中使用return 关键字返回数据，但是有时候也可以使用yield关键字返回数据。yield关键字的函数返回的是
一个生成器（generator）对象，生成器对象是一种可迭代对象
def sq(num):
n_list=[]
for i in range(1,num+1):
n_list.append(i*i)
return n_list
for i in sq(5):
print(i,end=" ")
输出结果
1 4 9 16 25
更好的解决方法
def sq(num):
for i in range(1,num+1):
yield i*i （1）
for i in sq(5): （2）
print(i,end=" ")
注意：（1）使用了yield关键字返回平方数，不需要return关键字了，（2）行调用函数sq返回的是生成器对象
生成器对象是可以迭代对象，可迭代的对象通过__next__（）方法获取元素，代码第二行for循环能够遍历可迭代对象，就是隐式的调用生成器的__next__()方法获取元素
def sq(num):
for i in range(1,num+1):
yield i*i
a=sq(5)
print(a.__next__())
print(a.__next__())
执行结果一样
嵌套函数
函数还可以定义在另外的函数体中，称为“嵌套函数”
def calculate(n1,n2,orp):
multi=2
def add(a,b):
return (a+b)*multi
def sub(a,b):
return (a-b)*multi
if orp=="+":
return add(n1,n2)
else:
return sub(n1,n2)
print(calculate(10,9,‘+‘))
add(10,5) 报错
sub(10,5) 报错
----------------------------------------------------------------------------------------------------------
函数试编程基础
与面向对象编程一样，是一种编程规范，函数试编程，也称为面向函数的编程
python并不是彻底的函数试编程语言，但是还是提供了一些函数试编程必备的技术，主要有函数类型，Lambda表达式
他们是函数试编程的基础
函数类型：任何一个函数都有函数类型，但是函数调用时，就创建了函数类型实例。及函数对象
它可以赋值给一个变量，也可以作为参数传递给一个函数，还可以作为函数返回值使用。
def calculate(orp):
multi=2
def add(a,b):
return (a+b)*multi
def sub(a,b):
return (a-b)*multi
if orp=="+":
return add
else:
return sub
f1=calculate(‘+‘)
f2=calculate(‘-‘)
print("10+5={}".format(f1(10,5)))
注意：calculate函数返回的是函数对象，所以放放
f1是add（）函数对象
f2是sub（）函数对象
--------------------------------------------------------------
Lambda表达式
本质上未匿名函数，匿名函数也是函数，也有函数类型，也可以创建函数对象
lambda表达式语法：lambda 参数列表： lambda体
def calculate(orp):
if orp=="+":
return lambda a,b:(a+b)
else:
return lambda a,b:(a-b)
f1=calculate(‘+‘)
f2=calculate(‘-‘)
print("10+5={}".format(f1(10,5)))
标签：字典 双星 方法 创建 全局变量 ice sum 执行 面向
原文地址：https://www.cnblogs.com/fkkk/p/9636350.html
