目录

一、从头到尾

题目要求：

1. 从键盘输入一个小于 500 的三位整数
2. 输入不符合条件时需要重新输入
3. 将输入正确的这个整数乘乘以2 得到一个新的数
4. 最后将这个新的数从尾到头倒叙输出

def study_num():
    flag=0
    while flag==0:
        num=int(input("请输入一个小于500的三位数："))
        if 100 <= num < 500:
            num=num*2
            num_str=str(num)  #切片操作可以反转倒序输出内容，但数字类型的变量没有切片操作，可以先将其转化为字符类型进行切片操作
            new_num=num_str[::-1]
            print("这个新的数从尾到头倒叙输出为:",new_num)
        else:
            print("输入的数字不符合条件：请重新输入：")
            flag=0

#调用函数           
study_num()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

二、删除字符

题目要求：

1. 分两行输入两个整数，第一个整数表示字符串 string 的索引开始值 begin_index，第二个整数表示需要删除的长度 length。
2. 将字符串 string 从索引 begin_index 开始，长为 length 的子字符串删除。
3. 输出字符串 string 删除后剩下的部分。

def study_delete_chars():
    orgStr="abfghijklmnopqrstuvwxyz"
    begin_index=int(input("请输入开始位置的索引："))
    length = int(input("请输入要删除的长度："))
    #目前字符串没有删除子字符串的方法
    #这里可以通过字符串的切片操作进行删除
    #可以将题目分解：删除子字符串的前后两段拼接起来就是我们需要得到的
    newStr1=orgStr[0:begin_index]
    newStr2=orgStr[(begin_index+length):]
    newStr=newStr1+newStr2
    print(newStr)

#调用函数  
study_delete_chars()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

三、插入字符

题目要求：

1. 已知字符串orgStr
2. 请将另一个字符串sub添加到字符串orgStr的指定索引位置中
3. 并将添加后的newStr输出

def study_insert_subStr():
    orgStr="abfz"
    sub="我是小明"
    position_index=int(input("请输入需要插入的位置的索引："))
    #因为字符串还没有在指定索引位置插入子字符串的方法
    #但是我们可以通过列表可以在其指定的位置插入元素的的原理来实现题目要求
    #先将原字符串转化为列表进行元素插入，然后再将新的列表转换为字符串
    list1=list(orgStr)
    list1.insert(position_index,sub)
    print(list1,type(list1)) #列表插入，结果：['a', '我是小明', 'b', 'f', 'z'] <class 'list'>
    newStr="".join(list1)
    print(newStr, type(newStr))  # 结果：a我是小明bfz <class 'str'>
    
#调用函数      
study_insert_subStr()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

Python中有.join()和os.path.join()，两个函数，具体作用如下：

• .join()方法: 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串；

• os.path.join()方法： 将多个路径组合后返回；

.join() 对列表进行操作（分别使用’’、’ ’ 、’-’、’:’、’.’等作为分隔符）

a=['1','2','3','4','5']

newStr1="".join(a)
print(newStr1)

newStr2=" ".join(a)
print(newStr2)

newStr3="-".join(a)
print(newStr3)

newStr4=":".join(a)
print(newStr4)

newStr5=".".join(a)
print(newStr5)

newStr6="a".join(a)
print(newStr6)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

运行结果如下：

12345
1 2 3 4 5
1-2-3-4-5
1:2:3:4:5
1.2.3.4.5
1a2a3a4a5

• 1
• 2
• 3
• 4
• 5
• 6

.join() 对字符串进行操作（分别使用’’、’ ’ 、’-’、’:’、’.’等作为分隔符）

orgStr="hello world"
newStr1="".join(orgStr)
print(newStr1)

newStr2=" ".join(orgStr)
print(newStr2)

newStr3="-".join(orgStr)
print(newStr3)

newStr4=":".join(orgStr)
print(newStr4)

newStr5=".".join(orgStr)
print(newStr5)

newStr6="a".join(orgStr)
print(newStr6)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

运行结果如下：

hello world
h e l l o   w o r l d
h-e-l-l-o- -w-o-r-l-d
h:e:l:l:o: :w:o:r:l:d
h.e.l.l.o. .w.o.r.l.d
haealalaoa awaoaralad

• 1
• 2
• 3
• 4
• 5
• 6

.join() 对元组进行操作（分别使用’’、’ ’ 、’-’、’:’、’.’等作为分隔符）

tuple1=('1','2','3','4','5')

newStr1="".join(tuple1)
print(newStr1)

newStr2=" ".join(tuple1)
print(newStr2)

newStr3="-".join(tuple1)
print(newStr3)

newStr4=":".join(tuple1)
print(newStr4)

newStr5=".".join(tuple1)
print(newStr5)

newStr6="a".join(tuple1)
print(newStr6)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

运行结果如下：

12345
1 2 3 4 5
1-2-3-4-5
1:2:3:4:5
1.2.3.4.5
1a2a3a4a5

• 1
• 2
• 3
• 4
• 5
• 6

.join() 对字典进行无序操作（分别使用’’、’ ’ 、’-’、’:’、’.’等作为分隔符）

dicc={'name1':'a','name2':'b','name3':'c','name4':'d'}

newStr1="".join(dicc)
print(newStr1)

newStr2=" ".join(dicc)
print(newStr2)

newStr3="-".join(dicc)
print(newStr3)

newStr4=":".join(dicc)
print(newStr4)

newStr5=".".join(dicc)
print(newStr5)

newStr6="a".join(dicc)
print(newStr6)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

运行结果如下：

name1name2name3name4
name1 name2 name3 name4
name1-name2-name3-name4
name1:name2:name3:name4
name1.name2.name3.name4
name1aname2aname3aname4

• 1
• 2
• 3
• 4
• 5
• 6

os.path.join() 对目录进行操作

import os
newPath=os.path.join("/home/","good/date/","yuki_dir")
print(newPath)

• 1
• 2
• 3

运行结果如下：

/home/good/date/yuki_dir

• 1

四、过滤敏感字符，并替换

1. 输入一段英文文本 text
2. 将其中出现的敏感词改为***(三个星号)
3. 并将更改后的内容输出

注意：敏感字符包括 “fuck”、“shit”、“bitch”，其他的暂不考虑。

def study_grep_char():
    text=" Oh, fuck! I've lost my keys. Oh, shit! I've lost my keys.Oh, bitch! I've lost my keys."
    text=text.replace("fuck","***")
    text=text.replace("shit","***")
    text=text.replace("bitch","***")
    print(text)
#调用函数  
study_grep_char()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

五、输出九九乘法表

大家小时候都背过乘法表，乘法表是有规律的：  
1x1=1 
1x2=2 2x2=4 
1x3=3 2x3=6 3x3=9
......
......

• 1
• 2
• 3
• 4
• 5
• 6

在这里，你需要在循环里面嵌套一个循环：外面的循环控制行数，里面的循环控制每一行算式的个数。

def study_multiplication_table():
    for line in range(1,10):
        for num in range(1,line+1):
            print("%sx%s=%s"%(num,line,num*line),end=" ")
        print()
        
#调用函数  
study_multiplication_table()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

六、判断星期

题目要求：

1. 每个星期对应的英语单词都不同，星期一到星期天的单词分别为：
   monday、tuesday、wednesday、thursday、friday、saturday、sunday。
2. 请用程序实现：输入单词的前两个字符，判断输入的单词是星期几，并输出对应的单词；如果输入的字符不匹配，则输出error。

第一种方法：

def study_judge_weekday():
    chars = input("请输入单词的前两个字符：")
    if chars=="mo":
        print("monday")
    elif chars=="tu":
        print("tuesday")
    elif chars=="we":
        print("wednesday")
    elif chars=="th":
        print("thursday")
    elif chars=="fr":
        print("friday")
    elif chars=="sa":
        print("saturday")
    elif chars=="su":
        print("sunday")
    else:
        print("error")
 
#调用函数  
study_judge_weekday() 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

第二种方法：

def study_judge_weekday():
    chars = input("请输入单词的前两个字符：")
    weekday_dicc={"mo":"monday","tu":"tuesday","we":"wednesday","th":"thursday","fr":"friday","sa":"saturday","su":"sunday"}
    if weekday_dicc.get(chars) is None:
        print("error", weekday_dicc.get(chars))
    else:
        print(weekday_dicc.get(chars))
        
#调用函数  
study_judge_weekday()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

七、判断位数并打印各位的值

题目要求：

1. 输入一个不多于五位的正整数num
2. 求出它是几位数，将结果输出
3. 并将每一位的数字都打印出来

注意: 位数和每位的数字分两行打印。

第一种方法：

def study_judge_num_length():
    num=int(input("请输入一个不多于五位的正整数："))
    #数字类型的变量没有求长度的方法，也不能通过索引求索引位置所在的内容，可以先将其转化为字符类型进行求长度操作
    numStr=str(num)
    length=len(numStr)
    print("这个数的位数是%s"%(length))
    for i in range(0,length):
        print("这是第%s位数，这位数的值是%s"%(i+1),numStr[i])
        
#调用函数         
study_judge_num_length() 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

第二种方法：

def study_judge_num_length():
    num=int(input("请输入一个不多于五位的正整数："))
    #数字类型的变量没有求长度的方法，也不能通过索引求索引位置所在的内容，可以先将其转化为字符类型进行求长度操作
    numStr=str(num)
    dicc={1:"一",2:"二",3:"三",4:"四",5:"五"}
    length=len(numStr)
    print("这个数是%s位数"%dicc[length])
    for i in numStr:
        print(i,end=" ")

#调用函数         
study_judge_num_length() 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

八、猴子摘桃

题目要求：

1. 一只猴子摘桃子, 第一天摘了两个桃
2. 以后每天摘的是前一天的两倍还多一个
3. 输入一个天数day，计算第day天它摘的个数，并将结果输出
4. 再计算出第day天过后，他摘得桃子的总个数，并将结果输出

def study_momkey_get_picth():

    day=int(input("请输入猴子摘桃的天数(猴子摘桃天数必须大于等于1天)："))
    start_num=2
    sum=0
    for i in range(1,day+1):
        if i==1:
            peach_num=start_num
            print("这是第%s天摘桃子,今天摘到的桃子个数是%s个" % (i, peach_num))
        else:
            peach_num=peach_num*2+1
            print("这是第%s天摘桃子,今天摘到的桃子个数是%s个" % (i, peach_num))
        sum=sum+peach_num
    print("到第%s天,猴子一共摘到桃子数目为%s个" % (day, sum))


#调用函数
study_momkey_get_picth()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

九、单词转换

1. 输入一段英文文本 text

2. 将文本中的单词分别按照 全部小写、全部大写 和 标题化 格式输出。

   全部小写: beautiful is better than ugly.
   全部大写: BEAUTIFUL IS BETTER THAN UGLY.
   标题化: Beautiful Is Better Than Ugly.

提示：使用字符串的内建函数。

def study_upper_lower():
    text=" Beautiful is better than ugly."
    print("全部小写:%s"%(text.lower()))
    print("全部大写:%s"%(text.upper()))
    print("标题化:%s"%(text.title()))

#调用函数
study_upper_lower()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

十、杨辉三角

杨辉三角，又称贾宪三角形、帕斯卡三角形，是二项式系数在三角形中的一种几何排列。

以下是杨辉三角的前十行：

由上可以看出：

1. 每行端点与结尾的数为 1
2. 每个数等于它上方两数之和
3. 每行数字左右对称，且由 1 开始逐渐变大
4. 第 n 行的数字有 n 项