Fork me on GitHub

Python之路,Day2 - Python基础2

运算符

1、算数运算：

2、比较运算：

3、赋值运算：

4、逻辑运算：

5、成员运算：

基本数据类型

1、数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
2、布尔值
　　真或假
　　1 或 0
3、字符串
"hello world"
字符串常用功能：
  • 移除空白
  • 分割
  • 长度
  • 索引
  • 切片
  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 ""
  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 ""
  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
  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()
  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()
  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
  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 ""
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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 ""
  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 ""
  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 ""
  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 ""
  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
  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 ""
  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
  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
  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 ""
  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
  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 []
  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 ""
  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 []
  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 []
  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
  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 ""
  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 ""
  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 ""
  379.     def translate(self, table, deletechars=None):  
  380.         """
  381.         转换，需要先做一个对应表，最后一个表示删除字符集合
  382.         intab = "aeiou"
  383.         outtab = "12345"
  384.         trantab = maketrans(intab, outtab)
  385.         str = "this is string example....wow!!!"
  386.         print str.translate(trantab, 'xm')
  387.         """
  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 ""
  401.     def upper(self):  
  402.         """
  403.         S.upper() -> string
  404.         
  405.         Return a copy of the string S converted to uppercase.
  406.         """
  407.         return ""
  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 ""
  419.     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  420.         pass
  422.     def _formatter_parser(self, *args, **kwargs): # real signature unknown
  423.         pass
  425.     def __add__(self, y):  
  426.         """ x.__add__(y) <==> x+y """
  427.         pass
  429.     def __contains__(self, y):  
  430.         """ x.__contains__(y) <==> y in x """
  431.         pass
  433.     def __eq__(self, y):  
  434.         """ x.__eq__(y) <==> x==y """
  435.         pass
  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 ""
  445.     def __getattribute__(self, name):  
  446.         """ x.__getattribute__('name') <==> x.name """
  447.         pass
  449.     def __getitem__(self, y):  
  450.         """ x.__getitem__(y) <==> x[y] """
  451.         pass
  453.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  454.         pass
  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
  464.     def __ge__(self, y):  
  465.         """ x.__ge__(y) <==> x>=y """
  466.         pass
  468.     def __gt__(self, y):  
  469.         """ x.__gt__(y) <==> x>y """
  470.         pass
  472.     def __hash__(self):  
  473.         """ x.__hash__() <==> hash(x) """
  474.         pass
  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
  486.     def __len__(self):  
  487.         """ x.__len__() <==> len(x) """
  488.         pass
  490.     def __le__(self, y):  
  491.         """ x.__le__(y) <==> x<=y """
  492.         pass
  494.     def __lt__(self, y):  
  495.         """ x.__lt__(y) <==> x<y """
  496.         pass
  498.     def __mod__(self, y):  
  499.         """ x.__mod__(y) <==> x%y """
  500.         pass
  502.     def __mul__(self, n):  
  503.         """ x.__mul__(n) <==> x*n """
  504.         pass
  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
  511.     def __ne__(self, y):  
  512.         """ x.__ne__(y) <==> x!=y """
  513.         pass
  515.     def __repr__(self):  
  516.         """ x.__repr__() <==> repr(x) """
  517.         pass
  519.     def __rmod__(self, y):  
  520.         """ x.__rmod__(y) <==> y%x """
  521.         pass
  523.     def __rmul__(self, n):  
  524.         """ x.__rmul__(n) <==> n*x """
  525.         pass
  527.     def __sizeof__(self):  
  528.         """ S.__sizeof__() -> size of S in memory, in bytes """
  529.         pass
  531.     def __str__(self):  
  532.         """ x.__str__() <==> str(x) """
  533.         pass
  535. str

4、列表
创建列表：
1
2
3
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
  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
  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
  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
  25.     def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26.         """ L.insert(index, object) -- insert object before index """
  27.         pass
  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
  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
  43.     def reverse(self): # real signature unknown; restored from __doc__
  44.         """ L.reverse() -- reverse *IN PLACE* """
  45.         pass
  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
  54.     def __add__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__add__(y) <==> x+y """
  56.         pass
  58.     def __contains__(self, y): # real signature unknown; restored from __doc__
  59.         """ x.__contains__(y) <==> y in x """
  60.         pass
  62.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  63.         """ x.__delitem__(y) <==> del x[y] """
  64.         pass
  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
  74.     def __eq__(self, y): # real signature unknown; restored from __doc__
  75.         """ x.__eq__(y) <==> x==y """
  76.         pass
  78.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  79.         """ x.__getattribute__('name') <==> x.name """
  80.         pass
  82.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  83.         """ x.__getitem__(y) <==> x[y] """
  84.         pass
  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
  94.     def __ge__(self, y): # real signature unknown; restored from __doc__
  95.         """ x.__ge__(y) <==> x>=y """
  96.         pass
  98.     def __gt__(self, y): # real signature unknown; restored from __doc__
  99.         """ x.__gt__(y) <==> x>y """
  100.         pass
  102.     def __iadd__(self, y): # real signature unknown; restored from __doc__
  103.         """ x.__iadd__(y) <==> x+=y """
  104.         pass
  106.     def __imul__(self, y): # real signature unknown; restored from __doc__
  107.         """ x.__imul__(y) <==> x*=y """
  108.         pass
  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
  118.     def __iter__(self): # real signature unknown; restored from __doc__
  119.         """ x.__iter__() <==> iter(x) """
  120.         pass
  122.     def __len__(self): # real signature unknown; restored from __doc__
  123.         """ x.__len__() <==> len(x) """
  124.         pass
  126.     def __le__(self, y): # real signature unknown; restored from __doc__
  127.         """ x.__le__(y) <==> x<=y """
  128.         pass
  130.     def __lt__(self, y): # real signature unknown; restored from __doc__
  131.         """ x.__lt__(y) <==> x<y """
  132.         pass
  134.     def __mul__(self, n): # real signature unknown; restored from __doc__
  135.         """ x.__mul__(n) <==> x*n """
  136.         pass
  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
  143.     def __ne__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ne__(y) <==> x!=y """
  145.         pass
  147.     def __repr__(self): # real signature unknown; restored from __doc__
  148.         """ x.__repr__() <==> repr(x) """
  149.         pass
  151.     def __reversed__(self): # real signature unknown; restored from __doc__
  152.         """ L.__reversed__() -- return a reverse iterator over the list """
  153.         pass
  155.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  156.         """ x.__rmul__(n) <==> n*x """
  157.         pass
  159.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  160.         """ x.__setitem__(i, y) <==> x[i]=y """
  161.         pass
  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
  171.     def __sizeof__(self): # real signature unknown; restored from __doc__
  172.         """ L.__sizeof__() -- size of L in memory, in bytes """
  173.         pass
  175.     __hash__ = None
  177. list
5、元祖
创建元祖：
1
2
3
ages = (11, 22, 33, 44, 55)
或
ages = tuple((11, 22, 33, 44, 55))
基本操作：
  • 索引
  • 切片
  • 循环
  • 长度
  • 包含
  1. lass 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
  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
  19.     def __add__(self, y): # real signature unknown; restored from __doc__
  20.         """ x.__add__(y) <==> x+y """
  21.         pass
  23.     def __contains__(self, y): # real signature unknown; restored from __doc__
  24.         """ x.__contains__(y) <==> y in x """
  25.         pass
  27.     def __eq__(self, y): # real signature unknown; restored from __doc__
  28.         """ x.__eq__(y) <==> x==y """
  29.         pass
  31.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  32.         """ x.__getattribute__('name') <==> x.name """
  33.         pass
  35.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  36.         """ x.__getitem__(y) <==> x[y] """
  37.         pass
  39.     def __getnewargs__(self, *args, **kwargs): # real signature unknown
  40.         pass
  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
  50.     def __ge__(self, y): # real signature unknown; restored from __doc__
  51.         """ x.__ge__(y) <==> x>=y """
  52.         pass
  54.     def __gt__(self, y): # real signature unknown; restored from __doc__
  55.         """ x.__gt__(y) <==> x>y """
  56.         pass
  58.     def __hash__(self): # real signature unknown; restored from __doc__
  59.         """ x.__hash__() <==> hash(x) """
  60.         pass
  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
  72.     def __iter__(self): # real signature unknown; restored from __doc__
  73.         """ x.__iter__() <==> iter(x) """
  74.         pass
  76.     def __len__(self): # real signature unknown; restored from __doc__
  77.         """ x.__len__() <==> len(x) """
  78.         pass
  80.     def __le__(self, y): # real signature unknown; restored from __doc__
  81.         """ x.__le__(y) <==> x<=y """
  82.         pass
  84.     def __lt__(self, y): # real signature unknown; restored from __doc__
  85.         """ x.__lt__(y) <==> x<y """
  86.         pass
  88.     def __mul__(self, n): # real signature unknown; restored from __doc__
  89.         """ x.__mul__(n) <==> x*n """
  90.         pass
  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
  97.     def __ne__(self, y): # real signature unknown; restored from __doc__
  98.         """ x.__ne__(y) <==> x!=y """
  99.         pass
  101.     def __repr__(self): # real signature unknown; restored from __doc__
  102.         """ x.__repr__() <==> repr(x) """
  103.         pass
  105.     def __rmul__(self, n): # real signature unknown; restored from __doc__
  106.         """ x.__rmul__(n) <==> n*x """
  107.         pass
  109.     def __sizeof__(self): # real signature unknown; restored from __doc__
  110.         """ T.__sizeof__() -- size of T in memory, in bytes """
  111.         pass
  113. tuple
6、字典（无序）
创建字典：
1
2
3
person = {"name": "mr.wu", 'age': 18}
或
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.     """
  14.     def clear(self): # real signature unknown; restored from __doc__
  15.         """ 清除内容 """
  16.         """ D.clear() -> None.  Remove all items from D. """
  17.         pass
  19.     def copy(self): # real signature unknown; restored from __doc__
  20.         """ 浅拷贝 """
  21.         """ D.copy() -> a shallow copy of D """
  22.         pass
  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
  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
  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
  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 []
  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
  52.     def iterkeys(self): # real signature unknown; restored from __doc__
  53.         """ key可迭代 """
  54.         """ D.iterkeys() -> an iterator over the keys of D """
  55.         pass
  57.     def itervalues(self): # real signature unknown; restored from __doc__
  58.         """ value可迭代 """
  59.         """ D.itervalues() -> an iterator over the values of D """
  60.         pass
  62.     def keys(self): # real signature unknown; restored from __doc__
  63.         """ 所有的key列表 """
  64.         """ D.keys() -> list of D's keys """
  65.         return []
  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
  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
  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
  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
  101.     def values(self): # real signature unknown; restored from __doc__
  102.         """ 所有的值 """
  103.         """ D.values() -> list of D's values """
  104.         return []
  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
  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
  115.     def viewvalues(self): # real signature unknown; restored from __doc__
  116.         """ D.viewvalues() -> an object providing a view on D's values """
  117.         pass
  119.     def __cmp__(self, y): # real signature unknown; restored from __doc__
  120.         """ x.__cmp__(y) <==> cmp(x,y) """
  121.         pass
  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
  127.     def __delitem__(self, y): # real signature unknown; restored from __doc__
  128.         """ x.__delitem__(y) <==> del x[y] """
  129.         pass
  131.     def __eq__(self, y): # real signature unknown; restored from __doc__
  132.         """ x.__eq__(y) <==> x==y """
  133.         pass
  135.     def __getattribute__(self, name): # real signature unknown; restored from __doc__
  136.         """ x.__getattribute__('name') <==> x.name """
  137.         pass
  139.     def __getitem__(self, y): # real signature unknown; restored from __doc__
  140.         """ x.__getitem__(y) <==> x[y] """
  141.         pass
  143.     def __ge__(self, y): # real signature unknown; restored from __doc__
  144.         """ x.__ge__(y) <==> x>=y """
  145.         pass
  147.     def __gt__(self, y): # real signature unknown; restored from __doc__
  148.         """ x.__gt__(y) <==> x>y """
  149.         pass
  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
  166.     def __iter__(self): # real signature unknown; restored from __doc__
  167.         """ x.__iter__() <==> iter(x) """
  168.         pass
  170.     def __len__(self): # real signature unknown; restored from __doc__
  171.         """ x.__len__() <==> len(x) """
  172.         pass
  174.     def __le__(self, y): # real signature unknown; restored from __doc__
  175.         """ x.__le__(y) <==> x<=y """
  176.         pass
  178.     def __lt__(self, y): # real signature unknown; restored from __doc__
  179.         """ x.__lt__(y) <==> x<y """
  180.         pass
  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
  187.     def __ne__(self, y): # real signature unknown; restored from __doc__
  188.         """ x.__ne__(y) <==> x!=y """
  189.         pass
  191.     def __repr__(self): # real signature unknown; restored from __doc__
  192.         """ x.__repr__() <==> repr(x) """
  193.         pass
  195.     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  196.         """ x.__setitem__(i, y) <==> x[i]=y """
  197.         pass
  199.     def __sizeof__(self): # real signature unknown; restored from __doc__
  200.         """ D.__sizeof__() -> size of D in memory, in bytes """
  201.         pass
  203.     __hash__ = None
  205. dict
PS：循环，range，continue 和 break
1、for循环
用户按照顺序循环可迭代对象中的内容，
PS：break、continue
  1. li = [11,22,33,44]
  2. for item in li:
  3.     print item
2、enumrate
  1. li = [11,22,33]
  2. for k,v in enumerate(li, 1):
  3.     print(k,v)

3、range和xrange
指定范围，生成指定的数字
  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]　

PS：字符串的处理

  1. str='python String function'
  2. 生成字符串变量str='python String function'
  4. 字符串长度获取：len(str)
  5. 例：print '%s length=%d' % (str,len(str))
  7. 字母处理
  8. 全部大写：str.upper()
  9. 全部小写：str.lower()
  10. 大小写互换：str.swapcase()
  11. 首字母大写，其余小写：str.capitalize()
  12. 首字母大写：str.title()
  13. print '%s lower=%s' % (str,str.lower())
  14. print '%s upper=%s' % (str,str.upper())
  15. print '%s swapcase=%s' % (str,str.swapcase())
  16. print '%s capitalize=%s' % (str,str.capitalize())
  17. print '%s title=%s' % (str,str.title()) 
  18. 格式化相关
  19. 获取固定长度，右对齐，左边不够用空格补齐：str.ljust(width)
  20. 获取固定长度，左对齐，右边不够用空格补齐：str.ljust(width)
  21. 获取固定长度，中间对齐，两边不够用空格补齐：str.ljust(width)
  22. 获取固定长度，右对齐，左边不足用0补齐
  23. print '%s ljust=%s' % (str,str.ljust(20))
  24. print '%s rjust=%s' % (str,str.rjust(20))
  25. print '%s center=%s' % (str,str.center(20))
  26. print '%s zfill=%s' % (str,str.zfill(20))
  27. 字符串搜索相关
  28. 搜索指定字符串，没有返回-1：str.find('t')
  29. 指定起始位置搜索：str.find('t',start)
  30. 指定起始及结束位置搜索：str.find('t',start,end)
  31. 从右边开始查找：str.rfind('t')
  32. 搜索到多少个指定字符串：str.count('t')
  33. 上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1
  34. print '%s find nono=%d' % (str,str.find('nono'))
  35. print '%s find t=%d' % (str,str.find('t'))
  36. print '%s find t from %d=%d' % (str,1,str.find('t',1))
  37. print '%s find t from %d to %d=%d' % (str,1,2,str.find('t',1,2))
  38. #print '%s index nono ' % (str,str.index('nono',1,2))
  39. print '%s rfind t=%d' % (str,str.rfind('t'))
  40. print '%s count t=%d' % (str,str.count('t'))
  41. 字符串替换相关
  42. 替换old为new：str.replace('old','new')
  43. 替换指定次数的old为new：str.replace('old','new',maxReplaceTimes)
  44. print '%s replace t to *=%s' % (str,str.replace('t', '*'))
  45. print '%s replace t to *=%s' % (str,str.replace('t', '*',1))
  46. 字符串去空格及去指定字符
  47. 去两边空格：str.strip()
  48. 去左空格：str.lstrip()
  49. 去右空格：str.rstrip()
  50. 去两边字符串：str.strip('d')，相应的也有lstrip，rstrip
  51. str=' python String function '
  52. print '%s strip=%s' % (str,str.strip())
  53. str='python String function'
  54. print '%s strip=%s' % (str,str.strip('d'))
  55. 按指定字符分割字符串为数组：str.split(' ')
  57. 默认按空格分隔
  58. str='a b c de'
  59. print '%s strip=%s' % (str,str.split())
  60. str='a-b-c-de'
  61. print '%s strip=%s' % (str,str.split('-'))
  62. 字符串判断相关
  63. 是否以start开头：str.startswith('start')
  64. 是否以end结尾：str.endswith('end')
  65. 是否全为字母或数字：str.isalnum()
  66. 是否全字母：str.isalpha()
  67. 是否全数字：str.isdigit()
  68. 是否全小写：str.islower()
  69. 是否全大写：str.isupper()
  70. str='python String function'
  71. print '%s startwith t=%s' % (str,str.startswith('t'))
  72. print '%s endwith d=%s' % (str,str.endswith('d'))
  73. print '%s isalnum=%s' % (str,str.isalnum())
  74. str='pythonStringfunction'
  75. print '%s isalnum=%s' % (str,str.isalnum())
  76. print '%s isalpha=%s' % (str,str.isalpha())
  77. print '%s isupper=%s' % (str,str.isupper())
  78. print '%s islower=%s' % (str,str.islower())
  79. print '%s isdigit=%s' % (str,str.isdigit())
  80. str='3423'
  81. print '%s isdigit=%s' % (str,str.isdigit())
作业：




附件列表

     

    posted @ 2016-10-21 15:31  Anonymous-develop  阅读(343)  评论(0)    收藏  举报

    python自动化开发&研究 - 创建于 2016年1月10日

    这是一位运维自动化开发工程师的个人站，内容主要是网站开发方面的技术文章，大部分来自学习或工作，部分来源于网络,希望对大家有所帮助。

    致力于自动化应用开发&研究工作，专注运维与前端开发，关注互联网前沿技术与趋势。


    廖雪峰的博客 | 徐亮的博客 | 刘耀的博客 | python基础课程 | 我的svn | 我的个人导航首页