这里很怪，没有运行键，我用main方法时又能运行

padding模式的补零，到底补的是黑色还是白色

import re

pattern = r"\\\n\d{3,}"
s=r"\\\n123"
print(s)
v=re.match(pattern,s)
print(v)

老师，这里如果s也用r标识原始字符串，则返回None，这里怎么理解？

import java.util.Arrays;

//自定义一个简单的包装类
public class MyInteger {
    private final int value; //MyInteger类的私有属性value
    private static MyInteger[] cache;//缓存【-128,127】之间的数值
    private static final int LOW = -128;
    private static final int HIGH = 127;

    @Override
    public String toString() {
        return  value + "";
    }

    static{
        cache = new MyInteger[HIGH-LOW+1];
        for (int i=LOW;i<=HIGH;i++){
             cache[i-LOW] = new MyInteger(i);
        }
        System.out.println(Arrays.toString(cache));
    }

    public MyInteger(int value) {  //MyInteger类的带参构造器
        this.value = value;
    }
    public static MyInteger valueOf(int value){ //MyInteger方法
        if (value>=LOW&&value<=HIGH){
            return cache[value-LOW];
        }
        return new MyInteger(value);
    }

    public int intValue(){
        return value;
    }

    public static void main(String[] args){
//        MyInteger m = new MyInteger(101);//main方法里创建MyInteger对象
//        MyInteger m1 = MyInteger.valueOf(10101);//官方推荐的创建方法
//        int m2 = m1.intValue();
        MyInteger x = MyInteger.valueOf(100);
        MyInteger x1 = MyInteger.valueOf(100);
        MyInteger x2 = MyInteger.valueOf(1000);
        MyInteger x3 = MyInteger.valueOf(1000);
        System.out.println(x==x1);
        System.out.println(x2==x3);
        System.out.println(x.equals(x1));
        System.out.println(x2.equals(x3));

    }
}

最后x2.equals（x3）结果为什么会是false

字母，数字做了编码处理，在浏览器中显示的内容就是原内容；而中文做了编码处理，在浏览器中显示的内容才会改变？

def remove(self,value):
    prev = self.root
    for n in self.__iter__():
        if n.value == value:
            if not n.next:
                self.next = prev
                # 这里不能直接break,因为self.size没有减1
            else:
                prev.next = n.next
            self.size-=1
        prev = n

老师，请问如果我这样写，就是把删除的节点脱离了链，那请问被删除的节点会被垃圾回收吗

老师，这里创建的这几个文件的关系是什么，能不能做个图说明下，他们之间的执行顺序有点搞不清

老师，请问，浏览器发出的请求中是用什么方式编码字符的？也是utf-8吗？

#coding=utf-8
from collections.abc import Iterator
class Ite:
    def __iter__(self):
        self.num = 0
        return self  #返回自身
    def __next__(self):
        if self.num<3:
            self.num += 1
            return self.num
        else:
            raise StopIteration
myclass = Ite() #实例化对象为可迭代对象，因为类中既有iter方法，又有next方法
print(isinstance(myclass,Iterator)) #True
myiter = iter(myclass)
print(isinstance(myiter,Iterator))#True
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))  #报错

老师，第14行判断myclass为迭代器，后面为何又要加一个iter函数来让它变成迭代器，不是可迭代对象才需要加iter方法么？

self.__item = [None]*size，老师说是分配空间，没太看懂

import os

import os.path

def my_print_file(path,level):

        child_files=os.listdir(path) #os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表

        for file in child_files:#遍历child_files

             file_path=os.path.join(path,file)#s.path.join()函数：连接两个或更多的路径名组件

              print("\t"*level+file_path)

              if os.path.isdir(file_path): #判断file_path是否为目录

                    my_print_file(file_path,level+1)

my_print_file("module",0)

import os
import os.path

def my_print_file(path,level):
child_files=os.listdir(path) #os.listdir() 方法用于返回指定的文件夹包含的文件或文件夹的名字的列表
for file in child_files:#遍历child_files
file_path=os.path.join(path,file)#s.path.join()函数：连接两个或更多的路径名组件
print("\t"*level+file_path)
if os.path.isdir(file_path): #判断file_path是否为目录
my_print_file(file_path,level+1)

my_print_file("module",0)

为什么这样回报错

少壮不努力，长大干快递。

少壮不努力，毕业进工地。

少壮不努力，一生在内地。

少壮不努力，老了徒伤悲。

#encoding=utf-8
import salary
print(salary.__doc__)
print(salary.yearsalary.__doc__)

结果

D:\python_exe\python.exe "D:/Python代码/第三阶段学习/我们可以通过 __doc__ 可以获得模块的文档字符串的内容..py"

Traceback (most recent call last):

  File "D:\Python代码\第三阶段学习\我们可以通过 __doc__ 可以获得模块的文档字符串的内容..py", line 2, in <module>

    import salary

ModuleNotFoundError: No module named 'salary'

Process finished with exit code 1

这里的 操作数 指的是