精华内容
参与话题
问答
  • (C语言)常见字符函数和字符串函数

    万次阅读 多人点赞 2018-07-23 10:49:50
    字符串通常放在常量字符串中或者字符数组中,字符串常量适用于那些对她不做修改的字符串函数。 string.h这个头文件里声明的函数原型也全是针对char数组的种种操作。 直到C++中才出现了string这个类 这篇文章就...

    我们都知道,在C语言里有string.h这个头文件,但是C语言里没有string这个类型。
    字符串通常放在常量字符串中或者字符数组中,字符串常量适用于那些对她不做修改的字符串函数。
    string.h这个头文件里声明的函数原型也全是针对char数组的种种操作。
    直到C++中才出现了string这个类

    这篇文章就简单整理一下C语言中处理字符、字符串的库函数。

    strlen

     size_t  strlen( const char*  str)

    功能:计算字符串长度,不包含’\0’
    返回值:返回字符串的字符数
    说明:

    • strlen() 函数计算的是字符串的实际长度,遇到第一个’\0’结束;
    • 参数指向的字符串必须以 ’ \0 ‘结束
    • 函数返回值一定是size_t ,是无符号的
    • 如果你只定义没有给它赋初值,这个结果是不定的,它会从首地址一直找下去,直到遇到’\0’停止
    • sizeof返回的是变量声明后所占的内存数,不是实际长度,此外sizeof不是函数,仅仅是一个操作符,strlen()是函数

    strcpy

    char* strcpy(char* dest,char* src)

    功 能: 将参数src字符串拷贝至参数dest所指的地址
    返回值: 返回参数dest的字符串起始地址
    说明:

    • 源字符串必须以’\0’结束
    • 会将源字符串的’\0’拷贝到目标空间
    • 目标空间必须可变
    • 如果参数dest所指的内存空间不够大,可能会造成缓冲溢出的错误情况,在编写程序时需特别留意,或者用strncpy()来取代

    strncpy

    char* strncpy(char* dest,const char* src,size_t num)

    功能:拷贝src字符串的前num个字符至dest
    返回值:dest字符串起始地址
    说明:

    • 如果src字符串长度小于num,则拷贝完字符串后,在目标后追加0,直到num个
    • strncpy不会向dest追加’\0’
    • src和dest所指的内存区域不能重叠,且dest必须有足够的空间放置n个字符

    strcat

    char* strcat(char* dest,const char* src)

    功能: 字符串拼接
    返回值:返回dest字符串起始地址
    说明:

    - 源字符串必须’\0’结束
    - 目标空间必须可修改
    - strcat() 会将参数src字符串复制到参数dest所指的字符串尾部
    - dest最后的结束字符’\0’会被覆盖掉,并在连接后的字符串的尾部再增加一个’\0’
    - dest与src所指的内存空间不能重叠,且dest要有足够的空间来容纳要复制的字符串

    strncat

    char* strncat (char* dest,const char* src,size_t num)

    功能:将n个字符追加到字符串结尾
    返回值:返回dest字符串的起始地址
    说明:

    • strncat将会从字符串src的开头拷贝n个字符到dest字符串尾部
    • dest要有足够的空间来容纳要拷贝的字符串
    • 如果n大于字符串src的长度,那么仅将src全部追加到dest的尾部
    • strncat会将dest字符串最后的’\0’覆盖掉,字符追加完成后,再追加’\0’

    strcmp

    int strcmp (const char* str1,const char* str2)

    功能:字符串比较
    返回值:若参数s1和s2字符串相同则返回0,s1若大于s2则返回大于0的值,s1若小于s2则返回小于0的值
    说明:

    • 判断两个字符串大小1)ASII码 2)长度
    • 区分大小写比较的,如果希望不区分大小写进行字符串比较,可以使用stricmp函数

    strncmp

    int strncmp(const char* str1,const char* str2,size_t num)

    功能:指定长度比较
    返回值:同strcmp

    strstr

    char* strstr(const char* str,const char* substr)
    功能:检索子串在字符串中首次出现的位置
    返回值:返回字符串str中第一次出现子串substr的地址;如果没有检索到子串,则返回NULL

    strchr

    char* strchr(const char* str,char c)

    功能:查找字符串中第一次出现c的位置
    返回值:返回首次出现c的位置的指针,如果s中不存在c则返回NULL

    strrchr

    char* strchr(const char* str,char c)

    功能:查找字符串中最后一次出现c的位置
    返回值:返回最后一次出现c的位置的指针,如果s中不存在c则返回NULL

    strspn

    size_t  strspn(const char* str1, const char* str2)
    

    功能:用来计算str1字符串开始部分匹配str2字符串的字符个数
    返回值:返回字符串str1开头连续包含字符串str2内的字符数目。

    • 如果str所包含的字符都属于str2,那么返回str1的长度
    • 如果str的第一个字符不属于str2,那么返回0

    strcspn

    size_t  strspn(const char* str1, const char* str2)

    功能:用来计算str1字符串开始部分不匹配str2字符串的字符个数
    返回值:返回字符串str1开头部分不出现在字符串str2内的字符数目。

    strtok

    char* strtok(char* str,const char* sep)

    功能:根据分隔符将字符串分隔成一个个片段
    返回值:返回下一个分割后的字符串指针,如果已无从分割则返回NULL
    说明:
    - sep参数是个字符串,定义了用作分隔符的字符集合
    - 第一个参数指定一个字符串,它包含了一个或者多个由sqp字符串中一个或者多个字符分割的标记
    - 第一次调用时将字符串首地址传进去,之后调用不用传地址,内部会有static函数保存指向地址
    - 分隔符不作为输出内容,只做分界符
    - 当strtok在参数s的字符串中发现到参数sep的分割字符时则会将该字符改为’\0’字符
    - 在第一次调用时,strtok必须赋予参数str字符串,往后的调用则将参数s设置成NULL
    - strtok会修改原字符串,所以必须放至栈上

    strerror

    char* strerror(int errnum)
    

    功能:返回指向错误信息字符串的指针
    说明:

    • 必须包含头文件errno.h

    strpbrk

    char* strpbrk(const char*  str1, const char* str2)

    功能:在字符串s1中寻找字符串s2中任何一个字符相匹配的第一个字符的位置,空字符NULL不包括在内

    atoi

    int atoi(const char* str)

    功能:将字符串转换成整型
    返回值:返回转换后的整型数。如果str不能转换成int或者str为空字符串,那么将返回0
    说明:

    • ANSI C规范定义了 stof()、atoi()、atol()、strtod()、strtol()、strtoul()共6个可以将字符串转换为数字的函数,可以对比学习
    • 另外在C99/C++11规范中又新增了5个函数,分别是atoll()、strtof()、strtold()、strtoll()、strtoull()

    字符分类函数:

    int isalnum(int c):检查字符是否为数字或字母;(0~9,a~z,A~Z) 
    int isalpha(int c):检查字符是否为字母;(a~z, A~Z) 
    int iscntrl(int c):检查字符是否为控制字符;(八进制000~037以及177的字符) 
    int isdigit(int c):检查字符是否为十进制数字;(0~9) 
    int isgraph(int c):检查字符是否为图形表示,依赖于使用语言的环境;0~9,a~z,A~Z,以及标点符号) 
    int islower(int c):检查字符是否为小写的字母;(a~z) 
    int isprint(int c):检查字符是否为可打印的;(数字、字母、标点符号、空白字符) 
    int ispunct(int c):检查字符是否为标点符号;(! ” # $ % & ’ ( ) * + , - . / : ; < = > ? @ [ ] ^ _ ` { | } ~等) 
    int isspace(int c):检查字符是否为空白字符;(TAB、换行、垂直TAB、换页、回车、空格) 
    int isupper(int c):检查字符是否为大写字母;(A~Z) 
    int isxdigit(int c):检查字符是否为十六进制数字;(0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f) 

    字符转换

    int tolower(int c):转化字符为小写字母; 
    int toupper(int c):转化字符为大写字母;
    展开全文
  • python字符串函数用法大全

    万次阅读 多人点赞 2018-10-12 21:19:12
    1.0 capitalize()函数 2.0 title()函数 3.0swapcase()函数 4.0 lower()函数 5.0upper()函数 6.0 casefold()函数 7.0 center()函数 8.0ljust()函数 9.0 rjust()函数 10.0 zfill()函数 11.0 count()函数 ...


     

    目录

    1.0 capitalize()函数

    2.0 title()函数

    3.0 swapcase()函数

    4.0 lower()函数

    5.0 upper()函数

    6.0 casefold()函数

    7.0 center()函数

    8.0 ljust()函数

    9.0 rjust()函数

    10.0 zfill()函数

    11.0 count()函数

    12.0 encode()函数

    13.0 decode()函数

    14.0 expandtabs()函数

    15.0 find()函数

    16.0 rfind()函数

    17.0 index()函数

    18.0 rindex()函数

    19.0 format()函数

    20.0 format_map()函数

    21.0 endswith()函数

    22.0 startswith()函数

    23.0 isalnum()函数

    24.0 isalpha()函数

    25.0 isdecimal()函数

    26.0 isdigit()函数

    27.0 isidentifier()函数

    28.0  islower()函数

    29.0 isupper()函数

    30.0 isnumeric()函数

    31.0 isprintable()函数

    32.0 isspace()函数

    33.0 istitle()函数

    34.0  strip()函数

    35.0 lstrip()函数

    36. rstrip()函数

    37.0 maketrans()函数

    38.0 translate()函数

    39.0 partition()函数

    40.0  rpartition()函数

    41.0  split()函数

    42.0  rsplit()函数

    43.0 splitlines()函数

    44.0 join()函数

    45.0 replace()函数


    序言:

    字符串属于序列类型,根据字符串内容的多少可以将字符串分为单行字符串和多行字符串。其中单行字符串可以由一对双引号(" ")或一对单引号(' ')表示,单引号和双引号等效。多行字符串可由一对三单引号(''' ''')或一对三双引号(""" """)表示,三单引号和三双引号也等效。

     

    解决英文单词大小写问题:

    1.0 capitalize()函数

    描述:将字符串的第一个字母变成大写,其余字母变为小写。

    语法:str.capitalize()  —> str 返回字符串

    程序示例:

    str1 = "i Love python"
    str2 = " i Love python" #字母i前有空格
    str3 = "I Love python"
    print(str1.capitalize())
    print(str2.capitalize())
    print(str3.capitalize())

    程序运行结果: 

    I love python
     i love python
    I love python

    2.0 title()函数

    描述:返回一个满足标题格式的字符串。即所有英文单词首字母大写,其余英文字母小写。

    语法:str.title() -> str 返回一个字符串

    程序示例:

    str = "i love python"
    print(str.title()) #将字符串str的所有单词首字母大写,其余字母小写

    程序运行结果: 

    I Love Python

    3.0 swapcase()函数

    描述:将字符串str中的大小写字母同时进行互换。即将字符串str中的大写字母转换为小写字母,将小写字母转换为大写字母。

    语法:str.swapcase() -> str 返回字符串

    程序示例:

    str1 = "I Love PYTHON"
    str2 = "我爱python Python pYTHON"
    print(str1.swapcase()) #将字符串str1中的大写字母转为小写字母,小写字母转换为大写字母。
    print(str2.swapcase())

    程序运行结果:

    i lOVE python
    我爱PYTHON pYTHON Python

    4.0 lower()函数

    描述:将字符串中的所有大写字母转换为小写字母。

    语法:str.lower()  -> str  返回字符串

    程序示例:

    str1 = "I Love Python"
    str2 = "Groß - α" #德语 大写α
    print(str1.casefold())
    print(str1.lower())
    print(str2.casefold())
    print(str2.lower())

    程序运行结果:

    i love python
    i love python
    gross - α
    groß - α

    注意 lower()函数和casefold()函数的区别:

    lower() 方法只对ASCII编码,即‘A-Z’有效,对于其它语言中把大写转换为小写的情况无效,只能用 casefold() 函数。

    5.0 upper()函数

    描述:将字符串中的所有小写字母转换为大写字母。

    语法: str.upper() -> str  返回字符串

    程序示例:

    str1 = "i love python"  #全为小写字母
    str2 = "I Love Python"  #所有单词首字母大写
    print(str1.upper())
    print(str2.upper())

    程序运行结果:

    I LOVE PYTHON
    I LOVE PYTHON

    6.0 casefold()函数

    描述:将字符串中的所有大写字母转换为小写字母。也可以将非英文 语言中的大写转换为小写。

    注意 lower()函数和casefold()函数的区别:lower() 方法只对ASCII编码,即‘A-Z’有效,对于其它语言中把大写转换为小写的情况无效,只能用 casefold() 函数。

    语法:str.casefold()   -> str 返回字符串

    程序示例:

    str1 = "I Love Python"
    str2 = "Groß - α" #德语 大写α
    print(str1.casefold())
    print(str1.lower())
    print(str2.casefold())
    print(str2.lower())

    程序运行结果:

    i love python
    i love python
    gross - α
    groß - α

     

     

     

    解决字符串填充问题:

    7.0 center()函数

    描述:返回一个长度为width,两边用fillchar(单字符)填充的字符串,即字符串str居中,两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。

    语法:str.center(width , "fillchar")  -> str  返回字符串       注意:引号不可省

    • width —— 指定字符串长度。
    • fillchar —— 要填充的单字符,默认为空格。

    程序示例:

    str = "i love python"
    print(str.center(20,"*")) #指定字符串长度为20 用单字符"*"填充
    print(str.center(1,"*")) #指定字符串长度为1,小于原字符串的长度。
    print(str.center(20,"8"))
    print(str.center(20)) #fillchar 默认为空格

    程序运行结果:

    ***i love python****
    i love python
    888i love python8888
       i love python  

    8.0 ljust()函数

    描述:返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

    语法: str.ljust(width, fillchar)  -> str 返回一个新的字符串

    • width —— 指定字符串的输出长度。
    • fillchar—— 将要填充的单字符,默认为空格

    程序示例:

    str = "python"
    print(str.ljust(30,"*")) #指定宽度为30,填充字符为*
    print(str.ljust(30))  #指定宽度为30,填充字符默认为空格
    print(str.ljust(30),"1") #对比

    程序运行结果:

    python************************
    python                        
    python                         1

    9.0 rjust()函数

    描述:返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

    语法: str.ljust(width, fillchar)  -> str 返回一个新的字符串

    • width —— 指定字符串的输出长度。
    • fillchar—— 将要填充的单字符,默认为空格。

    程序示例:

    str = "python"
    print(str.rjust(30,"*")) #指定宽度为30,填充字符为*
    print(str.rjust(30))  #指定宽度为30,填充字符默认为空格
    print("1",str.rjust(30)) #对比

    程序运行结果:

    ************************python
                            python
    1                         python

    10.0 zfill()函数

    描述:返回指定长度的字符串,使原字符串右对齐,前面用0填充到指定字符串长度。

    语法:str.zfill(width) -> str 返回一个字符串

    • width —— 指定字符串的长度,但不能为空。若指定长度小于字符串长度,则直接输出原字符串。

    程序示例:

    str = "i love python"
    print(str.zfill(30)) #指定字符串长度为30
    print(str.zfill(2)) #指定字符串长度为2,小于原字符串长度。
    print(str.zfill()) #参数width为空,报错.

    程序运行结果:

    00000000000000000i love python
    i love python
    ---------------------------------------------------------------------------
    TypeError                                 Traceback (most recent call last)
    <ipython-input-22-45e4baf7a246> in <module>()
          2 print(str.zfill(30)) #指定字符串长度为30
          3 print(str.zfill(2)) #指定字符串长度为2,小于原字符串长度。
    ----> 4 print(str.zfill()) #参数width为空,报错.
    
    TypeError: zfill() takes exactly 1 argument (0 given)
    

     

     

     

    解决统计字符次数问题:

    11.0 count()函数

    描述:统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。           

    语法:str.count("char", start,end)  或 str.count("char")    -> int    返回整数

    • str —— 为要统计的字符(可以是单字符,也可以是多字符)。
    • star —— 为索引字符串的起始位置,默认参数为0。
    • end —— 为索引字符串的结束位置,默认参数为字符串长度即len(str)。

    程序示例:

    str = "i love python,i am learning python"
    print(str.count("i")) #star 和end 为默认参数
    print(str.count("i",2)) # star值为2,end值为默认参数
    print(str.count("i",2,5)) #star值为2,end值为5
    print(str.count("am"))  #多字符统计

    程序运行结果:

    3
    2
    0
    1

     

    解决编码问题:

    12.0 encode()函数

    描述:以指定的编码格式编码字符串,默认编码为 'utf-8'。

    语法:str.encode(encoding='utf-8', errors='strict')     -> bytes (获得bytes类型对象)

    • encoding 参数可选,即要使用的编码,默认编码为 'utf-8'。字符串编码常用类型有:utf-8,gb2312,cp936,gbk等。
    • errors 参数可选,设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeEncodeError。 其它可能值有 'ignore', 'replace', 'xmlcharrefreplace'以及通过 codecs.register_error() 注册其它的值。

    程序示例:

    str1 = "我爱祖国"
    str2 = "I love my country"
    print("utf8编码:",str1.encode(encoding="utf8",errors="strict")) #等价于print("utf8编码:",str1.encode("utf8"))
    print("utf8编码:",str2.encode(encoding="utf8",errors="strict"))
    print("gb2312编码:",str1.encode(encoding="gb2312",errors="strict"))#以gb2312编码格式对str1进行编码,获得bytes类型对象的str
    print("gb2312编码:",str2.encode(encoding="gb2312",errors="strict"))
    print("cp936编码:",str1.encode(encoding="cp936",errors="strict"))
    print("cp936编码:",str2.encode(encoding="cp936",errors="strict"))
    print("gbk编码:",str1.encode(encoding="gbk",errors="strict"))
    print("gbk编码:",str2.encode(encoding="gbk",errors="strict"))

    程序运行结果:

    utf8编码: b'\xe6\x88\x91\xe7\x88\xb1\xe7\xa5\x96\xe5\x9b\xbd'
    utf8编码: b'I love my country'
    gb2312编码: b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
    gb2312编码: b'I love my country'
    cp936编码: b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
    cp936编码: b'I love my country'
    gbk编码: b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
    gbk编码: b'I love my country'
    
    

    注:在python中encode和decode分别指编码和解码

    13.0 decode()函数

    描述:以 encoding 指定的编码格式解码字符串,默认编码为字符串编码。

    语法:str.decode(encoding='utf-8', errors='strict')

    • encoding ——要使用的编码,如:utf-8,gb2312,cp936,gbk等。

    • errors ——设置不同解码错误的处理方案。默认为 'strict',意为编码错误引起一个 UnicodeDecodeError。 其它可能得值有 'ignore', 'replace'以及通过 codecs.register_error() 注册的1其它值。

    程序示例:

    s = "我爱祖国"
    str1 = s.encode(encoding="utf-8",errors="strict")
    str2 = s.encode("gb2312") #编码错误的处理方案默认为"strict"
    str3 = s.encode("gbk")
    print(str1.decode(encoding="utf-8",errors="strict"))#用utf-8的解码格式,解码str1.
    print(str1.decode(encoding="gbk",errors="ignore"))##如果以gbk的解码格式对str1进行解码得,将无法还原原来的字符串内容
    print(str1.decode(encoding="gbk",errors="strict"))
    print(str1.decode(encoding="gbk",errors="replace"))
    print("\n")
    print(str2.decode("gb2312"))
    print(str3.decode("gbk"))

    程序运行结果:

    我爱祖国
    鎴戠埍绁栧浗
    鎴戠埍绁栧浗
    鎴戠埍绁栧浗
    
    
    我爱祖国
    我爱祖国

     注:在python3.x中,encode()函数只能用于字符串类型,而decode()函数只能用于字节数据类型。

    程序示例中 str1,str2,str3都是字节数据类型(通过encode()函数把 字符串类型s 转换为字节数据类型)。

     

     

    14.0 expandtabs()函数

    描述:返回一个字符串的副本。使原字符串中的制表符("\t")的使用空间变大。使用空格来扩展空间。

    语法: str.expandtabs(tabsize=8)  —> str  返回字符串

    • tabsize 的默认值为8。tabsize值为0到7等效于tabsize=8。tabsize每增加1,原字符串中“\t”的空间会多加一个空格。

    程序示例:

    str = "i love\tpython"
    print(str.expandtabs())#默认值为8
    print(str.expandtabs(tabsize=8))
    print(str.expandtabs())
    print(str.expandtabs(2)) #tabsize值为0到7,与tabsize值为8相同
    print(str.expandtabs(tabsize=2))
    print(str.expandtabs(tabsize=9))      
    print(str.expandtabs(tabsize=10))

    程序运行结果:

    i love  python
    i love  python
    i love  python
    i love  python
    i love  python
    i love   python
    i love    python

     

     

     

    解决查找指定字符(子字符串)位置问题:

    15.0 find()函数

    描述:查找字符串中指定的子字符串sub第一次出现的位置,可以规定字符串的索引查找范围。若无则返回 -1。

    语法:str.find(sub,start,end) -> int 返回整数

    • sum —要索引的子字符串。
    • start —索引的起始位置。默认值为0。
    • end —索引的结束位置。默认值为字符串长度len(str)。
    • [start,end) 不包括end。

    程序示例:

    str = "i love python"
    print(str.find("o")) #索引子字符串"o"
    print(str.find("0",4))#索引起始位置为4 索引范围为:ve python
    print(str.find("o",4,12))#索引起始位置为4,结束位置为12 索引范围为:ve pytho
    print(str.find(""))
    print(str.find(" "))#返回第一个空格出现的位置。
    print(str.find("k")) #索引子字符串"k",不存在,返回-1
    

    程序运行结果:

    3
    -1
    11
    0
    1
    -1

    16.0 rfind()函数

    描述:查找字符串中指定的子字符串sub最后一次出现的位置,可以规定字符串的索引查找范围。若无则返回 -1。

    语法:str.rfind(sub,start,end) -> int 返回整数

    • sum —要索引的子字符串。
    • start —索引的起始位置。默认值为0。
    • end —索引的结束位置。默认值为字符串长度len(str)。
    • [start,end) 不包括end。

    注:rfind()函数用法与find()函数相似,rfind()函数返回指定子字符串最后一次出现的位置,find()函数返回指定子字符串第一次出现的位置。

    程序示例:

    str = "i love python python"
    print(str.rfind("o")) #默认索引整个字符串str
    print(str.rfind("o",11)) #索引范围为:on python
    print(str.rfind("o",0,12)) #索引范围为 i love pytho
    print(str.rfind("python")) #返回最后一次出现"python"的位置,即字母"p"最后一次出现的位置。
    print(str.rfind("")) #等效于返回字符串str的长度。
    print(str.rfind(" "))#返回最后一个空格出现的位置
    print(str.rfind("2"))  #字符串str中不存在字符"2",返回值为 -1

    程序运行结果:

    18
    18
    11
    14
    20
    13
    -1

    17.0 index()函数 

    描述:查找字符串中第一次出现的子字符串的位置,可以规定字符串的索引查找范围[star,end)。若无则会报错。

    语法:str.index(sub, start, end)  -> int  返回整数

    • sub —— 查找的子字符串。
    • start —— 索引的起始位置,默认为0。
    • end  —— 索引的结束位置,默认为字符串的长度。
    • [star,end)

    程序示例:

    str = "i love python"
    print(str.index("o"))  #默认索引整个字符串
    print(str.index("o",4))  #索引 ve python
    print(str.index("o",4,12)) #索引 ve pytho
    print(str.index("love"))    #索引多个字符
    print(str.index("k"))    #索引字符串不存在,报错

     程序运行结果:

    3
    11
    11
    2
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-90-a880e13b1574> in <module>()
          4 print(str.index("o",4,12)) #索引 ve pytho
          5 print(str.index("love"))    #索引多个字符
    ----> 6 print(str.index("k"))
    
    ValueError: substring not found
    

       注:index()函数和find()函数类似,但index()函数没有找到子字符串会报错。

    18.0 rindex()函数

    描述:查找字符串中最后一次出现的子字符串的位置,可以规定字符串的索引查找范围[star,end),若无则会报错。

    语法:str.rindex(sub, start, end) -> int   返回整数。

    • sub —— 查找的子字符串。
    • start —— 索引的起始位置,默认为0。
    • end  ——  索引的结束位置,默认为字符串的长度。
    • [star,end)

    注:rindex()函数用法与index()函数相似,rindex()函数返回指定子字符串最后一次出现的位置,index()函数返回指定子字符串第一次出现的位置。

    程序示例:

    str = "i love python python"
    print(str.rindex("p")) #默认索引整个字符串
    print(str.rindex("o",5)) #索引的范围为:e python python
    print(str.rindex("o",5,13)) #索引范围为:e python
    print(str.rindex("python")) #返回最后一次出现"python"的位置,即字母"p"最后一次出现的位置。
    print(str.rindex("k"))  #索引字符串不存在,报错
    len(str),str[5:13]

    程序运行结果:

    14
    18
    11
    14
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-116-44cc5c1acea1> in <module>()
          4 print(str.rindex("o",5,13)) #索引范围为:e python
          5 print(str.rindex("python")) #返回最后一次出现"python"的位置,即字母"p"最后一次出现的位置。
    ----> 6 print(str.rindex("k"))
          7 len(str),str[5:13]
    
    ValueError: substring not found
    

     

     

     

    解决格式化输出问题:

    19.0 format()函数

    描述:返回一个格式化的字符串。

    语法:str.format(*args, **kwargs) ——> str 返回字符串    [模板字符串].format(逗号分隔的参数) 

    或  {参数序号:格式控制标记}.format(逗号分隔的参数) 

    • 它是通过{}和:来代替%。
    • 模板字符串是一个由槽(用大括号{}来表示)和字符串组成的字符串,用来控制字符串的显示效果。
    • 大括号{}对应着format()中逗号分隔的参数。

    format()基本用法 :

    语法:[模板字符串].format(逗号分隔的参数) 

     通过位置 

    程序示例:

    print("用法一:")
    print("一日之计在于{}".format("晨"))
    
    #如果模板字符串有多个槽{},并且槽内没有指定的序号,则按照槽{}出现的顺序一一对应format()函数中的不同参数
    print("用法二:")
    print("{}之计在于{}".format("一日","晨"))
    
    #也可以通过在槽{}中指定format()函数中参数的序号来使用,参数是从0开始编号的。
    print("用法三:")
    print("{0}之计在于{1}".format("一日","晨"))
    print("{1}之计在于{0}".format("晨","一日"))
    
    # 如果想要在模板字符串中输出大括号("{}"),则使用{{ 来表示 {   用 }} 来表示 }
    print("用法四:")
    print("{0}说得好:{{一{1}之计在于晨 一{2}之计在于春}}".format("俗话","日","年"))
    
    #如果模板字符串中出现的槽{}和format()函数中参数个数不一致,
    #则必须要在槽{}中使用序号来指定参数的使用,否者会产生IndexError的错误。
    print("用法五:")
    print("{0}日之计在于晨, {0}年之计在于春".format("一"))
    print("{}日之计在于晨, {}年之计在于春".format("一")) #槽中没有指定参数序号,会报错。

    程序运行结果:

    用法一:
    一日之计在于晨
    用法二:
    一日之计在于晨
    用法三:
    一日之计在于晨
    一日之计在于晨
    用法四:
    俗话说得好:{一日之计在于晨 一年之计在于春}
    用法五:
    一日之计在于晨, 一年之计在于春
    ---------------------------------------------------------------------------
    IndexError                                Traceback (most recent call last)
    <ipython-input-20-5f7b4f063a3b> in <module>()
         19 print("用法五:")
         20 print("{0}日之计在于晨, {0}年之计在于春".format("一"))
    ---> 21 print("{}日之计在于晨, {}年之计在于春".format("一")) #槽中没有指定参数序号,会报错。
    
    IndexError: tuple index out of range

     通过关键字参数 

    程序示例: 

    print("{year}之计在于{season}".format(year="一年",season="春"))

    程序运行结果:

    一年之计在于春

    通过列表  

    程序示例:

    l = ["一日","晨","一年","春"]
    a = ["一日","晨"]
    b = ["一年","春"]
    print("{0[0]}之计在于{0[1]}, {0[2]}之计在于{0[3]}".format(l))
    
    #format()函数中的参数可以是一个或多个列表,但要注意槽中序号的差异。
    print("{0[0]}之计在于{0[1]}, {1[0]}之计在于{1[1]}".format(a,b)) 

    程序运行结果:

    一日之计在于晨, 一年之计在于春
    一日之计在于晨, 一年之计在于春

    通过字典

    程序示例:

    d1 = {"year":"一年","season":"春"}
    print(" {year}之计在于{season}".format(**d1))
    
    d2 = {"time":["一日","一年"],"season":["晨","春"]}
    print("{time[0]}之计在于{season[0]},{time[1]}之计在于{season[1]}".format(**d2))

    程序运行结果:

    一年之计在于春
    一日之计在于晨,一年之计在于春
    

    format()函数格式控制方法:

    语法:{参数序号:格式控制标记}.format(逗号分隔的参数) 

     

    槽中格式控制标记规则
           :            [填充]    [对齐]    [宽度]                [,]               [.精度]             [类型]
    引导符号 要填充的单个字符

    < 左对齐

    > 右对齐

    ^ 居中对齐

    设定槽的输出宽度

    数字的千位分隔符

    适用于整数和浮点数

     

    用于控制浮点数小数部分

    的精度(长度)

    或字符串的最大输出长度

    整数类型:b,c,d,o,x,X

    浮点数类型:e,E,f,%

    [填充]——只能填充单个字符。填充字符时,一定要选择对齐方式,否者会有 Invalid format specifier 的报错

    [对齐]——默认对齐方式为左对齐。

    [宽度]——指的是槽的输出宽度,当槽的实际宽度比槽的设定宽度大,则输出槽的实际宽度,否者按设定的宽度输出。

    [类型]——解析如下表

    整数和浮点数类型的输出格式
    类型 描述 类型 描述
    b 输出整数的二进制形式 e 输出浮点数对应的小写字母e的指数形式
    c 输出整数对应的Unicode字符 E 输出浮点数对应的大写字母E的指数形式
    d 输出整数的十进制形式 f 输出标准浮点数形式
    o 输出整数的八进制形式 % 输出浮点数的百分比形式
    x 输出整数的小写十六进制形式    
    X 输出整数的大写写十六进制形式    

    格式控制标记规则:[填充], [对齐], [宽度], [,], [.精度], [类型]  这六个规则是可以任意组合使用的,但要按以上顺序使用。不过一般可以分为两组。

    一组为:[填充] [对齐] [宽度]   主要用于规范字符串的显示格式。

    程序示例:

    s = "厉害了,我的国"
    print("{0:30}".format(s))  #默认为左对齐,宽度为30,序号0可省
    print("{0:>30}".format(s))  #右对齐  
    print("{0:*>30}".format(s)) #填充*字符,右对齐
    print("{0:*^30}".format(s)) #居中对齐
    print("{0:*30}".format(s)) #填充字符时,没有选择对齐方式,会有 Invalid format specifier 的报错

    程序运行结果:

    厉害了,我的国                       
                           厉害了,我的国
    ***********************厉害了,我的国
    ***********厉害了,我的国************
    ---------------------------------------------------------------------------
    ValueError                                Traceback (most recent call last)
    <ipython-input-86-959132fb938a> in <module>()
          4 print("{0:*>30}".format(s)) #填充*字符,右对齐
          5 print("{0:*^30}".format(s)) #居中对齐
    ----> 6 print("{0:*30}".format(s)) #填充字符时,没有选择对齐方式,会有 Invalid format specifier 的报错
    
    ValueError: Invalid format specifier
    

    格式控制标记规则也可以用变量来表示,即用槽{}来指定对应的格式控制标记规则。

    程序示例:

    s = "厉害了,我的国"
    a = "*"
    b = "^"
    c = 30
    d = ["<","^",">"]
    print("{0:{1}{2}{3}}".format(s,a,b,c))  #居中对齐,宽度为30,填充字符为*
    print("{0:{1}{2[2]}{3}}".format(s,a,d,c))#右对齐,用列表选择对齐方式。
    print("{0:{1}{2[0]}{3}}".format(s,a,d,c)) 

      程序运行结果:

    ***********厉害了,我的国************
    ***********************厉害了,我的国
    厉害了,我的国***********************

     另一组为:[,]  [.精度]  [类型]   主要于规范数字的输出格式和控制字符串的输出长度。

    程序示例:

    print("{0:,}".format(123456789)) # 千位分隔符
    print("{:,.3}".format(123456.123)) #保留3为有效数字
    print("{:.3}".format("厉害了,我的国")) # 输出前三个字符
    
    
    #输出整数类型的格式化规则:
    #print("输出整数的二进制形式:{0:b}\n输出整数对应的Unicode字符:{0:c}\n输出整数的十进制形式:{0:d}\n输出整数的八进制形式:{0:o}\n输出整数的小写十六进制形式:{0:x}\n输出整数的大写写十六进制形式:{0:X}".format(123456))
    # 等效于一下语句:
    print("输出整数的二进制形式: {:b}".format(123456))
    print("输出整数对应的Unicode字符: {:c}".format(123456))
    print("输出整数的十进制形式: {:d}".format(123456))
    print("输出整数的八进制形式: {:o}".format(123456))
    print("输出整数的小写十六进制形式: {:x}".format(123456))
    print("输出整数的大写写十六进制形式: {:X}".format(123456))
    
    
    #输出浮点数类型的格式化规则:
    print("输出浮点数对应的小写字母e的指数形式: {:e}".format(123456.123456))
    print("输出浮点数对应的大写字母E的指数形式: {:E}".format(123456.123456))
    print("输出标准浮点数形式: {:f}".format(123456.123456))
    print("输出浮点数的百分比形式: {:%}".format(123456.123456))
    
    #对比  [.精度]可以控制小数部分的输出长度
    print("输出浮点数对应的小写字母e的指数形式: {:.3e}".format(123456.123456))
    print("输出浮点数对应的大写字母E的指数形式: {:.3E}".format(123456.123456))
    print("输出标准浮点数形式: {:.3f}".format(123456.123456))
    print("输出浮点数的百分比形式: {:.3%}".format(123456.123456))

    程序运行结果:

    123,456,789
    1.23e+05
    厉害了
    
    输出整数的二进制形式: 11110001001000000
    输出整数对应的Unicode字符: ?
    输出整数的十进制形式: 123456
    输出整数的八进制形式: 361100
    输出整数的小写十六进制形式: 1e240
    输出整数的大写写十六进制形式: 1E240
    
    输出浮点数对应的小写字母e的指数形式: 1.234561e+05
    输出浮点数对应的大写字母E的指数形式: 1.234561E+05
    输出标准浮点数形式: 123456.123456
    输出浮点数的百分比形式: 12345612.345600%
    
    输出浮点数对应的小写字母e的指数形式: 1.235e+05
    输出浮点数对应的大写字母E的指数形式: 1.235E+05
    输出标准浮点数形式: 123456.123
    输出浮点数的百分比形式: 12345612.346%

    综合运用实例:

    程序示例:

    print("{:*^30,.2f}".format(123456.1235))#用*字符填充,居中对齐,宽度为30,千位分隔符,保留小数点后两位,输出标准浮点数
    s = "一年有:"
    a = 365.0000
    b = "天"
    print("{0:*>8}{1:,.1f}{2:*<5}".format(s,a,b))

    程序运行结果:

    **********123,456.12**********
    ****一年有:365.0天****

    20.0 format_map()函数

    描述:返回字符串的格式化版本。

    语法:str.format_map(mapping)  -> str 返回字符串

    程序示例:

    student = {"name":["张三","李四"],"idcard":[1,2]}
    
    print("我的名字是{name[0]},我的学号是{idcard[0]}".format_map(student))
    print("我的名字是{name[0]},我的学号是{idcard[1]}".format_map(student))
    
    
    print(["我的名字是{},我的学号是{}".format(*x) for x in zip(student["name"],student["idcard"])]) #以列表的形式输出
    print("我的名字是{},我的学号是{}".format(*x) for x in zip(student["name"],student["idcard"]))
    
    print(["我的名字是{},我的学号是{}".format(*x) for x in zip(*map(student.get,["name","idcard"]))]) #以列表的形式输出
    print("我的名字是{},我的学号是{}".format(*x) for x in zip(*map(student.get,["name","idcard"]))) 
    
    for i in range(len(student)):
        print("我的名字是{{name[0]}},我的学号是{{idcard[0]}}".format(i).format_map(student))
        # {{ }} 等效于{ }  

    程序运行结果:

    我的名字是张三,我的学号是1
    我的名字是张三,我的学号是2
    
    ['我的名字是张三,我的学号是1', '我的名字是李四,我的学号是2']
    <generator object <genexpr> at 0x0000018F5E1CFF68>
    
    ['我的名字是张三,我的学号是1', '我的名字是李四,我的学号是2']
    <generator object <genexpr> at 0x0000018F5E1CF200>
    
    我的名字是张三,我的学号是1
    我的名字是张三,我的学号是1

     

     

    解决判断问题(返回bool类型)

    21.0 endswith()函数

    描述:判断字符串是否以指定字符或子字符串结尾。

    语法:str.endswith("suffix", start, end) 或

    str[start,end].endswith("suffix")    用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

    —> bool    返回值为布尔类型(True,False)

    • suffix — 后缀,可以是单个字符,也可以是字符串,还可以是元组("suffix"中的引号要省略,常用于判断文件类型)。
    • start —索引字符串的起始位置。
    • end — 索引字符串的结束位置。
    • str.endswith(suffix)  star默认为0,end默认为字符串的长度len(str)

      注意:空字符的情况。返回值通常为True

    程序示例:

    str = "i love python"
    print("1:",str.endswith("n")) 
    print("2:",str.endswith("python"))
    print("3:",str.endswith("n",0,6))# 索引 i love 是否以“n”结尾。
    print("4:",str.endswith("")) #空字符
    print("5:",str[0:6].endswith("n")) # 只索引 i love
    print("6:",str[0:6].endswith("e"))
    print("7:",str[0:6].endswith(""))
    print("8:",str.endswith(("n","z")))#遍历元组的元素,存在即返回True,否者返回False
    print("9:",str.endswith(("k","m")))
    
    
    #元组案例
    file = "python.txt"
    if file.endswith("txt"):
        print("该文件是文本文件")
    elif file.endswith(("AVI","WMV","RM")):
        print("该文件为视频文件")
    else:
        print("文件格式未知")
    

    程序运行结果:

    1: True
    2: True
    3: False
    4: True
    5: False
    6: True
    7: True
    8: True
    9: False
    该文件是文本文件

     

    22.0 startswith()函数

    描述:判断字符串是否以指定字符或子字符串开头。

    语法:str.endswith("suffix", start, end) 或

    str[start,end].endswith("suffix")    用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

    —> bool    返回值为布尔类型(True,False)

     

    • suffix — 后缀,可以是单个字符,也可以是字符串,还可以是元组("suffix"中的引号要省略)。
    • start —索引字符串的起始位置。
    • end — 索引字符串的结束位置。
    • str.endswith(suffix)  star默认为0,end默认为字符串的长度减一(len(str)-1)。

    注意:空字符的情况。返回值通常也为True

    程序示例:

    str = "hello,i love python"
    print("1:",str.startswith("h"))
    print("2:",str.startswith("l",2,10))# 索引 llo,i lo 是否以“n”结尾。
    print("3:",str.startswith("")) #空字符
    print("4:",str[0:6].startswith("h")) # 只索引  hello,
    print("5:",str[0:6].startswith("e"))
    print("6:",str[0:6].startswith(""))
    print("7:",str.startswith(("h","z")))#遍历元组的元素,存在即返回True,否者返回False
    print("8:",str.startswith(("k","m")))

    程序运行结果:

    1: True
    2: True
    3: True
    4: True
    5: False
    6: True
    7: True
    8: False

    23.0 isalnum()函数

    描述:检测字符串是否由字母和数字组成。

    语法:str.isalnum()  -> bool  返回值为布尔类型(True,False)

    • str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False

    程序示例:

    str1 = "i love python 666"  #有空格,不全是字母或数字
    str2 = "python" #全为字母
    str3 = "123"  #全为数字
    str4 = "python666"  #字母和数字的组合
    print(str1.isalnum())
    print(str2.isalnum())
    print(str3.isalnum())
    print(str4.isalnum())

    程序运行结果:

    False
    True
    True
    True

    24.0 isalpha()函数

    描述:检测字符串是否只由字母组成。

    语法:str.isalpha()  -> bool  返回值为布尔类型(True,False)

    • 字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。

    程序示例:

    str1 = "python" #全为字母
    str2 = " python" #存在空格
    str3 = "123"  #全为数字
    str4 = "python666"   #字母和数字的组合
    print(str1.isalpha())
    print(str2.isalpha())
    print(str3.isalpha())
    print(str4.isalpha()

    程序运行结果:

    True
    False
    False
    False

    25.0 isdecimal()函数

    描述:检查字符串是否只包含十进制字符。该方法只存在于unicode对象中。

    注意:定义一个十进制字符串,只需要在字符串前添加前缀 'u' 即可。

    语法: str.isdecimal()  -> bool  返回值为布尔类型(True,False)

    • 字符串中若只包含十进制字符返回True,否则返回False。

    程序示例:

    str1 = u"123456" 
    str2 = u"python666"
    str3 = "123456"
    str4 = "python666"
    print(str1.isdecimal())
    print(str2.isdecimal())
    print(str3.isdecimal())
    print(str4.isdecimal())

    程序运行结果:

    True
    False
    True
    False

    26.0 isdigit()函数

    描述:检测字符串是否只由数字组成.

    语法: str.isdigit()  -> bool  返回值为布尔类型(True,False)

    • 字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。
    • 注:能判断“①”,不能判断中文数字。但 isnumeric() 函数可以。

    程序示例:

    str1 = "python" #全为字母
    str2 = " python" #存在空格
    str3 = "123"  #全为数字
    str4 = "python666"   #字母和数字的组合
    str5 = "一二三四五六七" #中文数字输出False
    str6 = "①"  
    print(str1.isdigit())
    print(str2.isdigit())
    print(str3.isdigit())
    print(str4.isdigit())
    print(str5.isdigit())
    print(str6.isdigit())

    程序运行结果:

    False
    False
    True
    False
    False
    True

    27.0 isidentifier()函数

    描述:判断str是否是有效的标识符。str为符合命名规则的变量,保留标识符则返回True,否者返回False。

    语法:str.isidentifier()  -> bool  返回值为布尔类型(True,False)

    程序示例:

    str1 = "123"  #变量名为123
    str2 = "def"  #变量名为保留字
    str3 = "_123"  #变量名有下划线开头
    str4 = "student"#变量名由字母开端
    print(str1.isidentifier())
    print(str2.isidentifier())
    print(str3.isidentifier())
    print(str4.isidentifier())

    程序运行结果:

    False
    True
    True
    True

    28.0  islower()函数

    描述:检测字符串中的字母是否全由小写字母组成。(字符串中可包含非字母字符)

    语法:str.islower()  -> bool   返回值为布尔类型(True,False)

    • 字符串中包含至少一个区分大小写的字符,且所有这些区分大小写的字符都是小写,则返回 True,否则返回 False。

    程序示例:

    str1 = "i love python"  #字符串中的字母全为小写
    str2 = "我爱python!"  #字符串中的字母全为小写,也存在非字母的字符
    str3 = "I love python" #字符串中有大写字符
    print(str1.islower())
    print(str2.islower())
    print(str3.islower())

    程序运行结果:

    True
    True
    False

    29.0 isupper()函数

    描述:检测字符串中的字母是否全由大写字母组成。(字符串中可包含非字母字符)。

    语法:str.isupper()  -> bool  返回值为布尔类型(True,False)

    • 字符串中包含至少一个区分大小写的字符,且所有这些区分大小写的字符都是大写,则返回 True,否则返回 False。

    程序示例:

    str1 = "I LOVE PYTHON"  #全为大写字母
    str2 = "i LOVE PYTHON"  #存在小写字母
    str3 = "我爱PYTHON"   #存在非字母的字符
    print(str1.isupper())
    print(str2.isupper())
    print(str3.isupper())

    程序运行结果:

    True
    False
    True

    30.0 isnumeric()函数

    描述:测字符串是否只由数字组成。这种方法是只适用于unicode对象。

    注:把一个字符串定义为Unicode,只需要在字符串前添加 前缀 'u' 

    语法:str.isnumeric()  -> bool  返回值为布尔类型(True,False)

    • 字符串中只包含数字字符,则返回 True,否则返回 False。
    • 与isdigit()函数类似,但isnumeric()函数可以判断中文数字,功能更强大。

    程序示例:

    str1 = u"123456"  #全为数字
    str2 = "123456"
    str3 = "python666"  #字母数字组合
    str4 = "一二三四五六"  #中文数字
    str5 = "①"
    print(str1.isnumeric())
    print(str2.isnumeric())
    print(str3.isnumeric())
    print(str4.isnumeric())
    print(str5.isnumeric())

    程序运行结果:

    True
    True
    False
    True
    True

    31.0 isprintable()函数

    描述:判断字符串中是否有打印后不可见的内容。如:\n \t  等字符。

    语法:  str.isprintable()  -> bool 返回值为布尔类型(True,False)

    • 若字符串中不存在\n \t 等不可见的内容,则返回True,否者返回False。

    程序示例:

    str1 = "i love  python"  #不存在用print()打印后不可见的内容
    str2 = "i love python \n" #存在用print()打印后不可见的内容 \n
    str3 = "i love \t python"
    print(str1.isprintable())
    print(str2.isprintable())
    print(str3.isprintable())

    程序运行结果:

    True
    False
    False

    32.0 isspace()函数

    描述: 检测字符串是否只由空格组成。

    语法:str.isspace()  -> bool   返回值为布尔类型(True,False)

    • 若字符串中只包含空格,则返回 True,否则返回 False。

    程序示例:

    str1 = "   "#空格
    str2 = "i love python" 
    print(str1.isspace())
    print(str2.isspace())
    print(str2[1].isspace()) #字符串str2 的第二个字符为空格

    程序运行结果:

    True
    False
    True

    33.0 istitle()函数

    描述:检测判断字符串中所有单词的首字母是否为大写,且其它字母是否为小写,字符串中可以存在其它非字母的字符。

    语法:str.istitle()  -> bool  返回值为布尔类型(True,False)

    • 若字符串中所有单词的首字母为大写,且其它字母为小写,则返回 True,否则返回 False.

    程序示例:

    str1 = "I Love Python" #各单词的首字母均为大写,其余字母为小写
    str2 = "I love python" 
    str3 = "I LOVE PYTHON"
    str4 = "我爱Python"  #存在其它非字母字符,
    print(str1.istitle())
    print(str2.istitle())
    print(str3.istitle())
    print(str4.istitle())

    程序运行结果:

    True
    False
    False
    True

     

     

     

     

    解决字符串两端:

    34.0  strip()函数

    描述:从字符串str中去掉在其左右两边chars中列出的字符。

    注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。

    语法: str.strip(chars)  -> str 返回一个新的字符串

    • chars —— 要去除的字符  默认为空格或换行符。

    程序示例:

    str = "123456789321"
    print(str.strip("123")) #除去123,对于字符串str右边,1 在 "123"中去除,2在"123"中去除,同理3也去除,但9不在"123"中,去除结束
    str1 = "my name is ymyyyy"
    print(str1.strip("my"))  #"my" 无空格,字母n前的空格不去掉。
    print(str1.strip("my ")) #"my "有空格,所以str1左边字母n前的空格被去掉。

    程序运行结果:

    456789
     name is 
    name is

    35.0 lstrip()函数

    描述:从字符串str中去掉在其左边chars中列出的字符。

    注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。

    语法:str.lstrip(chars)  -> str 返回一个新的字符串

    • chars —— 要去除的字符  默认为空格或换行符。

    程序示例:

    str1 = "bacjabck123kluabc"
    print(str1.lstrip("abc"))  #只去掉左边的"bac",左边第4个字符j不在"abc"中,去除结束
    str2 = "12578asdfgh12"
    print(str2.lstrip("12")) #只去掉字符串str2左边的 12

    程序运行结果:

    jabck123kluabc
    578asdfgh12

    36. rstrip()函数

    描述:从字符串str中去掉在其右边chars中列出的字符。

    注:chars传入的是一个字符数组,编译器去除两端所有相应的字符,直到出现第一个在chars中不匹配的字符。详看示例。

    语法:str.rstrip(chars)  -> str 返回一个新的字符串

    • chars —— 要去除的字符  默认为空格或换行符。

    程序示例:

    str1 = "abcjabck123kluabcca"
    print(str1.rstrip("abc"))  #只去掉右边的"abcca",右边第6个字符u不在"abc"中,去除结束
    str2 = "12578asdfgh11112"
    print(str2.rstrip("12")) #只去掉字符串str2右边的 11112

    程序运行结果:

    abcjabck123klu
    12578asdfgh

     

     

    解决 制表 翻译 问题:

    37.0 maketrans()函数

    描述:制作翻译表,删除表,常与translate()函数连用。 即:返回用于str.translate()函数翻译的的转换表。

    语法:maketrans(x, y=None, z=None, /)  返回可用于str.translate()函数的转换表

    str.maketrans(x,y,z)  #返回的是Unicode映射的字典。
    
    bytes.maketrans(x,y)  #返回的是bytes类型.
    
    bytearray.maketrans(x,y)  #返回的是bytes类型。
    • 如果只有一个参数x,它必须是一个字典且为Unicode形式的映射。
    • 如果有两个参数x和y,它们必须是长度相等的字符串,并且在结果映射中,x中的每个字符都将映射到y中相同位置的字符(Unicode形式的映射)。
    • 如果有三个参数x,y和z.  x和y用法同上,z为指定要删除的字符串,其结果中的字符将一一映射为:None。
    • bytes.maketrans(x,y) 和  bytearray.maketrans(x,y) 必须要有x和y两个参数。
      注:z的长度可以和x和y不同。

    str.maketrans(x,y,z)形式:

    程序示例:

    s = "123456789"
    
    #只有参数x,且x为字典。
    map1 = str.maketrans({"1":"a","2":"b","3":"c"}) 
    #单字符"1" "2" "3"对应的Unicode编码值分别为:49,50,51
    #制作翻译表,将 字符串s 中的单字符"1"替换为单字符"a",单字符"2"替换为单字符"b",一一对应。
    print(map1,type(map1),ord("1"),ord("2"),ord("3")) #map1返回的是一个Unicode形式映射的字典
    
    #只有参数x和参数y
    map2 = str.maketrans("123","abc")
    #单字符"1" "2" "3"对应的Unicode编码值如上,单字符"a" "b" "c"对应的Unicode编码值分别为:97,98,99
    #制作翻译表,将字符串s中的单字符"1"替换为单字符"a",单字符"2"替换为单字符"b",一一对应
    print(map2,type(map2),ord("a"),ord("b"),ord("c"))#map2返回的也是一个Unicode形式映射的字典
    
    #有x,y,z三个参数
    map3 = str.maketrans("123","abc","56k") 
    #字符串"123"和"abc"含义如上。字符串"567"为 字符串s 要删除的字符,即制作删除表。
    #单字符"5" "6" "k"对应的Unicode编码值分别为:53,54,107
    print(map3,type(map3),ord("5"),ord("6"),ord("k")) #map3返回的也是一个Unicode形式映射的字典
    

    程序运行结果:

    49: 'a', 50: 'b', 51: 'c'} <class 'dict'> 49 50 51
    {49: 97, 50: 98, 51: 99} <class 'dict'> 97 98 99
    {49: 97, 50: 98, 51: 99, 53: None, 54: None, 107: None} <class 'dict'> 53 54 107
    In [6]:
    

    bytes.maketrans(x,y)形式:

    程序示例:

    map4 = bytes.maketrans(b"123",b"abc")
    print(type(b"123"),type(b"abc"),type(map4),map4)

    程序运行结果:

    <class 'bytes'> <class 'bytes'> <class 'bytes'> 
    
    b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

    bytearray.maketrans(x,y)形式:

    程序示例:

    map5 = bytearray.maketrans(b"123",b"abc")
    print(type(b"123"),type(b"abc"),type(map5),map5)

    程序运行结果:

    <class 'bytes'> <class 'bytes'> <class 'bytes'> 
    
    b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'

    38.0 translate()函数

    描述:过滤(删除),翻译字符串。即根据maketrans()函数给出的字符映射转换表来转换字符串中的字符。

    注:translate()函数是先过滤(删除),再根据maketrans()函数返回的转换表来翻译。

    语法:str.translate(table)  -> str 返回一个字符串

    str.translate(table)
    bytes.translate(table, deletechars)    
    bytearray.translate(table, deletechars) 
    • table —— 转换表,转换表是通过maketrans()函数转换而来。
    • deletechars —— 字符串中要过滤(删除)的字符。

    程序示例:

    s = "123456789abc"
    s1 = b"123456789abc"
    #只有参数x,且x为字典。
    map1 = str.maketrans({"1":"a","2":"b","3":"c"}) 
    #单字符"1" "2" "3"对应的Unicode编码值分别为:49,50,51
    #制作翻译表,将 字符串s 中的单字符"1"替换为单字符"a",单字符"2"替换为单字符"b",一一对应。
    print(map1,type(map1),ord("1"),ord("2"),ord("3")) #map1返回的是一个Unicode形式映射的字典
    
    #只有参数x和参数y
    map2 = str.maketrans("123","abc")
    #单字符"1" "2" "3"对应的Unicode编码值如上,单字符"a" "b" "c"对应的Unicode编码值分别为:97,98,99
    #制作翻译表,将字符串s中的单字符"1"替换为单字符"a",单字符"2"替换为单字符"b",一一对应
    print(map2,type(map2),ord("a"),ord("b"),ord("c"))#map2返回的也是一个Unicode形式映射的字典
    
    #有x,y,z三个参数
    map3 = str.maketrans("123","abc","56k") 
    #字符串"123"和"abc"含义如上。字符串"567"为 字符串s 要删除的字符,即制作删除表。
    #单字符"5" "6" "k"对应的Unicode编码值分别为:53,54,107
    print(map3,type(map3),ord("5"),ord("6"),ord("k")) #map3返回的也是一个Unicode形式映射的字典
    
    map4 = bytes.maketrans(b"123",b"abc")
    print(type(b"123"),type(b"abc"),type(map4),map4)
    
    print("\n")
    
    map5 = bytearray.maketrans(b"123",b"abc")
    print(type(b"123"),type(b"abc"),type(map5),map5)
    
    print("\n\n")
    
    
    print(s.translate(map1)) #将 字符串s 中的"123" 分别替换为 "abc"
    print(s.translate(map2)) #将 字符串s 中的"123" 分别替换为 "abc"
    print(s.translate(map3)) #先将 字符串s 中的字符 "5","6" ,"k"过滤(删除),再将 字符串s 中的"123" 分别翻译替换为 "abc"
    print(s1.translate(map4))
    print(s1.translate(map5))
    print(s1.translate(map4,b"78b")) #先将s1中的b"78b" 过滤(删除),再将 s1 中的b"123" 分别翻译替换为 b"abc"
    print(s1.translate(map5,b"9"))  #先将s1中的b"9" 过滤(删除),再将 s1 中的b"123" 分别翻译替换为 b"abc"

    程序运行结果:

    {49: 'a', 50: 'b', 51: 'c'} <class 'dict'> 49 50 51
    {49: 97, 50: 98, 51: 99} <class 'dict'> 97 98 99
    {49: 97, 50: 98, 51: 99, 53: None, 54: None, 107: None} <class 'dict'> 53 54 107
    
    
    <class 'bytes'> <class 'bytes'> <class 'bytes'> b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
    
    
    <class 'bytes'> <class 'bytes'> <class 'bytes'> b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0abc456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
    
    
    
    abc456789abc
    abc456789abc
    abc4789abc
    b'abc456789abc'
    b'abc456789abc'
    b'abc4569ac'
    b'abc45678abc'

     

     

     

     

    解决分割字符串问题:

    39.0 partition()函数:

    描述:根据指定的分隔符(sep)将字符串进行分割。从字符串左边开始索引分隔符sep,索引到则停止索引。

    语法: str.partition(sep) -> (head, sep, tail)  返回一个三元元组,head:分隔符sep前的字符串,sep:分隔符本身,tail:分隔符sep后的字符串。

    • sep —— 指定的分隔符。
    • 如果字符串包含指定的分隔符sep,则返回一个三元元组,第一个为分隔符sep左边的子字符串,第二个为分隔符sep本身,第三个为分隔符sep右边的子字符串。

    • 如果字符串不包含指定的分隔符sep,仍然返回一个三元元组,第一个元素为字符串本身,第二第三个元素为空字符串

    程序示例:

    str = "https://www.baidu.com/"
    print(str.partition("://")) #字符串str中存在sep"://"
    print(str.partition(","))  #字符串str中不存在sep",",返回了两个空字符串。
    print(str.partition("."))  #字符串str中存在两个"." 但索引到www后的"."  停止索引。
    print(type(str.partition("://"))) #返回的是tuple类型, 即元组类型

    程序运行结果:

    ('https', '://', 'www.baidu.com/')
    ('https://www.baidu.com/', '', '')
    ('https://www', '.', 'baidu.com/')
    <class 'tuple'>

    40.0  rpartition()函数

    描述:根据指定的分隔符(sep)将字符串进行分割。从字符串右边(末尾)开始索引分隔符sep,索引到则停止索引。

    语法:str.rpartition(sep)  -> (head, sep, tail) 返回一个三元元组,head:分隔符sep前的字符串,sep:分隔符本身,tail:分隔符sep后的字符串。

    • sep —— 指定的分隔符。
    • 如果字符串包含指定的分隔符sep,则返回一个三元元组,第一个为分隔符sep左边的子字符串,第二个为分隔符sep本身,第三个为分隔符sep右边的子字符串。

    • 如果字符串不包含指定的分隔符sep,仍然返回一个三元元组,第一个元素为字符串本身,第二第三个元素为空字符串。

    注:rpartition()函数与partition()函数用法相似,rpartition()函数从右边(末尾)开始索引,partition()函数从左边开始索引。

    程序示例:

    str = "https://www.baidu.com/"
    print(str.rpartition("://")) #字符串str中存在sep"://"
    print(str.rpartition(","))  #字符串str中不存在sep",",返回了两个空字符串。
    print(str.rpartition("."))  #字符串str中存在两个"." 但索引是从右边(末尾)开始,索引到du后的"."  停止索引。
    print(type(str.partition("://"))) #返回的也是tuple类型, 即元组类型

    程序运行结果:

    ('https', '://', 'www.baidu.com/')
    ('', '', 'https://www.baidu.com/')
    ('https://www.baidu', '.', 'com/')
    <class 'tuple'>

    41.0  split()函数

    描述:拆分字符串。通过指定分隔符sep对字符串进行分割,并返回分割后的字符串列表。

    语法: str.split(sep=None, maxsplit=-1)  -> list of strings  返回 字符串列表  或str.split(sep=None, maxsplit=-1)[n]  

    • sep —— 分隔符,默认为空格,但不能为空即(")。
    • maxsplit —— 最大分割参数,默认参数为-1。
    • [n] —— 返回列表中下标为n的元素。列表索引的用法。

    程序示例:

    str1 = "i love python"
    str2 = "https://www.baidu.com"
    str3 = "script<i love python>script"
    str4 = "i \n love \n python"
    print(str1.split()) #默认空格分割。
    print(str2.split("."))#以"."为分隔符,maxsplit默认为-1
    print(str2.split(".",-1)) #maxsplit为-1
    print(str2.split(".",1)) #以"."为分隔符,分割一次。
    print(str2.split(".")[1]) #分割后,输出列表中下标为1的元素
    print(str3.split("<")[1].split(">")[0])
    print(str4.split("\n")) #可用于去掉字符串中的"\n" "\t"等

    程序运行结果:

    ['i', 'love', 'python']
    ['https://www', 'baidu', 'com']
    ['https://www', 'baidu', 'com']
    ['https://www', 'baidu.com']
    baidu
    i love python
    ['i ', ' love ', ' python']

    42.0  rsplit()函数

    描述:拆分字符串。通过指定分隔符sep对字符串进行分割,并返回分割后的字符串列表,类似于split()函数,只不过 rsplit()函数是从字符串右边(末尾)开始分割。

    语法: str.rsplit(sep=None, maxsplit=-1)  -> list of strings  返回 字符串列表  或str.rsplit(sep=None, maxsplit=-1)[n]  

    • sep —— 分隔符,默认为空格,但不能为空即(")。
    • maxsplit —— 最大分割参数,默认参数为-1。
    • [n] —— 返回列表中下标为n的元素。列表索引的用法。

    程序示例:

    str = "https://www.baidu.com"
    print(str.rsplit()) #默认空格分割。
    print(str.rsplit(".")) #以"."为分隔符,maxsplit默认为-1
    print(str.rsplit(".",1)) #以"."为分隔符,分割一次。从字符串右边(末尾)开始分割。
    print(str.rsplit(".",1)[1]) #分割后,输出列表中下标为1的元素

    程序运行结果:

    ['https://www.baidu.com']
    ['https://www', 'baidu', 'com']
    ['https://www.baidu', 'com']
    com

    43.0 splitlines()函数

    描述:按照('\n', '\r', \r\n'等)分隔,返回一个包含各行作为元素的列表,默认不包含换行符。

    符号 描述
    \n 换行符
    \r 回车符
    \r\n 回车+换行

    语法:str.splitlines(keepends) -> list of strings  返回 字符串列表

    • keepends —— 默认参数为False ,译为 不保留换行符。参数为True , 译为 保留换行符。

    程序示例:

    s1 = """i
    love
    python
    """
    s2 = "i\nlove\npython\n" #与s1等效。
    s3 = "123\n456\r789\r\nabc"
    print(s1.splitlines(True)) 
    print(s1.splitlines()) #keepends 默认为False
    print(s1.splitlines(False))
    print(s2.splitlines())
    print(s3.splitlines()) #遇到("\n"  "\r"  "\r\n"等)即分隔。

    程序运行结果:

    ['i\n', 'love\n', 'python\n']
    ['i', 'love', 'python']
    ['i', 'love', 'python']
    ['i', 'love', 'python']
    ['123', '456', '789', 'abc']

    44.0 join()函数

    描述:将iterable变量的每一个元素后增加一个str字符串。

    语法: str.join(iterable)  -> str  返回字符串 即:返回一个以str作为分隔符,将iterable中的各元素合并连接成一个新的字符串。

    • str——分隔符。可以为空。
    • iterable—— 要连接的变量 ,可以是 字符串,元组,字典,列表等。

    程序示例:

    #对列表进行操作
    l = ["1","2","3"]
    print(" ".join(l)) #以空格为分隔符
    print(",".join(l)) #以逗号为分隔符
    
    
    #对字符串进行操作
    str = "python"
    print(" ".join(str)) #以空格为分隔符
    print(",".join(str)) #以逗号为分隔符
    
    #对字典进行操作
    d = {"a":1,"b":2,"c":3}
    print(" ".join(d)) #以空格为分隔符
    print(",".join(d)) #以逗号为分隔符
    
    #对元组进行操作
    s = ("1","2","3")
    print(" ".join(s)) #以空格为分隔符
    print(",".join(s)) #以逗号为分隔符

    程序运行结果:

    1 2 3
    1,2,3
    
    p y t h o n
    p,y,t,h,o,n
    
    b c a
    b,c,a
    
    1 2 3
    1,2,3

     

     

     

    解决替换问题:

    45.0 replace()函数:

    描述:返回字符串str的副本,所有old子字符串被替换为new字符串。

    语法:str.replace(old, new, count) -> str 返回字符串str的副本

    • old —— 将被替换的子字符串。
    • new —— 新子字符串,用于替换old子字符串。
    • count —— 替换的次数,默认全部替换。

    程序示例:

    s = "i love python python "
    print(s.replace("o","w")) #默认字符串中的全部"o" 全部替换为"w"
    print(s.replace("o","w",2)) #只替换掉前两个子字符串 "o"
    print(s.replace("python","c++"))  #子字符串可以是多个字符。
    print(s.replace("python","c++",1))

    程序运行结果:

    i lwve pythwn pythwn 
    i lwve pythwn python 
    i love c++ c++ 
    i love c++ python 

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 本文主要介紹PostgreSQL 的行转列、列转行以及字符串切割函数,实际业务中对前两个均有使用,并配有实际例子参考。 1、字符串列转行 ...实际业务中有什么需要这种字符串函数的呢? -------------------...

    本文主要介紹PostgreSQL 的行转列、列转行以及字符串切割函数,实际业务中对前两个均有使用,并配有实际例子参考。

    1、字符串列转行

    string_agg,某些地方也称为字符串聚合操作。

    如果需要按照一个字符串按照某个分割符拼接起来。

    例如:

    按照id把字符串按照指定分隔符拼接起来。实际业务中有什么需要这种字符串函数的呢?

     

     

    ---------------------------------update 2020年1月16日17:05:59----------------------------

    这里学习一个和系统表有关的查询,用到了stragg ,用法之妙,自己体会。

     SELECT string_agg(att.attname,',' order by attrnums) as distribution
            FROM gp_distribution_policy a,pg_attribute att
            WHERE a.localoid ='sor.wpp_adefect_f_n'::regclass
          and a.localoid = att.attrelid
          and att.attnum = any(a.attrnums);
     

     select attname,attnum from pg_attribute where attrelid='26625' order by attnum asc;
    
    

     可以看到每个表上除了可见的列之外还有attrnums  < 1的列。这几个列用来实现mvcc、表明数据的物理位置、数据所处segID...

    select string_agg(attname,',' order by attnum) from pg_attribute where attrelid='26625' and attnum >0;

    将所有可见列查询出来拼接sql,屡试不爽。

     

    2、字符串行转列

    regexp_split_to_table(stringpattern [, flags ])

    regexp_split_to_table(stringpattern [, flags ])。如果没有与pattern的匹配,该函数返回string。如果有至少有一个匹配,对每一个匹配它都返回从上一个匹配的末尾(或者串的开头)到这次匹配开头之间的文本。当没有更多匹配时,它返回从上一次匹配的末尾到串末尾之间的文本。flags参数是一个可选的文本串,它包含零个或更多单字母标志,这些标识可以改变该函数的行为。这个标识有很多,具体可查看http://postgres.cn/docs/9.6/functions-matching.html。不过该参数是可以省略的,我看到很少用这个flg的。

    E是Posix样式转义字符串的前缀。现代Postgres通常不需要这个,此处的E可有可无。

    --\\s+ 可匹配至少一个空白字符。
    --\\s 表示空白字符。包括,空格,制表符等
    --\s*
    --*是贪婪模式,会尽可能匹配更多的字符
    --而*?是非贪婪模式 会尽量匹配少的字符
    SELECT foo FROM regexp_split_to_table('the quick brown fox jumps over the lazy dog', E'\\s') AS foo;


    SELECT foo FROM regexp_split_to_table('the quick brown fox', E'\\s*?') AS foo;

    关于正则表达式计划以专题来学习

    几个元字符是需要记住的:

    -------------------------------------update 2019年10月23日11:37:32---------------------------------------------------------------

    imagePath字符串切割处理

    如果想将如上的长列转换为多行,可通过regexp_split_to_table()来处理。处理的结果如下。

    sql形如:

    select  regexp_split_to_table(image_path,E'\\  ') pattern from (select distinct panel_id,  'Y:\\' || prod_id || '\\' || substring( glass_id, 0, 6 )|| '\\' || substring( glass_id, 0, 9 )|| '\\' || panel_id || '\\' || 'big' || '   '||
       'Y:\\' || prod_id || '\\' || substring( glass_id, 0, 6 )|| '\\' || substring( glass_id, 0, 9 )|| '\\' || panel_id || '\\' || 'small'|| '   '||
     	 'Y:\\' || prod_id || '\\' || substring( glass_id, 0, 6 )|| '\\' || substring( glass_id, 0, 9 )|| '\\' || panel_id || '\\' || 'IMAGE' as image_path 
    from tabelName
    where 1 = 1
    and time>= '2019-09-09 00:00:00'
    and time<= '2019-09-10 08:00:00'
    )A

    3、字符串分割符

    split_part(str,',',1)

    select split_part('A3332-22222222','-',1);      -  >  A3332

      
    select split_part('A3332-22222222','-',2);      - > 22222222

    这个比较简单一看便知道了。

     

    展开全文
  • 随机生成字符串函数

    千次阅读 2018-03-10 20:34:15
    1、随机生成字符串函数(一定范围的字符串) 2、随机获取一定范围的数据公式 1、随机生成字符串函数(一定范围的字符串) char *rand_str(char *str) //随机生成字符串函数 { int i,n; n=rand()%5; for(i=0;...

    目录

    1、随机生成字符串函数(一定范围的字符串)

    2、随机获取一定范围的数据公式


    1、随机生成字符串函数(一定范围的字符串)

    char *rand_str(char *str) //随机生成字符串函数
    
    {
    	int i,n;
    	n=rand()%5;
    	for(i=0;i<n+4;++i)
    	{
    		str[i]='a'+rand()%26;
    	}
    	str[++i]='\\0';
    	return str;
    }

    2、随机获取一定范围的数据公式

    rand()%(n-m+1)+m

     

    展开全文
  • 目录 subst patsubst strip findstring filter filter-out ...字符串函数实例 subst $(subst <from>,<to>,<text>) 名称:字符串替换函数——subst。 功能:把字串<text>...
  • MySQL 字符串函数:字符串截取

    万次阅读 2009-03-12 14:08:00
    MySQL 字符串函数:字符串截取 MySQL 字符串截取函数:left(), right(), substring(), substring_index()。还有 mid(), substr()。其中,mid(), substr() 等价于 substring() 函数,substring() 的功能非常强大和...
  • Java 常用字符串函数

    千次阅读 2014-07-31 16:10:23
    java中的字符串也是一连串的字符。但是与许多其他的计算机语言将字符串作为字符数组处理不同,Java将字符串作为String类型对象来处理。将字符串作为内置的对象处理允许Java提供十分丰富的功能特性以方便处理字符串。...
  • PHP字符串函数

    千次阅读 2020-04-16 09:06:22
    本文总结了字符串的常见函数,希望能对您有所帮助。
  • 字符串函数 日期函数 条件函数 加密函数 数学函数 abs(n): 求一个数字的绝对值 sqrt(n): 求一个数字的 正的算术平方根 mod(n, m) : 求 n/m 的 余数 ceil(n) : 对一个数字 向上 取整 3.1 ----> 4 floor(n) : 向...
  • SQL截取字符串,SQL分割字符串函数

    千次阅读 2019-02-19 10:14:22
    -- 截取字符串函数: -- SUBSTRING_INDEX(str, delim, count) -- str: 要处理的字符串。 -- delim: 分割符,将str分割成两部分。 -- count: 计数(使用第几个分隔符)。 如果为正数,则从左开始数,返回分割后左边...
  • 判断回文字符串 (20 分) 本题要求编写函数,判断给定的一串字符是否为“回文”。...函数palindrome判断输入字符串char *s是否为回文。若是则返回true,否则返回false。 裁判测试程序样例: #include &lt;st...
  • 润乾报表-字符串函数

    千次阅读 2016-09-30 11:03:04
    数据集函数 1. avg() 函数说明: 从数据集中,从满足条件的记录中,算出给定字段或表达式的平均值 语法: datasetName.avg(selectExp{,filterExp{,rootGroupExp{,containNull}}}) 参数说明: selectExp 需要计算...
  • hive常用字符串函数

    万次阅读 2015-09-14 15:38:56
    字符串长度函数:length   Java代码  语法: length(string A)  返回值: int  说明:返回字符串A的长度  举例:  hive> select length(‘abcedfg’) from dual;  7        字符串反转...
  • ORACLE 字符串函数

    千次阅读 2018-07-19 09:21:15
    字符串函数 1、INSTR() 格式一:instr(string1,string2) 返回string2第一次出现在string1的位置,若没有出现,则显示0 select instr('hello','lc') from dual; // 0 select instr('hello','lo') from dual; // ...
  • strlen求字符串长度。 strcmp比较2个字符串是否一样。 strcat字符串连接操作。 strcpy字符串拷贝操作。 strncat字符串连接操作(前n个字符)。 strncpy字符串拷贝操作(前n个字符)。 strchr查询字串。 strstr 查询子串...
  • mysql 字符串函数

    千次阅读 2018-06-15 01:06:42
    1)说明:将字符串连接,可以是一个或多个字符串。若都是非二进制的字符,那么返回的结果也是非二进制的。若包含任何二进制字符,那么结果则是二进制的。若是数值型的,也将转换成非二进制的形式。若其中任意一个...
  • postgresql 字符串函数

    千次阅读 2019-08-01 16:36:46
    字符串函数:postgresql中的字符串函数有:计算字符串长度函数、字符串合并函数、字符串替换函数、字符串比较函数、查找指定字符串位置函数等。 1、计算字符串字符数和字符串长度的函数:char_length(str)和...
  • hive字符串函数

    万次阅读 2016-05-31 22:57:40
    1. 字符串长度函数:length 语法: length(string A) 返回值: int 说明:返回字符串A的长度 举例: hive> select length('abcedfg') from lxw_dual; 7 2. 字符串反转函数:reverse 语法: reverse...
  • Hive字符串函数

    千次阅读 2018-04-02 11:00:50
    (1)length('abcedfg') 作用:返回字符串的长度 (2)reverse('abcedfg') 作用:返回字符串的反转结果(3)concat(‘abc’,'def’,'gh’) 作用:返回输入字符串连接后的结果,支持任意个输入字符串 concat_ws(‘,’,'...
  • 能否理解为两个字符串的对应元素逐个比较,谁首先出现ASC码值小于对方的元素。就说:这个元素小于另一个元素? 例如:"abcdfeg"小于“z”“abcd”小于“abcccccccc” 以及“24 XXXXXXXXXX”小于“5”? 如果我理解的...
  • pandas字符串函数

    千次阅读 2017-05-22 21:05:58
    pandas中矢量化的字符串函数问题: 通过Series的map函数,所有字符串和正则表达式方法都能被应用于各个值(传入lambda表达式或其他函数),但是如果存在NA就会报错。解决: Series有一些能够跳过NA值得字符串操作...
  • Hive 字符串函数

    千次阅读 2017-11-06 20:16:55
    下表为Hive内置的字符串函数,具体的用法可以参见本文的下半部分。 返回类型 函数名 描述 int ascii(string str) 返回str第一个字符串的数值 string base64(binary bin) ...
  • matlab字符串函数

    千次阅读 2018-05-29 17:03:46
    字符串操作函数:eval() :执行运行字符串的表达式 num2str() :将数字转换为字符串,由于主要接触的还是在科学计算方面,使用较多的还是在多变量批量命名上。类似的函数还有int2str,mat2str,str2double等,...
  • package com.zy.hive.udf;import java.util.UUID;import org.apache.hadoop.hive.ql.exec.Description;import org.apache.hadoop.hive.ql.exec.UDF;import org.apache.hadoop.hive.ql.udf.UDFType;import org.apache
  • arduino字符串函数

    万次阅读 2015-01-30 23:22:20
    arduino教程:字符串函数 如果你需要操作文本。比如拷贝,增加文本,和定义文本数量。 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 String text1=...
  • db2字符串函数

    万次阅读 2012-11-01 13:57:18
    转载于:http://www.cnblogs.com/zhaoshuangshuang/archive/2012/09/23/2699172.html   DB2一个汉字占3个字节,Oracle占两个字节。 Oracle: ...SQL> select lengthb('中') from dual;...db2 =>
  • sybase字符串函数

    千次阅读 2012-09-29 15:48:51
    sybase字符串函数 文章分类:Java编程 长度和语法分析 datalength(char_expr)  在char_expr中返回字符的长度值,忽略尾空 substring(expression,start,length)  返回部分字符串 right(char_expr,int_...
  • VBA字符串函数

    万次阅读 2010-11-03 12:57:00
    原文链接: http://we1818.javaeye.com/blog/600120 http://blog.csdn.net/ljnxd1/archive/2008/07/16/2663268.aspx
  • awk 字符串函数

    万次阅读 2010-03-29 21:24:00
    awk提供了许多强大的字符串函数,见下表:awk内置字符串函数gsub(r,s) 在整个$0中用s替代rgsub(r,s,t) 在整个t中用s替代rindex(s,t) 返回s中字符串t的第一位置length(s) 返回s长度match(s,r) 测试s是否包含匹配...

空空如也

1 2 3 4 5 ... 20
收藏数 209,155
精华内容 83,662
关键字:

字符串函数