python - 函数

1. 函数定义

# 函数定义
# 通过关键字def来定义。这一关键字后跟一个函数的标识符，在跟一对圆括号，其中可以包括一些变量的名称，再以冒号结尾。另起一行的语句块是函数体。
# def 函数名():
def say_hello():
    print('hello')

say_hello()   # 函数调用

 

2. 函数参数

# 函数参数
def compare(a, b):  # 两个参数a, b（形参）
    if a > b:
        print(a, 'is big')
    elif a == b:
        print('{} is equal to {}'.format(a, b))
    else:
        print('{} is big'.format(b))

compare(5, 5)

 

3. 默认值参数

# 默认参数值
'''
目标：使一些参数可选并使用默认值
在函数定义时，附加一个赋值运算符(=)来为参数指定默认参数值，默认参数值应该是常数，不可变
默认参数应位于函数参数列表最后（因为传参时按照参数所在位置依次分配的），即在函数的参数列表中，拥有默认参数值的参数不能位于没有默认参数值的参数之前。
'''
def say_hello(a, times=1):
    print(a * times)

say_hello('hello ')
say_hello('hello ', 5)

 

4. 关键字参数

# 关键字参数
'''
如果你有一些具有许多参数的函数，而又希望只对其中的一些进行指定，就可以通过命名它们来給这些参数赋值
使用命名（关键字）而非位置来指定函数中的参数
优点1：我们不再需要考虑参数的顺序
优点2：可以只对那些我们希望的参数赋值，只要其他参数都具有默认参数值
'''
def func3(a, b=5, c=10):
    print('a = {}, b = {}, c = {}'.format(a, b, c))

func3(3, 7)        # a=3, b=7, c=10
func3(25, c=24)   # 指定关键字参数c的值  a=25, b=5, c=24
func3(c=50, a=100)   # 关键字参数c和a，不用考虑顺序   a=100, b=5, c=50

 

5. 可变参数

# 可变参数
'''
若希望定义的函数里面有任意数量的变量（参数数量可变），可以通过使用星号来实现
通过元组和字典实现（一个*接收元组，两个*接收字典）
'''
def total(a=5, *numbers, **phonebook):
    print('a', a)

    # 遍历元组中的所有项目
    for single_item in numbers:
        print('single_item', single_item)

    # 遍历字典中的所有项目
    for first_part, second_part in phonebook.items():
        print(first_part, second_part)

print(total(10, 1, 2, 3, jack=1123, jone=2231, inge=1560))

 拆包：在传递参数时，为了对应相应的数据，在调用带有多值参数的函数时，如果希望：

• 将一个元组变量，传递给args
• 将一个字典变量，传递给kwargs

 就可以使用拆包，简化参数的传递，拆包的方式是：

• 在元组变量前，加一个*
• 在字典变量前，加两个**

def func(a, *args, **kwargs):
    print(a)
    print(args)
    print(kwargs)

tuple1 = (2, 3, 4)
dict1 = {
    'name1': 'zhangsan',
    'name2': 'lisi'
}

func(1, *tuple1, **dict1)  # 简化元组/字典的传递

 打印：

1
(2, 3, 4)
{'name1': 'zhangsan', 'name2': 'lisi'}

 

ps:

列表前加个*号，是将列表拆分成单个元素，一般用在传递列表参数到函数中

a = [1, 2, 3]
print(a)  # 打印：[1, 2, 3]
print(*a)  # 打印： 1 2 3

 

 

6. 各参数顺序

1. 所有非默认参数必须在默认参数的前面
2. *参数为非默认参数
3. 出现在*参数后的参数是关键字参数，**参数后面不能出现其他参数，即**必须出现在最后。

def func1(a,  *args, b = 10, **kwargs):
    pass

 

 

7. return语句

# return 语句
''' 
return语句用于从函数中返回，也就是中断函数。在中断函数时，从函数中返回一个值
若return语句没有搭配任何一个值，则代表着返回None。None在python中是一个特殊的类型，代表着虚无。例：它用于指示一个变量没有值，如果有值则它的值便是None
每一个函数都在其末尾隐含了一句return None，除非你写了自己的return语句
'''
def maxinum(x, y):  # 例1
    if x > y:
        return x
    elif x == y:
        return 'x is equal to y'
    else:
        return y

print(maxinum(5, 5))


def som_fun():   # 例2
    pass   # pass语句用于指示一个没有内容的语句块

print(som_fun())   # 打印None

在python中，return可以返回多个值，将多个返回值组装成元组的形式，如下：

def split_data(str1):
    result = str1.split('>')
    return result[0], result[1]  # return多个值


aa = 'fjds>fs>fsdd'
bb = split_data(aa)

print(bb)  # 打印：('fjds', 'fs')，元组的形式

 或通过索引，获取响应值。例如：bb[0]、bb[1]

 或者通过多个变量接收返回值。例如：b1, b2 = split_data(aa)

 

另，两个数交换的方法（python专有）

# 以下交换a，b的值
a = 1
b = 2
a, b = b, a

print(a)  # 打印：2
print(b)  # 打印：1

  

8. 局部变量

# 局部变量
# 所有变量的作用域，是它们被定义的块，从定义它们的名字的定义点开始
x = 5

def func1(x):
    print('x is', x)
    x = 2  # 同名的局部变量的值改变，不影响同名的全局变量的值
    print('local x is', x)  # x = 2

func1(x)
print('global x is', x)  # x = 5

 

9. 全局变量

# 全局变量 global
# 如果想给一个全局变量赋值，使用global关键字。因为在不使用global语句的情况下，不可能为一个定义于函数之外的变量赋值
# 使用global，为一个定义于函数之外的变量赋值（使用global告诉python，这一变量是全局的）
y = 5

def func2():
    global y  # 使用global声明全局变量，若在函数体内有同名局部变量，赋值会影响全局变量
    print('before modified y is', y)   # y = 5
    y = 2
    print('modified y is', y) # y = 2

func2()
print('global y is', y) # y = 2

 

10. 文档字符串docstring

1）函数的文档字符串

# 文档字符串 DocString
"""
函数的第一行逻辑行中的字符串，是该函数的文档字符串（也适用于模块和类）
规则：多行字符串
约定格式：第一行以某大写字母开始，以句号结束。第二行为空行。第三行任意说明
"""
def print_max(x, y):
    """
    Prints the maximum of two numbers. 打印两个数值中的最大数。

    :param x:
    :param y:
    :return:
    """
    x = int(x)
    y = int(y)

    if x > y:
        print(x, 'is maximum')
    else:
        print(y, 'is maximum')

print_max(3, 5)
print(print_max.__doc__)  # 打印docstring（获取函数print_max的__doc__属性）

2）类和方法的文档字符串：

class A:
    """类A的文档字符串"""
    def fun_A(self):
        """方法A的文档字符串"""
        pass


print(A.__doc__)         # 访问类的文档字符串
print(A.fun_A.__doc__)   # 访问方法的文档字符串

 

11. 函数注释

def func3(aa:int)->str:
      return str(aa)

b = func3(8)
print(type(b), b)  # 打印：<class 'str'> 8
print(func3.__annotations__)  # 打印：{'aa': <class 'int'>, 'return': <class 'str'>}

 函数参数中的aa:int，是对参数aa的注释，表示参数aa的类型是str；函数第一行结尾冒号前的->str是对函数返回值的注释，表示函数的返回值类型是str。

 函数注释可以通过__annotations__显示

 

12. 函数自动注释

　在函数下方连续输入三个引号，回车，即可自动生成（后期更新的参数，需要手动加注释）

def func3(aa:int)->str:
      """

      :param aa:
      :return:
      """
      return str(aa)