python基础面试编程题汇总+个人练习（入门+结构+函数+面向对象编程）--需要自取

该Python程序包含多个功能模块，主要涵盖以下内容：
**基础计算功能：**数字处理函数（读取数字、计算平均值）文件操作（读写、追加、定位）数学计算（圆面积、周长、闰年判断）

**实用工具：**随机密码生成器质数判断文件统计（行数、单词数、字符数）

**面向对象编程：**学生管理系统（Student和ClassManage类）银行账户系统（BankAccount和User类）游戏角色系统（Role基类和多个子类）电商订单系统（Product、OrderItem和Order类）

**高级特性：**继承与多态私有属性封装异常处理列表推导式匿名函数
程序展示了Python在数据处理、文件操作和面向对象编程方面的综合应用，包含完整的测试用例和错误处理机制。
复制代码
#average_calculator.py（Python 基础 + 函数与模块+面向对象）
import random

from Python文件.课堂编程习题1 import student


#编写函数读取数字、计算平均值，处理异常（如非数字输入）
def read_1(numbers):
    txt1=[]
    for i in numbers:
        try:
            txt1.append(float(i))
        except ValueError:
            print(f"跳过无效数字：{i} ")
    return txt1

def ave_num(numbers):
    if not numbers:
        #向终端返回值
        raise ValueError("没有有效数字")
    return sum(numbers)/len(numbers)#sum()求和函数      #len()长度函数


if __name__=="__main__":
    txt1=["10","20","30","asd","40"]
    #txt1 = ["10", "20", "30", "40"]
    read_1=read_1(txt1)
    try:
        qw=ave_num(read_1)
        print(f"有效值:{read_1}")
        print(f"平均值{qw}")

    except ValueError as e:
        print(e)


#文件读取
with open("numbers.txt","r",encoding="utf-8") as file1:
    content=file1.read()
    print(content)

#读取其中一行
with open("numbers.txt",'r',encoding="utf-8")as file1:
    line1=file1.readline()
    print(line1)

#读取其中所以内容
with open("numbers.txt",'r',encoding="utf-8")as file1:
    line1=file1.readlines()
    for i in line1:
        print(i.strip())# 去除换行符


# 逐行读取（内存友好，适合大文件）
with open("numbers.txt", "r", encoding="utf-8") as file:
    for line in file:  # 文件对象是可迭代的
        print(line.strip())

# 写入模式会覆盖现有内容
with open("numbers.txt", "w", encoding="utf-8") as file:
    file.write("hhdsdch\n")
    file.write("Hello, World!\n")
    file.write("This is a test file.\n")

#写入多行
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("numbers.txt", "w", encoding="utf-8") as file:
    file.writelines(lines)  # 写入列表中的所有字符串
try:
    #文件追加操作
    with open("numbers.txt", "a", encoding="utf-8") as file:
        file.write("This is appended content.\n")
        file.write("One more line.\n")
except FileNotFoundError:
    print("文件不存在")
    pass

except Exception:
    pass

#文件定位操作
with open("numbers.txt", "r", encoding="utf-8") as file:
    file.seek(0)  # 移动到文件开头
    content = file.read()
    file.seek(5)  # 移动到第6个字符位置
    print(file.tell()) # 获取当前位置
    content_part = file.read(10)  # 读取10个字符
    # file.seek(10)
    # print(file.tell())
    # print(file.read(20))

import os

if os.path.exists("numbers.txt"):
    print("文件存在")
else:
    print("not exists")

#圆的面积
pi=3.1415926
def A(R):
    return pi*R*R

#圆的周长
def B(R):
    return 2*pi*R
print(A(9.0))
print(B(9.0))

#闰年
def C(year):
    if year%4==0 and year%100!=0 and year%400==0:
        return True
    return False
print(C(2026))

#将列表写入文件
list_1=["1\n","2\n","3\n","4\n"]
with open("numbers.txt","w",encoding="utf-8")as file:
    file.writelines(list_1)

num=0
#读取并算平均
with open("numbers.txt","r",encoding="utf-8")as file:
    for i in file:
      num+=int(i)

    print(num)

#生成指定大小长度的随机密码
import string
import random

#数字+大小字母
password=string.digits+string.ascii_letters
pass1=''.join(random.choice(password) for i in range(10))
print(pass1)

#数字+大小字母+特殊符号
password =string.ascii_letters+string.digits+string.punctuation
pass1=''.join(random.choice(password)for i in range(30))
print(pass1)

i=0
if i%2==0:print("偶")
else: print("奇")

#列表反转
list1=[1,2,3,4,5,6]
print(list1[::-1])
print(sum(list1))
print(len(list1))


#质数打印
import math
for i in range(2,100):
    num=0
    for ii in range(2,int(math.sqrt(i)+1)):
       if i%ii==0:
           num=1
    if num==0:
        print(i,end=" ")


# 读取一个文本文件data.txt，统计文件中包含的行数、单词数和字符数，并输出结果。
# 提示： 可以使用readlines()方法读取文件的每一行。
line_count=0
word_count=0
char_count=0
with open("numbers.txt","r",encoding="utf-8")as file:
    for i in file:
        line_count+=1
        char_count+=len(i)

        #统计单词
        words=i.strip().split()
        word_count+=len(words)

#i.strip()：清理字符串首尾的空白
#.split()： 按空白分割字符串为列表

#匿名函数
q=lambda x:x**2
qq=lambda x:x**2
print(q(3))

import time
#时间戳
print(time.time())
#时间格式化
print(time.strftime("%Y-%m-%d %H-%M-%S"))
#输出：2026-01-21 13-42-29

#编写一个Python函数，接收一个整数列表，并返回该列表中所有奇数的平方值组成的新列表。
def vip(vip_1):
    return [x**2 for x in vip_1 if x%2!=0]

print(vip([1,2,3,4,5,6]))

#编写一个Python程序，定义一个函数，该函数能够接收任意数量的位置参数并输出它们的和。函数使用*args来接受多个位置参数。指针类型
def sum_(*a):
    return sum(a)
print(sum_(1,2,3,4,5,6))


#定义一个类
class base_1:
    a="swdcwdn"
    def __init__(self,name,age,pass1):
        self.name=name
        self.age=age
        self.__pass=pass1

    def base_show(self):
        print(self.name)
        print(self.age)
        print(self.__pass)

    def __str__(self):
        return [self.age,self.name]

q=base_1("zs",18,123456)
q.base_show()

print(q.name)#可访问
print(q.age)#可访问
#print(q.__pass1)#该位置会报错，不能直接访问，能通过类函数实现私有属性输出

#继承
class dongwu:
    def __init__(self,name):
        self.name=name
    def eat_1(self):
        return f"{self.name}吃东西"

class dog(dongwu):
    def __init__(self,name):
        super().__init__(name) #调用父类初始化函数

    def bark(self):
        return f"{self.name}is barking"

dag1=dog("xy")
print(dag1.name)
print(dag1.bark())
print(dag1.eat_1())

#方法
class myclass:
    #类属性
    class_var="class"
    def __init__(self,app1):
        self.app1=app1

    #类方法
    @classmethod
    def class_method(cls):
        return f"{cls.app1}"

    @staticmethod
    def add_1(a,b):
        return a+b

# 请定义一个父类Vehicle，包含方法describe()，并定义两个子类Car和Bicycle，分别实现describe()方法，输出不同的描述信息。然后创建Car和Bicycle的实例，调用它们的describe()方法。
#
# 示例：
#
# Car输出："这是汽车，四个轮子。"
#
# Bicycle输出："这是自行车，两个轮子。"
class Vehicle:
    def describe(self):
        pass


class Car(Vehicle):
    def describe(self):
        print("这是汽车")
        pass


class Bicycle(Vehicle):
    def describe(self):
        print("这是自行车")
        pass

q1=Car()
q2=Bicycle()

q1.describe()
q2.describe()

# 习题 1：班级管理系统（基础类定义 + 实例管理）
# 题目要求
# 定义Student类：包含属性（学号、姓名、成绩），方法（显示学生信息）；
# 定义ClassManage类：包含属性（班级名称、学生列表），方法（添加学生、删除学生、显示全班信息、计算班级平均分）；
# 测试：创建班级实例，添加 3 个学生，删除 1 个，显示全班信息并计算平均分。
class Student:
    def __init__(self,id,name,score):
        self.id=id
        self.name=name
        self.score=score

    def show_student(self):
        print(f"学生学号{self.id}，学生姓名{self.name}，学生成绩{self.score}")


class classmanage:
    def __init__(self,class_name):
        self.class_name=class_name
        self.student_list=[]

    #add student
    def student_add(self,student):
        if not isinstance(student,Student):
        #if not isinstance(student,Student);
            print("only Student class")
            return

        #学号是否冲突
        for i in self.student_list:
            if i.id==student.id:
                print("id false")
                return
        self.student_list.append(student)

    #delete student
    def delete_student(self,id):
        if not self.student_list:
            print("not students")
            return

        #第一种列表索引
        # for i ,user in enumerate(self.student_list):
        # #for i,user in enmuerate(self.student_liat):
        #     if user.id==id:
        #         del self.student_list[i]
        #         print(f"delete successful{id}")
        #         return

        #第二种列表索引
        for i in self.student_list:
            if i.id==id:
                self.student_list.remove(i)

        print("delete not successful")

    #show all student
    def show_class_name(self):
        if not self.student_list:
            print("not students")
            return
        for x in self.student_list:
            x.show_student()

    #count avg score score score
    def count_score(self):
        if not self.student_list:
            print("not students")
            return
        print((sum(i.score for i in self.student_list)/len(self.student_list)))

#test
if __name__=="__main__":
    banji=classmanage("速成班")
    stu1=Student("10086","zs",100)
    stu2 = Student("14", "ytui", 50)
    stu3 = Student("2", "ztys", 10)
    banji.student_add(stu1)
    banji.student_add(stu2)
    banji.student_add(stu3)

    banji.count_score()
    banji.show_class_name()
    banji.delete_student("2")
    banji.show_class_name()

# 核心知识点
# 类的封装：Student封装学生属性和展示方法，ClassManage封装班级管理逻辑；
# 实例关联：ClassManage的student_list存储Student实例，体现 "组合" 关系；
# 参数校验：isinstance判断实例类型，避免无效数据；
# 列表操作：enumerate遍历带索引，实现按学号删除。
#
#
# 习题 2：银行账户与用户（封装 + 私有属性）
# 题目要求
# 定义BankAccount类：包含私有属性（账户余额），方法（存款、取款、查询余额）；
# 取款时校验余额是否充足，存款 / 取款金额需大于 0；
# 定义User类：包含属性（用户名、身份证号、银行账户），方法（显示用户信息、操作账户）；
# 测试：创建用户和账户，存款 5000，取款 2000，查询余额。

class BankAccount:
    """银行账户类：封装余额（私有属性），提供存款/取款/查余额方法"""
    def __init__(self, initial_balance=0):
        # 私有属性：以双下划线开头，外部无法直接访问
        self.__balance = max(initial_balance, 0)  # 初始余额不能为负

    def deposit(self, amount):
        """存款：金额必须大于0"""
        if amount <= 0:
            print("错误：存款金额必须大于0！")
            return
        self.__balance += amount
        print(f"存款{amount}元成功，当前余额：{self.__balance}元")

    def withdraw(self, amount):
        """取款：金额>0且不超过余额"""
        if amount <= 0:
            print("错误：取款金额必须大于0！")
            return
        if amount > self.__balance:
            print(f"错误：余额不足！当前余额{self.__balance}元，取款{amount}元")
            return
        self.__balance -= amount
        print(f"取款{amount}元成功，当前余额：{self.__balance}元")

    def get_balance(self):
        """提供接口访问私有余额（封装原则：不直接暴露属性）"""
        return self.__balance

class User:
    """用户类：关联银行账户，实现账户操作"""
    def __init__(self, username, id_card, account):
        self.username = username
        self.id_card = id_card
        self.account = account  # 关联BankAccount实例

    def show_user_info(self):
        """显示用户信息和账户余额"""
        print(f"\n【用户信息】")
        print(f"姓名：{self.username}，身份证：{self.id_card}")
        print(f"账户余额：{self.account.get_balance()}元")

# 测试代码
if __name__ == "__main__":
    # 创建银行账户（初始余额0）
    account = BankAccount()
    # 创建用户，关联账户
    user = User("小明", "110101199001011234", account)
    # 存款
    user.account.deposit(5000)
    # 取款
    user.account.withdraw(2000)
    # 尝试取超额
    user.account.withdraw(4000)
    # 显示用户信息
    user.show_user_info()
#
#
# 习题 3：游戏角色转职（继承 + 方法重写 + 多态）
# 题目要求
# 定义基类Role：包含属性（姓名、等级、血量），方法（攻击：默认输出基础攻击）；
# 定义子类Warrior（战士）、Mage（法师）：
# 战士：重写攻击方法（物理攻击，附带血量加成）；
# 法师：重写攻击方法（魔法攻击，附带等级加成）；
# 定义Paladin（圣骑士）：继承战士，新增 "治疗" 方法；
# 测试：创建不同角色，调用攻击方法，体现多态。

class Role:
    """角色基类：定义基础属性和通用方法"""
    def __init__(self, name, level=1, hp=100):
        self.name = name
        self.level = level
        self.hp = hp

    def attack(self):
        """基础攻击方法（子类重写）"""
        return f"{self.name}发起基础攻击，造成10点伤害！"

class Warrior(Role):
    """战士子类：重写攻击方法（物理攻击）"""
    def attack(self):
        """物理攻击：伤害=等级*5 + 血量/10"""
        damage = self.level * 5 + self.hp // 10
        return f"{self.name}（战士）发起物理攻击，造成{damage}点伤害！"

class Mage(Role):
    """法师子类：重写攻击方法（魔法攻击）"""
    def attack(self):
        """魔法攻击：伤害=等级*8 + 20"""
        damage = self.level * 8 + 20
        return f"{self.name}（法师）发起魔法攻击，造成{damage}点伤害！"

class Paladin(Warrior):
    """圣骑士：继承战士，新增治疗方法"""
    def heal(self):
        """治疗：恢复自身血量"""
        heal_hp = self.level * 10
        self.hp += heal_hp
        return f"{self.name}（圣骑士）使用治疗，恢复{heal_hp}点血量，当前血量：{self.hp}！"

# 测试代码（多态：不同子类调用同一方法，表现不同行为）
if __name__ == "__main__":
    # 创建角色
    base_role = Role("路人甲", 5, 150)
    warrior = Warrior("狂战士", 10, 200)
    mage = Mage("大法师", 10, 80)
    paladin = Paladin("圣光骑士", 8, 180)

    # 调用攻击方法（多态体现）
    print(base_role.attack())
    print(warrior.attack())
    print(mage.attack())
    # 圣骑士：攻击+治疗
    print(paladin.attack())
    print(paladin.heal())
#
# 习题 6：电商订单系统（类嵌套 + 属性校验）
# 题目要求
# 定义Product类：属性（商品 ID、名称、单价、库存）；
# 定义OrderItem类：属性（商品实例、购买数量），方法（计算小计金额）；
# 定义Order类：属性（订单 ID、用户 ID、订单项列表、订单状态），方法（添加订单项、计算订单总价、修改订单状态）；
# 订单项：购买数量 > 0 且不超过商品库存；
# 订单状态：默认 "待支付"，可修改为 "已支付""已发货""已完成"；
# 测试：创建 2 个商品，添加到订单，计算总价，修改订单状态。

class Product:
    """商品类：封装商品基础信息"""
    def __init__(self, prod_id, name, price, stock=0):
        self.prod_id = prod_id
        self.name = name
        self.price = max(price, 0)  # 单价不能为负
        self.stock = max(stock, 0)

class OrderItem:
    """订单项类：关联商品，计算小计"""
    def __init__(self, product, quantity):
        if not isinstance(product, Product):
            raise TypeError("必须传入Product类实例！")
        if quantity <= 0 or quantity > product.stock:
            raise ValueError(f"购买数量{quantity}无效（库存：{product.stock}）！")
        self.product = product
        self.quantity = quantity

    def calculate_subtotal(self):
        """计算小计：单价×数量"""
        return round(self.product.price * self.quantity, 2)

class Order:
    """订单类：管理订单项，计算总价，修改状态"""
    def __init__(self, order_id, user_id):
        self.order_id = order_id
        self.user_id = user_id
        self.order_items = []  # 存储OrderItem实例
        self.status = "待支付"  # 订单状态：待支付/已支付/已发货/已完成

    def add_order_item(self, order_item):
        """添加订单项"""
        if not isinstance(order_item, OrderItem):
            print("错误：只能添加OrderItem类实例！")
            return
        self.order_items.append(order_item)
        print(f"商品《{order_item.product.name}》添加到订单{self.order_id}成功！")

    def calculate_total(self):
        """计算订单总价"""
        if not self.order_items:
            return 0
        total = sum(item.calculate_subtotal() for item in self.order_items)
        return round(total, 2)

    def change_status(self, new_status):
        """修改订单状态：校验状态合法性"""
        valid_status = ["待支付", "已支付", "已发货", "已完成"]
        if new_status not in valid_status:
            print(f"错误：状态{new_status}无效！可选：{valid_status}")
            return
        self.status = new_status
        print(f"订单{self.order_id}状态修改为：{new_status}")

    def show_order_info(self):
        """显示订单信息"""
        print(f"\n【订单{self.order_id}信息】")
        print(f"用户ID：{self.user_id}，状态：{self.status}")
        print("订单项：")
        for item in self.order_items:
            print(f"- 商品：{item.product.name}，数量：{item.quantity}，小计：{item.calculate_subtotal()}元")
        print(f"订单总价：{self.calculate_total()}元")

# 测试代码
if __name__ == "__main__":
    # 创建商品
    prod1 = Product("P001", "Python实战教程", 59.9, 100)
    prod2 = Product("P002", "机械键盘", 299.9, 50)

    # 创建订单
    order = Order("O2024001", "U1001")

    # 创建订单项并添加到订单
    try:
        item1 = OrderItem(prod1, 2)
        item2 = OrderItem(prod2, 1)
        order.add_order_item(item1)
        order.add_order_item(item2)
    except ValueError as e:
        print(e)

    # 显示订单信息
    order.show_order_info()

    # 修改订单状态
    order.change_status("已支付")
    order.show_order_info()