如： 字符串 a="1,2,3";

怎样判断a 中的逗号 有几个 

len(a)-len(replace(a,",",""))
转载于:https://www.cnblogs.com/lauplay/p/3152128.html

如何判断字符串是否是整数
题目描述
写一个方法，检查字符串是否是整数，如果是整数，那么返回其整数值。
分析与解答:
整数分为负数与非负数，负数只有一种表示方法，而非负数可以有两种表示方法。例如:-123，123 ，+ 123。因此在判断字符串是否为整数的时候，需要把这几个问题都考虑到。
非递归法
首先通过第一个字符的值确定整数的正负性，然后去掉符号位，把后面的字符串当做正数 来处理，处理完成后再根据正负性返回正确的结果。实现方法为从左到右遍历字符串计算整数 的值，以“ 123”为例，遍历到’ 1’的时候结果为 1，遍历到 2的时候结果为 110+2=12，遍 历到’3’的时候结果为 1210+3=123。其本质思路与方法一类似，根据这个思路实现代码如下:
class test:
    def __init__(self):
        self.flag=None
    def getFlag(self):
        return self.flag
    def isnumber(self,c):
        return c>='0'and c<='9'
    def str2int(self,strs):
        if strs==None:
            self.flag=False
            print('不是数字')
            return -1
        self.flag=True
        res=0
        i=0
        minus=False
        if list(strs)[i]=='-':
            minus=True
            i+=1
        if list(strs)[i]=='+':
            i+=1
        while i<len(strs):
            if self.isnumber(list(strs)[i]):
                res=res*10+ord(list(strs)[i])-ord('0')
            else:
                self.flag=False
                print('不是数字')
                return -1
            i+=1
        return -res if minus else res
if __name__=='__main__':
    t=test()
    s='-543'
    print(t.str2int(s))

输出：

-543

最近做的东西有这么一个需要：判断一个字符串中是否含有日文字符。最直观的想法就是使用正则表达式，因此上网一搜，找到了这个 utf-8 对应的日文字符列表：http://ash.jp/code/unitbl21.htm 。满心欢喜，按照列表，用utf-16指定的区间，再用正则表达式方式写了一个判断方法。

测试了几个单词，正确。不过测试了几个汉字，发现不对。

仔细看了看那个表，发现 字母和假名部分，utf-16是连续的，但是汉字和特殊字符部分，就不是连续的了。这就是用正则表达式也得累死人！

再看看那个表，SJIS 编码的code是连续的，恩，可以使用区间，所以字符串得转换一下：

str = new String(str.getBytes(), "UTF-8");
byte[] bt = str.getBytes("SHIFT-JIS");


不过那个表也真大阿！！就算用 shift-jis编码，正则表达式也不短！

在输出 byte[] 的时候，发现如果是中文的话，那么 byte[] 的长度会小于4，而且不会被2 整除。于是乎，方法来了：

return bt.length %2 == 0;


这个方法可以判断一个字符是否为日文字符，那么判断字符串中是否包含日文字符也不难了。

以下是测试类：


assertTrue(CharacterUtil.isContainJapaneseCharacter("亜亜"));

assertTrue(CharacterUtil.isContainJapaneseCharacter("お早う"));
assertTrue(CharacterUtil.isContainJapaneseCharacter("学校"));
assertTrue(CharacterUtil.isContainJapaneseCharacter("お早う,tom!"));
assertFalse(CharacterUtil.isContainJapaneseCharacter("严"));
assertFalse(CharacterUtil.isContainJapaneseCharacter("tom"));

try {
  InputStream is = getClass().getClassLoader().getResourceAsStream("util/CharacterTest.utf_8");
  LineNumberReader ln = new LineNumberReader(new InputStreamReader(is, "UTF-8"));
  // 汉字 足
  assertTrue(CharacterUtil.isContainJapaneseCharacter(ln.readLine()));
  //　あし　足
  assertTrue(CharacterUtil.isContainJapaneseCharacter(ln.readLine()));
} catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
}


其中比较特殊的是 “足”之类的文字，在 UNICODE 列表中，中日韩有几部分是公用一些汉字的。（CharacterTest.utf_8 是一个 utf-8 编码的文本文件，里面分别用汉字和日文写了“足”这个字 ）。

题目描述：写一个方法，检查字符串是否为整数，那么返回整数值。

分析与解答： 整数分为负数和非负数，负数只有一种表示方法，而非负数可以有两种表示方法。例如111，-111，+111，因此在判断字符串是否为整数的时候，需要把这几个问题都考虑到。下面说两个方法，

方法一：递归法：对于整数而言，例如111,可以看成11*10+1，而11又可以看成1*10+1。而-111可以看成（-11)*10-1，-11可以看成（-1）*10-1.根据这个特点可以采用递归的方法求解，可以先根据字符串的第一个字符确定整数的正负，接着对字符串从右向左遍历.

class Test:
    def __init__(self):
        self.flag = None

    def getFlag(self):
        return self.flag

    # 判断c是否是数字，如果是返回数字，且设置flag=True,否则返回False
    def isNumber(self, c):
        return c >= '0' and c <= '9'

    # 判断str是否是数字
    def strtoint(self, strs, length):
        if length > 1:
            if not self.isNumber(list(strs)[length - 1]):
                # 不是数字
                print("不是数字")
                self.flag = False
                return -1

            if list(strs)[0] == '-':
                return self.strtoint(strs, length - 1) * 10 - (ord(list[length - 1]) - ord('0'))
            else:
                return self.strtoint(strs, length - 1) * 10 + ord(list(strs)[length - 1]) - ord('0')

        else:
            if list(strs)[0] == '-':
                return 0
            else:
                if not self.isNumber(list(strs)[0]):
                    print("不是数字")
                    self.flag = False
                    return -1
                return ord(list(strs)[0]) - ord('0')

    def strToint(self, s):
        self.flag = True
        if s == None or len(s) <= 0 or (list(s)[0] == '-' and len(s) == 1):
            print("不是数字")
            self.flag = False
            return -1

        if list(s)[0] == '+':
            return self.strToint(s[1:len(s)], len(s) - 1)
        else:
            return self.strToint(s, len(s))

方法二：非递归法

首先通过一个字符的值确定整数的正负性，然后去掉符号位，把后面的字符串当做正数来处理，处理完成后再根据正负性返回正确的结果。实现方法为从左向右遍历字符串计算整数的值，以“123”为例，遍历到'2'的时候结果为1*10+2=12，遍历到‘3’的时候结果为12*10+3=123。

class Test:
    def __init__(self):
        self.flag = None

    def getFlag(self):
        return self.flag

    # 判断c是否是数字，如果是返回True,否则返回False
    def isNumber(self, c):
        return c >= "0" and c <= "9"

    def strToint(self, strs):
        if strs == None:
            self.flag = False
            print("不是数字")
            return -1
        self.flag = True

        res = 0
        i = 0
        minus = False  # 是否是负数

        if list(strs)[i] == '-':  # 结果是负数
            minus = True
            i += 1

        if list(strs)[i] == '+':  # 结果是正数
            i += 1
        while i < len(strs):
            if self.isNumber(list(strs)[i]):
                res = res * 10 + ord(list(strs)[i]) - ord('0')
            else:
                self.flag = False
                print("不是数字")
                return -1 
            i += 1
        return -res if minus else res


if __name__ == "__main__":
    t = Test()
    s = "-543"
    print(t.strToint(s))
    s = "543"
    print(t.strToint(s))
    s = "+543"
    print(t.strToint(s))
    s = "++43"
    result = t.strToint(s)
    if t.getFlag():
        print(result)