打卡day07 python基础—函数

def 和 return 是关键字（keyword）python 就是靠识别这些特定的关键字来明白用户的意图

# 1、创建和调用函数
"""
我们创建了一个函数，但是从来都不去调用它，那么这个函数里的 代码就永远也不会被执行。
"""
def myFirstFunction():
    print('这是我创建的第一个函数')
print('我表示很激动')
print('在这里，我要努力学习')

 打印结果：

我表示很激动
在这里，我要努力学习

"""
我们创建了一个函数，去调用它，那么这个函数里的代码就会被执行。
"""
def myFirstFunction():
    print('这是我创建的第一个函数')
print('我表示很激动')
print('在这里，我要努力学习')
myFirstFunction()

打印结果：

我表示很激动
在这里，我要努力学习
这是我创建的第一个函数

# 假如想 把刚才的内容打印3次，只需要调用3次函数即可
"""
这里教大家如何调用一个函数，调用一个函 数也非常简单，直接写出函数名加上小括号即可
函数的调用和运行机制：当函数myFirstFunction()发生调用操作的时候，Python会自动往上找到def myFirstFunction()的定义过程，
然后依次执行该函数所包含的代码块部分（也就是冒号后面的缩进部分内 容）。只需要一条语句，就可以轻松地实现函数内的所有功能。
"""
def myFirstFunction():
    print('这是我创建的第一个函数')
print('我表示很激动')
print('在这里，我要努力学习')

for i in range(3):
    myFirstFunction()

打印结果：

我表示很激动
在这里，我要努力学习
这是我创建的第一个函数
这是我创建的第一个函数
这是我创建的第一个函数

# 2、函数的参数
def sayHi(name):
    print('嗨,%s'%name)
sayHi('小甲鱼')

打印结果：

嗨,小甲鱼

"""
其实括号里放的就是函数的 参数，在函数刚开始被发明出来的时候，是没有参数的（也就是说，小括号里没有内容），
很快就引来了许多小伙伴们的质疑：函数不过是对做同样内容的代码进行打包，这样与使用循环就没有什么本质不同了
"""
def mySecondFunction(name):
    print(name + '是帅哥')

mySecondFunction('小甲')
mySecondFunction('小雨')
mySecondFunction('小丑')

打印结果：

小甲是帅哥
小雨是帅哥
小丑是帅哥

# 传两个参数
def add(num1,num2):
    print(num1+num2)
add(1,6)

打印结果：

7

"""
函数的返回值  只需要在函数中使用关键字 return，后面跟着的就是指定要返回的值
"""
def fire():
    pass #此处添加炮弹的发射细节
    return '发射成功！！！'

fire()
print(fire())

打印结果：

发射成功！！！

#在Python中，并不需要定义函数的返回值类型，函数可以返回不同类型的值；

def add(num1,num2):
    return num1 + num2

print(add(1,3))

#而如果没有返回值，则默认返回None；
def hello():
    return
hello()
print(hello())

 打印结果：

4

None

def div(num1,num2):
    if num2 ==0:
        return'除数不能为0'
    else:
        return num1/num2

print(div(3,2))
print(div(4,0))

打印结果：

1.5
除数不能为0

# 如果返回了多个值，Python默认是以元组的形式进行打包
def test():
    return 1,'summer','abc'
test()
print(test())

打印结果：

(1, 'summer', 'abc')

# 也可以利用列表将多种类型的值打包到一块儿再返回
def test():
    return ['summer','adc',3.14]
print(test())

打印结果：

['summer', 'adc', 3.14]

# 参数从调用的角度来说，分为形式参数（parameter）和实际参数 （argument）。
# 与绝大多数编 程语言一样，形参指的是函数定义的过程中小括号里的参数，而实参则指的是函数在被调用的过程中传递进来的参数
def sayHi(name):
    return '嗨,%s'% name
sayHi('小海豚')
print(sayHi('小海豚'))
"""sayHi(name)中的name是一个形参，因为它只是代表一个位置、一 个变量名；
而调用sayHi("小甲鱼")传递的"小甲鱼"则是一个实参，因为 它是一个具体的内容，是赋值到变量name中的值。
"""

打印结果：

嗨,小海豚

"""
    功能：汇率转换 美元转人民币
    汇率：6.54
    日期;2020-7-27
"""
def exchangeRate(dollar):
    return dollar*6.54
    
exchangeRate(10)
print(exchangeRate(10))

# 函数的文档字符串可以通过特殊属性_ _doc_ _获取（注：_ _doc_ _两边分别是两条下画线）：
print(exchangeRate.__doc__)

# 当想使用一个BIF却又不确定其用法的时候，可以通过help() 函数来查看函数的文档：
help(exchangeRate)

打印结果：

65.4
None
Help on function exchangeRate in module __main__:

exchangeRate(dollar)

# 关键字参数
"""
关键字参数其实就是在传入实参时明确指定形参的变量名，其特点就是参数之间不存在先后顺序。
尽管使用这种技巧要多输入一些字符， 但随着程序规模越大、参数越多的时候，关键字参数起到的作用就越明 显。
毕竟宁可多输入几个字符，也不希望出现料想不及的BUG。
"""
def eat(somebody,something):
    print(somebody+'把'+something+'吃了')
eat('小海豚','蛋糕')
eat('蛋糕','小海豚')
eat(somebody='小海豚',something='蛋糕')

打印结果：

小海豚把蛋糕吃了
蛋糕把小海豚吃了
小海豚把蛋糕吃了

# 在调用函数的时候，位置参数必须在关键字参数的前面，否则就会出错
def eat(somebody,something):
    print(somebody+'把'+something+'吃了')
eat(something='蛋糕','小海豚')

#位置参数在关键字参数前面
eat('小海豚',something='蛋糕')

打印结果：

  File "C:/Users/issuser/PycharmProjects/untitled/test001/函数.py", line 129
    eat(something='蛋糕','小海豚')
                          ^
SyntaxError: positional argument follows keyword argument

小海豚把蛋糕吃了

# 默认参数
def saySomething(name='小海豚',word='让编程改变世界'):
    print(name+ '->'+ word)
"""
Python的函数允许为参数指定默认的值，那么在函数调用的时候如果没有传递实参，则采用默认参数值：
"""
saySomething()
saySomething('钢铁侠','拯救人类')
saySomething('苏轼','不识庐山真面目，只缘身在此山中')
saySomething(word='古之成大事者，不惟有超世之才，亦有坚忍不拔之志',name='苏轼')

打印结果：

小海豚->让编程改变世界
钢铁侠->拯救人类
苏轼->不识庐山真面目，只缘身在此山中
苏轼->古之成大事者，不惟有超世之才，亦有坚忍不拔之志

# 结合默认参数和关键字参数，可以使函数的调用变得非常灵活：
def watchMovie(girlfriend,name='小海豚',cigarette=True,beer=True):
    pass


# 在定义函数的时候，位置参数必须在默认参数的前面，否则 就会出错
def watchMovie(name='小海豚',cigarette=True,beer=True,girlfriend):
    pass

打印结果：

C:\Users\issuser\AppData\Local\Programs\Python\Python35\python.exe C:/Users/issuser/PycharmProjects/untitled/test001/函数.py

Process finished with exit code 0

C:\Users\issuser\AppData\Local\Programs\Python\Python35\python.exe C:/Users/issuser/PycharmProjects/untitled/test001/函数.py
  File "C:/Users/issuser/PycharmProjects/untitled/test001/函数.py", line 144
    def watchMovie(name='小海豚',cigarette=True,beer=True,girlfriend):
                  ^
SyntaxError: non-default argument follows default argument

Process finished with exit code 1

def watchMovie(name='小海豚',cigarette=True,beer=True,girlfriend=True):
    sentence = name + '带着'
    if cigarette:
        sentence = sentence + '香烟'
    if beer:
        sentence = sentence + '啤酒'
    if girlfriend:
        if cigarette or beer:
            sentence = sentence + '和女朋友'
        else:
            sentence = sentence + '女朋友'
    sentence = sentence + '去看电影'
    return sentence
print(watchMovie())
print(watchMovie(name='小鲤鱼',girlfriend=False))

打印结果：

小海豚带着香烟啤酒和女朋友去看电影
小鲤鱼带着香烟啤酒去看电影

# 收集参数
"""
若实参个数不确定，在定义函数的时候，形参就可以使用收集参数 来“搞定”。
而语法也很简单，仅需要在参数前面加上星号（*）即可：
"""
def test(*params):
    print('有 %d 个参数'%len(params))
    print('第二个参数是:',params[1])
test('F','i','s','h','C')

打印结果：

有 5 个参数
第二个参数是: i

# 请使用摄氏度转换器将35摄氏度转成华氏度，将结果存储在名为C2F的变量并打印出来，完成函数的调用同时打印结果
"""
把摄氏度转化定义函数Fahrenheit_Converter()，将输入进去的必然是摄氏度（Celsius）的数值，把C设为参数，最后返回的是华氏度(fahrenheit)
"""
def fahrenheit_Converter(C):
    fahrenheit = C*9/5 +32
    return str(fahrenheit) + ' F'
C2F=fahrenheit_Converter(35)
print(C2F)

打印结果：

95.0 F

"""
因为 print 是一个函数，并非关键字；return作为关键字在函数中起到了返回值的作用，而print，只是在函数中展示我们打印的结果，是为人类设计的函数。
95.0℉实际上是函数后产生的数值，下面的None正是此时变量C2F 中被返回到的数值——什么都没有，就因为没有关键字“return”
好比你对着一个人喊了一声他的名字（call）他只是“哎”地回应你一声，这是因为你并没有他改做什么（return）
"""
def fahrenheit_Converter(C):
    fahrenheit = C*9/5 +32
    """
    做一个小改动，把return换成print函数
    """
    print(str(fahrenheit) + ' F')

C2F=fahrenheit_Converter(35)
print(C2F)

打印结果：

95.0 F
None

# 设计一个重量转换器，输入以‘g’为单位的数字后返回换算成“kg”的结果
def weight_Conversion(g):
    # 1g=1/1000kg
    return   str((g/1000)) +'kg'
"""将结果存在g2kg这个变量并打印出来"""
g2kg = weight_Conversion(500)
print(g2kg )

打印结果：

0.5kg

# 设计一个求直角三角形斜边长的函数（两条直角边为参数，求最长边），如果直角边边长分别为3和4，那么返回的结果应该是这样：The right triangle third side's length is 5.0
def side_length(a,b):
    return 'The right triangle third side\'s length is {}'.format( (a**2+b**2)**(1/2))
"""
等价于2的平方米与b的平方米之和的1/2次方（即开根）
"""
print(side_length(3,4))
"""调用函数并打印结果"""

打印结果：

The right triangle third side's length is 5.0

# 传递参数与参数类型
"""定义函数:trapezoid_area（梯形面积），设定参数：base_up（上底）,base_down（下底）,height（高）每一个都用英文输入法的都好隔开。"""
def trapezoid_area(base_up,base_down,height):
    return (base_up+base_down)*height*(1/2)
"""
第一种方式调用函数，（1,2,3）分别对应（base_up,base_down,height），这种传入参数的方式被称做位置参数"""
area = trapezoid_area(1,2,3)
print('第一种方式调用函数的结果是： %s'%area)

"""
第二种方式调用函数，（base_up = 1,base_down = 2,height = 3）,将每个参数名称后面赋予一个我们想要传入的值，
这种以名称作为一一对应的参数传入方式被称作是关键词参数
"""
area1 = trapezoid_area(base_up=1,base_down=2,height=3)
print('第二种方式调用函数的结果是： %s'%area1)

"""第三种调用函数，（height = 3,base_down = 2,base_up = 1），函数参数按照反序传入，因为是关键词参数，所以并不影像函数正常运作"""
area2 = trapezoid_area(height = 3,base_down = 2,base_up = 1)
print('第三种方式调用函数的结果是： %s'%area2)

"""
第四种调用函数，(height = 3,base_down = 2,1),函数参数反序传入，但是第三个却变成了位置参数，
这种方式是错误的方法，因为如果按照位置来传入，最后一个应该是参数height的位置，但前面height已经按照名称传入了值3，所以是冲突的
"""
# are3 = trapezoid_area(height = 3,base_down = 2,1)
# print('第四种方式调用函数的结果是： %s'%area2area3)

"""
第五种调用函数，(base_up=1,base_down=2,3),函数郑旭传入，前两个以关键词的方式传入，最后一个以位置参数传入，这是错误的
"""
# area4 = trapezoid_area(base_up=1,base_down=2,3)
# print('第五种方式调用函数的结果是： %s'%area4)

"""
第6种调用函数，(1,2,height=3),函数参数正序传入，前两个以位置方式传入，最后一个以关键字参数传入，这是可以正常运行的
"""
area5 = trapezoid_area(1,2,height=3)
print('第六种方式调用函数的结果是： %s'%area5)


"""
第七种调用函数，给一个参数设定默认值，只需要在定义参数的时候给参数赋值即可，
"""
def trapezoid_area(base_up,base_down,height=3):
    return 1/2*(base_up + base_down)*height
"""定义时设置了height默认值等于3，这时只需要传入两个参数就可以正常进行了"""
area6 = trapezoid_area(1,2)
print('第七种方式调用函数的结果是： %s'%area6)

打印结果：

第一种方式调用函数的结果是： 4.5
第二种方式调用函数的结果是： 4.5
第三种方式调用函数的结果是： 4.5
第六种方式调用函数的结果是： 4.5

第七种方式调用函数的结果是： 4.5

"""
我们定义一个叫做手电筒（flashlight）的函数，他需要两个参数 battery1 和 battery2 意为电池；
# nanfu1/nanfu2是变量，同时也是满足能够传入的函数的flashlight函数的参数，
传入后就替代了原有的battery1和battery2且传入方式仍旧是位置参数传入，battery1和battery2只是形式上的的占位符,
表达的意思是函数所需的参数应该是和电池即battery有关的变量或者是对象
"""
def flashlight(battery1,battery2):
    return 'Light'

nanfu1 = 600
nanfu2 = 600
"""将调用函数结果存在变量light里"""
light = flashlight(nanfu1,nanfu2)
print(light)

打印结果：

Light