Python学习笔记(十七) 列表函数练习 (附练习题)

插入排序的主要思想是每次取一个列表元素与列表中已经排序好的列表段进行比较，然后插入从而得到新的排序好的列表段，最终获得排序好的列表。

比如，待排序列表为[49,38,65,97,76,13,27,49]，则比较的步骤和得到的新列表如下：

(带有背景颜色的列表段是已经排序好的，红色背景标记的是执行插入并且进行过交换的元素）

时间复杂度：O(n^2)

待排序： 　　　　[49,38,65,97,76,13,27,49]

第一次比较后：　 [38,49,65,97,76,13,27,49]     第二个元素（38）与之前的元素进行比较，发现38较小，进行交换

第二次比较后：　 [38,49,65,97,76,13,27,49]　  第三个元素（65）大于前一个元素（49），所以不进行交换操作，直接到下一个元素比较

第三次比较后： 　[38,49,65,97,76,13,27,49]　  和第二次比较类似

第四次比较后：　 [38,49,65,76,97,13,27,49]　  当前元素（76）比前一元素（97）小，（97）后移，（76）继续与（65）比较，发现当前元素比较大，执行插入

第五次比较后：　 [13,38,49,65,76,97,27,49]　　

第六次比较后：　 [13,27,38,49,65,76,97,49]

第七次比较后：　 [13,27,38,49,49,65,76,97] 

从百度百科上盗了一张图：

# InsertSort插入排序
def InsertSort(myList):
    for i in range(1, len(myList)):
        # 设置当前一个元素的标识
        j = i - 1

        # 如果当前值小于前一个元素，则将当前值作为一个临时变量存储，将第一个元素后移一位
        if myList[i] < myList[j]:
            tmp = myList[i]
            myList[i] = myList[j]

            # 继续往前寻找，如果有比临时变量大的数，则后移一位，直到找到比临时变量小的元素或者达到第一个元素
            j = j - 1
            while j >= 0 and myList[j] > tmp:
                myList[j + 1] = myList[j]
                j -= 1

            # 将临时变量赋值给合适的位置
            myList[j + 1] = tmp


myList = [49, 38, 65, 97, 76, 13, 27, 13]
InsertSort(myList)
print(myList)

练习题：

1. 表达式[1,  2,  3] * 3的值为[1, 2, 3, 1, 2, 3, 1, 2, 3]  
2. 表达式3 in [1,  2,  3,  4]的值为True  
3. 表达式“[3] in [1, 2, 3, 4]”的值为False  
4. 任意长度的非空列表最后一个元素的下标为-1  |  len - 1
5. 表达式list(range(1, 10, 3))的值为[1, 4, 7]  

表达式list(range(10, 1, -3))的值为  [10, 7, 4]  

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

6.列表的方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常

7.假设列表对象的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片：

a[3 : 7] =   [6, 7, 9, 11]  

a[ : 5 : 2] =   [3, 5, 7]  

a[-5 : ] =   [ 9, 11, 13, 15, 17]  

a[-7 : -2 : 2] =   [6, 9, 13]  

a[ : 5 : -1] =   [17, 15, 13, 11]    a[ : 5 : -1]等价于a[ : -5 : -1]

a[8 : -9 : -1] =   [15, 13, 11, 9, 7, 6, 5]  

或者     sorted([5, 6, 7, 9, 11, 13, 15], reverse = True)  

8.已知a = [7, 3, 4, 9, 10, 3, 12, 3, 17]，执行a.pop()后，a = ;

执行a.pop(0)后，a =         ；

执行a.remove(3)后，a =       ;

执行del a[ : 2]后，a =       

9.已知a = [1, 2, 3,]，执行a.insert(1, 4)后，a = [1, 4, 2, 3]  ;

继续执行a.append(10)后，a =   [1, 4, 2, 3, 10]  ;

继续执行a.extend([20, 30])后，a =   [1, 4, 2, 3, 10, 20, 30]  

10.随机返回列表的一个元素（使用系统函数）：    ;

打乱列表元素顺序（使用系统函数）：    ;

11.已知s2 = ‘123’，则：s2 * 3 = 123123123  ;

s2 + str(456) =   123456  ;

12.已知s1 = ‘123456789’，则：s1[ : 3] = 123  ;

s1[-5 : ] =   456789  ;

s1[ : : 2] =   13579  ;

s1[ : : -3] =   963  ;

int(s1[3 : 5]) + int(s1[-5 : 3 : -1]) =   50  ;   字符串可以转整型，列表不可以(如[4, 5])

13.已知s1 = “this is a test of Python”：统计字符串中s出现的次数：s1.count(‘s’)  ;

取出子串”test”的表达式：  s1[s1.find(‘test’) : s1.find(‘test’) + 4]  ;

获取s1的反序字符串：  s1[ : : -1] 或   ;

将子串”test”替换为”exam”：  s1.replace(‘test’, exam‘’)  ;
14.已知字符串a = ‘aAsmr3idd4bgs7D1sf9eAF’，要求如下：

将a字符串中的大写改为小写：    ;

小写改为大写：    ;

转为小写字符串：    ;

a = 'aAsmr3idd4bgs7D1sf9eAF'
s = ''
# 字符串拼接法
for i in a:
    if i.islower():
        s += i.upper()
    elif i.isupper():
        s += i.lower()
    else:
        s += i

print(s)

# 下标法   暂时不会

15.已知x = “abc”，y = “def”，z = [“d”, “e”, “f”]，

则x.join(y) =   dabceabcf  ;

x.join(z) =   dabceabcf  ;

16.把s1 = “你好”，编码为字节流字符串：s1.encode(‘utf-8’)  

17.已知字符串：s2 = ‘bj1902  ’，

去除s2左边的空格：  s2.lstrip()  ;

去除s2右边的空格：  s2.rstrip()  ;

去除s2两边的空格：  s2.strip()  ;

列表函数练习

# 列表的函数：
'''
字符串函数：只有字符串才能调用的函数，列表不能调用
    'abc'.split('-') 正确
    ['a', 'b', 'c'].split('-') 错误    .split()只有字符串才能调用
列表函数：只有通过列表才可以调用的函数
    添加：
        append()
         extend()
         insert()
    删除：
        del  list_name[index]
         remove(element)    # 删除列表中第一次出现的指定元素，返回值是None。若没有找到要删除的元素，则抛出异常。
         pop()              # 删除列表中的最后一个元素，返回值是删除的元素本身。
                            # 默认是删除最后一个元素，也可以指定index来删除
                            # 在数据结构中叫做“弹栈”。弹栈的讲解18:00 -- 32:30 https://www.bilibili.com/video/BV1JE411v7N4?p=67
         clear()            # 清除列表（删除列表里的所有元素）
    反转：
        reverse()
    排序：
        sort()
    次数：
        count()
'''
hotpot_list = ['海底捞', '呷哺呷哺', '张亮麻辣烫', '热辣一号', '宽板凳']

hotpot_list.append('张亮麻辣烫')     # 列表之append()函数
print(hotpot_list)

# result = hotpot_list.remove('张亮麻辣烫') # 列表之remove()函数，删除第一个
# print(result)
# print(hotpot_list)

result2 = hotpot_list.pop()     # 列表之pop()函数
print(result2)
print(hotpot_list)

result2 = hotpot_list.pop(2)
print(hotpot_list)

# result3 = hotpot_list.clear()   # 列表之clear()函数
# print(result3)
# print(hotpot_list)

print(hotpot_list[ : : -1])     # 只是逆序拿出列表中的元素，打印出来，未改变列表元素的位置结构
print(hotpot_list)
# 上下对比分析
hotpot_list.reverse()           # 列表之reverse()函数，改变了列表元素的位置结构
print(hotpot_list)
 
# 系统提供的排序
'''
1、sorted(list, reverse = True | False)
2、list.sort(reverse = True | False)         # 列表调用sort()函数
'''
l = [4, 8, 1, 8, 9, 5, 7]

# l.sort()    # 默认为升序，改变了列表元素的位置结构
# print(l)
l.sort(reverse = True)  # reverse = True表示降序
print(l)

小练习：游戏之王者荣耀购买武器

# 方法一：列表嵌套列表的方法

'''
小练习：游戏之王者荣耀购买武器
    1、选择人物
    2、购买武器  金币
    3、对战  赢  得金币
    4、选择删除武器
    5、退出游戏
'''

以上程序“出售武器”功能的另一种写法：

# 方法二：字典嵌套列表的方法