一篇博客带你学会python

最新推荐文章于 2023-08-26 07:45:00 发布

Mr Gao

最新推荐文章于 2023-08-26 07:45:00 发布

阅读量7.6k

点赞数 23

分类专栏： python 文章标签： python 字符串编程语言算法

本文链接：https://blog.csdn.net/weixin_43327597/article/details/114703752

版权

python 专栏收录该内容

106 篇文章 22 订阅

订阅专栏

一篇博客带你学完python

1.数字类型及表达式实战

第一关
本关的编程任务是补全文件的代码内容，输入一个整数，把这个整数换算为月份数和天数，每月以30天计算。
注意：在输出时用format函数将数字转换成字符串输出。

测试输入：
100
预期输出：
Months=3 Days=10

代码：

# coding = utf-8
data=int(input())
# 请在下面添加代码
###### Begin ######
print("Months=%d"%(data//30),"Days=%d"%(data%30))
####### End #######

第二关
本关的编程任务是补全文件的代码内容，输入一个任意位数大于0的整数，作为秒数，将此整数换算为天、时、分、秒，并按“天：时：分：秒”的形式显示结果。
注意：在输出时用format函数将数字转换成字符串后输出。

测试输入：
100
预期输出：
100秒是0天0时1分40秒

###### Begin ######
a=int(input())

d=a//(24*3600)
print("%d秒是%d天%d时%d分%d秒"%(a,a//(24*3600),d//3600,a//60,a%60))

第三关

2.Python 表达式和语句

第一关，我们做一个有趣的事，用turtle绘制一个等边三角形
下面，我们简单介绍一下turtle的一些用法
在这里插入图片描述

编写程序导入turtle库，并画出如图所示的等边三角形。要求边长为200，三边颜色为红色。

import turtle
Bob = turtle.Turtle()
Bob.pencolor("red")

Bob.forward(200)
Bob.left(120)	
Bob.forward(200)
Bob.left(120)	
Bob.forward(200)

#********* End *********#
#保存屏幕图片

ts = turtle.getscreen()
ts.getcanvas().postscript(file="Python/src1/py1-1/yourimg/sj.ps")

第二关：
编写程序导入turtle库，并画出如图所示的等边三角形。外面三角形边长为200，三边颜色为红色；里面的三角形边长为100，三边颜色为蓝色，填充颜色为黄色。
在这里插入图片描述

import turtle
Bob = turtle.Turtle()
Bob.pencolor("red")
Bob.forward(200)
Bob.left(120)	
Bob.forward(200)
Bob.left(120)	
Bob.forward(200)
Bob.right(180)

Bob.forward(100)

Bob.begin_fill()
Bob.fillcolor("yellow")
Bob.right(60)
Bob.pencolor("blue")
Bob.forward(100)
Bob.right(120)
Bob.forward(100)
Bob.right(120)
Bob.forward(100)
Bob.penup()
Bob.end_fill()

第三关
编写程序导入turtle库，并画出如图所示的等边三角形。最外面三角形边长为200，三边颜色为红色，次外面的三角形边长为100，三边颜色为蓝色，填充颜色为黄色；最里面的三角形三边长度为50，颜色为红色，填充颜色为白色。
在这里插入图片描述

代码如下:

import turtle
Bob = turtle.Turtle()
Bob.pencolor("red")
Bob.forward(200)
Bob.left(120)	
Bob.forward(200)
Bob.left(120)	
Bob.forward(200)
Bob.right(180)

Bob.forward(100)

Bob.begin_fill()
Bob.fillcolor("yellow")
Bob.right(60)
Bob.pencolor("blue")
Bob.forward(100)
Bob.right(120)
Bob.forward(100)
Bob.right(120)
Bob.forward(100)
Bob.end_fill()
Bob.left(180)
Bob.forward(50)
Bob.pencolor("red")
Bob.begin_fill()
Bob.fillcolor("white")
Bob.left(60)
Bob.forward(50)
Bob.left(120)
Bob.forward(50)
Bob.left(120)
Bob.forward(50)

Bob.end_fill()

3.Python语言的数据类型

第一关：
在指定的位置编写程序，输入一个字符串，编程实现字符串的反转。
相关知识
序列类型共同的运算及函数表
在这里插入图片描述

代码：

data=input()
# 补全每一步的代码，实现字符串的反转
#第一步，将字符串转换为列表

l=list(data)
#第二步：将列表反转

l.reverse()
#第三步：用join方法返回一个新字符串，该字符串由将反转后的列表的每一个元素组成，元素间用''分割

s="".join(l)
#第四步：输出新的字符串
print(s)

第二关：
任务描述
在指定的位置编写程序，输入一个字符串，编程实现删除字符串中的所有0~9的数字字符。
测试输入：
gc3n4nw9f
预期输出：
gcnnwf

data=str(input())
# 请在下面添加代码
###### Begin ######

for i in range(0,10):
    data=data.replace(str(i),'')
print(data)

第三关：
回文数判断：一个整数，如果将其反向排列后得到的整数和原值相等，则称该数为回文。从键盘输入一个5位数，编写程序判断他是否是一个回文数。
测试输入：
12821
预期输出：
12821是回文数
测试输入：
15821
预期输出：
15821不是回文数
代码：

# coding = utf-8
data=input() #从键盘输入一个5位数
# 请在下面添加代码
###### Begin ######
a=int(data)

b=list(data)
b.reverse()
c=int(''.join(b))
if c==a:
    print("%d是回文数"%a)
else:
    print("%d不是回文数"%a)

4.Python分支结构

第一关：
编写一个能判断输入数字奇偶的小程序。
测试输入：2
预期输出：偶数

测试输入：101
预期输出：奇数

num = int(input(""))
#********* Begin *********#
    # 在此处补全代码
if num%2==0:
    print("偶数")
else:
    print("奇数")

第二关：
编写一个能判断数取值范围的小程序。
输入两个浮点数，如果两个数均在0.0和1.0之间，则输出True，否则输出False。

测试说明
我会对你编写的代码进行测试：

测试输入：0.0 1.0
预期输出：True

测试输入：0.5 0.8
预期输出：True

测试输入：0.9 1.1
预期输出：False

a,b=map(float,input().split())
#********* Begin *********#
    # 在此处补全代码
if   0<=a<=1 and    0<=b<=1:
    print(True)
else : print(False)

第三关：
将RGB格式颜色转换成CMYK格式。
计算机采用不同的格式表示颜色，如数码照片、显示屏的颜色主要采用了RGB格式，指定个颜色分量红色®、绿色(G)、蓝色(B)分别为一个取值范围为0_{255的整数。用于书刊印刷的颜色格式是CMYK格式，指定了各颜色分量青©、品红(M)、黄(Y)和黑(K)分别为一个取值范围为0.0}1.0的实数。

编写程序实现将RGB格式的颜色转换成CMYK格式。输入3个整数分别表示R、G、B的值，输出4个实数，分别表示C、M、Y、K的值。如果RGB的值均为0，则CMY均为0，K为1，否则转换公式如下：
w=max(R/255,G/255,B/255)

C=(w−r/255)/w

M=(w−g/255)/w

Y=(w−b/255)/w

K=1−w

样例输入：

请输入RGB，以空格做间隔:75 0 130

样例输出：
C = 0.423077
M = 1.000000
Y = 0.000000
K = 0.490196

R,G,B=map(float,input().split())

if R == 0  and B == 0 and G == 0:
    C = 0.0
    M = 0.0
    Y = 0.0
    K = 1.0
    print("C = %f\nM = %f\nY = %f\nK = %f" % ( C, M, Y, K ) ,end='')
else:
    w=max(R/255,G/255,B/255)
    
    C=(w-R/255)/w
    M=(w-G/255)/w
    Y=(w-B/255)/w
    K=1-w

    #print(C)
    print("C = %f\nM = %f\nY = %f\nK = %f" % ( C, M, Y, K ) ,end='')

Python循环结构
第一关：
编写一个能输出由符号构成菱形图案的小程序。

import math
row = int( input() )

for i in range(row):
    
    if (i)>row/2:
        print(" "*(1+i*2-row)+"*"+" *"*((row-i-1)*2))
    else:print(" "*(row-1-i*2)+"*"+" *"*(i*2))
#********* End *********#

第二关;
编写一个能输出指定范围内的偶数的小程序。

输入两个整数，两个数作为范围，通过程序输出范围内所有的偶数。

例如：
输入： 1 12，则输出：2,4,6,8,10,12；
输入： -2 10，则输出：-2,0,2,4,6,8,10；
输入： 100 110，则输出：100,102,104,106,108,110 。


begin, end = map( int, input("").split() )
result = []
#********* Begin *********#


if begin%2==0:
    a=begin
else:
    a=begin+1
print(str(a)+",",end='')
for i in range(begin,end):
        a=a+2
        if a+2>end:
            print(str(a),end='')
            break
        else:
            print(str(a)+",",end='')

第三关：
利用小程序输出九九乘法表。

python
for i in range(1,10):
    for j in range(i):
        #********* Begin *********#
        if j==i-1:

            print("%d * %d = %d"%(i,j+1,i*(j+1)),end='')
        else:
            print("%d * %d = %d "%(i,j+1,i*(j+1)),end='')

        #********* End *********#
    if i != 9:
        print()

Python函数
第一关：
编写函数，接收一个十进制整数为参数，返回等值的二进制数。
测试输入：10
预期输出：1010

测试输入：100
预期输出：1100100

def dec_to_bin( number ):
    str1=''
    while(number//2):
       # print(number%2)
        str1=str(number%2)+str1
        number=number//2
    str1="1"+str1
    return str1
    

#********** Begin *********/
    # 在此处补全代码
#********** End **********/
num = int(input())
print( dec_to_bin(num) ,end="")

第二关：
编写一个程序，输入4个整数，要求按由小到大的顺序输出
测试输入：17 1 13 411
预期输出：1,13,17,411

测试输入：112 0 12 -8
预期输出：-8,0,12,112

# -*- coding:utf-8 -*-
def sort(l):
    for i  in range(len(l)):
        
        for j in range(i,len(l)):
            if l[i]>l[j]:
                t=l[i]
                l[i]=l[j]
                l[j]=t
    return l
        
	#********** Begin *********/
    #在此处补全代码
	#********** End **********/
line = input()
l = []
line = line.split()
for i in line:
    l.append(int(i))
l = sort( l )

for index, number in enumerate(l):
    if index != len( l ) -1:
        print(number, end=',')
    else:
        print( number, end='' )

第四关
编写函数，接收一个整数n为参数，打印杨辉三角前n行

def PrintTringle(x):
    '''
    打印杨辉三角，其中利用到的是字符串居中显示，周围填充空格，但是由于不确定得到的结果的长度，所以需要得到整个列表中最大的那个元素，然后计算该元素的长度，利用该长度，为每一个杨辉三角的值进行填充剧中。
    :param x:
    :return:
    '''
    n = 1
    x = int(x)
    # 获取最大的元素，判断列表最大的元素的长度
    if x % 2 == 0:
        max_item = Traingle(x)[int(x/2)]
    else:
        max_item = Traingle(x)[int((x+1)/2)]
    max_length = len(str(max_item))
    while n <= x :
        list = Traingle(n)
        string = ''
        tem = 0
        # 对每一列杨辉三角进行处理，转化成为字符串，拼接
        while tem < len(list):
            if tem == 0:
                string = str(list[tem]).center(max_length)
            else:
                string = string + ' ' + str(list[tem]).center(max_length)
            tem += 1
        # 打印处理，每一列的元素有N个，空格用N+1
        print(string.center((max_length+1)*x-1))
        n += 1