python学习笔记05：函数

1. 定义函数

作用：

• 在开发程序时，使用函数可以提高 编写的效率以及 代码的复用性。

使用：

• 定义函数：def  函数名(): 
  
• 函数名不能重复，可以右字符下划线和数字组成，不能以数字开头，不可以与关键字重名。
• 调用函数：函数名()

# 函数格式：
def 函数名():
    函数封装的代码


函数名()

参考：

def hello():  # hello是函数名
    print('hello')  # 函数体


hello()  # 调用函数，函数不调用不会执行

注意：

• 1、函数即变量
• 2、函数添加注释（使用三引号注释），在函数调用位置，使用快捷键ctrl+q可以查看函数的说明信息；
• 2、函数体相对比较独立，函数定义及调用函数的上方 保留2个空行，否则会有波浪线；

2. 函数的参数

作用：

• 增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据。
  • 在函数 内部，把参数当作 变量 使用，进行需要的数据处理。
  • 函数调用时，按照函数定义的 参数顺序，把希望在函数内部处理的数据，通过参数 传递。

使用：

• 多个参数之间使用  ,  号分隔
参数分为形参和实参
• 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用。
• 实参：调用 函数时，小括号中的参数，是用来 把数据传递到函数内部 用的。

# 写文件
def write_file(file_name,content):  #file_name和content是形参
    with open(file_name, 'w', encoding='utf_8') as f:
        f.write(content)
write_file('函数.txt','学习函数')  #'函数.txt'和'学习函数'是实参

3. 函数的返回值

作用：

• 1.返回结果（函数没有写返回值的时候，默认返回为None）
• 2.函数里面只要遇到return，函数立马 执行结束，下方代码不会被执行到。

使用：

• 可以使用 变量 来 接收 函数的 返回结果

1）返回数据

# 返回数据
def read_file(file_name):
    with open(file_name, 'r', encoding='utf-8') as f:
        content = f.read()
        return content  # 函数返回值，读完的结果返回
result = read_file('函数.txt')  # 使用变量保存返回值
print('result结果:', result)

2）遇到return立马返回

# 函数里面只要遇到return，函数立马执行结束
def t():
    for i in range(5):
        print(i)
        return
t()

3）多个返回值

# 多个返回值
def measure():
    temp = 39
    wetness = 50 
    return temp, wetness     # return (temp, wetness)如果函数返回的类型是元组，小括号可以省略
result = measure()  #可以拿一个变量接收，返回的结果是元祖形式
print(result)
# 使用多个变量，一次性接收函数的返回结果
# 注意：使用多个变量接收结果时，变量的个数 应该和 元组中元素的个数 保持一致
gl_temp, gl_wetness = measure()  # 接收多个变量（称为“解包”）
print(gl_temp, gl_wetness)

解包

# 解包：list有多个元素可以解开
info = ['xiaohei', 'beijing', '139']
name, addr, phone = info
print(name, addr, phone)

4. 函数的嵌套调用

在工作中针对需求的变化，不要轻易修改之前已经完成的代码。

# 一个函数能够打印5行分割线，由任意字符 任意次数组成的分隔线
def print_line(char, times):
    """打印单行分割线

    :param char: 分割线使用的分隔字符
    :param times: 分隔线重复的次数
    """
    print(char * times)


def print_lines(char,times,num):
    """打印多行分割线

    :param char:分割线使用的分隔符
    :param times:分割线重复的次数
    :param num:打印行数
    """
    for i in range(num):
        print_line(char, times)


print_lines("-", 20, 6)

小技巧：函数添加文档注释

函数小练习

# 判断s是否是合法小数，如s = '14.1'，返回True或False
# 分析：
# 1）传参
# 2）把入参转成字符串
# 3）判断小数点个数是否为1
# 4）判断小数点前面是否为整数
# 5）判断小数点后面是否为整数

def is_float(s):
    s = str(s)
    if s.count('.') == 1:  #判断小数点是否存在
        left, right = s.split('.')  #分割小数点的左右
        if right.isdigit() and left.isdigit():  #判断是否是正小数（左右两边是否是整数）
            if int(right) != 0 or int(left) != 0:  #判断左右两边不能同时为0（因0.0不是小数）
                return True

        if left.startswith('-') and left.count('-') == 1:  #判断是否是负小数
            num = left[1:]
            if num.isdigit() and right.isdigit():
                if int(right) != 0 or int(left) != 0:
                    return True
    return False
print(is_float('-1.3'))

5. 函数的形参

1）缺省参数

• 定义函数时，可以给 某个参数 指定一个 默认值，具有默认值的参数就叫做 缺省参数。
• 调用函数时，如果 没有传入缺省参数 的值，则在函数内部使用定义函数时指定的参数默认值。
• 函数的缺省参数，将常见的值设为参数的缺省值，从而简化函数的调用。

# 无参数
def a():
    pass

# 必填参数
def b(name,age):  #又叫位置参数
    pass
b('xiaohei',19)

# 默认值参数
def op_file(file, content=None):  #默认值参数
    with open(file, 'a+', encoding='utf-8') as f:
        if content:  #传值，说明要写
            f.write(str(content))
        else:  #没传值，说明要读
            f.seek(0)
            result = f.read()
            return result

# 可变参数
# 1.这个参数非必传
# 2.不限制参数的个数
# 3.args是元祖
def send_sms(*args):  #可变参数
    print(args)
    print(type(args))
send_sms(151,150,138,131)

# 关键字参数
# 1.这个参数非必传
# 2.不限制参数的个数
# 3.kwargs是字典
def t(**kwargs):  #关键字参数
    print(kwargs)
    print(type(kwargs))
t(age = 5, name = 'beijing')  #关键字参数，传入的必须指定关键字

# 如果四种参数一起用的话，顺序必须是： 必填参数、默认值参数， 可变参数、关键值参数
def test(name,content=None,*args,**kwargs):
    print(name)
    print(content)
    print(args)
    print(kwargs)


def test(name, phone, age, addr, sex):
    print(name)
    print(phone)
    print(age)
    print(addr)
    print(sex)
test('小明','1111','18','北京','男')  #根据定义的参数顺序来传参，容易传错顺序
test(age='18', name='小明', phone='1111', addr='北京', sex='男')  #指定关键字传参，不需要按照顺序
test('小明', '1111', age='18', addr='北京', sex='男')  #组合传参
# test('小明', '1111', age='18', addr='北京', '男')  #错误的，不能这样写

6. 局部变量和全局变量

在python中，在函数内部是不允许直接修改全局变量的值。如果在函数中修改全局变量，需要使用global进行声明。

• 全局变量：定义在 函数外面 的变量，位置应该定义在 函数的上面，作用域是 全部的，大家都可以用。
• 局部变量：定义在 函数里面 的变量（没有加global修饰），作用域在 函数里面，出了函数就失效。

建议：

　　为了避免局部变量和全局变量混淆，在定义全局变量时，变量名前面增加 g_ 或者 gl_ 的前缀。

name = 'xiaohei'  # 全局变量
def rename():
    global name  # global声明全局变量（在函数里面改全局变量）
    name = 'xiao'  # 局部变量
    print('name1', name)
def test():
    print('name2', name)  # 函数里变量先在函数里找局部变量，取不到值，再去函数外找全局变量
print('name3', name)
rename()
print('name4', name)  # 调用函数后，声明的全局变量才生效
test()

小练习：

money = 500
def test(consume):  # 3.test(500)
    return money - consume  #4.500全局变量-500consume=0
def test1(money):  # 2.test1(500)
    return test(money) +money  # 5.test(500)+全局变量500
money = test1(money)  # 1.test1(500全局变量)
print(money)  #打印500



def test():
    global a
    a = 5
def test1():
    c = a+5
    return c
test()  # 定义函数，不调用不会执行
res = test1()
print(res)

7. 递归函数

# 递归函数：函数自己调用自己，有最大的递归次数999
def xiake():
    print('下课')
    xiake()    #调用函数
xiake()  #调用函数


# 递归效率没有循环效率高
def enter():
    choice = input('请输入你的选择(1、登录；2、注册；3、后台管理):')
    if choice not in ['1', '2', '3']:
        print('输入有误，请重新输入')
        enter()
    else:
        print('登录')
enter()

8. 内置函数

int()  #转整数
str()  #转字符串
list()  #转列表类型
set()  #转集合类型
dict()  #转字典类型
tuple()  #转元祖类型
bool()  #转bool类型
type()  #查看类型
len()  #取长度
input()  #输出
print()  #打印

print(all([1, 2, 3, 0]))  #判断可循环的对象里面的值是否都为真，返回True，否则返回False（非空即真，非0即真）
print(any([1, 2, 3, 0]))  #判断可循环的对象里面的值是否有一个为真，返回True，否则返回False（非空即真，非0即真）
print(bin(10))  #十进制转二进制
print(chr(33))  #数字对应的ASCII
print(ord('b'))  #字符串对应的ASCII
print(hex(111))  #数字转成16进制
print(oct(111))  #数字转成8进制

print(max(111, 12))  #取最大值
print(sum([111, 12]))  #求和
print(divmod(10, 3))  #取余数，打印(商,余数)
print(round(11.11111, 2))  #取几位小数

f = open('a.txt', 'w')
print(dir('f'))  #dir()打印传入对象的可调用方法

def func():
    name = 'abc'
    age = 18
    print(locals())  #locals()返回函数里局部变量放到字典l里
func()
# 返回结果：{'name': 'abc', 'age': 18}

name = '124'
print(globals())  #返回程序内所有变量，返回的是一个字典

# zip：把2个list合成一个二维数组
l = ['u1', 'u2', 'u4']
l2 = ['p1', 'p2', 'p3', 'p4']
print(list(zip(l, l2)))
# 返回结果：[('u1', 'p1'), ('u2', 'p2'), ('u4', 'p3')]

# sorted：排序(不影响原来的值)
l = [1, 4, 2, 6, 45, 56, 32]
print(sorted(l))  #升序
print(sorted(l, reverse=True))  #降序

# sorted二维数组排序
l3 = [['小黑', 45], ['小贝', 20], ['小白', 35]]
# 方法一：
l4 = sorted(l3, reverse=True, key=lambda x: x[-1])  #key的作用：传函数名
print(l4)
# 方法二：
def use_key(x): 
    return x[1]
l5 = sorted(l3, reverse=True,key=use_key)  #根据某个值排序
print(l5)

# 三维数组排序
l7 = [['小黑', 45, ['xx', 13]], ['小贝', 20, ['xx', 11]], ['小白', 35, ['xx', 33]]]
l7 = sorted(l7, reverse=True, key=lambda x: x[-1][-1])
print(l7)

# sorted字典排序
d = {'a': 3, 'c': 1, 'b': 2}
l5 = sorted(d.items(), reverse=True, key=lambda x:x[0])  #按key排序
l6 = sorted(d.items(), reverse=True, key=lambda x:x[-1])  #按value排序
print(l5)
print(l6)

# filter：循环对象，过滤参数
# 方法一：
def filter_test(x):
    return x > 5
result = filter(filter_test, [12, 3, 2, 1, 35])  #循环list里的值传给函数
print(list(result))  
# 返回结果：[12, 35]
# 方法二：
result2 = filter(lambda x: x > 5, [12, 3, 2, 35])  #循环把list里的值传给函数
print(list(result2))  
# 返回结果：[12, 35]

# map：循环对象，保存函数的返回值
result4 = map(lambda x: str(x).strip().zfill(3), [2, 3, 4])  
print(list(result4))
# 返回结果：['002', '003', '004']

# enumerate：循环对象，自动计算下标，生成二维数组
l = ['注册', '登录', '购物', '积分查询']
for index, i in enumerate(l, 1):  #不传值是默认下标从0开始
    print('%s->%s' % (index, i))
print('请输入你的选择：')
# 返回结果：
# 1->注册
# 2->登录
# 3->购物
# 4->积分查询

# exec：执行python代码
str_code = '''
l = [12, 3, 2, 35]
print([str(i).strip().zfill(3) for i in l ])
'''
exec(str_code)
# 返回结果：['012', '003', '002', '035']

# eval：执行python代码，只能执行简单的，定义数据类型和运算
result = eval('{"code":1,"name":"小黑"}')
print(result)  #返回结果：{'code': 1, 'name': '小黑'}

9. 匿名函数

# 匿名函数：是一个简单的函数，没有名字，只能实现一些简单的功能

# lambda x,y:x+y

# lambdad定义匿名函数(冒号前面是入参，冒号后面是返回值)