学习之旅6-python函数（一）

• 引入 ：基本上所有的高级语言都支持函数，Python也不例外。Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。
  函数就是最基本的一种代码抽象的方式

1、python函数

1.1 函数基础

• 什么是函数： 函数其实就是一系列代码封装组合，在程序中可以多次运行，一般来说函数是完成一个具体的独立功能。
• 函数的优点： 简化复杂冗余的代码块，整体代码结构清晰，使问题局部化。
• 函数的定义： def + 关键字 + 小括号 + 冒号+ 换行缩进 + 代码块 定义一个函数
  def 函数名():
  代码块
  return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
• 函数的调用： 本质上就是去执行函数定义里面的代码块，在调用函数之前 必须先定义

# 如果不使用函数，则需要每次重复执行大量代码
print('tom的性别是：男')
print('tom的出生年月是：1993-08')
print('tom的身高是：175')
print('tom的体重是：150')
print('tom的工作是：数据分析师')

print('peter的性别是：男')
print('peter的出生年月是：1994-02')
print('peter的身高是：172')
print('peter的体重是：134')
print('peter的工作是：java架构师')
# 定义一个函数，每次调用执行输出即可
def fun_info(): #定义函数名
    '''
    这是用来输出个人信息的
    :return: 
    ''' #在定义函数的时候，可以写注释说明该函数的作用，注意是6个单引号，后面调用时，按住Ctrl,鼠标指向函数名时会显示该函数的说明
    print('tom的性别是：男') #代码块定义函数体
    print('tom的出生年月是：1993-08')
    print('tom的身高是：175')
    print('tom的体重是：150')
    print('tom的工作是：数据分析师')
    return #表示该函数定义结束

# 函数的调用,注意必须先定义才能调用，不能注释掉
# 函数名加()即可调用该函数,如果此前定义函数有说明，此时按住Ctrl,鼠标指向函数名时会显示该函数的说明
fun_info()
fun_info() #多次调用
# 函数调用完后，会执行后面的语句，即函数是单独的代码块，不影响后面语句的执行
print('这是执行函数后的语句')

1.2、函数参数

• 参数的意义： 之前的函数都是将函数体写死，若我们想要输出不同人的信息，此时我们在定义函数之前就应该确定参数，通过参数来进行不同函数值的返回。因此对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了。
• 参数传递： python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。（即python中不存在所谓的传值调用，一切传递的都是对象的引用，也可以认为是传址）
• 关于对象： a、可变对象（ list,dict）：对象的内容是可变的；b、不可变的对象（int，string，float，tuple）：表示其内容不可变。

#下面代码中，[1,2,3,'python'] 是 list 类型，"python" 是 string 类型，而变量 a 是没有类型，变量a仅仅是一个对象的引用（一个指针），可以是 list 类型对象，也可以指向 string 类型对象。
a = [1,2,3,'python']
a = 'python'

# 函数的参数，通过传入不同的参数来得到我们想要的信息
def fun_info(name,sex,date,height,weight,job): #通过定义参数来返回信息（参数个数不定）
    '''
    这是用来输出不同人信息的（带参数）
    :return:
    '''
    print('{}的性别是：{}'.format(name,sex))
    print('{}的出生年月是：{}'.format(name,date))
    print('{}的身高是：{}'.format(name,height))
    print('{}的体重是：{}'.format(name,weight))
    print('{}的工作是：{}'.format(name,job))
    return

#调用带参数的信息
fun_info('tom','男','1992-09','170','135','数据分析师')
fun_info('peter','男','1993-09','175','140','java架构师')

• 参数的分类： 参数其实就是函数为了实现某些特定的功能，进而为了得到实现功能所需的数据，就是为了得到外部数据。
  1）必选参数：

#1)必选参数
def sum(a,b):#形式参数，定义的时候不占内存地址
    '''
    求a，b之和
    :param a:
    :param b:
    :return:
    '''
    sum=a+b
    print(sum)
    return

#函数调用，对于定义函数已经设定的必选参数，必须赋值，否则报错
sum(10,20) # 10,20是实际参数（实参），实实在在的参数，会占内存地址
# sum(13) # 报错，丢失参数

2）默认参数

#2）默认参数
def sum1(a=20,b=30): # 默认参数必须都赋值，否则未赋值的必选放最前面sum1(a,b=20)
    print(a*b)
    return
# 函数调用
sum1()
sum1(10) #对应默认参数，我们可以重新传值

3）不定长参数

# 3）不定长参数 加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：
def printinfo(a,*arg1): #注意此时我们定义了2个参数，一个必选参数，一个不定长参数，则第一个必须赋值
    print(a)
    print(arg1)
    return

# 调用printinfo 函数
printinfo(10) #此时我们会发现，第一个结果为10,第二个结果为元组()
printinfo(70,60,50) #第一个结果为70,第二个结果为元组(60,50)

def funfor(*args):
    '''
    求累加和，但是累加数不确定，通过不定长参数来定义，根据循环得到累加和
    :param args:
    :return:
    '''
    result=0
    for item in args:
        result+=item
        pass
    print(result)
    return

funfor(1,2,3)
funfor(10,20,30)

4）关键字参数

# 4）关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为字典{dict}
# 关键字参数:**like
def info(name,age,**like):
    print('我的名字是{},年龄{},其他：{}'.format(name,age,like))
    return

info('tom',18)
info('peter',23,like='python')  #此时关键字参数会以字典形式出现

other={
     'city':'成都','job':'数据分析师'}
info('jake',28,**other)

# 除个别信息是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足需求

#补充：一般来说都是各种参数混合使用 注意顺序：必选参数，不定长参数，关键字参数
def funinfo(name,sex,age,*args,**other):
    print(name,sex,age,args,other)
    return

funinfo('dawei','男',26,'篮球','羽毛球','游泳',job='java架构师',city='成都')

1.3、函数返回值

• 返回值： 所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果。通俗来讲，我用10元钱买2斤水果，那么这10元就相当于之前所讲的参数，而2斤水果就是我们所需要的返回值。
• return： return 语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。return可以返回任何类型的值，具体取决于return后面的类型。
• 注意： 在一个函数体内可以出现多个return值：但是肯定只能返回一个return，如果函数需要返回多个结果呢？ 将要返回的值用逗号隔开。最终会返回一个包含所有返回值的元组

# 函数返回值，给调用方返回数据
# 如果在一个函数体内 执行了return,意味着函数就执行完成退出了，return后面的代码语句将不会执行
def Sum(a,b):
    '''
    求两个数的和
    :param a:
    :param b:
    :return: 返回值
    '''
    sum=a+b
    return sum#将计算的结果返回
    pass

print(Sum(2,1)) #直接返回输出

result=Sum(10,2) #将返回值赋给其他变量
print(result)  #函数的返回值返回到调用的地方

# 定义一个函数求累加和（while循环），但是最后return后面是一个list（列表）类型，则返回的值为列表类型
def sumfun(num):
    '''
    求累加和
    :param num:
    :return: 返回指定类型
    '''
    result=0
    list1=[]
    item=0
    while item <=num:
        result+=item
        item += 1
        pass
    list1.append(result) # 将得到的累加和追加给列表list1
    return list1 #返回列表
    pass

values=sumfun(30)
print(values)
print(type(values)) #由于return后面返回的列表，所以values的类型为列表

# 同理求累加和（for循环）
def fu(num):
    sum=0
    list2=[]
    dict3={
     }
    for i in range(num):
        sum+=i
    pass
    list2.append(sum) #将sum值追加到列表中
    dict3['人数']=sum #将sum值添加到字典中 键为'人数'，values为 sum
    return sum,list2,dict3 #返回多个值，用逗号隔开
pass

print(fu(11)) #此时我们将得到3个返回结果（元组类型）
print(type(fu(11)))

结果如下：

1.4、函数嵌套调用

# 函数的嵌套使用
def fun1():
    print('----------这是第1个函数开始---------')
    pass

def fun2():
    print('----------这是第2个函数开始---------')
    #调用第1个函数
    fun1()
    print('----------这是第2个函数结束--------')
    pass

fun2()

结果如下：

参考文献 :
1、可变对象和不可变对象.
2、Python 函数.
3、Python 关键字参数.