第十四题:
 
以下代码的输出结果是？
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
 
public class B
 
{
 
    public static B t1 = new B();
 
    public static B t2 = new B();
 
    {
 
        System.out.println("构造块");
 
    }
 
    static
 
    {
 
        System.out.println("静态块");
 
    }
 
    public static void main(String[] args)
 
    {
 
        B t = new B();
 
    }
 
}
 
 
 
 
A 静态块 构造块 构造块 构造块
 
B 构造块 静态块 构造块 构造块
 
C 构造块 构造块 静态块 构造块
 
D:构造块 构造块 构造块 静态块
 
懵逼树上懵逼果，懵逼树下你和我
 
首先看到这道题，我就想着那不是先静态代码块先执行吗
 
话不多说，直接跑代码
 
public class B

{

    public static B t1 = new B();

    public static B t2 = new B();

    {

        System.out.println("构造块");

    }

    static

    {

        System.out.println("静态块");

    }

    public static void main(String[] args)

    {

        B t = new B();

    }

}
 
运行结果
 
 
接着我们看看大家的评论
 

开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，又因为t1 t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载类B了，所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出''构造块''）接着构造函数（无输出）。接着对t2进行初始化过程同t1相同（输出'构造块'），此时就对所有的static变量都完成了初始化，接着就执行static块部分（输出'静态块'），接着执行，main方法，同样也，new了对象，调用构造函数输出（'构造块'）
 
最后答案选择C
 
文章仅个人理解，来在各大网站。如有不合理之处，欢迎吐槽。
 
阅读目录（置顶)(长期更新计算机领域知识）
 
阅读目录（置顶)(长期更新计算机领域知识）
 
阅读目录（置顶)(长期科技领域知识）
 
歌谣带你看java面试题 

for(i=4;i>1;i–)
 for(j=1;j<i;j++)
 putchar(’#’);
 
答案：######
 解析：内部循环完了之后再进行外部循环，第二次外部循环的时候，内部循环从头开始，此时j=1
 putchar:c语言函数之一，作用是向终端输出一个字符,这里一共循环输出6次

写出整洁的代码，是每个程序员的追求。《clean code》指出，要想写出好的代码，首先得知道什么是肮脏代码、什么是整洁代码；然后通过大量的刻意练习，才能真正写出整洁的代码。
 
WTF/min是衡量代码质量的唯一标准，Uncle Bob在书中称糟糕的代码为沼泽（wading），这只突出了我们是糟糕代码的受害者。国内有一个更适合的词汇：屎山，虽然不是很文雅但是更加客观，程序员既是受害者也是加害者。
 
对于什么是整洁的代码，书中给出了大师们的总结：
 
Bjarne Stroustrup：优雅且高效；直截了当；减少依赖；只做好一件事
Grady booch：简单直接
Dave thomas：可读，可维护，单元测试
Ron Jeffries：不要重复、单一职责，表达力（Expressiveness）
 
其中，我最喜欢的是表达力（Expressiveness）这个描述，这个词似乎道出了好代码的真谛：用简单直接的方式描绘出代码的功能，不多也不少。
 
本文记录阅读《clean code》之后个人“深有同感”或者“醍醐灌顶”的一些观点。
 
一、命名的艺术
 
坦白的说，命名是一件困难的事情，要想出一个恰到好处的命名需要一番功夫，尤其我们的母语还不是编程语言所通用的英语。不过这一切都是值得了，好的命名让你的代码更直观，更有表达力。
 
好的命名应该有下面的特征：
 
1.1 名副其实
 
好的变量名告诉你：是什么东西，为什么存在，该怎么使用
 
如果需要通过注释来解释变量，那么就先得不那么名副其实了。
 
下面是书中的一个示例代码，展示了命名对代码质量的提升
 
# bad code
def getItem(theList):
   ret = []
   for x in theList:
      if x[0] == 4:
         ret.append(x)
   return ret

# good code
def getFlaggedCell(gameBoard):
   '''扫雷游戏，flagged： 翻转'''
   flaggedCells = []
   for cell in gameBoard:
      if cell.IsFlagged():
         flaggedCells.append(cell)
   return flaggedCells
 
1.2 避免误导
 
不要挂羊头卖狗肉
不要覆盖惯用缩略语
 
这里不得不吐槽前两天才看到的一份代码，居然使用了 l 作为变量名；而且，user居然是一个list（单复数都没学好！！）
 
1.3 有意义的区分
 
代码是写给机器执行，也是给人阅读的，所以概念一定要有区分度。
 
# bad
def copy(a_list, b_list):
    pass

# good
def copy(source, destination):
    pass
 
1.4 使用读的出来的单词
 
如果名称读不出来，那么讨论的时候就会像个傻鸟
 
1.5 使用方便搜索的命名
 
名字长短应与其作用域大小相对应
 
1.6 避免思维映射
 
比如在代码中写一个temp，那么读者就得每次看到这个单词的时候翻译成其真正的意义
 
二、注释
 
有表达力的代码是无需注释的：The proper use of comments is to compensate for our failure to express ourself in code.
 
注释的适当作用在于弥补我们用代码表达意图时遇到的失败，这听起来让人沮丧，但事实确实如此。The truth is in the code, 注释只是二手信息，二者的不同步或者不等价是注释的最大问题。
 
书中给出了一个非常形象的例子来展示：用代码来阐述，而非注释
 
bad
// check to see if the employee is eligible for full benefit
if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))

good
if (employee.isEligibleForFullBenefits())
 
因此，当想要添加注释的时候，可以想想是否可以通过修改命名，或者修改函数（代码）的抽象层级来展示代码的意图。
 
当然，也不能因噎废食，书中指出了以下一些情况属于好的注释
 
法务信息
对意图的注释，为什么要这么做
警示
TODO注释
放大看似不合理之物的重要性
 
其中个人最赞同的是第2点和第5点，做什么很容易通过命名表达，但为什么要这么做则并不直观，特别涉及到专业知识、算法的时候。另外，有些第一感觉“不那么优雅”的代码，也许有其特殊愿意，那么这样的代码就应该加上注释，说明为什么要这样，比如为了提升关键路径的性能，可能会牺牲部分代码的可读性。
 
最坏的注释就是过时或者错误的注释，这对于代码的维护者（也许就是几个月后的自己）是巨大的伤害，可惜除了code review，并没有简单易行的方法来保证代码与注释的同步。
 
三、函数
 
3.1 函数的单一职责
 
一个函数应该只做一件事，这件事应该能通过函数名就能清晰的展示。判断方法很简单：看看函数是否还能再拆出一个函数。
 
函数要么做什么do_sth, 要么查询什么query_sth。最恶心的就是函数名表示只会query_sth, 但事实上却会do_sth, 这使得函数产生了副作用。比如书中的例子
 
public class UserValidator {
    private Cryptographer cryptographer;
    public boolean checkPassword(String userName, String password) {
        User user = UserGateway.findByName(userName);
        if (user != User.NULL) {
            String codedPhrase = user.getPhraseEncodedByPassword();
            String phrase = cryptographer.decrypt(codedPhrase, password);
            if ("Valid Password".equals(phrase)) {
                Session.initialize();
                return true;
            }
        }
        return false;
    }
}
 
3.2 函数的抽象层级
 
每个函数一个抽象层次，函数中的语句都要在同一个抽象层级，不同的抽象层级不能放在一起。比如我们想把大象放进冰箱，应该是这个样子的：
 
def pushElephantIntoRefrige():
    openRefrige()
    pushElephant()
    closeRefrige()
 
函数里面的三句代码在同一个层级（高度）描述了要完成把大象放进冰箱这件事顺序相关的三个步骤。显然，pushElephant这个步骤又可能包含很多子步骤，但是在pushElephantIntoRefrige这个层级，是无需知道太多细节的。
 
当我们想通过阅读代码的方式来了解一个新的项目时，一般都是采取广度优先的策略，自上而下的阅读代码，先了解整体结构，然后再深入感兴趣的细节。如果没有对实现细节进行良好的抽象（并凝练出一个名副其实的函数），那么阅读者就容易迷失在细节的汪洋里。
 
某种程度看来，这个跟金字塔原理也很像
 
 
每一个层级都是为了论证其上一层级的观点，同时也需要下一层级的支持；同一层级之间的多个论点又需要以某种逻辑关系排序。pushElephantIntoRefrige就是中心论点，需要多个子步骤的支持，同时这些子步骤之间也有逻辑先后顺序。
 
3.3 函数参数
 
函数的参数越多，组合出的输入情况就愈多，需要的测试用例也就越多，也就越容易出问题。
 
输出参数相比返回值难以理解，这点深有同感，输出参数实在是很不直观。从函数调用者的角度，一眼就能看出返回值，而很难识别输出参数。输出参数通常逼迫调用者去检查函数签名，这个实在不友好。
 
向函数传入Boolean（书中称之为 Flag Argument）通常不是好主意。尤其是传入True or False后的行为并不是一件事情的两面，而是两件不同的事情时。这很明显违背了函数的单一职责约束，解决办法很简单，那就是用两个函数。
 
3.4 Dont repear yourself
 
在函数这个层级，是最容易、最直观实现复用的，很多IDE也难帮助我们讲一段代码重构出一个函数。
 
不过在实践中，也会出现这样一种情况：一段代码在多个方法中都有使用，但是又不完全一样，如果抽象成一个通用函数，那么就需要加参数、加if else区别。这样就有点尴尬，貌似可以重构，但又不是很完美。
 
造成上述问题的某种情况是因为，这段代码也违背了单一职责原则，做了不只一件事情，这才导致不好复用，解决办法是进行方法的细分，才能更好复用。也可以考虑template method来处理差异的部分。
 
四、测试
 
非常惭愧的是，在我经历的项目中，测试（尤其是单元测试）一直都没有得到足够的重视，也没有试行过TDD。正因为缺失，才更感良好测试的珍贵。
 
我们常说，好的代码需要有可读性、可维护性、可扩展性，好的代码、架构需要不停的重构、迭代，但自动化测试是保证这一切的基础，没有高覆盖率的、自动化的单元测试、回归测试，谁都不敢去修改代码，只能任其腐烂。
 
即使针对核心模块写了单元测试，一般也很随意，认为这只是测试代码，配不上生产代码的地位，以为只要能跑通就行了。这就导致测试代码的可读性、可维护性非常差，然后导致测试代码很难跟随生产代码一起更新、演化，最后导致测试代码失效。所以说，脏测试 - 等同于 - 没测试。
 
因此，测试代码的三要素：可读性，可读性，可读性。
 
对于测试的原则、准则如下：
 
You are not allowed to write any production code unless it is to make a failing unit test pass. 没有测试之前不要写任何功能代码
You are not allowed to write any more of a unit test than is sufficient to fail; and compilation failures are failures. 只编写恰好能够体现一个失败情况的测试代码
You are not allowed to write any more production code than is sufficient to pass the one failing unit test. 只编写恰好能通过测试的功能代码
 
测试的FIRST准则：
 
快速（Fast）测试应该够快，尽量自动化。
独立（Independent） 测试应该应该独立。不要相互依赖
可重复（Repeatable） 测试应该在任何环境上都能重复通过。
自我验证（Self-Validating） 测试应该有bool输出。不要通过查看日志这种低效率方式来判断测试是否通过
及时（Timely） 测试应该及时编写，在其对应的生产代码之前编写
 
该文章通过 https://openwrite.cn/ 工具创造并群发。

6.for i in range(2,n):
if n%i==0:break
if i==n-1:
print('是素数')
else:
print('不是素数')
7.'abcabcabc'.count('abc')的值为__3__。
8.对于有else子句的for循环和while循环，但循环因循环条件不成立而自然结束时__会__(会或不会)执行else中的代码。
10.已知x='hello world.',那么表达式x.find('x')和x.rfind('x')的值都为__-1__。
12.print("{:#>4d}".format(23))的输出结果是__##23__。
13.以下哪个选项不是Python中的合法名称(2_g):_ag,a_g,ag_,2_g
14.以下哪个选项是python中的合法名称(num_1)：2num,num-1,num_1,num 1
15.print(3+5)语句的运行结果是（8）
16.print(2**4+16%3)  __17__
17.以下程序的输出结果是__0__。
a=8
a%=2
print(a)
18.print("**"*3)的输出结果是(******)。
19.表达式True and False的值为：__False__。
20.以下程序的输出结果是(7)
x=371
print(x%100//10)
21.a,b=1,2则a的值为__1__。
22.在循环语句中，__continue___语句的作用是提前结束本层循环。
23.表达式"abc10'.isalnum()的值为__True__。
24.表达式True*3的值为 __3__。
25.表达式'c:\windows\notepad.exe'.endswith('.exe')的值为__True__。
26.表达式'test.py'.endswith('.py')的值为__True__。
27.表达式 int('123')的值为__123__。
28.表达式 'Beautifule is better than ugly.'.startswith('Be',5)的值为__False__。
29.假设a,b=10,50,则条件表达式a>10 and b<100的值为__False_____。
30.python3.x语句 for i in range(3):print(i,end=',')的输出结果为__0,1,2,__。
31.程序的基本结构：__顺序结构、选择结构和循环结构__。
32.在python语言内置的random库中，哪个函数功能是从序列s中随即选择一个元素(A)：A、choice(s),B、randint(m,n),C、shuffle(s),D、uniform(m,n)
33.以下程序的输出结果(3
5)
print(3,end="")
print()
print(5)
34.表达式int(False)的值为：__0__。
35.以下程序的输出结果是(-3)
a=-8
a//=3
print(a)
36.print(15%4)的输出结果是(3)
37.有python语句：
for s in "abced":
print(s,end=' ')
的运行结果是（a b c d e）。
38.print("{:&>8}".format("python"))的输出结果是（$$python）
39.有python语句：
for i in range(100,999+1):
a=i//100
b=i//10%10
c=i%10
if a**3 + b**3 + c**3 == i:
print(i,end="  ")
的运行结果是（153  370  371  407）。
40.下列Python语句：
x,y=30,70
min = x if x
print(min)
的运行结果是（30）。
41.表达式'abc' in ('abcdefg')的值为__True__。
42.已知x,y=3,5,那么执行x,y=y,x之后，x的值为__5__。
43.表达式'aaasdf'.strip('a')的值为__'sdf'__。
44.已知x=3，那么执行语句 x += 6之后，x的值为__9__。
45.python用于表示逻辑与运算的关键字是__and__。
46.表达式 int(4**0.5)的值为__2__。
47.表达式len('aaaassddf'.strip('afds'))的值为__0__。
48.在循环语句中，__continue__语句的作用是提前进入下一次循环。
49.Python标准库random中的__choice()__方法作用是从序列中随机选择1个元素。
50.已知x=3，那么执行语句 x*=6之后，x的值为__18__。
51.以下程序的输出结果是(9630)。
s="0123456789"
print(s[::-3])
52.在python语句中，条件表达式中判断相等用的关系运算符是（==）。
53.表达式 chr(ord('A')+2)的值为__'C'__。
54.表达式 sum(range(10))的值为__45__。
55.x=-9
print(x) if x>=0 else print(-x)
的输出结果为__9__。
56.python的内置函数__len()__可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
57.表达式'apple.peach,banana,pear'.find('p')的值为__1__。
58.表达式 len('SDIBT')的值为__5__。
59.表达式':'.join('hello world.'.split())的值为__'hello:world.'__。
60.python语句''.join(list('hello world!'))执行的结果是__'hello world!'__。
61.表达式 3 or 5 的值为__3__。
62.表达式 16**0.5的值为 __4.0__。
63.有关for循环和while循环的退出(有两种方式：一是循环条件不成立或循环序列遍历结束，二是在循环过程中遇到break语句)。
64.分支结构的类型：单分支、双分支、多分支和嵌套if结构。
65.关于多分支结构if-elif-else语句的说法正确的是:最多只会执行一个分支。
66.表达式not (True and False）的值为(True)。
67.s.islower()方法是用来：判断字符串s中的字母是否全为小写。
68.以下程序的输出结果为(bird-fish-monkey-rabbit)
s=['bird','fish','monkey','rabbit']
print("-".join(s))
69.python语言的运行方式有__交互__式和文件式两种。
70.表达式'a'+'b'的值为 __'ab'__。
71.表达式'Hello world'.lower()的值为__'hello world'__。
72.表达式 1234%1000//100的值为__2__。
73.表达式'abc10'.isdigit()的值为__False__。
74.表达式 'hello world, hellow every one'.replace('hello','hi')的值为__'hi world, hiw every one'__。
75.表达式 5 if 5>6 else (6 if 3>2 else 5)的值为__6__。
76.表达式 len(range(1,10))的值为__9__。
77.表达式 'abcab'.replace('a','yy')的值为__'yybcyyb'__。
78.Python标准库math中用来计算平方根的函数是__sqrt()__。
79.以下程序的输出结果是(('bird,fish,monkey,rabbit,tiger,','monkey','')):
s='bird,fish,monkey,rabbit,tiger,monkey'
print(s.rpartition("monkey"))
80.int(2<3)的值为__0__。
81.gcd(27,42)的值为__3__。
82.python语言的提示符是__>>>__。
83.表达式':'.join('1,2,3,4,5'.split(','))的值为__'1:2:3:4:5'__。
84.eval()函数可以将__字符串__解析成数值。
85.表达式min(['11','2','3'])的值为__'11'__。
86.print("{:=<8}".format("python"))的输出结果是__python==__。
87.print(str(3+5))的输出结果是__8__。
88.Python语言的主要应用领域是(人工智能，网络爬虫，数据分析与处理)
89.判断三条线段a,b,c能否构成三角形的条件表达式，正确的是__(a>0)and(b>0)and(c>0)and(a+b>c)and(a+c>b)and(b+c>a)__。
90.语句a,b=b,a的功能是__交换a和b的值__。
91.下列Python语句：
k=16
while k>1:
k=k/2
print(k)
的运行结果是__1.0__。
92.在Python语句内置的random库中，哪个函数的功能是生成一个[m,n]之间的随机小数：__uniform(m,n)__。
93.表达式'aaaassddf'.strip('af')的值为__'ssdd'__。
94.Python语句中的当行注释语句以符号__#__作为开始。
95.Python运算符中用来计算整商的是__//__。
96.表达式True*3的值为 __3__。
97.表达式 len('Hello world!'.ljust(20))的值为__20__。
98.表达式'a'.join('abc',partition('a'))的值为__'aaabc'__。
二、判断题
1.s[1:5]可以去除字符串s中从索引值1开始到5结束的子字符串。（F)
2.Python是一种跨平台、开源、免费的高级动态编程语言。(T)
3.判断整数x是否偶数的条件表达式为x%2=0。(F)
4.判断整数x是否偶数的条件表达式为x%2==0。（T)
5.带有else子句的循环如果因为执行了break语句而退出的话，则会执行else子句中的代码。(F)
6.print(1+'2')的输出结果是'3'。（F）
7.编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。（T）
8.print(s[0,5,-1])输出的是字符串s左起6个字符的反向字符串。(F)
9.python使用缩进来体现代码之间的逻辑关系。(T)
10.在python的循环体内，continue语句的作用是结束该语句所在的循环。(F)
11.如果仅仅是用于控制循环次数，那么使用for i in range(20)和 for i in range(20,40)的作用是等价的。(T)
12.在python的循环体内，continue语句的作用是结束这一轮的循环，程序跳转到循环头部。(T)
13.s[::-1]的功能是对字符串s反向取整串。（T）
14.python变量名区分大小写，所以student和Student不是同一个变量。（T）
15.python不允许使用关键字作为变量名，允许使用内置函数作为变量名，但这会改变函数名的含义。(T)
16.放在一对三引号之间的任何内容将被认为是注释。(F)
17.print(8,end="")的功能是输出8以后不换行。(T)
18.a,b,c=10,20语句执行完以后，变量c的值为0。(F)
19.如果需要连接大量字符串成为一个字符串，那么使用字符串对象的join()方法比运算符+具有更高的效率。(T）
20.python标准库random的方法randint(m,n)用来生成一个[m,n]区间上的随机整数。(T)
21.ord("c")-ord("a")的值为2。(T)
22.Python运算符%不仅可以用来求余数，还可以用来格式化字符串。（T）
23.a**=b等价于a=a**b。(T)
24.s.replace(" ","")的功能是在字符串s尾部添加空格。(F)
25.a=b=10语句执行完以后，变量a和b的值都是10。(T)
26.在循环中continue语句的作用是跳出当前循环。(F)
27.表达式 'a'+1的值为'b'。(F)
28.Python语句只有一种运行方式——文件式。（F）
29.加法运算符可以用来连接字符串并生成新字符串。(T）
30.range(m,n)得到的迭代序列为：m,m+1,m+2,m+3,...,n-1。(T)
31.在python中0xad是合法的十六进制数字表示形式。(T)
32.当作为条件表达式时，空值、空字符串、空列表、空元组、空字典、空集合、空迭代对象以及任意形式的数字0都等价于False。(T)
33.已知x=3,那么赋值语句x='abcedfg'是无法正常执行的。(F)
34.在python中，变量不直接存储值，而是存储值的引用，也就是值在内存中的地址。(T)
35.在random模块的函数randint(1,100）获取随机数时，有可能会得到100。(T)
36.在python中可以使用for作为变量名。（F）
37.Python代码的注释只有一种方式，那就是使用#符号。（F）
38.random库中的函数random（）返回左闭右开区间[0.0,0.1)中的一个随机浮点数。（T）
39.在python的循环体内，break语句的作用是结束该语句所在的循环。(T)
40.在python中，关系运算符可以连续使用，例如00并且a
41."ABC">"ab"结果为False。（T）

42.带有else子句的循环如果因为执行了break语句而退出的话，则会执行else子句的代码。(F)

43.在python3.0中可以使用中文作为变量名。(T)

44.Python中一切内容都可以称为对象。(T)

45.Python语言的标示符只能以字母开头，后面可以跟字母、数字、下划线。(F)

46.程序中异常处理结构在大多数情况下是没必要的。(F)

三、编程题

'''

使用循环方法求解百钱买百鸡问题。假设公鸡5元一只，母鸡3元一只，小鸡1元三只，

现有100元钱想买100只鸡，编程计算买鸡的方案，有多少种买法？

'''

for a in range(0,21):

for b in range(0,34):

for c in range(0,101):

if a+b+c==100 and a*5+b*3+c/3==100:

print(a,b,c)

#韩信点兵

for i in range(1000,1101):

if i%3==2 and i%5==4 and i%7==6:

print(i)

#打印九九乘法表

for i in range(1,10):

for j in range(1,i+1):

print("{}*{}={:2d}".format(i,j,i*j),end=" ")

print()

#从键盘输入任意一个正整数，编程计算该数的阶乘 如：输入5，阶乘结果120 。

x=eval(input("请输入一个正整数"))

t=1

for i in range(1,x+1):

t=t*i

print(t)

#编程分别计算100以内(含100)奇数与偶数的和。

s1,s2=0,0

for i in range(1,101):

if i%2==1:

s1=s1+i

else:

s2=s2+i

print(s1,s2)

#编程计算前30项的和：s=1+(1+2)+(1+2+3)+(1+2+3+4)+…+(1+2+3+4+…+n)

s,y=0,0

for i in range(1,31):

s=s+i

y=y+s

print(y)

#编程产生菲波拉契数列20项，例如：0  1   1  2  3   5   8   13    21    ……

x1=0

x2=1

print(x1,end=" ")

print(x2,end=" ")

for i in range(1,18+1):

x3=x1+x2

print(x3,end=" ")

x1=x2

x2=x3

#一小球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？

h=100

s=0

for i in range(1,11):

s=s+h

h=h/2

s=s+h

print(s-h,h)

'''

猴子第一天摘了若干个桃子，当天吃了一半，还不过隐，有多吃了一个，第二天早上又将剩下的桃子吃了一半，又多吃了一个，以后每天早上都吃了前一天剩下的一半零一个，到第10天早上想再吃时，见只剩下一个桃子，问第一天共摘了多少个桃子

'''

x=1

for i in range(1,10):

x=(x+1)*2

print(x)

#商场购物

x=eval(input("x="))

if x<1000:

y=x

elif x<2000:

y=0.9*x

elif x<3000:

y=0.8*x

else:

y=0.7*x

print(y)

#分段函数1

import math

x=eval(input("x="))

if x>5:

y=math.sin(x)+(x**2+1)**0.5

elif x>0:

y=math.e**x+math.log(x,5)+x**(1/5)

else:

y=math.cos(x)-x**3+3*x

print(y)

#分段函数2

x=eval(input("x="))

if x<0:

y=0

elif x<5:

y=x

elif x<10:

y=3*x-5

elif x<20:

y=0.5*x-2

else:

y=0

print(y)

#判断素数

x=eval(input("x="))

for i in range(2,x):

if x%i==0:

print("不是素数")

break

else:

print("是素数")

'''

一个富翁试图与陌生人做一笔换钱生意，换钱规则为：陌生人每天给富翁10万元钱，直到满一个月(30天)；而富翁第一天给陌生人1分钱，第2天给2分钱，第3天给4分钱，…，富翁每天给穷人的钱是前一天的两倍，直到满一个月，分别显示富翁给陌生人的钱和陌生人给富翁的钱各是多少？

'''

s1,s2=0,0

x=0.01

for i in range(1,31):

s1=s1+100000

s2=s2+x

x=2*x

print(s1,s2)

#判断闰年

x = eval(input('请输入一个年份'))

if x%400==0 or (x%4==0 and not x%100==0):

print('是闰年')

else:

print('不是闰年')

四五章选择判断填空编程

一、选择题

1.下列表达式值为False的是:______。2 in {1:2,3:4}

2.下列代码执行的正确结果为（.[1,4,9]

lnum=[]

for i in range(1,4)

lnum.append(i**2)

print(lnum)

3. 执行语句x={},x的类型是:______.字典

4.已知 x = {1:2, 2:3}，那么表达式 x.get(3, 4) 的值为__.4

5.列表guests=["萧峰","杨过","令狐冲","张无忌","郭靖"]，下列删除"张无忌"的方法，哪种是错误的？（guests.remove[3]

6. 下列元组定义正确的是（.tupScores=(“萧峰”,)

7. 有关pop()方法的说法,正确的是:_____集合的pop()方法是从集合中随机删除一个元素

8.已知s={1,2,3,4},以下操作执行会报错的是:___s.remove(5)

9.下列集合运算的运算符,求交集的是:___.&

10.以下哪种不是字典的遍历方式:___按"元素"遍历

11.列表guests=[“萧峰”,”杨过”,”令狐冲”,”张无忌”,”郭靖”]，下列哪种方法能够在”令狐冲”前插入”张三丰”？（guests.insert(2, ”张三丰”)

12.假设d1,d2是两个字典,执行操作d1.update(d2)后,下列说法正确的是: d1的内容被更新,d2不变

13.courses="计算机,数学"，执行代码courses1=list(courses)后，courses1的值为（）。

.['计','算','机', ' , ', '数','学']

14.下列关于列表与元组的说法正确的是（ ）。列表的元素能修改

15.列表guests=["萧峰","杨过","令狐冲","张无忌","郭靖"]，下列删除"张无忌"的方法，哪种是错误的？（ ）guests.remove[3]

15．字典对象的________方法以"(键,值)"的形式返回字典中的所有条目的列表。.items()

16下列代码执行结果为（ ）？.[6, 6, 6, 6, 6, 6, 6, 6, 6, 6]

ls=[6]*10

print(ls)

17. 下列代码执行的正确结果为（.[1,4,9]

）。

lnum=[i**2 for i in range(1,4)]

print(lnum)

18. 下列有关字典条目的说法,错误的是:__字典中的值必须是不可变类型

19. group=[("张三丰",95),("杨过",94)]，下列操作不正确的是（group[1][0]="虚竹"将'杨过'修改为'虚竹'。）。

20. score = eval(input("请输入3个学生的分数列表 "))

maxScore = max(score)

minScore = min(score)

aveScore = sum(score)/len(score)

print(maxScore,minScore,aveScore))

如输入分数为[94,96,95]，代码执行的正确结果为（96 94 95

21. 列表guests=[”令狐冲”,”张无忌”,”郭靖”]，ls=[“98”,”97”,”99”]，guests+ls执行结果正确的是（.["令狐冲’,’张无忌’,’郭靖’, "98’,’97’,’99’]

22.。下列列表定义错误的是（names=[萧峰,96,令狐冲]

23. 表达式sorted({4:2,3:1,5:6})的值为___.[3,4,5]

24. 下列代码执行的正确结果为（.[1,4,9]

）。

lnum=[]

for i in range(1,4)

lnum.append(i**2)

print(lnum)

25. 执行语句x={},x的类型是:____.字典

26.已知 x = {1:2, 2:3}，那么表达式 x.get(3, 4) 的值为___4

27.列表guests=["萧峰","杨过","令狐冲","张无忌","郭靖"]，下列删除"张无忌"的方法，哪种是错误的？（guests.remove[3]

28. 下列元组定义正确的是（tupScores=(“萧峰”,)

29. 有关pop()方法的说法,正确的是:____集合的pop()方法是从集合中随机删除一个元素

s={1,2}

s.add({2,3})

print(s)

31. guests=["李秋水","郭襄","赵敏"]，彻底从内存中删除guests的方法是（del guests

32.列表guests=["张三丰","萧峰","杨过","令狐冲","张无忌"]，下列表达式用来判断指定的元素是否在列表中，下列描述正确的是？（."杨" not in guests，返回True。

33. 列表courses=[”法律”,“管理”,”计算机”,”数学”]，列表切片结果错误的是（courses[0:3:-2]切片结果为["法律’,’计算机’]。

34. 执行下列代码的结果为:报错

s={1,2}

s.add({2,3})

print(s)

35.下列集合运算的运算符,求并集的是:___.|

36. 下列哪种方法能够生成一份列表courses的备份？（courses.copy()

37. 已知x={'a':2,'b':4},以下操作会报错的是:___x.pop('c')

38. 以下说法正确的是:___集合可以作为字典的值

39. 关于列表复制，下列说法错误的是（利用列表赋值实现复制会生成列表的备份。

40. 执行下列代码的结果为:.{1:4,2:5,3:6}

l1=[1,2,3]

l2=[4,5,6]

d={}

for j in range(3):

d[l1[i]]=l2[i

41.已知x = {1:2, 2:3}，那么表达式x.get(3, 4)的值为__4

42.列表guests=["萧峰","杨过","令狐冲","张无忌","郭靖"]，下列删除"张无忌"的方法，哪种是错误的？（guests.remove[3]

43. 列表guests=["张三丰","萧峰","杨过","令狐冲","张无忌"]，下列表达式用来判断指定的元素是否在列表中，下列描述正确的是？（."杨" not in guests，返回True。

44. 下列关于列表与元组的说法不正确的是（列表的元素不能修改

45. 按照指定的键访问字典中对应条目的值应采用的方法是:get()

46，下列从输入设备获取数值列表的方法正确的是（lnum=eval(input(“请输入数值列表： ”))

47. 字典对象的____keys()

____方法返回字典中的"键"的列表。

48下列哪个函数可以将range()函数生成的数值对象转换成数值列表？（list()

49. 以下创建集合的操作错误的是:____s={}

50.已知x={1:2,3:4},以下选项返回False的是:_2 in x

51. 以下哪种不是字典的遍历方式:__按"元素"遍历

二、判断题

1、del命令和pop命令删除列表元素的方式相同。F

2、字典和集合属于无序序列。T

3、Python字典中的“键”可以是列表。F

4、使用del命令或者列表对象的remove()方法删除列表中元素时会影响列表中部分元素的索引。T

5、可以使用del删除集合中的部分元素。F

6、假设x为列表对象，那么x.pop()和x.pop(-1)的作用是一样的。T

7、元组可以作为字典的“键”。T

8、已知列表x中包含超过5个以上的元素，那么语句 x = x[:5]+x[5:] 的作用是将列表x中的元素循环左移5位。F

9、字典中的值不允许重复。F

10、Python字典中的“键”可以是元组。T

11、字典可以通过索引访问所存储的条目。F

12、Python集合可以包含相同的元素。F

13、访问字典是通过键访问条目的值。T

14、已知x = list(range(20))，那么语句print(x[100:200])无法正常执行。F

15、Python集合中的元素可以是列表。F

16、元组是不可变的，不支持列表对象的insert()、remove()等方法，也不支持del命令删除其中的元素，但可以使用del命令删除整个元组对象。T

17、元组也是用来存放一组相关的数据，所以元组与列表相同。F

18、集合中的元素不允许重复。T

19、在Python 3.5中运算符+不仅可以实现数值的相加、字符串连接，还可以实现列表、元组的合并和集合的并集运算。F

20、列表可以作为字典的“键”。F

21、Python支持使用字典的“键”作为下标来访问字典中的值。T

22、字典的“键”必须是不可变的。T

23、Python集合中的元素可以是元组。T

24、语句s1={}创建了一个空集合。F

25、对于数字n>2，如果表达式 0 not in [n%d for d in range(2, n)] 的值为True则说明n是素数。T

26、已知x = (1, 2, 3, 4)，那么执行x[0] = 5之后，x的值为(5, 2, 3, 4)。F

27、Python字典和集合属于无序序列。T

28、同一个列表对象中所有元素必须为相同类型。F

29、已知x = {1:1, 2:2}，那么语句x[3] =3无法正常执行。F

30、假设x是含有5个元素的列表，那么切片操作x[10:]是无法执行的，会抛出异常。F

31、列表scores=[98,96,95,94,92]，scores[::1]与scores[::-1]返回列表的值相等。F

32、只能对列表进行切片操作，不能对元组和字符串进行切片操作。F

33、Python列表、元组、字符串都属于有序序列。T

34、列表的长度是列表中元素的个数减1。F

35、字典中的键必须是不可变的类型,比如字符串、元祖或者列表。F

36、字典的键一旦被加入到字典中，除非随着条目一起被删除，否则都是始终保持不变的。T

37、已知x = {1:1, 2:2}，那么语句x[3] =3无法正常执行F

38、只能通过切片访问列表中的元素，不能使用切片修改列表中的元素。F

39、在Python中元组的值是不可变的，因此，已知x = ([1], [2])，那么语句x[0].append(3)是无法正常执行的。F

40、运算符“-”可以用于集合的差集运算。T

41、删除列表中重复元素最简单的方法是将其转换为集合后再重新转换为列表。T

42、遍历列表用for和range()函数配合可以减少代码的重复度。T

43、已知x = list(range(20))，那么语句del x[::2]可以正常执行。T

44、字典的“键”必须是不可变的。T

45、无法删除集合中指定位置的元素，只能删除指定值的元素。T

46、列表对象的pop()方法默认删除并返回最后一个元素，如果列表已空则抛出异常。T

47、Python集合不支持使用下标访问其中的元素。T

48、删除列表中重复元素最简单的方法是将其转换为集合后再重新转换为列表。T

49、遍历列表用for和range()函数配合可以减少代码的重复度。T

50、字典和集合都支持双向索引。F

51、del命令和pop命令删除列表元素的方式相同。F

52、字典和集合属于无序序列。T

53、Python支持使用字典的“键”作为下标来访问字典中的值。T

54、字典可以通过索引访问所存储的条目。F

55、Python集合可以包含相同的元素。F

56、已知x = list(range(20))，那么语句print(x[100:200])无法正常执行。F

57、元组是不可变的，不支持列表对象的insert()、remove()等方法，也不支持del命令删除其中的元素，但可以使用del命令删除整个元组对象。T

58、元组也是用来存放一组相关的数据，所以元组与列表相同。F

59、集合中的元素不允许重复。T

60、在Python 3.5中运算符+不仅可以实现数值的相加、字符串连接，还可以实现列表、元组的合并和集合的并集运算。F

61、Python支持使用字典的“键”作为下标来访问字典中的值。T

62、对于数字n>2，如果表达式0 not in [n%d for d in range(2, n)]的值为True则说明n是素数。T

63、同一个列表对象中所有元素必须为相同类型。F

64、假设x是含有5个元素的列表，那么切片操作x[10:]是无法执行的，会抛出异常。F

65、del命令和pop命令删除列表元素的方式相同。F

66、使用del命令或者列表对象的remove()方法删除列表中元素时会影响列表中部分元素的索引。I

67、可以使用del删除集合中的部分元素。F

68、假设x为列表对象，那么x.pop()和x.pop(-1)的作用是一样的。T

69、字典中的值不允许重复。F

70、Python字典中的“键”可以是元组。T

71、使用列表对象的remove()方法可以删除列表中首次出现的指定元素，如果列表中不存在要删除的指定元素则抛出异常。T

72、使用Python列表的方法insert()为列表插入元素时会改变列表中插入位置之后元素的索引。T

73、使用pop()方法删除字典的指定键对应的条目时，如果缺省指定键参数,则随机删除一个条目。F

74、表达式 list('[1, 2, 3]') 的值是[1, 2, 3]。F

75、利用append()方法只能在列表尾部追加新的元素。T

76、列表切片缺省“起始索引”时，切片默认从索引1元素开始。F

77、已知x是个列表对象，那么执行语句y = x之后，对y增加一个元素的操作都会同样作用到x上。T

78、采用copy()方法与列表之间赋值实现复制的过程相同。F

79、无法删除集合中指定位置的元素，只能删除特定值的元素。T

三、填空题

1.已知列表对象x = ['11', '2', '3']，则表达式 max(x) 的值为_____'3'______。

2.已知列表 x = [1, 2, 3]，那么执行语句 x.pop(0) 之后，x的值为__[2,3]____

3.已知 x = [3, 5, 7]，那么执行语句 x[:3] = [2]之后，x的值为_______[2]_________。

4.列表guests=[“萧峰”,”杨过”,”令狐冲”,”张无忌”,”郭靖”]，删除”杨过”的方法是guests._____ remove______(”杨过”)。

5.表达式 {1, 2, 3} | {3, 4, 5} 的值为_________{1,2,3,4,5}____________。

6.表达式 (1,) + (2,) 的值为______(1,2)_______。

7.表达式 {1, 2, 3} & {3, 4, 5} 的值为______{3}________。

8.已知列表 x = [1, 2]，那么连续执行命令 y = x[:] 和 y.append(3) 之后，x的值为___[1,2]_____。

9.表达式 [1,2,3].count(4) 的值为________0_______。

10.已知 x = (3,)，那么表达式 x * 3 的值为________(3,3,3)_____。

11.guests=[“赵敏”,”任盈盈”,”袁紫衣”]，复制guests并生成备份的方法是guests.______copy____( )。

12.列表、元组、字符串是Python的_____有序____(有序或无序)序列。

13.guests=[“赵敏”,”任盈盈”,”袁紫衣”]，执行guests___*__2的返回结果为["赵敏’,’任盈盈’,’袁紫衣’,"赵敏’,’任盈盈’,’袁紫衣’]。

14.已知 x = {1:2}，那么执行语句 x[2] = 3之后，x的值为_______{1:2,2:3}_________。

15.已知x = [1, 2, 3]，那么连续执行y = [1, 2, 3]和y.append(4)这两条语句之后，x的值为_________[1,2,3]___________。

16.已知 x = [1, 2, 3, 2, 3]，执行语句 x.remove(2) 之后，x的值为_____[1,3,2,3]_______。

17.字典对象的______clear()_____方法可以一次性清空字典中所有条目。

18.已知 x = [3, 5, 7]，那么执行语句 x[len(x):] = [1, 2]之后，x的值为______[3,5,7,1,2]________。

19.已知 x = [1, 2, 3, 2, 3]，执行语句 x.pop() 之后，x的值为_______[1,2,3,2]______。

20.列表group=[("郭靖",99),("杨过",98)]，则group[0][1]=__99___。

21.表达式 [1, 2] * 2 的值为________[1,2,1,2]______。

22.已知 x = [3, 7, 5]，那么执行语句 x.sort(reverse=True)之后，x的值为______[7,5,3]___________。

23.表达式 set([1,2,3]) == {1, 2, 3} 的值为_____True_______。

24.表达式type({3})的值为_________set___________。

25.执行下列语句:

x={1:1,2:2}

x[1]=3

print(len(x))

显示结果为:2

26.表达式 {1, 2, 3} - {3, 4, 5}的值为____{1,2}_______。

27.表达式 sum(range(1, 10, 2)) 的值为_____25_______。

28.列表courses=[”法律”,“管理”,”计算机”,”数学”]，执行下列代码能对courses列表的元素降序排序，并改变原列表的顺序，courses._____sort____(reverse=False)。

29.字典对象的______keys______方法返回字典的"键"列表。

30.表达式sorted({'a':3, 'b':9, 'c':78}.values())的值为_____[3,9,78]________。

31.表达式[1,2]*3的执行结果为_________[1,2,1,2,1,2]_____________。

32.表达式 list(range(50, 60, 3)) 的值为________[50,53,56,59]_______________。

33.表达式 len([i for i in range(10)]) 的值为______10____。

34.已知列表 x = [1, 2, 3]，那么执行语句 x.insert(1, 4)之后 ，x的值为_____[1,4,2,3]______。

35.已知列表 x = list(range(10))，那么执行语句 del x[::2]之后，x的值为____[1,3,5,7,9]_____。

36.已知 x = (3)， 那么表达式 x * 3 的值为_____9_____。

37.列表guests=[”a”,“b”,”cd”,”e”]，表达式“d” in guests，返回结果为____False____。

38.表达式 [1, 2] + [3] 的值为_________[1,2,3]_________。

39.表达式 str([1, 2, 3]) 的值为__________'[1,2,3]'________。

40.表达式type({}) == set的值为________False_______。

41.已知列表 x = list(range(5))，那么执行语句 x.remove(3) 之后，表达式 x.index(4) 的值为____3____。

42.已知列表 x = [1, 2]，那么执行语句 x.append([3]) 之后，x的值为_____[1,2,[3]]________。

43.已知列表 x = [1, 2, 3]，那么执行语句 x.insert(1, 4)之后 ，x的值为____[1,4,2,3]_______。

44.已知 x = [1, 2, 3, 4, 5]，那么执行语句 del x[1:3] 之后，x的值为______[1,4,5]______。

45.已知列表 x = [1, 2]，那么执行语句 x.extend([3]) 之后， x的值为_____[1,2,3]_______。

46.已知 x = [1, 2, 3, 2, 3]，执行语句 x.remove(2) 之后，x的值为____[1,3,2,3]________。

47.已知 x = {1:2, 2:3, 3:4}，那么表达式 sum(x.keys()) 的值为____6_______。

48.表达式sorted({3:'a',8:'b',5:'c'}.values())的值为:___ ['a','b','c']_____。

49.已知 x = {1, 2, 3}，那么执行语句 x.add(3) 之后，x的值为___{1,2,3}_______。

50.guests=["令狐冲","张无忌","郭靖"]，ls=["李秋水","郭襄","赵敏"]，将guests列表的值修改为['令狐冲', '张无忌', '郭靖', '李秋水', '郭襄', '赵敏']的方法是guests.____ extend______(ls)。

51.字典对象的________get___方法可以获取指定“键”对应的“值”，如果指定的键在字典中不存在，则返回默认值。

52.清空列表guests=["赵敏","任盈盈","袁紫衣"]的命令是____del____guests[:]。

53.已知 x = {'a':'b', 'c':'d'}，那么表达式 'b' in x.values() 的值为_____True_________。

54.执行下列语句:

x={1:1,2:2}

x[3]=1

print(len(x))

显示结果为:3

55.已知x = ([1], [2])，那么执行语句x[0].append(3)后x的值为________([1,3],[2])________。

56.执行下列代码可以创建数值列表：lnum=____list____(range(1,9))。

57.已知 x = {'a':'b', 'c':'d'}，那么表达式 'b' in x 的值为___False___。

58.表达式sorted({3:'a',8:'b',5:'c'})的值为:___ [3,5,8]_____。

59.已知x为非空且元素无序的列表，那么表达式 x.sort() == sorted(x) 的值为____False______。

60.表达式[3] in [1, 2, 3, 4]的值为______False__________。

61.表达式sorted({3:'a',8:'b',5:'c'})的值为:___ [3,5,8]_____。

62.表达式 {1, 2, 3} ^ {3, 4, 5} 的值为___{1,2,4,5}________。

63.表达式 list(range(5)) 的值为______[0,1,2,3,4]__________。

64.已知 x = {'a':'b', 'c':'d'}，那么表达式 'a' in x 的值为______True________。

65.列表courses=[”Falv”,“Guanli”,”Jisuanji”,”Shuxue”,”Lishi”,’Dili’]，courses[1:5:__2__]切片结果为[“Guanli”,”Shuxue”]。

66.执行下列语句:

67.x={1:1,2:2}

x[3]=1

print(len(x))

显示结果为:3

68.清空列表guests=["赵敏","任盈盈","袁紫衣"]的命令是____del____guests[:]。

69.已知列表 x = [1, 2, 3]，那么执行语句 x.insert(0, 4) 只有，x的值为_____[4,1,2,3]______。

70.已知列表 x = [1, 2, 3]，那么执行语句 x.pop(0) 之后，x的值为____[2,3]_____。

71.已知 x = [3, 5, 7]，那么表达式 x[10:]的值为______[]______。

72.表达式type({}) == set的值为_______False________。

73.已知 x = [1, 2]，那么执行语句 x[0:1] = [3, 3]之后，x的值为_____[3,3,2]______。

74.已知x = list(range(20))，那么表达式x[-1]的值为________19____________。

75.______del________命令既可以删除列表中的一个元素，也可以删除整个列表。

76.表达式 type(3.0) in (int, float, complex) 的值为______True______。

77.表达式 3 not in [1, 2, 3]的值为____False______。

78.表达式 3 in {1, 2, 3} 的值为_____True____。

79.表达式 len(range(1, 10)) 的值为_____9______。

字典对象的_______values_______方法返回字典的“值”列表。

三、编程题

'''

编写一个程序，接受逗号分隔的单词序列作为输入，按字母顺序排序后按逗号分隔的序列打印单词。假设向程序提供以下输入:

without,hello,bag,world

则输出为:

bag,hello,without,world

'''

x=input("x=")

l=x.split(",")

l.sort()

print(",".join(l))

'''

编写一个程序来计算输入中单词的频率。 按字母顺序对键进行排序后输出。

假设为程序提供了以下输入：

New to Python or choosing between Python 2 and Python 3 Read Python 2 or Python 3

然后，输出应该是：

2:2

3:2

New:1

Python:5

Read:1

and:1

between:1

choosing:1

or:2

to:1

'''

x=input("x=")

l=x.split()

d={}

for i in l:

d[i]=d.get(i,0)+1

l2=sorted(d)

for i in l2:

print("{}:{}".format(i,d[i]))

#依次输入三个整数放在一个列表中，请把这三个数由小到大输出。

l=[]

for i in range(3):

x=int(input("x="))

l.append(x)

l.sort()

for i in l:

print(i,end=" ")

'''

使用列表生成式方法求解百钱买百鸡问题。

假设大鸡5元一只，中鸡3元一只，小鸡1元三只，

现有100元钱想买100只鸡，有多少种买法？

'''

l=[(i,j,k) for i in range(0,100) for j in range(0,100) for k in range(0,100) if i+j+k==100 and 5*i+3*j+k/3==100]

for i in l:

print(i)

'''

使用给定的整数n，编写一个程序生成一个包含(i, i*i)的字典，该字典包含1到n之间的整数(两者都包含)。然后程序应该打印字典。

假设向程序提供以下输入:8

则输出为:

{1:1，2:4，3:9，4:16，5:25，6:36，,7:49，8:64}

'''

n=eval(input("n="))

d={}

for i in range(1,n+1):

d[i]=i*i

print(d)

'''

使用列表生成式随机产生10个两位的正整数，存入列表ls中，输出ls中的这10个随机数，

然后对这10个随机数求平均值，并输出统计高于平均值的数有多少个。

'''

from random import *

ls=[randint(10,99) for i in range(10)]

print(ls)

pj=sum(ls)/10

n=0

for i in ls:

if i>pj:

n=n+1

print(n)

#编写一个程序，输出2000到3200（含2000和3200）之间所有是7的倍数，但不是5的倍数的整数。要求：用列表保存符合条件的整数，输出结果各整数之间用逗号分隔，并输出在一行上。

l=[]

for i in range(2000,3201):

if i%7==0 and i%5!=0:

l.append(str(i))

print(",".join(l))

'''

编写一个程序，接收一系列单个空格分隔的单词作为输入，在删除所有重复的单词并按字母升序排序后打印这些单词。

假设向程序提供以下输入:

hello world and practice makes perfect and hello world again

则输出为:

again and hello makes perfect practice world

'''

x=input("x=")

l=x.split()

s=set(l)

l2=list(s)

l2.sort()

for i in l2:

print(i,end=" ")

'''

编写一个接收句子并计算字母和数字的程序。假设为程序提供了以下输入：

Hello world! 123

然后，输出应该是：

字母10

数字3

'''

d={'字母':0,'数字':0}

x=input("x=")

for i in x:

if i.isdigit():

d['数字']=d['数字']+1

elif i.isalpha():

d['字母']=d['字母']+1

for k,v in d.items():

print("{} {}".format(k,v))

'''

使用列表生成式来求列表中的每个奇数。 该列表由一系列逗号分隔的数字输入。

假设为程序提供了以下输入：

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

然后，输出应该是：

[1,3,5,7,9]

'''

l=eval(input("l="))

l2=[ i for i in l if i%2==1]

print(l2)