精华内容
下载资源
问答
  • 列表对象alist
    万次阅读
    2019-11-27 22:07:58

    A对象List 转 为B对象List

    如下所示:将Long类型的List 转换为String类型的List:

    
    
    List<Long> longList = new ArrayList<>();
            longList.add(1L);
            longList.add(2L);
            longList.add(3L);
    
            List<String> stringList = longList.stream().map(l -> String.valueOf(l.intValue())).collect(Collectors.toList());
            System.out.println(stringList);
    
    
    
    更多相关内容
  • python程序设计第二章序列类型 题库及选解

    万次阅读 多人点赞 2020-06-25 21:41:27
    2、 list(map(str, [1, 2, 3]))的执行结果为 ['1','2','3'] Python序列类型包括列表,元组,字典 map()函数传入一个或多个序列,返回迭代器 3、 语句x = 3==3, 5执行结束后,变量x的值为 (True, 5) 4、 已知 x = 3...

    由于学校的python是笔试,所以找了份感觉比较好的题库刷了下其中前八章的填空和判断,附上选解。各章链接如下

    python程序设计题库完整版
    https://blog.csdn.net/lijia111111/article/details/80763095
    python程序设计第一章基础知识 题库及选解
    https://blog.csdn.net/zimuzi2019/article/details/106963005
    python程序设计第二章序列类型 题库及选解https://blog.csdn.net/zimuzi2019/article/details/106962735
    python程序设计第三章选择与循环 题库及选解https://blog.csdn.net/zimuzi2019/article/details/106968152
    python程序设计第四章字符串 题库及选解https://blog.csdn.net/zimuzi2019/article/details/106967507
    python程序设计第五章函数设计与应用 题库及选解https://blog.csdn.net/zimuzi2019/article/details/106968597
    python程序设计第六章面向对象程序设计 题库https://blog.csdn.net/zimuzi2019/article/details/106974412
    python程序设计第七章文件操作 题库https://blog.csdn.net/zimuzi2019/article/details/106974419
    python程序设计第八章异常 题库
    https://blog.csdn.net/zimuzi2019/article/details/106974425

    填空

    1、 表达式[1, 2, 3]*3的执行结果为() ([1,2,3,1,2,3,1,2,3])

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

    ['1','2','3']
    
    • Python序列类型包括列表,元组,字典
    • map()函数传入一个或多个序列,返回迭代器

    3、 语句x = 3==3, 5执行结束后,变量x的值为

    (True, 5)
    

    在这里插入图片描述

    4、 已知 x = 3,并且id(x)的返回值为 496103280,那么执行语句 x += 6 之后,表达式 id(x) == 496103280 的值为() (False)

    5、 已知 x = 3,那么执行语句 x *= 6 之后,x的值为() (18)

    6、 表达式[3] in [1, 2, 3, 4]的值为

    False
    

    在这里插入图片描述

    7、 列表对象的sort()方法用来对列表元素进行原地排序,该函数返回值为

    None
    

    8、 假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17],那么切片aList[3:7]得到的值是() ([6, 7, 9, 11])

    9、 使用列表推导式生成包含10个数字5的列表,语句可以写为

    [5 for i in range(10)]
    

    10、假设有列表a = [‘name’, ‘age’, ‘sex’]和b = [‘Dong’, 38, ‘Male’],请使用一个语句将这两个列表的内容转换为字典,并且以列表a中的元素为“键”,以列表b中的元素为“值”,这个语句可以写为

    c = dict(zip(a, b))
    
    • zip()函数传入一个或多个可迭代对象,返回迭代器

    在这里插入图片描述
    11、 任意长度的Python列表、元组和字符串中最后一个元素的下标为() (-1)

    12、 Python语句list(range(1,10,3))执行结果为

    [1, 4, 7]
    

    13、 表达式 list(range(5)) 的值为() ([0, 1, 2, 3, 4])

    14、 已知a = [1, 2, 3]和b = [1, 2, 4],那么id(a[1])==id(b[1])的执行结果为() (True)

    15、 切片操作list(range(6))[::2]执行结果为

    [0, 2, 4]
    

    16、使用切片操作在列表对象x的开始处增加一个元素3的代码为

    x[0:0] = [3]
    

    在这里插入图片描述

    17、 语句sorted([1, 2, 3], reverse=True) == reversed([1, 2, 3])执行结果为

    False
    
    • sorted()返回一个新的列表,reversed()返回一个迭代器

    在这里插入图片描述

    18、 表达式 sorted([111, 2, 33], key=lambda x: len(str(x)))的值为

    [2, 33, 111]
    

    19、 表达式 sorted([111, 2, 33], key=lambda x: -len(str(x))) 的值为

    [111, 33, 2]
    

    20、 语句 x = (3,) 执行后x的值为() ((3,))

    21、 语句 x = (3) 执行后x的值为() (3)

    22、 已知x=3和y=5,执行语句 x, y = y, x 后x的值是

    5
    
    • 这是交换x,y的值。等号左侧多个变量一起赋值是Python特殊的赋值方式。会自动分析右侧的可迭代对象然后一次性赋值,如x,y,z=[1,2,3]

    23、 可以使用内置函数()查看包含当前作用域内所有全局变量和值的字典。

    globals()
    

    24、 可以使用内置函数()查看包含当前作用域内所有局部变量和值的字典。

    locals()
    

    25、 字典中多个元素之间使用()分隔开,每个元素的“键”与“值”之间使用()分隔开。 (逗号、冒号)

    26、 字典对象的()方法可以获取指定“键”对应的“值”,并且可以在指定“键”不存在的时候返回指定值,如果不指定则返回None。

    get()
    
    • get()函数的语法为dict.get(key,default=None)

    27、 字典对象的()方法返回字典中的“键-值对”列表。

    items()
    
    • items方法返回字典中的"键-值对"组成的元组的列表

    28、 字典对象的()方法返回字典的“键”列表。

    keys()
    

    29、 字典对象的()方法返回字典的“值”列表。

    values()
    

    30、 已知 x = {1:2},那么执行语句 x[2] = 3之后,x的值为

    {1: 2, 2: 3}
    

    31、 表达式 {1, 2, 3, 4} - {3, 4, 5, 6}的值为

    {1, 2}
    
    • set1-set2返回set1有但是set2没有的元素

    32、 表达式set([1, 1, 2, 3])的值() ({1, 2, 3})

    33、 使用列表推导式得到100以内所有能被13整除的数的代码可以写作

    [i for i in range(100) if i%13==0]
    

    34、 已知 x = [3, 5, 7],那么表达式 x[10:]的值为

    []
    
    • 切片操作超出下标并不会报错而是返回空列表

    在这里插入图片描述

    35、 已知 x = [3, 5, 7],那么执行语句 x[len(x):] = [1, 2]之后,x的值为

    [3, 5, 7, 1, 2]
    

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

    [7, 5, 3]
    
    • sorted()和list.sort()不同,区别在于

      1.前者不是原地排序,原列表不变。后者是原地排序,原列表改变

      2.前者返回值是一个排序后的新列表。后者没有返回值

    在这里插入图片描述

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

    None
    

    38、 已知 x = [1, 11, 111],那么执行语句 x.sort(key=lambda x: len(str(x)), reverse=True) 之后,x的值为

    [111, 11, 1]
    

    39、 表达式 list(zip([1,2], [3,4]))的值为

    [(1, 3), (2, 4)]
    

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

    [1, 2, 3, 2]
    
    • 列表的pop方法的参数要移除的元素的索引值,如果不填默认为最后一个元素。返回值为移除元素

    41、 表达式 list(map(list,zip(*[[1, 2, 3], [4, 5, 6]])))的值为

    [[1, 4], [2, 5], [3, 6]]
    
    • '*'操作符可以理解为解包的意思
      在这里插入图片描述

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

    [1, 2]
    

    43、 表达式 [index for index, value in enumerate([3,5,7,3,7]) if value == max([3,5,7,3,7])]的值为

    [2, 4]
    

    在这里插入图片描述

    44、 已知 x = [3,5,3,7],那么表达式 [x.index(i) for i in x if i==3] 的值为

    [0,0]
    
    • 列表的index方法只会返回第一个匹配项的索引位置

    45、 已知列表 x = [1, 2],那么表达式 list(enumerate(x)) 的值为

    [(0, 1), (1, 2)]
    

    46、 已知 vec = [[1,2], [3,4]],则表达式 [col for row in vec for col in row] 的值为

    [1, 2, 3, 4]
    

    在这里插入图片描述

    47、 已知 vec = [[1,2], [3,4]],则表达式 [[row[i] for row in vec] for i in range(len(vec[0]))] 的值为

    [[1, 3], [2, 4]]
    

    48、 已知 x = list(range(10)),则表达式 x[-4:] 的值为() ([6, 7, 8, 9])

    49、 已知 x = [3, 5, 7],那么执行语句 x[1:] = [2]之后,x的值为() ([3, 2])

    50、 已知 x = [3, 5, 7],那么执行语句 x[:3] = [2]之后,x的值为

    [2]
    

    51、 已知x为非空列表,那么执行语句y = x[:]之后,id(x[0]) == id(y[0])的值为() (True)

    52、 已知 x = [1, 2, 3, 2, 3],执行语句 x.remove(2) 之后,x的值为

    [1, 3, 2, 3]
    
    • remove()方法只会移除第一个匹配项

    53、 表达式 len([i for i in range(10)]) 的值为() (10)

    54、 表达式 len(range(1,10)) 的值为

    9
    

    55、 表达式 range(10)[-1] 的值为() (9)

    56、 表达式 range(10,20)[4] 的值为()

    14
    

    57、 表达式 round(3.4) 的值为

    3
    
    • round()返回浮点数的四舍五入值

    58、 表达式 round(3.7) 的值为

    4
    

    59、 已知 x = (3), 那么表达式 x * 3 的值为() (9)

    60、 已知 x = (3,),那么表达式 x * 3 的值为()

    (3, 3, 3)
    

    61、 假设列表对象x = [1, 1, 1],那么表达式id(x[0]) == id(x[2])的值为() (True)

    62、 已知列表 x = list(range(10)),那么执行语句 del x[::2]之后,x的值为

    [1, 3, 5, 7, 9]
    

    63、 已知列表 x = [1, 2, 3, 4],那么执行语句 del x[1] 之后x的值为() ([1, 3, 4])

    64、 表达式 [1] * 2 的值为() ([1, 1])

    65、 表达式 [1, 2] * 2 的值为() ([1, 2, 1, 2])

    66、 已知列表 x = [1, 2, 3],那么执行语句 x.insert(1, 4) 后x的值为

    [1, 4, 2, 3]
    

    67、 已知列表 x = [1, 2, 3],那么执行语句 x.insert(0, 4) 后x的值为

    [4, 1, 2, 3]
    

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

    [2, 3]
    

    69、 已知 x = [[1]] * 3,那么执行语句 x[0] [0]= 5之后,变量x的值为

    [[5], [5], [5]]
    

    70、 表达式 list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为

    [6, 7, 8, 9, 10]
    

    71、 表达式 {1, 2, 3, 4, 5} ^ {4, 5, 6, 7} 的值为

    {1, 2, 3, 6, 7}
    
    • set1^set2返回二者的对称差集,该集中元素是set1或者set2的元素但不是set1和set2都有的元素

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

    73、 表达式 len(range(1, 10)) 的值为() (9)

    74、 已知x是一个列表对象,那么执行语句 y = x[:] 之后表达式 id(x) == id(y) 的值为() (False)

    75、 表达式 sorted([13, 1, 237, 89, 100], key=lambda x: len(str(x))) 的值为

    [1, 13, 89, 237, 100]
    

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

    4
    

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

    78、 表达式 {1, 2, 3} | {3, 4, 5} 的值为

    {1, 2, 3, 4, 5}
    
    • set1|set2为求二者的并集,把两个集合合并

    79、 表达式 {1, 2, 3} | {2, 3, 4} 的值为

    {1, 2, 3, 4}
    

    80、 表达式 {1, 2, 3} & {3, 4, 5} 的值为() ({3})

    81、 表达式 {1, 2, 3} & {2, 3, 4} 的值为

    {2, 3}
    
    • set1&set2为求二者的交集,即两个集合共有的元素

    82、 表达式 {1, 2, 3} - {3, 4, 5} 的值为() ({1, 2})

    83、 表达式 {1, 2, 3} < {3, 4, 5} 的值为

    False
    
    • set1<set2判断set1是否为set2的子集

    84、 表达式 {1, 2, 3} < {1, 2, 4} 的值为() (False)

    85、 表达式 [1,2,3].count(4) 的值为

    0
    

    86、 Python标准库random中的()方法作用是从序列中随机选择1个元素。

    choice()
    

    87、 Python标准库random中的sample(seq, k)方法作用是从序列seq中选择()(重复/不重复)的k个元素。 (不重复)

    88、 random模块中()方法的作用是将列表中的元素随机乱序。

    shuffle()
    

    89、 执行代码 x, y, z = sorted([1, 3, 2]) 之后,变量y的值为

    2
    

    90、 表达式 (1, 2, 3)+(4, 5) 的值为

    (1, 2, 3, 4, 5)
    

    91、 表达式 dict(zip([1, 2], [3, 4])) 的值为

    {1: 3, 2: 4}
    

    92、 语句 x, y, z = [1, 2, 3] 执行后,变量y的值为() (2)

    93、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:item[0]+item[2]) 的值为

    [[2, 3, 1], [1, 3, 3]]
    

    94、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:(item[1],item[2])) 的值为

    [[2, 3, 1], [1, 3, 3]]
    

    95、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:(item[1], -item[2])) 的值为() ([[1, 3, 3], [2, 3, 1]])

    96、 已知 x = {1, 2, 3},那么执行语句 x.add(3) 之后,x的值为

    {1, 2, 3}
    

    97、 已知 x = {1:1},那么执行语句 x[2] = 2之后,len(x)的值为

    2
    

    98、 已知 x = {1:1, 2:2},那么执行语句 x[2] = 4之后,len(x)的值为

    2
    

    99、 假设已从标准库functools导入reduce()函数,那么表达式 reduce(lambda x, y: x-y, [1, 2, 3]) 的值为

    -4
    

    100、 假设已从标准库functools导入reduce()函数,那么表达式 reduce(lambda x, y: x+y, [1, 2, 3]) 的值为() (6)

    101、 假设已从标准库functools导入reduce()函数,那么表达式reduce(lambda x,y:max(x,y), [1,2,3,4,4,5])的值为

    5
    

    102、 已知有函数定义 def demo(*p):return sum§,那么表达式 demo(1, 2, 3) 的值为()、表达式 demo(1, 2, 3, 4) 的值为()

    610
    

    103、 已知列表 x = [1, 2],那么连续执行命令 y = x和 y.append(3) 之后,x的值为() ([1, 2, 3])

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

    105、 已知列表 x = [1, 2],执行语句 y = x[:] 后,表达式 id(x) == id(y) 的值为() (False)

    106、 已知列表 x = [1, 2],执行语句 y = x 后,表达式 id(x) == id(y) 的值为() (True)

    107、 已知列表 x = [1, 2],执行语句 y = x 后,表达式 x is y 的值为() (True)

    108、 已知列表 x = [1, 2],执行语句 y = x[:] 后,表达式 x is not y 的值为() (True)

    109、 表达式 sorted(random.sample(range(5), 5)) 的值为

    [0, 1, 2, 3, 4]
    

    110、 表达式 [i for i in range(10) if i>8] 的值为() ([9])

    111、 已知有列表 x = [[1, 2, 3], [4, 5, 6]],那么表达式 [[row[i] for row in x] for i in range(len(x[0]))] 的值为

    [[1, 4], [2, 5], [3, 6]]
    

    112、 执行语句 x,y,z = map(str, range(3)) 之后,变量y的值为

    '1'
    

    113、 已知列表 x = [1, 2],那么执行语句 x.extend([3]) 之后, x的值为

    [1, 2, 3]
    
    • extend()的参数为一个可迭代对象

    114、 已知列表 x = [1, 2],那么执行语句 x.append([3]) 之后,x的值为

    [1, 2, [3]]
    

    115、 表达式 print(0b10101) 的值为

    21
    

    116、 已知 x = [1, 2, 3, 4, 5],那么执行语句 del x[:3] 之后,x的值为() ([4, 5])

    117、 已知 x = range(1,4) 和 y = range(4,7),那么表达式 sum([i*j for i,j in zip(x,y)]) 的值为

    32
    

    118、 表达式 [5 for i in range(3)] 的值为() ([5, 5, 5])

    119、 表达式 {1, 2, 3} == {1, 3, 2} 的值为() (True)

    120、 表达式 [1, 2, 3] == [1, 3, 2] 的值为() (False)

    121、 已知 x = [1, 2, 1],那么表达式 id(x[0]) == id(x[2]) 的值为() (True)

    122、 表达式 3 not in [1, 2, 3]的值为() (False)

    123、 已知 x = [1, 2],那么执行语句 x[0:0] = [3, 3]之后,x的值为

    [3, 3, 1, 2]
    

    124、 已知 x = [1, 2],那么执行语句 x[0:1] = [3, 3]之后,x的值为() ([3, 3, 2])

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

    [1, 4, 5]
    

    126、 已知 x = [[1, 2, 3,], [4, 5, 6]],那么表达式 sum([i * j for i,j in zip(*x)]) 的值为

    32
    

    127、 已知列表 x = [1, 2, 3] 和 y = [4, 5, 6],那么表达式 [(i,j) for i, j in zip(x,y) if i==3] 的值为[(3, 6)]

    [(3, 6)]
    

    128、 已知列表 x = [1.0, 2.0, 3.0],那么表达式 sum(x)/len(x) 的值为

    2
    

    129、 已知 x = {1:2, 2:3, 3:4},那么表达式 sum(x) 的值为

    6
    
    • sum对字典使用是字典key值相加

    130、 已知 x = {1:2, 2:3, 3:4},那么表达式 sum(x.values()) 的值为

    9
    

    131、 已知 x = [3, 2, 3, 3, 4],那么表达式 [index for index, value in enumerate(x) if value==3] 的值为

    [0, 2, 3]
    

    132、 表达式 1234%1000//100 的值为() (2)

    133、 表达式 3 // 5 的值为() (0)

    134、 表达式 [1, 2] + [3] 的值为

    [1, 2, 3]
    

    135、 表达式 (1,) + (2,) 的值为

    (1, 2)
    

    136、 表达式 (1) + (2) 的值为() (3)

    137、 已知 x, y = map(int, [‘1’, ‘2’]),那么表达式 x + y 的值为()

    3
    

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

    3
    

    139、 已知列表 x = [1, 3, 2],那么执行语句 x.reverse() 之后,x的值为

    [2, 3, 1]
    

    140、 已知列表 x = [1, 3, 2],那么执行语句 x = x.reverse() 之后,x的值为

    None
    

    141、 已知x为非空列表,那么表达式 x.reverse() == list(reversed(x)) 的值为

    False
    

    在这里插入图片描述

    142、 已知x为非空列表,那么表达式 x.sort() == sorted(x) 的值为

    False
    

    143、 已知列表 x = [1, 3, 2],那么执行语句 y = list(reversed(x)) 之后,x的值为

    [1, 3, 2]
    

    144、 已知列表 x = [1, 3, 2],那么执行语句 y = list(reversed(x)) 之后,y的值为() ([2, 3, 1])

    145、 已知列表x中包含超过5个以上的元素,那么表达式 x == x[:5]+x[5:] 的值为

    True
    

    146、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 sum(x) 的值为

    3
    

    147、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 sum(item[0] for item in x.items()) 的值为

    3
    

    在这里插入图片描述

    148、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 ‘’.join([item[1] for item in x.items()]) 的值为

    '345'
    

    149、 已知列表 x = [1, 3, 2],那么表达式 [value for index, value in enumerate(x) if index==2] 的值为

    [2]
    

    150、 已知列表 x = [1, 3, 2],那么执行语句 a, b, c = sorted(x) 之后,b的值为() (2)

    151、 已知列表 x = [1, 3, 2],那么执行语句 a, b, c = map(str,sorted(x)) 之后,c的值为() (‘3’)

    152、 表达式 set([1,2,3]) == {1, 2, 3} 的值为() (True)

    153、 表达式 set([1,2, 2,3]) == {1, 2, 3} 的值为() (True)

    154、 表达式 ‘%c’%65 == str(65) 的值为

    False
    

    155、 表达式 ‘%s’%65 == str(65) 的值为

    True
    

    156、 表达式 chr(ord(‘b’)^32) 的值为

    'B'
    
    • ^为按位异或运算符,只要对应的二进制有一个为1时,结果位就为1

    157、 表达式 ‘abc’ in ‘abdcefg’ 的值为() (False)

    158、 已知x为整数变量,那么表达式 int(hex(x), 16) == x 的值为

    True
    

    159、 已知 x, y = 3, 5,那么执行x, y = y, x 之后,x的值为() (5)

    160、 已知 x = ‘abcd’ 和 y = ‘abcde’,那么表达式 [i==j for i,j in zip(x,y)] 的值为

    [True, True, True, True]
    

    161、 已知x = list(range(20)),那么表达式x[-1]的值为() (19)

    162、 已知x = 3+4j和y = 5+6j,那么表达式x+y的值为() (8+10j)

    163、 已知x = [3],那么执行x += [5]之后x的值为

    [3, 5]
    

    164、 已知x = [3, 3, 4],那么表达式id(x[0])==id(x[1])的值为() (True)

    165、 表达式int(‘11’, 2)的值为

    3
    

    166、 表达式int(‘11’, 8)的值为() 9

    167、 表达式int(bin(54321), 2)的值为

    54321
    
    • bin传入一个整数int或者长整数long int,以二进制表示后用字符串返回

    168、 表达式chr(ord(‘A’)+1)的值为() (‘B’)

    169、 表达式int(str(34)) == 34的值为() (True)

    170、 表达式list(str([3, 4])) == [3, 4]的值为

    False
    

    在这里插入图片描述

    171、 表达式{1, 2, 3, 4, 5, 6} ^ {5, 6, 7, 8}的值为()

    {1, 2, 3, 4, 7, 8}
    

    172、 表达式15 // 4的值为() (3)

    173、 表达式sorted({‘a’:3, ‘b’:9, ‘c’:78})的值为

    ['a', 'b', 'c']
    
    • sorted对字典进行排序时默认根据字典的键值与ASCII码顺序升序排列

    174、 表达式sorted({‘a’:3, ‘b’:9, ‘c’:78}.values())的值为

    [3, 9, 78]
    

    175、 已知x = [3, 2, 4, 1],那么执行语句x = x.sort()之后,x的值为() (None)

    176、 表达式list(filter(lambda x: x>5, range(10)))的值为

    [6, 7, 8, 9]
    

    177、 已知x = list(range(20)),那么语句print(x[100:200])的输出结果为

    []
    

    178、 已知x = list(range(20)),那么执行语句x[:18] = []后列表x的值为() ([18, 19])

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

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

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

    182、 已知x = [[]] * 3,那么执行语句x[0].append(1)之后,x的值为()

    [[1], [1], [1]]
    

    183、 已知x = [[] for i in range(3)],那么执行语句x[0].append(1)之后,x的值为

    [[1], [], []]
    

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

    185、 已知x = {1:1, 2:2},那么执行语句x.update({2:3, 3:3})之后,表达式sorted(x.items())的值为

    [(1, 1), (2, 3), (3, 3)]
    

    186、 已知x = {1:1, 2:2},那么执行语句x[3] = 3之后,表达式sorted(x.items())的值为

    [(1, 1), (2, 2), (3, 3)]
    

    187、 已知x = [1, 2, 3],那么表达式not (set(x*100)-set(x))的值为

    True
    

    188、 已知x = [1, 2, 3],那么表达式not (set(x*100)&set(x))的值为

    False
    

    189、 表达式{‘x’: 1,** {‘y’: 2}}的值为

    {'x': 1, 'y': 2}
    

    190、 表达式{*range(4), 4, *(5, 6, 7)}的值为

    {0, 1, 2, 3, 4, 5, 6, 7}
    

    191、 已知 x = [1,2,3,4,5],那么执行语句 x[::2] = range(3) 之后,x的值为

    [0, 2, 1, 4, 2]
    

    192、 已知 x = [1,2,3,4,5],那么执行语句 x[::2] = map(lambda y:y!=5,range(3)) 之后,x的值为

    [True, 2, True, 4, True]
    

    193、 已知 x = [1,2,3,4,5],那么执行语句 x[1::2] = sorted(x[1::2], reverse=True) 之后,x的值为

    [1, 4, 3, 2, 5]
    

    194、 表达式 True*3 的值为

    3
    

    195、 表达式 False+1 的值为

    1
    

    判断

    1、 Python支持使用字典的“键”作为下标来访问字典中的值。(对)

    2、 列表可以作为字典的“键”。(错)

    3、 元组可以作为字典的“键”。(对)

    4、 字典的“键”必须是不可变的。(对)

    • 不可变序列包括字符串,元组,数字。可变序列包括列表,字典,集合

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

    6、 已知x为非空列表,那么x.sort(reverse=True)和x.reverse()的作用是等价的。(错)

    7、 生成器推导式比列表推导式具有更高的效率,推荐使用。(对)

    8、 Python集合中的元素不允许重复。(对)

    9、 Python集合可以包含相同的元素。(错)

    10、 Python字典中的“键”不允许重复。(对)

    11、 Python字典中的“值”不允许重复。(错)

    12、 Python集合中的元素可以是元组。(对)

    13、 Python集合中的元素可以是列表。(错)

    14、 Python字典中的“键”可以是列表。(错)

    15、 Python字典中的“键”可以是元组。(对)

    16、 Python列表中所有元素必须为相同类型的数据。(错)

    17、 Python列表、元组、字符串都属于有序序列。(对)

    18、 已知A和B是两个集合,并且表达式A<B的值为False,那么表达式A>B的值一定为True。(错)

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

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

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

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

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

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

    25、 已知列表 x = [1, 2, 3],那么执行语句 x = 3 之后,变量x的地址不变。(错)

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

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

    28、 Python字典和集合属于无序序列。(对)

    29、 无法删除集合中指定位置的元素,只能删除特定值的元素。(对)

    30、 元组的访问速度比列表要快一些,如果定义了一系列常量值,并且主要用途仅仅是对其进行遍历二不需要进行任何修改,建议使用元组而不使用列表。(对)

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

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

    • 返回空列表而不是抛出异常

    33、 只能对列表进行切片操作,不能对元组和字符串进行切片操作。(错)

    34、 只能通过切片访问列表中的元素,不能使用切片修改列表中的元素。(错)

    35、 只能通过切片访问元组中的元素,不能使用切片修改元组中的元素。(对)

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

    37、 Python字典和集合支持双向索引。(错)

    38、 Python集合不支持使用下标访问其中的元素。(对)

    39、 相同内容的字符串使用不同的编码格式进行编码得到的结果并不完全相同。(对)

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

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

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

    在这里插入图片描述

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

    44、 表达式 {1, 3, 2} > {1, 2, 3} 的值为True。(错)

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

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

    47、 表达式 ‘a’+1的值为’b’。(错)

    48、 创建只包含一个元素的元组时,必须在元素后面加一个逗号,例如(3,)。(对)

    49、 表达式 list(’[1, 2, 3]’) 的值是[1, 2, 3]。(错)

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

    51、 同一个列表对象中所有元素必须为相同类型。(错)

    52、 已知x为非空列表,那么执行语句x[0] = 3之后,列表对象x的内存地址不变。(对)

    53、 列表可以作为集合的元素。(错)

    54、 集合可以作为列表的元素。(对)

    55、 元组可以作为集合的元素。(对)

    56、 集合可以作为元组的元素。(对)

    57、 字典可以作为集合的元素。(错)

    58、 集合可以作为字典的键。(错)

    59、 集合可以作为字典的值。(对)

    60、 可以使用del删除集合中的部分元素。(错)

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

    62、 表达式 {1, 2} * 2 的值为 {1, 2, 1, 2}。(错)

    63、 Python字典支持双向索引。(错)

    64、 Python集合支持双向索引。(错)

    65、 Python元组支持双向索引。(对)

    66、 假设re模块已成功导入,并且有 pattern = re.compile(’^’+’.’.join([r’\d{1,3}’ for i in range(4)])+’$’),那么表达式 pattern.match(‘192.168.1.103’) 的值为None。(错)

    67、 假设random模块已导入,那么表达式 random.sample(range(10), 20) 的作用是生成20个不重复的整数。(错)

    • 这样会抛出异常

    68、 假设random模块已导入,那么表达式 random.sample(range(10), 7) 的作用是生成7个不重复的整数。(对)

    69、 使用random模块的函数randint(1, 100)获取随机数时,有可能会得到100。(对)

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

    71、 已知x = 3,那么执行x += 6语句前后x的内存地址是不变的。(错)

    72、 成员测试运算符in作用于集合时比作用于列表快得多。(对)

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

    74、 已知x和y是两个等长的整数列表,那么表达式sum((i*j for i, j in zip(x, y)))的作用是计算这两个列表所表示的向量的内积。(对)

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

    76、 表达式int(‘1’*64, 2)与sum(2 * * i for i in range(64))的计算结果是一样的,但是前者更快一些。(对)

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

    78、 已知x = list(range(20)),那么语句x[::2] = []可以正常执行。(错)

    在这里插入图片描述

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

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

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

    82、 在Python中,变量不直接存储值,而是存储值的引用,也就是值在内存中的地址。(对)

    83、 表达式(i * *2 for i in range(100))的结果是个元组。(错)

    • 是一个生成器对象

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

    85、 Python内置的字典dict中元素是按添加的顺序依次进行存储的。(错)

    86、 Python内置的集合set中元素顺序是按元素的哈希值进行存储的,并不是按先后顺序。(对)

    87、 已知x = {1:1, 2:2},那么语句x[3] =3无法正常执行。(错)

    88、 Python内置字典是无序的,如果需要一个可以记住元素插入顺序的字典,可以使用collections.OrderedDict。(对)

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

    • 列表没有find方法,这是字符串用来寻找子串的方法。list只有index方法。

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

    91、 已知x是一个列表,那么x = x[3:] + x[:3]可以实现把列表x中的所有元素循环左移3位。(对)

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

    76、 表达式int('1’64, 2)与sum(2 *i for i in range(64))的计算结果是一样的,但是前者更快一些。(对)

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

    78、 已知x = list(range(20)),那么语句x[::2] = []可以正常执行。(错)

    在这里插入图片描述

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

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

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

    82、 在Python中,变量不直接存储值,而是存储值的引用,也就是值在内存中的地址。(对)

    83、 表达式(i * *2 for i in range(100))的结果是个元组。(错)

    • 是一个生成器对象

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

    85、 Python内置的字典dict中元素是按添加的顺序依次进行存储的。(错)

    86、 Python内置的集合set中元素顺序是按元素的哈希值进行存储的,并不是按先后顺序。(对)

    87、 已知x = {1:1, 2:2},那么语句x[3] =3无法正常执行。(错)

    88、 Python内置字典是无序的,如果需要一个可以记住元素插入顺序的字典,可以使用collections.OrderedDict。(对)

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

    • 列表没有find方法,这是字符串用来寻找子串的方法。list只有index方法。

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

    91、 已知x是一个列表,那么x = x[3:] + x[:3]可以实现把列表x中的所有元素循环左移3位。(对)

    在这里插入图片描述

    展开全文
  • Python期末复习题

    万次阅读 多人点赞 2019-01-15 11:11:33
    Python内置函数len()可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。P15   列表、元组、字符串是Python的有序(有序?无序?)序列。   查看变量内存地址的Python内置函数是ID()。P8   表...

    填空题

    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') 的值为8P97# 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

     

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

     

    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。

     

    已知xy是两个字符串,那么表达式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.xinput()函数的返回值总是字符串。

     

    在循环中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] 

     

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

     

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

     

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

     

    Python变量名区分大小写,所以studentStudent不是同一个变量。

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

    Python元组支持双向索引。

     

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

     

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

     

    使用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:#n3取余等于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):#1001,步长为-1

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

                  if n % i==0:#ni取余不等于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 循环当中。

    展开全文
  • 查了一下,发现是SpringMVC不知道怎么封装对象中的数组对象导致的,所以需要自己在前端传值回来之前手动封装一下。 封装方法如下:(其中,data是你要从前端传递到后端的对象,里面可能包含属性,数组,对象数组...

        今天碰到这个问题是真的头疼,本来要传递的是data.objs[0].key = 1这样的一个内容,结果传到后台时被解析成了data.objs[0][key] = 1。查了一下,发现是SpringMVC不知道怎么封装对象中的数组对象导致的,所以需要自己在前端传值回来之前手动封装一下。

        封装方法如下:(其中,data是你要从前端传递到后端的对象,里面可能包含属性,数组,对象数组等等;objs为data中的对象数组;key1为对象数组中的一个属性;key2为对象数组中的另一个属性)

        Vue的方法中:

    for (let i=0; i<objs.length; i++) {
        data['objs[' + i + '].key1'] = objs[i].key1
        data['objs[' + i + '].key2'] = objs[i].key2
    }

        Controller中接收:

    @RequestMapping("/insert")
    public void insert(Data data) {}

        Bean中:

    /*Data.class*/
    public class Data {
        private String prop1;
        private String prop2;
        private List<Obj> objs;
    
        get...
    
        set...
    }
    
    /*Obj.class*/
    public class Obj {
        private String key1;
        private String key2;
    
        get...
    
        set...
    }

        参考文章:https://blog.csdn.net/freeniuniu/article/details/78806508

    -------------------------------------------------------------------------------分割线---------------------------------------------------------------------------------

        你以为到这里就结束了,我也没想到这个事情竟然还有后续。

        我这样处理新增的操作确实是可以了,但是在执行修改的操作的时候又出现了同样的错误,明明我用的是同样的代码。这个事情卡了我一晚上,后来想想我把新增和修改的数据分别打印出来,看看有什么不一样。

        此时我们会发现在新增的时候,choices是undefined的,而在编辑的时候choices是有数据的,这就会导致在编辑的时候,SpringMVC会去解析自动封装的choices而忽略了我们手动封装choices,最后导致的报错。所以我们在手动封装之前,还需要把choices设为undefined,问题解决。

        第一次碰到这个问题还真的挺上火的。

     

    展开全文
  • Java List.add()方法:向集合列表中添加对象 Java 集合类中的 List.add() 方法用于向集合列表中添加对象。 语法1 用于在列表的尾部插入指定元素。如果 List 集合对象由于调用 add 方法而发生更改,则返回 true;否则...
  • Python列表List保存对象的指针

    千次阅读 2017-03-03 15:26:51
    突然发现Python中列表(list)的一些有意思的设计: # coding:utf-8 a = [[1,2,3],[4,5,6],[7,8,9]] print 'a : ' print a b = a print 'b : ' print b a[0][0]=10 a[0][1]=10 a[0][2]=10 print 'a修改过后,b取值 :...
  • python找出列表list中重复元素

    千次阅读 2021-05-19 10:13:38
    a = [29,36,57,12,79,43,23,56,28,11,14,15,16,37,24,35,17,24,33,15,39,46,52,13] b = dict(Counter(a)) print ([key for key,value in b.items()if value > 1]) #只展示重复元素 print ({key:value for key,...
  • Spring MVC : Property referenced in indexed property path is neither an array nor a List nor a Map JQuery的$.ajax在将json对象映射到参数方面做得非常出色,但是当你开始尝试传输更复杂的对象时(比如对象里...
  • List 属性List = 对象List.stream().map(对象::get方法()).collect(Collectors.toList());例如:List idList = list.stream().map(User::getId).collect(Collectors.toList());//或者List idList = list.stream()....
  • 说明:后台对象为 类似结构ObjectA{private String a;private String b;private List c;}ObjectC{private Stringd;private String e;}往后台传的数据都是转为JSON字符串的,但是只要List一有值就会报错。解决方案:...
  • python如何判断一个对象是否是列表

    千次阅读 2021-03-06 04:40:19
    python中的isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。以下是 isinstance() 方法的语法:isinstance(object,classinfo)参数object -- 实例对象。classinfo -- 可以是直接或间接类名、基本...
  • Java中,List集合对象,默认有一个排序方法sort(Comparator<? super E> c),如果传递null,那是对简单类型的排序,如果是对象类型,并且是需要按照对象类型的某一个属性字段排序,就需要我们传入排序的规则。 ...
  • 自定义对象集合List之间取差集

    万次阅读 2019-04-27 16:22:37
    前言 在工作中少不了使用集合类来处理数据,List是最常用的一种集合了。这些集合类使用都非常的方便,但是使用集合存放一些自定义的对象时,就需要注意使用这些方法了。 这里主要讲一下List之间的差集该...listA....
  • list对象去重

    千次阅读 2018-12-03 23:28:09
    一、针对String类型进行去重 方式一:使用另一个list在添加元素的时候进行重复判断 /** * 方式一:使用另一个list在添加元素的时候进行重复...a", "AA", "aa", "bb", "
  • java中,有两个listlistlist,AB对象的属性略有不同,现在想把A中的属性复制到B中,我们可以通过fastJOSN的方式方便的实现 package com.hanshow.wise.base.operate.util; import java.util.List; import ...
  • list对象的取值

    万次阅读 多人点赞 2017-09-09 14:43:46
    相信很多小伙伴都碰到过这种情况,查询数据库的数据放到list...直接上代码List<A> aList = new ArrayList<A>(); for(int i = 0;i < aList.size();i++){ A a = aList.get(i);//直接拿这个a去点get或者set就行了 a.get
  • list数据比对与list对象比对

    千次阅读 2018-12-24 22:39:22
    第一种方式使用工具类进行比较 ... import java.util.ArrayList; import java.util.HashMap;...import java.util.List; import java.util.Map; /** * lists数据比对 * @author nick */ public class ...
  • 最近开发接口过程中,发现在使用BeanCopier拷贝对象的时候,当对象中嵌套自定义对象类型属性的时候,如果对象名称一致,但是对象类型不一致的时候,拷贝的时候,该属性是会被忽略的,但是当对象中嵌套List集合类型,...
  • Python中关于列表list的赋值问题

    千次阅读 2022-03-03 10:19:59
        本文的原因是因为在使用list的直接赋值b=a时,得到的结果与预期不同,后来才发现直接使用等于号=对列表进行赋值会产生一系列的问题,于是将赋值、浅拷贝、深拷贝三者之间的区别进行记录。 1.列表
  • postman 传递对象对象中包含list

    千次阅读 2018-08-17 10:08:00
    list中如果还是一个对象那么该对象同样需要声明出: 默认的构造函数, 不然同样报错!!!至此问题终于解决了!!! 转载于:https://my.oschina.net/u/252854/blog/1929401
  • I have a list of Fruit objects in arraylist and I want to modify fruitName to its plural name.Refer the example:@Data@AllArgsConstructor@ToStringclass Fruit {long id;String name;String country;}List f...
  • list stream:将对象List中的某个字段放到新的List

    万次阅读 多人点赞 2019-03-13 01:58:52
    public static void main... List&lt;TAdslot&gt; userList = new ArrayList&lt;&gt;(); TAdslot adslot1 = new TAdslot(); adslot1.setName("One"); TAdslot adslot2 = new TAdslot...
  • Python list 常用方法总结

    千次阅读 2021-03-05 22:57:46
    转载的https://www.cnblogs.com/chendai21/p/8125422.html一,创建列表 只要把逗号分隔的不同的数据项使用方括号([ ])括起来即可 ...[] 空列表二,添加新的元素list.append() 在list 末尾增加一个元素list.insert(n...
  • 例如Listlist=NEWArrayList();peoplep=newPeple();p.setage(“1”);p.setname(“2”);peoplep2=newPeple();p2.setage(“3”);p2.setname(“4”);peoplep3=newPeple();p3.setage(“1”);p3.setname(“2”);lsit.add(....
  • import java.util.List; public class JudgeList { class Person{ private int id; private int age; private String name; public int getId() { return id; } public void setId(int id) { .
  • 例如我们有一个Student集合,每个对象有“id”,“name”,“age”三个字段,如下: @Data @AllArgsConstructor public class Student { private Integer id; private String name; private Integer age; } ...
  • list.stream修改对象

    千次阅读 2021-04-25 15:53:17
    list.stream().filter(a -> 筛选条件).forEach(b -> b.setOrg("1"));
  • 两个List对象做对比

    千次阅读 2020-11-10 17:27:52
    1、思路 两个集合对象对比数据,找出缺少的,多余的,和不同的数据。前提下是两个对象是同一个对象才可以对比,这样比较方便。如果是两个不同的对象,需要先转化成一样的对象再... a = new ArrayList<Student>();
  • 利用Java8按照元素对象的多字段对List进行排序 实例对象 public class WarningRule implements Serializable { private String hour; private String content; //类型排序字段 private Integer order; ...
  • 在java克隆的时候,所要克隆的对象包含比较复杂的数据结构如:list集合等一些复杂的引用的时候,该怎么克隆。 深克隆,浅克隆的实现和理解。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,163,920
精华内容 465,568
关键字:

列表对象alist