精华内容
下载资源
问答
  • python 练习题目

    千次阅读 多人点赞 2020-02-26 21:11:38
    总结了一些python题目可供初学者练习

    练习题目

    一、语言元素

    练习1:华氏温度转摄氏温度。

    摄氏温度©与华氏温度(F)的换算式是:C = 5×(F- 32)/9,F = 9×C /5+32。

    # 华氏温度转摄氏温度
    # 输入华氏温度,通过转化公式,输出摄氏温度
    
    F = float(input("请输入华氏温度:"))
    C = (5/9)*(F-32)
    print("摄氏温度为:%.2f" %C)
    

    总结:

    1. 字符串类型不能和数字相加减,然后使用了int()函数,又发现问题了,如果是输入小数时又会报错,然后就应该换成float()函数。
    练习2:输入圆的半径计算计算周长和面积。
    # 输入圆的半径计算计算周长和面积。
    import math
    r = float(input("输入圆的半径:"))
    L = 2*(math.pi)*r
    S = (math.pi)*r**2
    print("周长为:%.2f"% L)
    print("面积为:%.2f"% S)
    

    总结:

    π\pi的表达方式

    import math
    math.pi
    import numpy as np
    np.pi
    

    平方的表达方式

    r**2
    
    pow(r,2)
    import numpy as np
    np.power(r,2)
    
    练习3:输入年份判断是不是闰年。
    # 输入年份判断是不是闰年。
    
    y = int(input("请输入年份:"))
    if (y%4 == 0 and y%100!=0) or y%400==0:
        print("%d年是闰年" %y)
    else:
        print("%d年不是闰年" %y)
    

    总结 and or not 表示与或非逻辑运算符

    ​ & | 表示位运算符 ,按位运算符是把数字看作二进制来进行计算的

    二、分支结构

    练习1:英制单位与公制单位互换
    # 英制单位与公制单位互换
    
    '''
    长度单位: 1 英 寸=2.5400 厘 米   
                1 英 尺 =12 英 寸 =0.3048 米   
                1 码 =3 英 尺 =0.9144 米    
                1 英 里 =1760 码 =1.6093 千 米 
    '''
    
    
    L = float(input("输入长度:"))
    d = input('输入英制长度单位:')
    
    if d=='英寸':
        print( '%f英寸=%f厘米'%(L,L*2.54))
    elif d=="英尺":
        print(L ,"英尺=" ,L * 0.3048,"米")
    elif d=="码":
        print(str(L) + "码=" + str(L * 0.9144) + "米")
    elif d=="英里":
        print(str(L) + "英里=" + str(L * 1.6093) + "千米")
    else:
        print("输入单位错误,请重新输入")
    

    **总结:**三种输出方式:

    ​ 格式化输出

    ​ 字符串拼接使用+,输出时没有空格,

    ​ 多变量输出使用“,”有空格

    ​ 浮点数和字符串不能用+拼接

    练习2:掷骰子决定做什么
    from random import randint
    
    face = randint(1, 6)
    if face == 1:
        result = '唱首歌'
    elif face == 2:
        result = '跳个舞'
    elif face == 3:
        result = '学狗叫'
    elif face == 4:
        result = '做俯卧撑'
    elif face == 5:
        result = '念绕口令'
    else:
        result = '讲冷笑话'
    print(result)
    
    练习3:百分制成绩转等级制
    """
    百分制成绩转等级制成绩
    90分以上    --> A
    80分~89分    --> B
    70分~79分	   --> C
    60分~69分    --> D
    60分以下    --> E
    
    """
    
    score = float(input('请输入成绩: '))
    if score >= 90:
        grade = 'A'
    elif score >= 80:
        grade = 'B'
    elif score >= 70:
        grade = 'C'
    elif score >= 60:
        grade = 'D'
    else:
        grade = 'E'
    print('对应的等级是:', grade)
    
    练习4:输入三条边长如果能构成三角形就计算周长和面积
    #  输入三条边长如果能构成三角形就计算周长和面积
    import math
    a = float(input("输入三角形第一条边长:"))
    b = float(input("输入三角形第二条边长:"))
    c = float(input("输入三角形第三条边长:"))
    
    if a+b>c and a+c>b and b+c>a:
        L = a+b+c
        print("三角形周长为:%f" % L)
        p = L/2
        s = math.sqrt(p*(p-a)*(p-b)*(p-c)) # 海伦公式:使用三条边长计算三角形面积
        print("三角形的面积为:%f" % s)
    else:
        print("对不起,这三条边不能构成三角形,请重新输入")
    

    开根号

    import math
    math.sqrt()
    import numpy as np
    np.sqrt()
    
    练习5:个人所得税计算器。

    在这里插入图片描述

    # 个人所得税计算器。
    # 个人所得税(应发工资-五险一金-起征税额)*对应的税率-对应的速算扣除数
    
    a = float(input("应发工资:"))
    b = float(input("五险一金:"))
    
    k = a-b-5000
    
    if k <3000:
        diff = 0.03
        s = 0
    elif k<12000:
        diff = 0.1
        s = 210
    elif k<25000:
        diff = 0.2
        s = 1410
    elif k<35000:
        diff = 0.25
        s = 2660
    elif k<55000:
        diff = 0.3
        s = 4410
    elif k<80000:
        diff = 0.35
        s = 7160
    else:
        diff = 0.45
        s = 15160
    
    w = k*diff-s
    
    print("个人所得税额为:%.2f" % w)
    
    # ------------------------------------------------------------
    
    a = float(input("应发工资:"))
    b = float(input("五险一金:"))
    
    k = a-b-5000
    
    money = [80000,55000,35000,25000,12000,3000,0]
    rate = [0.45,0.35,0.3,0.25,0.2,0.1,0.03]
    deduction = [15160,7160,4410,2660,1410,210,0]
    for i in range(len(money)):
        if k > money[i]:
            w = k*rate[i]-deduction[i]
            break
    print("个人所得税额为:%.2f" % w)
    
    
    

    三、循环结构

    1.用for循环实现1~100求和

    sum = 0
    for i in range(1,101):
        sum += i
        
    print(sum)
    # 下面这种更方便---------------------
    sum = sum(i for i in range(1,101))
    print(sum)
    

    2.用for循环实现1~100之间的偶数求和

    sum = sum(i for i in range(2,101,2))
    print(sum)
    

    3.猜数字游戏
    计算机出一个1~100之间的随机数由人来猜
    计算机根据人猜的数字分别给出提示大一点/小一点/猜对了

    # 猜数字游戏
    # 计算机出一个1~100之间的随机数由人来猜
    # 计算机根据人猜的数字分别给出提示大一点/小一点/猜对了
    
    import random
    random.seed(0)
    a = random.randint(1,100)
    
    b = int(input("请输入数字:"))
    k = 1
    while k:  
        if a > b:
            print("再大一点")
            b = int(input("请再次输入:"))
        elif a<b:
            print("再小一点")
            b = int(input("请再次输入:"))
        else:
            k = 0
            print("猜对了")
            
    # ----------------------------------------------------------------
    
    import random
    
    answer = random.randint(1, 100)
    counter = 0
    while True:
        counter += 1
        number = int(input('请输入: '))
        if number < answer:
            print('大一点')
        elif number > answer:
            print('小一点')
        else:
            print('恭喜你猜对了!')
            break
    print('你总共猜了%d次' % counter)
    if counter > 7:
        print('你的智商余额明显不足')
    
    

    说明: 上面的代码中使用了break关键字来提前终止循环,需要注意的是break只能终止它所在的那个循环,这一点在使用嵌套的循环结构(下面会讲到)需要引起注意。除了break之外,还有另一个关键字是continue,它可以用来放弃本次循环后续的代码直接让循环进入下一轮。

    4.输出乘法口诀表(九九表)

    #  输出乘法口诀表(九九表)
    
    for i in range(1,10):
        for j in range(1,i+1):
            print(str(j)+"*"+str(i)+"="+str(i*j),end='  ')
        print()
    # ---------------------------------------------------------------
    
    for i in range(1, 10):
         for j in range(1, i + 1):
             print('%d*%d=%d' % (j, i, i * j), end='\t')
         print()
    # -------------------------------------------------------------------    
        
    row = 1        # 行数,九九乘法表有九行,因此row从1开始到9结束
    while row <= 9:   
        col = 1    #列数,
        while col <= row:    # 第一行有一次输出,第二行有两次输出,...col < row正好符合该条件
            print("%d * %d = %d\t" % (col,row,row*col),end="")  
          # print() 默认每次输出都会换行,是因为默认有一个换行符\n,使用end="",就可以不让他换行 
            col += 1
        print()     # 内层循环每循环一次都强制换行,开始下一行的输出
        row += 1
    

    5.输入一个正整数判断它是不是素数

    # 输入一个正整数判断它是不是素数
    # 质数是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数
    
    a = int(input("输入一个正整数:"))
    
    k=0
    for j in range(2,a):
        if a%j ==0:
            print("%d 不是素数" %a)
            break
        else:
            k +=1
    if k==a-2:
        print("%d 是素数" %a)
    
    
    
    
    from math import sqrt
    
    num = int(input('请输入一个正整数: '))
    end = int(sqrt(num))
    is_prime = True
    for x in range(2, end + 1):
        if num % x == 0:
            is_prime = False
            break
    if is_prime and num != 1:
        print('%d是素数' % num)
    else:
        print('%d不是素数' % num)
    

    6.输入两个正整数计算最大公约数和最小公倍数

    img

    img

    # 输入两个正整数计算最大公约数和最小公倍数
    
    # x = int(input("输入第一个正整数:"))
    # y = int(input("输入第二个正整数:"))
    x,y = eval(input("输入两个正整数 需要用逗号隔开:"))
    # x,y = map(int,input("输入两个正整数:").split())
    a,b =x,y
    
    r= 1
    while r :
        r = a % b
        a = b
        b = r
    
    print("最大公约数:%d" %a)
    
    print("最小公倍数:%d" %(x*y/a))
    
    # ------------------------------
    x = int(input('x = '))
    y = int(input('y = '))
    if x > y:
        x, y = y, x
    for factor in range(x, 0, -1):
        if x % factor == 0 and y % factor == 0:
            print('%d和%d的最大公约数是%d' % (x, y, factor))
            print('%d和%d的最小公倍数是%d' % (x, y, x * y // factor))
            break
    
    

    四、构造程序逻辑

    1.寻找“水仙花数”

    n = int(input("输入位数:"))
    # a ='1'
    # x,y = int(a+'0'*(n-1)),int(a+'0'*n)
    x,y = pow(10,n-1),pow(10,n)
    
    for num in range(x,y):
        Num = str(num)
        list = [int(Num[i])**n for i in range(n)]
        Sum = sum( j for j in list)
        if Sum == num:
            print("%d 是水仙花数" %num)
    #------------------------------------------------------------------
            
    for num in range(100, 1000):
        low = num % 10
        mid = num // 10 % 10
        high = num // 100
        if num == low ** 3 + mid ** 3 + high ** 3:
            print(num)
    
    

    2.寻找“完美数”

    n = int(input("输入位数:"))
    x,y = pow(10,n-1),pow(10,n)
    
    for i in range(x,y):
        num = 1
        list = []
        while num <= i:
            if i % num == 0:
                list.append(num)
            num = num + 1
        list.pop()
        Sum = sum(j for j in list)
        if Sum == i:
            print("%d是完美数" % i)
            
            
    # -----------------------------------------------------
    import math
    
    for num in range(1, 10000):
        result = 0
        for factor in range(1, int(math.sqrt(num)) + 1):
            if num % factor == 0:
                result += factor
                if factor > 1 and num // factor != factor:
                    result += num // factor
        if result == num:
            print(num)
    
    

    3.“百钱百鸡”问题。

    # 百钱百鸡问题
    # 公鸡一只五块钱,母鸡一只三块钱,小鸡三只一块钱,现在要用一百块钱买一百只鸡,问公鸡、母鸡、小鸡各多少只?
    
    
    
    for x in range(101):
        for y in range(101):
            if 5*x+3*y+(100-x-y)/3 ==100:
                print("公鸡%d只,母鸡%d只,小鸡%d只" %(x,y,100-x-y))
    
    
    

    4.生成“斐波拉切数列”

    # 4.生成“斐波拉切数列”
    # 1、1、2、3、5、8、13、21、34、……
    # F(1)=1,F(2)=1, F(n)=F(n-1)+F(n-2)(n>=3,n∈N*)
    
    list = [1,1]
    
    for i in range(2,100):
        list.append(list[i-1]+list[i-2])
    
    print(list)
    
    # ---------------------------------------------------
    a = 0
    b = 1
    for _ in range(20):
        a, b = b, a + b
        print(a, end=' ')
        
        
    # --------------------------------------------------------------
    def fib(n):
        a, b = 0, 1
        for _ in range(n):
            a, b = b, a + b
            yield a
    
    
    def main():
        for val in fib(20):
            print(val)
    
    
    if __name__ == '__main__':
        main()
    
    
    
    

    5.Craps赌博游戏。

    在这里插入图片描述

    '''
    Craps赌博游戏
    玩家摇两颗色子 如果第一次摇出7点或11点 玩家胜
    如果摇出2点 3点 12点 庄家胜 其他情况游戏继续
    玩家再次要色子 如果摇出7点 庄家胜
    如果摇出第一次摇的点数 玩家胜
    否则游戏继续 玩家继续摇色子
    玩家进入游戏时有1000元的赌注 全部输光游戏结束
    '''
    
    import random
    
    money = 1000
    # debt = int(input("请下注:"))
    while money>0:
        debt = int(input("请下注:"))
        x1 = random.randint(1,6)
        x2 = random.randint(1,6)
        X = x1+x2
        print("X",X)
        if X in (7,11):
            print("*玩家胜")
            money += debt
            print("还剩%d元" % money)
        elif X in (2,3,12):
            print("*庄家胜")
            money -= debt
            print("还剩%d元" % money)
        else:
            print("*请继续游戏")
            while money>0:
               debt = int(input("请下注:"))
               x3 = random.randint(1, 6)
               x4 = random.randint(1, 6)
               Y = x3 + x4
               print("Y",Y)
               if Y == X:
                   print("**玩家胜")
                   money += debt
                   print("还剩%d元" % money)
               elif Y ==7:
                   print("**庄家胜")
                   money -= debt
                   print("还剩%d元" % money)
                   break
               else:
                   print("**请继续游戏")
    
    # --------------------------------------------------------------------------
    from random import randint
    
    money = 1000
    while money > 0:
        print('你的总资产为:', money)
        needs_go_on = False
        while True:
            debt = int(input('请下注: '))
            if 0 < debt <= money:
                break
        first = randint(1, 6) + randint(1, 6)
        print('玩家摇出了%d点' % first)
        if first == 7 or first == 11:
            print('玩家胜!')
            money += debt
        elif first == 2 or first == 3 or first == 12:
            print('庄家胜!')
            money -= debt
        else:
            needs_go_on = True
    
        while needs_go_on:
            current = randint(1, 6) + randint(1, 6)
            print('玩家摇出了%d点' % current)
            if current == 7:
                print('庄家胜')
                money -= debt
                needs_go_on = False
            elif current == first:
                print('玩家胜')
                money += debt
                needs_go_on = False
    
    print('你破产了, 游戏结束!')
    
    

    区别:

    import numpy as np
    np.random.randint(a,b) # 不包括b
    
    import random
    random.randint(a,b) # 包括b
    
    

    五、函数和模块的使用

    练习1:实现计算求最大公约数和最小公倍数的函数。
    def gcd(x, y):
        (x, y) = (y, x) if x > y else (x, y)
        for factor in range(x, 0, -1):
            if x % factor == 0 and y % factor == 0:
                return factor
    
    
    def lcm(x, y):
        return x * y // gcd(x, y)
    
    
    练习2:实现判断一个数是不是回文数的函数。
    def is_palindrome(num):
        temp = num
        total = 0
        while temp > 0:
            total = total * 10 + temp % 10
            temp //= 10
        return total == num
    
    
    练习3:实现判断一个数是不是素数的函数。
    def is_prime(num):
        for factor in range(2, num):
            if num % factor == 0:
                return False
        return True if num != 1 else False
    
    
    练习4:写一个程序判断输入的正整数是不是回文素数。
    if __name__ == '__main__':
        num = int(input('请输入正整数: '))
        if is_palindrome(num) and is_prime(num):
            print('%d是回文素数' % num)
    
    

    六、字符串和常用数据结构

    练习1:在屏幕上显示跑马灯文字
    import os
    import time
    
    content = "我爱你,中国!---我为你歌唱---"
    
    while True:
        os.system('cls')
        print(content)
    
        time.sleep(0.2)
    
        content = content[1:]+content[0]
    
    
    练习2:设计一个函数产生指定长度的验证码,验证码由大小写字母和数字构成。
    # 设计一个函数产生指定长度的验证码,验证码由大小写字母和数字构成。
    # (1)看到验证码,肯定要用random()随机函数
    #
    # (2)随机生成数字:randint(0,9)
    #
    #           注意:要把数字转换成字符串
    #
    # (3)随机生成字母:不区分大小写
    #
    #           在ASC码中找到A:65,Z:90 a:97  z:122
    #
    #           randint(65,90):在65~90中随机产生一个数字
    #
    #          把随机产生的数字转换成字母:chr()函数
    #
    #  (4)在字母和数字中随机选一个:choice()
    
    import random
    def yanzhengma(n):
        x = 0
        while x<n:
            s = random.choice(range(1,4))
            if s == 1:
                a = random.randint(0,10)
                print(a,end='')
                x+=1
            if s == 2:
                a = random.randint(65,90)
                print(chr(a),end='')
                x+=1
            if s == 3:
                a = random.randint(97, 122)
                print(chr(a), end='')
                x += 1
    
    n = int(input("请输入验证码位数:"))
    yanzhengma(n)
    
    # ---------------------------------------------------------------------------
    import random
    
    
    def generate_code(code_len=4):
        """
        生成指定长度的验证码
    
        :param code_len: 验证码的长度(默认4个字符)
    
        :return: 由大小写英文字母和数字构成的随机验证码
        """
        all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
        last_pos = len(all_chars) - 1
        code = ''
        for _ in range(code_len):
            index = random.randint(0, last_pos)
            code += all_chars[index]
        return code
    
    
    
    • chr():将整数转换成该编码对应的字符串(一个字符)。
    • ord():将字符串(一个字符)转换成对应的编码(整数)。
    练习3:设计一个函数返回给定文件名的后缀名。
     def hzm():
        """
        获取文件名的后缀名
        
        :return:文件名后缀
        """
        a = input("输入文件名:")
        list = a.split('.')
        # print(list[-1])
        # print('.'+list[-1])
        return list[-1]
    hzm()
    
    
    # --------------------------------------------------------------------------
    def get_suffix(filename, has_dot=False):
        """
        获取文件名的后缀名
    
        :param filename: 文件名
        :param has_dot: 返回的后缀名是否需要带点
        :return: 文件的后缀名
        """
        pos = filename.rfind('.')
        if 0 < pos < len(filename) - 1:
            index = pos if has_dot else pos + 1
            return filename[index:]
        else:
            return ''
    
    
    
    练习4:设计一个函数返回传入的列表中最大和第二大的元素的值。
    # 设计一个函数返回传入的列表中最大和第二大的元素的值。
    def zuida(list):
        a = max(list)
        list.remove(a)
        b = max(list)
    
        return a,b
    list = [1,2,3,4,5,6,9,8]
    a,b = zuida(list)
    print("列表中最大的元素是%d,第二大元素是%d" %(a,b))
    
    
    # -----------------------------------------------------------------------
    def zuida(list):
        list.sort(reverse=True)
        a = list[0]
        b = list[1]
        return a,b
    list = [1,2,3,4,5,6,9,8]
    a,b = zuida(list)
    print("列表中最大的元素是%d,第二大元素是%d" %(a,b))
    
    # ---------------------------------------------------------------
    def max2(x):
        m1, m2 = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0])
        for index in range(2, len(x)):
            if x[index] > m1:
                m2 = m1
                m1 = x[index]
            elif x[index] > m2:
                m2 = x[index]
        return m1, m2
    
    
    练习5:计算指定的年月日是这一年的第几天
    # 计算指定的年月日是这一年的第几天
    # 先判断年份是闰年还是普通年份
    # 再判断是一年中的第几个月份
    # 然后根据号数计算天数
    
    
    def runnian(y):
        if (y % 4 == 0 and y % 100 != 0) or y % 400 == 0:
            return True
        else:
            return False
    
    
    def main(y,m,d):
        a = runnian(y)
        if (a == True):
            list1 = [31,29,31,30,31,30,31,31,30,31,30,31]
            d1 = sum(list1[i] for i in range(0,m-1))
            d2 = d1+d
            print("%d年%d月%d日是这一年的第%d天" %(y,m,d,d2))
            return d2
        if (a == False):
            list2 = [31,28,31,30,31,30,31,31,30,31,30,31]
            d1 = sum(list2[i] for i in range(0,m-1))
            d2 = d1+d
            print("%d年%d月%d日是这一年的第%d天" % (y, m, d, d2))
            return d2
        
    
    y = int(input("请输入年份:"))
    m = int(input("请输入月份:"))
    d = int(input("请输入几号:"))
    
    main(y,m,d)
    
    # ------------------------------------------------
    # 简化版本
    
    def runnian(y):
        return (y % 4 == 0 and y % 100 != 0) or y % 400 == 0
    
    def main(y,m,d):
    
       list = [[31,28,31,30,31,30,31,31,30,31,30,31],[31,29,31,30,31,30,31,31,30,31,30,31]][runnian(y)]
       d1 = sum(list[i] for i in range(0,m-1))
       d2 = d1+d
       print("%d年%d月%d日是这一年的第%d天" %(y,m,d,d2))
       return d2
    
    
    y = int(input("请输入年份:"))
    m = int(input("请输入月份:"))
    d = int(input("请输入几号:"))
    
    main(y,m,d)
    
    # --------------------------------------------------------------------
    
    def is_leap_year(year):
        """
        判断指定的年份是不是闰年
    
        :param year: 年份
        :return: 闰年返回True平年返回False
        """
        return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
    
    
    def which_day(year, month, date):
        """
        计算传入的日期是这一年的第几天
    
        :param year: 年
        :param month: 月
        :param date: 日
        :return: 第几天
        """
        days_of_month = [
            [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
            [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        ][is_leap_year(year)]
        total = 0
        for index in range(month - 1):
            total += days_of_month[index]
        return total + date
    
    
    def main():
        print(which_day(1980, 11, 28))
        print(which_day(1981, 12, 31))
        print(which_day(2018, 1, 1))
        print(which_day(2016, 3, 1))
    
    
    if __name__ == '__main__':
        main()
        
    # ---------------------------------------------------------------
    def tm004():
        '''
        【个人备注】:知道python有时间元组这一概念,这道题完全不需要计算。
        时间元组包含九个属性
        tm_year     年
        tm_mon      月(1~12)
        tm_mday     日(1~31)
        tm_hour     时(0~23)
        tm_min      分(0~59)
        tm_sec      秒(0~61, 60或61是闰秒)
        tm_wday     星期(0~6, 0是周一)
        tm_yday     第几天(1~366, 366是儒略历)
        tm_isdst    夏令时(平时用不到)
        '''
        import time
        date = input('输入时间(例如2018-01-23):')
        st = time.strptime(date,'%Y-%m-%d') # 时间文本转化成时间元祖
        num = st.tm_yday
        print(num)
    
    
    
    练习6:打印杨辉三角
    def YangHui(n=16,r=80):
        """
        打印杨辉三角
        :param n: 打印的行数
        :param r: 居中的范围
        :return: 打印出来的杨辉三角
        """
        line = [1,1]
        LL = [[1]]
    
        for i in range(2,n+1):
            linei = [1]+[(line[j]+line[j+1]) for j in range(i-2)]+[1]
            line = linei
            LL.append(linei)
    
        for i in range(n):
            linei = [str(j) for j in LL[i]]
            stri = " ".join(linei)
            print(stri.center(r))
    
    YangHui()
    
    # --------------------------------------------------------------------
    def YangHui(n,r):
        """
        打印杨辉三角
        :param n: 打印的行数
        :param r: 居中的范围
        :return: 打印出来的杨辉三角
        """
        line1 = [1]
        print((" ".join([str(j) for j in line1])).center(r))
        line = [1,1]
        for i in range(2,n+1):
            linei = [1]+[(line[j]+line[j+1]) for j in range(i-2)]+[1]
            line = linei
            print((" ".join([str(j) for j in linei])).center(r))
    
    YangHui(n=16,r=80)
    
    
    
    案例1:双色球选号
    from random import randrange, randint, sample
    
    
    def display(balls):
        """
        输出列表中的双色球号码
        """
        for index, ball in enumerate(balls):
            if index == len(balls) - 1:
                print('|', end=' ')
            print('%02d' % ball, end=' ')
        print()
    
    
    def random_select():
        """
        随机选择一组号码
        """
        red_balls = [x for x in range(1, 34)]
        selected_balls = []
        selected_balls = sample(red_balls, 6)
        selected_balls.sort()
        selected_balls.append(randint(1, 16))
        return selected_balls
    
    
    def main():
        n = int(input('机选几注: '))
        for _ in range(n):
            display(random_select())
    
    
    if __name__ == '__main__':
        main()
    
    

    random模块的用法

    Python标准库中的random函数,可以生成随机浮点数、整数字符串,甚至帮助你随机选择列表

    列中的一个元素,打乱一组数据等。

    random中的一些重要函数的用法:

    1 )、random() 返回0<=n<1之间的随机实数n;
    2 )、choice(seq) 从序列seq中返回随机的元素;
    3 )、getrandbits(n) 以长整型形式返回n个随机位;
    4 )、shuffle(seq[, random]) 原地指定seq序列;
    5 )、sample(seq, n) 从序列seq中选择n个随机且独立的元素;

    详细介绍:

    **random.random()**函数是这个模块中最常用的方法了,它会生成一个随机的浮点数,范围是在0.0~1.0之间。

    **random.uniform()**正好弥补了上面函数的不足,它可以设定浮点数的范围,一个是上限,一个是下限。

    **random.randint()**随机生一个整数int类型,可以指定这个整数的范围,同样有上限和下限值,python random.randint。

    **random.choice()**可以从任何序列,比如list列表中,选取一个随机的元素返回,可以用于字符串、列表、元组等。

    **random.shuffle()**如果你想将一个序列中的元素,随机打乱的话可以用这个函数方法。

    **random.sample()**可以从指定的序列中,随机的截取指定长度的片断,不作原地修改。

    综合案例2:约瑟夫环问题

    《幸运的基督徒》
    有15个基督徒和15个非基督徒在海上遇险,为了能让一部分人活下来不得不将其中15个人扔到海里面去,有个人想了个办法就是大家围成一个圈,由某个人开始从1报数,报到9的人就扔到海里面,他后面的人接着从1开始报数,报到9的人继续扔到海里面,直到扔掉15个人。由于上帝的保佑,15个基督徒都幸免于难,问这些人最开始是怎么站的,哪些位置是基督徒哪些位置是非基督徒。

    def main():
        persons = [True]*30
        counter,index,number = 0,0,0
        while counter<15:
            if persons[index]:
                number += 1
                if number ==9:
                    persons[index]=False
                    counter += 1
                    number = 0
    
            index +=1
            index %=30
    
    
        for person in persons:
            print("基" if person else "非" , end=' ')
    
    if __name__ == '__main__':
        main()
    
    
    
    综合案例3:井字棋游戏
    import os
    
    
    def print_board(board):
        print(board['TL'] + '|' + board['TM'] + '|' + board['TR'])
        print('-+-+-')
        print(board['ML'] + '|' + board['MM'] + '|' + board['MR'])
        print('-+-+-')
        print(board['BL'] + '|' + board['BM'] + '|' + board['BR'])
    
    
    def main():
        init_board = {
            'TL': ' ', 'TM': ' ', 'TR': ' ',
            'ML': ' ', 'MM': ' ', 'MR': ' ',
            'BL': ' ', 'BM': ' ', 'BR': ' '
        }
        begin = True
        while begin:
            curr_board = init_board.copy()
            begin = False
            turn = 'x'
            counter = 0
            os.system('clear')
            print_board(curr_board)
            while counter < 9:
                move = input('轮到%s走棋, 请输入位置: ' % turn)
                if curr_board[move] == ' ':
                    counter += 1
                    curr_board[move] = turn
                    if turn == 'x':
                        turn = 'o'
                    else:
                        turn = 'x'
                os.system('clear')
                print_board(curr_board)
            choice = input('再玩一局?(yes|no)')
            begin = choice == 'yes'
    
    
    if __name__ == '__main__':
        main()
    
    

    面向对象编程基础

    练习1:定义一个类描述数字时钟
    class Clock:
        def __init__(self, hour, miniter, seconds):
            self.hour = hour
            self.miniter = miniter
            self.seconds = seconds
    
        def baoshi(self):
            print('%s点%s分%s秒' % (self.hour, self.miniter, self.seconds))
            print('现在的时间为:',datetime.datetime.now())
    
    import datetime
    
    time1 = Clock('10','27','30')
    
    time1.baoshi()
    
            
            
    # ---------------------------------------------------------------------
    from time import sleep
    
    
    class Clock(object):
        """数字时钟"""
    
        def __init__(self, hour=0, minute=0, second=0):
            """初始化方法
    
            :param hour: 时
            :param minute: 分
            :param second: 秒
            """
            self._hour = hour
            self._minute = minute
            self._second = second
    
        def run(self):
            """走字"""
            self._second += 1
            if self._second == 60:
                self._second = 0
                self._minute += 1
                if self._minute == 60:
                    self._minute = 0
                    self._hour += 1
                    if self._hour == 24:
                        self._hour = 0
    
        def show(self):
            """显示时间"""
            return '%02d:%02d:%02d' % \
                   (self._hour, self._minute, self._second)
    
    
    def main():
        clock = Clock(23, 59, 58)
        while True:
            print(clock.show())
            sleep(1)
            clock.run()
    
    
    if __name__ == '__main__':
        main()
        
    
    
    
    练习2:定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。
    # 定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。
    
    class Point:
        def __init__(self,x,y):
            self.x = x
            self.y = y
    
    
        def move(self,a,b):
            self.x += a
            self.y += b
            return (self.x,self.y)
    
        def distence(self,x1,y1):
            distence = sqrt((self.x - x1)**2 + (self.y - y1)**2)
            return distence
    
    from math import sqrt
    p = Point(2,6)
    
    print(p.x)
    print(p.y)
    
    print(p.move(4,-3))
    
    print(p.x)
    print(p.y)
    
    print(p.distence(4,6))
    print(sqrt(13))
    
    
    # --------------------------------------------------------------
    
    
    from math import sqrt
    
    
    class Point(object):
    
        def __init__(self, x=0, y=0):
            """初始化方法
            
            :param x: 横坐标
            :param y: 纵坐标
            """
            self.x = x
            self.y = y
    
        def move_to(self, x, y):
            """移动到指定位置
            
            :param x: 新的横坐标
            "param y: 新的纵坐标
            """
            self.x = x
            self.y = y
    
        def move_by(self, dx, dy):
            """移动指定的增量
            
            :param dx: 横坐标的增量
            "param dy: 纵坐标的增量
            """
            self.x += dx
            self.y += dy
    
        def distance_to(self, other):
            """计算与另一个点的距离
            
            :param other: 另一个点
            """
            dx = self.x - other.x
            dy = self.y - other.y
            return sqrt(dx ** 2 + dy ** 2)
    
        def __str__(self):
            return '(%s, %s)' % (str(self.x), str(self.y))
    
    
    def main():
        p1 = Point(3, 5)
        p2 = Point()
        print(p1)
        print(p2)
        p2.move_by(-1, 2)
        print(p2)
        print(p1.distance_to(p2))
    
    
    if __name__ == '__main__':
        main()
    
    
    案例3:工资结算系统

    某公司有三种类型的员工 分别是部门经理、程序员和销售员
    需要设计一个工资结算系统 根据提供的员工信息来计算月薪
    部门经理的月薪是每月固定15000元
    程序员的月薪按本月工作时间计算 每小时150元
    销售员的月薪是1200元的底薪加上销售额5%的提成

    class Manager:
        def __init__(self,name):
            self.name = name
    
        @property
        def salary(self):
            return 15000
    
    class Iter:
        def __init__(self,name,time):
            self.name = name
            self.time = time
    
    
        @property
        def salary(self):
            return self.time * 150
    
    class Saler:
        def __init__(self,name,sale_money):
            self.name = name
            self.sale_money = sale_money
    
        @property
        def salary(self):
            return 1200 + self.sale_money * 0.05
    
    
    m = Manager('晓明')
    
    i = Iter('Jarrod',8*5*4)
    
    s = Saler('gg',100000)
    
    print('部门经理%s的月薪是%d' %(m.name,m.salary))
    print('程序员%s的月薪是%d' %(i.name,i.salary))
    print('销售员%s的月薪是%d' %(s.name,s.salary))
    
    
    # --------------------------------------------------------
    
    from abc import ABCMeta, abstractmethod
    
    
    class Employee(object, metaclass=ABCMeta):
        """员工"""
    
        def __init__(self, name):
            """
            初始化方法
    
            :param name: 姓名
            """
            self._name = name
    
        @property
        def name(self):
            return self._name
    
        @abstractmethod
        def get_salary(self):
            """
            获得月薪
    
            :return: 月薪
            """
            pass
    
    
    class Manager(Employee):
        """部门经理"""
    
        def get_salary(self):
            return 15000.0
    
    
    class Programmer(Employee):
        """程序员"""
    
        def __init__(self, name, working_hour=0):
            super().__init__(name)
            self._working_hour = working_hour
    
        @property
        def working_hour(self):
            return self._working_hour
    
        @working_hour.setter
        def working_hour(self, working_hour):
            self._working_hour = working_hour if working_hour > 0 else 0
    
        def get_salary(self):
            return 150.0 * self._working_hour
    
    
    class Salesman(Employee):
        """销售员"""
    
        def __init__(self, name, sales=0):
            super().__init__(name)
            self._sales = sales
    
        @property
        def sales(self):
            return self._sales
    
        @sales.setter
        def sales(self, sales):
            self._sales = sales if sales > 0 else 0
    
        def get_salary(self):
            return 1200.0 + self._sales * 0.05
    
    
    def main():
        emps = [
            Manager('刘备'), Programmer('诸葛亮'),
            Manager('曹操'), Salesman('荀彧'),
            Salesman('吕布'), Programmer('张辽'),
            Programmer('赵云')
        ]
        for emp in emps:
            if isinstance(emp, Programmer):
                emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
            elif isinstance(emp, Salesman):
                emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
            # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
            print('%s本月工资为: ¥%s元' %
                  (emp.name, emp.get_salary()))
    
    
    if __name__ == '__main__':
        main()
    
    
    扑克牌
    import random
    
    
    class Card(object):
        """一张牌"""
    
        def __init__(self, suite, face):
            self._suite = suite   # 设置成私有属性
            self._face = face
    
        @property
        def face(self):         # 可以通过 对象.face 访问到 face属性
            return self._face
    
        @property
        def suite(self):       # 可以通过 对象.suite 访问到 suite属性
            return self._suite
    
        def __str__(self):     # 内置方法
            if self._face == 1:
                face_str = 'A'
            elif self._face == 11:
                face_str = 'J'
            elif self._face == 12:
                face_str = 'Q'
            elif self._face == 13:
                face_str = 'K'
            else:
                face_str = str(self._face)
            return '%s%s' % (self._suite, face_str)
        
        def __repr__(self):
            return self.__str__()
    
    
    class Poker(object):
        """一副牌"""
    
        def __init__(self):
            self._cards = [Card(suite, face) 
                           for suite in '♠♥♣♦'
                           for face in range(1, 14)]
            self._current = 0
    
        @property
        def cards(self):
            return self._cards
    
        def shuffle(self):
            """洗牌(随机乱序)"""
            self._current = 0
            random.shuffle(self._cards)
    
        @property
        def next(self):
            """发牌"""
            card = self._cards[self._current]
            self._current += 1
            return card
    
        @property
        def has_next(self):
            """还有没有牌"""
            return self._current < len(self._cards)
    
    
    class Player(object):
        """玩家"""
    
        def __init__(self, name):
            self._name = name
            self._cards_on_hand = []
    
        @property
        def name(self):
            return self._name
    
        @property
        def cards_on_hand(self):
            return self._cards_on_hand
    
        def get(self, card):
            """摸牌"""
            self._cards_on_hand.append(card)
    
        def arrange(self, card_key):
            """玩家整理手上的牌"""
            self._cards_on_hand.sort(key=card_key)
    
    
    # 排序规则-先根据花色再根据点数排序
    def get_key(card):
        return (card.suite, card.face)
    
    
    def main():
        p = Poker()
        p.shuffle()
        players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
        for _ in range(13):
            for player in players:
                player.get(p.next)
        for player in players:
            print(player.name + ':', end=' ')
            player.arrange(get_key)
            print(player.cards_on_hand)
    
    
    if __name__ == '__main__':
        main()
    
    
    展开全文
  • Python练习题目

    千次阅读 2019-09-17 23:11:24
    Python课堂练习题目 1、生成一个由100以内能够被5整除的数组的列表,然后将列表的数字从大到小排序。(下列介绍3种方法) 第一种方法: list1= [] for i in range(1,101): if i%5==0: list1.append(i) list...

    Python课堂练习题目

    1、生成一个由100以内能够被5整除的数组的列表,然后将列表的数字从大到小排序。(下列介绍3种方法)
    第一种方法:

    list1= []
        for i in range(1,101):
            if i%5==0:
                list1.append(i)
                list1.sort(reverse=True)
        print(list1)
    

    第二种方法:

    list1=list(range(5,101,5))
    list1.sort(reverse=True)
    print(list1)
    

    第三种方法:

    tp_list=list()
    for i in range(1,101):
        if i%5 == 0:
            tp_list.append(i)
            tp_list.sort(reverse=True)
    print(tp_list)
    

    2、定义一个列表,要求该列表中的元素至少要包括字符串、整数、浮点数。(编写程序,将列表中 不是字符串的元素全部删除)

    list1=[1,2.14,'python',3,1.24,'java','C++',5,3.1415926]
    print(list1)
    ll = []
    for i in range(len(list1)):
        if type(list1[i]) is str:
            ll.append(list1[i])
    print(ll)
    

    3、写一段程序实现输入英文的姓名,按照字典的顺序将所有的姓名排序并输出。

    name_list = []
    while True:
        name=input("Please input an English name(input 'q' then exit):")
        if name=='q':
            name_list.sort()
            print(name_list)
            break;
        else:
            name_list.append(name)
    
    展开全文
  • python练习题目

    2019-10-08 00:20:59
    1.查看本机安装python版本 2.用python打印"Hello World",给出源代码和执行结果 a.命令行窗口输出(前提:python程序加入PATH系统环境变量) b.python.exe程序输出 3.用python计算10/3,发出截图 print...

    1.查看本机安装python版本

    2.用python打印"Hello World",给出源代码和执行结果

    a.命令行窗口输出(前提:python程序加入PATH系统环境变量)

    b.python.exe程序输出

    3.用python计算10/3,发出截图

    print(10/3)

    4.查看通过pip安装python module

    利用pip安装matplotlib模块,matplotlib是一个Python的2D绘图库

     查看matplotlib模块信息

     5.将用pycharm创建一个工程项目,其中包含Dog.py文件,发截图

    源代码:

    class Dog():
    def __init__(self,name,age):
    self.name=name
    self.age=age

    def sit(self):
    # 小狗被命令下蹲
    print(self.name.title()+ " is now sitting.")

    def roll_over(self):
    # 小狗被命令打滚
    print(str(self.age) + " 岁 " + self.name + " rolled over!")

    my_dog = Dog('willie',25)
    print(my_dog.sit())
    print(my_dog.roll_over())
    运行结果

     1.比如在游戏中经常需要从一个点移动到另一个点,给出坐标、位移和角度,就可以计算出新的坐标:

    # math包提供了sin()和 cos()函数,我们先用import引用它:

    import math
    def move(x, y, step, angle):
        nx = x + step * math.cos(angle)
        ny = y - step * math.sin(angle)
        return nx, ny

    这样我们就可以同时获得返回值:

    >>> x, y = move(100, 100, 60, math.pi / 6)
    >>> print x, y
    151.961524227 70.0

    但其实这只是一种假象,Python函数返回的仍然是单一值:

    >>> r = move(100, 100, 60, math.pi / 6)
    >>> print r
    (151.96152422706632, 70.0)

    用print打印返回结果,原来返回值是一个tuple!
    但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。


    range()函数可以创建一个数列:

    >>> range(1, 101)
    [1, 2, 3, ..., 100]

    请利用切片,取出:

    1. 前10个数;
    2. 3的倍数;
    3. 不大于50的5的倍数。

    L = range(1, 101)

    print L[0:10]
    print L[2::3]
    print L[4:51:5]

    2.倒序切片

    对于list,既然Python支持L[-1]取倒数第一个元素,那么它同样支持倒数切片,试试:

    >>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

    >>> L[-2:]
    ['Bart', 'Paul']

    >>> L[:-2]
    ['Adam', 'Lisa']

    >>> L[-3:-1]
    ['Lisa', 'Bart']

    >>> L[-4:-1:2]  --第三个参数2:每个两个数取一个,也即取数之间间隔1
    ['Adam', 'Bart']

    记住倒数第一个元素的索引是-1。倒序切片包含起始索引,不包含结束索引。

    3.迭代dict的key和value

    我们了解了如何迭代 dict 的key和value,那么,在一个 for 循环中,能否同时迭代 key和value?答案是肯定的。

    首先,我们看看 dict 对象的 items() 方法返回的值:

    >>> d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
    >>> print d.items()
    [('Lisa', 85), ('Adam', 95), ('Bart', 59)]

    可以看到,items() 方法把dict对象转换成了包含tuple的list,我们对这个list进行迭代,可以同时获得key和value:

    >>> for key, value in d.items():
    ...     print key, ':', value
    ...
    Lisa : 85
    Adam : 95
    Bart : 59

    和 values() 有一个 itervalues() 类似, items() 也有一个对应的 iteritems(),iteritems() 不把dict转换成list,而是在迭代过程中不断给出 tuple,所以, iteritems() 不占用额外的内存。





    转载于:https://www.cnblogs.com/tanxiaojun/p/10686120.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,241
精华内容 1,696
关键字:

python练习题目

python 订阅