1、关于编码：

utf-8 与gbk都是对Unicode 编码的简化，utf-8是针对所有语言的精简，gbk是针对中文的精简

py3默认字符集为UTF-8，取消了Unicode字符集，如后面的编程过程涉及其他字符集的输出，需手工设置

2、win命令提示符显示异常的解决方案：

2.1 chcp 65001 就是换成UTF-8代码页；

2.2设置字体为:Lucida consol

2.3将源代码的格式设置为utf-8格式

3、运算符

3.1算数运算

3.2比较运算：

3.3赋值运算

3.4逻辑运算

3.5成员运算

4、基本数据类型：

4.1数字

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

4.2布尔值

真或假

1或0

4.3字符串：

字符串常用功能：
  • 移除空白
  • 分割
  • 长度
  • 索引
  • 切片
  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

示例代码1

  1. s = 'helloword '
  2. sa=s.strip()
  3. sl=s.lstrip()
  4. sr=s.rstrip()
  5. print(s)
  6. print(sl)
  7. print(sr)
  8. print(sa)
  9. i = sa.startswith('h')
  10. i1 = s.find("ll")-1
  11. i2 = s.upper()
  12. print(i1)
  13. print(s[i1])
  14. print(i2)
  15. i3 = s.capitalize()
  16. print(i3)
  17. i4 = s.isalpha()
  18. i5 = s.islower()
  19. i6 = i2.isupper()
  20. i7 = s.index("l")
  21. print(i5)
  22. print(i6)
  23. print(s[1])
  24. print(i7)

示例代码2

  1. a  = "李四"
  2. b1 = bytes(a,encoding='utf-8')
  3. print(b1)
  4. b2 = bytes(a,encoding='gbk')
  5. print(b2)
  6. #字节 2  字符串
  7. s = str(b1,encoding="utf-8")
  8. print(s)
  9. s2 = str(b2,encoding="gbk")
  10. print(s2)

示例代码3

  1. s =  'HqliliAliceslipifali a * sdfgbllasdfl1'
  2. print(s.center(10,"*"))
  3. print(s.lower())
  4. print(s.upper())
  5. print(s.count("li",1,6))
  6. print(s.find("li"))
  7. #find ==>找到出第一次出现位置，找不到 返回-1
  8. print(s[1:4])
  9. print(s.istitle())
  10. print(s.swapcase())
  11. ## 小写变大写  大写变小写
  12. print(s.format('li',19))
  13. print(s[-1])
  14. print(len(s))
  15. print(s[-1].isdecimal())
  16. a = ''
  17. b = 'john'
  18. print(a.join(b))
  19. l = [1,2,3]
  20. print("_".join(b))
  21. print("/".join(b)
  22.  
  23. for i in "好好学习":
  24.     byte_list = bytes(i,encoding="utf-8")
  25.     print(byte_list)
  26.     for k  in byte_list:
  27.         print(k)
  28.         print(bin(k))

4.4列表

创建列表：
name_list = ['alex', 'seven', 'eric']
或
name_list ＝ list(['alex', 'seven', 'eric'])

基本操作：

    • 索引
    • 切片
    • 追加

      • 删除长度切片循环

包含

  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.  
  177. list

示例代码1：

  1. l = ["li","m",28]
  2. print(l)
  3. #插入
  4. l.append("tj")
  5. print(l)
  6. #切片
  7. m = l[1:2]
  8. print(m)

示例代码2：

  1. s = "李四"
  2. #for 字符==》可迭代
  3. l1=list(s)  #for循环将每个元素放入列表
  4. print(l1)
  5. t1 = ("张三","李四","王五")
  6. l2 = list(t1)
  7. print(l2)
  8. dic = {
  9.     'k1':"张三",
  10.     'k2':"李四"
  11. }
  12. l3 = list(dic)
  13. l4 = list(dic.items())
  14. print(l3)
  15. print(l4)

4.5元组

创建元组：

ages = (11, 22, 33, 44, 55)

or ages = tuple((11, 22, 33, 44, 55))

基本操作：
  • 索引
  • 切片
  • 循环
  • 长度
  • 包含
  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.  
  177. list

ps：元组与列表几乎一模一样，只是元组不能修改里面的内容

示例代码:

  1. t = ("电脑","鼠标垫","自行车","电钻")
  2. print(t)
  3. #获取元组内容
  4. for i in t:
  5.     print(i)
  6. #获取最后一个元素
  7. print(t[-1])
  8. #计算出现个数
  9. n = t.count("电脑")
  10. print(n)
  11. #获取元素索引值
  12. i = t.index("自行车")
  13. print(i)

4.6字典（无序）

创建字典：

person = {"name": "mr.wu", 'age': 18}

or

person = dict({"name": "mr.wu", 'age': 18})

常用操作：

  • 索引
  • 新增
  • 删除
  • 键、值、键值对
  • 循环
  • 长度
  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.  
  205. dict

ps：常用get方式获取值

4.7 其他

4.7.1 for循环

li = [11,22,33,44]

for item in li:
    print item
4.7.2 enumrate
为可迭代的对象添加序号
li = [11,22,33]

for k,v in enumerate(li, 1):
    print(k,v)
4.7.3range和xrange
指定范围，生成指定的数字
print range(1, 10)

# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
 
print range(1, 10, 2)
# 结果：[1, 3, 5, 7, 9]
 
print range(30, 0, -2)
# 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]　
 
5、类的参数：
是否需要查看参数需要查看原码，
6、练习题：
6.1元素分类

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

A 思路 创建一个字典，k1 和k2两个键，键值为空列表。遍历集合是小于登录66的房k1，大于66的放k2

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. li = [11,22,33,44,55,66,77,88,99,90]
  4. dic ={
  5.      "k1":[],
  6.      "k2":[]
  7. }
  8. for i in li:
  9.      if i <= 66:
  10.          dic["k1"].append(i)
  11.      else:
  12.          dic["k2"].append(i)
  13.  
  14. print(dic)

6.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"}
  1. li = ["aleb", " aric", "Alec", "Tony", "rain"]
  2. tu = ("alec", " aric", "Alex", "Tony", "rain")
  3. dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
  4. for i in li :
  5.     #i表示每个元素
  6.     new_i = i.strip()
  7.     if (new_i.startswith('a') or new_i.startswith('A')) and new_i.endswith('c'):
  8.         print(i)
  9.  
  10. for i in tu :
  11.     new_i = i.strip()
  12.     if (new_i.startswith('a') or new_i.startswith('A')) and new_i.endswith('c'):
  13.         print(i)
  14.  
  15. for i in dic.values():
  16.     new_i = i.strip()
  17.     if (new_i.startswith('a') or new_i.startswith('A')) and new_i.endswith('c'):
  18.         print(i)

answer

6.3 输出商品列表，用户输入序号，显示用户选中的商品
商品 li = ["手机", "电脑", '鼠标垫', '游艇']
  1. li = ["手机", "电脑", '鼠标垫', '游艇']
  2. for i,j in enumerate(li):
  3.     print(i+1,j)
  4. n = input("请输入编号：")
  5. num = int(n)
  6. len_li =len(li)
  7. if num > 0 and num<=len_li:
  8.     good = li[int(n)-1]
  9.     print(good)
  10. else:
  11.     print("商品不存在")

answer

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

goods = [

    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998},
]
A：

  1. asset_all = 0
  2. car_list = []
  3.    #format  "电脑":{'price':"单价",'num':"数量"}
  4. i1 = input('请输入总资产：')
  5. asset_all = int(i1)
  6. goods = [
  7.     {"name": "电脑", "price": 1999},
  8.     {"name": "鼠标", "price": 10},
  9.     {"name": "游艇", "price": 20},
  10.     {"name": "美女", "price": 998},
  11. ]
  12. for i in goods:
  13.     print(i['name'],i['price'])
  14. while True:
  15.     i2 = input('请选择商品(输入域Y/y结算)：')
  16.     if i2.lower() == "y":
  17.         break
  18.     for j in goods:
  19.         if j['name'] == i2:
  20.             ##存下已买商品
  21.            # print(j)
  22.             car_list.append(j)
  23.     print(car_list)
  24. #结算
  25. all_prise = 0
  26. for item in car_list:
  27.     p = item['price']
  28.     all_prise = all_prise + p
  29. print('您的总资产：',asset_all,'，您购买的商品总价为：',all_prise)
  30.  
  31. if asset_all < all_prise:
  32.     print("穷逼")
  33. else:
  34.     print('购买成功')

方式一

  1. asset_all = 0
  2. i1 = input('请输入总资产：')
  3. asset_all = int(i1)
  4. goods = [
  5.     {"name": "电脑", "price": 1999},
  6.     {"name": "鼠标", "price": 10},
  7.     {"name": "游艇", "price": 20},
  8.     {"name": "美女", "price": 998},
  9. ]
  10. car_dict = {}
  11. for i in goods:
  12.     print(i['name'],i['price'])
  13. while True:
  14.     i2 = input("请选择商品（输入Y/y结算）：")
  15.     #循环所有的商品，查找需要的商品
  16.     iok = i2.lower()
  17.     if iok == 'y':
  18.         break
  19.  
  20.     for item in goods:
  21.         if item['name'] == i2:
  22.             name = item['name']
  23.             #判断购物车是否有，无添加有数量+1
  24.             if name in car_dict.keys():
  25.                 car_dict[name]['num'] = car_dict[name]['num'] +1
  26.             else:
  27.                 car_dict[name] ={"num":1,'single_price':item['price']}
  28.     print(car_dict)
  29.  
  30. print(car_dict)
  31. all_price = 0
  32. for k,v in car_dict.items():
  33.     n = v['single_price']
  34.     m = v['num']
  35.     all_sum = m*n
  36.     all_price = all_price + all_sum
  37.  
  38. if all_price > asset_all:
  39.     print("穷逼")
  40. else:
  41.     print("购买成功")

方式二

6.5用户交互，显示省市县三级联动的选择
dic = {

    "河北": {
        "石家庄": ["鹿泉", "藁城", "元氏"],
        "邯郸": ["永年", "涉县", "磁县"],
    }
    "河南": {
        ...
    }
    "山西": {
        ...
    }
}
  1. dic = {
  2.     "河北": {
  3.         "石家庄": ["鹿泉", "藁城", "元氏"],
  4.         "邯郸": ["永年", "涉县", "磁县"],
  5.     },
  6.     "河南": {
  7.         "郑州":["不知道","少林寺","嵩山"],
  8.         "开封":["包拯","展昭","威士忌"]
  9.     },
  10.     "山西": {
  11.         "太原":["xxx","ooo","小店"],
  12.         "运城":["更不知道","","哈尔滨啤酒"]
  13.     },
  14. }
  15. #循环输出所有的省
  16. for  x in dic:
  17.     print(x)
  18.  
  19. i1 = input("请输入省份：")
  20. a = dic[i1]
  21. #循环疏忽所哟逇市
  22. for j in a:
  23.     print(j)
  24. i2 = input("请输入地区：")
  25. b = dic[i1][i2]
  26. print(b)
  27. for z in b:
  28.     print(z)

answer

7 小结：

7.1 序列数据类型对比分析表

  字符串 列表 元组 字典 集合　
方法名称　 str list tuple dict set
定义方法

s="john"

s='john'

s=str（"john"）

i=[11,22,33,]

i=list([11,22.33,])

t = (11,22,33)

t=tuple(可迭代对象)

 d = {"k1":name,}

s=set()

s={11,22,33}
可修改 否 是 否  是  
可切片 是 是 是 否  否 
常用特有功能

首字母大写

去除空格

替换

是否数字、字母...

已xx开头、结尾

查找

出现次数

格式化

编码区中

反转

排序

追加

插入

索引位置

删掉

个数

扩展

清除

个数

索引位置

项

键

值

  
公共功能  

索引

切片

for

长度

enumerate

in

dell

索引

切片

for

长度

enumerate

in

 索引

增加

删除

for

长度

in

  
备注 若使用转义字符，使用""   儿子不能被修改  

set是无序不重复的集合

适用于求交集并集差集的情况

PYDay4-基本数据类型、字符串、元组、列表、字典的更多相关文章

  1. python基础之数据类型/字符串/元组/列表/字典

    Python 数据类型 数字类型: int整型,long 长整型(在python3.0里不区分整型和长整型).float浮点型:complex复数(python中存在小数字池:-5--257):布尔值 ...

  2. Python之路 day2 字符串/元组/列表/字典互转

    #-*-coding:utf-8-*- #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type ' ...

  3. python字符串/元组/列表/字典互转

    #-*-coding:utf-8-*- #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type ' ...

  4. 转：python字符串/元组/列表/字典互转

    #-*-coding:utf-8-*-  #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type ...

  5. python 小白(无编程基础，无计算机基础)的开发之路，辅助知识6 python字符串/元组/列表/字典互转

    神奇的相互转换,小白同学可以看看,很有帮助 #1.字典dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type ...

  6. 【转】python字符串/元组/列表/字典互转

    #-*-coding:utf-8-*- #1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} #字典转为字符串,返回:<type ' ...

  7. python数据类型:序列(字符串,元组,列表,字典)

    序列通常有2个特点: 1,可以根据索引取值 2,可以切片操作 字符串,元组,列表,字典,都可以看做是序列类型 我的操作环境:Ubuntu16.04+python2.7 一.字符串类型 >按索引获 ...

  8. python数据类型之元组、字典、集合

    python数据类型元组.字典.集合 元组 python的元组与列表类似,不同的是元组是不可变的数据类型.元组使用小括号,列表使用方括号.当元组里只有一个元素是必须要加逗号: >>> ...

  9. python 元组 列表 字典

    type()查看类型 //取整除 **幂 成员运算符: in  x在y序列中,就返回true 反之  not in 身份运算符: is is not 逻辑运算符 and or not 字符编码 问题 ...

  10. python-day02数据类型-字符串和列表的操作

    while循环: while True: 条件语句....... 关于break和continue,break:跳出当前的循环                               contnu ...

随机推荐

  1. 用ssh-key-gen 在本地主机上创建公钥和密钥

    用ssh-key-gen 在本地主机上创建公钥和密钥 ligh@local-host$ ssh-keygen -t rsa

  2. ES-Mac OS环境搭建(1)

    前言 由于elasticsearch依赖Java,所以先要配置上Java环境,并且Java JDK必须要求1.8以上,这里以安装Java 1.8为例.安装环境如下: elasticsearch6.5. ...

  3. List 集合中数据不重复的使用

    foreach (DataRow dr in dt.Rows) { list.Add(dr["项目组"].ToString()); } list = list.Distinct&l ...

  4. 大数据freestyle: 共享单车轨迹数据助力城市合理规划自行车道

    编者按:近年来,异军突起的共享单车极大地解决了人们共同面临的“最后一公里”难题,然而,共享单车发展迅猛,自行车道建设却始终没有能够跟上脚步.幸运的是摩拜单车大量的轨迹数据为我们提供了一种新的思路:利用 ...

  5. mybatis insert、update 、delete默认返回值解释与如何设置返回表主键

    在使用mybatis做持久层时,insert.update.delete,sql语句默认是不返回被操作记录主键的,而是返回被操作记录条数: 那么如果想要得到被操作记录的主键,可以通过下面的配置方式获取 ...

  6. 在使用线程池时应特别注意对ThreadLocal的使用

    使用ThreadLocal并且有线程池时要特别注意,ThreadLocal是以线程为key的,而线程池里面的线程是会被重新利用的,所以如果有使用线程池并且使用ThreadLocal来保存状态信息时要特 ...

  7. codevs 1262 不要把球传我 2012年CCC加拿大高中生信息学奥赛

    时间限制: 1 s  空间限制: 128000 KB  题目等级 : 白银 Silver 题目描述 Description CCC的足球比赛和传统的足球比赛有一点不同, 一次进球当且仅当先后接触到球的 ...

  8. Objective-C相关Category的收集(更新)

    Categories是给你得不到源码的classes增加功能的一种方法.这个页面收集一些相关的Category,并且持续更新,你可以订阅关注.作者是Fille ?str?m,是@ IMGNRY的联合创 ...

  9. 技术大众化--10款无需编程的App DIY开发工具

    你有一个很棒的创意但不会编程怎么办?外包.合伙开发还是从零学编程?这里提供另外一种方式--使用无需编程的App DIY开发工具.DIY开发工具不仅节省了开发时间和资金,更为那些创意无限热爱应用的人提供 ...

  10. Spring中的事务传播行为与隔离级别

    事务传播行为 事务传播行为(为了解决业务层方法之间互相调用的事务问题): 当事务方法被另一个事务方法调用时,必须指定事务应该如何传播.例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己 ...