填空题

  1. Python安装扩展库常用的是pip工具。P5

 

  1. Python程序文件扩展名主要有.py和.pyw两种，其中后者常用于GUI程序。P4

 

  1. Python内置函数len()可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。P15

 

  1. 列表、元组、字符串是Python的有序(有序？无序?)序列。

 

  1. 查看变量内存地址的Python内置函数是ID()。P8

 

  1. 表达式 int('123') 的值为123。

 

  1. 已知 x = 3，那么执行语句  x += 6 之后，x的值为9。

 

  1. 已知 g = lambda x, y=4, z=7: x*y*z，则语句 print(g(2)) 的输出结果为56。P129

 

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

 

  1. 假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是[6,7,9,11]。

 

  1. 已知 x = {1:7, 2:3}，那么表达式 x.get(1, 4) 的值为7。# get() 函数返回指定键的值，如果值不在字典中返回默认值。

 

  1. 任意长度的Python列表、元组和字符串中最后一个元素的下标为-1。

 

  1. 已知x=3和y=5，执行语句 x, y = y, x 后x的值是5。

 

  1. 在函数内部可以通过关键字global来定义全局变量。P127

 

  1. 表达式 len([i for i in range(20)]) 的值为20。

 

  1. 在循环语句中，break语句的作用是提前结束本层循环。P82

 

  1. 字典中多个元素之间使用，分隔开。

 

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

 

  1. 已知 x = [3, 4, 5]，那么表达式 x[5:]的值为[ ]。P41
     
  2. 表达式 eval('3+5') 的值为8。P97# eval() 函数用来执行一个字符串表达式，并返回表达式的值。

 

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

 

  1. 表达式 len(range(1,7)) 的值为6。

 

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

 

  1. 已知列表 x = [3, 7，5]，那么连续执行命令 y = x[:] 和 y.append(4) 之后，x的值为[3,7,5]。P32
     
  2. 表达式 [y for y in [10,2,9,3,1,1,4] if y<4] 的值为[2, 3, 1, 1]。

 

  1. 当在字符串前加上字母r表示原始字符串，不对其中的任何字符进行转义。P10

 

  1. 表达式[1] in [1, 2, 1, 4]的值为False。

 

  1. 已知列表y = [1, 2, 7,7,8]，那么执行语句 del y[2] 之后y的值为[1, 2, 7, 8]。

 

  1. 表达式 {1, 2, 3, 4, 7} ^ {4, 5, 7, 8,15} 的值为{1, 2, 3, 5, 8, 15}。P11

 

  1. 表达式 list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为 [6, 7, 8, 9, 10]。

 

  1. 表达式print(“我叫{1},今年{0}岁”.format(18,“小王”))的输出结果是  我叫小王,今年18岁  。 # str.format()格式化字符串的函数, 基本语法是通过 {} 和 : 来代替以前的 %( "{0} {1}".format("hello", "world") # 设置指定位置 'hello world')

 

  1. 语句 print(re.match('abc', 'reabc')) 输出结果为None。

 

  1. 表达式 'ad' in 'acbed' 的值为False。

 

  1. list(map(str, [1, 2, 3]))的执行结果为 ['1', '2', '3']。

 

  1. Python语句list(range(1,10,2))执行结果为[1, 3, 5, 7, 9]。# range() 函数可创建一个整数列表，一般用在 for 循环中.range(start, stop[, step])   start: 计数从 start 开始。默认是从 0 开始。stop: 计数到 stop 结束，但不包括 stop。step：步长，默认为1。

 

  1. 执行代码 x, y, z = sorted([4, 9, 7]) 之后，变量y的值为7。

 

  1. 表达式 len('abc'.ljust(7)) 的值为7。# ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

 

  1. 字典中每个元素的“键”与“值”之间使用:分隔开。P53

 

  1. 已知x = [10,5,9]，那么执行语句x.sort(reverse=True)之后，x的值为[10, 9, 5]。P31

 

  1. 表达式 eval('[5, 7, 9]') 的值为[5, 7, 9]。

 

  1. 表达式 [str(i) for i in range(5)] 的值为['0', '1', '2', '3', '4']。

 

  1. 表达式 'Hello world!'[-4] 的值为'r'。

 

  1. 表达式 {1, 2, 3} == {1, 3, 2} 的值为True。

 

  1. 已知 x = list(range(15))，则表达式 x[-5:] 的值为 [10, 11, 12, 13, 14] 。

 

  1. 假设正则表达式模块re已导入，那么表达式 re.sub('\d+', 'y', 'a12345oooo67b890i0g') 的值为'ayooooybyiyg'。

 

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

 

  1. 已知 x = '123' 和 y = '456'，那么表达式 x + y 的值为'123456'。P11

 

  1. 已知 x = [1, 2, 3, 1, 2, 3]，那么执行语句 x[len(x)-1:] = [4, 6, 8]之后，变量x的值为[1, 2, 3, 1, 2, 4, 6, 8]。

 

  1. 已知 x = 2，那么执行语句  x += 8 之后，x的值为10。

 

  1. 表达式[4, 2, 9]*2的执行结果为[4, 2, 9, 4, 2, 9] 。P11

 

  1. 已知 x = {1:5, 2:7, 3:9}，那么表达式 sum(x.values()) 的值为21。

 

  1. 正则表达式模块re的search() 方法用来在整个字符串中进行指定模式的匹配。P106

 

  1. 查看变量类型的Python内置函数是Type()。   

 

  1. 表达式 7 // 4 的值为1。P11

 

  1. 表达式 (6) + (9) 的值为15。

 

  1. 已知x=1和y=5，执行语句 x, y = y, x 后x的值是5。

 

  1. 已知 x = [6, 5, 4, 3, 2]，执行语句 x.pop() 之后，x的值为[6, 5, 4, 3]。P36

 

表达式set([1, 1, 2, 3, 4, 3])的值为{1, 2, 3, 4}。# set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等，(可迭代对象)

 

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

 

  1. 已知 x = [10,5, 9]，那么执行语句 x.sort(reverse=True)之后，x的值为[10, 9, 5]。P43

 

  1. 表达式 False+3 的值为3。

 

  1. 已知列表 x = [1, 2, 3, 4]，那么执行语句 x.insert(2, 7) ，x的值为[1, 2, 7, 3, 4]。# insert() 函数用于将指定对象插入列表的指定位置。

 

  1. 已知 x = 2，那么执行语句  x += 5 之后，x的值为7。

 

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

 

  1. 表达式 'abcabcabc'.rindex('ca') 的值为5。# rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。str.rindex(str, beg=0 end=len(string))

 

  1. 已知列表 x = [5, 7, 9]，执行语句 y = x 后，表达式 x is y 的值为True。

 

  1. 假设正则表达式模块re已正确导入，那么表达式''.join(re.findall('\d+', '11a22babcd1234'))的值为'11221234'。P95#join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

 

  1. 假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[2:5]得到的值是[5, 6, 7]。

 

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

 

  1. 表达式 list(map(lambda x: len(x), ['a', 'bb', 'ccc', 'dddd'])) 的值为[1, 2, 3, 4]。

 

  1. Python使用Class关键字来定义类。P139

 

  1. 表达式 sorted([25, 1, 256, 64, 1024], key=lambda x: len(str(x))) 的值为 [1, 25, 64, 256, 1024]。P43

 

  1. 转义字符r’\n’的含义是原样输出\n。

 

  1. Python内置函数用来返回序列中的最小元素min()。P15

 

  1. 已知列表 x = [4, 9, 7]，那么执行语句 a, b, c = map(str,sorted(x)) 之后，b的值为’7’。

 

  1. Python中定义函数的关键字是def。P121

 

  1. 正则表达式模块re的compile()方法用来编译正则表达式对象。P106

 

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

 

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

 

  1. list(map(str, [2, 5, 8]))的执行结果为['2', '5', '8']。

 

  1. 表达式 int('101',2) 的值为5。

 

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

 

  1. 表达式 {1, 2, 3, 4, 7, 9} - {3, 4, 5} 的值为{1, 2, 7, 9}。

 

  1. 表达式 'Hello python world!'[-7:] 的值为' world!'。

 

  1. 已知 g = lambda x, y=9, z=15: x+y+z，那么表达式 g(20) 的值为44。

 

  1. 已知x为非空列表，那么表达式 x.sort() == sorted(x) 的值为False。

 

  1. 已知x=8和y=15，执行语句 x, y = y, x 后x的值是15。

 

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

 

  1. 已知x = [3, 5, 7]，那么执行x += [5, 5]之后x的值为 [3, 5, 7, 5, 5]。

 

  1. 表达式 True*5 的值为5。

 

  1. 表达式 [x for x in [1,2,3,4,5] if x<3] 的值为 [1,2]。

 

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

 

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

 

  1. 表达式 str([1, 2, 3, 4, 5]) 的值为 '[1, 2, 3, 4, 5]'。

 

  1. 假设正则表达式模块re已正确导入，那么表达式re.findall('\d+?', '1234abcd7896’)的值为 ['1', '2', '3', '4', '7', '8', '9', '6']。

 

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

 

  1. 正则表达式模块re的match()方法用来在字符串开始处进行指定模式的匹配。P106

 

  1. 关键字in用于测试一个对象是否是一个可迭代对象的元素。P98

 

  1. 查看变量内存地址的Python内置函数是id()。

 

  1. 表达式 [x for x in [1,2,3,4,5,6,7,8,9] if x<5] 的值为 [1, 2, 3, 4]。

 

  1. 已知x = 'hello python world.'，那么表达式x.find('x')和x.rfind('x')的值都为-1。

 

  1. 已知 f = lambda x: x+5，那么表达式 f(3) 的值为8。

 

  1. 已知 x, y = 7, 9，那么执行x, y = y, x 之后，x的值为9。

 

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

 

  1. 表达式 [i for i in range(20) if i>10] 的值为 [11, 12, 13, 14, 15, 16, 17, 18, 19]。

 

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

 

  1. 表达式 str([1, 2, 3, 4, 7, 9]) 的值为'[1, 2, 3, 4, 7, 9]'。

 

  1. 已知列表 x = [7, 2, 9, 1]，那么执行语句 del x[2] 之后x的值为 [7, 2, 1]。

 

  1. 代码 for i in range(3):print(i, end=',') 的执行结果为 0,1,2,。

 

判断

Python是一种跨平台、开源、免费的高级动态编程语言.P1

 

正则表达式元字符“^”一般用来表示从字符串开始处进行匹配，用在一对方括号中的时候则表示反向匹配，不匹配方括号中的字符。P104

 

Python采用的是基于值的自动内存管理方式。P8

 

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

 

加法运算符可以用来连接字符串并生成新字符串。

 

Python集合中的元素不允许重复。P57

 

放在一对三引号之间的任何内容将被认为是注释。P10

 

正则表达式模块re的match()方法是从字符串的开始匹配特定模式，而search()方法是在整个字符串中寻找模式，这两个方法如果匹配成功则返回match对象，匹配失败则返回空值None。P106

 

Python关键字不可以作为变量名。P8

 

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

 

元组可以作为字典的“键”。P50

 

函数中必须包含return语句。P126

 

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

 

Python中一切内容都可以称为对象。P5

 

列表对象的append()方法属于原地操作，用于在列表尾部追加一个元素。P32

 

已知列表 x = [1, 2, 3]，那么执行语句 x = 3 之后，变量x的地址不变。P8

 

创建只包含一个元素的元组时，必须在元素后面加一个逗号，例如(9,)。P49

 

定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。

 

如果仅仅是用于控制循环次数，那么使用for i in range(20)和for i in range(20, 40)的作用是等价的。

 

假设有非空列表x，那么x.append(3)、x = x+[3]与x.insert(0,3)在执行时间上基本没有太大区别。P34

 

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

 

正则表达式'^http'只能匹配所有以'http'开头的字符串。P104

 

Python变量名必须以字母或下划线开头，并且区分字母大小写。P8

 

函数是代码复用的一种方式P120。

 

已知x和y是两个字符串，那么表达式sum((1 for i,j in zip(x,y) if i==j))可以用来计算两个字符串中对应位置字符相等的个数。

 

定义Python函数时必须指定函数返回值类型。P121

 

Python字典中的“键”不允许重复。P53

 

在Python中定义类时实例方法的第一个参数名称必须是self。

 

在Python中可以为自定义类的对象动态增加新成员。P140

 

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

 

正则表达式'^\d{18}|\d{15}$'只能检查给定字符串是否为18位或15位数字字符，并不能保证一定是合法的身份证号。

 

已知x为非空字符串，那么表达式 ''.join(x.split()) == x 的值一定为True。

 

使用正则表达式对字符串进行分割时，可以指定多个分隔符，而字符串对象的split()方法无法做到这一点。

 

元组可以作为集合的元素。

 

在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。

 

以写模式打开的文件无法进读操作。

 

不可以在同一台计算机上安装多个Python版本。

 

已知x为非空列表，那么表达式 sorted(x, reverse=True) == list(reversed(x)) 的值一定是True。

 

Python采用的是基于内存空间的自动内存管理方式。

 

已知列表 x = [1, 2, 3]，那么执行语句 x = 'a' 之后，变量x的地址不变。

 

已知 x = 3，那么赋值语句 x = 'abcedfg' 是无法正常执行的。

 

对于大量列表的连接，extend()方法比运算符+具有更高的效率。

 

在Python 3.x中可以使用中文作为变量名。

 

Python运算符%不仅可以用来求余数，还可以用来格式化字符串。

 

在Python中可以使用if作为变量名。

 

Python使用缩进来体现代码之间的逻辑关系。

 

不管输入什么，Python 3.x中input()函数的返回值总是字符串。

 

在循环中continue语句的作用是跳出当前循环。

 

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

 

Python字典中的“值”允许重复。P53

 

表达式 pow(3,2) == 3**2 的值为True。

 

尽管可以使用import语句一次导入任意多个标准库或扩展库，但是仍建议每次只导入一个标准库或扩展库。P20

 

在IDLE交互模式下，一个下划线“_”表示解释器中最后一次显示的内容或最后一次语句正确执行的输出结果。

 

对于列表而言，在尾部追加元素比在中间位置插入元素速度更快一些，尤其是对于包含大量元素的列表。

 

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

 

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

 

Python列表中所有元素必须为相同类型的数据。

 

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

 

同一个列表对象中的元素类型可以各不相同。

 

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

 

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

 

在函数内部，既可以使用global来声明使用外部全局变量，也可以使用global直接定义全局变量。P127

 

正则表达式元字符“\d”用来匹配任意数字字符。

 

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

 

全局变量会增加不同函数之间的隐式耦合度，从而降低代码可读性，因此应尽量避免过多使用全局变量。

 

通过对象不能调用类方法和静态方法。

 

定义函数时，即使该函数不需要接收任何参数，也必须保留一对空的圆括号来表示这是一个函数。P121

 

表达式 {1, 2, 3} * 2 的值为 {1, 2, 3, 1, 2, 3}。

 

在条件表达式中不允许使用赋值运算符“=”，会提示语法错误。

 

当以指定“键”为下标给字典对象赋值时，若该“键”存在则表示修改该“键”对应的“值”，若不存在则表示为字典对象添加一个新的“键-值对”。

 

正则表达式'^http'只能匹配所有以'http'开头的字符串。

 

调用函数时，在实参前面加一个型号*表示序列解包。P126

 

Python变量使用前必须先声明，并且一旦声明就不能在当前作用域内改变其类型。

 

已知x是个列表对象，那么执行语句y = x[:]之后，对y所做的任何操作都会同样作用到x上。

 

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

 

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

 

在Python中定义类时，如果某个成员名称前有2个下划线则表示是私有成员。P143

 

Python标准库os中的方法exists()可以用来测试给定路径的文件是否存在。

 

Python类不支持多继承。

 

只有Python扩展库才需要导入以后才能使用其中的对象，Python标准库不需要导入即可使用其中的所有对象和方法。

 

字符串属于Python有序序列，和列表、元组一样都支持双向索引。

 

在定义函数时，某个参数名字前面带有一个*符号表示可变长度参数，可以接收任意多个普通实参并存放于一个元组之中。

 

已知x为非空列表，那么x.sort(reverse=True)和x.reverse()的作用是等价的。[宋1] 

 

Python字典中的“值”不允许重复。[宋2] 

 

标准库os的rename()方法可以实现文件移动操作。

 

正则表达式'[^abc]'可以一个匹配任意除'a'、'b'、'c'之外的字符。

 

Python内置的字典dict中元素是按添加的顺序依次进行存储的。P56#字典的存储是无序的

 

Python变量名区分大小写，所以student和Student不是同一个变量。

 

已知x和y是两个等长的整数列表，那么表达式[i+j for i,j in zip(x,y)]的作用时计算这两个列表所表示的向量的和。

 

不同作用域中的同名变量之间互相不影响，也就是说，在不同的作用域内可以定义同名的变量。

 

对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。P142

 

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

 

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

 

对于带有else子句的循环语句，如果是因为循环条件表达式不成立而自然结束循环，则执行else子句中的代码。

 

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

 

集合可以作为列表的元素。

 

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

 

Python元组支持双向索引。

 

带有else子句的循环如果因为执行了break语句而退出的话，则会执行else子句中的代码。P80

 

内置函数len()返回指定序列的元素个数，适用于列表、元组、字符串、字典、集合以及range、zip等迭代对象。

 

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

 

已知x是个列表对象，那么执行语句y = x之后，对y所做的任何操作都会同样作用到x上。

 

使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。P158

 

列表对象的排序方法sort()只能按元素从小到大排列，不支持别的排序方式。P43

 

带有else子句的异常处理结构，如果不发生异常则执行else子句中的代码。

 

正则表达式'[^abc]'可以一个匹配任意除'a'、'b'、'c'之外的字符。

 

已知x = 3，那么执行x += 6语句前后x的内存地址是不变的。

 

在Python 3.x中语句 print(*[1,2,3]) 不能正确执行。

 

列表对象的排序方法sort()只能按元素从小到大排列，不支持别的排序方式。P43
 

对于生成器对象x = (3 for i in range(5))，连续两次执行list(x)的结果是一样的。
 

.正则表达式对象的match()方法可以在字符串的指定位置开始进行指定模式的匹配。
 

Python类的析构函数是__del__()。P149

 

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

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

列表对象的extend()方法属于原地操作，调用前后列表对象的地址不变。P34
 

已知列表x = [1, 2, 3, 4]，那么表达式x.find(5)的值应为-1。
[宋3] 

集合可以作为字典的值。
[宋4] 

异常处理结构中的finally块中代码仍然有可能出错从而再次引发异常。P192
 

生成器推导式比列表推导式具有更高的效率，推荐使用。
 

已知x为非空字符串，那么表达式 ','.join(x.split(',')) == x 的值一定为True。
[宋5] 

定义函数时，带有默认值的参数必须出现在参数列表的最右端，任何一个带有默认值的参数右边不允许出现没有默认值的参数。
 

 

读程序：

def func(score):#定义func函数，score参数

       degree = 'DCBAAE'

       if score > 100 or score < 0:

              return 'wrong score. must between 0 and 100.'

       else:

              index = (score - 60)//10#index等于score-60再整除10

              if index >= 0: #如果index大于等于0

                     return degree[index] #返回degree中第index个字符

              else:

                     return degree[-1]#返回degree的最后一个字符

func(70)

 

答案：'C'

 

lst = [5, 20, 9, 25,15,9,9, 10, 17, 10, 99]#创建一个列表lst

for n in lst:

       if n % 3 == 0:#n对3取余等于0

              idx = lst.index(n)#返回n的索引位置并赋给idx

              lst[idx] = 'good'#更改idx位置上的值为‘good’

lst

答案：[5, 20, 'good', 25, 'good', 'good', 'good', 10, 17, 10, 'good']

 

n=int(input('Please input n:'))
for i in range(1,n):

       for j in range(n-i):

              print(' ',end='')

       for j in range(i-1):

              print('#',end='')

       print()

 

答案：Please input n:10

 

        #

       ##

      ###

     ####

    #####

   ######

  #######

 ########

 

x = list(range(20))  #生成一个0-19的列表

index, value in enumerate[宋6] (x):

       if value == 3:

              x[index] = 5#将列表x中值为3的元素修改为5

 

答案：

 

for n in range(100,1,-1):#从100到1，步长为-1

       for i in range(2,n):#从2到n

              if n % i==0:#n对i取余不等于0

                     break#提前退出循环

       else:

              print(n)#输出n的值

              break#提前退出循环

答案：97

 

age=int(input("please input a number:"))#age通过输入赋值，并转换为十进制数字

if age>=18:#如果age大于等于18

    print("adult")#输出adult

elif age>=6:#如果age大于等于6小于18

    print('teenager')#输出teenager

else:

    print('kid')#输出kid

答案：please input a number:20

adult

 

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def sleep(self):
        print("%s 正在睡觉"%self.name)
class Man(People):
    def beard(self):
        print("%s 已经长了胡子了"%self.name)
class Woman(People):
    pass
m1=Man("JOHN",18)
m1.sleep()
m1.beard()

 

答案：JOHN 正在睡觉

JOHN 已经长了胡子了

 

for num in range(100,1000):
    r=map(lambda x:int(x)**3,str(num))
    if sum(r)==num:
        print(num)

 

答案：153

370

371

407

写程序：

1.编写程序，实现找出1到100之间的所有素数，并输出结果。要求找素数这部分的功能代码用函数实现。

from math import sqrt#导入平方根计算函数

result =[]

for num in range(2,100):  #range(2,100) 表示在到2~100之间

    f = True

    for snu in range(2,int(sqrt(num))+1):

        if num %snu ==0:

            f = False

            break

    if f:

        result.append(num)#在result末尾加上num的值

print(result)

 

 

2.请找出所有的水仙花数，请编写程序找出所有的这样的数，要求找数字的这部分功能用函数实现

def sx(s,e):

    for num in range(s,e):

        bai = num // 100 # //取整符号，对100取整，得到百位上的数字

        shi = num // 10%10 #得到十位上的数字 %取余符号

        ge = num%10 #得到个位上的数字

        if(bai**3+shi**3+ge**3==num):

            print(num,end = ' ')

sx(100,1000)

 

3.写出斐波拉契数列前100项的代码，要求阅读性良好。

a = int(input("你需要几项？"))

# 第一和第二项

n1 = 0

n2 = 1

count = 2

# 判断输入的值是否合法

if a == 1:#a：输入需要多少项

   print("斐波那契数列：")

   print(n1)

else:

   print("斐波那契数列：")

   print(n1,",",n2,end=" , ")#用，分割，用，结束

   while count < a:

       nth = n1 + n2#用nth存放输出结果

       print(nth,end=" , ")

       # 更新值

       n1 = n2

       n2 = nth

       count += 1

 

4.请以上三角的格式输出九九乘法表

for i in range(1,10):

    for j in range(i,10):

        print("%d*%d=%2d" % (i,j,i*j),end=" ")

    print("")

       

 

5. 一个预设的分数，通过不停输入猜测分数直至猜中,要求程序要有良好的阅读性，输出显示信息完善。

keywords=666

n=0

while n!=keywords :

               n=int(input("请输入你猜的分数："))

               if n == keywords:

                     print("恭喜你O(∩_∩)O！猜中了")

                     break

               else:

                     print("猜错啦，再试试吧")

 

6. 序，生成包含20个随机数的列表，然后将前10个元素升序排列，后10个元素降序排列，并输出结果。

import random

lst1= random.sample(range(1,101),20) #random.sample()生成不相同的随机数#sample(seq, n) 从序列seq中选择n个随机且独立的元素；

print(lst1)

#分片

lst2= lst1[0:10]

lst3 = lst1[10:20]

#升序排序

lst2.sort()

#降序排序

lst3.sort()

lst3.reverse()

#列表合并

lst4 = lst2 + lst3

 

print('排序后的列表为：\n',lst4)

 

 

7定义一个类，给出一些属性和方法，实例化化后会调用这些属性和方法

#类定义

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):

    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))

 

#另一个类，多重继承之前的准备

class speaker():

    topic = ''

    name = ''

    def __init__(self,n,t):

        self.name = n

        self.topic = t

    def speak(self):

        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

 

#多重继承

class sample(speaker,student):

    a =''

    def __init__(self,n,a,w,g,t):

        student.__init__(self,n,a,w,g)

        speaker.__init__(self,n,t)

 

test = sample("Tim",25,80,4,"Python")

test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

 

 [宋1]Sort()默认为升序，reverse=False

 [宋2]键可以重复，值不能重复

 [宋3]'list' 'set' ‘dict’ ‘tuple’
object has no attribute 'find'

 

 [宋4]集合可以作为字典的值。

集合不能作为字典的键

 [宋5]join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串

split() 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串

 [宋6]enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。