Python---基础---数据类型的内置函数

2019-05-23

----------------------------

一、

#数据类型的内置函数
Python有哪些数据类型？
Number   数值型
string   字符型
list     列表
tuple    元组
dict     字典
set      集合

---------------------------

二、

## 字符串的简单操作
   
 +  字符串的连接操作
 *  字符串的复制操作
 [] 字符串的索引操作
 [: :] 字符串的切片操作
 [开始索引: 结束索引: 间隔值] (包含开始， 不包含结尾)

------------------------------------------------------------------------

str1 = 'lo'
str2 = 've'
print(str1 + str2)
print('lo' + 've')

print('#'*10)

s = 'I like dog'
print(s[-1])
s = '012345678'
# 指定范围切字符串
print(s[2:5])
# 指定范围并且给出间隔值
print(s[2:6])
print(s[2:6:2])
# 切整个字符串
print(s[:])
#指定开始，不指定结束
print(s[2:])
# 指定结束，不指定开始
print(s[:4])
# 指定开始，不指定结束，并给出间隔值
print(s[2::3])
#指定结束，不指定开始并给出间隔值
print(s[:6:2])

----------------------------

三、help(str)

-----------------------------

Help on class str in module builtins:

class str(object)
|  str(object='') -> str
|  str(bytes_or_buffer[, encoding[, errors]]) -> str
| 
|  Create a new string object from the given object. If encoding or
|  errors is specified, then the object must expose a data buffer
|  that will be decoded using the given encoding and error handler.
|  Otherwise, returns the result of object.__str__() (if defined)
|  or repr(object).
|  encoding defaults to sys.getdefaultencoding().
|  errors defaults to 'strict'.
| 
|  Methods defined here:
| 
|  __add__(self, value, /)
|      Return self+value.
| 
|  __contains__(self, key, /)
|      Return key in self.
| 
|  __eq__(self, value, /)
|      Return self==value.
| 
|  __format__(self, format_spec, /)
|      Return a formatted version of the string as described by format_spec.
| 
|  __ge__(self, value, /)
|      Return self>=value.
| 
|  __getattribute__(self, name, /)
|      Return getattr(self, name).
| 
|  __getitem__(self, key, /)
|      Return self[key].
| 
|  __getnewargs__(...)
| 
|  __gt__(self, value, /)
|      Return self>value.
| 
|  __hash__(self, /)
|      Return hash(self).
| 
|  __iter__(self, /)
|      Implement iter(self).
| 
|  __le__(self, value, /)
|      Return self<=value.
| 
|  __len__(self, /)
|      Return len(self).
| 
|  __lt__(self, value, /)
|      Return self<value.
| 
|  __mod__(self, value, /)
|      Return self%value.
| 
|  __mul__(self, value, /)
|      Return self*value.
| 
|  __ne__(self, value, /)
|      Return self!=value.
| 
|  __repr__(self, /)
|      Return repr(self).
| 
|  __rmod__(self, value, /)
|      Return value%self.
| 
|  __rmul__(self, value, /)
|      Return value*self.
| 
|  __sizeof__(self, /)
|      Return the size of the string in memory, in bytes.
| 
|  __str__(self, /)
|      Return str(self).
| 
|  capitalize(self, /)
|      Return a capitalized version of the string.
|     
|      More specifically, make the first character have upper case and the rest lower
|      case.
| 
|  casefold(self, /)
|      Return a version of the string suitable for caseless comparisons.
| 
|  center(self, width, fillchar=' ', /)
|      Return a centered string of length width.
|     
|      Padding is done using the specified fill character (default is a space).
| 
|  count(...)
|      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.
| 
|  encode(self, /, encoding='utf-8', errors='strict')
|      Encode the string using the codec registered for encoding.
|     
|      encoding
|        The encoding in which to encode the string.
|      errors
|        The error handling scheme to use for encoding errors.
|        The 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.
| 
|  endswith(...)
|      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.
| 
|  expandtabs(self, /, tabsize=8)
|      Return a copy where all tab characters are expanded using spaces.
|     
|      If tabsize is not given, a tab size of 8 characters is assumed.
| 
|  find(...)
|      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.
| 
|  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 '}').
| 
|  format_map(...)
|      S.format_map(mapping) -> str
|     
|      Return a formatted version of S, using substitutions from mapping.
|      The substitutions are identified by braces ('{' and '}').
| 
|  index(...)
|      S.index(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.
|     
|      Raises ValueError when the substring is not found.
| 
|  isalnum(self, /)
|      Return True if the string is an alpha-numeric string, False otherwise.
|     
|      A string is alpha-numeric if all characters in the string are alpha-numeric and
|      there is at least one character in the string.
| 
|  isalpha(self, /)
|      Return True if the string is an alphabetic string, False otherwise.
|     
|      A string is alphabetic if all characters in the string are alphabetic and there
|      is at least one character in the string.
| 
|  isascii(self, /)
|      Return True if all characters in the string are ASCII, False otherwise.
|     
|      ASCII characters have code points in the range U+0000-U+007F.
|      Empty string is ASCII too.
| 
|  isdecimal(self, /)
|      Return True if the string is a decimal string, False otherwise.
|     
|      A string is a decimal string if all characters in the string are decimal and
|      there is at least one character in the string.
| 
|  isdigit(self, /)
|      Return True if the string is a digit string, False otherwise.
|     
|      A string is a digit string if all characters in the string are digits and there
|      is at least one character in the string.
| 
|  isidentifier(self, /)
|      Return True if the string is a valid Python identifier, False otherwise.
|     
|      Use keyword.iskeyword() to test for reserved identifiers such as "def" and
|      "class".
| 
|  islower(self, /)
|      Return True if the string is a lowercase string, False otherwise.
|     
|      A string is lowercase if all cased characters in the string are lowercase and
|      there is at least one cased character in the string.
| 
|  isnumeric(self, /)
|      Return True if the string is a numeric string, False otherwise.
|     
|      A string is numeric if all characters in the string are numeric and there is at
|      least one character in the string.
| 
|  isprintable(self, /)
|      Return True if the string is printable, False otherwise.
|     
|      A string is printable if all of its characters are considered printable in
|      repr() or if it is empty.
| 
|  isspace(self, /)
|      Return True if the string is a whitespace string, False otherwise.
|     
|      A string is whitespace if all characters in the string are whitespace and there
|      is at least one character in the string.
| 
|  istitle(self, /)
|      Return True if the string is a title-cased string, False otherwise.
|     
|      In a title-cased string, upper- and title-case characters may only
|      follow uncased characters and lowercase characters only cased ones.
| 
|  isupper(self, /)
|      Return True if the string is an uppercase string, False otherwise.
|     
|      A string is uppercase if all cased characters in the string are uppercase and
|      there is at least one cased character in the string.
| 
|  join(self, iterable, /)
|      Concatenate any number of strings.
|     
|      The string whose method is called is inserted in between each given string.
|      The result is returned as a new string.
|     
|      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
| 
|  ljust(self, width, fillchar=' ', /)
|      Return a left-justified string of length width.
|     
|      Padding is done using the specified fill character (default is a space).
| 
|  lower(self, /)
|      Return a copy of the string converted to lowercase.
| 
|  lstrip(self, chars=None, /)
|      Return a copy of the string with leading whitespace removed.
|     
|      If chars is given and not None, remove characters in chars instead.
| 
|  partition(self, sep, /)
|      Partition the string into three parts using the given separator.
|     
|      This will search for the separator in the string.  If the separator is found,
|      returns a 3-tuple containing the part before the separator, the separator
|      itself, and the part after it.
|     
|      If the separator is not found, returns a 3-tuple containing the original string
|      and two empty strings.
| 
|  replace(self, old, new, count=-1, /)
|      Return a copy with all occurrences of substring old replaced by new.
|     
|        count
|          Maximum number of occurrences to replace.
|          -1 (the default value) means replace all occurrences.
|     
|      If the optional argument count is given, only the first count occurrences are
|      replaced.
| 
|  rfind(...)
|      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.
| 
|  rindex(...)
|      S.rindex(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.
|     
|      Raises ValueError when the substring is not found.
| 
|  rjust(self, width, fillchar=' ', /)
|      Return a right-justified string of length width.
|     
|      Padding is done using the specified fill character (default is a space).
| 
|  rpartition(self, sep, /)
|      Partition the string into three parts using the given separator.
|     
|      This will search for the separator in the string, starting at the end. If
|      the separator is found, returns a 3-tuple containing the part before the
|      separator, the separator itself, and the part after it.
|     
|      If the separator is not found, returns a 3-tuple containing two empty strings
|      and the original string.
| 
|  rsplit(self, /, sep=None, maxsplit=-1)
|      Return a list of the words in the string, using sep as the delimiter string.
|     
|        sep
|          The delimiter according which to split the string.
|          None (the default value) means split according to any whitespace,
|          and discard empty strings from the result.
|        maxsplit
|          Maximum number of splits to do.
|          -1 (the default value) means no limit.
|     
|      Splits are done starting at the end of the string and working to the front.
| 
|  rstrip(self, chars=None, /)
|      Return a copy of the string with trailing whitespace removed.
|     
|      If chars is given and not None, remove characters in chars instead.
| 
|  split(self, /, sep=None, maxsplit=-1)
|      Return a list of the words in the string, using sep as the delimiter string.
|     
|      sep
|        The delimiter according which to split the string.
|        None (the default value) means split according to any whitespace,
|        and discard empty strings from the result.
|      maxsplit
|        Maximum number of splits to do.
|        -1 (the default value) means no limit.
| 
|  splitlines(self, /, keepends=False)
|      Return a list of the lines in the string, breaking at line boundaries.
|     
|      Line breaks are not included in the resulting list unless keepends is given and
|      true.
| 
|  startswith(...)
|      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.
| 
|  strip(self, chars=None, /)
|      Return a copy of the string with leading and trailing whitespace remove.
|     
|      If chars is given and not None, remove characters in chars instead.
| 
|  swapcase(self, /)
|      Convert uppercase characters to lowercase and lowercase characters to uppercase.
| 
|  title(self, /)
|      Return a version of the string where each word is titlecased.
|     
|      More specifically, words start with uppercased characters and all remaining
|      cased characters have lower case.
| 
|  translate(self, table, /)
|      Replace each character in the string using the given translation table.
|     
|        table
|          Translation table, which must be a mapping of Unicode ordinals to
|          Unicode ordinals, strings, or None.
|     
|      The table must implement lookup/indexing via __getitem__, for instance a
|      dictionary or list.  If this operation raises LookupError, the character is
|      left untouched.  Characters mapped to None are deleted.
| 
|  upper(self, /)
|      Return a copy of the string converted to uppercase.
| 
|  zfill(self, width, /)
|      Pad a numeric string with zeros on the left, to fill a field of the given width.
|     
|      The string is never truncated.
| 
|  ----------------------------------------------------------------------
|  Static methods defined here:
| 
|  __new__(*args, **kwargs) from builtins.type
|      Create and return a new object.  See help(type) for accurate signature.
| 
|  maketrans(x, y=None, z=None, /)
|      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.

---------------------------------

四、

# capitalize() 首字母大写   返回的是字符串
s = 'i like dog'
print(s.capitalize())

----------------------------------

五、

# capitalize() 首字母大写   返回的是字符串
s = 'i like dog'
print(id(s))
new_s = s.capitalize()
print(id(new_s))

--------------------------------------

六、

# title()   将每个单词的首字母变为大写   返回的是字符串
s = 'I like dog'
print(s.title())

---------------------------

七、

# upper()   将所有字母变为大写字母     返回的是字符串
s = 'I 狗 like  dog'
print(s.upper())

-----------------------------

八、

# swapcase() 大小写互换   返回的是字符串
s = 'I 狗 like dog'
print(s.swapcase())

-----------------------------

八、

# len()计算字符串长度，不属于字符串的内建函数
s = 'I 狗 like dog'
s1 = 'I like dog'
print(len(s))
print(len(s1))

------------------------------

九、

# find()  查找指定字符串，找不到返回-1   找到返回索引值
# index() 查找指定字符串，找不到报错
s = 'asdfghjklasdfghjkl'
s1 = s.find('a',2,10)
s2 = s.index('a')
print(s1)
print(s2)

--------------------------------

十、

# count() 计算字符串出现次数
s = 'asdfghjklasdfghjkl'
print(s.count('g'))

------------------------------------

十一、

# startswith() 检测是否已指定字母开头
# endswith() 检测是否  以指定字母结束
s = 'I like dog'
print(s.startswith('i'))
print(s.startswith('I'))

print(s.endswith('g'))
print(s.endswith('G'))

--------------------------------------

十二、

# isupper()  检测所有字母是否是大写字母    返回的都是布尔值
s = 'fgh'
s1 = 'DFGH'
print(s.isupper())
print(s1.isupper())
print('='*20)

# islower()  检测所有字母是否是小写字母
print(s.islower())
print(s1.islower())
print('='*20)
#istitle()   检测是否以指定标题显示（每个单词首字母大写）
print(s.istitle())
print(s1.istitle())
s2 = 'I Like Dog'
print(s2.istitle())
print('='*20)
# isspace()   检测字符串是否是空字符串
s = '  '
s1 = 'i  like  '
s2 = ''
print(s.isspace())
print(s1.isspace())
print(s2.isspace())
print('='*20)

------------------------------

十三、

 # isalpha() 检测字符串是否是字母组成    返回布尔值
s = 'I 狗  like dog'
print(s.isalpha())

-----------------------------

十四、

# isalpha() 检测字符串是否是字母组成    返回布尔值
s = 'I 狗  like dog'
s1 = 'I狗likedog'
print(s.isalpha())
print(s1.isalpha())

----------------------------

十五、