Python数据类型之字符串

>>> string = 'hello'
>>> type(string)
<class 'str'>

>>> string = "hello"
>>> type(string)
<class 'str'>

>>> string = '''hello'''
>>> type(string)
<class 'str'>>>> string = """hello"""
>>> type(string)
<class 'str'>

>>> string = str("hello")
>>> type(string)
<class 'str'>

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
       """
       T.index(value, [start, [stop]]) -> integer -- return first index of value.
       Raises ValueError if the value is not present.
       """
       return 0

>>> name = 'nock'
>>> name[0];name[1]
'n'
'o'
>>> name.index('n')
0
>>> name.index('c', 0, 4)
2

>>> name = 'nockgod'
>>> name[0:7]
'nockgod'
>>> name[0:4]
'nock'
>>> name[:7]
'nockgod'
>>> name[:]
'nockgod'
>>> name[0:7:2]
'ncgd'
>>> name[::2]
'ncgd'
>>> name[::-1]
'dogkcon'

# 定义一个列表，列表内有三个元素
>>> var=["PM","OPS","DEV"]
# 通过索引取到了一个值
>>> var[0]
'PM'
# 通过切片取到了多个值
>>> var[0:2]
['PM', 'OPS']
>>> var[1:3]
['OPS', 'DEV']

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
       """
       B.find(sub[, start[, end]]) -> int       Return the lowest index in B where subsection sub is found,
       such that sub is contained within B[start,end].  Optional
       arguments start and end are interpreted as in slice notation.       Return -1 on failure.
       """
       return 0

>>> msg = "My blog address is fashengba.com"
>>> msg.find("blog")
3
>>> msg.find("b")             # 找到第一个b的索引值，就不往下找了
3
>>> msg.find("b", 8, 30)
26

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
       """
       B.rfind(sub[, start[, end]]) -> int       Return the highest index in B where subsection sub is found,
       such that sub is contained within B[start,end].  Optional
       arguments start and end are interpreted as in slice notation.       Return -1 on failure.
       """
       return 0

>>> msg = "My blog address is fashengba.com"
>>> msg.rfind('b')
26
>>> msg.rfind('b', 1, 10)
3
>>> print('find nock ok') if msg.rfind('nock') != -1 else print('find nock failed')
find nock failed

def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
       """
       B.rindex(sub[, start[, end]]) -> int       Like B.rfind() but raise ValueError when the substring is not found.
       """
       return 0

>>> msg = "My blog address is fashengba.com"
>>> msg.rindex('b')
26
>>> msg.rindex('b', 1, 10)
3
>>> print('find nock ok') if msg.rindex('nock') != -1 else print('find nock failed')
Traceback (most recent call last):
 File "<input>", line 1, in <module>
   print('find nock ok') if msg.rindex('nock') != -1 else print('find nock failed')
ValueError: substring not found

def rstrip(self, chars=None): # real signature unknown; restored from __doc__
       """
       S.rstrip([chars]) -> str       Return a copy of the string S with trailing whitespace removed.
       If chars is given and not None, remove characters in chars instead.
       """
       return ""

>>> msg1 = "   My blog address is fashengba.com   "
>>> msg2 = "***My blog address is fashengba.com***"
>>> msg1.rstrip(); msg2.rstrip('*')
'   My blog address is fashengba.com'
'***My blog address is fashengba.com'

def lstrip(self, chars=None): # real signature unknown; restored from __doc__
       """
       S.lstrip([chars]) -> str       Return a copy of the string S with leading whitespace removed.
       If chars is given and not None, remove characters in chars instead.
       """
       return ""

>>> msg = "   My blog address is fashengba.com   "
>>> msg.lstrip()
'My blog address is fashengba.com   '
# 从左侧开始删除匹配的字符串
>>> string="hello world"
>>> string.lstrip("hello ")
'world'

def lstrip(self, chars=None): # real signature unknown; restored from __doc__
       """
       S.lstrip([chars]) -> str       Return a copy of the string S with leading whitespace removed.
       If chars is given and not None, remove characters in chars instead.
       """
       return ""

>>> msg1 = "   My blog address is fashengba.com   "
>>> msg2 = "***My blog address is fashengba.com***"
>>> msg1.lstrip(); msg2.lstrip('*')
'My blog address is fashengba.com   '
'My blog address is fashengba.com***'

def strip(self, chars=None): # real signature unknown; restored from __doc__
       """
       S.strip([chars]) -> str       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.
       """
       return ""

>>> msg1 = "   My blog address is fashengba.com   "
>>> msg2 = "***My blog address is fashengba.com***"
>>> msg1.strip(); msg2.strip('*')
'My blog address is fashengba.com'
'My blog address is fashengba.com'

def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
       """
       S.splitlines([keepends]) -> 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 []

>>> msg = "nock\ngod"
>>> msg
'nock\ngod'
>>> msg.splitlines()
['nock', 'god']
>>> msg = """my
... name
... is
... nock"""
>>> msg.splitlines()
['my', 'name', 'is', 'nock']

def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
       """
       S.rsplit(sep=None, maxsplit=-1) -> list of strings       Return a list of the words in 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, any whitespace string
       is a separator.
       """
       return []

>>> msg = "my name is nock name is nock name is nock"
>>> msg.rsplit('name')
['my ', ' is nock ', ' is nock ', ' is nock']
>>> msg.rsplit('name', 2)
['my name is nock ', ' is nock ', ' is nock']

def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
       """
       S.split(sep=None, maxsplit=-1) -> list of strings       Return a list of the words in 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 []

>>> msg = "my name is nock name is nock name is nock"
>>> msg.split()
['my', 'name', 'is', 'nock', 'name', 'is', 'nock', 'name', 'is', 'nock']
>>> msg.split('name')
['my ', ' is nock ', ' is nock ', ' is nock']

def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
       """
       S.ljust(width[, fillchar]) -> str       Return S left-justified in a Unicode string of length width. Padding is
       done using the specified fill character (default is a space).
       """
       return ""

>>> name = 'nock'
>>> name.ljust(10, 'G')
'nockGGGGGG'

def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
       """
       S.rjust(width[, fillchar]) -> str       Return S right-justified in a string of length width. Padding is
       done using the specified fill character (default is a space).
       """
       return ""

>>> name = 'nock'
>>> name.rjust(10, 'G')
'GGGGGGnock'

def zfill(self, width): # real signature unknown; restored from __doc__
       """
       S.zfill(width) -> str       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 ""

>>> name = 'nock'
>>> name.zfill(10)
'000000nock'

def capitalize(self): # real signature unknown; restored from __doc__
       """
       S.capitalize() -> str       Return a capitalized version of S, i.e. make the first character
       have upper case and the rest lower case.
       """
       return ""

>>> name = 'nock'
>>> name.capitalize()
'Nock'

def islower(self): # real signature unknown; restored from __doc__
       """
       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

>>> name1 = 'nock'
>>> name2 = 'Nockgod'
>>> name1.islower()
True
>>> name2.islower()
False

def istitle(self): # real signature unknown; restored from __doc__
       """
       S.istitle() -> bool       Return True if S is a titlecased string and there is at least one
       character in S, i.e. upper- and titlecase characters may only
       follow uncased characters and lowercase characters only cased ones.
       Return False otherwise.
       """
       return False

>>> name = 'lol'
>>> name.istitle()
False
>>> name = 'I Love Lol'
>>> name.istitle()
True

def isupper(self): # real signature unknown; restored from __doc__
       """
       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

>>> name1.isupper(), name2.isupper(), name3.isupper()
(False, True, True)

def upper(self): # real signature unknown; restored from __doc__
       """
       S.upper() -> str       Return a copy of S converted to uppercase.
       """
       return ""

>>> name = 'nock'
>>> name.upper()
'NOCK'

def lower(self): # real signature unknown; restored from __doc__
       """
       S.lower() -> str       Return a copy of the string S converted to lowercase.
       """
       return ""

>>> name = 'NOCK'
>>> name.lower()
'nock'

def swapcase(self): # real signature unknown; restored from __doc__
       """
       S.swapcase() -> str       Return a copy of S with uppercase characters converted to lowercase
       and vice versa.
       """
       return ""

>>> name = "My Name Is Nock"
>>> name.swapcase()
'mY nAME iS nOCK'

def isalnum(self): # real signature unknown; restored from __doc__
       """
       B.isalnum() -> bool       Return True if all characters in B are alphanumeric
       and there is at least one character in B, False otherwise.
       """
       return False

>>> name = 'nock 123 ^ff'
>>> name1 = '123 ^&&&'
>>> name2 = '123nock'
>>> name.isalnum(), name1.isalnum(), name2.isalnum()
(False, False, True)

def isalpha(self): # real signature unknown; restored from __doc__
       """
       B.isalpha() -> bool       Return True if all characters in B are alphabetic
       and there is at least one character in B, False otherwise.
       """
       return False

>>> name = 'nock123'
>>> name1 = '$%^^&&'
>>> name2 = 'nock'
>>> name.isalpha(), name1.isalpha(), name2.isalpha()
(False, False, True)

def isdigit(self): # real signature unknown; restored from __doc__
       """
       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

>>> u = 'nock'
>>> p = '123'
>>> up = '123.8'
>>> u.isdigit(), p.isdigit(), up.isdigit()
(False, True, False)

def isidentifier(self): # real signature unknown; restored from __doc__
       """
       S.isidentifier() -> bool       Return True if S is a valid identifier according
       to the language definition.       Use keyword.iskeyword() to test for reserved identifiers
       such as "def" and "class".
       """
       return False

>>> u = '123nock'
>>> p = '123.0'
>>> up = 'nock'
>>> u.isidentifier(), p.isidentifier(), up.isidentifier()
(False, False, True)

def isnumeric(self): # real signature unknown; restored from __doc__
       """
       S.isnumeric() -> bool       Return True if there are only numeric characters in S,
       False otherwise.
       """
       return False

>>> up = '123'
>>> u = '123nock'
>>> p = '123.0'
>>> u.isnumeric(), p.isnumeric(), up.isnumeric()
(False, False, True)

def isprintable(self): # real signature unknown; restored from __doc__
       """
       S.isprintable() -> bool       Return True if all characters in S are considered
       printable in repr() or S is empty, False otherwise.
       """
       return False

>>> msg = 'My name is nock\t blog address is fashengba.com'
>>> print("no tabs") if msg.isprintable() else print("have tabs")
have tabs
>>> msg = 'My name is nock blog address is fashengba.com'
>>> print("no tabs") if msg.isprintable() else print("have tabs")
no tabs

def isspace(self): # real signature unknown; restored from __doc__
       """
       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

>>> msg = 'nock'
>>> print('is space') if msg.isspace() else print('no space')
no space
>>> msg = 'my name is nock'
>>> print('is space') if msg.isspace() else print('no space')
no space
>>> msg = '  '
>>> print('is space') if msg.isspace() else print('no space')
is space

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
       """
       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

>>> email = 'nockgod@gmail.com'
>>> print('is Google Email') if email.endswith('gmail.com') else print('not Google Email')
is Google Email

def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
       """
       S.expandtabs(tabsize=8) -> str       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 ""

>>> msg = 'LOL is\t Good Game'
>>> msg.expandtabs()
'LOL is   Good Game'
>>> msg.expandtabs(tabsize=1)
'LOL is  Good Game'
>>> msg.expandtabs(tabsize=0)
'LOL is Good Game'
>>> msg.expandtabs(10)
'LOL is     Good Game'

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
       """
       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

>>> email = 'nockgod@gmail.com'
>>> email.startswith('nock')
True
>>> email.startswith('o', 2, 4)
False
>>> email.startswith('c', 2, 4)
True

def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
       """
       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

>>> msg = 'my name is nock'
>>> msg.count('n')
2
>>> msg.count('n', 1, 10)
1
>>> msg.count('nock')
1

def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
       """
       S.center(width[, fillchar]) -> str       Return S centered in a string of length width. Padding is
       done using the specified fill character (default is a space)
       """
       return ""

>>> annotation = "Shoping Info"
>>> annotation.center(50, '#')
'###################Shoping Info###################'

def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
       """
       S.encode(encoding='utf-8', errors='strict') -> bytes       Encode S using the codec registered for encoding. Default encoding
       is 'utf-8'. 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 can handle UnicodeEncodeErrors.
       """
       return b""

>>> msg = '葫芦娃'
>>> msg.encode(encoding='utf-8', errors='strict')
b'\xe8\x91\xab\xe8\x8a\xa6\xe5\xa8\x83'

def format(*args, **kwargs): # known special case of str.format
       """
       S.format(*args, **kwargs) -> str       Return a formatted version of S, using substitutions from args and kwargs.
       The substitutions are identified by braces ('{' and '}').
       """
       pass

def format_map(self, mapping): # real signature unknown; restored from __doc__
       """
       S.format_map(mapping) -> str       Return a formatted version of S, using substitutions from mapping.
       The substitutions are identified by braces ('{' and '}').
       """
       return ""

>>> msg = """ ################### Shoping List ###################
... book: {Book}
... bike: {Bike}
... food: {Food}"""
>>> print(msg.format_map({'Book': 39, 'Bike': 800, 'Food': 300}))
################### Shoping List ###################
book: 39
bike: 800
food: 300

def join(self, iterable): # real signature unknown; restored from __doc__
       """
       S.join(iterable) -> str       Return a string which is the concatenation of the strings in the
       iterable.  The separator between elements is S.
       """
       return ""

# 对序列进行操作（分别使用' '与':'作为分隔符）
>>> info = ['hello', 'world', 'Python', 'Coder']
>>> ' '.join(info)
'hello world Python Coder'
>>> ':'.join(info)
'hello:world:Python:Coder'# 对字符串进行操作
>>> info = "hello world python coder"
>>> ':'.join(info)
'h:e:l:l:o: :w:o:r:l:d: :p:y:t:h:o:n: :c:o:d:e:r'# 对元组进行操作
>>> info = ('hello', 'world', 'Python', 'Coder')
>>> ':'.join(info)
'hello:world:Python:Coder'# 对字典操作 字典是无序的
>>> info = {'hello': 1, 'world': 2, 'python': 3, 'coder': 4}
>>> ':'.join(info)
'coder:hello:python:world'# 合并目录
>>> import os
>>> os.path.join('/data/', 'www/web/', 'code')
'/data/www/web/code'

def maketrans(self, [i]args, [/i]*kwargs): # real signature unknown
       """
       Return a translation table usable for str.translate().       If there is only one argument, it must be a dictionary mapping Unicode
       ordinals (integers) or characters to Unicode ordinals, strings or None.
       Character keys will be then converted to ordinals.
       If there are two arguments, they must be strings of equal length, and
       in the resulting dictionary, each character in x will be mapped to the
       character at the same position in y. If there is a third argument, it
       must be a string, whose characters will be mapped to None in the result.
       """
       pass

# 加密
>>> info = "10.0.1.100"
>>> mtinfo = info.maketrans('abcdefg', '3!@#$%^')
>>> mtinfo
{97: 51, 98: 33, 99: 64, 100: 35, 101: 36, 102: 37, 103: 94}# 解密，打印出真实的info的值
>>> info.translate(mtinfo)
'10.0.1.100'

def translate(self, table): # real signature unknown; restored from __doc__
       """
       S.translate(table) -> str       Return a copy of the string S in which each character has been mapped
       through the given translation table. The table must implement
       lookup/indexing via __getitem__, for instance a dictionary or list,
       mapping Unicode ordinals to Unicode ordinals, strings, or None. If
       this operation raises LookupError, the character is left untouched.
       Characters mapped to None are deleted.
       """
       return ""

>>> name = 'nock'
>>> name.maketrans('abcde', '12345')
{97: 49, 98: 50, 99: 51, 100: 52, 101: 53}
>>> cname = name.maketrans('abcde', '12345')
>>> name.translate(cname)
'no3k'

def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
       """
       S.replace(old, new[, count]) -> str       Return a copy of 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 ""

>>> info = 'Pythog'
>>> info.replace('g', 'n')
'Python'
>>> info = 'Good'
>>> info.replace('o', 'e', 2)
'Geed'

def title(self): # real signature unknown; restored from __doc__
       """
       S.title() -> str       Return a titlecased version of S, i.e. words start with title case
       characters, all remaining cased characters have lower case.
       """
       return ""

>>> info = 'shopping list'
>>> info.title()
'Shopping List'