1.定义函数 moreThan(num)，判断输入的数字是否大于1500，打印输出"大于1500"或"不大于1500"

def moreThan(num):
   '''
   判断输入的数字是否大于1500，
   :param num:一个数字 ；
   :return: 和1500的关系；
   '''
   if num > 1500:
      print("大于1500")
   elif num <= 1500:
      print("不大于1500")

# 测试
n = int(input("请输入一个整数："))
moreThan(n)

2.定义函数：max(x, y)，返回两个整数的输入的最大值

def max(x, y):
   '''
   返回两个整数的输入的最大值
   :param x:一个整数
   :param y: 一个整数
   :return: 最大的整数
   '''
   if x >= y:
      return x
   elif x < y:
      return y

# 测试数据
result = max(100, 200)
print(result)

3.定义函数，max(x,y,z)，返回求三个整数的最大值

ef max(x, y, z):
   '''
   求三个整数的最大值
   :param x: 一个整数
   :param y: 一个整数
   :param z: 一个整数
   :return: 最大的整数
   '''
   t = 0
   if x > y:
      t = x
   else:
      t = y
   if t > z:
      result = f'{x}, {y}, {z}三个整数中最大的为{t}'
      return result
   else:
      result = f'{x}, {y}, {z}三个整数中最大的为{z}'
      return result

#测试
result = max(800, 900, 1000)
print(result)

4.定义函数 generateNum( ) 返回从0~9的十个数字中随机取出4个不重复的数字组成一个字符串

例如：0123，3657，4578

import random as rd

def generateNum():
   '''
   生成一个4个不重复的数字组成一个字符串
   :return: 字符串
   '''
   setNum = []
   numStr = ''
   while len(setNum) < 4:
      digital = rd.randint(0, 9)
      if digital not in setNum:
         setNum.append(digital)
   for num in setNum:
      numStr =numStr + str(num)
   return numStr

#自我扩展：得到指定数量的字符串
def getNum(n):
   '''
   得到指定数量的包含4个不重复的数字的字符串
   :param n: 字符串数量
   :return: 指定数量的字符串
   '''
   ls = []
   result = ''
   for i in range(n):
      randNum = generateNum()
      ls.append(randNum)
   for l in ls :
      result = result + f'{l},'
   result = result.strip(',')
   return result

#测试
num = getNum(8)
print(num)

5.定义函数：taxRate(income) ，根据收入的不同，显示输出不同的税率和税金。

个人所得税采用速算扣除数法计算超额累进税率的所得税时的计税公式是：

应纳税额=应纳税所得额×适用税率-速算扣除数

个人所得税税率速算扣除数
个税所得额<=500000
超过5000，个税区间在0-30003%0
超过5000，个税区间在3000-1200010%210
超过5000，个税区间在12000-2500020%1410
超过5000，个税区间在25000-3500025%2660
超过5000，个税区间在35000-5500030%4410
超过5000，个税区间在55000-8000035%7160
超过5000，个税区间在80000以上45%15160
def taxRate(income):
	'''
	根据收入的不同，显示输出不同的税率和税金
	:param income: 个人收入
	:return: 
	'''
	tax = income - 5000
	incometax = 0
	if tax <= 0:
		incometax = 0
		print(f'税率为 0% ，税金为 {incometax} ')
	elif 0 < tax <= 3000:
		incometax = tax * (3 / 100) - 0
		print(f'税率为 3% ，税金为 {incometax} ')
	elif 3000 < tax <= 12000:
		incometax = tax * (10 / 100) - rate.get('10%')
		print(f'税率为 10% ，税金为 {incometax} ')
	elif 12000 < tax <= 25000:
		incometax = tax * (20 / 100) - rate.get('20%')
		print(f'税率为 20% ，税金为 {incometax} ')
	elif 25000 < tax <= 35000:
		incometax = tax * (25 / 100) - rate.get('25%')
		print(f'税率为 25% ，税金为 {incometax} ')
	elif 35000 < tax <= 55000:
		incometax = tax * (30 / 100) - rate.get('30%')
		print(f'税率为 30% ，税金为 {incometax} ')
	elif 55000 < tax <= 80000:
		incometax = tax * (35 / 100) - rate.get('35%')
		print(f'税率为 35% ，税金为 {incometax} ')
	elif tax > 80000:
		incometax = tax * (45 / 100) - rate.get('45%')
		print(f'税率为 45% ，税金为 {incometax} ')

rate = {'0%': 0, '3%': 0, '10%': 210, '20%': 1410, '25%': 2660, '30%': 4410, '35%': 7160, '45%': 15160}
# 测试函数
taxRate(9000)

6.定义函数 getLength，打印用户传入的容器类型数据长度

def getLength(container):
    '''
    打印用户传入的容器类型数据长度
    :param container: 容器名称
    '''
    if isinstance(container,(str,tuple,dict,list,set)):
        print(f'容器的类型为{type(container)}, 容器的数据长度为{len(container)}')
    else:
        print("请输入容器类型数据")
    return


# 测试函数
s1 = [1, 3, 5]	#列表
s2 ='hubmu'	#字符串
s3 = (1, 3, 5)	#元组
s4 = {'刘':10, '何':11}		#字典
s5 = {1, 3, 5, 7}	#集合

getLength(s1)
getLength(s2)
getLength(s3)
getLength(s4)
getLength(s5)

7.定义函数 getType，参数为容器类型数据,打印所有奇数位索引对应的元素

def getType(lst):
    '''
    打印所有奇数位索引对应的元素
    :param lst: 容器类型数据
    :return:
    '''
    if isinstance(lst, dict):
        print("字典容器类型没有索引")
    elif isinstance(lst, set):
        print("集合容器类型没有索引")
    elif isinstance(lst, (str, list, tuple)):
        for i in range(len(lst)):
            if i % 2 == 1:
                print(lst[i], end='\t')
        print()
    else:
        print("请输入容器类型数据")


# 测试函数
s1 = [1, 3, 5]  # 列表
s2 = 'hubmu'  # 字符串
s3 = (1, 3, 5)  # 元组
s4 = {'刘': 10, '何': 11}  # 字典
s5 = {1, 3, 5, 7}  # 集合

getType(s1)
getType(s2)
getType(s3)
getType(s4)
getType(s5)

8.定义函数 connect ,接收一个参数(可迭代性数据),用 _ 让元素相连成字符串,打印出来

from collections.abc import Iterable
def connect(data):
    '''
    用_让元素相连成字符串
    :param data: 可迭代性数据参数
    :return:
    '''
    if isinstance(data, Iterable):
        if isinstance(data,dict):
            for value in data.values():
                print(str(value), end="_")
            print()
        elif isinstance(data,(str,list,tuple,set)):
            for i in data:
                print(str(i), end='_')
            print()
    else:
        print("请输入可迭代数据类型")



# # 测试函数
s1 = [1, 3, 5]  # 列表
s2 = 'hubmu'  # 字符串
s3 = (1, 3, 5)  # 元组
s4 = {'刘': 10, '何': 11}  # 字典
s5 = {1, 3, 5, 7}  # 集合

connect(s1)
connect(s2)
connect(s3)
connect(s4)
connect(s5)

9.定义函数 getMin，接收任意参数,打印最小值

提示：可能为不同的数据类型

def getMin(*args):
   '''
   打印最小值
   :param args: 任意参数
   :return: 
   '''
   i = min(args)
   print(f'最小值为{i}')

#测试
ls = [110, 25, 6655, 56, 622,462]
getMin(*ls)

10.定义函数 getPoker( )，返回一个扑克牌列表，里面有52项，每一项是一个元组

例如：[(‘红心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]

def getPoker():
	'''
	返回一个扑克牌列表
	:return:列表 
	'''
	style = ['黑桃', '红桃', '梅花', '方片']
	number = [i for i in range(2, 11)]
	king = ['J', 'Q', 'K', 'A']
	number.extend(king)
	ls = []
	for key in style:
		for value in number:
			ls.append((key,value))
	return ls

# 测试
ls = getPoker()
print(ls)
print(len(ls))

11.定义函数 count( ) ,统计一个字符串中大写字母、小写字母、数字的个数，并以字典为结果返回给调用者

def count(string):
	'''
	统计一个字符串中大写字母、小写字母、数字的个数
	:param string: 传入的字符串
	:return: 字典
	'''
	ls = list(string)
	dic = {}
	for l in ls:
		if l.isupper():
			dic['大写字母个数'] = dic.get('大写字母个数', 0) + 1
		elif l.islower():
			dic['小写字母个数'] = dic.get('小写字母个数', 0) + 1
		elif l.isdecimal():
			dic['数字个数'] = dic.get('数字个数', 0) + 1
	return dic

# 测试
string = 'WOHENSHUAIshizhende66666'
print(count(string))

【递归练习】

1.求阶乘，传入一个参数n，返回n的阶乘

例如:cal(7) 计算 7*6*5*4*3*2*1

def cal(n):
   '''
   传入一个参数n，返回n的阶乘
   :param n: 参数
   :return: n的阶乘
   '''
   if n == 1:
      return 1
   elif n > 1:
      return n*cal(n-1)

#测试
print(cal(7))

2.有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

def rabbit(m):
   '''
   每个月的兔子总数
   :param m:第m个月
   :return:兔子总数
   '''
   if m < 1:
      return 0
   if m == 1 or m == 2:
      return 2
   else :
      return rabbit(m - 1) + rabbit(m - 2)
#测试
m = 10
print(f'第{m}个月有{rabbit(m)}只兔子')

3.猴子吃桃：猴子第一天摘下若干个桃子，当即吃了一半，不过瘾就多吃了一个。第二天又将剩下的桃子吃了一半，不过瘾多吃了一个。以后每天都吃前一天剩下的一般再加一个。到第10天刚好剩下一个。问猴子第一天摘了多少个桃子？

def getPeaches(day):
   '''
   计算猴子第一天摘的桃子数
   :param day: 天数
   :return:
   '''
   if day == 1:
      return 1
   else:
      return (getPeaches(day - 1) + 1) * 2

#测试
print(getPeaches(10))
# python
Logo
华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

cover

解锁HDC 2024之旅：从购票到报名，全程攻略

avatar 华为云开发者联盟
cover

从原始边列表到邻接矩阵Python实现图数据处理的完整指南

avatar 华为云开发者联盟
cover

华为云云原生FinOps解决方案，释放云原生最大价值

avatar 华为云开发者联盟