# 1、输入a,b,c,d4个整数，计算a+b-c*d的结果？

# 从键盘输入数字
str_input = input('请输入a、b、c、d四个整数（数字之前使用,逗号连接）：')

# 使用split对数据进行切分
list_data = str_input.split(',')

if len(list_data) == 4:
    a = int(list_data[0])
    b = int(list_data[1])
    c = int(list_data[2])
    d = int(list_data[2])
    
    # 计算测试结果
    ret = a + b - c * d
    print(f'a+b-c*d={ret}')
else:
    print('输入的数字有误！')

# 2、编写程序，从键盘输入某个分钟数，将其转换成小时和分钟表示。

# 从键盘输入分钟数
minutes = int(input('请输入分钟数:'))

# 计算小时和分钟
hours = minutes // 60
remaining_minutes = minutes % 60

# 输出结果
print(f'{minutes} 分钟是 {hours} 小时和 {remaining_minutes} 分钟')

# 3，输入一个16位学号如，1001010220170101，
# 其中100是学校代号、101是院系代号、02专业代号、2017年级、01班级、01学号，
# 请使用切片获取出各个代码。

stu_no = input('请输入16位学号:')
if len(stu_no) != 16:
    print('学号长度有误！')
else:
    print(f'学校代号: {stu_no[0:2]}')
    print(f'院系代号: {stu_no[3:5]}')
    print(f'专业代号: {stu_no[6:7]}')
    print(f'年级: {stu_no[8:11]}')
    print(f'班级: {stu_no[12:13]}')
    print(f'学号: {stu_no[14:]}')

# 1、输入年份，判断该年是否为闰年。闰年的条件:能够被4整除但不能被100整除，或者能够被400整除的。

year = int(input('请输入年份：（系统会判断输入的年份是否为闰年）'))
if ((year % 4 == 0) and (year % 100 != 0)) or (year % 400 == 0):
    print(f'{year}是闰年')
else:
    print(f'{year}不是闰年')

# 2、输出10行内容，每行的内容都不一样，第1行一个星号，第2行2个星号…

# 设置输出10行
len_num = 10
for i in range(1, len_num + 1):
    print('*' * i)

# 3、输出所有的水仙花数（三位数，各位数字的立方和等于自身）。

list_data = [100, 407, 370, 456]

for inumber in list_data:
    ones = inumber % 10
    tens = (inumber // 10) % 10
    hundreds = inumber // 100
         
    ret = ones ** 3 + tens ** 3 + hundreds ** 3
    
    print(f"{hundreds}的三次方+{tens}的三次方+{ones}的三次方 = {ret}")   

        
    if inumber == ones ** 3 + tens ** 3 + hundreds ** 3:
        print(f'{inumber}是一个水仙花数')

# 1、假定有下面的列表:    names = ['fentiao','fendai','fensi','apple']    
# 输出结果为:'I have fentiao, fendai, fensi and apple.'

names = ['fentiao','fendai','fensi','apple']

result = f'I hava {names[0]}, {names[1]}, {names[2]} and {names[3]}.'

print(result)

# 2、已知一个数字列表，求所有元素和。

num = [1, 3, 5, 6, 7, 8, 9]
sum = 0    
for i in num:
    sum = sum + i
print(f'数字列表的和为：{sum}')

# 3、将列表逆序输出，使用三种方式。

num = [1, 3, 5, 6, 7, 8, 9]

# 方式一:使用切片函数
print('方式一：')
print(num[::-1])

# 方式二:使用for循环从后往前遍历输出
print('方式二：')
for i in range(len(num)-1, -1, -1):   # range的用法是(start,  end , step)，其中end是开区间，即并不包含
    print(num[i], end=' ')
print('')
  
# 方式三:将num数组翻转，然后顺序输出
print('方式三：')
reversed_num = reversed(num)
for num in reversed_num:
    print(num, end=' ')
print('')

# 1、去除列表中的重复元素：li=[1,1,2,3,4,7,8,2,1,2]

li = [1, 1, 2, 3, 4, 7, 8, 2, 1, 2]

# 声明新的new_li用于保存去除重复元素后的list
new_li = list()
dic_appear = dict()

for i in li:
    if i in dic_appear:
        continue
    else:
        dic_appear.setdefault(i)
        new_li.append(i)
print(new_li)

# 2、现存任意两个字符串s1与s2，判断s1中的字符在s2中存在的个数（重复的字符算1个，一条语句实现）
s1 = 'hello world'
s2 = 'this is a test'

# 将字符串转换为集合，然后使用&运算符计算两个集合的交集，最后通过len()函数获取交集的元素个数
count = len(set(s1) & set(s2))
print(count)

# 3、编写程序，将字典中的键与值互换。

data = {'a': 'apple',
         'b': 'banana',
         'c': 'cina'}

# 使用字典推导式将键与值互换
flipped_data = {v: k for k, v in data.items()}

print(flipped_data)

# 1、写一个lambda表达式，实现两个数的相加
addition = lambda x, y: x + y

sum_result = addition(5,3)
print(f'lambda相加结果：{sum_result}')

# 2、编写函数，第一个参数指定今天是星期几（1 ~ 7），第二个参数指定天数n，返回n天后是星期几。
def get_future_weekday(today, n):
    weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
    
    # 计算n天后的星期几
    future_weekday = weekdays[(today + n) % 7]
    
    return future_weekday
    
# 假设今天是星期一（1代表星期一，以此类推）
today = 2  
# 假设n为30天后
n = 30  

future_weekday = get_future_weekday(today, n)
print(future_weekday)  # 输出结果为星期六

# 3、求平方和，有列表[1,……9]，把每一个元素都取一下平方，然后累加求和，使用普通函数和使用高阶函数两种方式解决问题

# 普通函数方式：
def square_sum_normal(lst):
    total = 0
    for num in lst:
        total += num ** 2
    return total

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]

result_normal = square_sum_normal(nums)
print("平方和（普通函数）：", result_normal)

# 高阶函数方式：
def square_sum_advance(lst):
    # 使用sum函数直接计算map对象中元素的和
    return sum(map(lambda x: x ** 2, lst))

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]

result_advance = square_sum_advance(nums)
print("平方和（高阶函数）：", result_advance)

class Computer:
    def __init__(self, cpu = 'i7', mem = '8M', hd = '500G'):
        self.cpu = cpu
        self.mem = mem
        self.hd = hd
        
    def get_cpu(self):
        print(f'CPU : {self.cpu}')
        
    def get_mem(self):
        print(f'内存 : {self.mem}')
        
    def get_hdisk(self):
        print(f'硬盘 : {self.mem}')
    
    def get_info(self):
        self.get_cpu()
        self.get_mem()
        self.get_hdisk()

computer = Computer('i9-10400k', '16G', '10T')
computer.get_info()

# 1、将一个列表中所有元素转换成浮点类型，如果不能转换，则丢弃该元素。

original_list = [1, "2.5", 3, "hello", 4.2]

float_list = []
for item in original_list:
    try:
        # 直接尝试将元素转换为浮点数
        float_item = float(item)
        float_list.append(float_item)
    except ValueError:
        # 如果转换失败（例如，因为元素是不能转换为浮点数的字符串），则忽略该元素
        pass

print(float_list)

# 2、读取iris.txt文件数据，并存入列表中

iris_data = []

with open('testdata/iris.txt', 'r') as file:
    for line in file:
        # 去除换行符并按逗号分割每行数据
        data = line.strip().split(',')
        iris_data.append(data)

# 打印存储的数据列表
for data in iris_data:
    print(data)

# 1、生成一个文件夹，文件夹下面生成100个txt文件，分别命名为1.txt ,2.txt到100.txt,其中1.txt内容为1到100,2.txt的内容为101到200，以此类推到100.txt的内容为9901到10000。
import os

# 创建文件夹
folder_name = "testdata/txt_files"
os.makedirs(folder_name, exist_ok=True)

for i in range(1, 101):
    file_name = f"{folder_name}/{i}.txt"
    with open(file_name, 'w') as file:
        start_num = (i - 1) * 100 + 1
        end_num = i * 100
        for num in range(start_num, end_num + 1):
            file.write(str(num) + '\n')
print("生成100个txt文件成功！")

# 2、输出如下格式的日志信息
import logging

# 配置日志格式
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y年%m月%d日 %H:%M:%S', level=logging.DEBUG)

# 输出不同级别的日志信息
logging.debug('logging debug message')
logging.info('logging info message')
logging.warning('logging warning message')
logging.error('logging error message')
logging.critical('logging critical message')

# 1、创建一个 3x3 并且值从0到8的矩阵
import numpy as np

matrix = np.arange(9).reshape(3, 3)
print(matrix)

# 2、创建一个 10x10 的随机数组并找到它的最大值和最小值提示：可以使用np.random.random((10,10))创建随机数组
import numpy as np

random_array = np.random.random((10, 10))

max_value = np.max(random_array)
min_value = np.min(random_array)

print("随机数组:")
print(random_array)
print("\n最大值:", max_value)
print("最小值:", min_value)

# 3、一个5x3的矩阵与一个3x2的矩阵相乘，矩阵乘积是什么？
import numpy as np

matrix1 = np.random.rand(5, 3)
matrix2 = np.random.rand(3, 2)

# 将两个矩阵相乘
result_matrix = np.dot(matrix1, matrix2)

print("第一个矩阵:")
print(matrix1)
print("\n第二个矩阵:")
print(matrix2)
print("\n矩阵相乘的结果:")
print(result_matrix)

# 4、创建一个长度为10，并且除了第五个值为1，其他值均为0的一维数组。
import numpy as np

# 创建长度为10的一维数组
array = np.zeros(10)
array[4] = 1

print(array)

import numpy as np
import matplotlib.pyplot as plt

# 定义函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# 生成 x 值
x = np.linspace(-5, 5, 100)  # 在区间 [-5, 5] 生成 100 个点

# 计算对应的 y 值
y = sigmoid(-x)

# 绘制函数图像
plt.figure()
plt.plot(x, y, label='y = 1 / (1 + e^(-x))')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Plot of y = 1 / (1 + e^(-x))')
plt.grid(True)
plt.legend()
plt.show()

import numpy as np
import pandas as pd

data = {
    'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
    'age': [2.5, 3, 0.5, 3.6, 5, 2, 4.5, 5, 7, 3],
    'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
    'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']
}


labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

df = pd.DataFrame(data, index=labels)
df

# (1) 选择df中列标签为animal和age的数据
selected_data = df[['animal', 'age']]
selected_data

# (2)选择visits大于2的行
selected_rows = df[df['visits'] > 2]
selected_rows

# (3)将f行的age改为1.5
df.loc['f','age'] = 1.5
df

# (4)计算visits列的数据总和
df['visits'].sum()