Python基础百题，做时老遭罪了，做完老厉害了【持续更新】

原创已于 2025-05-04 23:21:45 修改 · 304 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2025-04-16 11:32:25 首次发布

人工智能、大模型是为未来，且未来已经到来。Python是大模型的基础语言之一，不可不学。所谓基础坚实与否，决定能去得到的高度，不可不重视。操练起来吧兄弟们。

1.兔子繁殖

有一对兔子，出生后第3个月起，每个月生一对兔子。小兔子长到第三个月又开始生兔子。
假设兔子不死，每个月兔子总数是多少.

#典型的斐波那契。第n个月时，兔子对数
def pairs_of_rabbit(n):
    if 1<=n<=2:
        return 1
    a,b = 1,1
    for _ in range(3,n+1):
        a,b = b,a+b
    return b

n = int(input("输入第N个月\n"))
print(f"第{n}个月一共有{pairs_of_rabbit(n)}对兔子")

扩展：如果兔子从第4个月开始生小兔子呢？

那就是非典型的斐波那契，但依然可以采用类似斐波那契的算法。

def pairs_of_rabbit(n):
    if 1<=n<=3:
        return 1
    a,b = 1,1
    for _ in range(4,n+1):
        a,b = b,a+b
    return b

n = int(input("输入第N个月\n"))
print(f"第{n}个月一共有{pairs_of_rabbit(n)}对兔子")

2.求素数

打印100-200之间的素数，并输出素数的个数。

#素数者，除1和自身之外，不可被其他自然数整数。素数有且只有2个正因数。1不是素数，2是素数。
#艾拉托斯特尼筛选法
def is_prime(n):
    if n<=1:
        return False
    if n<=3:
        return True
    if n%2==0 or n%3==0:
        return False
    loop = 5
    while loop*loop<=n:
        #除2以外，所有的偶数都不是素数，只需要检查奇数，所以loop+2
        if n%loop==0 or n%(loop+2)==0:
            return False
        #保持loop始终是奇数
        loop += 6
    return True

cnt = 0
print("素数如下：")
for loop in range(100,201):
    if is_prime(loop):
        cnt += 1
        print(loop,end='\t')
print(f"\n素数的总个数为{cnt}")

3.整数的质因数分解

分解质因数。
将一个整数分解成质数（也就是素数）的乘积。比如90=2*3*3*5
"""
解题思路：
1、从最小的质数2开始
2、判断整数是否能整除该质数，如果能，记录该质数，并进行整数获得商
3、用得到的商重复步骤2，直到新的商不能整除
4、移动到下一个质数，重复步骤2、3
5、商为1，流程结束
"""

def is_prime(n):
    if n==1:
        return False
    if n==2 or n==3:
        return True
    if n%2==0 or n%3==0:
        return False
    loop = 5
    while loop*loop<=n:
        if n%loop==0 or n%(loop+2)==0:
            return False
        loop += 6
    return True

n = int(input("输入一个正整数:\n"))
tmp = n  #tmp如果最终等于1，则完成循环
result = []
for loop in range(2,n+1):
    if is_prime(loop):
        while tmp%loop==0:
            result.append(loop)
            tmp /= loop
    if tmp == 1:
        break
print(f"{n}={'*'.join(map(str,result))}")

4.统计字符数量

输入一行字符，统计出英文字母、空格、数字和其他字符的个数

str1 = input("输入一行字符串:\n")
num_of_alp = 0 #英文字母个数
num_of_dig = 0 #数字个数
num_of_bla = 0 #空格个数
num_of_oth = 0 #其他字符个数
for char1 in str1:
    if char1.isdigit():
        num_of_dig += 1
    elif char1.isalpha():
        num_of_alp += 1
    elif char1.isspace():
        num_of_bla += 1
    else:
        num_of_oth += 1
print(f"英文字母个数为：{num_of_alp}")
print(f"空格个数为：{num_of_bla}")
print(f"数字个数为：{num_of_dig}")
print(f"其他字符个数为：{num_of_oth}")

5.b个a相加

分别输入两个字符a和b，显示s=a+aa+aaa+...+aa(b个a)

a,b = map(str,input().strip().split())
result = []  #用于存储最后的表达式中的每个成分
len1 = int(b)
loop = 1
tmp = a #用于循环内拼接新的字符串
while loop<=len1:
    result.append(tmp)
    tmp += a
    loop += 1
print(f"s={'+'.join(result)}")

6.求完数

完数者，一个正整数，如果等于除了自身之外的因子之和，则称之为完数，比如6=1+2+3
求一千以内的全部完数。

#计算正整数n的所有因子之和
def sum_of_factor(n):
    sum1 = 1
    #为了减少循环的次数，所以终点设置成n的平方根。
    #后续在进行因子加和时，除了加正序的因子，同时也需要加倒序的因子
    #倒序的因子在根号之后
    for loop in range(2,int(n**0.5)+1):
        if n%loop==0:
            sum1 += loop
            #1000以内不会出现这种情况，但是这部分逻辑需要有
            if loop != n//loop:
                sum1 += n//loop
    return sum1

result = []
for loop in range(2,1001):
    if loop == sum_of_factor(loop):
        result.append(loop)
print(f"1千以内的完数为：{' '.join(map(str,result))}")

7.皮球反弹

一个球从100米高处落下，反弹后到原来高度的一半。再落下，再反弹。在第十次落地时，
球一共经过了多少米。第十次反弹多高。
思考：第一次下落单独计算。第一次反弹和第二次下落的路径长度一致，一起计算。
以此类推。

def total_len(ini_height,bounce_num):
    tot_len = ini_height  #第一次落地的路径长度
    current_height = ini_height  #第n次落地前的高度
    for _ in range(1,bounce_num):
        current_height /= 2
        tot_len += current_height*2
    #第一次反弹，高度为初始值的一半
    #第二次反弹，高度为初始值一半的一半，即初始值/(2的平方)
    #第三次反弹，高度为初始值一半的一半的一半，即初始值/(2的立方)
    final_height = ini_height/(2**bounce_num)
    return tot_len,final_height

print(total_len(100,10))

8.猴子吃桃

猴子第一天摘下若干个桃子，吃了一半+1个。
第二天吃了剩下的桃子的一半+1个。
以此类推。
第10天时，还没吃，只剩下一个桃子。
问第一天摘下来多少个桃子。

#思考：第10天没吃前，还剩一个，说明第9天吃完，剩一个
#第8天吃完，剩(1+1)*2=4个
#第7天吃完，剩(4+1)*2=10个
#依次循环，第一天吃完，共循环8次。算上第一天吃之前，共循环9次
result = 1
for _ in range(9):
    result = (result+1)*2
print(result)

9.两队比赛

两队比赛。甲队abc，乙队xyz
a不跟x比
c不跟xz比
给出比赛名单

team1 = ['a','b','c']
team2 = ['x','y','z']
result = []
for name1 in team1:
    for name2 in team2:
        if name1 == 'a' and name2 == 'x':
            continue
        if name1 == 'c' and (name2 == 'x' or name2 == 'z'):
            continue
        result.append(dict(zip(name1,name2)))

print(result)

扩展：如果双方每位队员都需要上场比赛，且每位队员只参与一次比赛，应如何实现？

10. 实现单例模式

class Singleton:
    _instance = None  #用于保存对象的内存地址，也就是引用。
                      # 且这是类属性，只会在类定义时被初始化一次。
    # 类属性属于类，不属于某个实例
    #print("_instance的值为：",_instance)

    def __new__(cls, *args, **kwargs):
        print("执行new，创建实例")
        if not cls._instance:
            cls._instance = super().__new__(cls)  #保存新创建的实例的内存地址
        return cls._instance

    def __init__(self,value):
        print("执行init，初始化实例的属性")
        self.value = value

#创建第一个对象s1
s1 = Singleton(10)
print(f"s1={s1}")
print(f"s1的value={s1.value}")
print()
"""输出
执行new，创建实例
执行init，初始化实例的属性
s1=<__main__.Singleton object at 0x000001EDBF967E00>
s1的value=10
"""
#创建第二个对象s2
s2 = Singleton(20)
print(f"s2={s2}")
print(f"s2的value={s2.value}")
print(s1.value)
"""输出
执行new，创建实例
执行init，初始化实例的属性
s2=<__main__.Singleton object at 0x000001EDBF967E00>
s2的value=20
20
"""

11.实现一个自定义的可迭代对象

class MyIterable:
    def __init__(self,data):
        self.data = data

    def __iter__(self):
        return MyIterator(self.data)

class MyIterator:
    def __init__(self,data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

#my_iterable = MyIterable(1)
#注意，这种实例化是错误的，因为int类型没有len()。

my_iterable = MyIterable('asdf')

for item in my_iterable:
    print(item)

"""
输出：
a
s
d
f
"""

扩展：定义一个可迭代对象类MyIterable类，是否一定要配套定义一个迭代器对象类？

答案是否定的。可以有另外两种不显示定义迭代器对象类的方法：

class MyIterable:
    def __init__(self,data):
        self.data = data

    #使用生成器。生成器是一个特殊的迭代器，通过yield生成值
    def __iter__(self):
        for item in self.data:
            yield item


#my_iterable = MyIterable(1)
#注意，这种实例化是错误的，因为int对象不是可迭代的

my_iterable = MyIterable('asdf')

for item in my_iterable:
    print(item)

class MyIterable:
    def __init__(self,data):
        self.data = data

    #直接返回一个已经存在的迭代器
    def __iter__(self):
        return iter(self.data)


#my_iterable = MyIterable(1)
#注意，这种实例化是错误的，因为int对象不是可迭代的

my_iterable = MyIterable('asdf')

for item in my_iterable:
    print(item)

12.实现与门，与非门，或门

w1, w2, theta = 0.5, 0.5, 0.7

def and_gate(x1,x2):
    tmp = x1*w1 + x2*w2
    if tmp <= theta:
        return 0
    else:
        return 1

def not_and_gate(x1,x2):
    tmp = x1*w1 + x2*w2
    if tmp <= theta:
        return 1
    else:
        return 0

def or_gate(x1,x2):
    w1, w2, theta = 0.5, 0.5, 0.4
    tmp = x1*w1 + x2*w2
    if tmp > theta:
        return 1
    else:
        return 0

print(or_gate(0,0))
print(or_gate(1,0))
print(or_gate(0,1))
print(or_gate(1,1))

标签