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()

  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'\x00\x10', byteorder='big')
 69         >>> int.from_bytes(b'\x00\x10', byteorder='little')
 70         >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
 71         -1024
 72         >>> int.from_bytes(b'\xfc\x00', 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'\x04\x00'
101         >>> (1024).to_bytes(10, byteorder='big')
102         b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
103         >>> (-1024).to_bytes(10, byteorder='big', signed=True)
104         b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
105         >>> x = 1000
106         >>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
107         b'\xe8\x03'
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

 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 \nLine2-abc \nLine4-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 #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)

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

 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