本篇主要内容有：运算符 基本数据类型等

一、运算符

1、算术运算

2、比较运算

3、赋值运算

4、逻辑运算

5、成员运算

6、身份运算

7、位运算

8、运算符优先级

二、基本数据类型

１.整数：int

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

  1. class int(object):
  2.     """
  3.     int(x=0) -> int or long
  4.     int(x, base=10) -> int or long
  5.  
  6.     Convert a number or string to an integer, or return 0 if no arguments
  7.     are given.  If x is floating point, the conversion truncates towards zero.
  8.     If x is outside the integer range, the function returns a long instead.
  9.  
  10.     If x is not a number or if base is given, then x must be a string or
  11.     Unicode object representing an integer literal in the given base.  The
  12.     literal can be preceded by '+' or '-' and be surrounded by whitespace.
  13.     The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  14.     interpret the base from the string as an integer literal.
  15.     >>> int('0b100', base=0)
  16.  
  17.     """
  18.     def bit_length(self):
  19.         """ 返回表示该数字的时占用的最少位数 """
  20.         """
  21.         int.bit_length() -> int
  22.  
  23.         Number of bits necessary to represent self in binary.
  24.         >>> bin(37)
  25.         '0b100101'
  26.         >>> (37).bit_length()
  27.  
  28.         """
  29.         return 0
  30.  
  31.     def conjugate(self, *args, **kwargs): # real signature unknown
  32.         """ 返回该复数的共轭复数 """
  33.         """ Returns self, the complex conjugate of any int. """
  34.         pass
  35.  
  36.     def __abs__(self):
  37.         """ 返回绝对值 """
  38.         """ x.__abs__() <==> abs(x) """
  39.         pass
  40.  
  41.     def __add__(self, y):
  42.         """ x.__add__(y) <==> x+y """
  43.         pass
  44.  
  45.     def __and__(self, y):
  46.         """ x.__and__(y) <==> x&y """
  47.         pass
  48.  
  49.     def __cmp__(self, y):
  50.         """ 比较两个数大小 """
  51.         """ x.__cmp__(y) <==> cmp(x,y) """
  52.         pass
  53.  
  54.     def __coerce__(self, y):
  55.         """ 强制生成一个元组 """
  56.         """ x.__coerce__(y) <==> coerce(x, y) """
  57.         pass
  58.  
  59.     def __divmod__(self, y):
  60.         """ 相除，得到商和余数组成的元组 """
  61.         """ x.__divmod__(y) <==> divmod(x, y) """
  62.         pass
  63.  
  64.     def __div__(self, y):
  65.         """ x.__div__(y) <==> x/y """
  66.         pass
  67.  
  68.     def __float__(self):
  69.         """ 转换为浮点类型 """
  70.         """ x.__float__() <==> float(x) """
  71.         pass
  72.  
  73.     def __floordiv__(self, y):
  74.         """ x.__floordiv__(y) <==> x//y """
  75.         pass
  76.  
  77.     def __format__(self, *args, **kwargs): # real signature unknown
  78.         pass
  79.  
  80.     def __getattribute__(self, name):
  81.         """ x.__getattribute__('name') <==> x.name """
  82.         pass
  83.  
  84.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  85.         """ 内部调用 __new__方法或创建对象时传入参数使用 """
  86.         pass
  87.  
  88.     def __hash__(self):
  89.         """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
  90.         """ x.__hash__() <==> hash(x) """
  91.         pass
  92.  
  93.     def __hex__(self):
  94.         """ 返回当前数的 十六进制 表示 """
  95.         """ x.__hex__() <==> hex(x) """
  96.         pass
  97.  
  98.     def __index__(self):
  99.         """ 用于切片，数字无意义 """
  100.         """ x[y:z] <==> x[y.__index__():z.__index__()] """
  101.         pass
  102.  
  103.     def __init__(self, x, base=10): # known special case of int.__init__
  104.         """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
  105.         """
  106.         int(x=0) -> int or long
  107.         int(x, base=10) -> int or long
  108.  
  109.         Convert a number or string to an integer, or return 0 if no arguments
  110.         are given.  If x is floating point, the conversion truncates towards zero.
  111.         If x is outside the integer range, the function returns a long instead.
  112.  
  113.         If x is not a number or if base is given, then x must be a string or
  114.         Unicode object representing an integer literal in the given base.  The
  115.         literal can be preceded by '+' or '-' and be surrounded by whitespace.
  116.         The base defaults to 10.  Valid bases are 0 and 2-36.  Base 0 means to
  117.         interpret the base from the string as an integer literal.
  118.         >>> int('0b100', base=0)
  119.  
  120.         # (copied from class doc)
  121.         """
  122.         pass
  123.  
  124.     def __int__(self):
  125.         """ 转换为整数 """
  126.         """ x.__int__() <==> int(x) """
  127.         pass
  128.  
  129.     def __invert__(self):
  130.         """ x.__invert__() <==> ~x """
  131.         pass
  132.  
  133.     def __long__(self):
  134.         """ 转换为长整数 """
  135.         """ x.__long__() <==> long(x) """
  136.         pass
  137.  
  138.     def __lshift__(self, y):
  139.         """ x.__lshift__(y) <==> x<<y """
  140.         pass
  141.  
  142.     def __mod__(self, y):
  143.         """ x.__mod__(y) <==> x%y """
  144.         pass
  145.  
  146.     def __mul__(self, y):
  147.         """ x.__mul__(y) <==> x*y """
  148.         pass
  149.  
  150.     def __neg__(self):
  151.         """ x.__neg__() <==> -x """
  152.         pass
  153.  
  154.     @staticmethod # known case of __new__
  155.     def __new__(S, *more):
  156.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  157.         pass
  158.  
  159.     def __nonzero__(self):
  160.         """ x.__nonzero__() <==> x != 0 """
  161.         pass
  162.  
  163.     def __oct__(self):
  164.         """ 返回改值的 八进制 表示 """
  165.         """ x.__oct__() <==> oct(x) """
  166.         pass
  167.  
  168.     def __or__(self, y):
  169.         """ x.__or__(y) <==> x|y """
  170.         pass
  171.  
  172.     def __pos__(self):
  173.         """ x.__pos__() <==> +x """
  174.         pass
  175.  
  176.     def __pow__(self, y, z=None):
  177.         """ 幂，次方 """
  178.         """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
  179.         pass
  180.  
  181.     def __radd__(self, y):
  182.         """ x.__radd__(y) <==> y+x """
  183.         pass
  184.  
  185.     def __rand__(self, y):
  186.         """ x.__rand__(y) <==> y&x """
  187.         pass
  188.  
  189.     def __rdivmod__(self, y):
  190.         """ x.__rdivmod__(y) <==> divmod(y, x) """
  191.         pass
  192.  
  193.     def __rdiv__(self, y):
  194.         """ x.__rdiv__(y) <==> y/x """
  195.         pass
  196.  
  197.     def __repr__(self):
  198.         """转化为解释器可读取的形式 """
  199.         """ x.__repr__() <==> repr(x) """
  200.         pass
  201.  
  202.     def __str__(self):
  203.         """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
  204.         """ x.__str__() <==> str(x) """
  205.         pass
  206.  
  207.     def __rfloordiv__(self, y):
  208.         """ x.__rfloordiv__(y) <==> y//x """
  209.         pass
  210.  
  211.     def __rlshift__(self, y):
  212.         """ x.__rlshift__(y) <==> y<<x """
  213.         pass
  214.  
  215.     def __rmod__(self, y):
  216.         """ x.__rmod__(y) <==> y%x """
  217.         pass
  218.  
  219.     def __rmul__(self, y):
  220.         """ x.__rmul__(y) <==> y*x """
  221.         pass
  222.  
  223.     def __ror__(self, y):
  224.         """ x.__ror__(y) <==> y|x """
  225.         pass
  226.  
  227.     def __rpow__(self, x, z=None):
  228.         """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
  229.         pass
  230.  
  231.     def __rrshift__(self, y):
  232.         """ x.__rrshift__(y) <==> y>>x """
  233.         pass
  234.  
  235.     def __rshift__(self, y):
  236.         """ x.__rshift__(y) <==> x>>y """
  237.         pass
  238.  
  239.     def __rsub__(self, y):
  240.         """ x.__rsub__(y) <==> y-x """
  241.         pass
  242.  
  243.     def __rtruediv__(self, y):
  244.         """ x.__rtruediv__(y) <==> y/x """
  245.         pass
  246.  
  247.     def __rxor__(self, y):
  248.         """ x.__rxor__(y) <==> y^x """
  249.         pass
  250.  
  251.     def __sub__(self, y):
  252.         """ x.__sub__(y) <==> x-y """
  253.         pass
  254.  
  255.     def __truediv__(self, y):
  256.         """ x.__truediv__(y) <==> x/y """
  257.         pass
  258.  
  259.     def __trunc__(self, *args, **kwargs):
  260.         """ 返回数值被截取为整形的值，在整形中无意义 """
  261.         pass
  262.  
  263.     def __xor__(self, y):
  264.         """ x.__xor__(y) <==> x^y """
  265.         pass
  266.  
  267.     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  268.     """ 分母 = 1 """
  269.     """the denominator of a rational number in lowest terms"""
  270.  
  271.     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  272.     """ 虚数，无意义 """
  273.     """the imaginary part of a complex number"""
  274.  
  275.     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  276.     """ 分子 = 数字大小 """
  277.     """the numerator of a rational number in lowest terms"""
  278.  
  279.     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
  280.     """ 实属，无意义 """
  281.     """the real part of a complex number"""
  282.  
  283. int

int

２.字符串：str

例如"hello world"

字符串常用功能：
  • 移除空白（strip）
  • 分割（split）　
  • 长度（len）
  • 索引（index）
  • 切片（str_name[0:len(str_name)）
  • 拼接（join）
  • 替换（replace）
  • 转大写（upper）
  • 翻转大小写（swapcase）
  • 查包含的方法（dir）
  • 字符串拼接（+或者(str1.__add__(str2))）
  • 首字母大写（capitalize）
  • 字符串居中，其他位置填充星号（center(长度,"*")）
  • 统计字符串出现次数（count）
  • 判断以某字符开头（startswith）
  • 判断以某字符结尾（endswith）
  • Tab符转换为空格（expandtabs）
  1. class str(basestring):
  2.     """
  3.     str(object='') -> string
  4.  
  5.     Return a nice string representation of the object.
  6.     If the argument is a string, the return value is the same object.
  7.     """
  8.     def capitalize(self):
  9.         """ 首字母变大写 """
  10.         """
  11.         S.capitalize() -> string
  12.  
  13.         Return a copy of the string S with only its first character
  14.         capitalized.
  15.         """
  16.         return ""
  17.  
  18.     def center(self, width, fillchar=None):
  19.         """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
  20.         """
  21.         S.center(width[, fillchar]) -> string
  22.  
  23.         Return S centered in a string of length width. Padding is
  24.         done using the specified fill character (default is a space)
  25.         """
  26.         return ""
  27.  
  28.     def count(self, sub, start=None, end=None):
  29.         """ 子序列个数 """
  30.         """
  31.         S.count(sub[, start[, end]]) -> int
  32.  
  33.         Return the number of non-overlapping occurrences of substring sub in
  34.         string S[start:end].  Optional arguments start and end are interpreted
  35.         as in slice notation.
  36.         """
  37.         return 0
  38.  
  39.     def decode(self, encoding=None, errors=None):
  40.         """ 解码 """
  41.         """
  42.         S.decode([encoding[,errors]]) -> object
  43.  
  44.         Decodes S using the codec registered for encoding. encoding defaults
  45.         to the default encoding. errors may be given to set a different error
  46.         handling scheme. Default is 'strict' meaning that encoding errors raise
  47.         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  48.         as well as any other name registered with codecs.register_error that is
  49.         able to handle UnicodeDecodeErrors.
  50.         """
  51.         return object()
  52.  
  53.     def encode(self, encoding=None, errors=None):
  54.         """ 编码，针对unicode """
  55.         """
  56.         S.encode([encoding[,errors]]) -> object
  57.  
  58.         Encodes S using the codec registered for encoding. encoding defaults
  59.         to the default encoding. errors may be given to set a different error
  60.         handling scheme. Default is 'strict' meaning that encoding errors raise
  61.         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
  62.         'xmlcharrefreplace' as well as any other name registered with
  63.         codecs.register_error that is able to handle UnicodeEncodeErrors.
  64.         """
  65.         return object()
  66.  
  67.     def endswith(self, suffix, start=None, end=None):
  68.         """ 是否以 xxx 结束 """
  69.         """
  70.         S.endswith(suffix[, start[, end]]) -> bool
  71.  
  72.         Return True if S ends with the specified suffix, False otherwise.
  73.         With optional start, test S beginning at that position.
  74.         With optional end, stop comparing S at that position.
  75.         suffix can also be a tuple of strings to try.
  76.         """
  77.         return False
  78.  
  79.     def expandtabs(self, tabsize=None):
  80.         """ 将tab转换成空格，默认一个tab转换成8个空格 """
  81.         """
  82.         S.expandtabs([tabsize]) -> string
  83.  
  84.         Return a copy of S where all tab characters are expanded using spaces.
  85.         If tabsize is not given, a tab size of 8 characters is assumed.
  86.         """
  87.         return ""
  88.  
  89.     def find(self, sub, start=None, end=None):
  90.         """ 寻找子序列位置，如果没找到，返回 -1 """
  91.         """
  92.         S.find(sub [,start [,end]]) -> int
  93.  
  94.         Return the lowest index in S where substring sub is found,
  95.         such that sub is contained within S[start:end].  Optional
  96.         arguments start and end are interpreted as in slice notation.
  97.  
  98.         Return -1 on failure.
  99.         """
  100.         return 0
  101.  
  102.     def format(*args, **kwargs): # known special case of str.format
  103.         """ 字符串格式化，动态参数，将函数式编程时细说 """
  104.         """
  105.         S.format(*args, **kwargs) -> string
  106.  
  107.         Return a formatted version of S, using substitutions from args and kwargs.
  108.         The substitutions are identified by braces ('{' and '}').
  109.         """
  110.         pass
  111.  
  112.     def index(self, sub, start=None, end=None):
  113.         """ 子序列位置，如果没找到，报错 """
  114.         S.index(sub [,start [,end]]) -> int
  115.  
  116.         Like S.find() but raise ValueError when the substring is not found.
  117.         """
  118.         return 0
  119.  
  120.     def isalnum(self):
  121.         """ 是否是字母和数字 """
  122.         """
  123.         S.isalnum() -> bool
  124.  
  125.         Return True if all characters in S are alphanumeric
  126.         and there is at least one character in S, False otherwise.
  127.         """
  128.         return False
  129.  
  130.     def isalpha(self):
  131.         """ 是否是字母 """
  132.         """
  133.         S.isalpha() -> bool
  134.  
  135.         Return True if all characters in S are alphabetic
  136.         and there is at least one character in S, False otherwise.
  137.         """
  138.         return False
  139.  
  140.     def isdigit(self):
  141.         """ 是否是数字 """
  142.         """
  143.         S.isdigit() -> bool
  144.  
  145.         Return True if all characters in S are digits
  146.         and there is at least one character in S, False otherwise.
  147.         """
  148.         return False
  149.  
  150.     def islower(self):
  151.         """ 是否小写 """
  152.         """
  153.         S.islower() -> bool
  154.  
  155.         Return True if all cased characters in S are lowercase and there is
  156.         at least one cased character in S, False otherwise.
  157.         """
  158.         return False
  159.  
  160.     def isspace(self):
  161.         """
  162.         S.isspace() -> bool
  163.  
  164.         Return True if all characters in S are whitespace
  165.         and there is at least one character in S, False otherwise.
  166.         """
  167.         return False
  168.  
  169.     def istitle(self):
  170.         """
  171.         S.istitle() -> bool
  172.  
  173.         Return True if S is a titlecased string and there is at least one
  174.         character in S, i.e. uppercase characters may only follow uncased
  175.         characters and lowercase characters only cased ones. Return False
  176.         otherwise.
  177.         """
  178.         return False
  179.  
  180.     def isupper(self):
  181.         """
  182.         S.isupper() -> bool
  183.  
  184.         Return True if all cased characters in S are uppercase and there is
  185.         at least one cased character in S, False otherwise.
  186.         """
  187.         return False
  188.  
  189.     def join(self, iterable):
  190.         """ 连接 """
  191.         """
  192.         S.join(iterable) -> string
  193.  
  194.         Return a string which is the concatenation of the strings in the
  195.         iterable.  The separator between elements is S.
  196.         """
  197.         return ""
  198.  
  199.     def ljust(self, width, fillchar=None):
  200.         """ 内容左对齐，右侧填充 """
  201.         """
  202.         S.ljust(width[, fillchar]) -> string
  203.  
  204.         Return S left-justified in a string of length width. Padding is
  205.         done using the specified fill character (default is a space).
  206.         """
  207.         return ""
  208.  
  209.     def lower(self):
  210.         """ 变小写 """
  211.         """
  212.         S.lower() -> string
  213.  
  214.         Return a copy of the string S converted to lowercase.
  215.         """
  216.         return ""
  217.  
  218.     def lstrip(self, chars=None):
  219.         """ 移除左侧空白 """
  220.         """
  221.         S.lstrip([chars]) -> string or unicode
  222.  
  223.         Return a copy of the string S with leading whitespace removed.
  224.         If chars is given and not None, remove characters in chars instead.
  225.         If chars is unicode, S will be converted to unicode before stripping
  226.         """
  227.         return ""
  228.  
  229.     def partition(self, sep):
  230.         """ 分割，前，中，后三部分 """
  231.         """
  232.         S.partition(sep) -> (head, sep, tail)
  233.  
  234.         Search for the separator sep in S, and return the part before it,
  235.         the separator itself, and the part after it.  If the separator is not
  236.         found, return S and two empty strings.
  237.         """
  238.         pass
  239.  
  240.     def replace(self, old, new, count=None):
  241.         """ 替换 """
  242.         """
  243.         S.replace(old, new[, count]) -> string
  244.  
  245.         Return a copy of string S with all occurrences of substring
  246.         old replaced by new.  If the optional argument count is
  247.         given, only the first count occurrences are replaced.
  248.         """
  249.         return ""
  250.  
  251.     def rfind(self, sub, start=None, end=None):
  252.         """
  253.         S.rfind(sub [,start [,end]]) -> int
  254.  
  255.         Return the highest index in S where substring sub is found,
  256.         such that sub is contained within S[start:end].  Optional
  257.         arguments start and end are interpreted as in slice notation.
  258.  
  259.         Return -1 on failure.
  260.         """
  261.         return 0
  262.  
  263.     def rindex(self, sub, start=None, end=None):
  264.         """
  265.         S.rindex(sub [,start [,end]]) -> int
  266.  
  267.         Like S.rfind() but raise ValueError when the substring is not found.
  268.         """
  269.         return 0
  270.  
  271.     def rjust(self, width, fillchar=None):
  272.         """
  273.         S.rjust(width[, fillchar]) -> string
  274.  
  275.         Return S right-justified in a string of length width. Padding is
  276.         done using the specified fill character (default is a space)
  277.         """
  278.         return ""
  279.  
  280.     def rpartition(self, sep):
  281.         """
  282.         S.rpartition(sep) -> (head, sep, tail)
  283.  
  284.         Search for the separator sep in S, starting at the end of S, and return
  285.         the part before it, the separator itself, and the part after it.  If the
  286.         separator is not found, return two empty strings and S.
  287.         """
  288.         pass
  289.  
  290.     def rsplit(self, sep=None, maxsplit=None):
  291.         """
  292.         S.rsplit([sep [,maxsplit]]) -> list of strings
  293.  
  294.         Return a list of the words in the string S, using sep as the
  295.         delimiter string, starting at the end of the string and working
  296.         to the front.  If maxsplit is given, at most maxsplit splits are
  297.         done. If sep is not specified or is None, any whitespace string
  298.         is a separator.
  299.         """
  300.         return []
  301.  
  302.     def rstrip(self, chars=None):
  303.         """
  304.         S.rstrip([chars]) -> string or unicode
  305.  
  306.         Return a copy of the string S with trailing whitespace removed.
  307.         If chars is given and not None, remove characters in chars instead.
  308.         If chars is unicode, S will be converted to unicode before stripping
  309.         """
  310.         return ""
  311.  
  312.     def split(self, sep=None, maxsplit=None):
  313.         """ 分割， maxsplit最多分割几次 """
  314.         """
  315.         S.split([sep [,maxsplit]]) -> list of strings
  316.  
  317.         Return a list of the words in the string S, using sep as the
  318.         delimiter string.  If maxsplit is given, at most maxsplit
  319.         splits are done. If sep is not specified or is None, any
  320.         whitespace string is a separator and empty strings are removed
  321.         from the result.
  322.         """
  323.         return []
  324.  
  325.     def splitlines(self, keepends=False):
  326.         """ 根据换行分割 """
  327.         """
  328.         S.splitlines(keepends=False) -> list of strings
  329.  
  330.         Return a list of the lines in S, breaking at line boundaries.
  331.         Line breaks are not included in the resulting list unless keepends
  332.         is given and true.
  333.         """
  334.         return []
  335.  
  336.     def startswith(self, prefix, start=None, end=None):
  337.         """ 是否起始 """
  338.         """
  339.         S.startswith(prefix[, start[, end]]) -> bool
  340.  
  341.         Return True if S starts with the specified prefix, False otherwise.
  342.         With optional start, test S beginning at that position.
  343.         With optional end, stop comparing S at that position.
  344.         prefix can also be a tuple of strings to try.
  345.         """
  346.         return False
  347.  
  348.     def strip(self, chars=None):
  349.         """ 移除两段空白 """
  350.         """
  351.         S.strip([chars]) -> string or unicode
  352.  
  353.         Return a copy of the string S with leading and trailing
  354.         whitespace removed.
  355.         If chars is given and not None, remove characters in chars instead.
  356.         If chars is unicode, S will be converted to unicode before stripping
  357.         """
  358.         return ""
  359.  
  360.     def swapcase(self):
  361.         """ 大写变小写，小写变大写 """
  362.         """
  363.         S.swapcase() -> string
  364.  
  365.         Return a copy of the string S with uppercase characters
  366.         converted to lowercase and vice versa.
  367.         """
  368.         return ""
  369.  
  370.     def title(self):
  371.         """
  372.         S.title() -> string
  373.  
  374.         Return a titlecased version of S, i.e. words start with uppercase
  375.         characters, all remaining cased characters have lowercase.
  376.         """
  377.         return ""
  378.  
  379.     def translate(self, table, deletechars=None):
  380.         """
  381.         转换，需要先做一个对应表，最后一个表示删除字符集合
  382.         intab = "aeiou"
  383.         outtab = ""
  384.         trantab = maketrans(intab, outtab)
  385.         str = "this is string example....wow!!!"
  386.         print str.translate(trantab, 'xm')
  387.         """
  388.  
  389.         """
  390.         S.translate(table [,deletechars]) -> string
  391.  
  392.         Return a copy of the string S, where all characters occurring
  393.         in the optional argument deletechars are removed, and the
  394.         remaining characters have been mapped through the given
  395.         translation table, which must be a string of length 256 or None.
  396.         If the table argument is None, no translation is applied and
  397.         the operation simply removes the characters in deletechars.
  398.         """
  399.         return ""
  400.  
  401.     def upper(self):
  402.         """
  403.         S.upper() -> string
  404.  
  405.         Return a copy of the string S converted to uppercase.
  406.         """
  407.         return ""
  408.  
  409.     def zfill(self, width):
  410.         """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
  411.         """
  412.         S.zfill(width) -> string
  413.  
  414.         Pad a numeric string S with zeros on the left, to fill a field
  415.         of the specified width.  The string S is never truncated.
  416.         """
  417.         return ""
  418.  
  419.     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  420.         pass
  421.  
  422.     def _formatter_parser(self, *args, **kwargs): # real signature unknown
  423.         pass
  424.  
  425.     def __add__(self, y):
  426.         """ x.__add__(y) <==> x+y """
  427.         pass
  428.  
  429.     def __contains__(self, y):
  430.         """ x.__contains__(y) <==> y in x """
  431.         pass
  432.  
  433.     def __eq__(self, y):
  434.         """ x.__eq__(y) <==> x==y """
  435.         pass
  436.  
  437.     def __format__(self, format_spec):
  438.         """
  439.         S.__format__(format_spec) -> string
  440.  
  441.         Return a formatted version of S as described by format_spec.
  442.         """
  443.         return ""
  444.  
  445.     def __getattribute__(self, name):
  446.         """ x.__getattribute__('name') <==> x.name """
  447.         pass
  448.  
  449.     def __getitem__(self, y):
  450.         """ x.__getitem__(y) <==> x[y] """
  451.         pass
  452.  
  453.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  454.         pass
  455.  
  456.     def __getslice__(self, i, j):
  457.         """
  458.         x.__getslice__(i, j) <==> x[i:j]
  459.  
  460.                    Use of negative indices is not supported.
  461.         """
  462.         pass
  463.  
  464.     def __ge__(self, y):
  465.         """ x.__ge__(y) <==> x>=y """
  466.         pass
  467.  
  468.     def __gt__(self, y):
  469.         """ x.__gt__(y) <==> x>y """
  470.         pass
  471.  
  472.     def __hash__(self):
  473.         """ x.__hash__() <==> hash(x) """
  474.         pass
  475.  
  476.     def __init__(self, string=''): # known special case of str.__init__
  477.         """
  478.         str(object='') -> string
  479.  
  480.         Return a nice string representation of the object.
  481.         If the argument is a string, the return value is the same object.
  482.         # (copied from class doc)
  483.         """
  484.         pass
  485.  
  486.     def __len__(self):
  487.         """ x.__len__() <==> len(x) """
  488.         pass
  489.  
  490.     def __le__(self, y):
  491.         """ x.__le__(y) <==> x<=y """
  492.         pass
  493.  
  494.     def __lt__(self, y):
  495.         """ x.__lt__(y) <==> x<y """
  496.         pass
  497.  
  498.     def __mod__(self, y):
  499.         """ x.__mod__(y) <==> x%y """
  500.         pass
  501.  
  502.     def __mul__(self, n):
  503.         """ x.__mul__(n) <==> x*n """
  504.         pass
  505.  
  506.     @staticmethod # known case of __new__
  507.     def __new__(S, *more):
  508.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  509.         pass
  510.  
  511.     def __ne__(self, y):
  512.         """ x.__ne__(y) <==> x!=y """
  513.         pass
  514.  
  515.     def __repr__(self):
  516.         """ x.__repr__() <==> repr(x) """
  517.         pass
  518.  
  519.     def __rmod__(self, y):
  520.         """ x.__rmod__(y) <==> y%x """
  521.         pass
  522.  
  523.     def __rmul__(self, n):
  524.         """ x.__rmul__(n) <==> n*x """
  525.         pass
  526.  
  527.     def __sizeof__(self):
  528.         """ S.__sizeof__() -> size of S in memory, in bytes """
  529.         pass
  530.  
  531.     def __str__(self):
  532.         """ x.__str__() <==> str(x) """
  533.         pass
  534.  
  535. str
  536. str

str

３.列表：list

例如[11,22,33,44]

列表基本操作：

  • 索引（index）
  • 切片（[xx_index:xx_index]）
  • 追加（append）
  • 删除（del或者pop或者remove...）
  • 长度（len）
  • 循环（while或者for）
  • 包含（in）
  • 翻转（reverse）
  1. class list(object):
  2.     """
  3.     list() -> new empty list
  4.     list(iterable) -> new list initialized from iterable's items
  5.     """
  6.     def append(self, p_object): # real signature unknown; restored from __doc__
  7.         """ L.append(object) -- append object to end """
  8.         pass
  9.  
  10.     def count(self, value): # real signature unknown; restored from __doc__
  11.         """ L.count(value) -> integer -- return number of occurrences of value """
  12.         return 0
  13.  
  14.     def extend(self, iterable): # real signature unknown; restored from __doc__
  15.         """ L.extend(iterable) -- extend list by appending elements from the iterable """
  16.         pass
  17.  
  18.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  19.         """
  20.         L.index(value, [start, [stop]]) -> integer -- return first index of value.
  21.         Raises ValueError if the value is not present.
  22.         """
  23.         return 0
  24.  
  25.     def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26.         """ L.insert(index, object) -- insert object before index """
  27.         pass
  28.  
  29.     def pop(self, index=None): # real signature unknown; restored from __doc__
  30.         """
  31.         L.pop([index]) -> item -- remove and return item at index (default last).
  32.         Raises IndexError if list is empty or index is out of range.
  33.         """
  34.         pass
  35.  
  36.     def remove(self, value): # real signature unknown; restored from __doc__
  37.         """
  38.         L.remove(value) -- remove first occurrence of value.
  39.         Raises ValueError if the value is not present.
  40.         """
  41.         pass
  42.  
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ L.reverse() -- reverse *IN PLACE* """
  45.         pass
  46.  
  47.     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
  48.         """
  49.         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
  50.         cmp(x, y) -> -1, 0, 1
  51.         """
  52.         pass
  53.  
  54.     def __add__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__add__(y) <==> x+y """
  56.         pass
  57.  
  58.     def __contains__(self, y): # real signature unknown; restored from __doc__
  59.         """ x.__contains__(y) <==> y in x """
  60.         pass
  61.  
  62.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  63.         """ x.__delitem__(y) <==> del x[y] """
  64.         pass
  65.  
  66.     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
  67.         """
  68.         x.__delslice__(i, j) <==> del x[i:j]
  69.  
  70.                    Use of negative indices is not supported.
  71.         """
  72.         pass
  73.  
  74.     def __eq__(self, y): # real signature unknown; restored from __doc__
  75.         """ x.__eq__(y) <==> x==y """
  76.         pass
  77.  
  78.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  81.  
  82.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  83.         """ x.__getitem__(y) <==> x[y] """
  84.         pass
  85.  
  86.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  87.         """
  88.         x.__getslice__(i, j) <==> x[i:j]
  89.  
  90.                    Use of negative indices is not supported.
  91.         """
  92.         pass
  93.  
  94.     def __ge__(self, y): # real signature unknown; restored from __doc__
  95.         """ x.__ge__(y) <==> x>=y """
  96.         pass
  97.  
  98.     def __gt__(self, y): # real signature unknown; restored from __doc__
  99.         """ x.__gt__(y) <==> x>y """
  100.         pass
  101.  
  102.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  103.         """ x.__iadd__(y) <==> x+=y """
  104.         pass
  105.  
  106.     def __imul__(self, y): # real signature unknown; restored from __doc__
  107.         """ x.__imul__(y) <==> x*=y """
  108.         pass
  109.  
  110.     def __init__(self, seq=()): # known special case of list.__init__
  111.         """
  112.         list() -> new empty list
  113.         list(iterable) -> new list initialized from iterable's items
  114.         # (copied from class doc)
  115.         """
  116.         pass
  117.  
  118.     def __iter__(self): # real signature unknown; restored from __doc__
  119.         """ x.__iter__() <==> iter(x) """
  120.         pass
  121.  
  122.     def __len__(self): # real signature unknown; restored from __doc__
  123.         """ x.__len__() <==> len(x) """
  124.         pass
  125.  
  126.     def __le__(self, y): # real signature unknown; restored from __doc__
  127.         """ x.__le__(y) <==> x<=y """
  128.         pass
  129.  
  130.     def __lt__(self, y): # real signature unknown; restored from __doc__
  131.         """ x.__lt__(y) <==> x<y """
  132.         pass
  133.  
  134.     def __mul__(self, n): # real signature unknown; restored from __doc__
  135.         """ x.__mul__(n) <==> x*n """
  136.         pass
  137.  
  138.     @staticmethod # known case of __new__
  139.     def __new__(S, *more): # real signature unknown; restored from __doc__
  140.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  141.         pass
  142.  
  143.     def __ne__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ne__(y) <==> x!=y """
  145.         pass
  146.  
  147.     def __repr__(self): # real signature unknown; restored from __doc__
  148.         """ x.__repr__() <==> repr(x) """
  149.         pass
  150.  
  151.     def __reversed__(self): # real signature unknown; restored from __doc__
  152.         """ L.__reversed__() -- return a reverse iterator over the list """
  153.         pass
  154.  
  155.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  156.         """ x.__rmul__(n) <==> n*x """
  157.         pass
  158.  
  159.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  160.         """ x.__setitem__(i, y) <==> x[i]=y """
  161.         pass
  162.  
  163.     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
  164.         """
  165.         x.__setslice__(i, j, y) <==> x[i:j]=y
  166.  
  167.                    Use  of negative indices is not supported.
  168.         """
  169.         pass
  170.  
  171.     def __sizeof__(self): # real signature unknown; restored from __doc__
  172.         """ L.__sizeof__() -- size of L in memory, in bytes """
  173.         pass
  174.  
  175.     __hash__ = None
  176. list

list

列表内删除元素举例：

  1. #del删除对应下标的元素
  2. >>> li = [11,22,33,44,55,66]
  3. >>> del li[1]
  4. >>> li
  5. [11, 33, 44, 55, 66]
  6.  
  7. #pop.()删除最后一个元素
  8. >>> li.pop()
  9. >>> li
  10. [11, 33, 44, 55]
  11.  
  12. #删除指定元素
  13. >>> li.remove(33)
  14. >>> li
  15. [11, 44, 55]
  16.  
  17. #使用切片删除
  18. >>> li = li[:-1]
  19. >>> li
  20. [11, 44]

列表删除用法举例

４.元祖：tuple

基本操作：
  • 索引（index）
  • 切片（1：3）
  • 循环(for)
  • 长度(len)
  • 包含(in)
  1. #索引指定下标位置的元素
  2. print(name_tuple[0])
  3.  
  4. #len 判断元组长度
  5. print(len(name_tuple))
  6.  
  7. #切片操作
  8. print(name_tuple[0:1])
  9.  
  10. #for循环操作
  11. for i in name_tuple:
  12.     print(i)
  13.  
  14. # count，计算元素出现的个数
  15. print(name_tuple.count('seven'))
  16.  
  17. # index 获取指定元素的索引位置
  18. print(name_tuple.index('seven))
  19.  
  20. #删除
  21. 不支持类似列表的删除操作del name_tuple[0]

元组用法举例

  1. class tuple(object):
  2.     """
  3.     tuple() -> empty tuple
  4.     tuple(iterable) -> tuple initialized from iterable's items
  5.  
  6.     If the argument is a tuple, the return value is the same object.
  7.     """
  8.     def count(self, value): # real signature unknown; restored from __doc__
  9.         """ T.count(value) -> integer -- return number of occurrences of value """
  10.         return 0
  11.  
  12.     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  13.         """
  14.         T.index(value, [start, [stop]]) -> integer -- return first index of value.
  15.         Raises ValueError if the value is not present.
  16.         """
  17.         return 0
  18.  
  19.     def __add__(self, y): # real signature unknown; restored from __doc__
  20.         """ x.__add__(y) <==> x+y """
  21.         pass
  22.  
  23.     def __contains__(self, y): # real signature unknown; restored from __doc__
  24.         """ x.__contains__(y) <==> y in x """
  25.         pass
  26.  
  27.     def __eq__(self, y): # real signature unknown; restored from __doc__
  28.         """ x.__eq__(y) <==> x==y """
  29.         pass
  30.  
  31.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  32.         """ x.__getattribute__('name') <==> x.name """
  33.         pass
  34.  
  35.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  36.         """ x.__getitem__(y) <==> x[y] """
  37.         pass
  38.  
  39.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  40.         pass
  41.  
  42.     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  43.         """
  44.         x.__getslice__(i, j) <==> x[i:j]
  45.  
  46.                    Use of negative indices is not supported.
  47.         """
  48.         pass
  49.  
  50.     def __ge__(self, y): # real signature unknown; restored from __doc__
  51.         """ x.__ge__(y) <==> x>=y """
  52.         pass
  53.  
  54.     def __gt__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__gt__(y) <==> x>y """
  56.         pass
  57.  
  58.     def __hash__(self): # real signature unknown; restored from __doc__
  59.         """ x.__hash__() <==> hash(x) """
  60.         pass
  61.  
  62.     def __init__(self, seq=()): # known special case of tuple.__init__
  63.         """
  64.         tuple() -> empty tuple
  65.         tuple(iterable) -> tuple initialized from iterable's items
  66.  
  67.         If the argument is a tuple, the return value is the same object.
  68.         # (copied from class doc)
  69.         """
  70.         pass
  71.  
  72.     def __iter__(self): # real signature unknown; restored from __doc__
  73.         """ x.__iter__() <==> iter(x) """
  74.         pass
  75.  
  76.     def __len__(self): # real signature unknown; restored from __doc__
  77.         """ x.__len__() <==> len(x) """
  78.         pass
  79.  
  80.     def __le__(self, y): # real signature unknown; restored from __doc__
  81.         """ x.__le__(y) <==> x<=y """
  82.         pass
  83.  
  84.     def __lt__(self, y): # real signature unknown; restored from __doc__
  85.         """ x.__lt__(y) <==> x<y """
  86.         pass
  87.  
  88.     def __mul__(self, n): # real signature unknown; restored from __doc__
  89.         """ x.__mul__(n) <==> x*n """
  90.         pass
  91.  
  92.     @staticmethod # known case of __new__
  93.     def __new__(S, *more): # real signature unknown; restored from __doc__
  94.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  95.         pass
  96.  
  97.     def __ne__(self, y): # real signature unknown; restored from __doc__
  98.         """ x.__ne__(y) <==> x!=y """
  99.         pass
  100.  
  101.     def __repr__(self): # real signature unknown; restored from __doc__
  102.         """ x.__repr__() <==> repr(x) """
  103.         pass
  104.  
  105.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  106.         """ x.__rmul__(n) <==> n*x """
  107.         pass
  108.  
  109.     def __sizeof__(self): # real signature unknown; restored from __doc__
  110.         """ T.__sizeof__() -- size of T in memory, in bytes """
  111.         pass
  112. tuple

tuple

５.字典：dict

常用操作：

  • 索引（index）
  • 新增（update）
  • 删除（del）
  • 清空（clear）
  • 键、值、键值对（）
  • 循环（while或者for）
  • 长度（len）
  1. class dict(object):
  2.     """
  3.     dict() -> new empty dictionary
  4.     dict(mapping) -> new dictionary initialized from a mapping object's
  5.         (key, value) pairs
  6.     dict(iterable) -> new dictionary initialized as if via:
  7.         d = {}
  8.         for k, v in iterable:
  9.             d[k] = v
  10.     dict(**kwargs) -> new dictionary initialized with the name=value pairs
  11.         in the keyword argument list.  For example:  dict(one=1, two=2)
  12.     """
  13.  
  14.     def clear(self): # real signature unknown; restored from __doc__
  15.         """ 清除内容 """
  16.         """ D.clear() -> None.  Remove all items from D. """
  17.         pass
  18.  
  19.     def copy(self): # real signature unknown; restored from __doc__
  20.         """ 浅拷贝 """
  21.         """ D.copy() -> a shallow copy of D """
  22.         pass
  23.  
  24.     @staticmethod # known case
  25.     def fromkeys(S, v=None): # real signature unknown; restored from __doc__
  26.         """
  27.         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
  28.         v defaults to None.
  29.         """
  30.         pass
  31.  
  32.     def get(self, k, d=None): # real signature unknown; restored from __doc__
  33.         """ 根据key获取值，d是默认值 """
  34.         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
  35.         pass
  36.  
  37.     def has_key(self, k): # real signature unknown; restored from __doc__
  38.         """ 是否有key """
  39.         """ D.has_key(k) -> True if D has a key k, else False """
  40.         return False
  41.  
  42.     def items(self): # real signature unknown; restored from __doc__
  43.         """ 所有项的列表形式 """
  44.         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
  45.         return []
  46.  
  47.     def iteritems(self): # real signature unknown; restored from __doc__
  48.         """ 项可迭代 """
  49.         """ D.iteritems() -> an iterator over the (key, value) items of D """
  50.         pass
  51.  
  52.     def iterkeys(self): # real signature unknown; restored from __doc__
  53.         """ key可迭代 """
  54.         """ D.iterkeys() -> an iterator over the keys of D """
  55.         pass
  56.  
  57.     def itervalues(self): # real signature unknown; restored from __doc__
  58.         """ value可迭代 """
  59.         """ D.itervalues() -> an iterator over the values of D """
  60.         pass
  61.  
  62.     def keys(self): # real signature unknown; restored from __doc__
  63.         """ 所有的key列表 """
  64.         """ D.keys() -> list of D's keys """
  65.         return []
  66.  
  67.     def pop(self, k, d=None): # real signature unknown; restored from __doc__
  68.         """ 获取并在字典中移除 """
  69.         """
  70.         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
  71.         If key is not found, d is returned if given, otherwise KeyError is raised
  72.         """
  73.         pass
  74.  
  75.     def popitem(self): # real signature unknown; restored from __doc__
  76.         """ 获取并在字典中移除 """
  77.         """
  78.         D.popitem() -> (k, v), remove and return some (key, value) pair as a
  79.         2-tuple; but raise KeyError if D is empty.
  80.         """
  81.         pass
  82.  
  83.     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
  84.         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
  85.         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
  86.         pass
  87.  
  88.     def update(self, E=None, **F): # known special case of dict.update
  89.         """ 更新
  90.             {'name':'alex', 'age': 18000}
  91.             [('name','sbsbsb'),]
  92.         """
  93.         """
  94.         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
  95.         If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
  96.         If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
  97.         In either case, this is followed by: for k in F: D[k] = F[k]
  98.         """
  99.         pass
  100.  
  101.     def values(self): # real signature unknown; restored from __doc__
  102.         """ 所有的值 """
  103.         """ D.values() -> list of D's values """
  104.         return []
  105.  
  106.     def viewitems(self): # real signature unknown; restored from __doc__
  107.         """ 所有项，只是将内容保存至view对象中 """
  108.         """ D.viewitems() -> a set-like object providing a view on D's items """
  109.         pass
  110.  
  111.     def viewkeys(self): # real signature unknown; restored from __doc__
  112.         """ D.viewkeys() -> a set-like object providing a view on D's keys """
  113.         pass
  114.  
  115.     def viewvalues(self): # real signature unknown; restored from __doc__
  116.         """ D.viewvalues() -> an object providing a view on D's values """
  117.         pass
  118.  
  119.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  120.         """ x.__cmp__(y) <==> cmp(x,y) """
  121.         pass
  122.  
  123.     def __contains__(self, k): # real signature unknown; restored from __doc__
  124.         """ D.__contains__(k) -> True if D has a key k, else False """
  125.         return False
  126.  
  127.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  128.         """ x.__delitem__(y) <==> del x[y] """
  129.         pass
  130.  
  131.     def __eq__(self, y): # real signature unknown; restored from __doc__
  132.         """ x.__eq__(y) <==> x==y """
  133.         pass
  134.  
  135.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  136.         """ x.__getattribute__('name') <==> x.name """
  137.         pass
  138.  
  139.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  140.         """ x.__getitem__(y) <==> x[y] """
  141.         pass
  142.  
  143.     def __ge__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ge__(y) <==> x>=y """
  145.         pass
  146.  
  147.     def __gt__(self, y): # real signature unknown; restored from __doc__
  148.         """ x.__gt__(y) <==> x>y """
  149.         pass
  150.  
  151.     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
  152.         """
  153.         dict() -> new empty dictionary
  154.         dict(mapping) -> new dictionary initialized from a mapping object's
  155.             (key, value) pairs
  156.         dict(iterable) -> new dictionary initialized as if via:
  157.             d = {}
  158.             for k, v in iterable:
  159.                 d[k] = v
  160.         dict(**kwargs) -> new dictionary initialized with the name=value pairs
  161.             in the keyword argument list.  For example:  dict(one=1, two=2)
  162.         # (copied from class doc)
  163.         """
  164.         pass
  165.  
  166.     def __iter__(self): # real signature unknown; restored from __doc__
  167.         """ x.__iter__() <==> iter(x) """
  168.         pass
  169.  
  170.     def __len__(self): # real signature unknown; restored from __doc__
  171.         """ x.__len__() <==> len(x) """
  172.         pass
  173.  
  174.     def __le__(self, y): # real signature unknown; restored from __doc__
  175.         """ x.__le__(y) <==> x<=y """
  176.         pass
  177.  
  178.     def __lt__(self, y): # real signature unknown; restored from __doc__
  179.         """ x.__lt__(y) <==> x<y """
  180.         pass
  181.  
  182.     @staticmethod # known case of __new__
  183.     def __new__(S, *more): # real signature unknown; restored from __doc__
  184.         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  185.         pass
  186.  
  187.     def __ne__(self, y): # real signature unknown; restored from __doc__
  188.         """ x.__ne__(y) <==> x!=y """
  189.         pass
  190.  
  191.     def __repr__(self): # real signature unknown; restored from __doc__
  192.         """ x.__repr__() <==> repr(x) """
  193.         pass
  194.  
  195.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  196.         """ x.__setitem__(i, y) <==> x[i]=y """
  197.         pass
  198.  
  199.     def __sizeof__(self): # real signature unknown; restored from __doc__
  200.         """ D.__sizeof__() -> size of D in memory, in bytes """
  201.         pass
  202.  
  203.     __hash__ = None
  204. dict

dict

字典用法举例：

  1. #!/usr/bin/env python
  2. #-*- coding: utf-8 -*-
  3.  
  4. ###################### 字典 ###################
  5. user_info = {
  6.     "name": "Jerry",
  7.     "age": 100,
  8.     "geder": 'Male'
  9. }
  10.  
  11. '''
  12. 字典的每一个元素，称为键值对：
  13. 0   “Jerry"
  14. 1   100
  15. '''
  16.  
  17. # 根据key获取对应value
  18. print(user_info["name"])
  19. print(user_info["age"])
  20.  
  21. for i in user_info:
  22.     print(i)    # 循环，默认值输出key
  23.     print(user_info.keys())     # 获取所有键
  24.     print(user_info.values())   # 获取所有值
  25.     print(user_info.items())    # 获取所有键值对
  26.  
  27. #循环所有keys和values的另一种方式
  28. for i in user_info.keys():
  29.     print(i)
  30. for i in user_info.values():
  31.     print(i)
  32.  
  33. user_info.clear()   # clear，清除所有内容
  34.  
  35. # get 根据key获取值，如果key不存在，可以指定一个默认值
  36. val = user_info.get('age')
  37. print(val)
  38. val = user_info.get('age', '')
  39. print(val)
  40.  
  41. # 索引取值时，key不存在，报错
  42. print(user_info['age'])
  43. print(user_info['age1111'])
  44.  
  45. # has_key 检查字典中指定key是否存在
  46. print(user_info.has_key("name"))
  47.  
  48. #in判断包含某个元素
  49. ret = 'agfffe' in user_info.keys()
  50. print(ret)
  51.  
  52. # pop删除最尾部的一个元素
  53. user_info.pop()
  54.  
  55. # update  添加元素
  56. print(user_info)
  57. test = {
  58.     "a1": 123,
  59.     'a2': 456
  60. }
  61. user_info.update(test)
  62. print(user_info)
  63.  
  64. ##############################
  65. # 删除指定索引的键值对
  66. test = {
  67.     "a1": 123,
  68.     'a2': 456
  69. }
  70.  
  71. del test['a1']
  72. print(test)
  73.  
  74. # enumerate自动生成一列，默认0 自增一
  75. li = ["电脑", "鼠标垫", "U盘", '游艇']
  76. for key, item in enumerate(li, 1):
  77.     print(key,item)
  78.  
  79. # 没有采用enumerate自动生成之前
  80. li = ["电脑", "鼠标垫", "U盘", '游艇']
  81. for item in li:
  82.     print(item)
  83. #
  84. inp = input("请输入商品:")
  85.  
  86. inp = input("请输入商品:")
  87. # 字符串转换成int
  88. inp_num = int(inp)
  89. #
  90. # inp = "0"
  91. # li[inp]    li['0'] 错  li[0]
  92. print(li[inp_num-1])
  93.  
  94. li = ["电脑", "鼠标垫", "U盘", '游艇']
  95.  
  96. inp = input("请输入内容：")
  97. ret = li.index(inp)
  98. print(ret)
  99.  
  100. # range,xrange
  101. # py2.7
  102. # range，用获取指定范围内的数，range(0,10000000)
  103. # xrange，用获取指定范围内的数，xrange(0,10000000)
  104. for i in xrange(1, 1000):
  105.     print(i)
  106.  
  107. py3，range，等同2.7xrange
  108. print(range(1,10))
  109. for i in range(1,10, 2):
  110.     print(i)
  111.  
  112. print(range(10,1))
  113. for i in range(10,1, -2):
  114.     print(i)
  115.  
  116. li = ['alex', 'eirc']
  117.  
  118. leee = len(li) #
  119.  
  120. for i in range(0, leee):
  121.     print(i,li[i])

字典用法举例

6.set集合

set集合，是一个无序且不重复的元素集合

  1. #!/usr/bin/env python
  2. #-*- coding: utf-8 -*-
  3.  
  4. class set(object):
  5.     """
  6.     set() -> new empty set object
  7.     set(iterable) -> new set object
  8.  
  9.     Build an unordered collection of unique elements.
  10.     """
  11.     def add(self, *args, **kwargs): # real signature unknown
  12.         """
  13.         Add an element to a set，添加元素
  14.  
  15.         This has no effect if the element is already present.
  16.         """
  17.         pass
  18.  
  19.     def clear(self, *args, **kwargs): # real signature unknown
  20.         """ Remove all elements from this set. 清除内容"""
  21.         pass
  22.  
  23.     def copy(self, *args, **kwargs): # real signature unknown
  24.         """ Return a shallow copy of a set. 浅拷贝  """
  25.         pass
  26.  
  27.     def difference(self, *args, **kwargs): # real signature unknown
  28.         """
  29.         Return the difference of two or more sets as a new set.
  30.         A.difference(B)找出A中存在的和B中不存在的元素
  31.         (i.e. all elements that are in this set but not the others.)
  32.         """
  33.         pass
  34.  
  35.     def difference_update(self, *args, **kwargs): # real signature unknown
  36.         """ Remove all elements of another set from this set.
  37.         A从当前集合中删除和B中相同的元素,然后更新到A自身"""
  38.         pass
  39.  
  40.     def discard(self, *args, **kwargs): # real signature unknown
  41.         """
  42.         Remove an element from a set if it is a member.
  43.  
  44.         If the element is not a member, do nothing. 移除指定元素，元素不存在不保错
  45.         """
  46.         pass
  47.  
  48.     def intersection(self, *args, **kwargs): # real signature unknown
  49.         """
  50.         Return the intersection of two sets as a new set. 交集
  51.  
  52.         (i.e. all elements that are in both sets.)
  53.         """
  54.         pass
  55.  
  56.     def intersection_update(self, *args, **kwargs): # real signature unknown
  57.         """ Update a set with the intersection of itself and another.  取交集并更更新到A中 """
  58.         pass
  59.  
  60.     def isdisjoint(self, *args, **kwargs): # real signature unknown
  61.         """ Return True if two sets have a null intersection.  如果没有交集，返回True，否则返回False"""
  62.         pass
  63.  
  64.     def issubset(self, *args, **kwargs): # real signature unknown
  65.         """ Report whether another set contains this set.  判断xx是否是xx的子序列"""
  66.         pass
  67.  
  68.     def issuperset(self, *args, **kwargs): # real signature unknown
  69.         """ Report whether this set contains another set. 判断xx是否是xx父序列"""
  70.         pass
  71.  
  72.     def pop(self, *args, **kwargs): # real signature unknown
  73.         """
  74.         Remove and return an arbitrary set element.
  75.         Raises KeyError if the set is empty. 移除元素  并返回个值
  76.         """
  77.         pass
  78.  
  79.     def remove(self, *args, **kwargs): # real signature unknown
  80.         """
  81.         Remove an element from a set; it must be a member.
  82.  
  83.         If the element is not a member, raise a KeyError. 移除指定元素，不存在报错
  84.         """
  85.         pass
  86.  
  87.     def symmetric_difference(self, *args, **kwargs): # real signature unknown
  88.         """
  89.         Return the symmetric difference of two sets as a new set.  对称交集
  90.  
  91.         (i.e. all elements that are in exactly one of the sets.)
  92.         """
  93.         pass
  94.  
  95.     def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
  96.         """ Update a set with the symmetric difference of itself and another. 对称交集，并更新到a中 """
  97.         pass
  98.  
  99.     def union(self, *args, **kwargs): # real signature unknown
  100.         """
  101.         Return the union of sets as a new set.  并集
  102.  
  103.         (i.e. all elements that are in either set.)
  104.         """
  105.         pass
  106.  
  107.     def update(self, *args, **kwargs): # real signature unknown
  108.         """ Update a set with the union of itself and others. 更新集合 """
  109.         pass

set集合

set集合的用法举例

  1. # 添加元素
  2. se = { 11, 22, 33}
  3. print(se)
  4. se.add(44)
  5. print(se)
  6. se.clear()
  7. print(se)
  8.  
  9. ##########################################################################################
  10. # difference
  11. se = {11, 22, 33}
  12. be = {22, 55}
  13.  
  14. # 找se中存在，be中不存在的集合，并将其赋值给新变量
  15. ret = se.difference(be)
  16. print(ret)
  17.  
  18. # 找se中存在，be中不存在的集合，更新se自己
  19. se.difference_update(be)
  20.  
  21. print(se)
  22.  
  23. ##########################################################################################
  24.  
  25. se = {11, 22, 33, 44}
  26. be = {11, 22, 77, 55}
  27.  
  28. # 合集
  29. ret1 = se.union(be)
  30. print(ret1)
  31.  
  32. 添加 还有add方法也是
  33. se.update([444,555,666])
  34. print(se)
  35.  
  36. r1 = se.difference(be)
  37. r2 = be.difference(se)
  38. print(r1)
  39. print(r2)
  40.  
  41. # 对称交际
  42. ret = se.symmetric_difference(be)
  43. print(ret)
  44.  
  45. # 对称交集并更新自身
  46. se.symmetric_difference_update(be)
  47. print(se)
  48.  
  49. # 是否是子序列
  50. ret = se.issubset(be)
  51. print(ret)
  52.  
  53. # 是否是父序列
  54. ret = se.issuperset(be)
  55. print(ret)
  56.  
  57. # （随机）移出并返回值
  58. ret = se.pop
  59. print(ret)
  60.  
  61. # 移出指定值，指定值找不到则报错
  62. se.remove()
  63.  
  64. # 移出指定值，指定值找不到不报错
  65. se.discard()
  66.  
  67. ##########################################################################################

三、补充内容及作业

1.查看对象的类，或对象所具备的功能

  1. 1、type
  2. temp = "alex"
  3. t = type(temp)
  4. print(t)
  5. ## IDE里面 str, ctr+鼠标左，找到 str类，内部所有的方法
  6.  
  7. 2、dir
  8. temp = "alex"
  9. b = dir(temp)
  10.  
  11. 3、help，type
  12. help(type(temp))
  13.  
  14. 4、Pycharm环境下查看
  15. 直接点击
  16. temp = "alex"
  17. temp.upper()
  18. ## IDE里面鼠标放在upper() 上 Ctrl+左键，自动定位到 upper功能处

2.enumrate

为可迭代的对象添加序号

  1. li = [11,22,33]
  2. for k,v in enumerate(li, 1): #指定从1开始显示序号
  3. print(k,v) 
  4.  
  5. #执行结果
  6. (1, 11) (2, 22) (3, 33)

3.range和xrange

指定范围，生成指定的数字

py3，range，等同2.7xrange

  1.  print range(1, 10)
  2.  # 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
  3.  
  4.  print range(1, 10, 2)
  5.  # 结果：[1, 3, 5, 7, 9]
  6.  
  7.  print range(30, 0, -2)
  8.  # 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]　　

4.作业

1元素分类

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

 
2.查找
查找列表中元素，移动空格，并查找以 a或A开头 并且以 c 结尾的所有元素。
    li = ["alec", " aric", "Alex", "Tony", "rain"]
    tu = ("alec", " aric", "Alex", "Tony", "rain") 
    dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}
 
3.输出商品列表，用户输入序号，显示用户选中的商品
    商品 li = ["手机", "电脑", '鼠标垫', '游艇']
 
4.购物车

功能要求：

  • 要求用户输入总资产，例如：2000
  • 显示商品列表，让用户根据序号选择商品，加入购物车
  • 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
  • 附加：可充值、某商品移除购物车

 

  1.  goods = [
  2.      {"name": "电脑", "price": 1999},
  3.      {"name": "鼠标", "price": 10},
  4.      {"name": "游艇", "price": 20},
  5.      {"name": "美女", "price": 998},
  6.  ]

5.用户交互，显示省市县三级联动的选择

  1.  dic = {
  2.      "河北": {
  3.          "石家庄": ["鹿泉", "藁城", "元氏"],
  4.          "邯郸": ["永年", "涉县", "磁县"],
  5.      }
  6.      "河南": {
  7.          ...
  8.      }
  9.      "山西": {
  10.          ...
  11.      }
  12.  
  13.  }

[Python笔记]第二篇:运算符、基本数据类型的更多相关文章

  1. 《javascript权威指南》读书笔记——第二篇

    <javascript权威指南>读书笔记——第二篇 金刚 javascript js javascript权威指南 今天是今年的196天,分享今天的读书笔记. 第2章 词法结构 2.1 字 ...

  2. Python人工智能第二篇：人脸检测和图像识别

    Python人工智能第二篇:人脸检测和图像识别 人脸检测 详细内容请看技术文档:https://ai.baidu.com/docs#/Face-Python-SDK/top from aip impo ...

  3. Python【第二篇】运算符及优先级、数据类型及常用操作、深浅拷贝

    一.运算符及优先级 Python 运算符(算术运算.比较运算.赋值运算.逻辑运算.成员运算) 1.算数运算符 运算符 描述 实例,a=20,b=10 + 加 a+b输出结果30 - 减 a-b输出结果 ...

  4. python 【第二篇】python基本数据类型

    python数据类型 python的数据类型和大多数编程语言一样,有int,float,long,string但是python有三个特殊的数据类型:列表,元组,字典 如果不知道你的数据类型有什么方法: ...

  5. Python人工智能第二篇

    Python人工智能之路 - 第二篇 : 现成的技术   预备资料: 1.FFmpeg: 链接:https://pan.baidu.com/s/1jonSAa_TG2XuaJEy3iTmHg 密码:w ...

  6. Python学习：4.运算符以及数据类型解析

    运算符 一.算数运算: 二.比较运算: 三.赋值运算 四.逻辑运算 五.成员运算 基本数据类型 一.Number(数字) Python3中支持int.float.bool.complex. 使用内置的 ...

  7. c#开发Mongo笔记第二篇

    写到第二篇不得不说是我之前犯了一个小错误,其实实现子表存储也是很简单的事,先说我想实现什么样的效果吧 就是用户表里有个成绩字段,成绩字段是个子表 其实实现这个功能也很简单,用面向对象的思想很好理解,子 ...

  8. python基础-第二篇-基本数据类型

    一.运算符 1.算数运算: 算数运算符相信大家都不陌生吧,尤其是加减乘除,好!那我就带着大家看看最后三个,这三个到底是干什么玩意的? %,取两数相除的余数,看图: **,x的多少次幂,看图: //,取 ...

  9. Python 学习 第二篇：数据类型（字符串）

    字符串是一个字符的.有序的.不可变的序列,用于存储基于文本的信息.字符串所包含的字符存在从左至右的位置顺序,不可以在原处(in-place)修改.Python没有C语言的字符和字符串之分,只有字符串. ...

随机推荐

  1. HAProxy、Nginx 配置 HTTP/2 完整指南

    基于最近对HTTP/2的争论和它的优势,是时候升级底层架构了.这篇文章将会介绍如何在安装和配置HAProxy和Ngnix(使用ssl终端).为了简化流程,我建议你准备好使用Docker镜像. 如果你想 ...

  2. 最长回文 HDU 3068 （裸的Manacher）

    直接看代码: ============================================================================================= ...

  3. poj1019

    有一个序列 1 12 123 1234 ..... ........ ........... 12345678910 ................................ 求第n个数字是什 ...

  4. Deme_遥感控制物体移动（涉及遮罩，小摄像机跟随）

    using UnityEngine; using System.Collections; using UnityEngine.EventSystems; public class JoyControl ...

  5. SQL中存储过程中使用事务,并且加入异常处理机制.

    --存储过程中使用事务,并且加入异常处理机制. -- ============================================= CREATE PROCEDURE [dbo].[UP_ ...

  6. JQuery中_Radio、DropDownList、Checkbox选择控件的处理

    Radio  1.获取选中值,三种方法都可以: $('input:radio:checked').val(): $("input[type='radio']:checked").v ...

  7. 使用Tcl脚本分配FPGA管脚

    自己主动生成Tcl文件 Project -> Generate Tcl File for Project... 弹出例如以下对话框.设置脚本路径. 编辑引脚 使用set_location_ass ...

  8. boost库在工作（15）绑定器与函数对象之三

    前面已经可以优美地解决两个参数的函数给算法for_each调用了,但是又会遇到这样的一种情况,当需要三个参数或者三个以上的参数给算法for_each调用呢?从STL里的绑定器bind1st,显然是不行 ...

  9. log4j配置文件详解---转

    使用步骤注意: 1. 从http://logging.apache.org/log4j/1.2/ 下载文件 2. 在src目录下加入log4j.properties,将jar包放入build -pat ...

  10. TCP/IP协议原理与应用笔记11：TCP/IP中地址与层次关系

    1. 网络中常用的地址: 2. TCP/IP中地址与层次关系 :