#1.输出：Python是一种跨平台、开源、免费的高级编程语言。
print("Python是一种跨平台、开源、免费的高级编程语言。")
for i in range(1,10):
print(str(i)*i)
for i in range(1, 10):
j = 1
while j <= i:
print("*", end='')
j += 1
print()
rows = int(input())
for i in range(rows+1):
for j in range(0, rows - i):
print(end=' ')
for k in range(rows - i, rows):
print('*', end=' ')
print('')
#2. 从键盘输入圆的半径，求圆的面积有多大？输出结果保留小数点2位。（其中，π=3.14）
# 面积公式：s=π*r*r
radius = float(input("")) # 从键盘输入圆的半径
area = 3.14 * radius * radius # 计算圆的面积
print("圆的面积是{:.2f}".format(area)) # 输出结果，保留两位小数
#3. 根据输入的月份，输出对应的季度
month = int(input(""))# 判断月份对应的季度
if month in [1, 2, 3]:
print("第一季度")
elif month in [4, 5, 6]:
print("第二季度")
elif month in [7, 8, 9]:
print("第三季度")
elif month in [10, 11, 12]:
print("第四季度")
#4. 输入一个正整数，计算该正整数各位数字的和
num = input("") # 从键盘输入一个正整数
total = 0 # 计算各位数字的和
for digit in num:
total += int(digit)
print(total) # 输出结果
#5. 对于分数换成小数的时候，会要求保留指定位数的小数，实现转化小数的保留位数的功能
def hanshu(x, y):
# 解析分数表达式
f, m = x.split('/')
n_f = int(f)
d_m = int(m)
# 转换分数为小数
num = n_f / d_m
# 使用字符串格式化来保留指定的小数位数
z = "{:.{}f}".format(num, y)
return z
# 读取输入
x = input().strip()
y = int(input().strip())
# 调用函数并输出结果
print(hanshu(x, y))
#6. 在网络中出现敏感词，我们需要将其转换成***
x = eval(input())
y = input()
for word in x:y = y.replace(word, '***')
print(y)
#7. 利用递归函数实现阶层的计算5！ = 1*2*3*4*5 = 120输入5，输出120
def factorial(n):
if n == 0: # 基准情况：0的阶乘是1
return 1
else: # 递归步骤：n的阶乘等于n乘以(n-1)的阶乘
return n * factorial(n - 1)
num = int(input()) # 读取输入
print(factorial(num)) # 输出阶乘结果
#8. 输入键列表和值的列表，输出键值组成的字典。如果键值列表长度不一致，则已短的为准，长的多出来的就忽略掉。
keys = input() # 从键盘输入键的列表
values = input() # 从键盘输入值的列表
keys_list = eval(keys) # 将输入的字符串列表转换为实际的列表
values_list = eval(values) # 用zip函数将键和值配对，并创建字典
dictionary = dict(zip(keys_list, values_list))
print(dictionary) # 输出组成的字典
#9. 输入一串字符串，分别统计出其中字母，数字和其他字符的个数。
input_string = input("请输入一串字符串：") # 获取用户输入的字符串
letter_count = 0 # 初始化计数器
digit_count = 0
other_count = 0
for char in input_string: # 遍历字符串中的每个字符
if char.isalpha(): # 检查字符是否为字母
letter_count += 1
# 检查字符是否为数字
elif char.isdigit():
digit_count += 1
# 如果不是字母也不是数字，则属于其他字符
else:
other_count += 1
# 输出结果
print(f"字母：{letter_count}")
print(f"数字：{digit_count}")
print(f"其他：{other_count})")
#10. 从键盘输入一串字符串，把字符串按照逆序进行输出
# 从键盘输入一串字符串
input_string = input()
# 使用字符串切片功能进行逆序
reversed_string = input_string[::-1]
# 输出逆序后的字符串
print(reversed_string)
#11. 从键盘输入一组数据1，再输入一个数据2，把大于等于数据2的归纳到一个列表中，小于该数据的归纳到另一个列表中。并且把最终的归纳结果用字典表示。
# 从键盘输入一组数据
data_list = eval(input())
# 输入一个数据
threshold = int(input())
# 初始化两个列表，用于存储大于等于和小于该数据的元素
greater_or_equal = []
less_than = []
# 遍历输入的数据列表
for number in data_list:
if number >= threshold:
greater_or_equal.append(number)
else:
less_than.append(number)
# 使用字典存储最终的归纳结果
result = {
'key1': greater_or_equal,
'key2': less_than
}
# 输出字典
print(result)
#12编写一个程序，从两个集合中找出相同的元素。
# 获取用户输入的两个集合
set1_str = input()
set2_str = input()
# 解析输入的字符串为集合
set1 = set(eval(set1_str))
set2 = set(eval(set2_str))
# 找出两个集合的交集
common_elements = set1 & set2
# 输出相同的元素
print(common_elements)
#13. 键盘输入一个元组
# 键盘输入一个元素
# 给元组中添加这个元素，并输出元组。
# 提示：元组是不可变数据类型，没有元素的增删改功能，可以把之转化为列表类型进行操作
# 获取用户输入的元组和元素
input_tuple = eval(input()) # 使用eval函数解析输入的字符串为一个元组
element_to_add = input() # 输入要添加的元素
list_version = list(input_tuple) # 将元组转换为列表
# 添加元素到列表中
list_version.append(element_to_add)
# 将列表转换回元组
updated_tuple = tuple(list_version)
# 输出更新后的元组
print(updated_tuple)
#14. 输入一串字符串，求出字符串的长度（字符的个数），然后输出字符串的长度。
# 获取用户输入的字符串
input_string = input("请输入字符串：")
# 使用len()函数计算字符串的长度
length = len(input_string)
# 输出字符串的长度
print("输出字符串的长度：", length)
#15. 编写程序，判断给定的三个整数是否能构成三角形。若能构成等边三角形，输出3； 若能构成等腰三角形，输出2； 若能构成其他三角形，输出1； 若不能构成三角形，输出0。
# 要求使用函数来实现，不使用函数则扣分。 函数外的代码已经给出，如下所示：
# s=input()
# a,b,c=s.split(' ')
# a,b,c=int(a),int(b),int(c)
# print(trangle(a,b,c))
# 提交时不需要提交这部分代码，写出函数定义的代码，并提交。
def trangle(a, b, c): # 修正了函数名为triangle
# 首先判断是否能构成三角形
if (a + b > c) and (a + c > b) and (b + c > a):
# 判断是否为等边三角形
if a == b == c:
return 3 # 返回3表示等边三角形
# 判断是否为等腰三角形
elif a == b or a == c or b == c:
return 2 # 返回2表示等腰三角形
# 其他类型的三角形
else:
return 1 # 返回1表示其他类型的三角形
else:
# 不能构成三角形
return 0 # 返回0表示不能构成三角形
# #16定义一个Employee类，定义构造方法初始化员工姓名name，工龄year,和绩效工资
# 定义实例方法用于计算员工工资：其中工资=基本工资2000*工龄+绩效工资。
# 定义实例方法输出员工的工资。
# 输入姓名、工龄、绩效工资
# 输出工资
class Employee:
def __init__(self, name, year, performance_bonus):
self.name = name
self.year = year
self.performance_bonus = performance_bonus
def calculate_salary(self):
base_salary = 2000
salary = base_salary * self.year + self.performance_bonus
return salary
def print_salary(self):
salary = self.calculate_salary()
print(f"{self.name}的工资是{salary}")
# 输入姓名、工龄、绩效工资
name = input()
year = int(input())
performance_bonus = int(input())
# 创建Employee对象并计算并输出工资
employee = Employee(name, year, performance_bonus)
employee.print_salary()
#17编写程序，定义一个Point点类，使其能完成打印点的坐标功能。
# 要求：类中包含构造函数，初始化点的横坐标和纵坐标，类中定义实例方法info，输出点的横坐标和纵坐标。
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def info(self):
print(f"点的横坐标:{self.x}，点的纵坐标:{self.y}")
# 输入点的横坐标和纵坐标
x = float(input())
y = float(input())
# 创建Point对象并打印点的坐标
point = Point(x, y)
point.info()
#18输入姓名和成绩，输出相关信息。
#要求：定义类Student，构造方法带2个参数，一个是姓名，一个是成绩。
#定义实例方法info()，用来输出指定格式1信息。
#实现重载方法，使得Student实例可以通过print()输出指定格式2内容。
class Student:
def __init__(self, name, score):
self.name = name
self.score = score
def info(self):
print(f"姓名：{self.name}，成绩：{self.score}")
def __str__(self):
return f"{self.name}:{self.score}"
#19编写一个程序，读入自然数n, 计算1到n(包含n)之间所有奇数的和。
# 读取输入的自然数n
n = int(input())
# 计算1到n之间所有奇数的和
odd_sum = sum(i for i in range(1, n + 1, 2))
# 输出结果
print(odd_sum)
#20输入字符串，输出字符串中次数最多的字母及其出现次数，如果有多个字母出现次数一样，则依次输出字母及其出现次数。
from collections import Counter
# 读取输入的字符串
input_string = input()
# 统计每个字母的出现次数
letter_counts = Counter(input_string)
# 找出出现次数最多的次数
max_count = max(letter_counts.values())
# 找出所有出现次数等于最大次数的字母及其次数
result = {k: v for k, v in letter_counts.items() if v == max_count}
# 输出结果
print(result)
#21在列表制定位置插入新元素
# 读取输入
lst = eval(input())
pos, elem = input().split(',')
pos = int(pos)
elem = eval(elem)
# 插入新元素
lst.insert(pos, elem)
# 输出结果
print(lst)
#22删除列表中制定位置的元素
# 读取输入的第一行，将其转换为列表
input_list = eval(input())
# 读取输入的第二行，将其作为要删除的位置
position = int(input())
# 检查列表是否为空或位置是否超出列表范围
if not input_list or position < 0 or position >= len(input_list):
print("IndexError")
else:
# 删除指定位置的元素
del input_list[position]
# 输出删除后的列表
print(input_list)
#23任意输入三个英文字母，按照在英文字母表中的顺序输出
# 读取输入的三个英文字母，使用','分割
letters = input().split(',')
# 将字母转换为小写（如果需要忽略大小写的话）
# letters = [letter.lower() for letter in letters]
# 对字母列表进行排序
sorted_letters = sorted(letters)
# 输出排序后的字母
print(' '.join(sorted_letters))
#24鸡兔同笼问题是一个经典的数学问题，要求根据给定的总数量和总腿数，计算鸡和兔的数量。我们可以使用Python编写一个函数来解决这个问题。
def solve_chicken_rabbit(total_num, total_legs):
# 检查输入的总数量和总腿数是否合法
if total_num < 1 or total_legs % 2 != 0 or total_legs < total_num * 2 or total_legs > total_num * 4:
return "无法计算鸡和兔的数量"
# 鸡和兔的数量
for chicken in range(total_num + 1):
rabbit = total_num - chicken
if chicken * 2 + rabbit * 4 == total_legs:
return f"鸡的数量：{chicken}，兔的数量：{rabbit}"
# 如果没有找到解
return "无法计算鸡和兔的数量"
# 读取输入
total_num = int(input())
total_legs = int(input())
# 调用函数并输出结果
print(solve_chicken_rabbit(total_num, total_legs))
#25给出一个列表统计包含的元素的个数如果某个元素是列表，则统计结果加上该列表内的元素个数
def count_elements_in_list(lst):
count = 0
for element in lst:
if isinstance(element, list):
count += count_elements_in_list(element)
else:
count += 1
return count
# 读取输入
input_list = eval(input())
# 调用函数并输出结果
print(count_elements_in_list(input_list))
#26输入2个集合，输出两个集合的合并、去重、升序的列表
# 读取输入的两个集合
set1 = set(eval(input()))
set2 = set(eval(input()))
# 合并两个集合
merged_set = set1.union(set2)
# 将合并后的集合转换为列表，并进行升序排序
sorted_list = sorted(list(merged_set))
# 输出结果
print(sorted_list)
#27输入一个列表，找出这个列表中最大数和最小数，然后输出它们的最大公约数。（要求用函数来实现）
from math import gcd
def find_gcd_of_extremes(numbers):
# 找出列表中的最大数和最小数
max_number = max(numbers)
min_number = min(numbers)
# 计算最大数和最小数的最大公约数
result = gcd(max_number, min_number)
return result
# 读取输入
input_list = eval(input())
# 调用函数并输出结果
print(find_gcd_of_extremes(input_list))
#28输入年月日，输出星期几
import datetime
def get_day_of_week(year, month, day):
# 创建一个日期对象
date = datetime.date(year, month, day)
# 获取星期几，并返回对应的字符串
weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
return weekdays[date.weekday()]
# 读取输入
input_date = input()
year, month, day = map(int, input_date.split('-'))
# 调用函数并输出结果
print(get_day_of_week(year, month, day))
#29给你一个字符串 s，找到 s 中最长的回文子串。
# 如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
# 如果有多个答案，返回位置靠前的子串。(babad, 有2个答案bab和aba，返回bab)
def longest_palindrome(s):
n = len(s)
if n < 2:
return s
# 初始化一个二维数组来存储子串是否是回文的布尔值
dp = [[False] * n for _ in range(n)]
max_length = 1
start = 0
# 所有单个字符都是回文
for i in range(n):
dp[i][i] = True
# 检查长度大于1的子串
for length in range(2, n + 1):
for i in range(n - length + 1):
j = i + length - 1
if s[i] == s[j]:
if length == 2:
dp[i][j] = True
else:
dp[i][j] = dp[i + 1][j - 1]
if dp[i][j] and length > max_length:
max_length = length
start = i
return s[start:start + max_length]
# 读取输入
input_string = input()
# 调用函数并输出结果
print(longest_palindrome(input_string))
#30读入3个参数(以空格间隔），第一个是打印的菱形图案的大小（正方形的边长），第二个是菱形字符，第三个是背景字符
def print_diamond(size, char_diamond, char_background):
# 打印上半部分
for i in range(size // 2):
print((char_background * (size // 2 - i)) +
(char_diamond * (2 * i + 1)) +
(char_background * (size // 2 - i)))
# 打印中间一行
print(char_diamond * size)
# 打印下半部分
for i in range(size // 2 - 1, -1, -1):
print((char_background * (size // 2 - i)) +
(char_diamond * (2 * i + 1)) +
(char_background * (size // 2 - i)))
# 读取输入
input_params = input().split()
size = int(input_params[0])
char_diamond = input_params[1]
char_background = input_params[2]
# 调用函数并输出结果
print_diamond(size, char_diamond, char_background)
# 统计大写字母
# 使用input函数获取用户输入的字符串
input_string = input("请输入一串字符串：")
# 初始化大写字母计数器
string_count = 0
# 遍历字符串中的每个字符
for char in input_string:# 检查字符是否是大写字母
if char.isupper():
string_count += 1
# 输出大写字母的个数
print("大写字母的个数是：", string_count)
# 查找子串
# 获取用户输入的整个字符串
a= input("请输入一串字符串：")
# 获取用户想要查找的子串
b = input("请输入要统计的子串：")
# 使用count方法统计子串出现的次数
count = a.count(b)
# 输出结果
print(f"{count}")
# 统计大写字母
a = input ()
count=0
for i in a :
if i. isupper():
count +=1
print (count)
标签：count,输出,入门,Python,list,print,input,输入 From： https://www.cnblogs.com/lyn002126/p/18390889