python 初始函数

Posted 2020-12-31 -1206-

一、什么是函数

　　函数是组织好的，可重复使用的，用来实现单一或相关功能的代码段

　　函数能提高应用的模块儿性和代码的重复利用率。python提供了很多内置函数，比如print(),len()等等。我们也可以自己创建函数，这种函数叫做用户自定义函数。

二、函数的定义和调用

　　让我们来定义一个能计算字符串长度的，类似于len()的函数

# s = "我的团长我的团"   # 1
# def my_len(): # 定义/声明一个函数 函数名的定义和变量名的规则一样 #3

#     i = 0  #4
#     for k in s: #5
#         i += 1
#     print(i)
# my_len() # 调用函数  # 2
# my_len()
# my_len()
# my_len()
# length = my_len()
# print(length)   # print: None  只是执行函数，并没有把结果返回给my_len

定义：def关键字开头，空格之后+函数名称和（），最后加" :" 冒号。

　　    def是固定的写法，他就是定义函数的关键字不能换其他关键字或者字符串

           空格是为了将关键字def 和函数名分开，必须空，但是一般人只空一格。

函数名：函数名的命名规则和变量名的一样，由数字，字母下划线组成且不能以数字开头。函数名的定义并没有严格规定，但默认还是要尽量简短，并能表达函数功能。

括号：括号是必不可少的部分里面可以存放参数

注释：每一个函数都应该对其功能和参数进行相应的说明，应该写在函数下面的第一行，以增强代码的可读性。

调用： 很简单就是 函数名（） 务必加上括号

三、函数的返回值

return关键字的作用

　　return是一个关键字，在pycharm里，会自动变色。

　　很显然return是“返回”的意思，我们管写在return后面的值叫做“返回值”。

返回值有如下三种情况：

　　1.没有返回值    默认返回None

#  不写 return
#  只写return  结束一个函数的继续
#  return None  和不写return是一样的 都返回 None  最不常用
# def func=():
#     l1 = [‘狗哥‘, ‘狗智‘]
#     for i in l1:
#         print(i)
#         if i == ‘狗哥‘:
#             return  # 找到狗哥之后后面的就不循环了
# r1 = func()
# print(r1)

　　2.返回一个值 可以是数字、列表、字典等

# 1.可以返回任何数据类型 2. 只要返回了就可以接收到
# 3.如果一个程序中有多个return的话只执行第一个
# def func():
#     return [1, 2, 3]
# print(func())

　　3.返回多个值

# def func2():
#     return 1, 2, 3  # 相当于返回了一个元组 return（1,2,3） python特性
# r1, r2, r3 = func2()
# print(r1, r2, r3)  #  1 2 3

# r1, r2 = func2()
# print(r1, r2) # 会报错 两个变量不能接收三个返回值 不能平均分配

# r1 = func2()
# print(r1)   #可以用一个变量接收，返回一个元组 --> (1, 2, 3) 不可变类型
# 多个返回值用多个变量接收，有多少返回值就用多少变量接收

四、函数的参数

形参与实参：

我们调用函数的时候就是传参的过程，括号里的内容就是实际参数，是实际要交给函数的内容，简称实参。

当以函数的时候就是接受函数的过程，括号里的内容就是形式参数，在定义函数的时候他只是一个形式，表示这里有一个参数，简称形参。

# s = "我的团长我的团"
# l1 = [1, ‘barry‘, ‘大铁锤‘]
# def my_len(s):  # 接收参数 形式参数 形参
#     i = 0
#     for k in s:
#         i += 1
#     return i
# r1 = my_len(s) # 传参  传递参数  实际参数 实参
# r2 = my_len([1,2,3])
# print(r1, r2)  # -->7 3

　站在实参的角度上　

       1.按照位置传参
　　2.按照关键字传参
　　3.可以混着用，但是必须先按照位置传参再按照关键字传参
         不能给同一个变量传多个值

# def my_sum(a, b):
#     print(a, b)
#     res = a + b # result
#     return res
# ret = my_sum(1, 2)  # 按照位置传 1-->a  2-->b
# ret = my_sum(b=2, a=1) # 按照关键字传参
# ret = my_sum(1, b=2) # 位置传参关键字传参混着用
# print(ret)

站在形参的角度上;

　　位置参数：必须传，且有几个参数就传几个值
　　默认参数：可以不传，如果不传就用默认参数，如果传了就用传的

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘ %(name,sex))
classmate(‘二爷‘)
classmate(‘小五‘)
classmate(‘骚鑫‘)
classmate(‘马哥‘, ‘女‘)
classmate(‘coco‘, ‘女‘)

调用 函数时候：

　　按照位置传：直接写参数的值
　　按照关键字传: 关键字 = 值

定义参数的时候：

　　位置参数：直接定义参数
　　默认参数：默认参数：参数名=默认的值
　　动态参数 可以接收任意多个参数
　　参数名之前加* 习惯用args /参数的意思
　　参数名之前加** 习惯用kwargs
　　顺序：先定义位置参数，*args，默认参数,**kwargs

# 定义的时候使用按位置传参，传参的时候既可以用位置传参，又可以用关键字传参
def classmate(name, sex):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘, ‘男‘)
classmate(sex=‘男‘, name=‘鸡哥‘)

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘)
classmate(‘鸡哥‘, sex=‘女‘)
# 定义参数类型和传递参数类型之间没有必然联系

动态参数　　　　

动态参数 可以接收任意多个参数  参数名之前加* 习惯用args /参数的意思

# def sum(*args): #args仅仅是参数名
#     n = 0
#     for i in args:
#         n += i
#     return n
# print(sum(1, 2))
# print(sum(1, 2, 3))
# print(sum(1, 2, 3, 4))

# 接收动态参数
# def func(*args): #只能接收到按位置传递的参数，不能接收关键字传参
#     print(args)
# func(1, 2, [‘jack‘, 5,], {‘name‘:‘barry‘}) #-->(1, 2, [‘jack‘, 5], {‘name‘: ‘barry‘})

# def func(*args, l1=[]):
#     print(args, l1)
# func(1, 2, [‘rose‘, ‘marry‘])
# func(3, 4,‘coco‘, l1=[‘jack ma ‘, ‘lucy‘])

# 按照关键字传多个参数
# def func(**kwargs):
#     print(kwargs)
# func(a=1, b=2, c=3)
# func(a=1, b=2)
# func(a=1)
# func(a=1, b=2, c=3)
# 动态参数有两种：可接收任意多个参数
    #*args : 接受的是按位置传参的值，组成一个元组
    #**kwargs : 接收的是按照关键字传参的值，组成一个字典
    #args必须在kwargs之前
# 双剑合璧 天下无敌

# def func(*args, **kwargs):
#     print(args, kwargs)
#  func(1, 2, a=3, b=‘sb‘) #-->(1, 2) {‘a‘: 3, ‘b‘: ‘sb‘}
                            # 只要在传参的时候符合先按位置再按关键字就OK

# def func(a, b,*args, default=1, **kwargs): #这几种参数少了谁都可以，但顺序必须牢记
#    print(a, b, args, default, kwargs)
# func(1, 2, default=2, a=3, b=‘sb‘)

# 动态参数的另一种传输方式
# def func(*args): #站在形参的角度，给变量加上* 就是组合所有传来的值
#     print(args)
# func(1,2, 3, 4)
# l1 = [1, 2, 3, 4]
# func(*l1) #站在实参的角度上，给序列加上* ，就是将序列按顺序打散

# def func(**kwargs):
# #     print(kwargs)
# # func(a=1, b=2)
# # dic1 = {‘a‘: 1, ‘b‘: 2}
# # func(**dic1)

五、函数的注释

def func():
    ‘‘‘
    这个函数实现了什么功能
    参数1：
    参数2：
    。
    。
    。
    :return:  是字符串或列表的长度
    ‘‘‘
    pass

　　作业：

# 1. 写函数，检查获取传入列表或元组对应的所有奇数位索引对应的元素，并将其作为新列表返回给调用者
# def func(l1):
#     return l1[1::2] # 切片
# print(func([1, 2, 3, 4, 5, 6]))
# 2.写函数，判断用户输入的值（字符串，列表，元组）长度是否大于5
# def func(x):
#     return len(x) > 5
#
# print(func(‘everything i never told you!‘)) #返回的是布尔值
#
# if func(‘sad‘):
#     print(‘确实大于五‘)
# else:
#     print(‘小于五‘)
# 3.写函数，检查传入列表的长度，如果>2,那么仅保留前两个长度的内容，并将新内容返回给调用者
# def func(l1):
#     if len(l1) > 2: # 这一步完全可以省略
#         return l1[:2]
# print(func([1, 2, 3, 4])) #-->[1, 2]

# 4. 写函数 计算传入字符串中，数字，字母，空格，以及其他 的个数，并返回结果
# def func(s):
#     dic = {‘num‘: 0, ‘alpha‘: 0, ‘space‘: 0, ‘other‘: 0 }
#     for i in s:
#         if i.isdigit():
#             dic[‘num‘] += 1
#         elif i.isalpha():
#             dic[‘alpha‘] += 1
#         elif i.isspace():
#             dic[‘space‘] += 1
#         else:
#             dic[‘other‘] += 1
#     return dic
# print(func(s = ‘+*[email protected] s c d‘))

# 5. 写函数，检查用户输入的对象（字符串，列表，元组）的每一个元素是否含有空内容，并返回结果


# def func(x):
#     if type(x) is str and x:
#         for i in x:
#             if i == ‘ ‘:
#                 return True
#     elif x and type(x) is list or type(x) is tuple:
#         for i in x:
#             if not i:
#                 return True
#     elif not x:
#         return True
# print(func(‘dasd asd‘))
# print(func([1, 2, []]))
# print(func([]))
# print(func((1, 2, ())))

# 6.写函数，检查传入字典的每一个value的长度，如果>2，那么仅保留两个长度的内容，并将新内容返回给调用者
# dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: 1246, ‘k3‘: [1, 2, 3]}
# ps 字典中的value只能是字符串或列表
# def func(dic):
# #     for k in dic:
# #         if len(dic[k]) > 2:
# #             dic[k] = dic[k][:2]
# #     return dic
# # dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: ‘1333324‘, ‘k3‘: [1, 2, 3]}
# # print(func(dic))

# 7. 写函数，接收两个数字参数，返回比较大的那个数字
# def func(a, b):
#     if a > b:
#         max = a
#     else:
#         max = b
#     return max
#
# print(func(2, 1))
# 三元运算
# 变量 = 条件返回true的结果 if 条件 else 条件返回false的结果
# 必须要有结果  必须要有 if 和 else   只能是简单的情况
# def func(a, b):
#     max = a if a > b else b
#     return max  # 可以直接 return a if a > b
# print(func(10, 5))

# 8. 写函数，用户传入修改的文件名儿，与要修改的内容
# 执行函数完成整个文件的批量修改操作
# def func(filename, old, new):
#     with open(filename, encoding=‘utf-8‘) as f1, #             open(‘%s.bak‘ % filename, ‘w‘, encoding=‘utf-8‘) as f2:
#         for line in f1:
#             if old in line:
#                 line = line.replace(old, new)
#             f2.write(line)
#     import os
#     os.remove(filename)
#     os.rename(‘%s.bak‘ % filename, filename)
#     return ‘修改完毕‘
#
# print(func(‘H:python大学生兼职.txt‘, ‘快递小哥‘, ‘家政主妇‘))

# def func(l1=[]):
#     l1.append(1)
#     print(l1)
# func() # [1]
# func([]) #[1]
# func([‘a‘]) #[‘a‘,1]
# func() #[1,1]
# func() #[1,1,1]
# 如果默认参数是一个可变数据类型，
# 那么每次调用函数的时候，
# 如果不传值就公用这个数据类型的资源

# def func(k, dic={}):
#     dic[k] = ‘v‘
#     print(dic)
# func(1) # {1 :‘v‘}
# func(2) #{1 :‘v‘,2 :‘v‘}
# func(3) #{1 :‘v‘,2 :‘v‘,3 :‘v‘}
# func(4) #{1 :‘v‘,2 :‘v‘,3 :‘v‘,4: ‘v‘}