str(字符串)功能详解

class str(basestring):
    """
    str(object=‘‘) -> string
    
    Return a nice string representation of the object.
    If the argument is a string, the return value is the same object.
    """
    def capitalize(self):  
        """ 首字母变大写 """
        """
        S.capitalize() -> string
        
        Return a copy of the string S with only its first character
        capitalized.
        """
        return ""
        print (str.capitalize(‘ads‘)) Ads 首字母变大写
        
    def center(self, width, fillchar=None):  
        """ 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """
        """
        S.center(width[, fillchar]) -> string
        
        Return S centered in a string of length width. Padding is
        done using the specified fill character (default is a space)
        """
        return ""
        print (str.center(‘adsads‘,50,‘*‘,)) **********************adsads********************** 内容居中多少长度填充什么字符

def count(self, sub, start=None, end=None):  
        """ 子序列个数 """
        """
        S.count(sub[, start[, end]]) -> int
        
        Return the number of non-overlapping occurrences of substring sub in
        string S[start:end].  Optional arguments start and end are interpreted
        as in slice notation.
        """
        return 0
        print (str.count(‘sada‘,‘a‘,)) 2 查看字符中相同对象的个数

def decode(self, encoding=None, errors=None):  
        """ 解码 """
        """
        S.decode([encoding[,errors]]) -> object
        
        Decodes S using the codec registered for encoding. encoding defaults
        to the default encoding. errors may be given to set a different error
        handling scheme. Default is ‘strict‘ meaning that encoding errors raise
        a UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘
        as well as any other name registered with codecs.register_error that is
        able to handle UnicodeDecodeErrors.
        """
        return object()

def encode(self, encoding=None, errors=None):  
        """ 编码,针对unicode """
        """
        S.encode([encoding[,errors]]) -> object
        
        Encodes S using the codec registered for encoding. encoding defaults
        to the default encoding. errors may be given to set a different error
        handling scheme. Default is ‘strict‘ meaning that encoding errors raise
        a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and
        ‘xmlcharrefreplace‘ as well as any other name registered with
        codecs.register_error that is able to handle UnicodeEncodeErrors.
        """
        return object()

def endswith(self, suffix, start=None, end=None):  
        """ 是否以 xxx 结束 """
        """
        S.endswith(suffix[, start[, end]]) -> bool
        
        Return True if S ends with the specified suffix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        suffix can also be a tuple of strings to try.
        """
        return False
        print (str.endswith(‘asd‘,‘d‘)) True 是否是d结束
        
    def expandtabs(self, tabsize=None):  
        """ 将tab转换成空格,默认一个tab转换成8个空格 """
        """
        S.expandtabs([tabsize]) -> string
        
        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        """
        return ""
        print (str.expandtabs(‘ abs ‘))  abs  将tab转换成空格
        
    def find(self, sub, start=None, end=None):  
        """ 寻找子序列位置,如果没找到,返回 -1 """
        """
        S.find(sub [,start [,end]]) -> int
        
        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0
        print (str.find(‘asd‘,‘q‘)) 查找子序列位置,好不到返回-1

def format(*args, **kwargs): # known special case of str.format
        """ 字符串格式化,动态参数,将函数式编程时细说 """
        """
        S.format(*args, **kwargs) -> string
        
        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces (‘{‘ and ‘}‘).
        """
        pass

def index(self, sub, start=None, end=None):  
        """ 子序列位置,如果没找到,报错 """
        S.index(sub [,start [,end]]) -> int
        
        Like S.find() but raise ValueError when the substring is not found.
        """
        return 0
        print (str.index(‘asd‘,‘s‘)) 查找子序列位置 找不到报错

def isalnum(self):  
        """ 是否是字母和数字 """
        """
        S.isalnum() -> bool
        
        Return True if all characters in S are alphanumeric
        and there is at least one character in S, False otherwise.
        """
        return False
        
    
    def isalpha(self):  
        """ 是否是字母 """
        """
        S.isalpha() -> bool
        
        Return True if all characters in S are alphabetic
        and there is at least one character in S, False otherwise.
        """
        return False
        print (str.isalnum(‘1asd‘,)) 是否是字母

def isdigit(self):  
        """ 是否是数字 """
        """
        S.isdigit() -> bool
        
        Return True if all characters in S are digits
        and there is at least one character in S, False otherwise.
        """
        return False
        print (str.isdigit(‘1111‘)) 是否是数字

def islower(self):  
        """ 是否小写 """
        """
        S.islower() -> bool
        
        Return True if all cased characters in S are lowercase and there is
        at least one cased character in S, False otherwise.
        """
        return False
        print (str.islower(‘aBs‘)) 是否小写 False

def isspace(self):  
        """
        S.isspace() -> bool
        
        Return True if all characters in S are whitespace
        and there is at least one character in S, False otherwise.
        """
        return False
        print (str.isspace(‘   ‘))是否所有字符串是空格 True

def istitle(self):  
        """
        S.istitle() -> bool
        
        Return True if S is a titlecased string and there is at least one
        character in S, i.e. uppercase characters may only follow uncased
        characters and lowercase characters only cased ones. Return False
        otherwise.
        """
        return False
        print (str.istitle(‘s‘))Ture 开头是否大写
        
    def isupper(self):  
        """
        S.isupper() -> bool
        
        Return True if all cased characters in S are uppercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

def join(self, iterable):  
        """ 连接 """
        """
        S.join(iterable) -> string
        
        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""
        print (str.join(‘asd‘,‘dda‘,)) dasddasda 字符串连接

def ljust(self, width, fillchar=None):  
        """ 内容左对齐,右侧填充 """
        """
        S.ljust(width[, fillchar]) -> string
        
        Return S left-justified in a string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""
        print (str.ljust(‘asd‘,100,‘*‘,)) asd**************************************************** 左对齐 右侧填充
        
    def lower(self):  
        """ 变小写 """
        """
        S.lower() -> string
        
        Return a copy of the string S converted to lowercase.
        """
        return ""
        print (str.lower(‘ASD‘,)) asd 变小写

def lstrip(self, chars=None):  
        """ 移除左侧空白 """
        """
        S.lstrip([chars]) -> string or unicode
        
        Return a copy of the string S with leading whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        If chars is unicode, S will be converted to unicode before stripping
        """
        return ""
        print (str.lstrip(‘ *asd‘,‘ *‘,)) 移除左侧开头的值,一般用于移除空白
        
    def partition(self, sep):  
        """ 分割,前,中,后三部分 """
        """
        S.partition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.
        """
        pass
        print (str.partition(‘asd‘,‘a‘,)) (‘‘, ‘a‘, ‘sd‘) 以头,中,尾进行分割字符
        
    def replace(self, old, new, count=None):  
        """ 替换 """
        """
        S.replace(old, new[, count]) -> string
        
        Return a copy of string S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""
        print (str.replace(‘adds‘,‘d‘,‘a‘)) aaas 以**替换。。

def rfind(self, sub, start=None, end=None):  
        """
        S.rfind(sub [,start [,end]]) -> int
        
        Return the highest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0
        print (str.rfind(‘asd‘,‘a‘,)) 0 查看字符串位置

def rindex(self, sub, start=None, end=None):  
        """
        S.rindex(sub [,start [,end]]) -> int
        
        Like S.rfind() but raise ValueError when the substring is not found.
        """
        return 0
        print (str.rindex(‘asd‘,‘s‘,0,2,))1 查看索引
        
    def rjust(self, width, fillchar=None):  
        """
        S.rjust(width[, fillchar]) -> string
        
        Return S right-justified in a string of length width. Padding is
        done using the specified fill character (default is a space)
        """
        return ""
        print (str.rjust(‘asd‘,10,‘*‘))  *******asd 从左对齐多少长度,以什么填充

def rpartition(self, sep):  
        """
        S.rpartition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, starting at the end of S, and return
        the part before it, the separator itself, and the part after it.  If the
        separator is not found, return two empty strings and S.
        """
        pass

def rsplit(self, sep=None, maxsplit=None):  
        """
        S.rsplit([sep [,maxsplit]]) -> list of strings
        
        Return a list of the words in the string S, using sep as the
        delimiter string, starting at the end of the string and working
        to the front.  If maxsplit is given, at most maxsplit splits are
        done. If sep is not specified or is None, any whitespace string
        is a separator.
        """
        return []
        print (str.rsplit(‘asd‘,‘s‘))[‘a‘, ‘d‘]以什么进行切割并去除

def rstrip(self, chars=None):  
        """
        S.rstrip([chars]) -> string or unicode
        
        Return a copy of the string S with trailing whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        If chars is unicode, S will be converted to unicode before stripping
        """
        return ""
        print (str.rstrip(‘asdb‘,‘b‘)) asd 去除掉最后一位值

def split(self, sep=None, maxsplit=None):  
        """ 分割, maxsplit最多分割几次 """
        """
        S.split([sep [,maxsplit]]) -> list of strings
        
        Return a list of the words in the string S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are removed
        from the result.
        """
        return []
        print (str.split(‘asd‘,‘s‘))  [‘a‘, ‘d‘] 以什么进行切割并去除

def splitlines(self, keepends=False):  
        """ 根据换行分割 """
        """
        S.splitlines(keepends=False) -> list of strings
        
        Return a list of the lines in S, breaking at line boundaries.
        Line breaks are not included in the resulting list unless keepends
        is given and true.
        """
        return []

def startswith(self, prefix, start=None, end=None):  
        """ 是否起始 """
        """
        S.startswith(prefix[, start[, end]]) -> bool
        
        Return True if S starts with the specified prefix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        prefix can also be a tuple of strings to try.
        """
        return False
        print (str.startswith(‘asd‘,‘s‘)) s是否开头值

def strip(self, chars=None):  
        """ 移除两段空白 """
        """
        S.strip([chars]) -> string or unicode
        
        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        If chars is unicode, S will be converted to unicode before stripping
        """
        return ""
        print (str.strip(‘*asd ‘,‘*‘)) 移除两个*

def swapcase(self):  
        """ 大写变小写,小写变大写 """
        """
        S.swapcase() -> string
        
        Return a copy of the string S with uppercase characters
        converted to lowercase and vice versa.
        """
        return ""
        print (str.swapcase(‘Asd‘)) aSD 大小写转换

def title(self):  
        """
        S.title() -> string
        
        Return a titlecased version of S, i.e. words start with uppercase
        characters, all remaining cased characters have lowercase.
        """
        return ""
        print (str.title(‘asd‘)) Asd 开头大写

def translate(self, table, deletechars=None):  
        """
        转换,需要先做一个对应表,最后一个表示删除字符集合
        intab = "aeiou"
        outtab = "12345"
        trantab = maketrans(intab, outtab)
        str = "this is string example....wow!!!"
        print str.translate(trantab, ‘xm‘)
        """

"""
        S.translate(table [,deletechars]) -> string
        
        Return a copy of the string S, where all characters occurring
        in the optional argument deletechars are removed, and the
        remaining characters have been mapped through the given
        translation table, which must be a string of length 256 or None.
        If the table argument is None, no translation is applied and
        the operation simply removes the characters in deletechars.
        """
        return ""

def upper(self):  
        """
        S.upper() -> string
        
        Return a copy of the string S converted to uppercase.
        """
        return ""
        print(str.upper(‘asd‘)) ASD转换大写

def zfill(self, width):  
        """方法返回指定长度的字符串,原字符串右对齐,前面填充0。"""
        """
        S.zfill(width) -> string
        
        Pad a numeric string S with zeros on the left, to fill a field
        of the specified width.  The string S is never truncated.
        """
        return ""
        print(str.zfill(‘asd‘,10,)) 0000000asd 定义长度,以0填充

def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
        pass

def _formatter_parser(self, *args, **kwargs): # real signature unknown
        pass

def __add__(self, y):  
        """ x.__add__(y) <==> x+y """
        pass
        print(str.__add__(‘asd‘,‘bbq‘,)) asdbbq 两个字符串相加

def __contains__(self, y):  
        """ x.__contains__(y) <==> y in x """
        pass
        print(str.__contains__(‘asd‘,‘d‘)) True 值是否在字符串中
        
    def __eq__(self, y):  
        """ x.__eq__(y) <==> x==y """
        pass
        print(str.__eq__(‘asq‘,‘asq‘)) true 两个字符串是否相等

def __format__(self, format_spec):  
        """
        S.__format__(format_spec) -> string
        
        Return a formatted version of S as described by format_spec.
        """
        return ""

def __getattribute__(self, name):  
        """ x.__getattribute__(‘name‘) <==> x.name """
        pass

def __getitem__(self, y):  
        """ x.__getitem__(y) <==> x[y] """
        pass
        
        
    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        pass

def __getslice__(self, i, j):  
        """
        x.__getslice__(i, j) <==> x[i:j]
                   
                   Use of negative indices is not supported.
        """
        pass

def __ge__(self, y):  
        """ x.__ge__(y) <==> x>=y """
        pass
        大于等于print(str.__ge__(‘asd‘,‘as‘)) True 字符串长度
        
    def __gt__(self, y):  
        """ x.__gt__(y) <==> x>y """
        pass
        大于

def __hash__(self):  
        """ x.__hash__() <==> hash(x) """
        pass

def __init__(self, string=‘‘): # known special case of str.__init__
        """
        str(object=‘‘) -> string
        
        Return a nice string representation of the object.
        If the argument is a string, the return value is the same object.
        # (copied from class doc)
        """
        pass

def __len__(self):  
        """ x.__len__() <==> len(x) """
        pass
        字符长度
        
    def __le__(self, y):  
        """ x.__le__(y) <==> x<=y """
        pass
        小于等于
        
    def __lt__(self, y):  
        """ x.__lt__(y) <==> x<y """
        pass
        小于

def __mod__(self, y):  
        """ x.__mod__(y) <==> x%y """
        pass
        
        
    def __mul__(self, n):  
        """ x.__mul__(n) <==> x*n """
        pass
        print(str.__mul__(‘asdb‘,2,)) asdbasdb 字符串乘几倍
    
    @staticmethod # known case of __new__
    def __new__(S, *more):  
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

def __ne__(self, y):  
        """ x.__ne__(y) <==> x!=y """
        pass
        是否不相等print(str.__ne__(‘asd‘,‘asd‘)) False
        
    def __repr__(self):  
        """ x.__repr__() <==> repr(x) """
        pass

def __rmod__(self, y):  
        """ x.__rmod__(y) <==> y%x """
        pass
        从左到右除

def __rmul__(self, n):  
        """ x.__rmul__(n) <==> n*x """
        pass
        从右到左乘

def __sizeof__(self):  
        """ S.__sizeof__() -> size of S in memory, in bytes """
        pass
        字节位数

def __str__(self):  
        """ x.__str__() <==> str(x) """
        pass
        a=str.__str__(‘asd‘)
        print (type(a))
        <class ‘str‘> 定义声明字符串
str

时间: 2024-10-12 09:29:58

str(字符串)功能详解的相关文章

PHP5.2至5.6的新增功能详解

截至目前(2014.2), PHP 的最新稳定版本是 PHP5.5, 但有差不多一半的用户仍在使用已经不在维护 [注] 的 PHP5.2, 其余的一半用户在使用 PHP5.3 [注].因为 PHP 那"集百家之长"的蛋疼语法,加上社区氛围不好,很多人对新版本,新特征并无兴趣.本文将会介绍自 PHP5.2 起,直至 PHP5.6 中增加的新特征. PHP5.2 以前:autoload, PDO 和 MySQLi, 类型约束 PHP5.2:JSON 支持 PHP5.3:弃用的功能,匿名函数

Python 字符串方法详解

Python 字符串方法详解 本文最初发表于赖勇浩(恋花蝶)的博客(http://blog.csdn.net/lanphaday),如蒙转载,敬请保留全文完整,切勿去除本声明和作者信息. 在编程中,几乎90% 以上的代码都是关于整数或字符串操作,所以与整数一样,Python 的字符串实现也使用了许多拿优化技术,使得字符串的性能达到极致.与 C++ 标准库(STL)中的 std::string 不同,python 字符串集合了许多字符串相关的算法,以方法成员的方式提供接口,使用起来非常方便. 字符

PHP 5.2、5.3、5.4、5.5、5.6 对比以及功能详解

PHP 5.2.5.3.5.4.5.5.5.6 对比以及功能详解 截至目前(2014.2), PHP 的最新稳定版本是 PHP5.5, 但有差不多一半的用户仍在使用已经不在维护 [注] 的 PHP5.2, 其余的一半用户在使用 PHP5.3 [注]. 因为 PHP 那"集百家之长"的蛋疼语法,加上社区氛围不好,很多人对新版本,新特征并无兴趣. 本文将会介绍自 PHP5.2 起,直至 PHP5.6 中增加的新特征. PHP5.2 以前:autoload, PDO 和 MySQLi, 类型

使用JS截取字符串函数详解

使用JS截取字符串函数详解 JS截取字符串函数:一.函数:split();二.函数:John();三.函 数:indexOf();四.其他几种方 法:stringObject.substring(start,stop);stringObject.substr(start [, length ])... 一.函数:split() 功能:使用一个指定的分隔符把一个字符串分割存储到数组 例子: str=”jpg|bmp|gif|ico|png”; arr=theString.split(”|”); /

ServletContext作用功能详解

ServletContext作用功能详解 ServletContext,是一个全局的储存信息的空间,服务器开始, 其就存在,服务器关闭,其才释放.request,一个用户可有多个:session,一个用户一个:而servletContext,所有用户共用一 个.所以,为了节省空间,提高效率,ServletContext中,要放必须的.重要的.所有用户需要共享的线程又是安全的一些信息. 换一种方式说吧,运行在JAVA虚拟机中的每一个Web应用程序都有一个与之相关的Servlet上下文.Servle

ThinkPHP URL 路由功能详解与实例

本节内容导读 本节内容主要介绍 ThinkPHP 路由功能与 U方法的使用,分为下面几个部分: ThinkPHP URL 路由功能详解:见本页下面文字 ThinkPHP 正则路由与实例 ThinkPHP U方法:使用U方法自动生成URL超链接 ThinkPHP 3.0 版本的路由功能较 2.x 版本有较大的变更,如果您的版本是 2.x,请参阅下面的文档: ThinkPHP 2.0 URL 路由(2.0版本适用) ThinkPHP 泛路由使用详解(2.0版本适用) ThinkPHP 2.1 路由规

jdk5.0 新增的 Concurrent包主要功能详解

我们都知道,在JDK1.5之前,Java中要进行业务并发时,通常需要有程序员独立完成代码实现,当然也有一些开源的框架提供了这些功能,但是这 些依然没有JDK自带的功能使用起来方便.而当针对高质量Java多线程并发程序设计时,为防止死蹦等现象的出现,比如使用java之前的wait(). notify()和synchronized等,每每需要考虑性能.死锁.公平性.资源管理以及如何避免线程安全性方面带来的危害等诸多因素,往往会采用 一些较为复杂的安全策略,加重了程序员的开发负担.万幸的是,在JDK1

Redis的事务功能详解

Redis的事务功能详解 MULTI.EXEC.DISCARD和WATCH命令是Redis事务功能的基础.Redis事务允许在一次单独的步骤中执行一组命令,并且可以保证如下两个重要事项: >Redis会将一个事务中的所有命令序列化,然后按顺序执行.Redis不可能在一个Redis事务的执行过程中插入执行另一个客户端发出的请求.这样便能保证Redis将这些命令作为一个单独的隔离操作执行. > 在一个Redis事务中,Redis要么执行其中的所有命令,要么什么都不执行.因此,Redis事务能够保证

zabbix专题:第九章 zabbix自动发现功能详解

zabbix自动发现功能详解 对Linux有兴趣的朋友加入QQ群:476794643 在线交流 本文防盗链:http://zhang789.blog.51cto.co zabbix自动发现功能详解 网络发现简介 有100台服务器,不想一台台主机去添加,能不能让zabbix自动添加主机呢,当然可以,网络发现便是这个功能,当然前提条件是所有服务器都已经安装了agent或者snmp(其实也可以不用,鉴于我们大部分功能都用agent,所以请安装上agent),server扫描配置好的ip段,自动添加ho

jmeter 基础功能详解

jmeter 基础功能详解 thread group:包含一组线程,每个线程独立地执行测试计划. sampler:采样器,有多种不同的sample实现,用来发起各种请求,如http请求,jdbc请求,javaTest请求等等. logic controller:逻辑控制器有多种不同的实现,可以决定每个sample的执行顺序. listener:有多种不同的实现,主要用于统计测试接话运行中的数据并展示,如可以进行图形化方式展示响应时间. timer:定时器,有多种不同的实现,可用作每个请求见的停顿