函数的练习题答案--python

1.定义一个函数，传递文件路径，获取文件的后缀名

def get_houzhui(s):
    print("后缀名是:",s[s.rfind(".")+1:])
s = input("请输入需要获取文件后缀的路径:")
get_houzhui(s)

2：输入一个数字（年份，如2000年），定义函数，判断该年份是否是闰年

def get_isrun(num):
    if(num%4==0 and num%100!=0)or num%400 == 0:
        return True
    else:
        return False
        
s = int(input("请输入需要需要判断的年份:"))
if get_isrun(s):
    print("{}是闰年".format(s))
else:
    print("{}不是闰年".format(s))

3：将之前的打印*组成三角形的代码，改造成函数，要求如下（定义好多函数的）：
1、打印的层数有调用者决定
2、如果是菱形的话，判断用户必须输入才层数为奇数才行

def print_sanjiao(n):
    for i in range(1,n+1):
        for j in range(1,n-i+1):
            print(" ",end="")
        for k in range(1,2*i):
            print("*",end="")
        print()##换行
  

def print_linxing(n):
    for i in range(1,n//2 + 2):
        for j in range(1,n//2 + 2-i):
            print(" ",end = "")
        for k in range(1,2*i):
            print("*",end = "")
        print("")
    for m in range(1,n//2+1):
        for a in range(1,m+1):
            print(" ",end = "")
        for b in range(1,2*(n//2+1-m)):
            print("*",end="")
        print("")
        
        
choice = int(input("请输入需要打印的选择：1：三角形，2：菱形"))
if choice == 1:
    n = int(input("请输入需要打印的行数:"))
    print_sanjiao(n)
elif choice == 2:
    n = int(input("请输入需要打印的行数:"))
    if n%2 == 0:
        print("行数应为奇数")
    else:
        print_linxing(n)
else:
    print("错误选择！")

4：定义一个函数，判断该数是不是质数

def is_zhishu(n):
    flag = True
    for i in range(2,n//2):
        if n%i ==0:
            flag = False
            break
    return flag
                

n = int(input("请输入需要判断的数字："))
if is_zhishu(n):
    print("{}是质数".format(n))
else:
    print("{}不是质数".format(n))

5：做一个计算器函数，输入三个参数（两个数字，一个符号）。
如输入：5 6 + ，则输出： 5+6=11

def jisuanqi(a,b,op):
    if op == "+":
        return a+b
    elif op == "-":
        return a-b
    elif op == "*":
        return a*b
    elif op == "/":
        return a/b
        
    
num1 = float(input("请输入需要计算的第一个数字："))
num2 = float(input("请输入需要计算的第二个数字："))
op = input("请输入需要计算的符号：")
print(jisuanqi(num1,num2,op))

6：定义函数，打印九九乘法表

def print_table(n):
    for i in range(1,n+1):
        for j in range(1,i+1):
            print("{}X{}={}".format(i,j,i*j),end=" ")
        print(" ")    
    
n = int(input("打印的乘法表行数："))
print_table(n)

7：使用函数完成一个0~n之间的奇数的积。

def print_ji(n):
    sum = 1
    for i in range(1,n+1):
        if i%2 !=0:
            sum *= i 
    return sum
n = int(input("需要打印的乘积:"))
print(print_ji(n))

8：使用递归完成1~100之间的积

def print_chengji(n):
    if n == 1:
        return 1
    return n * print_chengji(n-1)


n = int(input("输入需要计算阶乘的值："))
print("{}的阶乘是{}".format(n,print_chengji(n)))

9：找出10000以内能被5或6整除，但不能被两者同时整除的数（函数）

def print_fuhe(n):
    for i in range(1,n+1):
        if (i%5 ==0 or i%6==0) and not (i%5 ==0 and i%6==0):
            print(i)


n = int(input("输入需要处理的范围从0开始："))
print_fuhe(n)

10：使用函数求三角形的面积和周长（已知三边的情况下，提示：海伦公式）
import math
math.sqrt(数据) # 表示开平方根
math.sqrt(4) #

import math

def sanjiao_zhouchang(a,b,c):
    return (a+b+c)*2


def sanjiao_mianji(a,b,c):
    p = (sanjiao_zhouchang(a,b,c))/2
    s = math.sqrt(p*(p-a)*(p-b)*(p-c))
    return s
    
a = float(input("输入三角形三边边长之a："))
b = float(input("输入三角形三边边长之b："))
c = float(input("输入三角形三边边长之c："))
print("三角形的周长：{}，面积是：{}".format(sanjiao_zhouchang(a,b,c),sanjiao_mianji(a,b,c)))

1、写一个方法，在方法内依次打印出列表每个元素
的值。

def print_list(ls):
    for i in ls:
        print(ls[i-1])

    
ls = [1,2,3,4,5]
print_list(ls)

2、写一个方法，计算列表所有元素的和(注意返回值
)。

def print_sum(ls):
    sum = 0
    for i in ls:
        sum += ls[i-1]
    return sum
    
ls = [1,2,3,4,5]
print("列表是：{}，元素和是：{}".format(ls,print_sum(ls)))

3、写一个方法，计算列表所有奇数下标元素的和(注
意返回值)。

def print_sum(ls):
    sum = 0
    i = 1
    while i < len(ls):
        sum += ls[i]
        i += 2
    return sum
    
ls = [1,2,3,4,5]
print("列表是：{}，奇数下标元素和是：{}".format(ls,print_sum(ls)))

4、写一个方法，计算列表所有偶数下标元素的和(注
意返回值)。

def print_sum(ls):
    sum = 0
    i = 0
    while i < len(ls):
        sum += ls[i]
        i += 2
    return sum
    
ls = [1,2,3,4,5]
print("列表是：{}，偶数下标元素和是：{}".format(ls,print_sum(ls)))

5、写一个方法可以计算两个数的和，想想这个方法
有哪些参数，返回值。

def add(a,b):
    return a+b
    
a = float(input("输入计算两个数的和第一位："))
b = float(input("输入计算两个数的和第二位："))
print("{}+{}={}".format(a,b,add(a,b)))

6、写一个方法可以计算两个数的商(分母不能为0)，
想想这个方法有哪些参数，返回值是什么。

def chu(a,b):
    return a/b
    
a = float(input("输入计算两个数中的被除数"))
b = float(input("输入计算两个数中的除数"))
if b != 0:
    print("{}/{}={}".format(a,b,chu(a,b)))
else:
    print("除数不能为0")

7、写一个方法将传入的天、小时、分钟、秒的总和
转换为秒，比如0天、2小时、5分、7秒，他们代表的
总秒数为23600+560+7=7507秒。想想这个方法
有哪些参数，返回值是什么类型。

def print_miao(day,hour,min,seconds):
    return day*86400+hour*3600+min*60+seconds
    
    
day = float(input("请依次输入天，"))
hour = float(input("请依次输入小时，"))
min = float(input("请依次输入分钟，"))
seconds = float(input("请依次输入秒:"))
print("转换为秒后：{}".format(print_miao(day,hour,min,seconds)))

8、写一个方法交换整型列表中两个指定下标元素的
值。想想这个方法有哪些参数，返回值是什么类型。

def swap(ls,a,b):
    ls[a] = ls[a]+ls[b]
    ls[b] = ls[a]-ls[b]
    ls[a] = ls[a]-ls[b]
    return ls
        
ls = [1,2,3,4,5]
a = int(input("需要交换的下标a："))
b = int(input("需要交换的下标b："))
print("交换前：{}".format(ls))
print("交换后：{}".format(swap(ls,a,b)))

9、写一个方法计算整型列表中所有能被3整除元素的
个数。想想这个方法有哪些参数，返回值是什么类
型。

def chu3(ls):
    count = 0
    for i in range(0,len(ls)):
        if ls[i]%3 == 0:
            count += 1
    return count

    
ls = [1,2,3,4,5,6,7,8,9,12]
print("列表：{}，能被三整除的元素个数：{}".format(ls,chu3(ls)))

10、写一个方法将整型数字(int)转换为格式化的字符
串(string)，现要求如下：
a.可以指定转换后[字符串的长度];
b.当数字的长度不足指定的长度，让这个字符串右对
齐，指定[左边补的字符(char)];
例如，假设现在将指定的数字转换为固定长度为8的
字符串，如果长度不足，左边补’0’，那么27这个数字
就会转换为字符串"00000027"。
根据要求，想想这个方法有哪些参数，返回值是什么
类型。

def exchang(num,lens):
    s = str(num)
    return s.rjust(lens,"0")

    
num = int(input("输入需要转换的数字："))
lens = int(input("输入需要转换后的长度："))
print("转换后：{}".format(exchang(num,lens)))

11.用方法实现找出一个int类型列表中最大值和最小
值

def exchang(ls):
    max = ls[0]
    min = ls[0]
    for i in range(0,len(ls)):
        if ls[i] > max:
            max = ls[i]
        elif ls[i] < min:
            min = ls[i]
    
    return max,min

    
ls = [1,2,3,4,5,4,3,2,1]
print("最大值和最小值是：{}".format(exchang(ls)))

12.判断一个数是否是质数(素数)？该如何声明方
法？

def iszhishu(num):
    flag = True
    for i in range(2,num//2):
        if num%i == 0:
            flag = False
            break
    return flag
    
num = int(input("请输入需要判断的数字:"))
if iszhishu(num):
    print("{}是质数".format(num))
else:
    print("{}不是质数".format(num))

13.将指定的秒数转变为几小时几分几秒。

def ex(num):
    a = num//3600
    b = (num - a*3600)//60
    c = (num - a*3600)%60
    return a,b,c
    
num = int(input("请输入需要转换的秒:"))
print("{}秒转换为{}时{}分{}秒".format(num,ex(num)[0],ex(num)[1],ex(num)[2]))

14.使用Random类给一个数组的所有元素赋随机初值
（不重复）。

import random
def fuzhi(num):
    len = 0 ##记录列表中元素的个数
    ls = []##空列表
    while len <= num :
        a = random.randint(0,num)
        if ls.count(a) == 0 : ##判断生成的这个随机数是否在列表中，不在则添加，在则跳过，通过count值来判断
            ls.append(a)
            len += 1
        else :
            continue
    print(ls)
    
    
num = int(input("请输入需要创建的列表长度："))
fuzhi(num)

15.判断一个整型数组是否是对称的。所谓对称就是
第一个元素等于最后一个元素，第二个元素等于倒数
第二个元素，依次类推，例如【7，3，1，3，7】就
是对称的。

def duichen(ls):
    i = 0
    j = len(ls)-1
    flag = True
    for k in range(0,len(ls)//2):
        if ls[i] != ls[j]:
            flag = False
            break
        i += 1
        j -= 1
    return flag
    
ls = [1,2,3,4,5,6,5,4,3,2,1,]
if duichen(ls):
    print("{}是对称的".format(ls))
else:
    print("{}是不对称的".format(ls))

16.打印一个元组的所有值。

def print_yuansu(t):
    ls = list(t)
    for i in range(0,len(ls)):
        print(ls[i],end=" ")
    
t = (1,2,3,4,5,4,3,2,1) 
print("元组是{},打印元素：".format(t),end = " ")
print_yuansu(t)

17.查找一个元组中某个值是否存在，如果存在返回
这个值的索引，否则返回-1。

def chazhao(t,num):
    ls = list(t)
    if ls.count(num) >= 1:
        return ls.index(num)
    else:
        return -1
    
t = (1,2,3,4,5,4,3,2,1) 
print(t)
num =int(input("输入需要判断的元素:"))
print("元组是{},查询元素是：{}，下标是{}".format(t,num,chazhao(t,num)),end = " "）

18.将一个列表反转过来，比如【2，3，1，4，7】转
换为【7，4，1，3，2】

def reverse(ls):
    ls.reverse()
    return ls

    
ls = [1,2,3,4,5] 

print("列表是{},翻转后是{}".format(ls,reverse(ls)),end = " ")

19.求一个列表的最大值。
20.求一个列表的最小值。

def max(ls):
    max = ls[0]
    for i in range(0,len(ls)):
        if ls[i] > max:
            max = ls[i]
    return max

def min(ls):
    min = ls[0]
    for i in range(0,len(ls)):
        if ls[i] < min:
            min = ls[i]  
    return min
            
ls = [1,2,3,4,5,6,32,1,2,3,2,1,32] 

print("列表是：{}，最大值是：{}，最小值是：{}".format(ls,max(ls),min(ls)))

21.写一个方法，实现在列表中指定的的位置前插入
一个值。

def insert(ls,num,num1):
    ls.insert(num,num1)
    return ls

            
ls = [1,2,3,4,5,6] 
print("插入前：{}".format(ls))
num = int(input("输入插入的位置："))
num1 = int(input("插入的元素"))
print("插入后：{}".format(insert(ls,num,num1)))

22.写一个方法，删除列表中指定位置的元素。

def remove(ls,num,):
    ls.remove(num)
    return ls

            
ls = [1,2,3,4,5,6] 
print("删除前：{}".format(ls))
num = int(input("输入删除的位置："))
print("删除后：{}".format(remove(ls,num)))

23.猜数游戏
1.随机出现一个数(范围自定义) 作为答案
2.提示用户输入并根据答案和用户输入的大小关系输
出大了? 小了?
3.5次机会
4.可以重复玩
5.根据猜对的次数进行评价
6.无论对错 请告知答案

import random
def caisuzi():
    com = random.randint(0,101)
    count = 0
    while count < 5:
        your = int(input("请输入一个0-100的数字:"))
        if your > com :
            print("输入值大了")
            count += 1
        elif your < com :
            print("输入值小了")
            count += 1
        else:
            print("猜对了！")
            count += 1
            break
    print("随机数字是{}".format(com))
    pinjia(count)

        
def pinjia(count):
    if count == 1:
        print("牛逼了，兄弟！")
    elif count == 2 or count == 3:
        print("厉害啊，兄弟！")
    elif count == 4:
        print("不错，不错！")
    else:
        print("输入次数达到上限，你有点菜呀，兄弟！")



while True:
    choice = int(input("请输入你的选择：1，继续玩游戏，其他，退出---"))
    if choice == 1:
        caisuzi()
    else:
        break

以上代码均提供运行示例，代码水平拙劣，不喜勿喷，实在是题目太多，也不想优化了，权当是抛砖引玉，希望各位水平更进！虽然我连砖都算不上。