Python第六次祖业

1. 求第n项的斐波那契数列值

# 斐波那契数列
# 使用循环算法完成
def fibonacii(n) :
    first ,second = 0 , 1
    if n < 3 :
        return n - 1
    for i in range(3 , n + 1) :
        first , second = second , first + second
    return second

2. 青蛙跳楼梯，每一次只能跳一个台阶或者两个台阶，注意，不允许倒退，
   	如果第N个台阶，请问有多少种跳法：

# 爬楼梯问题
 
# 有个人上楼梯，一次上一阶或两阶，
# 问：当他到达第N个台阶时，共有多少种走法？
 
def get_step_count(n) :
    if n == 1 or n == 2 :
        return n
    return get_step_count(n - 1) + get_step_count(n - 2)
 
# 测试
print(get_step_count(1))
print(get_step_count(2))
print(get_step_count(3))
print(get_step_count(10))
print(get_step_count(30))
print(get_step_count(90))
 
 
# 测试结果
# 1
# 2
# 3
# 89
# 1346269

   

3. 小明高考结束，成绩非常理想，父母为了奖励他，为他买了一对刚刚出生的兔子，
   	刚刚出生的兔子经过4个月成长为成年的兔子，就可以生小兔子，
   	假设成年兔子每月出生一对小兔子，问，第N月，共有多少对兔子，
   	假设所有不会死亡。

# 不死神兔问题
def immortal_rabbits(n):
    """
    计算不死神兔问题中第n个月的兔子对数。
    
    参数:
    n -- 月份，从1开始计数
    
    返回:
    第n个月的兔子对数
    """
    # 基本情况
    if n == 1 or n == 2:
        return 1
    # 递归情况
    else:
        return immortal_rabbits(n-1) + immortal_rabbits(n-2)
 
# 示例：计算一年（12个月）后的兔子对数
months = 12
rabbits = immortal_rabbits(months)
print(f"第{months}个月的兔子对数是：{rabbits}")
 
# 不死神兔修改版问题
# 兔子需要4个月生长成成年兔子，成年的一对兔子会开始生孩子，
# 假设，每一只只生一对（一公一母）兔子，
# 问：第N月时，共有多少只兔子，注意：不考虑兔子死活
def total_rabbits(n) :
    """
        使用递归方法计算第n个月的兔子整数
        参数：
        n -- 月份,从1开始计数
        返回：
        第n个月的兔子整数
    """
    # 基本情况
    if n == 1 or n == 2 or n == 3:
        return 1
    elif n == 4:
        return 2  # 第四个月，原始的一对兔子和它们新生的一对兔子
    # 递归情况
    else:
        return total_rabbits(n-1) + total_rabbits(n-3)
 
# 示例：计算第N个月的兔子总数
N = 12
rabbit_count = total_rabbits(N)
print(f"第{N}个月的兔子总数是：{rabbit_count}")

4. 找出10000以内能被5或6整除，但不能被两者同时整除的数（函数）

# 找出10000以内能被5或6整除，但不能被两者同时整除的数,并打印出有几个数
def count_numbers() :
    count = 0
    for i in range(1,10001) :
        if(i % 5 == 0 or i % 6 == 0) and not (i % 5 == 0 and i % 6 == 0) :
            count += 1
    return count
        
# 调用函数并打印结果
count = count_numbers()
print(f"在1-10000之间，能被5或6整除但不能同时被5和6整除的数共有{count}个。")
 
# 在1-10000之间，能被5或6整除但不能同时被5和6整除的数共有3000个。

5. 写一个方法，计算列表所有偶数下标元素的和(注意返回值)根据完整的路径从路径中分离文件路径、文件名及扩展名 

# 写一个方法，计算列表所有偶数下标元素的和(注意返回值)
# 根据完整的路径从路径中分离文件路径、文件名及扩展名 
# 要求：
#       1.使用函数
#       2.不使用任何模块
#       3.使用字符串方法
 
"""
    第一个功能：
    计算列表所有偶数元素下标元素的和
"""
 
 
def sum_even_index_elements(lst):
    total = 0
    for index in range(0,len(lst),2):   #  从0开始，步长为2，即偶数下标
        total += lst[index]
    return total
 
# 示例
my_list = [1,2,3,4,5,6]
result = sum_even_index_elements(my_list)
print(result)
 
""" 
    功能要是改变：
    计算所有偶数元素的和
def sum_even_elements(lst):
    total = 0
    for element in lst:  # 遍历列表中的每个元素
        if element % 2 == 0:  # 如果元素是偶数
            total += element  # 累加到总和中
    return total
# 示例
my_list = [1, 2, 3, 4, 5, 6]
result = sum_even_elements(my_list)
print(result)  # 输出应该是2 + 4 + 6 = 12
    
"""
 
"""
    第二个功能：
    根据完整的路径分离文件路径，文件名及扩展名
"""
 
 
def split_path(path):
    # 找到最后一个斜杠的位置，分割路径和文件名
    last_slash_index = path.rfind('/')
    file_path = path[:last_slash_index] if last_slash_index != -1 else ''
    file_name_with_extension = path[last_slash_index+1:]  # 从最后一个斜杠之后开始到末尾
    # 找到最后一个点的位置，分割文件名和扩展名
    last_dot_index = file_name_with_extension.rfind('.')
    file_name = file_name_with_extension[:last_dot_index] if last_dot_index != -1 else file_name_with_extension
    file_extension = file_name_with_extension[last_dot_index+1:] if last_dot_index != -1 else ''
    return file_path, file_name, file_extension
 
# 示例
full_path = '/path/to/your/file.txt'
path, file_name, extension = split_path(full_path)
print("文件路径:", path)
print("文件名:", file_name)
print("扩展名:", extension)

6. 根据标点符号对字符串进行分行

# 根据标点符号对字符串进行分行
def split_string_by_punctuation(text):
    # 定义标点符号集合
    punctuations = {'.', ',', ';', ':', '!', '?'}
    lines = []  # 用于存储分行后的字符串
    current_line = ''  # 当前行字符串
 
    # 遍历输入字符串中的每个字符
    for char in text:
        if char in punctuations:
            # 如果字符是标点符号，将当前行和标点符号加入lines列表，然后开始新的一行
            lines.append(current_line + char)
            current_line = ''
        else:
            # 如果字符不是标点符号，将其加入当前行
            current_line += char
 
    # 添加最后一行（如果有）
    if current_line:
        lines.append(current_line)
 
    return lines
 
# 示例
text = "Hello,world!This is a test string.How are you doing today?"
split_text = split_string_by_punctuation(text)
for line in split_text:
    print(line)
 
# Hello,
# world!
# This is a test string.
# How are you doing today?

7. 去掉字符串数组中每个字符串的空格

# 利用python语言（使用函数及字符串）解答：
# 去掉字符串数组中每个字符串的空格
 
"""
使用str.replace()方法
功能：替换空格为一个空字符串
"""
 
 
def remove_spaces(strings):
    # 使用列表推导式去除每个字符串中的所有空格
    return [s.replace(" ", "") for s in strings]
 
# 示例
string_array = ["Hello World", "  This is a test ", " remove spaces "]
cleaned_array = remove_spaces(string_array)
print(cleaned_array)
 
 
"""
使用str.strip()方法
功能：只想去除每个字符串两端的空格，而不是中间的空格
"""
 
 
def remove_spaces(strings):
    # 使用列表推导式去除每个字符串两端的空格
    return [s.strip() for s in strings]
 
# 示例
string_array = ["Hello World", "  This is a test ", " remove spaces "]
cleaned_array = remove_spaces(string_array)
print(cleaned_array)

8. 随意输入你心中想到的一个书名，然后输出它的字符串长度。 （len()属性:可以得字符串的长度）

# 随意输入你心中想到的一个书名，然后输出它的字符串长度。 （len()属性:可以得字符串的长度）
def book_title_length(title) :
    return len(title)
 
# 测试
book_title = "十宗罪"
length = book_title_length(book_title)
print(f"书名《{book_title}》的字符串长度为：{length}")
 
# 书名《十宗罪》的字符串长度为：3

9. 两个学员输入各自最喜欢的游戏名称，判断是否一致,如
   果相等,则输出你们俩喜欢相同的游戏；如果不相同,则输
   出你们俩喜欢不相同的游戏。

# 利用python语言写命令（利用函数）：
# 两个学员输入各自最喜欢的游戏名称，判断是否一致,
# 如果相等,则输出你们俩喜欢相同的游戏；
# 如果不相同,则输出你们俩喜欢不相同的游戏。
def compare_game_choice(game1,game2) :
    if game1 == game2 :
        print("你们俩喜欢相同的游戏")
    else:
        print("你们俩喜欢不相同的游戏")
 
student1_like_game = input("学员1,，请输入你最喜欢的游戏名称:")
student2_like_game = input("学员2,，请输入你最喜欢的游戏名称:")
 
# 调用函数进行比较
compare_game_choice(student1_like_game,student2_like_game)
 
# 学员1,，请输入你最喜欢的游戏名称:VALORANT
# 学员2,，请输入你最喜欢的游戏名称:CounterStrike 2
# 你们俩喜欢不相同的游戏
 

10. 上题中两位同学输入 lol和 LOL代表同一游戏，怎么办?


11. 让用户输入一个日期格式如“2008/08/08”，将 输入的日
    	期格式转换为“2008年-8月-8日”。

# 让用户输入一个日期格式如“2008/08/08”，
# 将输入的日期格式转换为“2008年-8月-8日”
 
def convert_date_format(date_str) :
    year , month , day = date_str.split('/')
    return f"{int(year)}年{int(month)}月{int(day)}日"
 
# 用户输入日期
input_date = input("请输入一个日期格式如“2008/08/08:")
convert_format = convert_date_format(input_date)
print(convert_format)
 
# 请输入一个日期格式如“2008/08/08:2004/10/23
# 2004年10月23日

12. 接收用户输入的字符串，将其中的字符进行排序（升
    序），并以逆序的顺序输出，“cabed”→"abcde"→“edcba”。

# 接收用户输入的字符串，
# 将其中的字符进行排序（升序），
# 并以逆序的顺序输出，“cabed”→"abcde"→“edcba”。
def sort_and_reverse(input_str) :
    # 将字符串按照升序排序
    sorted_str = " ".join(sorted(input_str))
    # return 排序后的字符串的逆序
    return sorted_str[::-1] 
 
 
# 用户输入字符串测试
user_input = input("请输入一个字符串：")
result = sort_and_reverse(user_input)
print(f"排序后的逆序字符串为：{result}")
 
# 请输入一个字符串：asdadad
# 排序后的逆序字符串为：s d d d a a a

13. 接收用户输入的一句英文，将其中的单词以反序输
    出，“hello c sharp”→“sharp c hello”。


14. 从请求地址中提取出用户名和域名
    http://www.163.com?userName=admin&pwd=123456

# 利用python语言（使用函数及字符串且不使用模块）解答：
# 请求地址中提取出用户名和域名
# http://www.163.com?userName=admin&pwd=123456
 
 
def extract_user_and_domain(url):
    """
    从给定的URL中提取用户名和域名。
    参数:
    url (str): 完整的URL字符串。
    返回:
    tuple: 包含用户名和域名的元组。
    """
    # 找到域名的结束位置，即'?'字符的位置
    query_start = url.find('?')
    # 如果存在'?'，则截取其前面的部分作为域名，否则整个URL都是域名
    domain = url[:query_start] if query_start != -1 else url
    
    # 找到参数部分，即'?'之后的所有内容
    query = url[query_start + 1:] if query_start != -1 else ''
    
    # 默认用户名为空
    username = ''
    
    # 按'&'分割参数部分
    params = query.split('&')
    
    # 遍历所有参数，找到用户名
    for param in params:
        key_value = param.split('=')
        if len(key_value) == 2 and key_value[0] == 'userName':
            username = key_value[1]
            break
    
    return username, domain
 
# 示例
url = "http://www.163.com?userName=admin&pwd=123456"
username, domain = extract_user_and_domain(url)
print("用户名:", username)
print("域名:", domain)

15. 有个字符串数组，存储了10个书名，书名有长有短，现
    在将他们统一处理，若书名长度大于10，则截取长度8的
    子串并且最后添加“...”，加一个竖线后输出作者的名字。

# 有个字符串数组，存储了10个书名，书名有长有短，现
# 在将他们统一处理，若书名长度大于10，则截取长度8的
# 子串并且最后添加“...”，加一个竖线后输出作者的名字。
 
def process_book_titles(titles, authors):
    """
    处理书名数组，若书名长度大于10，则截取长度8的子串并且最后添加“...”，
    并在竖线后输出作者的名字。
    参数:
    titles (list): 存储书名的字符串列表。
    authors (list): 存储对应作者名的字符串列表。
    返回:
    list: 处理后的书名和作者信息列表。
    """
    processed_titles = []
    for title, author in zip(titles, authors):
        if len(title) > 10:
            # 截取前8个字符并添加“...”
            processed_title = title[:8] + "..."
            processed_titles.append(f"{processed_title} | {author}")
        else:
            processed_titles.append(f"{title} | {author}")
    return processed_titles
 
# 示例
book_titles = [
    "Python",
    "HCIA",
    "HCIP",
    "HCIE",
    "RHCSA",
    "数据库",
    "数据结构",
    "web前端",
]
 
book_authors = [
    "作者A",
    "作者B",
    "作者C",
    "作者D",
    "作者E",
    "作者F",
    "作者G",
    "作者H",
    "作者I",
    "作者J"
]
 
# 处理书名
processed_books = process_book_titles(book_titles, book_authors)
for book in processed_books:
    print(book)
 
# Python | 作者A
# HCIA | 作者B
# HCIP | 作者C
# HCIE | 作者D
# RHCSA | 作者E
# 数据库 | 作者F
# 数据结构 | 作者G
# web前端 | 作者H

16. 让用户输入一句话,找出所有"呵"的位置。

# 在用户输入的字符串中找出所有“呵”字的位置。
 
def find_h_positions(user_input):
    """
    参数:
    user_input (str): 用户输入的字符串。
    返回:
    list: 包含所有“呵”字位置的列表。
    """
    positions = []
    # 遍历字符串，找到所有“呵”的位置
    for index, char in enumerate(user_input):
        if char == "呵":
            positions.append(index)
    return positions
 
# 提示用户输入一句话
user_sentence = input("请输入一句话：")
# 查找“呵”字的所有位置
heh_positions = find_h_positions(user_sentence)
# 打印结果
if heh_positions:
    print("“呵”字的位置有：", heh_positions)
else:
    print("“呵”字在句子中未出现。")
 
# 请输入一句话：真是这样的呢，呵呵！
# “呵”字的位置有： [7, 8]

17. 让用户输入一句话,判断这句话中有没有邪恶,如果有邪
    恶就替换成这种形式然后输出,如:“老牛很邪恶”,输出后变
    成”老牛很**”;

# 让用户输入一句话,判断这句话中有没有邪恶,
# 如果有邪恶就替换成这种形式然后输出,
# 如:“老牛很邪恶”,输出后变成”老牛很**”.
 
"""
    方案一：直接替换
"""
 
 
def replace_evil_with_stars(sentence):
    if"邪恶"in sentence:
        sentence = sentence.replace("邪恶","**")
    return sentence
 
# 提示用户输入一句话
user_input = input("请输入一句话")
# 替换“邪恶”并输出结果
processed_sentence = replace_evil_with_stars(user_input)
print(processed_sentence)
 
# 请输入一句话邪恶的一家人与邪恶的一个教团
# **的一家人与**的一个教团

18. 如何判断一个字符串是否为另一个字符串的子串 
    	find()  

    ​	index()
    ​	双层循环完成
    ​	？？

# 如何判断一个字符串是否为另一个字符串的子串
 
"""可以直接使用in关键字。"""
def is_substring(main_string,substring):
    """
    判断substring是否为main_string的子串。
    in关键字用于检查一个字符串是否包含在另一个字符串中。
    如果包含，表达式的结果为True，如果不包含，结果为False。
    """
    return substring in main_string
 
# 示例
main_str = "hello world"
sub_str = "world"
 
# 判断sub_string是否为main_string的子串
if is_substring(main_str,sub_str):
    print(f"{sub_str}是{main_str}的子串")
else:
    print(f"{sub_str}不是{main_str}的子串")
 
# world是hello world的子串
 
"""可以使用find()方法"""
# find()方法返回子串在字符串中首次出现的索引，如果找不到子串则返回 -1  。
def is_substring(main_string, substring):
    # 使用 find() 方法查找子串
    return main_string.find(substring) != -1
 
# 示例
main_str = "hello world"
sub_str = "world"
 
# 判断 sub_str 是否为 main_str 的子串
if is_substring(main_str, sub_str):
    print(f"'{sub_str}' 是 '{main_str}' 的子串")
else:
    print(f"'{sub_str}' 不是 '{main_str}' 的子串")
 
"""可以使用index()方法"""
# index()方法返回子串在字符串中首次出现的索引，如果找不到子串会抛出ValueError。
def is_substring(main_string, substring):
    try:
        # 使用 index() 方法查找子串
        main_string.index(substring)
        return True
    except ValueError:
        return False
 
# 示例
main_str = "hello world"
sub_str = "world"
 
# 判断 sub_str 是否为 main_str 的子串
if is_substring(main_str, sub_str):
    print(f"'{sub_str}' 是 '{main_str}' 的子串")
else:
    print(f"'{sub_str}' 不是 '{main_str}' 的子串")
 
 
"""也可以使用双层循环方法"""
# 使用双层循环来检查每个可能的位置
def is_substring(main_string, substring):
    # 外层循环遍历主字符串的所有可能起始位置
    for i in range(len(main_string) - len(substring) + 1):
        # 内层循环遍历子串的每个字符
        for j in range(len(substring)):
            if main_string[i + j] != substring[j]:
                break
        else:
            # 如果内层循环没有 break，说明找到了子串
            return True
    return False
 
# 示例
main_str = "hello world"
sub_str = "world"
 
# 判断 sub_str 是否为 main_str 的子串
if is_substring(main_str, sub_str):
    print(f"'{sub_str}' 是 '{main_str}' 的子串")
else:
    print(f"'{sub_str}' 不是 '{main_str}' 的子串")

19. 如何验证一个字符串中的每一个字符均在另一个字符串中出现过

# 如何验证一个字符串中的每一个字符均在另一个字符串中出现过
def are_all_chars_present(s1, s2):
    # 使用 all() 函数和列表推导式检查 s1 中的每个字符是否都在 s2 中
    return all(char in s2 for char in s1)
 
# 示例
s1 = "hello"
s2 = "worldhello"
result = are_all_chars_present(s1, s2)
print(result)  # 输出：True 或 False

20. 如何随机生成无数字的全字母的字符串

# 如何随机生成无数字的全字母的字符串
 
import random
import string
 
 
def generate_random_alpha_string(length):
    """
    随机生成一个无数字的全字母字符串。
    参数:
    length (int): 字符串的长度。
    返回:
    str: 随机生成的全字母字符串。
    """
    # 从string模块中获取所有字母的集合
    all_letters = string.ascii_letters
    # 使用random.choice随机选择字母
    return ''.join(random.choice(all_letters) for _ in range(length))
 
# 示例
length = 10  # 指定生成字符串的长度
random_alpha_string = generate_random_alpha_string(length)
print(random_alpha_string)

21. 如何随机生成带数字和字母的字符串

# 如何随机生成带数字和字母的字符串
 
import random
import string
 
def generate_random_string(length):
    # 定义字符集，包括大写字母、小写字母和数字
    characters = string.ascii_letters + string.digits
    # 使用random.choices随机选择字符，并连接成字符串
    random_string = ''.join(random.choices(characters, k=length))
    return random_string
 
# 使用函数生成一个长度为10的随机字符串
random_str = generate_random_string(10)
print(random_str)

22. 判断一个字符是否是回文字符串（面试题）
    	"1234567654321"
    	"上海自来水来自海上"

# 判断一个字符是否是回文字符串
# "1234567654321"
# "上海自来水来自海上"
 
def is_palindrome(s):
    # 移除非字母数字字符并转换为小写
    s = ''.join(c for c in s if c.isalnum()).lower()
    # 判断字符串与其反转是否相等
    return s == s[::-1]
 
# 测试字符串
str1 = "1234567654321"
str2 = "上海自来水来自海上"
 
# 输出结果
print(is_palindrome(str1))  # 应该返回 True
print(is_palindrome(str2))  # 应该返回 True