# 高质量python语法题
'''
编写一个程序，查找所有此类数字，它们可以被7整除，但不能是5的倍数
（在2000和3200之间（均包括在内））。获得的数字应以逗号分隔的顺序打印在一行上。
'''
# 法一：循环
# for i in range(2000, 3001):
# if i % 7 == 0 and i % 5 != 0:
# print(i, end=',')
# 法二：使用生成器和列表理解
# print(*(i for i in range(2000, 3001) if i % 7 == 0 and i % 5 != 0), sep=",")
'''
编写一个程序，可以计算给定数字的阶乘，结果应以逗号分隔的顺序打印在一行上，
假设向程序提供了以下输入：8然后，输出应为：40320
'''
# 法一：for循环
# a = int(input())
# res = 1
# for i in range(1, a + 1):
# res *= i
# print(res, end = ',')
# 法二：
# while True:
# try:
# num = int(input())
# break
# except ValueError as arr:
# print(arr)
# res = 1
# while num:
# res *= num
# num -= 1
# print(res, end=",")
'''
使用给定的整数n，编写程序以生成包含（i，ixi）的字典，
该字典为1到n之间的整数（都包括在内）。然后程序应打印字典。
'''
# 使用for循环：
# n = int(input())
# dic = {}
# for i in range(1, n + 1):
# dic[i] = i * i
# print(dic)
# 使用字典
# n = int(input())
# res = {i: i * i for i in range(1, n + 1)}
# print(res)
'''
编写一个程序，该程序接受以逗号分隔的4位二进制数字序列作为输入，
然后检查它们是否可被5整除。被5整除的数字将以逗号分隔的顺序打印。
'''
# 朴素方法
# def check(x):
# tot, pw = 0, 1
# reversed(x)
# for i in x:
# tot += pw * (ord(i) - 48)
# pw *= 2
# return tot % 5
#
#
# data = input().split(",")
# ls = []
# for i in data:
# if check(i) == 0:
# ls.append(i)
#
# print(",".join(ls))
# 推导式法
# data = input().split(",")
# data = [num for num in data if int(num, 2) % 5 == 0]
# print(",".join(data))
'''
问题:编写一个程序，该程序接受控制台以逗号分隔的数字序列，并生成包含每个数字的列表和元组。假设向程序提供以下输入:
34岁,67年,55岁,33岁,12日,98年
则输出为:['34'， '67'， '55'， '33'， '12'， '98']
('34'， '67'， '55'， '33'， '12'， '98')
提示:在为问题提供输入数据的情况下，应该假设它是控制台输入。方法可以将列表转换为元组
'''
# import re
# print('请输入一组数字：')
# values=input()
# l=values.split(",")
# k=re.findall(r'[0-9]+',values)
# t=tuple(k)
# print (k)
# print (t)
'''
编写一个程序，查找所有介于1000和3000之间的数字（都包括在内），
以使数字的每个数字均为偶数。获得的数字应以逗号分隔的顺序打印在一行上。
'''
# for循环
# for i in range(1000, 3001):
# flag = True
# for j in str(i):
# if int(j) % 2 != 0 or j == '0':
# flag = False
# break
# if flag:
# print(i, end=",")
# 使用列表
# ls = []
# for i in range(1000, 3001):
# flag = True
# for j in str(i):
# if ord(j) % 2 != 0:
# flag = False
# if flag == True:
# ls.append(str(i))
# print(",".join(ls))
'''
编写一个接受句子并计算字母和数字数量的程序
'''
# 使用内置函数str.isalpha() and str.isnumeric()
# s = input()
# letter, digit = 0, 0
# for i in s:
# if i.isalpha():
# letter += 1
# elif i.isnumeric():
# digit += 1
# print(f"{letter}\n{digit}")
# 使用ascII
# s = input()
# letter, digit = 0, 0
# for i in s:
# if 'a' <= i and i <= 'z' or 'A' <= i <= 'Z':
# letter += 1
# if i >= '0' and i <= '9':
# digit += 1
# print("{}\n{}".format(letter, digit))
'''
编写一个接受句子的程序，并计算大写字母和小写字母的数量。
'''
# 使用ascII
# s = input()
# upper, lower = 0, 0
# for i in s:
# if 'a' <= i and i <= 'z':
# upper += 1
# elif 'A' <= i and i <= 'Z':
# lower += 1
# print(f"{upper}\n{lower}")
# 使用内置函数str.isupper() and str.islower()
# s = input()
# upper, lower = 0, 0
# for i in s:
# upper += i.isupper()
# lower += i.islower()
# print("{}{}".format(upper, lower))
'''
问题:定义一个至少有两个方法的类: getString:从控制台输入获取字符串 printString::打印大写母的字符串。
还请包含简单的测试函数来测试类方法。提示:使用_init__方法构造一些参数
'''
# class InputOutString(object):
# def __init__(self):
# self.s = ""
# def getString(self):
# self.s = input()
# def printString(self):
# print(self.s.upper())
# strObj = InputOutString()
# strObj.getString()
# strObj.printString()
'''
问题:
编写一个程序，根据给定的公式计算并打印值:
以下是C和H的固定值:C是50。H是30。D是一个变量，它的值应该以逗号分隔的序列输入到程序中。
例子假设程序的输入序列是逗号分隔的:100，150，180，
程序输出为:18，22，24
提示:如果接收到的输出是小数，则应四舍五入到其最近的值
(例如，如果接收到的输出是26.0，则应打印为26)。
在为问题提供输入数据的情况下，应该假设它是控制台输入。
'''
# import math
# res = []
# c = 50
# h = 30
# ls = [x for x in input().split(",")]
# for i in ls:
# res.append(str(int(round(math.sqrt(2 * c * float(i) / h)))))
# print(",".join(res))
'''
问题:编写一个程序，以2位数字，X,Y作为输入，生成一个二维数组。数组的第i行和第j列中的元素值应该是i*j。
注意:i= 0,1 . .,X - 1; j = 0, 1,Y-1。
例子假设程序有以下输入:3、5
则程序输出为:[[0,0,0,0,0],[0,1,2,3,4],[0,2,4,6,8]]
提示:注意:如果要为问题提供输入数据，应该假设它是一个控制台输入，以逗号分隔。
'''
# input_str = input()
# dimensions = [int(x) for x in input_str.split(',')]
# rowNum = dimensions[0]
# colNum = dimensions[1]
# multilist = [[0 for col in range(colNum)] for row in range(rowNum)]
# for row in range(rowNum):
# for col in range(rowNum):
# multilist[row][col] = row * col
# print(multilist)
'''
问题:编写一个程序，接受逗号分隔的单词序列作为输入，
按字母顺序排序后按逗号分隔的序列打印单词。假设向程序提供以下输入:
without,hello,bag,world
则输出为:
bag,hello,without,world
提示:在为问题提供输入数据的情况下，应该假设它是控制台输入。
'''
# items = [x for x in input().split(',')] #要学会用列表推导式输入！
# items.sort()
# print(','.join(items))
'''
问题:编写一个程序，接受一行序列作为输入，并在将句子中的所有字符大写后打印行。
假设向程序提供以下输入:
Hello world
Practice makes perfect
则输出为:
HELLO WORLD
PRACTICE MAKES PERFECT
提示:在为问题提供输入数据的情况下，应该假设它是控制台输入。
'''
# lines = []
# while True:
# s = input()
# if s:
# lines.append(s.upper())
# else:
# break
# for sentance in lines:
# print(sentance)
'''
问题:编写一个程序，接受一系列空格分隔的单词作为输入，并在删除所有重复的单词并按字母数字排序后打印这些单词。
假设向程序提供以下输入:
hello world and practice makes perfect and hello world again
则输出为:
again and hello makes perfect practice world
提示:在为问题提供输入数据的情况下，应该假设它是控制台输入。
我们使用set容器自动删除重复的数据，然后使用sort()对数据进行排序。
'''
# str = input()
# words = [x for x in str.split(' ')]
# print(" ".join(sorted(list(set(words)))))
'''
题：编写一个程序，计算a + aa + aaa + aaaa的值，给定的数字作为a的值。
假设为程序提供了以下输入：9
然后，输出应该是： 11106
提示：如果输入数据被提供给问题，则应该假定它是控制台输入。
'''
# a = input()
# res = int(a) + int(a + a) + int(a + a + a) + int(a + a + a + a)
# print("%d" % res)
'''
使用列表推导来对列表中的每个奇数。 该列表由一系列逗号分隔的数字输入。
假设为程序提供了以下输入：
1,2,3,4,5,6,7,8,9
然后，输出应该是：
1,3,5,7,9
'''
# str = input()
# ls = [x for x in str.split(",") if int(x) % 2 != 0]
# print(",".join(ls))
'''
题：编写一个程序，根据控制台输入的事务日志计算银行帐户的净金额。 事务日志格式如下所示：
D 100
W 200
D表示存款，而W表示提款。
假设为程序提供了以下输入：
D 300
D 300
W 200
D 100
然后，输出应该是：
500
'''
# netAmount = 0
# while True:
# s = input()
# if not s:
# break
# values = s.split(" ") # 除去空格！
# if values[0] == "D":
# netAmount += int(values[1])
# elif values[0] == "W":
# netAmount -= int(values[1])
# else:
# pass
# print(netAmount)
'''
题：网站要求用户输入用户名和密码进行注册。编写程序以检查用户输入的密码的有效性。
以下是检查密码的标准：
1. [a-z]之间至少有1个字母
2. [0-9]之间至少有1个数字
1. [A-Z]之间至少有一个字母
3. [$＃@]中至少有1个字符
4.最短交易密码长度：6
5.交易密码的最大长度：12
您的程序应接受一系列逗号分隔的密码，并将根据上述标准进行检查。将打印符合条件的密码，每个密码用逗号分隔。
例：如果以下密码作为程序的输入：
ABd1234@1,a F1#,2w3E*,2We3345
然后，程序的输出应该是：
ABd1234@1
提示：如果输入数据被提供给问题，则应该假定它是控制台输入。
'''
'''
正则表表达式匹配字符串：
import re
a = re.match('test', 'testasdtest')
print(a) # 返回一个匹配对象
print(a.group()) # 返回test，获取不到则报错
print(a.span()) # 返回匹配结果的位置，左闭右开区间
print(re.match('test', 'atestasdtest')) # 返回None
>>> <re.Match object; span=(0, 4), match='test'>
>>> test
>>> (0, 4)
>>> None
'''
# import re
# res = []
# items = [x for x in input().split(",")]
# for c in items:
# if len(c) < 6 or len(c) > 12:
# continue
# else:
# pass
# if not re.match("[a-z]", c):
# continue
# elif not re.match("[0-9]", c):
# continue
# elif not re.match("[A-Z]", c):
# continue
# elif not re.match("[#$@]", c):
# continue
# elif re.match("/s", c):
# continue
# else:
# pass
# res.append(c)
# print(res)
'''
题：您需要编写一个程序，按升序对（名称，年龄，高度）元组进行排序，
其中name是字符串，age和height是数字。 元组由控制台输入。 排序标准是：
1：根据名称排序;
2：然后根据年龄排序;
3：然后按分数排序。
优先级是name > age > 得分。
如果给出以下元组作为程序的输入：
Tom,19,80
John,20,90
Jony,17,91
Jony,17,93
Json,21,85
然后，程序的输出应该是：
[（'John'，'20'，'90'），（'Jony'，'17'，'91'），（'Jony'，'17'，'93'），
（'Json'，'21 '，'85'），（'Tom'，'19'，'80'）]
'''
# from operator import itemgetter, attrgetter
# l = []
# print("请输入：")
# while True:
# s = input()
# if not s:
# break
# l.append(tuple(s.split(",")))
# print (sorted(l, key=itemgetter(0,1,2)))
'''
题：使用生成器定义一个类，该生成器可以在给定范围0和n之间迭代可被7整除的数字。
提示：考虑使用yield。
'''
# def putNumbers(n):
# i = 0
# while i<n:
# j=i
# i=i+1
# if j%7==0:
# yield j
# for i in putNumbers(100):
# print (i)
'''
题：编写一个程序来计算输入中单词的频率。 按字母顺序对键进行排序后输出。
假设为程序提供了以下输入：
New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3.
然后，输出应该是：
2:2
3.:1
3?:1
New:1
Python:5
Read:1
and:1
between:1
choosing:1
or:2
to:1
'''
# dic = {}
# line = input()
# for word in line.split():
# dic[word] = dic.get(word, 0) + 1
# words = sorted(dic.keys())
# for c in words:
# print("%s:%d" % (c, dic[c]))
'''
题：写一个可以计算数字平方值的方法
提示： 使用**运算符
'''
# def square(x):
# return x ** 2
# print(square(3))
'''
题：Python有许多内置函数，如果您不知道如何使用它，您可以在线阅读文档或查找一些书籍。
但是Python为每个内置函数都有一个内置的文档函数。
请编写一个程序来打印一些Python内置函数文档，例如abs（），int（），raw_input（）
并为您自己的功能添加文档
提示：内置文档方法是__doc__
'''
# print(abs.__doc__)
# print(int.__doc__)
# print(input.__doc__)
# def square(num):
# '''Return the square value of the input number.
# The input number must be integer.
# '''
# return num ** 2
# print(square(2))
# print(square.__doc__)
'''
题：定义一个类，它具有类参数并具有相同的实例参数。
提示：定义一个实例参数，需要在__init__方法中添加它。
您可以使用构造参数初始化对象，也可以稍后设置该值
'''
# class Person:
# # Define the class parameter "name"
# name = "Person" #！这是类的name
# def __init__(self, name=None):
# # self.name is the instance parameter
# self.name = name #！这是实例的name
# jeffrey = Person("Jeffrey")
# print("%s name is %s" % (Person.name, jeffrey.name))
# nico = Person()
# nico.name = "Nico"
# print("%s name is %s" % (Person.name, nico.name))
'''
判断练习：用户名和密码是否正确
'''
# import getpass
# username = input()
# password = getpass.getpass()
# if username == 'bob' and password = '123456':
# print("ok")
# else:
# print("no!")
'''
猜数：基础实现
'''
# import random
# num = random.randint(0,10) #随机生成1 - 10之间的数
# answer = int(input())
# if answer > num:
# print("<")
# elif answer < num:
# print(">")
# elif answer == num:
# print("nb!the num is %d" % num)
'''
石头剪刀布
'''
# import random
# all_choices = ['石头', '剪刀', '布']
# win_list = [['石头', '剪刀'], ['剪刀', '布'], ['布', '石头']]
# prompt = """(0) 石头
# (1) 剪刀
# (2) 布
# 请选择 (0/1/2): """
# computer = random.choice(all_choices)
# ind = int(input(prompt))
# player = all_choices[ind]
# print("Your choice: %s, Computer's choice: %s" % (player, computer))
# if player == computer:
# print('\033[32;1m 平局、033[0m')
# elif [player, computer] in win_list:
# print('\033[31;1mYou WIN!!!\033[0m')
# else:
# print('\033[31;1mYou LOSE!!!\033[0m')
'''
猜数，5 次机会
'''
# import random
# num = random.randint(1, 10)
# counter = 0
# while counter < 5:
# answer = int(input('guess the number: '))
# if answer > num:
# print('猜大了')
# elif answer < num:
# print('猜小了')
# else:
# print('猜对了')
# break
# counter += 1
# else: # 循环被 break 就不执行了，没有被 break 才执行
# print('the number is:', num)
'''
列表实现斐波那契数列
'''
# fib = [0, 1]
# for i in range(8):
# fib.append(fib[-1] + fib[-2])
# print(fib)
'''
九九乘法表
'''
# for i in range(1, 10):
# for j in range(1, i + 1):
# print("%d * %d = %d" % (i, j, i * j), end=' ')
# print()
'''
已知一个字符串为 “hello_world_yoyo”，如何得到一个队列 [“hello”,”world”,”yoyo”] ？
'''
# str = input()
# ls = [x for x in str.split("_")]
# print(ls)
'''
有个列表 [“hello”, “world”, “yoyo”]，如何把列表里面的字符串联起来，
得到字符串 “hello_world_yoyo”？
提示：使用 join 函数将数据转换成字符串：
'''
# ls = [x for x in input().split(",")]
# print(ls)
# print(",".join(ls))
'''
把字符串 s 中的每个空格替换成”%20”
输入：s = “We are happy.”
输出：“We%20are%20happy.”。
'''
# s = input()
# s = s.replace(' ', '%20') #支持原地替换
# print(s)
'''
从下标 0 开始索引，找出单词 “welcome” 在字符串“Hello, welcome to my world.”
中出现的位置，找不到返回 -1。
'''
# def test():
# message = 'Hello, welcome to my world.'
# world = 'welcome'
# if world in message:
# return message.find(world)
# else:
# return -1
# print(test())
'''
统计字符串“C” 中字母 w 出现的次数。
'''
# str = input()
# c = input()
# res = 0
# for i in str:
# if i == 'w':
# res += 1
# print(res)
'''
输入一个字符串 str，输出第 m 个只出现过 n 次的字符，
如在字符串 gbgkkdehh 中，找出第 2 个只出现 1 次的字符，输出结果：d
'''
# str = input()
# m, n = map(int, input().split())
# ls = []
# for c in str:
# if str.count(c) == n:
# ls.append(c)
# print(ls[m - 1]) #切记list下标是从0开始的！
#
'''
判断字符串 a = “welcome to my world” 是否包含单词 b = “world”，
包含返回 True，不包含返回 False。
'''
# def check(str, c):
# for c in str:
# if str.count(c) != 0:
# return True
# return False
# str, c = input().split(",")
# print(check(str, c))
'''
从 0 开始计数，输出指定字符串 A = “hello” 在字符串 B = “hi how are you hello world, hello yoyo!”
中第一次出现的位置，如果 B 中不包含 A，则输出 -1。
'''
# str = input()
# c = input()
# print(str.find(c))
'''
从 0 开始计数，输出指定字符串 A = “hello”在字符串 B = “hi how are you hello world, hello yoyo!”
中最后出现的位置，如果 B 中不包含 A，则输出 -1。
'''
# str = input()
# c = input()
# str = str[::-1]
# c = c[::-1]
# print(len(str) - str.find(c) - len(c))
# def test(string, str):
# # 定义 last_position 初始值为 -1
# last_position = -1
# while True:
# position = string.find(str, last_position+1)
# if position == -1:
# return last_position
# last_position = position
# print(test('hi how are you hello world, hello yoyo!', 'hello'))
'''
如何判断一个字符串是不是纯数字组成？
'''
# str = input()
# if str.isdigit():
# print(True)
# else:
# print(False)
'''
利用 Python 提供的类型转行，将用户输入的数据转换成浮点数类型，
如果转换抛异常，则判断数字不是纯数字组成。
'''
# def test(num):
# try:
# return float(num)
# except ValueError:
# print("不是数字！")
# str = input()
# print(test(str))
'''
将字符串 a = “ welcome to my world ”首尾空格去掉
Python 提供了strip() 方法，可以去除首尾空格，
rstrip() 去掉尾部空格，lstrip() 去掉首部空格，replace(" ", “”) 去掉全部空格。
'''
# a = ' welcome to my world '
# print(a.strip())
# 还可以通过递归的方式实现：
# def trim(s):
# flag = 0
# if s[:1]==' ':
# s = s[1:]
# flag = 1
# if s[-1:] == ' ':
# s = s[:-1]
# flag = 1
# if flag==1:
# return trim(s)
# else:
# return s
# print(trim(' Hello world! '))
# 通过 while 循环实现：
# def trim(s):
# while(True):
# flag = 0
# if s[:1]==' ':
# s = s[1:]
# flag = 1
# if s[-1:] == ' ':
# s = s[:-1]
# flag = 1
# if flag==0:
# break
# return s
# print(trim(' Hello world! '))
'''
输入字符串，去重并按字典序排序。
'''
# str = input()
# str_list = list(set(str))
# str_list = sorted(str_list)
# print("".join(str_list))
# def test():
# s = 'ajldjlajfdljfddd'
# # 定义一个数组存放数据
# str_list = []
# # for循环s字符串中的数据，然后将数据加入数组中
# for i in s:
# # 判断如果数组中已经存在这个字符串，则将字符串移除，加入新的字符串
# if i in str_list:
# str_list.remove(i)
# str_list.append(i)
# # 使用 sorted 方法，对字母进行排序
# a = sorted(str_list)
# # sorted方法返回的是一个列表，这边将列表数据转换成字符串
# return "".join(a)
# print(test())
'''
结果：
**
****
******
********
******
****
**
'''
# def test():
# n = 8
# for i in range(-int(n/2), int(n/2) + 1):
# print(" "*abs(i), "*"*abs(n-abs(i)*2))
# print(test())
'''
给一个不多于 5 位的正整数（如 a = 12346），求它是几位数和逆序打印出各位数字。
'''
# num = input()
# print("%d %s" % (len(num), num[::-1]))
# class Test:
# # 计算数字的位数
# def test_num(self, num):
# try:
# # 定义一个 length 的变量，来计算数字的长度
# length = 0
# while num != 0:
# # 判断当 num 不为 0 的时候，则每次都除以10取整
# length += 1
# num = int(num) // 10
# if length > 5:
# return "请输入正确的数字"
# return length
# except ValueError:
# return "请输入正确的数字"
# # 逆序打印出个位数
# def test_sorted(self, num):
# if self.test_num(num) != "请输入正确的数字":
# # 逆序打印出数字
# sorted_num = num[::-1]
# # 返回逆序的个位数
# return sorted_num[-1]
# print(Test().test_sorted('12346'))
'''
如果一个 3 位数等于其各位数字的立方和，则称这个数为水仙花数。
例如：153 = 13 + 53 + 33，因此 153 就是一个水仙花数。那么如何求 1000 以内的水仙花数（3 位数）。
'''
# ls = [int(x) for x in range(100, 1000) if x == (x % 10) **
# 3 + (x // 10 % 10) ** 3 + (x // 100) ** 3]
# print(" ".join(map(str, ls)))
'''
计算 1-2+3-4+5-…-100 的值。
'''
# def test(sum_to):
# # 定义一个初始值
# sum_all = 0
# # 循环想要计算的数据
# for i in range(1, sum_to + 1):
# sum_all += i * (-1) ** (1 + i)
# return sum_all
# if __name__ == '__main__':
# result = test(sum_to=100)
# print(result)
'''
定义一个类描述数字时钟。
'''
# from time import sleep
# class Clock(object):
# def __init__(self, hour=0, minute=0, second=0):
# self._hour = hour
# self._minute = minute
# self._second = second
# def run(self):
# self._second += 1
# if self._second == 60:
# self._second = 0
# self._minute += 1
# if self._minute == 60:
# self._minute = 0
# self._hour += 1
# if self._hour == 24:
# self._hour == 0
# def show(self):
# return "%02d:%02d:%02d" % (self._hour, self._minute, self._second)
# def main():
# clock = Clock(23, 59, 58)
# while True:
# print(clock.show())
# sleep(1)
# clock.run()
# if __name__ == '__main__':
# main()
'''
练习2：定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。
'''
# from math import sqrt
# class Point(object):
# def __init__(self, x=0, y=0):
# self.x = x
# self.y = y
# def move_to(self, x, y):
# self.x = x
# self.y = y
# def move_by(self, dx, dy):
# self.x += dx
# self.y += dy
# def calc(self, other):
# dx = self.x - other.x
# dy = self.y - other.y
# return sqrt(dx ** 2 + dy ** 2)
# def main():
# p1 = Point(3, 5)
# p2 = Point()
# print(p1)
# print(p2)
# p2.move_by(-1, 2)
# print(p2)
# print(p1.calc(p2))
# if __name__ == "__main__":
# main()
'''
继承实例
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people): #student为子类，people为父类
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
'''
'''
'''
2万+
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
