python基础训练100题,python入门100例题

2401_86114846

于 2024-07-02 13:20:17 发布

阅读量867

点赞数 8

分类专栏： paperbert 文章标签：算法

本文链接：https://blog.csdn.net/2401_86114846/article/details/140124256

版权

paperbert 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

这篇文章主要介绍了python基础训练100题，具有一定借鉴价值，需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获，下面让小编带着大家一起了解一下。

一、字符串（知识点）

HJ1 字符串最后一个单词的长度（简单）

HJ2 计算某字符出现次数（简单）

HJ4 字符串分隔（简单）

HJ5 进制转换（简单）

HJ10 字符个数统计（简单）

HJ11 数字颠倒（简单）

HJ12 字符串反转（简单）

HJ14 字符串排序（简单）

HJ17 坐标移动（中等）

HJ18 识别有效的IP地址和掩码并进行分类统计（较难）

自己研究的题解，也有借鉴评论区牛人思路，答案不唯一，仅供学习参考，也欢迎大家指出问题，共同学习

一、字符串（知识点）

HJ1 字符串最后一个单词的长度（简单）

描述

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000宿迁趣品网络。（注：字符串末尾不以空格为结尾）

输入描述：

输入一行，代表要计算的字符串，非空，长度小于5000。

输出描述：

输出一个整数，表示输入字符串最后一个单词的长度。

示例1

输入：hello nowcoder

输出：8

说明：最后一个单词为nowcoder，长度为8

import sys

a = input().split()
print(len(a[-1]))

分析：利用split将字符串按空格拆分成一个列表，再利用len和[-1]取最后一个字符串的长度。

HJ2 计算某字符出现次数（简单）

描述

写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）

数据范围：1≤n≤1000

输入描述：

第一行输入一个由字母、数字和空格组成的字符串，第二行输入一个字符（保证该字符不为格）。

输出描述：

输出输入字符串中含有该字符的个数。（不区分大小写字母）

示例1

输入：ABCabc

输出：2

import sys

st1 = input().lower()
st2 = input().lower()
print(st1.count(st2))

分析：将两次输入都小写化（lower），以至于不用区分大小写，再利用st1.count(st2)，意为st2在st1中的个数。

HJ4 字符串分隔（简单）

描述

输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；

长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。

输入描述：

连续输入字符串(每个字符串长度小于等于100)

输出描述：

依次输出所有分割后的长度为8的新字符串

示例1

输入：abc

输出：abc00000

import sys

#   :0<8s  格式左对齐 右补0 输出8个字符串
while True:
    try:
        l = input()
        for i in range(0, len(l), 8):  #间隔8
            print("{:0<8s}".format(l[i:i+8]))
    except:
        break

分析：主要利用一个循环，遍历每8个字符的开头，为了输出0-8,8-16……，补0利用初始化函数format，:0<8s意为左对齐右补0, 输出8个字符。（利用while和try的意图在于可以循环输入，直到输入一个非十六进制数，退出并且不会报错）

HJ5 进制转换（简单）

描述

写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。

数据范围：保证结果在 1≤n≤2**31−1

输入描述：

输入一个十六进制的数值字符串。

输出描述：

输出该数值的十进制字符串。不同组的测试用例用\n隔开。

示例1

输入：0xAA

输出：170

import sys

while True:
    try:
        a = input()
        print(int(a,16))
    except:
        break

分析：利用int()将其他进制转换为十进制--->int(a,16)十六进制转换为十进制，int（a,8）八进制转换为十进制，int(a,2)二进制转换为十进制。bin(a)将其他进制转换为二进制。

HJ10 字符个数统计（简单）

描述

编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次

例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。

数据范围：1≤n≤500

输入描述：

输入一行没有空格的字符串。

输出描述：

输出输入字符串中范围在(0~127，包括0和127)字符的种数。

示例1

输入：abc

输出：3

示例2

输入：aaa

输出：1

str = input()
lst = set(str)
print(len(lst))

分析：利用集合的不重复性，将字符串类型转换为集合类型，集合的长度即不同元素的数量。

HJ11 数字颠倒（简单）

描述

输入一个整数，将这个整数以字符串的形式逆序输出

程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

数据范围： 0≤n≤2**30−1

输入描述：

输入一个int整数

输出描述：

将这个整数以字符串的形式逆序输出

示例1

输入：1516000

输出：0006151

示例2

输入：0

输出：0

a = input()
b = a[::-1]
print(b)

分析：利用Python自带的切片逻辑实现逆序输出。

HJ12 字符串反转（简单）

描述

接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述：

输入一行，为一个只包含小写字母的字符串。

输出描述：

输出该字符串反转后的字符串。

示例1

输入：abcd

输出：dcba

while True:
    try:
        str = input()
        for i in str:
            # islower()判断字符串中是否含有一个小写字母，所以利用循环逐个判断
            if not i.islower():  
                break  # 如果有一个不为小写字母，则重新输入
        if i.islower():  # 如果最后一个i为小写字母，那么代表全都为小写字母，则逆序输出
            print(str[::-1])
    except:
        break

分析：for循环逐个判断字符串是否为小写字母（利用islower()），有一个不是则重新输入，全部都是则逆序输出。

HJ14 字符串排序（简单）

描述

给定 n 个字符串，请对 n 个字符串按照字典序排列。

数据范围：1≤n≤1000 ，字符串长度满足 1≤len≤100

输入描述：

输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。

输出描述：

数据输出n行，输出结果为按照字典序排列的字符串。

示例1

输入：

9
cap
to
cat
card
two
too
up
boat
boot

输出：

boat
boot
cap
card
cat
to
too
two
up

# 法一：
n = int(input())
list = []
for i in range(n):
    str = input()  # 一行一行输入字符串
    list.append(str)  # 添加成列表
()  # 将列表里的字符串排序
for j in list:
    print(j)  # 一行一行输出字符串

# 法二：
n = int(input())
list = []
for i in range(n):
    list.append(input())
print("\n".join(sorted(list)))

分析：利用列表sort（）排序，可以指定比较的形式和顺序，没有返回值。join（）用指定的字符连接列表元素。

HJ17 坐标移动（中等）

描述

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

输入：

合法坐标为A(或者D或者W或者S) + 数字（两位以内）

坐标之间以;分隔。

非法坐标点需要进行丢弃。如AA10; A1A; $%$; YAD; 等。

下面是一个简单的例子如：

A10;S20;W10;D30;X;A1A;B10A11;;A10;

处理过程：

起点（0,0）

+ A10 = （-10,0）

+ S20 = (-10,-20)

+ W10 = (-10,-10)

+ D30 = (20,-10)

+ x = 无效

+ A1A = 无效

+ B10A11 = 无效

+ 一个空不影响

+ A10 = (10,-10)

结果（10， -10）

数据范围：每组输入的字符串长度满足 1≤n≤10000 ，坐标保证满足 −2**31≤x, y≤2**31−1 ，且数字部分仅含正数

输入描述：

一行字符串

输出描述：

最终坐标，以逗号分隔

示例1

输入：A10;S20;W10;D30;X;A1A;B10A11;;A10;

输出：10,-10

示例2

输入：ABC;AKL;DA1;

输出：0,0

str = input()
list = str.split(";")  # 按分隔符分割字符串，返回列表
x = 0
y = 0
for i in list:
    # 如果不满足2、3的长度就跳过（满足：A11）
    if len(i) not in [2, 3]:
        continue
    try:  #避免类型转换错误，如果不能转换就跳转到except，直接pass
        direction = i[0].lower()
        step = int(i[1:])

        # 判断每个操作的长度是否合规、是否为空、方向是否正确
        if i != '' and direction in ['a', 'd', 's', 'w']:
            if direction == 'a':
                x -= step
            elif direction == 'd':
                x += step
            elif direction == 's':
                y -= step
            elif direction == 'w':
                y += step
    except:
        continue  # 如果异常就跳过这条
print(f'{x},{y}')

分析：抓住过滤的条件，非空、字符串长度、以asdw开头，借助异常捕获筛掉后两位不为数字的字符串。

HJ18 识别有效的IP地址和掩码并进行分类统计（较难）

描述

请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址从1.0.0.0到126.255.255.255;

B类地址从128.0.0.0到191.255.255.255;

C类地址从192.0.0.0到223.255.255.255;

D类地址从224.0.0.0到239.255.255.255；

E类地址从240.0.0.0到255.255.255.255

私网IP范围是：

从10.0.0.0到10.255.255.255

从172.16.0.0到172.31.255.255

从192.168.0.0到192.168.255.255

子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）

（注意二进制下全是1或者全是0均为非法子网掩码）

注意：

1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略

2. 私有IP地址和A,B,C,D,E类地址是不冲突的

输入描述：

多行字符串。每行一个IP地址和掩码，用~隔开。

请参考帖子处理循环输入的问题。

输出描述：

统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

示例1

输入：

10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19..0.~255.255.255.0

输出：

1 0 1 0 0 2 1

说明：

10.70.44.68~255.254.255.0的子网掩码非法，19..0.~255.255.255.0的IP地址非法，所以错误IP地址或错误掩码的计数为2；
1.0.0.1~255.0.0.0是无误的A类地址；
192.168.0.2~255.255.255.0是无误的C类地址且是私有IP；
所以最终的结果为1 0 1 0 0 2 1

示例2

输入：

0.201.56.50~255.255.111.255
127.201.56.50~255.255.111.255

输出：

0 0 0 0 0 0 0

说明：

类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略

# HJ18 识别有效的IP地址和掩码并进行分类统计
import sys


# 检查IP是否合规，不合规返回false
def check_ip(ip):
    # 先划分部位
    ip_list = ip.split('.')
    # ip长度有4位，且每一位不为空，不满足条件就返回FALSE
    if len(ip_list) != 4 or '' in ip_list:
        return False
    # 遍历每一位，判断范围是否属于0-255（最基本的规则）
    for i in ip_list:
        try:  # 如果输入非数字，异常->FALSE不合规
            if int(i) < 0 or int(i) > 255:  # 不属于这个范围的就返回FALSE
                return False
        except:
            return False
    return True


# 检查掩码是否合规，不合规返回false
def check_mask(mask):
    # 先判断掩码是否合规（按IP的方法）
    if not check_ip(mask):
        return False
    # 全255和全0的都视为非法
    if mask == '255.255.255.255' or mask == '0.0.0.0':
        return False
    # 划分掩码部位，将每部分都转化为二进制
    mask_list = mask.split('.')
    mask_bit = []
    for i in mask_list:
        try:
            j = bin(int(i))[2:]  # 每段都转换为二进制(j:'ob11111111')，所以还要去掉前面两个二进制前缀'ob'
            mask_bit.append(j.zfill(8))  # zfill(n)返回n个长度的字符串，右对齐，左填充0
        except:
            return False
    whole_mask = ''.join(mask_bit)  # 将4段二进制连接起来的字符串
    # 查第一个0的位置
    whole_find_0 = ('0')
    # 查最后一个1的位置
    whole_rfind_1 = whole_mask.rfind('1')
    # 如果最后一个1之后就是第一个0的位置，则表示0前面都是1，掩码合规
    if whole_rfind_1 + 1 == whole_find_0:
        return True
    else:
        return False


# 检查IP分类是否为私网（已经满足IP规格）
def check_private_ip(ip):
    try:
        # 划分部位
        ip_list = ip.split('.')
        if ip_list[0] == '10':
            return True
        elif ip_list[0] == '172' and 16 <= int(ip_list[1]) <= 31:
            return True
        elif ip_list[0] == '192' and ip_list[1] == '168':
            return True
        else:
            return False
    except:
        return False


ip_class_dic = {
    'a': 0,
    'b': 0,
    'c': 0,
    'd': 0,
    'e': 0,
    'error': 0,
    'private': 0
}

# 从标准输入读取多行数据，直到遇到EOF结束标志(ctrl+D结束输入)，可在控制台与用户交互并读取用户的输入
for line in sys.stdin:  # 输入一行读一行，如果输入有异常(不满足输入格式的话，例如没有掩码）则结束循环输入
    try:  # 如果出现异常则结束循环（结束输入）
        ip = line.split('~')[0]  # IP
        mask = line.split('~')[1]  # 掩码（此时会将换行符\n算进来，但没关系，后面是用数字计算的）

        # 1.1先判断IP地址是否合规
        if check_ip(ip):
            # 2.1如果合规就按第一部分进行分类
            first = int(ip.split('.')[0])
            # 2.2这两个不计
            if first == 0 or first == 127:
                continue  # 表示进行下一个输入
            # 2.3再判断掩码是否合规，如果掩码也合规，则判断IP类型
            if check_mask(mask):
                # 3.1先判断是否为私有IP（必须判断），是则私网+1
                if check_private_ip(ip):
                    ip_class_dic['private'] += 1
                # 3.2再判断是abcde类型中的哪种（必须判断）
                if 0 < first < 127:
                    ip_class_dic['a'] += 1
                elif 127 < first <= 191:
                    ip_class_dic['b'] += 1
                elif 192 <= first <= 223:
                    ip_class_dic['c'] += 1
                elif 224 <= first <= 239:
                    ip_class_dic['d'] += 1
                elif 240 <= first <= 255:
                    ip_class_dic['e'] += 1
            # 2.4如果（IP合规）掩码不合规，则error+1
            else:
                ip_class_dic['error'] += 1
        # 1.2如果IP不合规，则error+1
        else:
            ip_class_dic['error'] += 1
    except:
        break

# 最后将字典里的值循环输出
for i in ip_class_dic.values():
    print(i, end=' ')

分析：（该题较难，掌握字符串的基本应用即可。）

主要思路：循环输入，分割变量，判断ip、掩码、私网、类型

1.检查是否符合ip规格，否->error+1，是则2，不计直接continue

2.检查是否符合掩码规格，否->error+1，是则3

3.判断是否私网，判断是哪个类型的地址。（分别判断）否->error+1

4.用字典来表示变量

注：ip和掩码都符合规格才算是合法地址，才分类，有一个不符合规格就是非法+1（先判断ip，不合法直接error+1，如果ip合法，再判断掩码，掩码不合法直接error+1，如果掩码合法，再看ip地址是属于哪个类型）

拓展：sys.stdin和文件读取的区别

# 读取普通文件
with open('data'.txt) as f:
    lines = f.readlines()
    for line in lines:
        print(line)


# 读取标准输入
import sys

for line in sys.stdin:  # 循环读取，输入一行读一行
    print(line)

for line in sys.stdin.readlines():  # 输入一堆文本，一行一行读
    print(line)

原文地址1：https://blog.csdn.net/weixin_51754286/article/details/134668942
参考资料：python中用turtle画一个圆形 https://blog.csdn.net/SXIAOYAN_/article/details/140061099

2401_86114846

关注

8
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
python基础训练100题,python入门100例题

描述计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000宿迁趣品网络。（注：字符串末尾不以空格为结尾）输入一行，代表要计算的字符串，非空，长度小于5000。输出一个整数，表示输入字符串最后一个单词的长度。示例1输入：hello nowcoder输出：8说明：最后一个单词为nowcoder，长度为8import sys分析：利用split将字符串按空格拆分成一个列表，再利用len和[-1]取最后一个字符串的长度。
复制链接

扫一扫