实参是一个确定的值，能够传递给形参。 作为位置参数或者关键字参数传递

def user_manage(name,age,job,hobby):
print('用户管理系统'.center(16,'-'))
print('\tName:\t',name)
print('\tAge\t',age)
print('\tJob\t',job)
print('\tHobby\t',hobby)
print('用户管理系统'.center(16,'-'))
user_manage('Tom',20,'IT','coding')
user_manage('jim',21,'student','running')

-----用户管理系统-----
Name:	 Tom
Age	 20
Job	 IT
Hobby	 coding
-----用户管理系统-----
-----用户管理系统-----
Name:	 jim
Age	 21
Job	 student
Hobby	 runnizhing
-----用户管理系统-----

只传递实参，位置–对应----》位置参数

使用位置参数时和函数头定义的形参在顺序，个数，以及类型上匹配

默认值参数

def user_manage(name,age,job,hobby='trip'):
print('用户管理系统'.center(16,'-'))
print('\tName:\t',name)
print('\tAge\t',age)
print('\tJob\t',job)
print('\tHobby\t',hobby)
print('用户管理系统'.center(16,'-'))
user_manage('Tom',20,'IT')
user_manage('jim',21,'student','running')

-----用户管理系统-----
Name:	 Tom
Age	 20
Job	 IT
Hobby	 trip
-----用户管理系统-----
-----用户管理系统-----
Name:	 jim
Age	 21
Job	 student
Hobby	 running
-----用户管理系统-----

关键字参数

默认值参数，关键字参数，必须放值于位置参数之后

不定参数

在python中不定参数主要是指*args和 **kwargs 两个魔法变量。

a, b, *c = 1,2,3,4,5,6
print(c)

[3, 4, 5, 6]

主要用于函数定义，我可以将不定数量的参数传递给函数。

• *args* 用来接收任意非键值对的任意数量的参数列表给函数

  def un_para(para,*args):
  print('普通位置参数：',para)
  print('不定参数:',args)
  print(type(args))
  un_para(1,2,3,4,5,6,7,'a','b')
  un_para([1,2,3,4,5],'a','b')
  
  普通位置参数： 1
  不定参数: (2, 3, 4, 5, 6, 7, 'a', 'b')
  <class 'tuple'>
  普通位置参数： [1, 2, 3, 4, 5]
  不定参数: ('a', 'b')
  <class 'tuple'>

  def un_para(para,para2,*args):
  print('普通位置参数：',para,para2)
  print('不定参数:',args)
  print(type(args))
  un_para(1,2,3,4,5,6,7,'a','b')
  un_para([1,2,3,4,5],'a','b')
  
  普通位置参数： 1 2
  不定参数: (3, 4, 5, 6, 7, 'a', 'b')   #输出的结果是元组
  <class 'tuple'>
  普通位置参数： [1, 2, 3, 4, 5] a
  不定参数: ('b',)
  <class 'tuple'>

  def sum(*args):
  result = 0
  for i in args:
  result += i
  result = result / len(args)
  return  result
  
  print(sum(1,8,1,1,1,1,1,1,1,1))
  
  1.7

• **kwargs 用来接收任意不定长度的键值对、列表给函数

  def un_kye(**kwargs):
  print(kwargs)
  print(type(kwargs))
  
  un_kye(a=1,b=2,c=3)
  
  {'a': 1, 'b': 2, 'c': 3}   #输出的结果是一个字典
  <class 'dict'>

函数的引用

def foo():
print('in foo()')
bar()
def bar():
print('in bar()')
foo()

import bar,foo
print(foo.x + bar.x)

foobar

​ 你可以获得每个 pyhone 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突：

函数属性

def foo():
'foo() --- '
def bar():
pass
bar.__doc__ = 'oops,forget'
bar.version = 0.1

函数属性是python中另外一个使用了句点属性标识并拥有名字空间的领域。

内嵌函数

def foo():
def bar():
print('bar()  called.')
print('foo()  called')
bar()
foo()

foo()  called
bar()  called.

作用域

bar()整个函数都处于外部foo()函数的作用域里面（foo(）是我们可以从外部访问的一个对象区域，除了在foo()内部，其他地方无法调用bar()函数。

变量作用域

作用域的产生

对作用域而言，python与c有很大差别，只有当变量在module，Class,函数定义的时候，才会有作用域的概念。

def foo():
a = 'foo'
print(a)
foo()
print(a) #这里就无法调用a，因为不在foo()内部

在作用域中定义的变量，一般只在作用域中有效。需要注意的是，在if-elif-else,for-else,while-else,try-except(else - finally)等关键字中不会出现作用域

作用域的类型

Python中，使用一个变量时并不要求需要预先声明它。但在真正使用的时候，它鼻血绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在作用域引入新的变量，同时，屏蔽外层作用域中的同名变量。

• 局部作用域(locale — L)
• 局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
  注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
• 嵌套作用域(enclosing — E) E 也包含在def关键字中，E和L是相对的，E相对于跟上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在此函数内部的局部作用域。
• 主要为了实现Python的闭包，而增加的实现。

即在模块层次中定义的变量。模块顶层申明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。

系统固定模块中定义的变量

搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域。

全部变量和局部变量

搜索变量也是先从局部开始再往外找

gbl_str = 'foo'
def foo():
loc_str = 'bar'
return gbl_str + loc_str
print(foo())
print(gbl_str)

foobar
foo

a = 6688
def foo():
a = 666
print('foo(),修改前a:\t',a)
a = 888
print('foo(),修改后a:\t',a)
def bar():
print('bar(),a:\t',a)
foo()
bar()

foo(),修改前a:	 666
foo(),修改后a:	 888
bar(),a:	 6688

a = 6688
def foo():
# a = 666
print('foo(),修改前a:\t'<
4000
span class="token punctuation">,a)
a = 888
print('foo(),修改后a:\t',a)
def bar():
print('bar(),a:\t',a)
foo()
bar()

UnboundLocalError: local variable 'a' referenced before assignment

a = 6688
def foo():
# a = 666
print('foo(),修改前a:\t',a)
b = 888
print('foo(),修改后a:\t',a)
def bar():
print('bar(),a:\t',a)
foo()
bar()

foo(),修改前a:	 6688
foo(),修改后a:	 6688
bar(),a:	 6688