python中函数教程

函数的基本概念

1.什么是函数？
函数相当于一种工具，就是把一串代码装到一起，我们下次需要用的这个功能的时候可以直接使用
函数相当于是工具(具有一定功能)
不用函数
修理工需要修理器件要用锤子 原地打造 每次用完就扔掉 下次用继续原地打造
用函数
修理工提前准备好工具 什么时候想用就直接拿出来使用

代码举例；
    count = 0
    for i in name_list:
        count += 1
    print(count)
    #这就是一个可以查看列表元素个数的代码
    如果需要反复使用我们就可以把它设置成一个函数
    
2.函数的作用
  如果一段代码需要在不同的位置，多次反复执行
  那我们就可以把这一段代码封装成一个函数
  方便我们随时可以使用
  函数也可以通过收到不同的参数作出不同的结果。

函数的语法结构

关键词  def
代码格式：
    def 函数名称(参数):
      '''函数注释
         要写一个这个函数是做什么的，怎么使用'''
      函数内的代码块
      return 返回值
#函数命名要做到见面知意
#参数，可有可无。主要调用函数时规定是否需要外界输入某些数据
#函数体代码 函数功能的核心内容，也代表这个函数是如何运作的
#return 返回值 可有可无，指函数运行结束后返回的值

函数的定义与调用

1，定义函数
def 函数名称(参数)：
		pass
#函数在定义的时候不会执行函数体代码，只要语法正确就可以，

2.调用函数
函数名称()
#直接使用函数名称进行调用，当调用函数的时候 函数里面的子代码才会开始执行

3，函数必须先定义后才可以进行调用

函数的分类

1.空函数
  函数里面的代码为空，或者只是先使用pass进行了补全的
  举例：def add_users()：
  				pass
  作用与项目开始初期搭建功能框架的，先搭建大概需要用到哪些功能哪些函数 后期可以再补全
  
 2.无参函数
   定义函数时，括号内没有参数
   def 函数名()：
       print('我不需要传参')
   #不需要外界传参的函数类型
  
 3.有参函数
	  定义函数时，括号内有需要接受的参数
    def 函数名(name):
       print(name)
     #需要外界传递的数据，根据外界传递的数据进行处理

函数的返回值

1.什么是返回值
  调用过函数后返回给调用者的结果，就是使用过函数得到了什么
2.如果获取返回值
  变量名 = 函数名()
  # 相当于先执行了这个函数，然后把结果赋予了这个变量
3.函数返回值的多种情况
  3.1 函数里面没有写 return 关键字，则默认返回None
  3.2 函数里面有 return ，但是后面没有跟任何东西，还是默认返回None
  3.3 函数里面有 return 则后面写什么 返回什么
  3.4.函数体代码有return并且后面有多个数据值 则自动组织成元组返回
 	3.5.函数体代码遇到return会立刻结束

参数的概念

形式参数
	在函数定义阶段括号内填写的参数 简称'形参'
实际参数
	在函数调用阶段括号内填写的参数 简称'实参'
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
"""
形参与实参的关系
	形参类似于变量名 在函数定义阶段可以随便写 最好见名知意
	def register(name,pwd):
		pass
	
	实参类似于数据值 在函数调用阶段与形参临时绑定 函数运行结束立刻断开
	register('jason',123)   形参name与jason绑定 形参pwd与123绑定
"""

函数参数之位置参数

位置行数
	在函数定义阶段 公式括号内从左往右依次填写的变量名就是位置行参
  当在def 语句中 证明函数正在被定义，这就是位置行参
  def func1(位置1,位置2,位置3):
  		pass
位置实参
  在函数被调用阶段，我们在括号内从左往右依次填写的数据值
  func1(数据1,数据2,数据3)
  
  def func1(name,password): #位置行参
  		print(name,password)
   
  func1('moon','123')  #位置实参
  #代码运行结果  moon 123  当调用函数后 行参 name 绑定实参 moon 
  #行参password 绑定 123  所以调用函数后执行函数代码块 输出 moon 123
  
  错误传参
  func1()  # 报错，因为在定义函数时已设置需要收到2个传参还可以运行
  func1('moon') # 报错 只传了一个参数不行，必须2个
  func1('moon',12,1) # 报错 多传了一个参数
  
  a = input('请输入姓名')
  b = input('请输入密码')
  func1(a，b)  # 实参没有固定的定义 可以传数据 也可以传变量名等
  

函数参数之默认参数

什么是默认参数？
	当我们在定义函数时，定义行参时也可以预留设置一个默认数据，当没有收到参数时则
  默认这个数据为实参
  
def 函数名(行参名,行参名='默认数据'):
  	pass
def func1(name,age='18'):
		print(name,age)
 # 默认参数的定义也遵循短的简单的靠前 长的复杂的靠后
 
func1('moon') # 输出结果为 moon 18  我们只传了一个参数也可以使用该函数，
#因为该函数，默认了 age=18 如果你不给行参age 传送实参 则默认age行参的实参为18

func1('moon',22)  #输出结果为 moon 22 当你对行参 age传送了实参，则预留默认数据不需要存在了，因为你已经给他数据值了 展示你给的数据即可

def func1(name='moon',age):
		print(name,age)   
# 报错  行参的顺序必须 遵循越简单越靠前的原则， 拥有默认数据的行参不可以在 普通行参的前面

#等同复杂度遵循从左到右原则
def func1(name='moon',age=12):
		print(name,age)  
正确，因为大家都是有默认数据的行参  同样的复杂等级。

函数参数之关键字参数

什么是关键字参数？
可以理解为我们在传参的时候 把数据指名道姓的给到行参
代码展示:
def func1(name,gender，age=18)
 		print(name,age,gender)
func1(gender='男',name='moon') # moon 18 男 
# 这里就是指名道姓的 把 行参gender传送实参'男'  行参name传送实参'moon'然后age行参没有接收到数据 则启动默认数据 18
#凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值 

def func1(name,gender，age=18):
 		print(name,age,gender)
func1(gender='男','moon')
# 报错，在位置参与和关键字参数混合使用时也需要遵守 越简单的在前面处理的原则
#   ！！！！必须保证关键字参数在位置参数后面，！！！！

def func1(name,gender，age=18):
 		print(name,age,gender)
func1(gender='男',name='moon',gender='女') 
#报错 不可以对一个形参重复赋值 

可变长度行参

1，什么是可变长度行参？
当我们在定义函数时 需要接受多个数据，或者我们不确认有多少个实际参数
形参名前加*号,调用函数时，溢出的位置实参，都会被接收，以元组的形式保存下来赋值给该形参
关键词
*args
用于接收溢出的
def func1(*args):
		print(args)
func1(1,2,3,[212,22],{12:22})#(1, 2, 3, [212, 22], {12: 22})
#可以接受多个数据值，然后已元组的形式统一接收 然后赋值给*号后面的变量名

def func1(name,*arge):
		print(name,arge)
 func1(1,2,3,4)# 1 (2,3,4)
# 位置行参name 被 1所赋值，其他多余溢出的实参都被*整理为元组然后给了arge

def func1(*arge，name):
		print(name,arge)
 func1(1,2,3,4)
#报错，实参全部都被*号吸收给了 arge 导致行参 name没有实际参数
func1(1,2,3,name='4') # （1，2，3）4
#成功，因为name行参被 关键词指定了实际参数 那前面就都被*号处理


2.可变长度的关键字参数
**kwargs
形参名前加**号,调用函数时，溢出位置的关键字参数都会被接收，以字典的形式保存下来赋值给该形参
def func1(*name, arge,**kwargs):
    print(name, arge,kwargs)
func1(1, 2, 3, arge='4',name='moon',age='18')#(1, 2, 3) 4 {'name': 'moon', 'age': '18'}
# 首先 1，2，3，被*号接收赋值给了name变量 arge指定接收参数4，剩下的关键字参数都被**号接收，然后以字典的形式展示，健对展示。

def func1(**kwargs):
    print(kwargs)
func1() # {}
func1(name = 'moon')# {name:moon} 接收关键字传参然后反馈以字典 健值形式

def func1(a,**kwargs):
    print(a,kwargs)
func1(name='moon',age='18') #报错，必须按照从左到右顺利 先给位置行参a数据，

可变长度实参

1.可变长度实参
当我们在调用函数时 需要输出多个实参
*实参名
例如：
l1 = [11,22,33,44]
def func1(a,*args)
		print(a,args)
func1(*l1) # 11,(22,33,44)
#当什么再实参中使用 *号，则会默认为对此变量进行循环，把每一个数据一次性传给所有行参
#当循环第一次，11，被赋予行参a，22，33，44均溢出被 args接收。
t1 = (33, 22, 11)
def func1(a,*args)
		print(a,args)
func1(*t1) # 33 (22,11)
s1 = 'moon'
def func1(a,*args)
		print(a,args)
func1(*s1) # m ('o','o','n')
se = {123,222,111}
def func1(a,*args)
		print(a,args)
func1(*se)  # 123 (222,111)
d1 ={'name'='moon','age'='18'}
def func1(a,*args)
		print(a,args)
func1(*di)  # name ('age',)  
# 字典内数据只循环 健 不考虑值 
！！当什么再实参中使用 *号，则会默认为对此变量进行循环，把每一个数据一次性传给所有行参！！

2.实参中如何使用字典传参值
def func1(name,age):
		print(name,age)
d1 = {'name':'moon','age':'18'}
func1(**d1) # moon 18
#  **可以把字典打散成关键字传参 实际运作func1(name='moon',age='18')
#  *输出字典里的键
#  **输出字典里的值

3.混合使用
def index(*args, **kwargs):
    print(args)  # (11, 22, 33, 44)
    print(kwargs)  # {}
index(11,22,33,44)

！！所有参数可任意组合使用，但定义顺序必须是：位置参数、默认参数、*args、命名关键字参数、**kwargs！！

命名空间

1,什么是命名空间
命名空间就是系统自动设定了一部分内存空间 来存放 变量名和数据值绑定关系的地方。就是存变量名的地方，
2.命名空间的分类
2.1 内置空间
    一些python中自带的方法，函数等。这些方法和函数的名字在你打开python的时候就已经在内置空间中存贮。
    例如： print input len 等等 
    #当你打开python在其中时就可以使用这些名字来获得实际的效果
    
2.2全局名称空间
   针对于当前python文件中设置的名字，存放文件级别的名字，文件执行时就会放置全局空间
   例如： name = 'moon' # name 放置全局空间
         if x==1:     
         	   a=2     # 如果if执行 a 放置全局空间
         
2.3局部名称空间
	 函数体代码内的名称，类体代码里的名称 都是局部名称空间
   如果超过了这个函数或者类，就不可以使用了
    
3.存活周期
   存活周期
	内置名称空间
  		python解释器启动则创建 关闭则销毁
 	全局名称空间
    	py文件执行则创建 运行结束则销毁
 	局部名称空间
    	函数体代码运行创建 函数体代码结束则销毁(类暂且不考虑)
 
4.作用域
   内置名称空间
    	解释器级别的全局有效
 	全局名称空间
    	py文件级别的全局有效
 	局部名称空间
    	函数体代码内有效

命名查找顺序

1.相互独立的局部名称空间默认不能够互相访问
	 def func1():
    	name = 'jason'
    	print(age)

    def func2():
       age = 18
       print(name)
      
2.2.局部名称空间嵌套
	先从自己的局部名称空间查找 之后由内而外依次查找
"""
函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
	x = '你好阿'
    def func1():
        x = 1
        def func2():
            x = 2
            def func3():
                print(x) #2
            func3()
        func2()

    func1()
"""

小练习

判断下列money的值是多少并说明理由 思考如何修改而不是新增绑定关系
	money = 100
	def index():
        money = 666	
  index()
 	print(money)  # 100 定义函数时，函数内的代码不生效
    
   

	money = 100
 	def func1():
        money = 666
        def func2():
            money = 888
        func2()
   print(money) #100  因为函数func1()没有被执行，func2函数是在func1里的子代码