3.3.5 案例精选

　　1 编写函数计算圆的面积。

from math import pi as PI

def circle_area(r):
    if isinstance(r,(int,float)):
        return PI * r * r
    else:
        print('You must give an integer or float as radius.')

print('# 半径为3的圆的面积：',circle_area(3))

# 半径为3的圆的面积： 28.274333882308138

　　

　　2 编写函数，接受任意多个实数，返回一个元组，其中第一个元素为所有参数的平均值，其他元素为所有参数中大于平均值的实数。

#实现过程 1
def get_num1(*a):

    avg = sum(a)/len(a)

    l = [avg]

    for i in a:
        if i > avg:
            l.append(i)

    return tuple(l)

#实现过程 2
def get_num2(*a):

    avg = sum(a)/len(a)

    t1 = (avg,)

    def is_bigger(n):
        return n > avg

    t2 = tuple(filter(is_bigger,a))

    return t1 + t2



#实现过程 3
def get_num3(*para):
    avg = sum(para)/len(para)
    g = [i for i in para if i > avg]   #列表推导式
    return (avg,) + tuple(g)

print(get_num3(1,2,3,4,5,6,7,8,9))

#(5.0, 6, 7, 8, 9)

　　 

　　3 编写函数，接收字符串参数，返回一个元组，其中第一个元素为大写字母的个数，第二个元素为小写字母的个数。

# 我的实现过程

def get_num(s):

    #先判断传入的参数是否为字符串，如果不是结束程序。
    if not isinstance(s,str):
        return '在调用该函数时，请传入字符串作为参数'
    else:
        #定义一个变量表示大写字母的个数
        a = 0
        #定义一个变量表示小写字母的个数
        b = 0

        #判断如果s是空字符串，就没有必要进行下去了，结束程序
        if s is '':
            return '空字符串就没有必要继续处理了，结束'
        else:
            #遍历字符串，如果字符串的某个元素是小写字母，就b加1，是大写字母就 a加1
            for i in s:
                if i.islower():
                    b += 1
                if i.isupper():
                    a += 1
    return (a,b)

print(get_num(''))     #空字符串就没有必要继续处理了，结束
print(get_num(123))    #在调用该函数时，请传入字符串作为参数
print(get_num('123'))  #(0, 0)
print(get_num('hdwfegbngvjhdsafvdweBFEWIQAFBVDSAJFGQWEfkejdashgfFVBEQIRFAgfbewirfgvn    BGEKFA'))   #(34, 41)


#作者的实现过程
def demo(s):
    result = [0,0]
    for ch in s:
        if 'a' <= ch <= 'z':
            result[1] += 1
        elif 'A' <= ch <= 'Z':
            result[0] += 1

    return tuple(result)

print(demo('hdwfegbngvjhdsafvdweBFEWIQAFBVDSAJFGQWEfkejdashgfFVBEQIRFAgfbewirfgvn    BGEKFA'))   #(34, 41)

 

　　4  编写函数，接收包含20个整数的列表lst和一个整数k作为参数，返回新列表。处理规则：将列表lst中下标k之前的元素逆序，下标k之后的元素逆序，然后将整个列表lst中所有元素逆序。

def get_num(lst,k):

    # 判断lst是不是列表，是列表再进行接下来的操作
    if not isinstance(lst,list):
        return '要求参数lst是列表类型的数据哦，程序结束'
    else:

        # 判断传入的列表的元素个数是否为20个
        if not len(lst) == 20 :
            return '您输入列lst的元素个数不足20个，程序结束'
        # 判断传入的参数k的值是否过大或过小，防止引起下标越界的报错
        if k > 18 or k < 0:
            return '您输入的参数k的值不在0-18的范围内，会引起下标访问越界'

    #根据传入的参数k分隔lst
    l1 = lst[:k]
    l2 = lst[k:]

    l1.sort(reverse=True)
    l2.sort(reverse=True)

    lr = l1  + l2

    return l1,l2,sorted(lr,reverse=True)


print(get_num([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],7))


#作者的代码
def demo(lst,k):
    x = lst[:k]
    x.reverse()
    y = lst[k:]
    y.reverse()
    r = x + y
    return list(reversed(r))

#作者的代码好简洁啊，但健壮性就查了点，很容易因为调用者传入的参数不符合要求而出现异常

 

　　5 编写函数，接收整数参数t，返回斐波那契数列中大于t的第一个数。

def get_num(t):

    a = b =1

    while True:
        a , b = b , a + b

        if t < a :
            return a
        elif t > a and t < b:
            return b


print(get_num(-1))    #1
print(get_num(7))     #8
print(get_num(100))   #144

 

　　6 编写函数，接收一个包含若干整数的列表参数lst，返回一个元组，其中第一个元素为列表lst中的最小值，其余元素为最小值在lst中的下标。

 

import random

def get_num(lst):

    # 由于要求列表中的元素都要是整数，所以先判断元素
    t = tuple(lst)
    for i in t:
        if not isinstance(i,int):
            return 'lst中的元素 i = {}不是整数，不符合要求，请重新传入符合要求的列表'.format(i)

    #开始找列表中元素的最小值
    m = min(lst)

    #对列表做一个转换，
    l1 = list(enumerate(lst))

    #获取列表元素的下标
    l2 = []

    for tu in l1:
        if tu[1] == m:
            l2.append(tu[0])

    return (m,) + tuple(l2)

l = list(range(1,100))
random.shuffle(l)
l.append(1)
print(l)
print(get_num(l))

#[11, 60, 19, 25, 16, 24, 87, 67, 20, 44,
# 7, 10, 84, 73, 37, 42, 56, 68, 43, 91,
# 26, 3, 8, 14, 71, 94, 5, 31, 32, 34,
# 9, 17, 36, 69, 29, 12, 92, 41, 52, 57,
# 15, 74, 65, 82, 77, 75, 18, 47, 86, 45,
# 49, 2, 22, 64, 62, 33, 54, 1, 66,38,
# 88, 78, 30, 70, 58, 80, 95, 93, 79,55,
# 51, 6, 4, 40, 48, 39, 35, 89, 21,96,
# 90, 63, 81, 27, 61, 99, 72, 85, 98,23,
# 50, 53, 59, 28, 97, 76, 46, 13, 83,1]


#执行结果：  (1, 57, 99)

 作者的实现过程：

import random

def demo(lst):
    m = min(lst)
    result = (m,)
    position = [index for index,value in enumerate(lst) if value == m]
    result += tuple(position)

    return result

x = [random.randint(1,100) for i in range(50)]   #随机生成50条记录

print(demo(x))
#函数的执行结果 (2, 30, 39)

 

　　7 编写函数，接收一个整数t作为参数，打印杨辉三角前 t 行。

def demo(t):
    result = [[1],[1,1]]  #默认了前两项，从第三项开始加起的。
    line = [1,1]

    for i in range(2,t):
        r = []
        for j in range(0,len(line) - 1):
            r.append(line[j] + line[j+1])

        line = [1] + r +  [1]
        result.append(line)
    return result

def output(result):
    for item in result:
        print(item)

output(demo(10))