Python程序设计基础——代码习题

1 __name__属性

import demo

def main():
    if __name__ == '__main__':
        print('这个程序被直接运行。')
    elif __name__=='demo':
        print('这个程序作为模块被使用。')
main()

3.3 编写程序，生成包含1000个0~100之间的随机整数，并统计每个元素出现的次数。

import random

x=[random.randint(0,100) for i in range(1000)]

# 使用集合
s=set(x)
for v in s:
    print(v,':',x.count(v))
print('='*30)

# 使用字典
d=dict()
for v in x:
    d[v]=d.get(v,0)+1
for k,v in d.items():
    print(k,v,sep=':')

3.4 编写程序，用户输入一个列表和两个整数作为下标，然后使用切片获取并输出列表中介于两个下标之间的元素组成的子列表。例如，用户输入[1,2,3,4,5,6]和2、5，程序输出[3,4,5,6]。

x=eval(input('请输入一个列表：'))
start,end=eval(input('请输入开始位置：')),eval(input('请输入结束位置：'))
print(x[start:end+1])

4.5 编写程序，生成一个包含20个随机整数的列表，然后对其中偶数下标的元素进行降序排列，奇数下标的元素不变。

import random
x=[random.randint(0,100) for i in range(20)]
print(x)
x[::2]=sorted(x[::2],reverse=True) # 只对偶数下标降序排列
print(x)

4.6 编写程序，用户从键盘输入小于1000的整数，对其进行因式分解。例如10=2×5，60=2×2×3×5。

x = eval(input('请输入一个小于1000的整数：'))  # 获取用户输入的整数

t = x  # 将输入的整数赋值给变量t
i = 2  # 从最小的质数2开始尝试除法
result = []  # 存储质因数的列表

while True:
    if t == 1:  # 如果t已经被分解完毕，则跳出循环
        break
    if t % i == 0:  # 如果t能够整除当前的质数i，则i是t的一个质因数
        result.append(i)  # 将i添加到结果列表中
        t = t // i  # 将t除以i，继续判断是否还能整除
    else:
        i += 1  # 如果不能整除，则尝试下一个更大的质数

print(x, '=', '*'.join(map(str, result)))  # 输出质因数分解的结果

4.7 编写程序，至少使用两种不同的方法计算100以内所有奇数的和。

print(sum([i for i in range(1,100) if i%2==1]))
print(sum(range(1,100)[::2]))

4.8 编写程序，输出所有由1,2,3,4这四个数字组成的素数，并且在每个素数中每个数字只使用一次。

import itertools

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):  # 判断是否为素数
        if n % i == 0:
            return False
    return True

digits = [1, 2, 3, 4]  # 数字列表

# 生成由给定数字列表中的数字组成的所有排列
permutations = list(itertools.permutations(digits))

# 使用列表推导式，在每个排列中判断是否为素数，并将满足条件的素数转换为整数添加到一个新的列表中
prime_numbers = [int(''.join(map(str, perm))) for perm in permutations if is_prime(int(''.join(map(str, perm))))]

print(prime_numbers)  # [1423, 2143, 2341, 4231]

4.9 编写程序，实现分段函数计算

x=eval(input('请输入x:'))

if 0 <= x < 5:
    print(x)
elif 5 <= x < 10:
    print(x * 3 - 5) 
elif 10 <= x < 20:
    print(x * 0.5 - 2)
else:
    print(0)

5.2 编写函数，判断一个整数是否为素数，并编写主程序调用该函数

import math

def isPrime(v):
    n=int(math.sqrt(v)+1)
    for i in range(2,n):
        if v%i==0:
            return 'No'
    return 'Yes'

print(isPrime(37))

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# 主程序
num = int(input("请输入一个整数："))
if is_prime(num):
    print(f"{num} 是素数")
else:
    print(f"{num} 不是素数")

5.3 编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果。

def count(v):
    capital = little = digit = other = 0
    for i in v:
        if 'A'<=i<='Z':
            capital += 1
        elif 'a' <=i <='z':
            little += 1
        elif '0' <=i <='9':
            digit += 1
        else:
            other += 1
    return (capital,little,digit,other)

# 主程序
input_string = input("请输入一个字符串：")
result = count(input_string)
print(result)

5.8 编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和。

def demo(*v):
    print(v)
    print(max(v))
    print(sum(v))

demo(1,2,3)

5.9 编写函数，模拟内置函数sum()。

def Sum(v):
    s=0
    for i in v:
        s += i
    return s

x=[1,2,3,4,5]
print(Sum(x))
x=(1,2,3,4,5)
print(Sum(x))

5.11 编写函数，模拟内置函数sorted()。

from random import randint

def mySorted(lst, reverse=False):
    lst = lst[:]  # 复制原始列表，避免修改原始列表
    for i in range(0, len(lst)):
        flag = False  # 标记是否发生元素交换
        for j in range(0, len(lst) - i - 1):
            # 比较相邻两个元素大小，并根据需要进行交换，默认升序
            exp = 'lst[j] > lst[j+1]'
            # 若reverse=True，则降序排列
            if reverse:
                exp = 'lst[j] < lst[j+1]'
            if eval(exp):  # 利用eval()函数动态求值表达式
                lst[j], lst[j+1] = lst[j+1], lst[j]
                # flag=True表示本次扫描发生过元素交换
                flag = True
        # 若一次扫描结束后，没有发生过元素交换，说明已经按序排列
        if not flag:
            break
    return lst

# 示例使用
nums = [randint(1, 100) for _ in range(10)]  # 生成随机整数列表
print("原始列表：", nums)
sorted_nums = mySorted(nums)  # 默认升序排序
print("升序排序结果：", sorted_nums)
reverse_sorted_nums = mySorted(nums, reverse=True)  # 降序排序
print("降序排序结果：", reverse_sorted_nums)

5.12 编写函数，模拟内置函数reversed()。

def myReversed(lst):
    for item in lst[::-1]:
        yield item

lst = list(range(5))
for i in myReversed(lst):
    print(i)

6.1 继承6.3节例6-1中的Person类生成Student类，填写新的方法用来设置学生专业，然后生成该类对象并显示信息。

# 基类（父类）
class Person(object): # 基类必须继承于object，否则在派生类中将无法使用super()函数
    def __init__(self, name='',age=20,sex='man'):
        # 通过调用方法进行初始化，这样可以对参数进行更好控制
        self.setName(name)
        self.setAge(age)
        self.setSex(sex)

    def setName(self,name):
        if not isinstance(name,str):# 检查name是否为字符串类型
            print('名字必须是字符串！')
            return
        self.__name = name

    def setAge(self,age):
        if not isinstance(age,int):
            print('年龄必须是整数！')
            return
        self.__age = age

    def setSex(self,sex):
        if sex != '男' and sex !='女':
            print('性别必须输入男或女！')
            return
        self.__sex = sex

    def show(self):
        print(self.__name)
        print(self.__age)
        print(self.__sex)

# 派生类（子类）
class Student(Person):
    def __init__(self,name='',age=30,sex='男',major='计算机'):
        # 调用基类构造方法初始化基类的私有数据成员
        super(Student, self).__init__(name,age,sex)
        # 初始化派生类的数据成员
        self.setMajor(major)
    def setMajor(self,major):
        if not isinstance(major,str):
            print('专业必须是字符串类型！')
            return
        self._major = major
    def show(self):
        super(Student,self).show()
        print(self._major)

if __name__=='__main__':
    # 创建父类对象
    lesin = Person('lesin',18,'女')
    lesin.show()
    print('='*30)
    # 创建子类对象
    esin = Student('esin',17,'女','数学')
    esin.show()
    # 调用集成的方法修改专业
    esin.setMajor('计算机科学与技术')
    esin.show()

6.2 设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法运算。

class Vecter3:
    def __init__(self,x=0,y=0,z=0):
        self.X=x
        self.Y=y
        self.Z=z

    def __add__(self,n):
        r =Vecter3()
        r.X = self.X + n.X
        r.Y = self.Y + n.Y
        r.Z = self.Z + n.Z
        return r

    def __sub__(self, n):
        r =Vecter3()
        r.X = self.X - n.X
        r.Y = self.Y - n.Y
        r.Z = self.Z - n.Z
        return r

    def __mul__(self, n):
        r =Vecter3()
        r.X = self.X * n
        r.Y = self.Y * n
        r.Z = self.Z * n
        return r

    def __truediv__(self, n):
        r =Vecter3()
        r.X = self.X / n
        r.Y = self.Y / n
        r.Z = self.Z / n
        return r

    def __floordiv__(self, n):
        r =Vecter3()
        r.X = self.X // n
        r.Y = self.Y // n
        r.Z = self.Z // n
        return r

    def show(self):
        print((self.X,self.Y,self.Z))

v1 = Vecter3(1,2,3)
v2 = Vecter3(4,5,6)
v3 = v1 + v2
v3.show()

7.1 假设有一段英文，其中有单独的字母I误写为i，请编写程序进行修正。

x='i am a student,i am 18 years old.'
x=x.replace('i','I')
print(x)

7.2 假设有一段英文，其中有单词中间的字母i误写为I，请编写程序进行纠正。

text = 'If the implementatIon is hard to explain, it;s a bad idea.'
result = ''

# 遍历文本中的每个字符及其索引
for index, ch in enumerate(text):
    # 如果当前字符是大写的"I"，并且它前面和后面的字符都是字母
    if ch == 'I' and text[index-1].isalpha() and text[index+1].isalpha():
        ch = 'i'  # 将大写的"I"替换为小写的"i"
    result += ch

print(result)

8.1 有一段英文文本，其中有个单词连续重复了2次，编写程序检查重复的单词，并只保留一个。例如，文本内容为"This is is a desk.“，程序输出为"This is a desk.”

import re
'''
(\w+)：表示一个或多个连续的字母数字字符，被捕获到第一个分组中。
\s：表示一个空白字符（包括空格、制表符等）。
\1：表示对第一个分组的引用，即前面捕获到的单词。
通过调用 re.sub() 函数，将匹配到的重复的单词替换为第一个出现的单词。
'''
x = 'This is is a desk.'
x = re.sub(r'(\w+)\s\1',r'\1',x)
print(x)

8.2 编写程序，用户输入一段英文，然后输出这段英文中所有长度为3个字母的单词。

import re
'''
re.compile() 函数创建一个正则表达式模式对象。

\b 表示单词的边界，确保匹配的是完整的单词。
[a-zA-Z] 表示匹配任意一个字母（大小写不限）。
{3} 表示前面的表达式重复匹配3次，即匹配长度为3的单词。

调用 pattern.findall(x) 方法来查找并返回输入字符串 x 中满足匹配模式的所有结果。
'''
x = input('请输入一段英文：')
pattern = re.compile(r'\b[a-zA-Z]{3}\b')
print(pattern.findall(x))

9.1 假设有一个英文文本文件，编写程序获取其内容，并将其中的大写字母变为小写字母，小写字母变为大写字母。

with open(r'd:\test.txt', 'r') as src: # 打开D盘下的test.txt文件
    for line in src:  # 逐行读取文件内容
        print(line.swapcase())  # 对每一行的字符串进行大小写转换并打印输出

9.2 编写程序，使用pickle模块将包含学生成绩的字典保存为二进制文件，然后读取内容并显示。

import pickle

score = {'lesin': 150, 'Bob': 73, 'esin': 97}

with open('score.dat', 'wb') as fp:
    pickle.dump(score, fp)  # 将字典对象 score 序列化并写入到文件中

with open('score.dat', 'rb') as fp:
    result = pickle.load(fp)  # 从文件中读取并反序列化为对象

print(result)  # 打印反序列化后的结果（原始的字典对象）

10.1 使用shutil模块中的move()函数进行文件移动。

import shutil
shutil.move(r'd:\1.txt',r'e:\1.txt')

10.2 编写代码，将当前工作目录修改为"C:"，并验证，最后将当前工作目录恢复为原来的目录。

import os

os.getcwd()# 获取当前路径
os.chdir(r'c:\\') # 修改工作目录到C盘
os.getcwd()
os.chdir(r'd:\\Python\\demo') # 恢复到原来的目录
os.getcwd()

10.3 编写程序，用户输入一个目录和一个文件名，搜索该目录及其子目录中是否存在该文件。

import os

directory = input('请输入文件夹：')
filename = input('请输入文件名：')  

paths = os.walk(directory)  # 使用os.walk()函数遍历文件夹及其子文件夹
for root, dirs, files in paths:  # 遍历每个子文件夹中的目录、子文件夹和文件列表
    if filename in files:  # 判断文件名是否在文件列表中
        print('Yes')  # 如果找到匹配的文件名，打印'Yes'
        break  # 找到后跳出循环
else:
    print('No')  # 如果未找到匹配的文件名，在循环结束后打印'No'

11.1 Python异常处理结构有哪几种形式？

1）try…except…

try:
	# 可能会引发异常的代码，先执行一下试试
    x=int(input('请输入一个整数：'))
    print(x)
except Exception as e:
	# 若try中的代码抛出异常并被except捕捉，就执行这里的代码
    print('Error.')

2）try…except…else…

try:
	# 可能会引发异常的代码
    x=int(input('请输入一个整数：'))
    print(x)
except Exception as e:
	# 用来处理异常的代码
    print('Error.')
else:
    # 若try子句中的代码没有引发异常，就继续执行这里的代码
    print('success')

3. try…except…finally…

try:
	# 可能会引发异常的代码
    x=int(input('请输入一个整数：'))
    print(x)
except Exception as e:
	# 用来处理异常的代码
    print('Error.')
finally:
    # 无论try子句中的代码是否引发异常，都会执行这里的代码
    print(-1)

4. 捕捉多种异常的异常处理结构

try:
	# 可能会引发异常的代码
    x=float(input('请输入被除数：'))
    y=float(input('请输入除数：'))
    z=x/y
except ZeroDivisionError:#except Exception1:
	# 处理异常类型1的代码
    print('除数不能为零')
except TypeError:#except Exception2:
    # 处理异常类型2的代码
    print('被除数和除数应为数值类型')
except NameError:#except Exception3:
    # 处理异常类型3的代码
    print('变量不存在')
else:
    print(x,'/',y,'=',z)
finally:
    # 无论是否发生异常都会执行这段程序
    print('程序结束')

12.2 使用Python内置函数dir()查看Cursor对象中的方法，并使用内置函数help()查看其用法。

import sqlite3

# 创建数据库连接
conn = sqlite3.connect('database.db')

# 创建游标对象
cursor = conn.cursor()
methods = dir(cursor)
print(methods)

help(cursor.method_name)  # 将 `method_name` 替换为要查看的方法名

12.5 叙述使用Python操作MySQL数据库的步骤

import pymysql

conn=pymysql.connect(host='127.0.0.1',user='root',password='123456',database='MySQL',charset='UTF8MB4')

cursor = conn.cursor()

def doSQL(sql):
    cursor.execute(sql)
    conn.commit()

# 1.创建test数据库
doSQL('CREATE DATABASE IF NOT EXISTS test;')

# 2.在test数据库中创建question数据表
sql='''
CREATE TABLE IF NOT EXISTS test.questions(
id INT auto_increment PRIMARY KEY,
wenti CHAR(200) NOT NULL UNIQUE,
daan CHAR(50) NOT NULL
)ENGINE=innodb DEFAULT CHARSET=UTF8MB4;
'''
doSQL(sql)

# 3.插入数据
for i in range(10):
    sql='INSERT INTO test.questions(wenti,daan) VALUE ("测试问题{0}","答案{0}");'.format(i)
    cursor.execute(sql)
conn.commit()

# 4.修改数据
doSQL('UPDATE test.questions SET daan="被修改了" WHERE wenti="测试问题6";')

# 5.删除指定的数据
doSQL('DELETE FROM test.questions WHERE daan="答案8";')

# 6.查询并输出数据
sql='SELECT * FROM test.questions'
cursor.execute(sql)
for row in cursor.fetchall():
    print(row)

# 7.删除所有数据
doSQL('DELETE FROM test.questions')

# 8.删除数据表
doSQL('DROP TABLE IF EXISTS test.questions;')

# 9.删除数据库
doSQL('DROP DATABASE IF EXISTS test;')

# 10.关闭游标和连接
cursor.close()
conn.close()