精华内容
下载资源
问答
  • 在写代码过程中,我们经常会遇到这样一个需求:判断字符串是否包含某个关键词,也就是特定子字符串。比如从一堆书籍名称中找出含有“python”书名。判断两个字符串相等很简单,直接==就可以了。其实判断包含...

    c2548a809a274ab524c1805cd6e86857.png


    在写代码的过程中,我们经常会遇到这样一个需求:判断字符串中是否包含某个关键词,也就是特定的子字符串。比如从一堆书籍名称中找出含有“python”的书名。判断两个字符串相等很简单,直接 == 就可以了。其实判断包含子串也非常容易,而且还不止一种方法。下面我们就给大家分享 7 种可以达到此效果的方法:

    1、使用 in 和 not in

    innot in在 Python 中是很常用的关键字,我们将它们归类为成员运算符

    使用这两个成员运算符,可以很让我们很直观清晰的判断一个对象是否在另一个对象中,示例如下:

    >>> "llo" in "hello, python"
    True
    >>>
    >>> "lol" in "hello, python"
    False

    2、使用 find 方法

    使用 字符串 对象的 find 方法,如果有找到子串,就可以返回指定子串在字符串中的出现位置,如果没有找到,就返回-1

    >>> "hello, python".find("llo") != -1
    True
    >>> "hello, python".find("lol") != -1
    False
    >>

    3、使用 index 方法

    字符串对象有一个 index 方法,可以返回指定子串在该字符串中第一次出现的索引,如果没有找到会抛出异常,因此使用时需要注意捕获。

    def is_in(full_str, sub_str):
        try:
            full_str.index(sub_str)
            return True
        except ValueError:
            return False

    print(is_in("hello, python""llo"))  # True
    print(is_in("hello, python""lol"))  # False

    4、使用 count 方法

    利用和 index 这种曲线救国的思路,同样我们可以使用 count 的方法来判断。

    只要判断结果大于 0 就说明子串存在于字符串中。

    def is_in(full_str, sub_str):
        return full_str.count(sub_str) > 0

    print(is_in("hello, python""llo"))  # True
    print(is_in("hello, python""lol"))  # False

    5、通过魔法方法

    在第一种方法中,我们使用 in 和 not in 判断一个子串是否存在于另一个字符中,实际上当你使用 in 和 not in 时,Python 解释器会先去检查该对象是否有__contains__魔法方法。

    若有就执行它,若没有,Python 就自动会迭代整个序列,只要找到了需要的一项就返回 True 。

    示例如下;

    >>> "hello, python".__contains__("llo")
    True
    >>>
    >>> "hello, python".__contains__("lol")
    False
    >>>

    这个用法与使用 in 和 not in 没有区别,但不排除有人会特意写成这样来增加代码的理解难度。

    6、借助 operator

    operator模块是python中内置的操作符函数接口,它定义了一些算术和比较内置操作的函数。operator模块是用c实现的,所以执行速度比 python 代码快。

    在 operator 中有一个方法contains可以很方便地判断子串是否在字符串中。

    >>> import operator
    >>>
    >>> operator.contains("hello, python""llo")
    True
    >>> operator.contains("hello, python""lol")
    False
    >>> 

    7、使用正则匹配

    说到查找功能,那正则绝对可以说是专业的工具,多复杂的查找规则,都能满足你。

    对于判断字符串是否存在于另一个字符串中的这个需求,使用正则简直就是大材小用。

    import re

    def is_in(full_str, sub_str):
        if re.findall(sub_str, full_str):
            return True
        else:
            return False

    print(is_in("hello, python""llo"))  # True
    print(is_in("hello, python""lol"))  # False

    你平常会用哪种方法呢?或者你还有其他写法?欢迎在留言中给出。

    作者:写代码的明哥

    来源:Python编程时光


    _往期文章推荐_

    超详细Python字符串用法大全
    094ab94ffc7a0f764646f6dcf7bf584d.png
    展开全文
  • 判断字符串b是否是a非连续子串,例如2018字符串是否是233330321333338非连续子串
  • 题目来自BMY BBS算法版...从第一个字符开始,逐个扫描,对每一个字符,查找下一个相同字符,判断这两个字符之间的字符串是否回文。时间复杂度O(n^3),所以说是笨笨解,师弟说可以做到O(n^2)... 算法实现 /*======

    转自:http://www.cnblogs.com/mingzi/archive/2009/08/04/1538418.html

    题目来自BMY BBS算法版,原题如下:

    不仅能判断规则的中心对称,如123454321,还要能判断如123456547890中的45654的不规则部分中心对称

    算法思想

    从第一个字符开始,逐个扫描,对每一个字符,查找下一个相同字符,判断这两个字符之间的字符串是否回文。时间复杂度O(n^3),所以说是笨笨解,师弟说可以做到O(n^2)...

    算法实现

    /*================================================================================

    功能:判断字符串是否是回文字符串或者是否含有回文字符子串

    作者:sunnyrain

    日期:2008-09-11

    编译环境:VC++6.0

    ==================================================================

    #include<iostream>
    using namespace std;
    int find(char ch,char *str,size_t length) //查找str开始的字符串中第一个ch出现的位置,没找到返回-1
    {
            for(int i=0;i<length;i++)
            {
                    if(ch == str[i])
                            return i;
            }
            return -1;
    }
    
    int isSym(char *str,size_t length)  //判断一个字符串是否全对称,0对称,-1不对称
    {
            for(int i=0;i<length/2;i++)
            {
                    if(str[i] != str[length-i-1])
                            return -1;
            }
            return 0;
    }
    
    int isSymmetry(char *str,size_t length)//返回原字符串长度表示全部对称,-1表示无对称,其他值表示局部对称起始位置
    {
          if (isSym(str, lenght) == 0)
          {
                return length;
          }
    
            int begin=0,end;
            char ch;
            for(int i=0;i<length;i++)
            {
                    ch = str[i];
                    begin = end = i;
                    while((begin = find(ch,str+end+1,length-end-1)) != -1)
                    {
                            end = begin+end+1;
                            if(isSym(str+i,end-i+1) == 0)
                                    return i;
                    }
            }
            return -1;
    }
    
    int main()
    {
            char aa1[] = "123454321";
            char aa2[] = "123456547890";
            char aa3[] = "781234327891";
            char aa4[] = "954612313217891";
    
            cout<<isSymmetry(aa1,sizeof(aa1)/sizeof(char)-1)<<endl;
            cout<<isSymmetry(aa2,sizeof(aa2)/sizeof(char)-1)<<endl;
            cout<<isSymmetry(aa3,sizeof(aa3)/sizeof(char)-1)<<endl;
            cout<<isSymmetry(aa4,sizeof(aa4)/sizeof(char)-1)<<endl;
            return 0;
    


    测试结果:

    ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

    9

    3

    3

    4

    ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

    展开全文
  • 1. 使用 in 和 not inin 和 not in 在 Python ... 使用 find 方法使用 字符串 对象 find 方法,如果有找到子串,就可以返回指定子串字符串出现位置,如果没有找到,就返回 -13. 使用 index 方法字符串对象有...

    1. 使用 in 和 not in

    in 和 not in 在 Python 中是很常用的关键字,我们将它们归类为 成员运算符。

    使用这两个成员运算符,可以很让我们很直观清晰的判断一个对象是否在另一个对象中,示例如下:

    2. 使用 find 方法

    使用 字符串 对象的 find 方法,如果有找到子串,就可以返回指定子串在字符串中的出现位置,如果没有找到,就返回 -1

    3. 使用 index 方法

    字符串对象有一个 index 方法,可以返回指定子串在该字符串中第一次出现的索引,如果没有找到会抛出异常,因此使用时需要注意捕获。

    4. 使用 count 方法

    利用和 index 这种曲线救国的思路,同样我们可以使用 count 的方法来判断。

    只要判断结果大于 0 就说明子串存在于字符串中。

    5. 通过魔法方法

    在第一种方法中,我们使用 in 和 not in 判断一个子串是否存在于另一个字符中,实际上当你使用 in 和 not in 时,Python 解释器会先去检查该对象是否有 __contains__ 魔法方法。

    若有就执行它,若没有,Python 就自动会迭代整个序列,只要找到了需要的一项就返回 True 。

    示例如下:

    这个用法与使用 in 和 not in 没有区别,但不排除有人会特意写成这样来增加代码的理解难度。

    6. 借助 operator

    operator模块是python中内置的操作符函数接口,它定义了一些算术和比较内置操作的函数。operator模块是用c实现的,所以执行速度比 python 代码快。

    在 operator 中有一个方法 contains 可以很方便地判断子串是否在字符串中。

    7. 使用正则匹配

    说到查找功能,那正则绝对可以说是专业的工具,多复杂的查找规则,都能满足你。

    对于判断字符串是否存在于另一个字符串中的这个需求,使用正则简直就是大材小用。

    以上就是python七种方法判断字符串是否包含子串的详细内容,更多关于python 字符串的资料请关注服务器之家其它相关文章!

    原文链接:https://www.tuicool.com/articles/M3IJ3uR

    展开全文
  • 假设你有一个isSubstring函数,可以检测一个字符串是否是另一个字符串的子串。 给出字符串s1和s2,只使用一次isSubstring就能判断s2是否是s1的旋转字符串, 请写出代码。旋转字符串:”waterbottle”是”erbottlewat...

    题目

    假设你有一个isSubstring函数,可以检测一个字符串是否是另一个字符串的子串。 给出字符串s1和s2,只使用一次isSubstring就能判断s2是否是s1的旋转字符串, 请写出代码。旋转字符串:”waterbottle”是”erbottlewat”的旋转字符串。

    解答

    题目说我们使用一次isSubstring函数就可以判断s2是否是s1的旋转字符串, 如果从原始字符串s1和s2直接入手肯定不行,因为它们根本不存在子串关系。 如果不断地旋转字符,然后调用isSubstring,又需要调用多次的isSubstring。 而且通过旋转字符再判断,可以直接用等号判断,根本用不上isSubstring。

    既然如此,我们就要考虑去改变原始字符串。要判断a串是否是b串的子串, 一般情况下都会有b串长度大于a串,长度相等的话就直接判断它们是不是相等的串了。 我们可以考虑把串s1变长,然后调用一次isSubstring判断s2是否是s1变长后的子串, 如果是,就得出s2是s1的旋转字符串。s1怎么变长呢?无非就是s1+s1或是s1+s2, s2一定是s1+s2的子串,因此这样做没有任何意义。而s1+s1呢? 我们就上面的例子进行讨论:s1=waterbottle,s2=erbottlewat. 则:

    s1 + s1 = waterbottlewaterbottle 

    很容易可以发现,s1+s1其实是把s1中每个字符都旋转了一遍,而同时保持原字符不动。 比如waterbottle向右旋转2个字条应该是:terbottlewa,但如果同时保持原字符不动, 我们得到的就是waterbottlewa,而terbottlewa一定是waterbottlewa的子串, 因为waterbottlewa只是在terbottlewa的基础上再加上一条原字符不动的限制。 因此s1+s1将包含s1的所有旋转字符串,如果s2是s1+s1的子串,自然也就是s1 的旋转字符串了。

    C++代码如下:

    #include <iostream>
    #include <string>
    using namespace std;
     
    bool isSubstring(string s1, string s2){
        if(s1.find(s2) != string::npos) return true;
        else return false;
    }
    bool isRotation(string s1, string s2){
        if(s1.length() != s2.length() || s1.length()<=0)
            return false;
        return isSubstring(s1+s1, s2);
    }
     
    int main(){
        string s1 = "apple";
        string s2 = "pleap";
        cout<<isRotation(s1, s2)<<endl;
        //cout<<string::npos<<endl;
        return 0;
    }

         Java参考代码:

    public static boolean isRotation(String s1, String s2) {
         int len = s1.length();
          /* check that s1 and s2 are equal length and not empty */
         if (len == s2.length() && len > 0) { 
            /* concatenate s1 and s1 within new buffer */
            String s1s1 = s1 + s1;
            return isSubstring(s1s1, s2);
        }
        return false;
      }


    展开全文
  • 题目:假设你有一个isSubstring函数,可以检测一个字符串是否是另一个字符串的子串。 给出字符串s1和s2,只使用一次isSubstring就能判断s2是否是s1的旋转字符串, 请写出代码。旋转字符串:”waterbottle”是”...
  • 已知两个字符串A,B,判断B是否是A 的子串 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #include &lt;bits/stdc++.h&gt; using namespace std; ...
  • 从第一个字符开始,逐个扫描,对每一个字符,查找下一个相同字符,判断这两个字符之间的字符串是否回文。时间复杂度O(n^3)。虽然是笨笨解,但????找不出更好办法了,还望大神不吝赐教!!! 代码 #include<...
  • 码小辫专注更多编程视频和电子书天天在用钱1、...使用这两个成员运算符,可以很让我们很直观清晰的判断一个对象是否在另一个对象中,示例如下:>>>"llo"in"hello,python"True>>>>>>"lo...
  • Python判断字符串是否包含子字符串

    万次阅读 2019-04-10 15:36:20
    本文介绍Python判断一个字符串是否包含指定子串的4种方法。具有一定借鉴价值。 第一种 使用in运算符 最简单方法是通过python in 运算符 str = "Everyone has a world, quite and lonely!" result = ...
  • 判断一个字符串是否是另一个字符串的子串 */ classTest{ publicstaticvoidmain(String[]args){ booleanisSub=isSubString("asd213sdfwesdafasefsaefrasefasefawfghsfzsfsdr123wer1f","fghsfzsfs"); Syste...
  • 系列导读Python 炫技操作(01):条件语句七种写法Python 炫技操作(02):合并字典七种方法Python 炫技操作(03):连接列表八种方法Python 炫技操作(04):海象运算符三种方法Python 炫技操作(05):花式导包八...
  • 在写代码过程中,我们经常会遇到这样一个需求:判断字符串是否包含某个关键词,也就是特定子字符串。比如从一堆书籍名称中找出含有“python”书名。判断两个字符串相等很简单,直接 ==就可以了。其实判断...
  • 给出一个非空字符串,判断这个字符串是否是由它一个子串进行多次首尾拼接构成。 例如,"abcabcabc"满足条件,因为它是由"abc"首尾拼接而成,而"abcab"则不满足条件,输出false。 输入描述: abcabc ...
  • 如何判断某个字符串是否包含某个子串? 问题分析: 在项目中,我们常常会对已有数据库表中数据进行统计select; 所以经常会需要根据某些条件,来对结果集进行加工;例如: 如果一个select 数据库表违规环节字段中...
  • 判断字符串s1是否为字符串s2的重排子串,如s1=“aabcd”,s2=“sdabcda”,由于s2的子串“abcda”重新排序后可以为aabcd,因此s1是s2的重排子串;如s1=“aabcd”,s2=sdabcdsa“”,s2中任意子串重排后均不能和s1...
  • int f(char*s1,char*s2)... if (*s2==*s1) {/*判断字符串是否有和要判断字串首字符相同字符*/  flag=1;  p=s1; /*s1 p为第一个相同字符地址*/  q=s2;  for(;*q!='\0';) {/*如果有则判断接下去几个字
  • 使用js/javascript查看一个字符串是否是另一个字符串的子串。 解决 使用indexof方法即可。 indexOf()方法可返回某个指定的字符串值在字符串中首次出现的位置。 注释:indexOf() 方法对大小写敏感! 注释:如果...
  • Schema Specification http://www.verydemo.com/demo_c161_i74426.html https://oskb.wordpress ... dll--二进制层面复用 积木式思想其实是很自然一个过程,从c库函数到C++标准库,再到dll.com.com+都是这种...
  • 声明:这是我从"两颗番茄"博客看题目,然后自己编 不断学习!...从第一个字符开始,逐个扫描,对每一个字符,查找下一个相同字符,判断这两个字符之间的字符串是否回文。 #include <iostream....
  • python Python实现判断一个字符串是否包含子串的方法总结本文实例总结了Python实现判断一个字符串是否包含子串的方法。分享给大家供大家参考,具体如下:1.使用成员操作符 in>>> s='nihao,shijie'>&...
  • 1、使用 in 和 not ...使用这两个成员运算符,可以很让我们很直观清晰的判断一个对象是否在另一个对象中,示例如下:>>>"llo"in"hello,python"True>>>>>>"lol"in"hello,python"False2...
  • 不仅能判断规则中心对称,如123454321,还要能判断如123456547890中45654不规则部分中心对称算法思想从第一个字符开始,逐个扫描,对每一个字符,查找下一个相同字符,判断这两个字符之间的字符串是否回文。...
  • 写一个函数,判断一个字符串是否是子串: //函数实现如Strstr(): int Strstr(char s1[],char s2[]) { /* 如果s2是s1字串,则返回s1中第一次出现位置 如果s2不是s1字串,返回-1 空串,返回0 */ int ...
  • // 判断后一个字符串是否是前一个字符串的子串 #include"stdio.h" #include"string.h" int main(int argc,char*argv[3]){ int i,j,flag=0; char*q; for(i=0;i<=strlen(argv[1]);i++) if(*argv[2]==*argv[1]+...
  • 判断一个字符串是否是回文串 例如"abc"不是对称字符串,“aba”、“abba”、“aaa”、"mnanm"是对称字符串。 public static boolean func01(String str) { int result = 1; for (int i = 0; i < str.length() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,141
精华内容 856
关键字:

判断字符串是否是字符串的子串