python运维second_chapter（1）

注：能读懂源码是使用好该类的基础！

---

列表list源码

class list(object):

"""
list() -> 生成一个空的列表
list(iterable) -> 根据可迭代对象生成一个新的列表
"""
def append(self, p_object): # real signature unknown; restored from __doc__
    """ L.append(object) -> 无返回值-- 在L的末尾添加object """
    pass
def clear(self): # real signature unknown; restored from __doc__
    """ L.clear() -> 无返回值-- 移除L中的所有元素 """
    pass

def copy(self): # real signature unknown; restored from __doc__
    """ L.copy() -> 返回一个新的列表 -- 对L进行浅拷贝后返回一个新的列表 """
    return []

def count(self, value): # real signature unknown; restored from __doc__
    """ L.count(value) -> 返回一个整数 -- 返回value在L中出现的次数 """
    return 0

def extend(self, iterable): # real signature unknown; restored from __doc__
    """ L.extend(iterable) -> 无返回值  -- 通过添加迭代器iterable中的元素扩展L """
    pass

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    """
    L.index(value, [start, [stop]]) -> 返回一个整数 -- 返回在L中value第一次出现的索引值.
    如果value不在L中就会出现KeyError.
    """
    return 0

def insert(self, index, p_object): # real signature unknown; restored from __doc__
    """ L.insert(index, object) -- 在索引为index的位置前面插入object """
    pass

def pop(self, index=None): # real signature unknown; restored from __doc__
    """
    L.pop([index]) -> 返回元素 -- 移除并且返回在索引index上的元素（默认为最后一个）.
    如果列表为空或者index超出列表的索引长度将会出现KeyError.
    """
    pass

def remove(self, value): # real signature unknown; restored from __doc__
    """
    L.remove(value) -> 无返回值-- 移除在L中出现的value.
    如果value不在L中将会出现KeyError.
    """
    pass

def reverse(self): # real signature unknown; restored from __doc__
    """ L.reverse() -- 对L中的值进行反转*这个操作会覆盖原先的L* """
    pass

def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
    """ L.sort(key=None, reverse=False) -> None -- 对L进行排序 *这个操作会覆盖原先的L* """
    pass

元组tuple源码

元组生成后不可改变

class tuple(object):

"""
tuple() -> 生成空的元组
tuple(iterable) -> 通过迭代器中的元素生成一个元组

如果传入的迭代器iterable也是一个元祖，那么就会生成一个相同的对象.
"""
def count(self, value): # real signature unknown; restored from __doc__
    """ T.count(value) -> 返归整数 -- 返回在T中出现的value的次数 """
    return 0

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    """
    T.index(value, [start, [stop]]) -> 返回整数-- 返回T中的value第一次出现的索引值.
    如果value不在T中将会出现KeyError.
    """
    return 0

str源码

str对象生成后不可改变

class str(object):
"""
str(object='') -> 生成一个str对象
str(bytes_or_buffer[, encoding[, errors]]) -> 生成一个str对象

通过给出的object对象创建一个str对象. 如果编码方式encoding和错误处理方式errors都有给出，那么str对象就要给出一个数据缓冲器来对其进行给定的方式编码与错误处理    否则，就会返回object.__str__()或者repr（object）的返回值 (如果有定义的话）。 默认的编码方式可以从sys.getdeflautencoding()函数获得.默认的错误处理方式为'strict' 
"""
def capitalize(self): # real signature unknown; restored from __doc__
    """
    S.capitalize() -> 返回一个str对象        
    返回S的大写版本,即首字母大写其余部分小写.
    """
    return ""

def casefold(self): # real signature unknown; restored from __doc__
    """
    S.casefold() -> str

    Return a version of S suitable for caseless comparisons.
    """
    return ""

def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
    """
    S.center(width[, fillchar]) -> 返回str对象

    返回一个新的str对象S在str对象的长度的中间. 填充新的str对象用参数fillchar(默认是空格)
    """
    return ""

def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.count(sub[, start[, end]]) -> 返回整数

    给出子字符串sub在字符串S[start:end]中非重叠出现次数。可选参数start和end可以被认为是切片标记法。
    """
    return 0

def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
    """
    S.encode(encoding='utf-8', errors='strict') -> bytes

    使用设置的解码方式的解码器对S进行解码默认的编解码器为'utf-8'。错误处理方式errors可以设置不同的错误处理方法。默认为‘strict’，其意味着编码错误时会出现UnicodeEncodeError。其他可选的值为'ignore','replace'和'xmlcharrefreplace'只要任何寄存器带有上面三个编解码器。就可以处理UnicodeErrors
    """
    return b""

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.endswith(suffix[, start[, end]]) -> 返回布尔值        
    返回True如果S的结尾是我们指定的suffix字符，否则返回False.
    在传入可选参数start的情况下，我们在start的位置开始对比.
    在传入可选参数end的情况下，我们在end的位置结束对比.
    参数suffix也可以是字符组成的元组.
    """
    return False

def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
    """
    S.expandtabs(tabsize=8) -> 返回str对象   
    返回一个拷贝S的副本，其中该副本会把S中所有制表符都使用空格进行扩展（相当于替换掉制表符）
    如果参数tabsize没有给出，那么我们就会假定扩展的尺寸为8个字符长度。
    """
    return ""

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.find(sub[, start[, end]]) -> 返回整数        
    返回子字符串sub被找出的最后一个索引位置,sub是被包含在S[start:end]中的子字符串。可选参数start和end可以被认为是切片标注法。

    Return -1 on failure.
    """
    return 0

def format(self, *args, **kwargs): # known special case of str.format
    """
    S.format(*args, **kwargs) -> 返回str对象

    str

    返回格式化后的S版本，从参数args和kwargs中使用取代方法。取代方式是通过括弧来确定的（‘{’和‘}’）
    """
    pass

def format_map(self, mapping): # real signature unknown; restored from __doc__
    """
    S.format_map(mapping) -> 返回str对象str

    返回一个格式化的S版本，从参数mapping中使用取代。取代方式是通过括弧来确定的（‘{’和‘}’）
    """
    return ""

def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.index(sub[, start[, end]]) -> 返回整数int

    返回子字符串sub被找到的最后一个位置的索引,sub被包含在S[start:end]中。可选参数start和end可以认为是切片的标注法。当子字符串无法找到时会出现ValueError。 

    """
    return 0

def isalnum(self): # real signature unknown; restored from __doc__
    """
    S.isalnum() -> 返回布尔值

    如果S中的字符都是只包含数字或者字母并且S中最少有一个字符就返回True，否则返回False.
    """
    return False

def isalpha(self): # real signature unknown; restored from __doc__
    """
    S.isalpha() -> 布尔值bool

    如果在S中所有字符都为字母并且至少有一个字符就返回Ture，否则返回False。
    """
    return False

def isdecimal(self): # real signature unknown; restored from __doc__
    """
    S.isdecimal() -> 布尔值bool

    如果S中只有十进制字符就返回Ture，否则返回False。
    """
    return False

def isdigit(self): # real signature unknown; restored from __doc__
    """
    S.isdigit() -> 返回布尔值bool

    如果在S中所有字符都为数字并且至少有一个字符就返回Ture，否则就返回False。
    """
    return False

def isidentifier(self): # real signature unknown; restored from __doc__
    """
    S.isidentifier() -> 布尔值bool

    如果S根据语言的定义是有效的识别符就返回Ture

    使用keyword.iskeyword()来测试系统原始的识别符，像‘def'和’class'.
    """
    return False

def islower(self): # real signature unknown; restored from __doc__
    """
    S.islower() -> bool

    如果在S中所有的字符都是小写的并且至少有一个字符就返回Ture，否反之False。
    """
    return False

def isnumeric(self): # real signature unknown; restored from __doc__
    """
    S.isnumeric() -> bool

    在S中若只有数值字符串就返回Ture，反之False。
    """
    return False

def isprintable(self): # real signature unknown; restored from __doc__
    """
    S.isprintable() -> bool

    如果在S中的所有字符串都可以在函数repr()中打印或者为空就返回Ture，反之False。
    """
    return False

def isspace(self): # real signature unknown; restored from __doc__
    """
    S.isspace() -> bool

    若在S中的所有字符都是空白格并且至少有一个字符就返回Ture，反之则False。
    """
    return False

def istitle(self): # real signature unknown; restored from __doc__
    """
    S.istitle() -> bool

    若在S中的字符串为标题型字符并且至少有一个字符就返回True，也就是说大写和标题型字符只能跟在空格字符后面并且小写字符只能跟在它们两个后面。
    """
    return False

def isupper(self): # real signature unknown; restored from __doc__
    """
    S.isupper() -> bool

    若在S中所有的字符都为大写并且至少有一个字符，反之False。        """
    return False

def join(self, iterable): # real signature unknown; restored from __doc__
    """
    S.join(iterable) -> str

    连接迭代器中的字符串并返回一个字符串。S为元素之间的分隔符。
    """
    return ""

def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    """
    S.ljust(width[, fillchar]) -> str

    返回在长度为width的统一码中S被调整到最左边的字符串。使用参数fillchar对新生成的统一码进行填充。（默认为空格）
    """
    return ""

def lower(self): # real signature unknown; restored from __doc__
    """
    S.lower() -> str

    返回一个把S全转化为小写的副本。
    """
    return ""

def lstrip(self, chars=None): # real signature unknown; restored from __doc__
    """
    S.lstrip([chars]) -> str

    返回一个把S字符串中开头的空白格全移除的副本。若参数插入被给出了并且不为空，移除的字符换为char。
    """
    return ""

def maketrans(self, *args, **kwargs): # real signature unknown
    """
    返回对于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

def partition(self, sep): # real signature unknown; restored from __doc__
    """
    S.partition(sep) -> (head, sep, tail)

    搜索在S中的分隔符sep，返回sep前面的字符，sep本身和sep后面的字符。如果分隔符没有被找到，就返回S和两个空的字符串。
    """
    pass

def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
    """
    S.replace(old, new[, count]) -> str

    返回一个把S中所有出现的old子字符串都替换为new字符串的副本。若可选实参count已给出，只有头count次出现的old会被替代。
    """
    return ""

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.rfind(sub[, start[, end]]) -> int

    返回子字符串sub在S中被找到的最大索引值，sub被包含在S[start:end]中。可选实参start和end可以被认为是切片标注法。

    Return -1 on failure.
    """
    return 0

def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.rindex(sub[, start[, end]]) -> int

    返回子字符串sub在S中被找到的最大索引值，sub被包含在S[start:end]中。可选实参start和end可以被认为是切片标注法。

    Raises ValueError when the substring is not found.
    """
    return 0

def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    """
    S.rjust(width[, fillchar]) -> str

    返回在长度为width的字符串中S被调整至最右边的字符串。用指定的实参fillchar对返回的字符串进行填充。（默认为空格）。
    """
    return ""

def rpartition(self, sep): # real signature unknown; restored from __doc__
    """
    S.rpartition(sep) -> (head, sep, tail)

    从S的结尾开始搜索分隔符S，返回S前面的部分，S本身和后面的部分。如果分隔符没有被找到，返回两个空的字符串和S。
    """
    pass

def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
    """
    S.rsplit(sep=None, maxsplit=-1) -> list of strings

    返回一个在S中的元素形成的列表，使用参数sep为分解字符，从S的结尾开始工作到S的开头。如果参数maxsplit有给出，在maxsplit处将停止分割。若sep没有被指定，那么空白格就会作为分隔符。
    """
    return []

def rstrip(self, chars=None): # real signature unknown; restored from __doc__
    """
    S.rstrip([chars]) -> str

    返回把S末尾的空白格移除的副本。若实参chars有给出并且不为空，那么移除的字符就用chars代替。
    """
    return ""

def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
    """
    S.split(sep=None, maxsplit=-1) -> list of strings

    返回一个由S中的元素组成的列表，使用sep作为分界符。若maxsplit被出给了，在maxsplit处就分割。若sep没有指定或者为空，那么靠摆个就作为分隔符并且空字符就会被移除。
    """
    return []

def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
    """
    S.splitlines([keepends]) -> list of strings

    返回一个由S中的行组成的列表，通过行的界限进行分割。行分隔符不会被包括在结果中除非参数keepends被给出而且为真。
    """
    return []

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.startswith(prefix[, start[, end]]) -> bool

    若S是从指定的参数prefix开始的，反之False。若传入start S就从该处开始，若传入end S就从该处结束。prefix也可以为字符组成的元组。
    """
    return False

def strip(self, chars=None): # real signature unknown; restored from __doc__
    """
    S.strip([chars]) -> str

    返回一个S的开头与结尾处的空白格都被移除的副本。若chars被给出并且不为None，移除的字符就用chars代替。
    """
    return ""

def swapcase(self): # real signature unknown; restored from __doc__
    """
    S.swapcase() -> str

    返回一个S中大写变小写，小写变大写的副本（vice versa）。
    """
    return ""

def title(self): # real signature unknown; restored from __doc__
    """
    S.title() -> str

    返回S变为标题型字符串的副本，也就是说一个单词的首字母变为大写，其余的部分保持小写。
    """
    return ""

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 ""

def upper(self): # real signature unknown; restored from __doc__
    """
    S.upper() -> str

    返回一个S中的字符都变为大写的副本
    """
    return ""

def zfill(self, width): # real signature unknown; restored from __doc__
    """
    S.zfill(width) -> str

    使用数字字符零对S的左边进行填充，填充的区域为指定的长度width。字符串S不会被缩短。
    """
    return ""