Leet Code_python 9.回文数

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        a = 0
        x_str = str(x)
        #直接str()就转了
        x_array = list(x_str)
        '''
               在 Python 中将字符串转换为数组
               string = 'www,jiyik,com'
               # ✅ 将逗号分隔的字符串转换为数组
               array = string.split(',')
               print(array)  # -> ['www', 'jiyik', 'com']


               # ---------------------------------------------


               # ✅ 将空格分隔的字符串转换为数组
               string = 'www jiyik com'
               array = string.split(' ')
               print(array)  # -> ['www', 'jiyik', 'com']


               # ---------------------------------------------


               # ✅ 将字符串转换为字符数组


               string = 'jiyik'
               array = list(string)
               print(array)  # -> ['j', 'i', 'y', 'i', 'k']


               # ---------------------------------------------


               # ✅ 将字符串转换为整数数组


               string = '1,2,3'
               array = list(int(char) for char in string.split(','))
               print(array)  # -> [1, 2, 3]


               # ---------------------------------------------


               # ✅ 将字符串转换为单元素数组
               string = 'jiyikcom'


               array = [string]
               print(array) # -> ['jiyikcom']

         '''
        x_arry_inverted = x_array[::-1]
        '''
        数组排序：
        arr = [1, 9, 5, 73, 1, 4, 56, 2, 6, 10]
        # 数组倒序
        print(arr[::-1])
        # 输出：[10, 6, 2, 56, 4, 1, 73, 5, 9, 1]
         
        # 数组排序
        print(sorted(arr))
        # 输出：[1, 1, 2, 4, 5, 6, 9, 10, 56, 73]
         
         
        # 取前3位元素
        print(arr[:3])
        # 输出：[1, 9, 5]
         
        # 取除了后3位的元素
        print(arr[:-3])
        # 输出：[1, 9, 5, 73, 1, 4, 56]
         
        # 取后3位的元素
        print(arr[-3:])
        # 输出：[2, 6, 10]
         
        # 取除了前3位的元素
        print(arr[3:])
        # 输出：[73, 1, 4, 56, 2, 6, 10]
         
        # 排序后、倒序、取前3位元素（取最大的3位元素）
        print(sorted(arr)[::-1][:3])
        # 输出：[73, 56, 10]
        '''
        for i in range(len(x_array)):#加冒号！！！！
             #for、if语句后得加英文冒号，否则报错：synataxError:invalid syntax
             #当缩进出现问题时，报错：IndentationError：unexpected indent
             #在使用函数时，eg：range()用小括号。用数组啥的时候则用中括号[]
            if x_array[i] ==  x_arry_inverted[i]: #加冒号！！！！
                a+=1
                #python中没有自加a++，python中++a是指两次正号，最后得到一个不变量a，--a就是变两次号，最后还是a。
                #无论c语言还是python，其中的变量都对应一个地址
                #但，值得注意的是，python中当变量改变的时候，他是另外申请了个地址，再存放改变后的变量到新的内存地址。
                #而，c语言是，变量改变后，我地址是不变的，直接变地址内的数。
                #也因此python没有自加这一说，所以自加就用a += a就好了


        if a == len(x_array):#加冒号！！！！
            return True
            #return的必须是去确定的已经设置好的全局变量True和False，不能改成小写，容易出bug，在python的文件转为json时，True和False就会变成true和false。
            #注意是True 不是Truth
        else:#加冒号！！！！
            return False
            
Solution().isPalindrome(x=121)

Solution().isPalindrome(x=121)
//调用这个类中的方法，并直接输入。格式：类名().方法名(input)
//值得注意的是 在pytorch中构建模型时使用的类由于forword不需要再额外说明，所以一般就写成model(x)即可，即类名()。
引申-python中类的讲解：
一.分类有：
1.实例方法：
2.类方法：
3.静态方法：
class Book:
TYPES = (“hardcover”, “paperback”) # 精装，平装 #定义的一个初始的属性，这个属性下面所有方法都可以用

def __init__(self, name, book_type, weight):#对self做初始定义的。 self本身呢相当于类当中必须必须定义的一个属性，由于类中包含了众多的方法，但是众多方法大概率都需要相同的那些属性，所以这里同一的去定义一下
                                                                        #这里也不是一定就得定义，如果不定义就需要再你方法里再额外说么
    self.name = name
    self.book_type = book_type
    self.weight = weight

def __repr__(self):#1.实例方法：格式：方法名（self，x，y，...）#注意必须有self，是在self的基础上去写的这个方法，即使你不用self里的属性，你想定义成这个实例方法，你也得写
        #另外，你还可以针对于这个方法额外加入输入x，y，。。。。这个输入就只是这个确切的方法的输入了。
    return f"<Book {self.name}, {self.book_type}, weighing {self.weight}g>"

def instance_method(self):#1.实例方法：
    print(f"Called instance method of {self}")

@classmethod#2.类方法：
def class_method(cls):
    print(f"called class method of {cls}")

@classmethod#2.类方法：
def hardcover(cls, name, paper_weight):  # cls 名称任意，使用 cls 是 convention
    # 下一行的cls，改成 Book，代码也能跑，但应该写成 cls, 以避免在 inheritance 可能会遇到的问题
    return cls(name, cls.TYPES[0], paper_weight + 100)  #

@classmethod#2.类方法：#具体啥区别，我也没太搞清楚，反正定义的时候不用写self
def paperback(cls, name, paper_weight):
    # 下一行的cls，改成 Book，代码也能跑，但应该写成 cls, 以避免在 inheritance 可能会遇到的问题
    return cls(name, cls.TYPES[1], paper_weight)

@staticmethod#3.静态方法：#这个静态方法，就是当我用不到这个self的属性的时候，我把这类方法单独区分出来，当作静态方法。
def static_method():
    print("Called static method")

————————————————
原文链接：https://blog.csdn.net/ftell/article/details/125664788

二.类的调用：
1.正常调用：类名().方法名()
#类名()括号内需要输入，init初始化需要的参数。，如果init 你没有设置需要的参数，你括号()里可以不写,如果定义了，那就需要你输入一下。
比如：

class Solution(object):
    def __init__(self, c1, c2, p=None):
        self.c1 = c1
        self.c2 = c2
        self.p = c1 + c2
    def isPalindrome(self, x):
        a = 0
        x_str = str(x)
        x_array = list(x_str)
        x_arry_inverted = x_array[::-1]
        for i in range(len(x_array)):#加冒号！！！！
            if x_array[i] ==  x_arry_inverted[i]:
                a+=1
        if a == len(x_array):#加冒号！！！！
            return True
        else:#加冒号！！！！
            return False
Solution().isPalindrome(x=121)

报错：TypeError: init() missing 2 required positional arguments: ‘c1’ and ‘c2’

2.pytorch中模型类的调用
需要注意的是pytorch中是不同的
pytorch中继承的父类是nn.Module
在pytorch中调用的时候不需要在额外写forward的方法名。
！！步骤：只需要在init中先设置好需要确定的调用类的属性，然后在forward中直接调用即可
比如：

class Conv(nn.Module):
    # Standard convolution
    """在Focus、Bottleneck、BottleneckCSP、C3、SPP、DWConv、TransformerBloc等模块中调用
    Standard convolution  conv+BN+act
    :params c1: 输入的channel值
    :params c2: 输出的channel值
    :params k: 卷积的kernel_size
    :params s: 卷积的stride
    :params p: 卷积的padding  一般是None  可以通过autopad自行计算需要pad的padding数
    :params g: 卷积的groups数  =1就是普通的卷积  >1就是深度可分离卷积
    :params act: 激活函数类型   True就是SiLU()/Swish   False就是不使用激活函数
                 类型是nn.Module就使用传进来的激活函数类型
    """
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super(Conv, self).__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
//设置好属性！！！！

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))
//直接调用！！！

    def fuseforward(self, x):
        return self.act(self.conv(x))