第二十五节，自定义函数作业

1,简述普通参数、指定参数、默认参数、动态参数的区别

函数

         a.def(声明自定义函数开始)

         b.函数名（）如：f1()

         c.返回值return(关键字)

                   函数内部一旦遇到return,以下代码不在执行

         d.参数

                   1.形式参数（定义函数时的参数），实际参数（调用函数时的参数）

                   2.普通参数：数量一致，一一对应

print("普通参数：数量一致，一一对应")
def f1(a,b):
    c = a + b
    print(c)
f1(5,5)

 

                   3.指定参数

                            调用函数时指定参数如：f1(p="xxx")

print("指定参数:调用函数时指定参数")
def g1(a,b):
    c = a + b
    print(c)
g1(b = 4, a = 3)

 

                   4.默认参数

                            在定义函数时形式参数指定默认实参，默认参数要写在尾部

print("默认参数:在定义函数时形式参数指定默认实参")
def h1(a=5, b=3):
    c = a + b
    print(c)
h1()

 

                   5.动态参数

                            *args (接收实际参数组合成元组)

print("动态参数:*args (接收实际参数组合成元组)")
def i1(*args):
    print(args)
i1(123, 456, 789)

 

                            **kwargs (接收实际参数组合成字典)

print("动态参数:**kwargs (接收实际参数组合成字典)")
def j1(**kwargs):
    print(kwargs)
j1(k1=123,k2=456,k3=789)

 

2,写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
def pduan(s):
    shuzi = 0       #统计数字
    zimu = 0        #统计字母
    kongge = 0      #统计空格
    qita = 0        #统计其他
    for i in s:     #循环字符串
        if i.isdigit():     #判断循环到的字符是否是数字
            shuzi += 1      #如果是数字，统计加1
        elif i.isalpha():   #判断循环到的字符是否是字母
            zimu  += 1      #如果是字母，统计加1
        elif i.isspace():   #判断循环到的字符是否是空格
            kongge += 1     #如果是空格，统计加1
        else:               #判断循环到的字符都不是以上类型，则为其他
            qita += 1       #如果是其他，其他统计加1
    return {"shuzi":shuzi, "zimu":zimu, "kongge":kongge, "qita":qita}    #返回由各种统计组合的字典

jieg = pduan("1567df jweiwo r22r")  #调用函数传入字符串
print(jieg) #打印函数
print("\n")

#用字典索引的方式，分别获取到各项统计到的数量
print("数字:", jieg["shuzi"], "字母:", jieg["zimu"], "空格:", jieg["kongge"], "其他:", jieg["qita"])

 

3,写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5"""
print("写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5")
def pduan(s):   #定义函数
    if isinstance(s,str) or isinstance(s,list) or isinstance(s,tuple):  #判断接收到的是否是（字符串、列表、元组）类型
        if len(s) > 5:  #判断接收到的元素是否大于5
            print("大于五")    #大于5
        else:
            print("小于五")    #小于5
    else:    #如果接收到的不是（字符串、列表、元组）类型
        print("您输入的类型，不在范围内")   #不是（字符串、列表、元组）类型 打印提示

#shuju = "自贡玉1111111"
#shuju = [123,456,789]
shuju = (123,456,789,101112,131415,16171819)

pduan(shuju)    #调用函数

 

4，写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。"""
print("写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。")

def hanshu(s):  #定义函数
    tj = False  #空格统计默认False没有
    for i in s: #循环接收的字符串
        if i.isspace(): #判断循环到的字符是否是空格
            tj = True   #如果是空格将空格统计改为True有空格
    return tj   #返回空格统计

shuj = "112344233"

hsh = hanshu(shuj)  #调用函数
print(hsh)

 

5、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者"""
print("写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者")

def f2(s):  #定义函数
    if len(s) > 2:  #判断列表的长度是否大于2
        return s[0:2]   #如果大于2切片保留2位长度
    else:
        return s    #如果不大于2直接返回列表

fs = [123,456,789,987,654,321]

f3 = f2(fs) #调用函数
print(f3)

 

6、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者"""
print("写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者")

def f4(s):      #自定义函数
    tj = []     #统计奇数索引的元素
    for i in range(len(s)):     #循环列表的索引
        if i % 2 == 1:      #判断循环到的索引除以2是否等于1
            tj.append(s[i]) #如果除以2等于1，将此下标的元素追加到，统计奇数索引的元素
        else:
            pass    #如果除以2不等于1，什么都不做
    return tj   #返回统计奇数索引的元素

fsa = [123,456,789,987,654,432]

f5 = f4(fsa)    #调用函数
print(f5)

 

7、写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者"""
print("写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者")

def f5(s):      #定义函数
    tj = {}     #新建保留两位长度的字典
    for key,value in s.items():     #循环出字典的键和值
        if len(value) > 2:      #判断循环到的字典值是否大于两位
            tj[key] = value[0:2]    #如果大于两位将字典值切片成两位后，更新到新建保留两位长度的字典
        else:
            tj[key] = value     #如果不大于两位，就直接更新到新建保留两位长度的字典
    return tj   #返回新建保留两位长度的字典

dic = {"k1": "v1v1", "k2": [11,22,33,44], "k3": "12"}

f6 = f5(dic)    #调用函数
print(f6)

列2 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者"""
print("写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者")
dic = {"k1": "v1v1", "k2": [11,22,33,44], "k3": "12"}
def f6(s):  #定义函数
    for key,value in s.items():     #循环出字典的键和值
        if len(value) > 2:  #判断循环到的字典值是否大于两位
            s[key] = value[0:2]     #如果大于两位将字典值切片成两位
        else:
            s[key] = value      #如果不大于两位，就直接返回

f6(dic)
print(dic)