[已解决]浮点数存取问题

11063216906

FishC 发表于 2026-9-1 21:23
你的理解有点小误会：gcc 不会“输出 .c 文件”，因为 .c 是**源代码文件**，是给编译器读的输入。gcc  ...

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

条件：

字符串仅包含 '('、')'、'['、']'、'{'、'}' 这三对括号的组合
左右括号必须成对编写，比如 "()" 是合法的，"(" 则是非法的
左右括号必须以正确的顺序闭合，比如 "{()}" 是合法的，"{(})" 则是非法的

1. string = input("输入测试字符串：")
   
2. string_list = []
   
3. string_list.extend(string)
   
4. print(string_list)
   
5. list_temp = []
   
6. r = ''
   
7. index = 0
   
8. for i in string_list:
   
9.     print(i)
   
10.     if i == '{' or i == '(' or i == '[':
    
11.         list_temp.append(string_list.pop(index))
    
12.         print(list_temp)
    
13.     else:
    
14.         if len(list_temp) == 0:
    
15.             print("illegal2!")
    
16.             break
    
17.         if i == '}':
    
18.             r = '{'
    
19.         elif i == ']':
    
20.             r = '['
    
21.         elif i == ')':
    
22.             r = '('
    
23. 
    
24.             if list_temp.pop() != r:
    
25.                 print(i)
    
26.                 print(r)
    
27.                 test1 = list_temp.pop()
    
28.                 print(test1)
    
29.                 print('illegal3!')
    
30.                 break
    
31.     index += 1
    
32. 
    
33. else:
    
34.     if len(list_temp) == 0:
    
35.         print("legal!")
    
36.     else:
    
37.         print('illegal4!')
    
38.         
    

复制代码

我的代码有什么问题

FishC

11063216906 发表于 2026-10-01 19:52
FishC 发表于 2026-9-1 21:23
你的理解有点小误会：g ...

你的代码主要有以下几个问题：

1. string_list = 和 list_temp = 后面都是空的，这是语法错误，必须写成 string_list = list(string) 或直接遍历字符串；list_temp = [] 初始化一个空列表。

2. 缩进混乱：if i == '{' or i == '(' or i == '': 这一行后面缩进多了，导致 elif 和 if 不对齐，Python 会直接报语法错误。

3. 括号种类处理不全：你只处理了 ')'，没有处理 '}' 和 ']'。而且遇到左括号时，你写的是 r = '['，这完全没有意义。正确做法是遇到左括号就把对应的右括号压入栈中。

4. 弹栈前没有检查栈是否为空。如果遇到右括号时栈已经空了，list_temp.pop() 会直接报 IndexError。

5. for...else 的用法有误解。如果循环中 break 了，else 块不会执行。你希望无论是否 break 都检查栈是否为空，但现在的结构做不到。

6. 逻辑不完整：判断合法性的核心是“栈最终为空且中途没有不匹配”。你的代码没有完整实现这个逻辑。

下面是一个正确的写法，供你参考：

1. 
   
2. string = input("输入测试字符串：")
   
3. stack = []
   
4. pairs = {')': '(', ']': '[', '}': '{'}
   
5. 
   
6. for ch in string:
   
7.     if ch in '([{':
   
8.         stack.append(ch)
   
9.     elif ch in ')]}':
   
10.         if not stack or stack[-1] != pairs[ch]:
    
11.             print("illegal")
    
12.             break
    
13.         stack.pop()
    
14. else:
    
15.     if len(stack) == 0:
    
16.         print("legal")
    
17.     else:
    
18.         print("illegal")
    

复制代码

简单说：遇到左括号就压栈，遇到右括号就检查栈顶是否匹配。最后栈空就是合法的。你的代码方向是对的，但细节和语法需要修正。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-1 19:52
你的代码主要有以下几个问题：

1. string_list =  和 list_temp =  后面都是空的，这是语法错误，必 ...

1. string = input("输入测试字符串：")
   
2. string_list = [ ]
   
3. string_list.extend(string)
   
4. list_temp = [ ]
   
5. r = ''
   
6. index = 0
   
7. for i in string_list:
   
8.     print(i)
   
9.     if (i == '{') or (i == '(' )or (i == '['):
   
10.         list_temp.append(string_list.pop(index))
    
11.         print('1')
    
12.         print(list_temp)
    
13.     else:
    
14.         print('else')
    
15.         if len(list_temp) == 0:
    
16.             print("illegal2!")
    
17.             break
    
18.         if i == '}':
    
19.             r = '{'
    
20.         if i == ']':
    
21.             r = '['
    
22.         if i == ')':
    
23.             r = '('
    
24.             print('point3')
    
25. 
    
26.         if list_temp.pop() != r:
    
27.             print(i)
    
28.             print(r)
    
29.             print(test1)
    
30.             print('illegal3!')
    
31.             break
    
32.     index += 1
    
33. 
    
34. 
    
35. print('end')

复制代码

我这个代码为什么输入()作为测试字符串后for循环只执行一次

FishC

11063216906 发表于 2026-10-01 20:14
FishC 发表于 2026-10-1 19:52
你的代码主要有以下几 ...

你的代码有几个关键错误，导致输入 `()` 时 for 循环只执行一次就崩溃了。

首先，`if (i == '{') or (i == '(' )or (i == '':` 这行本身就有语法错误：缺少右括号和引号，应该是 if i == '{' or i == '(' or i == '[':。但即使修正，逻辑也不对。

真正让循环只执行一次的原因是：你遇到左括号时，只是给 `r` 赋值，**没有把对应的右括号压入 `list_temp`**。所以 `list_temp` 一直是空的。当循环到第二个字符 `')'` 时，执行到 if list_temp.pop() != r:，因为 `list_temp` 是空列表，`pop()` 会直接抛出 `IndexError`，程序异常终止。于是 for 循环只跑了第一次（处理 `'('`），第二次刚开始就崩了。

另外，你的 `r` 赋值也反了：遇到 `(` 应该期待 `)`，而不是 `'['`；遇到 `)` 时又去设 `r = '('`，完全混乱。

正确思路是用栈：遇到左括号，把对应的右括号压入栈；遇到右括号，检查栈顶是否匹配，然后弹出。最后栈空才算合法。

给你一个修正示例：

1. 
   
2. string = input("输入测试字符串：")
   
3. stack = []
   
4. pairs = {')': '(', ']': '[', '}': '{'}
   
5. 
   
6. for ch in string:
   
7.     if ch in '([{':
   
8.         stack.append(ch)
   
9.     elif ch in ')]}':
   
10.         if not stack or stack[-1] != pairs[ch]:
    
11.             print("illegal")
    
12.             break
    
13.         stack.pop()
    
14. else:
    
15.     if len(stack) == 0:
    
16.         print("legal")
    
17.     else:
    
18.         print("illegal")
    

复制代码

这样就能正确处理括号匹配了。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-1 20:14
你的代码有几个关键错误，导致输入 `()` 时 for 循环只执行一次就崩溃了。

首先，`if (i == '{') or ...

我这个代码的意思是遇到右括号的时候给r赋值 然后用list_temp的最后一个数据去比较啊

FishC

11063216906 发表于 2026-10-01 20:17
FishC 发表于 2026-10-1 20:14
你的代码有几个关键错 ...

你的思路是对的：遇到右括号时，拿栈顶和它比较。但代码有两个致命问题：

1. 你从来没往 list_temp 里放东西。遇到左括号时你只写了 r = '['，这只是给变量 r 赋值，并没有把左括号存进 list_temp。所以 list_temp 一直是空的。空列表调用 pop() 会直接报 IndexError，程序崩溃。

2. 缩进可能错了。你写的那行 if list_temp.pop() != r: 如果和 if i == ')' 同级，那么每次循环都会执行它，而不是只在遇到右括号时执行。第一次 i 是 '(' 时就会执行 pop，空列表直接崩，所以 for 循环只跑了一次。

正确做法：遇到左括号，把对应的左括号压入 list_temp；遇到右括号，先检查 list_temp 是否为空，再弹出栈顶比较。

给个简单示例：

1. 
   
2. string = input("输入测试字符串：")
   
3. stack = []
   
4. pairs = {')': '(', ']': '[', '}': '{'}
   
5. 
   
6. for ch in string:
   
7.     if ch in '([{':
   
8.         stack.append(ch)
   
9.     elif ch in ')]}':
   
10.         if not stack or stack[-1] != pairs[ch]:
    
11.             print("illegal")
    
12.             break
    
13.         stack.pop()
    
14. else:
    
15.     if len(stack) == 0:
    
16.         print("legal")
    
17.     else:
    
18.         print("illegal")
    

复制代码

你的方向没错，关键是“存进去”和“缩进要正确”。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-1 20:18
你的思路是对的：遇到右括号时，拿栈顶和它比较。但代码有两个致命问题：

1. 你从来没往 list_temp  ...

遇到左括号的时候我不都用if把左括号通过pop弹进list_temp了吗 怎么没东西

FishC

11063216906 发表于 2026-10-01 20:19
FishC 发表于 2026-10-1 20:18
你的思路是对的：遇到 ...

你误会了：`pop()` 是“弹出”，不是“压入”。它是从列表里**拿走最后一个元素并返回**，而不是把东西放进去。往列表里添加元素应该用 `append()`。

你的代码里，遇到左括号时只写了 `r = '['` 或者 `r = '('`，这只是在给变量 `r` 赋值，**根本没有把任何东西放进 `list_temp`**。所以 `list_temp` 一直是空的。空列表调用 `pop()` 会直接报 `IndexError`，程序崩溃，for 循环自然只跑了一次。

另外，你那行 `if list_temp.pop() != r:` 很可能缩进错了，导致每次循环都执行它。第一次遇到 `'('` 时就执行 `pop()`，空列表直接崩。

正确做法是：
- 遇到左括号，把**对应的右括号**用 `append()` 压入栈。
- 遇到右括号，先检查栈是否为空，然后用 `pop()` 弹出栈顶比较。

例如：

1. string = input("输入测试字符串：")
   
2. stack = []
   
3. pairs = {')': '(', ']': '[', '}': '{'}
   
4. 
   
5. for ch in string:
   
6.     if ch in '([{':
   
7.         stack.append(ch)          # 压入左括号
   
8.     elif ch in ')]}':
   
9.         if not stack or stack[-1] != pairs[ch]:
   
10.             print("illegal")
    
11.             break
    
12.         stack.pop()               # 弹出左括号
    
13. else:
    
14.     if len(stack) == 0:
    
15.         print("legal")
    
16.     else:
    
17.         print("illegal")

复制代码

简单记：`append` 是放进，`pop` 是取出。你之前没放，所以取的时候是空的。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-6-20 19:35
你提到的“存放 11，然后后边跟着 100 个比特位，都存放 0”，这其实是用定点数（或缩放整数）来存储大 ...

在python中 for循环后悬挂else的作用

FishC

11063216906 发表于 2026-10-05 16:43
FishC 发表于 2026-6-20 19:35
你提到的“存放 11， ...

在 Python 中，for 循环后面可以跟一个 else 子句，它的作用是：

当 for 循环**正常结束**（也就是遍历完了所有元素，没有中途遇到 break）时，就会执行 else 块。如果循环中因为 break 提前跳出了，那么 else 块**不会执行**。

简单记：else 是“没被打断就执行”。

典型用法是“查找”场景：遍历一个序列，如果找到了就 break，没找到就执行 else 来提示。

例如：

1. 
   
2. for i in range(5):
   
3.     if i == 10:
   
4.         print("找到了")
   
5.         break
   
6. else:
   
7.     print("没找到")
   

复制代码

因为循环正常走完，没有 break，所以会输出“没找到”。

如果改成 i == 3，那么当 i 等于 3 时会 break，else 就不会执行。

注意：else 也可以和 while 搭配，规则一样。它和 if-else 里的 else 含义不同，这里表示“循环完整结束”。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-5 16:43
在 Python 中，for 循环后面可以跟一个 else 子句，它的作用是：

当 for 循环**正常结束**（也就是 ...

家不妨可以将摩尔投票法的工作原理想象为诸侯争霸，假设每个国家都是全民皆兵，并且打起仗来都是以 1 换 1 的形式消耗人口，当一个国家人口总数为 0，那么 Gameover，OK，如果某国人口数量超过所有国家总人口的一半，最终赢家就肯定是它。
给我解释一下为什么，如果某国人口数量超过所有国家总人口的一半，最终赢家就肯定是它。

FishC

11063216906 发表于 2026-10-05 20:23
FishC 发表于 2026-10-5 16:43
在 Python 中，for 循 ...

摩尔投票法的“诸侯争霸”比喻中，每个国家代表一个数字，人口数就是该数字出现的次数。打仗规则是：任意两个不同国家的人相遇，就同归于尽（1换1）。

为什么某国人口超过总人口一半，最终赢家就一定是它？

假设总人口为 N，某国人口为 M，且 M > N/2。
那么其他所有国家人口总和就是 N - M，而因为 M > N/2，所以 N - M < N/2，也就是说其他国家总人口还不到一半，比 M 少。

现在想象最坏情况：其他所有国家联合起来，专门针对这个大国，每次都用一个小国的人去和大国的人同归于尽。
每消耗掉大国 1 个人，就要牺牲其他国家 1 个人。
因为其他国家总人数比大国少，所以当其他国家的人全部拼光时，大国必然还有剩余。
剩余人数 = M - (N - M) = 2M - N。
由于 M > N/2，所以 2M - N > 0，大国至少还剩 1 个人。

所以无论怎么打，只要某国人口超过一半，其他国家加起来都不够消灭它，最后站着的只能是它。这就是摩尔投票法能找到多数元素的根本原因。

简单记：超过一半，意味着其他所有加起来都不够抵消它，它必定是最后的幸存者。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-5 16:43
在 Python 中，for 循环后面可以跟一个 else 子句，它的作用是：

当 for 循环**正常结束**（也就是 ...

每次你试图创建一个 -5~256 范围内的整数时，Python 都会从这个数组中返回相对应的引用，而不是重新开辟一块新的内存空间存放。
那为什么 a = 3 b = 5
a is b是false 不是在数组里返回吗 那数组的内存空间是一样的啊

FishC

11063216906 发表于 2026-10-05 20:44
FishC 发表于 2026-10-5 16:43
在 Python 中，for 循 ...

小整数缓存的意思是：Python 会预先为 **-5 到 256 之间的每一个整数** 创建一个固定的对象。注意是“每一个整数”，不是“所有整数共享一个对象”。

所以：

- `a = 3` 时，Python 从缓存中取出“值为 3”的那个对象，让 `a` 指向它。
- `b = 5` 时，Python 从缓存中取出“值为 5”的那个对象，让 `b` 指向它。

3 和 5 是两个不同的整数，缓存里对应的是两个不同的对象，所以 `a is b` 当然是 `False`。

如果改成：


a = 3
b = 3
print(a is b)   # True


这时 `a` 和 `b` 都指向缓存中同一个“值为 3”的对象，所以 `is` 比较结果为 `True`。

简单记：小整数缓存保证的是“相同数值返回同一个对象”，而不是“所有小整数都是同一个对象”。不同数值自然对应不同的缓存对象。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-5 20:44
小整数缓存的意思是：Python 会预先为 **-5 到 256 之间的每一个整数** 创建一个固定的对象。注意是“ ...

s = [1]
s.append(s)为啥不报错 s是列表不可迭代啊

FishC

11063216906 发表于 2026-10-05 21:39
FishC 发表于 2026-10-5 20:44
小整数缓存的意思是： ...

不是“列表不可迭代”，列表是可迭代的。你误会了 `append` 的行为。

`append` 的参数可以是任意对象，它**不会去迭代**这个对象，只是把这个对象的引用放进列表末尾。

例如：

1. 
   
2. s = []
   
3. s.append(s)
   

复制代码

执行后，`s` 里就多了一个元素，而这个元素就是 `s` 自己。现在 `s` 变成了一个“自己包含自己”的循环列表。

因为 `append` 根本不需要遍历参数，所以不会报错。你可以理解为：

1. 
   
2. s = []
   
3. # s 是一个空列表对象
   
4. s.append(s)  # 把 s 这个对象本身的引用追加到 s 中
   

复制代码

此时：

1. 
   
2. print(s)        # 输出 [...]
   
3. print(s[0])     # 输出 [...]
   
4. print(s[0][0])  # 还是 [...]
   

复制代码

`[...]` 是 Python 发现循环引用后，为了避免无限打印而显示的省略形式。

所以结论是：
- 列表是可迭代的。
- `append` 不迭代参数，只把引用放进去。
- `s.append(s)` 合法，只是会创建自引用，平时不要这样写，容易造成递归打印或内存回收困难。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-5 21:39
不是“列表不可迭代”，列表是可迭代的。你误会了 `append` 的行为。

`append` 的参数可以是任意对 ...

那为啥
a = [0]
b = [0]
a.append(b)报错

FishC

11063216906 发表于 2026-10-05 21:41
FishC 发表于 2026-10-5 21:39
不是“列表不可迭代” ...

`a.append(b)` 不会报错。它和 `s.append(s)` 一样，都是合法的。

`append` 只做一件事：把参数这个对象本身，作为一个元素追加到列表末尾。它不会去遍历、迭代参数，也不会检查参数是不是可迭代对象。

所以：


a =
b =
a.append(b)
print(a)   # 输出


此时 `a` 里只有一个元素，这个元素就是列表 `b` 本身。

如果你运行 `a = []; b = []; a.append(b)` 真的报错了，那报错一定不是 `append` 本身引起的，常见原因有：

- `b` 没有定义，比如你写成了 `a.append(b)` 但前面没有 `b = []`。
- 你实际写的是 `a.extend(b)` 之类，但 `b` 不是可迭代对象。
- 你在 `append` 后面多写了东西，比如 `a.append(b, c)`，但 `append` 只接受一个参数。
- 你复制代码时少了括号或逗号，导致语法错误。

`append` 的参数可以是任何对象：整数、字符串、列表、字典、甚至另一个列表的引用。它来者不拒，只负责“放到末尾”。

所以 `a.append(b)` 本身绝对不报错。如果报错，请把完整代码和错误信息发出来，我帮你具体看。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

11063216906

FishC 发表于 2026-10-5 21:41
`a.append(b)` 不会报错。它和 `s.append(s)` 一样，都是合法的。

`append` 只做一件事：把参数这个 ...

我如何理解三维列表

FishC

11063216906 发表于 2026-10-05 21:57
FishC 发表于 2026-10-5 21:41
`a.append(b)` 不会报 ...

三维列表可以理解成“列表里套列表，再套一层列表”。最直观的比喻是：把二维列表看作一张表格，三维列表就是多张同样大小的表格叠在一起。

例如，一栋楼有 3 层，每层有 2 行，每行有 4 个房间，就可以用三维列表表示：

1. 
   
2. building = [
   
3.     [ [101, 102, 103, 104], [105, 106, 107, 108] ],   # 第1层
   
4.     [ [201, 202, 203, 204], [205, 206, 207, 208] ],   # 第2层
   
5.     [ [301, 302, 303, 304], [305, 306, 307, 308] ]    # 第3层
   
6. ]
   

复制代码

访问时用三个下标：building[层][行][列]。比如 building[1][0][2] 得到的是第2层、第1行、第3个房间，即 203。

注意：三维列表的每一层、每一行、每一个元素都只是引用。如果创建时写成：

1. 
   
2. a = [[[0] * 4] * 2] * 3
   

复制代码

那么所有层、所有行其实都指向同一个列表，改一个地方会全部跟着变。正确创建方式是使用嵌套列表推导式：

1. 
   
2. a = [[[0 for _ in range(4)] for _ in range(2)] for _ in range(3)]
   

复制代码

这样每个内层列表都是独立对象，修改互不影响。

总结：三维列表就是“层、行、列”的嵌套结构，索引时从外到内逐层深入即可。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。