• Python全栈开发【基础二】


    本节内容:

    • Python 运算符(算术运算、比较运算、赋值运算、逻辑运算、成员运算)
    • 基本数据类型(数字、布尔值、字符串、列表、元组、字典)
    • 其他(编码,range,for,while)

    Python 运算符

    1、算术运算:

    2、比较运算:

    3、赋值运算:

    4、逻辑运算:

     5、成员运算:

     

    基本数据类型

    1、数字

    int(整型) 

     1 数字  int ,所有的功能,都放在int里
     2 a1 = 123
     3 a1 = 456
     4             
     5 - int
     6     将字符串转换为数字
     7     a = "123"
     8     print(type(a),a)
     9     b = int(a)
    10     print(type(b),b)
    11                     
    12     进制转换,例子为转换为16进制
    13     num = "0011" 
    14     v = int(num, base=16)
    15     print(v)
    16 - bit_lenght
    17     当前数字的二进制,至少用n位表示
    18     r = age.bit_length()
    int常用属性
      1 class int(object):
      2     """
      3     int(x=0) -> integer
      4     int(x, base=10) -> integer
      5 
      6     Convert a number or string to an integer, or return 0 if no arguments
      7     are given.  If x is a number, return x.__int__().  For floating point
      8     numbers, this truncates towards zero.
      9 
     10     If x is not a number or if base is given, then x must be a string,
     11     bytes, or bytearray instance representing an integer literal in the
     12     given base.  The literal can be preceded by '+' or '-' and be surrounded
     13     by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
     14     Base 0 means to interpret the base from the string as an integer literal.
     15     >>> int('0b100', base=0)
     16     """
     17     def bit_length(self): # real signature unknown; restored from __doc__
     18         """
     19         int.bit_length() -> int
     20 
     21         Number of bits necessary to represent self in binary.
     22         """
     23         """
     24         表示该数字返回时占用的最少位数
     25 
     26         >>> (951).bit_length()
     27         """
     28         return 0
     29 
     30     def conjugate(self, *args, **kwargs): # real signature unknown
     31         """ Returns self, the complex conjugate of any int."""
     32 
     33         """
     34         返回该复数的共轭复数
     35  
     36         #返回复数的共轭复数
     37         >>> (95 + 11j).conjugate()
     38         (95-11j)
     39         #返回复数的实数部分
     40         >>> (95 + 11j).real
     41         95.0
     42         #返回复数的虚数部分
     43         >>> (95 + 11j).imag
     44         11.0
     45         """
     46         pass
     47 
     48     @classmethod # known case
     49     def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
     50         """
     51         int.from_bytes(bytes, byteorder, *, signed=False) -> int
     52 
     53         Return the integer represented by the given array of bytes.
     54 
     55         The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
     56 
     57         The byteorder argument determines the byte order used to represent the
     58         integer.  If byteorder is 'big', the most significant byte is at the
     59         beginning of the byte array.  If byteorder is 'little', the most
     60         significant byte is at the end of the byte array.  To request the native
     61         byte order of the host system, use `sys.byteorder' as the byte order value.
     62 
     63         The signed keyword-only argument indicates whether two's complement is
     64         used to represent the integer.
     65         """
     66         """
     67         这个方法是在Python3.2的时候加入的,python官方给出了下面几个例子:
     68         >>> int.from_bytes(b'x00x10', byteorder='big')
     69         >>> int.from_bytes(b'x00x10', byteorder='little')
     70         >>> int.from_bytes(b'xfcx00', byteorder='big', signed=True)
     71         -1024
     72         >>> int.from_bytes(b'xfcx00', byteorder='big', signed=False)
     73         >>> int.from_bytes([255, 0, 0], byteorder='big')
     74         """
     75         pass
     76 
     77     def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
     78         """
     79         int.to_bytes(length, byteorder, *, signed=False) -> bytes
     80 
     81         Return an array of bytes representing an integer.
     82 
     83         The integer is represented using length bytes.  An OverflowError is
     84         raised if the integer is not representable with the given number of
     85         bytes.
     86 
     87         The byteorder argument determines the byte order used to represent the
     88         integer.  If byteorder is 'big', the most significant byte is at the
     89         beginning of the byte array.  If byteorder is 'little', the most
     90         significant byte is at the end of the byte array.  To request the native
     91         byte order of the host system, use `sys.byteorder' as the byte order value.
     92 
     93         The signed keyword-only argument determines whether two's complement is
     94         used to represent the integer.  If signed is False and a negative integer
     95         is given, an OverflowError is raised.
     96         """
     97         """
     98         python官方给出了下面几个例子:
     99         >>> (1024).to_bytes(2, byteorder='big')
    100         b'x04x00'
    101         >>> (1024).to_bytes(10, byteorder='big')
    102         b'x00x00x00x00x00x00x00x00x04x00'
    103         >>> (-1024).to_bytes(10, byteorder='big', signed=True)
    104         b'xffxffxffxffxffxffxffxffxfcx00'
    105         >>> x = 1000
    106         >>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
    107         b'xe8x03'
    108         """
    109         pass
    110 
    111     def __abs__(self, *args, **kwargs): # real signature unknown
    112         """ abs(self)"""
    113 
    114         """
    115         返回一个绝对值
    116 
    117         >>> (95).__abs__()
    118         -95
    119         >>> (-95).__abs__()
    120         """
    121         pass
    122 
    123 
    124     def __add__(self, *args, **kwargs): # real signature unknown
    125         """ Return self+value."""
    126 
    127         """
    128         加法,也可区分数字和字符串
    129 
    130         >>> (95).__add__(1)
    131         >>> (95).__add__("1")
    132         NotImplemented
    133         >>>
    134         """
    135         pass
    136 
    137     def __and__(self, *args, **kwargs): # real signature unknown
    138         """ Return self&value."""
    139         pass
    140 
    141     def __bool__(self, *args, **kwargs): # real signature unknown
    142         """ self != 0 """
    143 
    144         """
    145         判断一个整数对象是否为0,如果为0,则返回False,如果不为0,则返回True
    146 
    147         >>> (95).__bool__()
    148         True
    149         >>> (0).__bool__()
    150         False
    151         """
    152         pass
    153 
    154     def __ceil__(self, *args, **kwargs): # real signature unknown
    155         """ Ceiling of an Integral returns itself. """
    156         pass
    157 
    158     def __divmod__(self, *args, **kwargs): # real signature unknown
    159         """ Return divmod(self, value). """
    160         """
    161         返回一个元组,第一个元素为商,第二个元素为余数
    162 
    163         >>> (9).__divmod__(5)
    164         (1, 4)
    165         """
    166         pass
    167 
    168     def __eq__(self, *args, **kwargs): # real signature unknown
    169         """ Return self==value. """
    170         """
    171         判断两个值是否相等
    172 
    173         >>> (95).__eq__(95)
    174         True
    175         >>> (95).__eq__(9)
    176         False
    177         """
    178         pass
    179 
    180     def __float__(self, *args, **kwargs): # real signature unknown
    181         """ float(self) """
    182         """
    183         将一个整数转换成浮点型
    184 
    185         >>> (95).__float__()
    186         95.0
    187         """
    188         pass
    189 
    190     def __floordiv__(self, *args, **kwargs): # real signature unknown
    191         """ Return self//value. """
    192         """
    193         整除,保留结果的整数部分
    194 
    195         >>> (95).__floordiv__(9)
    196         """
    197         pass
    198 
    199     def __floor__(self, *args, **kwargs): # real signature unknown
    200         """ Flooring an Integral returns itself. """
    201         """
    202         返回本身
    203 
    204         >>> (95).__floor__()
    205         """
    206         pass
    207 
    208     def __format__(self, *args, **kwargs): # real signature unknown
    209         """
    210         转换对象的类型
    211 
    212         >>> (95).__format__('f')
    213         '95.000000'
    214         >>> (95).__format__('b')
    215         '1011111'
    216         """
    217         pass
    218 
    219 
    220     def __getattribute__(self, *args, **kwargs): # real signature unknown
    221         """ Return getattr(self, name). """
    222         """
    223         判断这个类中是否包含这个属性,如果包含则打印出值,如果不包含,就报错了
    224 
    225         >>> (95).__getattribute__('__abs__')
    226         <method-wrapper '__abs__' of int object at 0x9f93c0>
    227         >>> (95).__getattribute__('__aaa__')
    228         Traceback (most recent call last):
    229         File "<stdin>", line 1, in <module>
    230         AttributeError: 'int' object has no attribute '__aaa__'
    231         """
    232         pass
    233 
    234     def __getnewargs__(self, *args, **kwargs): # real signature unknown
    235         pass
    236 
    237     def __ge__(self, *args, **kwargs): # real signature unknown
    238         """ Return self>=value. """
    239         """
    240         判断是否大于等于
    241 
    242         >>> (95).__ge__(9)
    243         True
    244         >>> (95).__ge__(99)
    245         False
    246         """
    247         pass
    248 
    249     def __gt__(self, *args, **kwargs): # real signature unknown
    250         """ Return self>value. """
    251         """
    252         判断是否大于
    253 
    254         >>> (95).__gt__(9)
    255         True
    256         >>> (95).__gt__(99)
    257         False
    258         """
    259         pass
    260 
    261     def __hash__(self, *args, **kwargs): # real signature unknown
    262         """ Return hash(self). """
    263         """
    264         计算哈希值,整数返回本身
    265 
    266         >>> (95).__hash__()
    267         >>> (95.95).__hash__()
    268         """
    269         pass
    270 
    271     def __index__(self, *args, **kwargs): # real signature unknown
    272         """ Return self converted to an integer, if self is suitable for use as an index into a list. """
    273         pass
    274 
    275     def __init__(self, x, base=10): # known special case of int.__init__
    276         """
    277          这个是一个类的初始化方法,当int类被实例化的时候,这个方法默认就会被执行
    278         """
    279         """
    280         int(x=0) -> integer
    281         int(x, base=10) -> integer
    282 
    283         Convert a number or string to an integer, or return 0 if no arguments
    284         are given.  If x is a number, return x.__int__().  For floating point
    285         numbers, this truncates towards zero.
    286 
    287         If x is not a number or if base is given, then x must be a string,
    288         bytes, or bytearray instance representing an integer literal in the
    289         given base.  The literal can be preceded by '+' or '-' and be surrounded
    290         by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
    291         Base 0 means to interpret the base from the string as an integer literal.
    292         >>> int('0b100', base=0)
    293         # (copied from class doc)
    294         """   
    295         pass
    296 
    297     def __int__(self, *args, **kwargs): # real signature unknown
    298         """ int(self) """
    299         """
    300         转换为整型
    301 
    302         >>> (9.5).__int__()
    303         """
    304         pass
    305 
    306 
    307     def __invert__(self, *args, **kwargs): # real signature unknown
    308         """ ~self """
    309 
    310         pass
    311 
    312     def __le__(self, *args, **kwargs): # real signature unknown
    313         """ Return self<=value. """
    314         """
    315         判断是否小于等于
    316      
    317         >>> (95).__le__(99)
    318         True
    319         >>> (95).__le__(9)
    320         False
    321         """
    322         pass
    323 
    324     def __lshift__(self, *args, **kwargs): # real signature unknown
    325         """ Return self<<value. """
    326         """
    327         用于二进制位移,这个是向左移动
    328 
    329         >>> bin(95)
    330         '0b1011111'
    331         >>> a = (95).__lshift__(2)
    332         >>> bin(a)
    333         '0b101111100'
    334          >>> 
    335         """
    336         pass
    337 
    338     def __lt__(self, *args, **kwargs): # real signature unknown
    339         """ Return self<value. """
    340         """
    341         判断是否小于
    342 
    343         >>> (95).__lt__(9)
    344         False
    345         >>> (95).__lt__(99)
    346         True
    347         """
    348         pass
    349 
    350     def __mod__(self, *args, **kwargs): # real signature unknown
    351         """ Return self%value. """
    352         """
    353         取模 %
    354 
    355         >>> (95).__mod__(9)
    356         """
    357         pass
    358 
    359     def __mul__(self, *args, **kwargs): # real signature unknown
    360         """ Return self*value. """
    361         """
    362         乘法 *
    363 
    364         >>> (95).__mul__(10)
    365         """
    366         pass
    367 
    368     def __neg__(self, *args, **kwargs): # real signature unknown
    369         """ -self """
    370         """
    371         将正数变为负数,将负数变为正数
    372 
    373         >>> (95).__neg__()
    374         -95
    375         >>> (-95).__neg__()
    376         """
    377         pass
    378 
    379     @staticmethod # known case of __new__
    380     def __new__(*args, **kwargs): # real signature unknown
    381         """ Create and return a new object.  See help(type) for accurate signature. """
    382         pass
    383 
    384     def __ne__(self, *args, **kwargs): # real signature unknown
    385         """ Return self!=value. """
    386         """
    387         不等于
    388 
    389         >>> (95).__ne__(9)
    390         True
    391         >>> (95).__ne__(95)
    392         False
    393         """
    394         pass
    395 
    396     def __or__(self, *args, **kwargs): # real signature unknown
    397         """ Return self|value. """
    398         """
    399         二进制或的关系,只要有一个为真,就为真
    400 
    401         >>> a = 4
    402         >>> b = 0
    403         >>> a.__or__(b)     # a --> 00000100        b --> 00000000
    404         >>> b = 1           # b --> 00000001
    405         >>> a.__or__(b)
    406         """
    407         pass
    408 
    409     def __pos__(self, *args, **kwargs): # real signature unknown
    410         """ +self """
    411         pass
    412 
    413     def __pow__(self, *args, **kwargs): # real signature unknown
    414         """ Return pow(self, value, mod). """
    415         """
    416 417 
    418         >>> (2).__pow__(10)
    419         """    
    420         pass
    421 
    422     def __radd__(self, *args, **kwargs): # real signatre unknown
    423         """ Return value+self. """
    424         """
    425         加法,将value放在前面
    426 
    427         >>> a.__radd__(b)       # 相当于 b+a 
    428         """
    429         pass
    430 
    431     def __rand__(self, *args, **kwargs): # real signature unknown
    432         """ Return value&self. """
    433         """
    434         二进制与的关系,两个都为真,才为真,有一个为假,就为假
    435         """
    436         pass
    437 
    438     def __rdivmod__(self, *args, **kwargs): # real signature unknown
    439         """ Return divmod(value, self). """
    440         pass
    441 
    442     def __repr__(self, *args, **kwargs): # real signature unknown
    443         """ Return repr(self). """
    444         pass
    445 
    446     def __rfloordiv__(self, *args, **kwargs): # real signature unknown
    447         """ Return value//self. """
    448         pass
    449 
    450     def __rlshift__(self, *args, **kwargs): # real signature unknown
    451         """ Return value<<self. """
    452         pass
    453 
    454     def __rmod__(self, *args, **kwargs): # real signature unknown
    455         """ Return value%self. """
    456         pass
    457 
    458     def __rmul__(self, *args, **kwargs): # real signature unknown
    459         """ Return value*self. """
    460         pass
    461 
    462     def __ror__(self, *args, **kwargs): # real signature unknown
    463         """ Return value|self. """
    464         pass
    465 
    466     def __round__(self, *args, **kwargs): # real signature unknown
    467         """
    468         Rounding an Integral returns itself.
    469         Rounding with an ndigits argument also returns an integer.
    470         """
    471         pass
    472 
    473     def __rpow__(self, *args, **kwargs): # real signature unknown
    474         """ Return pow(value, self, mod). """
    475         pass
    476 
    477     def __rrshift__(self, *args, **kwargs): # real signature unknown
    478         """ Return value>>self. """
    479         pass
    480 
    481     def __rshift__(self, *args, **kwargs): # real signature unknown
    482         """ Return self>>value. """
    483         pass
    484 
    485     def __rsub__(self, *args, **kwargs): # real signature unknown
    486         """ Return value-self. """
    487         pass
    488 
    489     def __rtruediv__(self, *args, **kwargs): # real signature unknown
    490         """ Return value/self. """
    491         pass
    492 
    493     def __rxor__(self, *args, **kwargs): # real signature unknown
    494         """ Return value^self. """
    495         pass
    496 
    497     def __sizeof__(self, *args, **kwargs): # real signature unknown
    498         """ Returns size in memory, in bytes """
    499         """
    500         在内存中占多少个字节
    501 
    502         >>> a = 95
    503         >>> a.__sizeof__()
    504         """
    505         pass
    506 
    507     def __str__(self, *args, **kwargs): # real signature unknown
    508         """ Return str(self). """
    509         """
    510         将一个正数转为字符串
    511 
    512         >>> a = 95 
    513         >>> a = a.__str__()
    514         >>> print(type(a))
    515         <class 'str'>
    516         """
    517         pass
    518 
    519     def __sub__(self, *args, **kwargs): # real signature unknown
    520         """ Return self-value. """
    521         """
    522         减法运算
    523 
    524         >>> (95).__sub__(5)
    525         """
    526         pass
    527 
    528     def __truediv__(self, *args, **kwargs): # real signature unknown
    529         """ Return self/value. """
    530         """
    531         除法运算
    532 
    533         >>> (95).__truediv__(5)
    534         19.0
    535         """
    536         pass
    537 
    538     def __trunc__(self, *args, **kwargs): # real signature unknown
    539         """ Truncating an Integral returns itself. """
    540         """
    541         返回一个对象的整数部分
    542 
    543         >>> (95.95).__trunc__()
    544         """
    545         pass
    546     def __xor__(self, *args, **kwargs): # real signature unknown
    547         """ Return self^value. """
    548         """
    549         将对象与值进行二进制的或运算,一个为真,就为真
    550 
    551         >>> a = 4
    552         >>> b = 1
    553         >>> a.__xor__(b)
    554         >>> c = 0
    555         >>> a.__xor__(c)
    556         """
    557 
    558         pass
    559 
    560     denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    561     """ 分母 = 1 """
    562     """the denominator of a rational number in lowest terms"""
    563 
    564     imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    565     """ 虚数 """
    566     """the imaginary part of a complex number"""
    567 
    568     numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    569     """ 分子 = 数字大小 """
    570     """the numerator of a rational number in lowest terms"""
    571 
    572     real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    573     """ 实属 """
    574     """the real part of a complex number"""
    575 
    576 int
    int

    2、布尔值

    真或假
    1 或 0
    一下情况一般为False
    None "" () [] {} 0 ==> False
    其余情况一般为真

    3、字符串

     1 test = "来啊相互伤害啊"
     2 
     3 # 一、for循环
     4 #     for 变量名 in 字符串:
     5 #         变量名
     6 #     break
     7 #     continue
     8 
     9     index = 0
    10     while index < len(test):
    11         v = test[index]
    12         print(v)    
    13         index += 1
    14     print('=======')
    15 
    16     for  in test:
    17         print()
    18 
    19     test = "来啊相互伤害啊"
    20     for item in test:
    21         print(item)
    22         break
    23 
    24     for item in test:
    25         continue
    26         print(item)
    27 
    28 # 二、索引,下标,获取字符串中的某一个字符
    29     v = test[3]
    30     print(v)
    31 
    32 # 三、切片
    33     v = test[0:-1] # 0=<  <1
    34     print(v)
    35 
    36 # 四、获取长度
    37 #     Python3: len获取当前字符串中由几个字符组成
    38     v = len(test)
    39     print(v)
    40 
    41 # 注意:
    42 # len("asdf")
    43 # for循环
    44 # 索引
    45 # 切片
    46 
    47 # 五、获取连续或不连续的数字,range用法
    48 #     Python2中直接创建在内容中
    49 #     python3中只有for循环时,才一个一个创建
    50     r1 = range(10)
    51     r2 = range(1,10)
    52     r3 = range(1,10,2)
    53 # 帮助创建连续的数字,通过设置步长来指定不连续
    54     v = range(0, 100, 5)
    55     for item in v:
    56         print(item)
    字符串常用属性
      1 #!/usr/bin/env python
      2 # -*- coding:UTF-8 -*-
      3 # Author:Ocean
      4 class str(object):
      5 
      6     def capitalize(self): # real signature unknown; restored from __doc__
      7 
      8         # 首字母变大写
      9         # name = "ocean"
     10         # a = name.capitalize()
     11         #         print(a)
     12 
     13     def casefold(self): # real signature unknown; restored from __doc__
     14 
     15         #         首字母变小写
     16         # name = "Ocean"
     17         # a =name.casefold()
     18         #         print(a)
     19 
     20     def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
     21 
     22         # 内容居中,width:总长度;fillchar:空白处填充内容,默认无。
     23         # name = "ocean"
     24         #         a = name.center(60,'$')
     25         #         print(a)
     26 
     27 
     28     def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
     29 
     30         # 子序列个数,0到12中a出现了几次。
     31         #         name = "ocean is a good man"
     32         #         v= name.count("a",0,12)
     33         #         print(v)
     34 
     35     def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
     36 
     37         # 编码,针对unicode.
     38         # temp = "烧饼"
     39         # temp.encode("unicode")
     40 
     41     def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
     42         # 是否以XX结束,0到4是否以n结尾
     43         # name = "ocean is a good man"
     44         # v = name.endswith("n",0,4)
     45         # print(v)
     46 
     47     def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
     48         # 将tab转换成空格,默认一个tab转换成8个空格
     49         # a = n.expandtabs()
     50         # b = n.expandtabs(16)
     51         # print(a)
     52         # print(b)
     53 
     54     def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
     55 
     56         # 寻找子序列位置,如果没找到,返回 -1。
     57         # name = "ocean is a good man"
     58         # a = name.find("good")
     59         # print(a)
     60 
     61     def format(self, *args, **kwargs): # known special case of str.format
     62          #    字符串格式化,动态参数
     63          # 格式化,传入的值 {"name": 'alex', "a": 19}
     64          # test = 'i am {name}, age {a}'
     65          # v1 = test.format(name='df',a=10)
     66          # v2 = test.format_map({"name": 'alex', "a": 19})  format_map用法(一般用字典键值)
     67 
     68 
     69     def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
     70 
     71         # 子序列位置,如果没有找到就报错
     72         # name = "ocean is a good man"
     73         # a = name.index("ocean")
     74         # print(a)
     75 
     76     def isalnum(self): # real signature unknown; restored from __doc__
     77 
     78         # 是否是字母和数字
     79         # name = "ocean is a good man"
     80         # a = name.isalnum()
     81         # print(a)
     82 
     83 
     84     def isalpha(self): # real signature unknown; restored from __doc__
     85 
     86         # 是否是字母
     87         # name = "ocean is a good man"
     88         # a = name.isalpha()
     89         # print(a)
     90 
     91 
     92     def isdecimal(self): # real signature unknown; restored from __doc__
     93 
     94         # 检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
     95 
     96 
     97 
     98     def isdigit(self): # real signature unknown; restored from __doc__
     99 
    100         # 是否是数字
    101         # name = "ocean is a good man"
    102         # a = name.isdigit()
    103         # print(a)
    104 
    105     def isidentifier(self): # real signature unknown; restored from __doc__
    106 
    107         # 判断字符串是否可为合法的标识符
    108 
    109 
    110     def islower(self): # real signature unknown; restored from __doc__
    111 
    112         # 是否小写
    113         # name = "ocean is A good man"
    114         # a = name.islower()
    115         # print(a)
    116 
    117     def isnumeric(self): # real signature unknown; restored from __doc__
    118 
    119         # 检查是否只有数字字符组成的字符串
    120         # name = "111111111111111”
    121         # a = name.isnumeric()
    122         # print(a)
    123 
    124     def isprintable(self): # real signature unknown; restored from __doc__
    125 
    126         # 判断字符串中所有字符是否都属于可见字符
    127         # name = "ocean is a good man"
    128         # a = name.isprintable()
    129         # print(a)
    130 
    131     def isspace(self): # real signature unknown; restored from __doc__
    132 
    133         # 字符串是否只由空格组成
    134         # name = "  "
    135         # a = name.isspace()
    136         # print(a)
    137 
    138     def istitle(self): # real signature unknown; restored from __doc__
    139 
    140 
    141         # 检测字符串中所有的单词拼写首字母是否为大写,且其他字母为小写
    142         # name = "Ocean Is A Good Man"
    143         # a = name.istitle()
    144         # print(a)
    145 
    146     def isupper(self): # real signature unknown; restored from __doc__
    147 
    148         # 检测字符串中所有的字母是否都为大写
    149         # name = "OCEAN"
    150         # a = name.isupper()
    151         # print(a)
    152 
    153     def join(self, iterable): # real signature unknown; restored from __doc__
    154 
    155         # 连接两个字符串
    156         # li = ["ocean","handsome"]
    157         # a = "".join(li)
    158         # b = "_".join(li)
    159         # print(a)
    160         # print(b)
    161 
    162     def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    163 
    164         # 向左对齐,右侧填充
    165         # name = "ocean is a good man"
    166         # a = name.ljust(60,$)
    167         # print(a)
    168 
    169     def lower(self): # real signature unknown; restored from __doc__
    170 
    171         # 所有大写变小写
    172         # name = "OCEan"
    173         # a = name.lower()
    174         # print(a)
    175 
    176     def lstrip(self, chars=None): # real signature unknown; restored from __doc__
    177 
    178         # 移除左侧空白
    179 
    180     def maketrans(self, *args, **kwargs): # real signature unknown
    181 
    182         # 用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
    183         # from string import maketrans
    184         # intab = "aeiou"
    185         # outtab = "12345"
    186         # trantab = maketrans(intab, outtab)
    187         # str = "this is string example....wow!!!"
    188         # print(str.translate(trantab))
    189 
    190     def partition(self, sep): # real signature unknown; restored from __doc__
    191 
    192         # 分割,前,中,后三部分
    193         # name = "ocean is a good man"
    194         # a = name.partition("good")
    195         # print(a)
    196 
    197     def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
    198 
    199         # 替换
    200         # name = "ocean is a good man"
    201         # a = name.replace("good","man")
    202         # print(a)
    203 
    204 
    205     def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    206 
    207         # 返回字符串最后一次出现的位置,如果没有匹配项则返回-1
    208 
    209     def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
    210 
    211         # 返回子字符串 str 在字符串中最后出现的位置,如果没有匹配的字符串会报异常
    212 
    213     def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    214 
    215         # 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
    216         # str = "this is string example....wow!!!"
    217         # print(str.rjust(50, '$'))
    218 
    219     def rpartition(self, sep): # real signature unknown; restored from __doc__
    220 
    221         # 根据指定的分隔符将字符串进行分割
    222 
    223     def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
    224 
    225         # 指定分隔符对字符串进行切片
    226         # name = "ocean is a good man"
    227         # a = name.rsplit("is")
    228         # print(a)
    229 
    230     def rstrip(self, chars=None): # real signature unknown; restored from __doc__
    231 
    232         # 删除 string 字符串末尾的指定字符(默认为空格)
    233 
    234     def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
    235 
    236         # 通过指定分隔符对字符串进行切片
    237         # str = "Line1-abcdef 
    Line2-abc 
    Line4-abcd";
    238         # print str.split( );
    239         # print str.split(' ', 1 );
    240 
    241     def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
    242 
    243         # 按照行分隔,返回一个包含各行作为元素的列表
    244 
    245     def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
    246 
    247         # 检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False
    248 
    249     def strip(self, chars=None): # real signature unknown; restored from __doc__
    250 
    251         # 用于移除字符串头尾指定的字符(默认为空格).
    252 
    253     def swapcase(self): # real signature unknown; restored from __doc__
    254 
    255         # 用于对字符串的大小写字母进行转换
    256 
    257     def title(self): # real signature unknown; restored from __doc__
    258         """
    259         S.title() -> str
    260 
    261         Return a titlecased version of S, i.e. words start with title case
    262         characters, all remaining cased characters have lower case.
    263         """
    264         return ""
    265 
    266     def translate(self, table): # real signature unknown; restored from __doc__
    267         """
    268         S.translate(table) -> str
    269 
    270         Return a copy of the string S in which each character has been mapped
    271         through the given translation table. The table must implement
    272         lookup/indexing via __getitem__, for instance a dictionary or list,
    273         mapping Unicode ordinals to Unicode ordinals, strings, or None. If
    274         this operation raises LookupError, the character is left untouched.
    275         Characters mapped to None are deleted.
    276         """
    277         return ""
    278 
    279     def upper(self): # real signature unknown; restored from __doc__
    280 
    281         # 将字符串中的小写字母转为大写字母
    282 
    283     def zfill(self, width): # real signature unknown; restored from __doc__
    284 
    285         # 返回指定长度的字符串,原字符串右对齐,前面填充0
    str

    4、列表

     1 1. 列表格式
     2 # 中括号括起来
     3 # 用 ,分割每个元素
     4 
     5 2. 列表中可以嵌套任何类型,列表中的元素可以是 数字,字符串,列表,布尔值..所有的都能放进去
     6 
     7 3. 索引取值
     8 print(li[3])
     9 
    10 4. 切片,切片结果也是列表
    11 
    12 print(li[3:-1])
    13 
    14 5. 支持for循环、while循环
    15 for item in li:
    16     print(item)
    17 
    18 # 列表元素,可以被修改
    19 
    20 # li = [1, 12, 9, "age", ["aaa", ["19", 10], "bbb"], "alex", True]
    21 
    22 6 .索引
    23 # 修改
    24 # li[1] = 120
    25 # print(li)
    26 # li[1] = [11,22,33,44]
    27 # print(li)
    28 
    29 7、删除,索引删除
    30 # del li[1]
    31 # print(li)
    32 # 切片替换修改
    33 # li[1:3] = [120,90]
    34 # print(li)
    35 # 切片删除
    36 # del li[2:6]
    37 # print(li)
    38 
    39 8. in 操作
    40 # li = [1, 12, 9, "age", ["aaa", ["19", 10], "bbb"], "alex", True]
    41 # v1 = "aaa" in li
    42 # print(v1)
    43 # v2 = "age" in li
    44 # print(v2)
    45 ###### 列表中的元素,
    46 
    47 9 .操作
    48 # li = [1, 12, 9, "age", ["aaa", ["19", 10], "bbb"], "alex", True]
    49 # li[4][1][0]
    50 # [1]
    51 
    52 # li = [1, 12, 9, "age", ["aaa", ["19", 10], "bbb"], "alex", True]
    53 
    54 # s = "pouaskdfauspdfiajsdkfj"
    55 # s = 123
    56 # a = "123"
    57 # int(a)
    58 # a = 123
    59 # str(a)
    60 10 转换
    61 # 字符串转换列表   li =  list("asdfasdfasdf"), 内部使用for循环
    62 # s = "pouaskdfauspdfiajsdkfj"
    63 # new_li = list(s)
    64 # print(new_li)
    65 
    66 # 列表转换成字符串,
    67  既有数字又有字符串:需要自己写for循环一个一个处理
    68 # li = [11,22,33,"123","alex"]
    69 # # r = str(li) # '[11,22,33,"123","alex"]'
    70 # # print(r)
    71 # s = ""
    72 # for i in li:
    73 #     s = s + str(i)
    74 # print(s)
    75 直接使用字符串join方法:列表中的元素只有字符串
    76 # li = ["123","alex"]
    77 # v = "".join(li)
    78 # print(v)
    79 
    80 补充:字符串创建后,不可修改
    81 
    82 # 列表,有序;元素可以被修改
    列表常用属性
     1 # def append(self, p_object): # real signature unknown; restored from __doc__
     2 # 在原来的最后追加
     3 li=[1,2,3,2,34,5]
     4 li.append([22,33])
     5 print(li)
     6 #结果:[1, 2, 3, 2, 34, 5, [22, 33]]
     7 # def clear(self): # real signature unknown; restored from __doc__
     8 # 清空列表
     9 li=[1,2,3,2,34,5]
    10 li.clear()
    11 print()
    12 
    13 # def copy(self): # real signature unknown; restored from __doc__
    14 # 复制列表,需赋值
    15 li=[1,2,3,2,34,5]
    16 v = li.copy()
    17 print(v)
    18 # def count(self, value): # real signature unknown; restored from __doc__
    19 # 统计列表中元素的个数
    20 li = [1,2,3,2,34,5]
    21 v = li.count(2)
    22 print(v)
    23 # 结果为2,也就是有两个2
    24 
    25 # def extend(self, iterable): # real signature unknown; restored from __doc__
    26 # 扩展列表,参数为可迭代对象(可以for循环的对象)以for循环遍历完结果加入列表
    27 # 注意区别append
    28 li = [1,2,3,2,34,5]
    29 li.extend(["aa",12,34])
    30 print(li)
    31 # def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    32 # 根据值获取当前索引位置(左边优先)
    33 li = [1,2,3,2,34,5]
    34 v = li.index(34)
    35 print(v)
    36 # def insert(self, index, p_object): # real signature unknown; restored from __doc__
    37 # 在指定索引位置插入元素
    38 li = [1,2,3,2,34,5]
    39 li.insert(0,[1,2])
    40 print(li)
    41 # def pop(self, index=None): # real signature unknown; restored from __doc__
    42 # 删除指定列表索引位置元素,默认删除最后一个,并且获取删除的值
    43 li = [1,2,3,2,34,5]
    44 v=li.pop(0)
    45 print(li)
    46 print(v)
    47 # def remove(self, value): # real signature unknown; restored from __doc__
    48 # 删除列表指定值,左边优先(不可获取)
    49 li = [1,2,3,2,34,5]
    50 li.remove(2)
    51 print(li)
    52 # def reverse(self): # real signature unknown; restored from __doc__
    53 # 将当前列表反转
    54 li = [1,2,3,2,34,5]
    55 li.reverse()
    56 print(li)
    57 # def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
    58 # 列表排序(从小到大)可以用反转来reverse()反排序
    59 li = [1,2,3,2,34,5]
    60 li.sort()
    61 print(li)
    62 li.sort(reverse=True)
    63 print(li)
    list

    5、元组(不可修改)

     1 # 元组,元素不可被修改,不能被增加或者删除
     2 # 1. 书写格式
     3 # tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
     4 # 一般写元组的时候,推荐在最后加入 ,
     5 # 元素不可被修改,不能被增加或者删除
     6 # 2. 索引
     7 # v = tu[0]
     8 # print(v)
     9 
    10 # 3. 切片
    11 # v = tu[0:2]
    12 # print(v)
    13 
    14 # 4. 可以被for循环,可迭代对象
    15 # for item in tu:
    16 #     print(item)
    17 
    18 # 5. 转换
    19 # s = "asdfasdf0"
    20 # li = ["asdf","asdfasdf"]
    21 # tu = ("asdf","asdf")
    22 #遍历字符串,每个字符成为元组元素
    23 # v = tuple(s)
    24 # print(v)
    25 #字典可以直接转换为元组
    26 # v = tuple(li)
    27 # print(v)
    28 #元组可以直接转化成列表
    29 # v = list(tu)
    30 # print(v)
    31 # 如果元组中都为字符串的时候可以用join粘合元组中元素,如果有数字则不可以
    32 # v = "_".join(tu)
    33 # print(v)
    34 # 列表能够遍历加入列表中
    35 # li = ["asdf","asdfasdf"]
    36 # li.extend((11,22,33,))
    37 # print(li)
    38 
    39 # 6.元组的一级元素不可修改/删除/增加
    40 # tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
    41 # # 元组,有序。
    42 # # v = tu[3][0][0]
    43 # # print(v)
    44 # # v=tu[3]
    45 # # print(v)
    46 # tu[3][0] = 567
    47 # print(tu)
    元组常用属性
    1 # 由于元组是不可更改的所以只有索引查询跟计数的功能
    2 def count(self, value): # real signature unknown; restored from __doc__
    3 # 获取指定元素在元组中出现的次数
    4 # tu = (11,22,33,44)
    5 # tu.count(22)
    6 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    7 # 获取指定元素在元组中的位置
    8 # tu = (11,22,33,44)
    9 # tu.index(22)
    tuple

    6、set集合

      1 class set(object):
      2 
      3 def add(self, *args, **kwargs): # real signature unknown
      4 """添加元素
      5 >>> a = {"alex","mm","ocean"}
      6 >>> a.add('ss')
      7 >>> a
      8 {"alex","mm","ocean","ss"}
      9 
     10 """
     11 
     12 def clear(self, *args, **kwargs): # real signature unknown
     13 """清除内容
     14 >>> a = {"alex","mm","ocean"}
     15 >>> a.clear()
     16 >>> a
     17 set()
     18 """
     19 def copy(self, *args, **kwargs): # real signature unknown
     20 """浅拷贝
     21 >>> a = {"alex","mm","ocean"}
     22 >>> b = a.copy()
     23 >>> b
     24 {"alex","mm","ocean"}
     25 """
     26 
     27 def difference(self, *args, **kwargs): # real signature unknown
     28 """A中存在,B中不存在,差集(-)
     29 >>> a = {"alex","mm","ocean"}
     30 >>> b = {"ll","tt","alex"}
     31 >>> a.difference(b) #或者可以为print(a-b)
     32 {"mm","ocean"}
     33 """
     34 
     35 def difference_update(self, *args, **kwargs): # real signature unknown
     36 """从当前集合中删除和B中相同的元素,并更新到a中
     37 >>> a = {"alex","mm","ocean"}
     38 >>> b = {"ll","tt","alex"}
     39 >>> a.difference_update(b)
     40 >>> a
     41 {"mm","ocean"}
     42 """
     43 
     44 def discard(self, *args, **kwargs): # real signature unknown
     45 """移除指定元素,不存在不报错
     46 >>> a = {"alex","mm","ocean"}
     47 >>> a.discard("aa")
     48 >>> a
     49 """
     50 
     51 def intersection(self, *args, **kwargs): # real signature unknown
     52 """a与b的交集(&)
     53 >>> a = {"alex","mm","ocean"}
     54 >>> b = {"ll","tt","alex"}
     55 >>> a.intersection(b)  #a&b
     56 {"alex"}
     57 """
     58 
     59 def intersection_update(self, *args, **kwargs): # real signature unknown
     60 """取交集并更更新到a中
     61 """
     62 
     63 def isdisjoint(self, *args, **kwargs): # real signature unknown
     64 """如果没有交集,返回True,否则返回False
     65 >>> a = {"alex","mm","ocean"}
     66 >>> b = {"ll","tt","alex"}
     67 >>> a.isdisjoint(b)
     68 False
     69 """
     70 
     71 def issubset(self, *args, **kwargs): # real signature unknown
     72 """是否是子序列
     73 >>> a = {"alex","mm","ocean"}
     74 >>> b = {"alex"}
     75 >>> b.issubset(a)
     76 True
     77 >>> a.issubset(b)
     78 False
     79 """
     80 
     81 def issuperset(self, *args, **kwargs): # real signature unknown
     82 """是否是父序列
     83 >>> a = {"alex","mm","ocean"}
     84 >>> b = {"alex"}
     85 >>> a.issuperset(b)
     86 True
     87 >>> b.issuperset(a)
     88 False
     89 """
     90 
     91 def pop(self, *args, **kwargs): # real signature unknown
     92 """移除元素
     93 >>> a = {"alex","mm","ocean"}
     94 >>> a.pop()
     95 "alex"
     96 >>> a
     97 {"mm","ocean"}
     98 """
     99 
    100 def remove(self, *args, **kwargs): # real signature unknown
    101 """移除指定元素,不存在报错
    102 >>> a = {"alex","mm","ocean"}
    103 >>> a.remove("ss")
    104 Traceback (most recent call last):
    105   File "<stdin>", line 1, in <module>
    106 KeyError: "ss"
    107 >>> 
    108 """
    109 
    110 def symmetric_difference(self, *args, **kwargs): # real signature unknown
    111 """交叉补集 (^)
    112 >>> a = {"alex","mm","ocean"}
    113 >>> b = {"ll","tt","alex"}
    114 >>> a.symmetric_difference(b)   #a^b
    115 {"mm","ocean","ll","tt"}
    116 """
    117 
    118 def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
    119 """交叉补集,并更新到a中
    120 >>> a = {"alex","mm","ocean"}
    121 >>> b = {"ll","tt","alex"}
    122 >>> a.symmetric_difference_update(b)
    123 >>> a
    124 {"mm","ocean","ll","tt"}
    125 """
    126 
    127 def union(self, *args, **kwargs): # real signature unknown
    128 """并集,(|)
    129 >>> a = {"alex","mm","ocean"}
    130 >>> b = {"ll","tt","alex"}
    131 >>> a.union(b)  #a|b
    132 {"alex","mm","ocean","ll","tt"}
    133 """
    134 
    135 def update(self, *args, **kwargs): # real signature unknown
    136 """更新,添加多个元素,更新  注意区别add
    137 >>> a = {"alex","mm","ocean"}
    138 >>> b = {"ll","tt","alex"}
    139 >>> a.update(b)  #把b中的多个元素加入到a中并更新a中的内容,b并不改变
    140 >>> a
    141 {"alex","mm","ocean", "ll","tt"}
    142 >>> b
    143 {"ll","tt","alex"}
    144 """
    set

    7、字典(无序)

      1 # 1、基本结构
      2 # info = {
      3 #     "k1": "v1", # 键值对
      4 #     "k2": "v2"
      5 # }
      6 #2、字典的value可以是任何值
      7 # info = {
      8 #     "k1": 18,
      9 #     "k2": True,
     10 #     "k3": [
     11 #         11,
     12 #         [],
     13 #         (),
     14 #         22,
     15 #         33,
     16 #         {
     17 #             'kk1': 'vv1',
     18 #             'kk2': 'vv2',
     19 #             'kk3': (11,22),
     20 #         }
     21 #     ],
     22 #     "k4": (11,22,33,44)
     23 # }
     24 # print(info)
     25 
     26 #3、列表、字典不能作为字典的key
     27 # info ={
     28 #     1: 'asdf',
     29 #     "k1": 'asdf',
     30 #     True: "123",
     31 #     # [11,22]: 123
     32 #     (11,22): 123,
     33 #     # {'k1':'v1'}: 123
     34 #
     35 # }
     36 # print(info)
     37 
     38 # 4 字典无序
     39 
     40 # info = {
     41 #     "k1": 18,
     42 #     "k2": True,
     43 #     "k3": [
     44 #         11,
     45 #         [],
     46 #         (),
     47 #         22,
     48 #         33,
     49 #         {
     50 #             'kk1': 'vv1',
     51 #             'kk2': 'vv2',
     52 #             'kk3': (11,22),
     53 #         }
     54 #     ],
     55 #     "k4": (11,22,33,44)
     56 # }
     57 # print(info)
     58 
     59 # 5、索引方式找到指定元素
     60 # info = {
     61 #     "k1": 18,
     62 #     2: True,
     63 #     "k3": [
     64 #         11,
     65 #         [],
     66 #         (),
     67 #         22,
     68 #         33,
     69 #         {
     70 #             'kk1': 'vv1',
     71 #             'kk2': 'vv2',
     72 #             'kk3': (11,22),
     73 #         }
     74 #     ],
     75 #     "k4": (11,22,33,44)
     76 # }
     77 # # v = info['k1']
     78 # # print(v)
     79 # # v = info[2]
     80 # # print(v)
     81 # v = info['k3'][5]['kk3'][0]
     82 # print(v)
     83 
     84 # 6 字典支持 del 删除
     85 # info = {
     86 #     "k1": 18,
     87 #     2: True,
     88 #     "k3": [
     89 #         11,
     90 #         [],
     91 #         (),
     92 #         22,
     93 #         33,
     94 #         {
     95 #             'kk1': 'vv1',
     96 #             'kk2': 'vv2',
     97 #             'kk3': (11,22),
     98 #         }
     99 #     ],
    100 #     "k4": (11,22,33,44)
    101 # }
    102 # del info['k1']
    103 #
    104 # del info['k3'][5]['kk1']
    105 # print(info)
    106 
    107 # 7 for循环
    108 # dict
    109 # info = {
    110 #     "k1": 18,
    111 #     2: True,
    112 #     "k3": [
    113 #         11,
    114 #         [],
    115 #         (),
    116 #         22,
    117 #         33,
    118 #         {
    119 #             'kk1': 'vv1',
    120 #             'kk2': 'vv2',
    121 #             'kk3': (11,22),
    122 #         }
    123 #     ],
    124 #     "k4": (11,22,33,44)
    125 # }
    126 # for item in info:
    127 #     print(item)
    128 #
    129 # for item in info.keys():
    130 #     print(item)
    131 
    132 # for item in info.values():
    133 #     print(item)
    134 
    135 # for item in info.keys():
    136 #     print(item,info[item])
    137 
    138 # for k,v in info.items():
    139 #     print(k,v)
    140 
    141 # True 1  False 0
    142 # info ={
    143 #     "k1": 'asdf',
    144 #     True: "123",
    145 #     # [11,22]: 123
    146 #     (11,22): 123,
    147 #     # {'k1':' v1'}: 123
    148 #
    149 # }
    150 # print(info)
    字典常用属性
     1 def clear(self): # real signature unknown; restored from __doc__
     2 # 清空字典
     3 
     4 def copy(self): # real signature unknown; restored from __doc__
     5 # 复制字典
     6 @staticmethod # known case
     7 def fromkeys(*args, **kwargs): # real signature unknown
     8 # 根据序列,创建字典,并指定统一的值
     9 # dic = {
    10 #     "k1": 'v1',
    11 #     "k2": 'v2'
    12 # }
    13 # v = dict.fromkeys("k1",123)
    14 # print(v)
    15 def get(self, k, d=None): # real signature unknown; restored from __doc__
    16 # 根据Key获取值,key不存在时,可以指定默认值(None)
    17 # v = dic['k1']
    18 # print(v)
    19 # v = dic.get('k11',111111)
    20 # print(v)
    21 
    22 def items(self): # real signature unknown; restored from __doc__
    23 # 可以利用for来遍历键值对
    24 # dic = {
    25 #     "k1": 'v1',
    26 #     "k2": 'v2'
    27 # }
    28 # for k,v in dic.items():
    29 #     print(k,v)
    30 
    31 def keys(self): # real signature unknown; restored from __doc__
    32 # 字典的key
    33 # dic = {
    34 #     "k1": 'v1',
    35 #     "k2": 'v2'
    36 # }
    37 # for k in dic.keys():
    38 #     print(k)
    39 
    40 def pop(self, k, d=None): # real signature unknown; restored from __doc__
    41 # 删除并获取值
    42 # dic = {
    43 #     "k1": 'v1',
    44 #     "k2": 'v2'
    45 # }
    46 # v = dic.pop('k1',90)
    47 # print(dic,v)
    48 
    49 def popitem(self): # real signature unknown; restored from __doc__
    50 # 删除键值对然后可以获取删除的键值对
    51 # dic = {
    52 #     "k1": 'v1',
    53 #     "k2": 'v2'
    54 # }
    55 # k,v = dic.popitem()
    56 # print(dic,k,v)
    57 
    58 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
    59 # 设置值,
    60 # 已存在,不设置,获取当前key对应的值
    61 # 不存在,设置添加,获取当前key对应的值
    62 # dic = {
    63 #     "k1": 'v1',
    64 #     "k2": 'v2'
    65 # }
    66 # v = dic.setdefault('k1111','123')
    67 # print(dic,v)
    68 
    69 def update(self, E=None, **F): # known special case of dict.update
    70 # 更新
    71 # dic = {
    72 #     "k1": 'v1',
    73 #     "k2": 'v2'
    74 # }
    75 # dic.update({'k1': '111111','k3': 123}) #形式一
    76 # print(dic)
    77 # dic.update(k1=123,k3=345,k5="asdf")  #形式二
    78 # print(dic)
    79 
    80 def values(self): # real signature unknown; restored from __doc__
    81 # 字典的值values
    82 # dic = {
    83 #     "k1": 'v1',
    84 #     "k2": 'v2'
    85 # }
    86 # for v in dic.values():
    87 #     print(v)
    dict

    其他

    1、编码与进制转换

    • utf-8与gbk编码转换,python3里默认的编码方式为unicode

    2、range

     1 #python 2.7 版本
     2 
     3 print range(1, 10)
     4 
     5 # 结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
     6 
     7   
     8 
     9 print range(1, 10, 2)
    10 
    11 # 结果:[1, 3, 5, 7, 9]
    12 
    13   
    14 
    15 print range(30, 0, -2)
    16 
    17 # 结果:[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]
    18 
    19  
    20 
    21  
    22 
    23 #python 3.5 版本
    24 
    25 a = range(10)
    26 
    27 print(a)
    28 
    29 #结果:range(0, 10)

    3、for循环

    用户按照顺序循环可迭代对象中的内容

    1 name = ('ocean','alex')
    2 
    3 for i in name:
    4 
    5     print(i)

    4、while循环

     1 while 条件:
     2         ....
     3 
     4     print('...')
     5     
     6     补充:
     7         a. while else
     8         b. continue   break
     9            continue ,终止当前循环,开始下一次循环
    10            break    ,终止所有循环
    11 ******continue 是跳出本次循环,break是跳出整个循环(当前的while or for循环)! ******   
    12 用户登陆(三次机会重试)
    13 count = 0
    14 while count < 3:
    15     user = input('>>>')
    16     pwd = input('>>>')
    17     if user == 'alex' and pwd == '123':
    18         print('欢迎登陆')
    19         print('..........')
    20         break
    21     else:
    22         print('用户名或者密码错误')
    23     count = count + 1
  • 相关阅读:
    PAT——1069. 微博转发抽奖
    PAT——1068. 万绿丛中一点红
    PAT——1066. 图像过滤
    PAT——1065. 单身狗
    PAT——1064. 朋友数
    PAT——1063. 计算谱半径
    PAT——1062. 最简分数
    PAT——1061. 判断题
    PAT——1060. 爱丁顿数
    PAT——1059. C语言竞赛
  • 原文地址:https://www.cnblogs.com/mocean/p/6091479.html
Copyright © 2020-2023  润新知