Python 之初识函数 （day08 课堂笔记）

"""
今天我们初识函数，函数分为内置函数和自定义函数，今天我们主要学习自定义函数

"""

# def conf():
# #     """
# #     该自定义的函数实现len()内置函数的功能，（但len（）函数效率要远远高于此自定义函数，它时用c语言编译的）
# #     :return: sum
# #     """
# #     s = 'hello everyone'
# #     sum = 0
# #     for i in range(len(s)):
# #         sum+=1
# #     return  sum
# #
# # print(conf())

"""
很多人会问，你这个直接用python()自带的len()内置函数就行了，为什么还用函数这么麻烦的操作？
其实函数在定义了之后，可以在任何需要它的地方调用,当我们多次需要这个自定义的函数的小功能的时候，
我们进行多次的调用就行了，不需要反复的写，提高代码的重用率，也提高代码的效率，同时自定义的函数
可以实现你想实现的功能，而毕竟内置函数有限，所以函数是很有必要的在我们的使用中。
"""

"""
讲述函数的返回值：

#返回值的3种情况
    # 没有返回值 —— 返回none
        # 不写return
        # 只写return:结束一个函数的继续
        # return none  —— 不常用
    # 返回1个值
        # 可以返回任何数据类型
        # 只要返回就可以接收到
        # 如果在一个程序中有多个return，那么只执行第一个
    # 返回多个值
        # 用多个变量接收：有多少返回值就用多少变量接收
        # 用一个变量接收: 得到的是一个元组
"""

#没有返回值
#
# def conf0():
#     print('123')    #123
# s = conf0()         #none
#
# print(s)
# #只有返回值
# def conf1():
#     return          #none
# print(conf1())
# #return none
# def conf1():
#     return  none    #none
# print(conf1())

#一个返回值
#
# def conf1():
#     s = [1,'2','3',['2','5','0']]
#     return s
# f1 = conf1()
# print(f1)           #[1, '2', '3', ['2', '5', '0']]
# print(type(f1))     #<class 'list'>

#多个返回值
#
#多返回值多变量接值（1 ：1 的关系）
# def conf1():
#     a = 1
#     b = 2
#     c = 3
#     return a,b,c
# f1,f2,f3 = conf1()
# print(f1,f2,f3)         # 1 2 3
# print(type(f1))         #<class 'int'>
#多返回值一个变量接值（n ：1 的关系）
# def conf2():
#     a = 'a'
#     b = 'b'
#     c = 'c'
#     return  a,b,c
# k1 = conf2()
# print(k1)                #('a', 'b', 'c')
# print(type(k1))          #<class 'tuple'>

"""
下面需要了解函数的参数问题，整体来看参数问题相较于返回值来说有一定的难度，需认真学习。
1.什么叫参数？
2.参数的语法
3.形参和实参的概念
"""

# def conf(s):        # 接收参数,形式参数，简称形参
#     '''
#     这个函数就是带参的函数
#     我们告诉conf()函数要计算的字符串是谁，
#     这个过程就叫做 传递参数，简称传参，
#     我们调用函数时传递的这个“hello ,everybody”和定义函数时的s就是参数。
#     :param s:
#     :return:m
#     '''
#     m = 0
#     for i in s:
#         m += 1
#     return m
# length = conf('hello ,everybody')   #传递参数：传参，实际参数，简称实参
# print(length)           #16

"""
实参与形参

参数还有分别：

我们调用函数时传递的这个“hello ,everybody”被称为实际参数，因为这个是实际的要交给函数的内容，
简称实参。

定义函数时的s，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它只是一个形式，
表示这里有一个参数，简称形参。　　

"""

"""
参数
    没有参数
        定义函数和调用函数时括号里都不写内容
    有一个参数
        传什么就是什么
    有多个参数
        位置参数
"""

#传递多个参数
#参数可以传递多个，多个参数之间用逗号分割。
# def conf(a ,b):
#     """
#     实现两个数相加的功能
#     :param a:
#     :param b:
#     :return: sum
#     """
#     sum = a + b
#     return sum
# print(conf(1,2))        # 3

"""
站在实参的角度上：
    按照位置传参
    按照关键字传参
    混着用可以:但是必须先按照位置传参，再按照关键字传参数,不能给同一个变量传多个值
"""

#位置传参
# def conf(a ,b):
#     """
#     实现两个数相加的功能
#     :param a:
#     :param b:
#     :return: sum
#     """
#     sum = a + b
#     return sum
# print(conf(1,2))        # 3
    # 位置传参 ：
    #             1 -> a
    #             2 -> b
#按关键字传参
# def conf(a ,b):
#     print(a,b)           # 2  1
#     sum = a + b
#     return sum
# print(conf(b =1,a =2))  # 3
#位置和关键字传参混用
#1.
# def conf(a,b):
#     sum = a + b
#     return sum
# print(conf(1,b=2))       # 3
#2.
# def conf(a,b):
#     sum = a + b
#     return sum
# print(conf(b=2,1))  #syntaxerror: positional argument follows keyword argument
#但是必须先按照位置传参，再按照关键字传参数,不能给同一个变量传多个值

"""
站在形参的角度上
    位置参数：必须传,且有几个参数就传几个值
    默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的
"""

#位置参数
# 1.两个参数，传一个值
# def conf(a,b):
#     sum = a + b
#     return sum
# print(conf(1))  #typeerror: conf() missing 1 required positional argument: 'b'
# 2.两个参数，传三个值
# def conf(a,b):
#     sum = a + b
#     return sum
# print(conf(1,2,3))  #typeerror: conf() takes 2 positional arguments but 3 were given
#3.两个参数，传两个值
# def conf(a,b):
#     sum = a + b
#     return sum
# print(conf(1,2))  # 3

#默认参数 , 不传值
# def conf(a = 1,b =2):
#     sum = a +b
#     return sum
# print(conf())       #3
#默认参数 , 传值
# def conf(a = 1 , b = 2):
#     sum = a + b
#     return sum
# print(conf(2,3))     #5

"""

只有调用函数的时候
    按照位置传 ： 直接写参数的值
    按照关键字： 关键字 = 值

定义函数的时候：
    位置参数 ： 直接定义参数
    默认参数，关键字参数 ：参数名 = '默认的值'
    动态参数 : 可以接受任意多个参数
                参数名之前加*，习惯参数名args，
                参数名之前加**，习惯参数名kwargs
    顺序：位置参数，*args,默认参数,**kwargs

"""

"""

动态参数有两种：可以接受任意个参数
    *args   ： 接收的是按照位置传参的值，组织成一个元组
    **kwargs： 接受的是按照关键字传参的值，组织成一个字典
    args必须在kwargs之前

"""


# *args   ： 接收的是按照位置传参的值，组织成一个元组
# def conf(*args):
#     n = 0
#     for i in args:
#         n = n + i
#     return n
# f1 = conf(1,2)
# print(f1)

#  **kwargs： 接受的是按照关键字传参的值，组织成一个字典
# def conf(**kwargs):
#     print(kwargs)
#     print(kwargs['name'],kwargs['sex'])
# conf(name = 'alex',sex = 'man')

"""

动态参数的另一种传参方式
站在形参的角度上，给变量加上*，就是组合所有传来的值。
站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

"""

#args
# def conf(*args):    #组合
#     print(args)
# conf(1,2,3,4,5)
# lisl = [1,2,3,4,5]
# conf(*lisl)        #打散
#kwargs
# def cof(**kwargs):
#     print(kwargs)
# cof(name = 'alex' , sex = 'man')
# f1 = {'name':'alex','sex':'man'}
# cof(**f1)

参数总结：