函数的定义与分类

函数简介#

# ctrl + 左键点击 >>>  如何查看内部源码
函数就是将一个写好的功能，可以拿来重复使用的一个工具
"""
没函数的情况
类似于修理工在修理汽车的时候需要用扳手，只能先打造出来扳手，螺丝刀什么的才能修车，下次使用还得重新打造
有函数的情况
修理工只需要提前准备好一个工具箱，里面提前准备好相应的工具之前就可以反复使用
"""
函数又分为内置函数和自定义函数
内置函数就是python解释器提前给我们写好的，像之前我们使用的内置方法，关键字等都属于内置函数
自定义函数就是我们自己写的函数

函数的语法结构#

def 函数名 (参数1，参数2)：
'''函数的注释'''
函数体代码
return 返回值

解释：

# 使用方法：使用函数时需要使用函数名加括号
1.def：是定义函数的关键字
2.函数名：函数名类似于是变量名，指代函数体代码，命名与变量名一致
3.括号：定义函数的时候，函数名肯定要先写括号
4.参数：类似于使用函数的时候，给函数内部传递的数据，可以不写或者单个、多个
5.冒号：定义函数也需要有缩进的代码块
6.函数的注释：用于解释函数的主要功能、使用方法等说明性文字
7.函数体代码：函数的核心功能，也是我们将来编写的核心
8.return：后面跟什么，那么执行完函数就会返回什么

拓展：

'''
定义函数需要使用的def关键字
定义函数的过程不会执行函数体代码，只会检测语法
	def index():
		askjfhakldsgl	定义的时候不会报错
	def index()
		if(后面不写东西了)  这种语法结构的错误在定义的时候就会报错
'''

函数使用例子：

s = 'kjsgfblkdsjblfiflkjgbdlxkjbndfb'


def mylen():
    # 用于计算s字符串内有多少个元素
    n = 0
    for i in s:
        n += 1
    print('字符串中的个数为%s' % n)


mylen()

函数的定义于调用#

定义：

1. 函数一定要遵循定义后调用的原则(定义函数的代码一定要比函数的代码先执行)
2.函数在定义阶段只检测语法不执行代码
3.函数体代码只有在调用函数的时候才会执行
	调用函数的方式>>>:函数名加括号  # 如果有参数则传递参数
4.函数名其实相当于是变量名指向的是内存中函数体代码所在的位置
# 定义函数
def func()
	print('hello world')
# 调用函数
# func() 就是去内存中找到函数体代码并执行

函数的分类#

1. 内置函数#

   python解释器提前的定义好可以直接调用的函数
   eg：len、print、open...
   

2. 自定义函数#

   自己编写的函数叫自定义函数
   

   2.1 无参函数

   # 在函数定义阶段括号内没有参数
   def index():
       print('阿巴阿巴阿巴')
   # 调用无参函数：括号内也不需要写参数
   index()
   

   2.2 有参函数

   # 在函数定义阶段括号内有参数>>>:类似于变量名
   def index(a):
       print('阿巴阿巴')
   index(11111)  
   # 阿巴阿巴 11111
   

   2.3 空函数

   # 在定义阶段函数体代码是用pass或者...占位
   def index():
   	pass
   '''
   作用：前期可以通过空函数快速的罗列出程序中大致的功能，让程序整体的框架清晰，空函数一般用于前期的功能框架搭建，先写好程序都应该有什么功能的这样子
   '''
   

   函数的返回值#

   # 函数的返回值其实就是在调用函数之后返回的结果
   eg:
       s = 'hello world'
       res = len(s)  # 将len函数的返回值赋值给变量res
       print(res)  # 11
   

   如何获取函数的返回值#

   变量名 = 函数调用
   

   如何操作返回值#

   1.当函数体代码没有return关键字的时候，返回值是None
   def index():
   	print('春困秋乏')
   res = index()
   print(res)  # None
   2.当函数体代码写了return但是没有任何值的时候，返回结果是None
   def index():
       print('春困秋乏')
       return
   res = index()
   print(res)  # None
   3.当函数体代码写了return并且跟了数据，那么写什么就返回什么
   如果写的是值，则返回的是值(任意数据类型)
   如果写的是变量名,则返回的是变量名指向的值
   def index():
       print('春困秋乏')
       name = 'tuzi'
       return name
   res = index()
   print(res)  # tuzi(返回的变量名指向的值)
   #####
   def index():
       print('春困秋乏')
       return 1111
   res = index()
   print(res)  # 1111(返回的值)
   # return 后面还可以跟多个值,逗号隔开,会自动组合成元组返回出去
   def index():
       print('你困不困')
       return 11,'tony',223344
   res = index()
   print(res)  # (11, 'tony', 223344)
   

   补充:#

   """
   函数体代码遇到return会立即结束函数运行,相当于循环遇到了break
   """
   

   

   函数的参数(重要)#

   # 函数的参数可以分为 两大类
   # 函数在定义阶段括号内写的参数,被称为形参>>>形式参数
   # 函数在调用阶段括号内写的参数,被成为实参>>>实际参数
   # 实参与实参的关系,形参类似于是变量名,实参类似于是变量的值
   # 在调用函数的时候传入实参,会与形参临时绑定,函数运行之后自动解除绑定
   

   实参传给形参的三种方式:#

   方式一:
       def index(a,b):  # a,b就是函数的形参
       print(a,b)
   index(1,2)  # 1和2就是函数的实参
   '''
    注意：1会临时绑定给形参a  2会临时绑定给形参b
           函数体代码运行完毕之后，解除绑定，
           形参ab没有绑定值的状态，等待下一次函数调用的时候传入形参进行绑定
   '''
   方式二:
       使用变量的值临时绑定给形参
   # 先定义函数
   def index(a,b):
       print(a,b)
   m = 100
   n = 200
   index(m,n)  # 100 200
   # 将m n 的值临时绑定给形参ab
   方式三:
       使用函数的嵌套
   def index(a,b):
       print(a,b)
   def func1():
       return 'hello'
   def func2():
       return '你好漂亮'
   index(func1(),func2())  # 将func1的返回值与func2的返回值临时绑定给函数index的形参ab，
   

   位置参数#

   '''
   位置形参:在函数定义阶段括号内从左往右依次填写的变量名
   位置实参:在函数调用阶段括号内从左往右依次传入的真实的数据
   '''
   特征:
       1.位置形参与位置实参在绑定关系的时候就是按照从左到右的顺序依次绑定
       2.位置形参与位置实参打的个数要一致,多一个少一个都不行
       
   

   使用:

   def index(name,pwd):  # name，pwd就是位置形参
       print(name,pwd)  # 外界传入什么,这里就打印什么
   index('tzui','123')  # tzui 123就是位置实参， 就是传入进的真实的数据
   index()  # 不传参会直接报错
   index(111)  # 报错,不可以少传参数
   index(111,222,333)   # 报错,多传了参数也不行
   位置参数的特征:1.位置形参与位置实参在绑定关系的时候就是按照从左往右的顺序依次绑定
               2.位置形参与位置参数的个数要保持一致,多一个不行,少一个也不行,而且传入的参数有意义的话要一一对应
   

   关键字参数#

   出现在实参中 指名道姓的给形参传值,不需要遵循位置
   def index(a, b):
       print(a, b)
   index(a=1, b=2)  # 1 2   指名道姓的说a接收值是1,b接收的值是2
   index(b=333,222)  # 报错 这样不被允许,关键字参数必须放在位置参数前后面
   index(111, a=222)  # 报错,形参只能指向一个实参,111已经绑定实参a了,再通过关键字参数给形参a重复邦值,这样是不允许的,且b没有接收到值
   index(222,b=111)  # 可以,222相当于位置参数,直接传给形参a了
   '''实参222按照位置参数传给形参a,而b=111按照指名道姓的方式传给形参b'''
   

   默认参数#

   出现在形参中
           在函数定义阶段就已经给一些形参赋值了
           后续如果不传值则直接使用默认的
           后续如果传值则使用传过来的
   主要用于经常出现, 或者大多数情况下不需要被传值的情况
   """
   默认参数的实际案例
   	eg:很多软件的注册页面 默认会帮助我们勾选一些选项
   		默认头像
   		如果男孩子喜欢使用的软件默认性别可能是男性
   		如果女孩子喜欢使用的软件默认性别可能是女性
   """
   

使用方法:

def index(name,age,gender='男'):
print(name,age,gender)
print('学生名字:%s\t学生年龄:%s\t学生性别:%s'%(name,age,gender))
不传就使用默认的
index('tuzi',18,)  # 学生名字:tuzi	学生年龄:18	学生性别:男
传了就使用自己的
index('Jerry',20,'女')  # 学生名字:Jerry	学生年龄:20	学生性别:女

可变长参数#

用来定义不管传多少位置实参都可以正常执行
def func(*a):
    print(a)
func()  # ()
func(1,2)  # (1, 2)
func(1,2,3,4,5,6)  # (1, 2, 3, 4, 5, 6)
'''
*号在形参中可以接受多余的位置参数,并组织成元组的形式赋值给*号后面的变量名
'''
def func(a,b,*args):
    print(a,b,args)
func(111)  # 会报错,因为形参ab的存在,意味着index最少要给两个参数
func(1,2)  # 1 2 ()
func(1,2,3,'x')  # 1 2 (3, 'x')


'''
** 在形参中用于接受多余的关键字参数,并且组织成字典的形式赋值给**后面的变量
'''
def func (**kwargs):
    print(a,b,kwargs)
func(name='tuzi',age=18)  # {'name': 'tuzi', 'age': 18}
# 不管写多少个关键字传参都能被kwargs接收

可变长形参/可变长关键字#

###可变长形参###
*用来接收值
def func(x,y,z,*args):
    print(x,y,z,args)
func(1,2,3,4,5,6)  # 1 2 3 (4, 5, 6) 多余的位置参数,会以元组的方式放入到args里面

###可变长关键字###
def func (a,b,**kwargs):
    print(a,b,kwargs)
func(1,2,name='tuzi',age=18)  # 1 2 {'name': 'tuzi', 'age': 18}
满足了位置参数后,后面不管写多少个关键字传参都能被kwargs接收


#######*args,**kwargs 也可放在一起使用######

def func(*args,**kwargs):  # 前面的接收位置参数,后面的接收关键字参数,但是关键字参数和位置参数必须前后分开
    print(args,kwargs)
func(1,2,3,4,5,6,7,name='tzui',age=18,hobby=['啊吧啊吧吧',12312312])
(1, 2, 3, 4, 5, 6, 7) {'name': 'tzui', 'age': 18, 'hobby': ['啊吧啊吧吧', 12312312]}
'''
*和**在形参中的使用 后面的变量名并不是关键 但是针对这两个特殊符号后面的变量名推荐使用*args,**kwargs
'''

*/**补充(重要)#

### *号在实参中###
可以将列表或者元组打散成位置参数一一传入
def func(x,y,*args,):
    print(x,y,args)
l = [4,5,6]
func(1,2,*l)  # *l相当于位置参数4,5,6,func等同于func(1,2,4,5,6)  
# 结果:1 2 4 (5, 6) 元组
func(*['jason', 'kevin', 'tony', 'oscar', 'jerry']) # jason kevin ('tony', 'oscar', 'jerry')
func(*('jason', 'kevin', 'tony', 'oscar', 'jerry'))  # ('jason', 'kevin', 'tony', 'oscar', 'jerry') {}
func(*[1,2,3])  等价于>>>>  func(1,2,3)
func(*(1,2,3))  等价于>>>>  func(1,2,3)
也可以看成*号会将列表和元组的括号去除,暴露出里面一个个元素

#### **号在实参中####
可以将字典打散成关键字参数一一传入
def func(**kwargs, ):
    print(kwargs)
func(**{'name':'tuzi', 'age': 18})  # {'name': 'tuzi', 'age': 18}
func(**{'name':'tuzi'}) 等价于>>>func(name='tuzi')