python 小甲鱼 源码 小甲鱼python最新版

文章目录

• 课后作业

• 0.列表都可以存放一些什么东西？
• 1.向列表增加元素有哪些方法？
• 2.append() 方法和 extend() 方法都是向列表的末尾增加元素，请问他们有什么区别？
• 3.有列表 name = [‘F’, ‘i’, ‘h’, ‘C’]，如果小甲鱼想要在元素 ‘i’ 和 ‘h’ 之间插入元素 ‘s’，应该使用什么方法来插入？
• 4.自己动手试试看，并分析在这种情况下，向列表添加数据应当采用哪种方法比较好？
• 5.利用 for 循环打印上边 member 列表中的每个内容，如图：
• 6.上一题打印的样式不是很好，能不能修改一下代码打印成下图的样式呢？【请至少使用两种方法实现】
• 7.下边的列表分片操作会打印什么内容？
• 8.请问 list1[0] 和 list1[0:1] 一样吗？
• 9.如果你每次想从列表的末尾取出一个元素，并将这个元素插入到列表的最前边，你会怎么做？
• 10.有些鱼油比较调皮，他说我想试试 list1[-3:-1] 会不会报错，怎么知道一试居然显示 [9, 7]，这是怎么回事呢？
• 11.有关分片的步长。
• 12.课堂上小甲鱼说可以利用分片完成列表的拷贝 list2 = list1[:]，那事实上可不可以直接写成 list2 = list1 更加简洁呢？
• 14.如果不上机操作，你觉得会打印什么内容？
• 15.请问如何将下边这个列表的’小甲鱼’修改为’小鱿鱼’？
• 16.要对一个列表进行顺序排序，请问使用什么方法？逆序排序呢？
• 17.问题：请先在 IDLE 中获得下边列表的结果，并按照上方例子把列表推导式还原出来。
• 18.活学活用：请使用列表推导式补充被小甲鱼不小心涂掉的部分。
• 19.你知道什么是匿名列表吗？
• 20.如果有一个列表 list1，有两种方法可以获取到该列表的最后一个元素，你知道分别是什么吗？
• 21.下面有两列表，请问如何将 list2 列表中的全部元素，添加到 list1 列表中第 2 和第 3 个元素的中间。
• 22.列表的 extend() 方法是否支持使用字符串来扩展列表？
• 23. 请问下面代码是否会报错？
• 24.请将下面代码改为使用列表的 insert() 方法实现。
• 25. 请问下面代码执行后，列表 s 的内容是什么？
• 26. 请使用切片的语法，实现与下面代码相同的效果。
• 27. 请使用切片的语法，实现与下面代码相同的效果。
• 28. 请问下面代码执行后，列表 s 的内容是什么？

• 总结：对于extend(方法和切片的方法增改列表，注意增改的参数对象是否为可迭代对象，若是可迭代对象，则就将可迭代对象中的元素依次赋为列表！

• 29.给定一个整数列表 nums 和一个目标值 target，请在该数组中找出和为目标值的两个元素，并将它们的数组下标值打印出来。
• 30.这次我们想让用户自己来录入 nums 和 target 的数据，请修改上一题的代码，让程序实现如下：
• 31. 回忆学习过的 random 模块，生成一个由 10000 个整数（范围是 1 ~ 65535）构成的随机列表，目标值 target 由用户输入。使得程序实现如下：
• 32. 请编写一个程序，判断给定的字符串 s 中括号的写法是否合法。

课后作业

0.列表都可以存放一些什么东西？

答： Python 的列表是一个打了激素的数组，如果把数组比喻成集装箱，那么 Python 的列表就是一个大仓库，Ta 可以存放我们已经学习过的任何数据类型。

1.向列表增加元素有哪些方法？

答：有append()、extend() 和 insert()。

2.append() 方法和 extend() 方法都是向列表的末尾增加元素，请问他们有什么区别？

答：append()方法是将参数作为一个元素增加到列表的末尾，即无论 append 的参数是什么类型，都将它作为一个元素添加到列表尾。

而extend()方法则是将参数作为一个列表在末尾去扩展列表。

比如member.append([‘竹林小溪’, ‘Crazy迷恋’]) 和 member.extend([‘竹林小溪’,

‘Crazy迷恋’]) 实现的效果一样吗？答案是不一样的。如下图：

3.有列表 name = [‘F’, ‘i’, ‘h’, ‘C’]，如果小甲鱼想要在元素 ‘i’ 和 ‘h’ 之间插入元素 ‘s’，应该使用什么方法来插入？

答：insert(2, ‘s’)

4.自己动手试试看，并分析在这种情况下，向列表添加数据应当采用哪种方法比较好？

假设给定以下列表：
member = [‘小甲鱼’, ‘黑夜’, ‘迷途’, ‘怡静’, ‘秋舞斜阳’]
要求将列表修改为：
member = [‘小甲鱼’, 88, ‘黑夜’, 90, ‘迷途’, 85, ‘怡静’, 90, ‘秋舞斜阳’, 88]
方法一：使用 insert() 和 append() 方法修改列表。
方法二：重新创建一个同名字的列表覆盖。

答： 方法一：

方法二：

对于这种情况，明显是第二种方法看起来要好一些。不过对于大型的列表，第一种方法可能更合适，所以我们说永远没有最好的，只有最合适的！

5.利用 for 循环打印上边 member 列表中的每个内容，如图：

答：代码如下：

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
for m in member:
	print(m)

6.上一题打印的样式不是很好，能不能修改一下代码打印成下图的样式呢？【请至少使用两种方法实现】

答：方法一：根据元素位置输出

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
for m in member:
    if member.index(m) % 2 == 0:
        print(m, end=' ') 
    else:
        print(m)

方法二：根据元素类型输出

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
for m in member:
    if isinstance(m, str):
        print(m, end=' ') 
    else:
        print(m)

7.下边的列表分片操作会打印什么内容？

>>> list1 = [1, 3, 2, 9, 7, 8]
>>> list1[2:5]

答：[2, 9, 7]，有图有真相：

8.请问 list1[0] 和 list1[0:1] 一样吗？

答：不一样，list[0]返回的是列表中索引为0的元素的值，而list1[0:1]则是返回一个只含有索引为0的元素的列表，如下：

9.如果你每次想从列表的末尾取出一个元素，并将这个元素插入到列表的最前边，你会怎么做？

答：list1.insert(0, list1.pop())，如下图：

10.有些鱼油比较调皮，他说我想试试 list1[-3:-1] 会不会报错，怎么知道一试居然显示 [9, 7]，这是怎么回事呢？

答：Python支持复数索引，正常索引是从左到右索引，负数索引是从右到左。从列表末尾来算的话，列表最后一个元素的索引为-1，倒数第二个为-2，以此类推，所以最后会打印[9, 7]。

11.有关分片的步长。

在进行分片的时候，我们知道分片的开始和结束位置需要进行指定，但其实还有另外一个隐藏的设置：步长。在普通的分片操作中，步长默认设置为1，表示逐个遍历元素。其实我们可以人为调整步长以达到不可告人的秘密。如下：

那么依你推测，关于步长的知识点还有哪些（很多知识点都是通用的）？

答：具体如下图：

12.课堂上小甲鱼说可以利用分片完成列表的拷贝 list2 = list1[:]，那事实上可不可以直接写成 list2 = list1 更加简洁呢？

答：千万不可以！
变量不是一个盒子，它并不能存储数据， list2 = list1 这样直接赋值的方式，其实就是相当于多了一个变量指向同一个东西，给一个固定的东西增加了一个新的标签而已，此时list和list2其实就是一样的，会互相影响对方的值。
而分片的操作完成的是浅拷贝，浅拷贝可以拷贝父对象，由于这里没有子对象，所以用此方法完成的拷贝使得list2和list1指向的是不同对象，所以不会相互影响。

14.如果不上机操作，你觉得会打印什么内容？

>>> old = [1, 2, 3, 4, 5]
>>> new = old
>>> old = [6]
>>> print(new)

答：[1, 2, 3, 4, 5]。

这是python贴标签式的变量赋值方法导致的。old = [6]这个语句实际上是将old这个标签贴在了一片新的内存空间上（old指向了新的引用），这片内存空间中存储了[6]这个列表，所以old在被赋了新值后，不再指向原来的内存空间，所以new不会改变。

15.请问如何将下边这个列表的’小甲鱼’修改为’小鱿鱼’？

list1 = [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]

代码如下图：

16.要对一个列表进行顺序排序，请问使用什么方法？逆序排序呢？

#顺序排序
>>> 列表名.sort()
#逆序排序1
>>> 列表名.sort() #顺序排序
>>> 列表名.reverse() #倒置
#逆序排序2
>>> 列表名.sort(reverse=True) 直接逆序排序

17.问题：请先在 IDLE 中获得下边列表的结果，并按照上方例子把列表推导式还原出来。

>>> list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]

答：还原代码如下：

list1 = []
for x in range(10):
    for y in range(10):
        if x%2 == 0:
            if y%2 != 0:
                list1.append((x, y))

18.活学活用：请使用列表推导式补充被小甲鱼不小心涂掉的部分。

答：代码如下：[y + ":" + x[2:] for x in list1 for y in list2 if x[0] == y[0]]，有图有真相：

19.你知道什么是匿名列表吗？

答：创建一个列表，但没有将其赋值给变量名，那它一个匿名列表。由于没有名字，将导致该列表创建完无法永远再次访问到。

20.如果有一个列表 list1，有两种方法可以获取到该列表的最后一个元素，你知道分别是什么吗？

答，最开始想到的是使用list1[-1]以及list1.pop()方法，但是其实pop()方法虽然获取到了但是也从列表中弹出了该元素，正确答案是list1[len(list1) - 1] 和 list1[-1]。

21.下面有两列表，请问如何将 list2 列表中的全部元素，添加到 list1 列表中第 2 和第 3 个元素的中间。

>>> list1 = [1, 2, 8, 9]
>>> list2 = [3, 4, 5, 6, 7]

答：答案如下图：

22.列表的 extend() 方法是否支持使用字符串来扩展列表？

答：支持，字符串也是可迭代对象，如下图：

23. 请问下面代码是否会报错？

>>> s = [1, 2, 3]
>>> s.append([4, 5, 6])

答：不会的，这里append的[4, 5, 6]就是作为一整个元素添加到s的末尾。如下图：

24.请将下面代码改为使用列表的 insert() 方法实现。

>>> s = [1, 2, 3, 4, 5]
>>> s.append(6)

答：s.insert(len(s), 6)，如下图：

25. 请问下面代码执行后，列表 s 的内容是什么？

>>> s = [1, 2, 3, 4, 5]
>>> s.extend(["FishC"])

答案：[1, 2, 3, 4, 5, ‘FishC’]，如下图：

补充：

列表的 extend() 方法的参数需要是一个可迭代对象，然后将可迭代对象的元素逐个插入到列表中。那么这里的可迭代对象是 [“FishC”]，它只有一个元素，就是 “FishC”。

如果代码换成 s.extend(“FishC”)，那么结果就会变成 [1, 2, 3, 4, 5, ‘F’, ‘i’, ‘s’, ‘h’, ‘C’]。

26. 请使用切片的语法，实现与下面代码相同的效果。

>>> s = [1, 2, 3, 4, 5]
>>> s.extend("上山打老虎")
>>> s
[1, 2, 3, 4, 5, '上', '山', '打', '老', '虎']

答：s[len(s):] = [“上山打老虎”]。
切片的语法很神奇，s[len(s):] = [“上山打老虎”] 其实相当于执行了两个步骤：
1）将赋值号左侧指定位置的内容清空；
2）将赋值号右侧可迭代对象的内容插入到左侧列表被清空的位置。
由于 s[len(s):] 指定的是列表的末尾，所以该代码是将右侧可迭代对象的内容（“上山打老虎”）插入 s 列表的末尾。

27. 请使用切片的语法，实现与下面代码相同的效果。

>>> s = [1, 2, 3, 4, 5]
>>> s.extend("上山打老虎")
>>> s
[1, 2, 3, 4, 5, '上', '山', '打', '老', '虎']

答： s[len(s):] = “上山打老虎”
这一题跟上一题比较的话，有一个容易混淆的点，就是上一题的可迭代对象是一个列表（[“上山打老虎”]，这个只有 1 个元素），而这一题的可迭代对象是一个字符串（“上山打老虎”，有 5 个字符元素构成）。

28. 请问下面代码执行后，列表 s 的内容是什么？

>>> s = [1, 2, 3, 4, 5]
>>> s[len(s)-2:] = [2, 1]

答：[1, 2, 3, 2, 1]，参考上面26&27两道题即可！

总结：对于extend(方法和切片的方法增改列表，注意增改的参数对象是否为可迭代对象，若是可迭代对象，则就将可迭代对象中的元素依次赋为列表！

29.给定一个整数列表 nums 和一个目标值 target，请在该数组中找出和为目标值的两个元素，并将它们的数组下标值打印出来。

比如给定的列表 nums = [2, 7, 11, 15]，目标值 target = 9，那么由于 nums[0] + nums[1] = 2 + 7 = 9，所以打印结果是：[0, 1]

答：代码如下：

nums = [2, 7, 11, 15]
target = 9
output_list = []
for i in range(len(nums)):
    for j in range(i+1, len(nums)):
        if nums[i] + nums[j] == target:
            output_list.extend([i, j])
            break
    break
print(output_list)

不使用列表，直接拼接输出结果：
链接：python print中f格式化输出简单介绍

nums = [2, 7, 11, 15]
target = 9
for i in range(len(nums)):
    for j in range(i+1, len(nums)):
        if nums[i] + nums[j] == target:
            print(f"[{i},{j}]")

运行结果：

30.这次我们想让用户自己来录入 nums 和 target 的数据，请修改上一题的代码，让程序实现如下：

答案：代码如下：

nums = []
while 1:
    num = input("请录入一个整数（输入STOP结束）：")
    if num.isdigit():
        nums.append(int(num))
    elif num == "STOP":
        break
    else:
        print("输入数据有误，请重新录入一个整数（输入STOP结束）！")
while 1:
    target = input("请录入目标整数：")
    if target.isdigit():
        target = int(target)
        break
    else:
        print("输入数据有误，请重新录入目标整数！") 
for i in range(len(nums)):
    for j in range(i+1, len(nums)):
        if nums[i] + nums[j] == target:
            print(f"[{i},{j}]")

运行结果：

虽然代码考虑到了数据输入错误的情况，但是对于如果找不到的情况并没有考虑进去，增加进去后的代码（加一个isFind标志位）：

nums = []
isFind = False
while 1:
    num = input("请录入一个整数（输入STOP结束）：")
    if num.isdigit():
        nums.append(int(num))
    elif num == "STOP":
        break
    else:
        print("输入数据有误，请重新录入一个整数（输入STOP结束）！")
while 1:
    target = input("请录入目标整数：")
    if target.isdigit():
        target = int(target)
        break
    else:
        print("输入数据有误，请重新录入目标整数！")
for i in range(len(nums)):
    for j in range(i+1, len(nums)):
        if nums[i] + nums[j] == target:
            print(f"[{i},{j}]")
            isFind = True
if not isFind:
    print("找不到和为目标值的两个元素！")

运行结果：

31. 回忆学习过的 random 模块，生成一个由 10000 个整数（范围是 1 ~ 65535）构成的随机列表，目标值 target 由用户输入。使得程序实现如下：

答案：代码如下：

import random
nums = []
for i in range(10000):
    x = random.randint(1, 65535)
    nums.append(x)
while 1:
    target = input("请录入目标整数：")
    if target.isdigit():
        target = int(target)
        break
    else:
        print("输入数据有误，请重新录入目标整数！")
        
for s in range(len(nums)):
    for j in range(s+1, len(nums)):
        if nums[s] + nums[j] == target:
            print(f"[{s},{j}]")

运行结果（注意：列表中的元素是随机生成的，而打印的是元素的下标，不是元素本身！）：

32. 请编写一个程序，判断给定的字符串 s 中括号的写法是否合法。

条件：
1.字符串仅包含 ‘()’、’[]’、’{}’ 这三对括号
2.左右括号必须成对编写，一旦左括号出现，则右括号必须要有。比如 “()” 是合法的，“(” 则是非法的
3.括号可以嵌套出现，但是必须以正确的顺序闭合，比如 “{()}” 是合法的，“{(})” 则是非法的
代码如下：

stack = [] #创建栈
tupl = ('(', '{', '[') # 左括号组成的元组
tupr = (')', '}', ']') # 右括号组成的元组
tup = ('()', '{}', '[]') # 完整的括号组成的元组
isRight = True #设置标志位
inputStr = input("请输入字符串：")
for s in inputStr:
    if s in tupl: # 判断字符是否是左括号中的一种
        stack.append(s) #是的话，压栈
    elif s not in tupr: # 判断字符是否是右括号的一种
        continue #不是的话，转入下一次循环
    else: #是的话，进行括号完整性判断
        if (stack.pop() + s) not in tup:
            isRight = False #一旦有不合法的括号出现，直接修改标志位
if isRight and not stack: #确保标志位的同时，保证栈中没有了元素
    print(inputStr,'是合法字符串！')
else:
    print(inputStr,'不是合法字符串！')

运行结果：