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()

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页