#写函数，计算传入字符串中【数字】、【字母】、【空格】以及【其他】的个数。
#   定义函数，输入字符串
def checkFunction(myStr):

#   新建字典，准备存放各类型数据及其个数
    typeNum = {}
    typeList = ['数字','字母','空格','其他']
    typeNum = typeNum.fromkeys(typeList,0)

#   将字符串中的制表符转换成空格，方便统计
    myStr.expandtabs()

#   遍历字符串，查找各类型数据的个数，并存入字典
    for i in myStr:
        if i.isdecimal():
            typeNum['数字'] += 1
        elif i.isalpha():
            typeNum['字母'] += 1
        elif i is ' ':
            typeNum['空格'] += 1
        else:
            typeNum['其他'] += 1

#   返回字典
    return  typeNum

# 函数调用，测试功能
# myStr = '435hfgh35454   @$#%    \nd'
myStr = input('请输入字符串：\n>>>')
print('字符串：{}'.format(myStr))
print('字符串中各类型数据的个数：')
ret = checkFunction(myStr)
for i,j in ret.items():
    print('{}:{}'.format(i,j))
View Code
#写函数，判断用户传入的对象（字符串、列表、元组）的长度是否大于5.
# 定义函数，输入动态参数
def lenCheck(*args):
#   判读输入的长度是否大于5
    if len(args) > 5:
        ret = True
    else:
        ret = False
#   返回结果
    return ret

# 调用函数，测试结果
# myStr = 'h tyi '
myStr = ('fef',343,343,34,'fdef')
# myStr = ['fef',343,343,34,'fdef',3]
ret = lenCheck(*myStr)
print(ret)
View Code
#写函数，检查用户传入的对象（字符串、列表、元组）的每一个元素是否含有空内容。
# 定义函数，输入动态参数
def noneCheck(*args):
    if args:
#   判读输入中是否含有空内容
        for i in args:      #for 循环不能遍历空内容，会报错
           if i:
               ret = False
           else:
               ret = True
               break
    else:
        ret = True
#   返回结果
    return ret

# 调用函数，测试结果
# myStr = ('fef',343,343,34,'fdef','')
myStr = ['fef',343,343,34,'fdef',3]
# myStr = ' '
ret = noneCheck(*myStr)
print(ret)
View Code
#写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# 定义函数，输入列表
def len2(*args):
#   检查列表长度
    argsLen = len(args)
#       如果长度大与2，保留前两个长度的内容，其余删除
    if argsLen > 2:
        args = args[0:2]
#       如果长度小于或等于2，保持不变
#   返回新列表
    return args
# 调用函数，测试结果
myList = ['dfd',34,34,'fe']
ret = len2(*myList)
print(ret,type(ret))
View Code
#写函数，检查获取列表或元组的对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
#定义函数，输入动态参数*args
def oddValues(*args):
#   创建新列表，赋值奇数位索引对应的元素
    ret = []
    i = 1
    while i < len(args):
        ret.append(args[i])
        i += 2
#   返回新列表
    return ret
#调用函数，测试结果
myTuple = ('fefe',34,'fef',343,'fedfe',54)
print(myTuple,type(myTuple))
ret = oddValues(*myTuple)
print(ret,type(ret))
View Code
#写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#定义函数，输入字典
def valueLen2(**kwargs):
    nKwargs = {}
#   遍历字典，检查每一个value的长度
    for i,j in kwargs.items():
#       数字保持不变
        if type(j) is int:
            nKwargs[i] = j
#       字典,函数嵌套
        elif type(j) is dict:
            nKwargs[i] = valueLen2(**j)
#       字符串，数字不变，字符取前两位
        elif type(j) is str:
            if not j.isdigit() and len(j)>2:
                nKwargs[i] = j[0:2]
            else:
                nKwargs[i] = j[:]
#       其它类型，
        else:
            if len(j) > 2:
                nKwargs[i] = j[0:2]
            else:
                nKwargs[i] = j[:]
#   返回结果
    return nKwargs


#调用函数，测试结果
#   测试用字典
myDic = {'k1':'1234','k2':'abcd','k3':['1','2','3'],'k4':('a','b',3,4),'k5':1234,'k6':{'t1':1234,'t2':'abcd','t3':[1,'a','b']}}
print('原字典为：')
for i,j in myDic.items():
    print('{}:{}'.format(i,j))
#   调用函数
ret = valueLen2(**myDic)
print('新字典为：')
for i,j in ret.items():
    print('{}:{}'.format(i,j))
View Code
#写函数，利用递归获取斐波那契数列中的第10个数，并将该值返回给调用者。
'''斐波那契数列（Fibonacci sequence），又称黄金分割数列、
因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，
指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
在数学上，斐波纳契数列以如下被以递归的方法定义：F(0)=0，F(1)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）'''

# 定义斐波那契数列，输入数值表示要取第几个数
def rabitNum(num):
    rabitList=[0,1]
    temp = 2
    while temp <= num:
        rabitList.append(rabitList[temp-1]+rabitList[temp-2])
        temp += 1
    return rabitList[num]
#调用函数，测试结果
for i in range(1,11):
    print(rabitNum(i))
print('第10个数为：',rabitNum(10))
View Code