Python中基本数据类型的学习

基本数据类型

　　Python中的基本数据类型分为：数字，字符串，布尔值，列表，元组，字典

关于这些基本数据类型对象常见掉用法介绍

　　数字： int

　　　　（int型所有功能都在 int 里面，在Pychram中建立文件输入int，按住Crtl鼠标点击int 进入查看）　　

#将字符串转换为数字
a = "123"
b = int(a)
#会报错转换中的字符串只能有数字
a = "123"
b = int(a)
#将字符串按base进制转换为10进制
a = "0011"
b = int(a,base=2)
print(b)#s输出为3
#--bit_length()将当前数字用二进制数所表示的位数
a = 5
print(a.bit_length()) #输出为3

　　字符串：str

　　　　（srt型所有功能都在 str 里面，在Pychram中建立文件输入str，按住Crtl鼠标点击str 进入查看）

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

    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__
        """字符居中； width：总长度 ； fillchar：空白处填内容 默认无"""
        """
        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 ""

    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """计算出字符串sub参数在出现几次, start：起始位置；end：结束位置"""
        """
        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

    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
        """判断是否以suffix参数结尾 start:起始位置；end结束位置"""
        """
        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

    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
        """以tabsize参数分割字符串，遇到'\t'不足的用空格补齐"""
        """
        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 ""

    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """寻找子序列，找到第一个返回位置，找不到返回-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

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

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """和find一样寻找子序列位置，但没找到会报错，"""
        """
        S.index(sub[, start[, end]]) -> int

        Like S.find() but raise ValueError when the substring is not found.
        """
        return 0

    def isalnum(self): # real signature unknown; restored from __doc__
        """判断是否只有数字和字符 是返回true，否则返回false"""
        """
        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): # real signature unknown; restored from __doc__
        """判断是否只有字符 是返回true，否则返回false"""
        """
        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

    def isdecimal(self): # real signature unknown; restored from __doc__
        """判断是否是数字（实际中用的更多） 是返回true，否则返回false"""
        """
        S.isdecimal() -> bool

        Return True if there are only decimal characters in S,
        False otherwise.
        """
        return False

    def isdigit(self): # real signature unknown; restored from __doc__
        """判断是否是数字（比上面支持的种类多，不支持中文如二） 是返回true，否则返回false"""
        """
        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

    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

    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

    def isnumeric(self): # real signature unknown; restored from __doc__
        """判断是否是数字（支持更多如中文） 是返回true，否则返回false"""
        """
        S.isnumeric() -> bool

        Return True if there are only numeric characters in S,
        False otherwise.
        """
        return False

    def isprintable(self): # real signature unknown; restored from __doc__
        """是否有不可显示的字符串如'\t','\n'"""
        """
        S.isprintable() -> bool

        Return True if all characters in S are considered
        printable in repr() or S is empty, False otherwise.
        """
        return False

    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

    def istitle(self): # real signature unknown; restored from __doc__
        """是否是标题形式的如 The Book （首字母大写）"""
        """
        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

    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

    def join(self, iterable): # real signature unknown; restored from __doc__
        """将iterable参数中的每个元素按照指定分隔符（调用join的变量）进行拼接"""
        """
        S.join(iterable) -> str

        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""

    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """将字符串放在左边，用法和center一样"""
        """
        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 ""

    def lower(self): # real signature unknown; restored from __doc__
        """将字符串转换成小写"""
        """
        S.lower() -> str

        Return a copy of the string S converted to lowercase.
        """
        return ""

    def lstrip(self, chars=None): # real signature unknown; restored from __doc__
        """去除左边开始chars参数所代表的字符串（包括其子字符串可自由组合）,没有不去除，不填默认去除多余空格还有（'\t','\]n'）；"""
        """
        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 ""

    def maketrans(self, *args, **kwargs): # real signature unknown
        """做一个对应关系 如maketrans("abcd','1234') 将'abcvd','1234'一一对应返回，
        调用translate时用到 用后面的替换前面的"""
        """
        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

    def partition(self, sep): # real signature unknown; restored from __doc__
        """从左边开始找到sep参数相同的字符串开始分割，（'xx','sep','xx'）"""
        """
        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

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

    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """和find一样，但是从右边开始寻找"""
        """
        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

    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """和index一样， 但是从右边开始寻找"""
        """
        S.rindex(sub[, start[, end]]) -> int

        Like S.rfind() but raise ValueError when the substring is not found.
        """
        return 0

    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """将字符串放在右边，用法和center一样"""
        """
        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 ""

    def rpartition(self, sep): # real signature unknown; restored from __doc__
        """从右边开始找到sep参数相同的字符串开始分割，（'xx','sep','xx'）"""
        """
        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=-1): # real signature unknown; restored from __doc__
        """从右边开始找到sep参数相同的字符串开始分割，分割时去掉sep；maxsplit：代表找几次；（'xx','xx'）"""
        """
        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 []

    def rstrip(self, chars=None): # real signature unknown; restored from __doc__
        """去除右边开始chars参数所代表的字符串（包括其子字符串可自由组合）,没有不去除（只有前一个去了后面才能去），
        不填默认去除多余空格还有（'\t','\]n'）；"""
        """
        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 ""

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """从左边开始找到sep参数相同的字符串开始分割，分割时去掉sep；maxsplit：代表找几次；（'xx','xx'）"""
        """
        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 []

    def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
        """分割，按照'\n'分割，keepends：true保留换行符，false不保留换行符"""
        """
        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 []

    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """判断是否以prefix参数开头 start:起始位置；end结束位置"""
        """
        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

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """去除两边开始chars参数所代表的字符串（包括其子字符串可自由组合）,没有不去除（只有前一个去了后面才能去），
        不填默认去除多余空格还有（'\t','\]n'）；"""
        """
        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 ""

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

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

    def translate(self, table): # real signature unknown; restored from __doc__
        """按照table参数表示的一一对应关系替换 变量中的值 ，返回替换后的字符串"""
        """
        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

        Return a copy of S converted to uppercase.
        """
        return ""

    def zfill(self, width): # real signature unknown; restored from __doc__
        """将字符串放在右边和 width：代表宽度  ；默认用0填充"""
        """
        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 ""

　　　　1. 索引，切片：字符串可以用索引：a = "abc"    b = a[0]  切片：a = "abcdef"   b = a[0:2] (取第0 1 个，2为-1时就是到最后)

　　　　2. len()：a = len("中") 在Python3中输出a=1,字符串长度;  Python2中输出a=3 ，字节长度

　　　　3. 还支持for循环如 ：for b in a:

　　　　4. 字符串一旦创建不可修改，修改和拼接都是产生的新的字符串

　　列表：list

　　　　（list型所有功能都在 int 里面，在Pychram中建立文件输入list，按住Crtl鼠标点击list 进入查看）

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
    def append(self, p_object): # real signature unknown; restored from __doc__
        """在元素当成整体后面追加字符串"""
        """ L.append(object) -> None -- append object to end """
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """清空列表"""
        """ L.clear() -> None -- remove all items from L """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """拷贝  浅拷贝"""
        """ L.copy() -> list -- a shallow copy of L """
        return []

    def count(self, value): # real signature unknown; restored from __doc__
        """计算出元素出现的次数"""
        """ L.count(value) -> integer -- return number of occurrences of value """
        return 0

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """将每个元素元素追加到后面 参数要是可迭代对象"""
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
        pass

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """找元素的位置 左边优先"""
        """
        L.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """插入元素；index：要插入值的位置；p_object要插入的值"""
        """ L.insert(index, object) -- insert object before index """
        pass

    def pop(self, index=None): # real signature unknown; restored from __doc__
        """删除某个值返回被删除的值；index：要删除的值的索引；默认情况下删除最后一个"""
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.
        """
        pass

    def remove(self, value): # real signature unknown; restored from __doc__
        """删除；value：要删除的元素"""
        """
        L.remove(value) -> None -- remove first occurrence of value.
        Raises ValueError if the value is not present.
        """
        pass

    def reverse(self): # real signature unknown; restored from __doc__
        """当前列表进行反转"""
        """ L.reverse() -- reverse *IN PLACE* """
        pass

    def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
        """帮忙排序；reverse=true 从大到小，reverse=false 从小到大"""
        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
        pass

　　　　1. 中括号括起来，用 , 分割元素

　　　　2. 列表中可以是数字，字符串，列表 ， 布尔值 ，元组，字典

　　　　3. 支持索引分割for,while,       可迭代

　　　　4. 可以被修改 通过索引和切片，

　　　　5. 可以通过索引和切片删除如 del(a[i]) 　

　　　　6. 列表换成字符转，如果没有数字直接用字符串的join函数，有数字就只能通过for循环

　　元组：tuple

　　　　（tuple型所有功能都在 tuple 里面，在Pychram中建立文件输入list，按住Crtl鼠标点击tuple 进入查看）

　　　　

class tuple(object):
    """
    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items
    
    If the argument is a tuple, the return value is the same object.
    """
    def count(self, value): # real signature unknown; restored from __doc__
        """计算出元素的个数"""
        """ T.count(value) -> integer -- return number of occurrences of value """
        return 0

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """索引出元素所在位置； value：索引的值；start：起始位置；stop：结束位置"""
        """
        T.index(value, [start, [stop]]) -> integer -- return first index of value.
        Raises ValueError if the value is not present.
        """
        return 0

　　　　1. 元组用()括起来 ，一般写元组的时候在后面加个 ,

　　　　2. 元组的元素（一级元素）不可修改，不能被增加或者删除，但是如果元组里面的元素的元素如果是可修改类型就可以修改

　　　　3. 一般写元素的时候推荐在最好加入

　　　　4. 可以被索引，切片，for循环，是可迭代对象

　　字典：dict

　　　　（dict型所有功能都在 dict 里面，在Pychram中建立文件输入dict，按住Crtl鼠标点击dict 进入查看）

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__
        """清空字典中的元素"""
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """浅拷贝"""
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case 支持类名加方法 如  dict.fromkeys
    def fromkeys(*args, **kwargs): # real signature unknown
        """根据序列创建一个字典 args：中间的元素当成key ； kwargs：中的元素当成value"""
        """ Returns a new dict with keys from iterable and values equal to value. """
        pass

    def get(self, k, d=None): # real signature unknown; restored from __doc__
        """根据key取字典中的值；不存在时可以指定默认值（NOLL）"""
        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
        pass

    def items(self): # real signature unknown; restored from __doc__
        """获取键值对"""
        """ D.items() -> a set-like object providing a view on D's items """
        pass

    def keys(self): # real signature unknown; restored from __doc__
        """获取key值"""
        """ D.keys() -> a set-like object providing a view on D's keys """
        pass

    def pop(self, k, d=None): # real signature unknown; restored from __doc__
        """删除键值对；k：想要删除的键值对；返回为删除的值；d:如果不存在时返回值"""
        """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised
        """
        pass

    def popitem(self): # real signature unknown; restored from __doc__
        """随机删除键值对；返回删除的键值对"""
        """
        D.popitem() -> (k, v), remove and return some (key, value) pair as a
        2-tuple; but raise KeyError if D is empty.
        """
        pass

    def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
        """设置值；如果存在不设置获取当前key对应的值，如果不存在添加，获取当前设置的值"""
        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
        pass

    def update(self, E=None, **F): # known special case of dict.update
        """更新字典里面上值"""
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """
        pass

    def values(self): # real signature unknown; restored from __doc__
        """获取字典中的元素"""
        """ D.values() -> an object providing a view on D's values """
        pass

　　　1. 字典的格式 key值不能是可变值  bool值不能和（0，1）一起出现

dic = {
    2 : 1,
    "key" : "abc",
    True : (1,2,3),
    (1,2) : {
        1 : 1,
        "key" : "abc",
        True : (1,2,3),

    }
}

　　　　2. 字典是无序的，不能进行切片

　　　　3. 字典里面可以嵌套任意元素类型

　　　　4. 可以通过索引的方式找到里面的元素

　　　　5. 支持删除和for循环

 　　布尔值：bool

　　　　1. 只有0 ，1

　　　　2. None，''，()，[]，{}，0 =====>代表False