zoukankan      html  css  js  c++  java

  • Python之路,Day2

    运算符

    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())
    作业：




    附件列表
    • 相关阅读:
      EBS_FORM_开发:关于离开record验证
      EBS_FORM_开发:关于WHEN-VALIDATE-ITEM上面commit
      EBS_FORM_开发:关于LOCK-ON
      EBS_FORM_开发:实现form record ctrl+F6复制
      EBS_FORM_开发:关于切换不同BLOCK的时候弹出需要保存的窗口
      EBS_FORM_开发:FRM-40150的解决思路
      工作记录
      02_mysql表的操作
      Mysql_字符集_排序规则
      JAVA_IO
    • 原文地址：https://www.cnblogs.com/wudonghang/p/5984808.html
    Copyright © 2011-2022 走看看