一、运算符

1.算数运算符

2.比较运算符

3.复制运算符

4.逻辑运算符

5.成员运算符

二、基本数据类型

1.数字

整数(int)

  1. 32位机器上,整数的位数为32位,取值范围为-2**312**31-1,即-21474836482147483647
  2. 64位系统上,整数的位数为64位,取值范围为-2**632**63-1,即-92233720368547758089223372036854775807

浮点数(fload)

  1. 浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x10912.3x108是完全相等的。
    浮点数可以用数学写法,如1.233.14,-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10e替代,1.23x109就是1.23e9,或者12.3e80.000012可以写成1.2e-5

2.布尔值

  1. 真或假
  2. 1 0

3.字符串

  1. str="Hello world ! "
字符串常用功能:
  • 移除空白

    1. str.strip(self, chars=None)
    1. """ 移除两段空白 """
  • 分割  
    1. str.split(self, sep=None, maxsplit=None)
    1. """ 分割, maxsplit最多分割几次 """
  • 长度   ##len(str)
  • 索引   ##str[0]  获取字符串第一个元素
  • 切片                 
    1. [:] 提取从开头(默认位置0)到结尾(默认位置-1)的整个字符串
    1. str[::5]
      [start:end:step]
    1. [:end] 从开头提取到end - 1
      [start:end] start 提取到end - 1
      [start:end:step] start 提取到end - 1,每step 个字符提取一个
      左侧第一个字符的位置/偏移量为0,右侧最后一个字符的位置/偏移量为-1
  • 大小写转换
    1. str.swapcase(self)
    2. """ 大写变小写,小写变大写 """
    1. str.upper(self)
    1. str.lower(self)
  • 替换
    1. str.replace(self, old, new, count=None)
  • 统计
    1. str.count('le') ##统计le在str出现的次数
    1. 格式输出

   str.center(50,"-")

  1.    ##输出 '--------------------- Hello world ! ----------------------'
  1. class str(basestring):
  2. """
  3. str(object='') -> string
  4.  
  5. Return a nice string representation of the object.
  6. If the argument is a string, the return value is the same object.
  7. """
  8. def capitalize(self):
  9. """ 首字母变大写 """
  10. """
  11. S.capitalize() -> string
  12.  
  13. Return a copy of the string S with only its first character
  14. capitalized.
  15. """
  16. return ""
  17.  
  18. def center(self, width, fillchar=None):
  19. """ 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """
  20. """
  21. S.center(width[, fillchar]) -> string
  22.  
  23. Return S centered in a string of length width. Padding is
  24. done using the specified fill character (default is a space)
  25. """
  26. return ""
  27.  
  28. def count(self, sub, start=None, end=None):
  29. """ 子序列个数 """
  30. """
  31. S.count(sub[, start[, end]]) -> int
  32.  
  33. Return the number of non-overlapping occurrences of substring sub in
  34. string S[start:end]. Optional arguments start and end are interpreted
  35. as in slice notation.
  36. """
  37. return 0
  38.  
  39. def decode(self, encoding=None, errors=None):
  40. """ 解码 """
  41. """
  42. S.decode([encoding[,errors]]) -> object
  43.  
  44. Decodes S using the codec registered for encoding. encoding defaults
  45. to the default encoding. errors may be given to set a different error
  46. handling scheme. Default is 'strict' meaning that encoding errors raise
  47. a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
  48. as well as any other name registered with codecs.register_error that is
  49. able to handle UnicodeDecodeErrors.
  50. """
  51. return object()
  52.  
  53. def encode(self, encoding=None, errors=None):
  54. """ 编码,针对unicode """
  55. """
  56. S.encode([encoding[,errors]]) -> object
  57.  
  58. Encodes S using the codec registered for encoding. encoding defaults
  59. to the default encoding. errors may be given to set a different error
  60. handling scheme. Default is 'strict' meaning that encoding errors raise
  61. a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
  62. 'xmlcharrefreplace' as well as any other name registered with
  63. codecs.register_error that is able to handle UnicodeEncodeErrors.
  64. """
  65. return object()
  66.  
  67. def endswith(self, suffix, start=None, end=None):
  68. """ 是否以 xxx 结束 """
  69. """
  70. S.endswith(suffix[, start[, end]]) -> bool
  71.  
  72. Return True if S ends with the specified suffix, False otherwise.
  73. With optional start, test S beginning at that position.
  74. With optional end, stop comparing S at that position.
  75. suffix can also be a tuple of strings to try.
  76. """
  77. return False
  78.  
  79. def expandtabs(self, tabsize=None):
  80. """ 将tab转换成空格,默认一个tab转换成8个空格 """
  81. """
  82. S.expandtabs([tabsize]) -> string
  83.  
  84. Return a copy of S where all tab characters are expanded using spaces.
  85. If tabsize is not given, a tab size of 8 characters is assumed.
  86. """
  87. return ""
  88.  
  89. def find(self, sub, start=None, end=None):
  90. """ 寻找子序列位置,如果没找到,返回 -1 """
  91. """
  92. S.find(sub [,start [,end]]) -> int
  93.  
  94. Return the lowest index in S where substring sub is found,
  95. such that sub is contained within S[start:end]. Optional
  96. arguments start and end are interpreted as in slice notation.
  97.  
  98. Return -1 on failure.
  99. """
  100. return 0
  101.  
  102. def format(*args, **kwargs): # known special case of str.format
  103. """ 字符串格式化,动态参数,将函数式编程时细说 """
  104. """
  105. S.format(*args, **kwargs) -> string
  106.  
  107. Return a formatted version of S, using substitutions from args and kwargs.
  108. The substitutions are identified by braces ('{' and '}').
  109. """
  110. pass
  111.  
  112. def index(self, sub, start=None, end=None):
  113. """ 子序列位置,如果没找到,报错 """
  114. S.index(sub [,start [,end]]) -> int
  115.  
  116. Like S.find() but raise ValueError when the substring is not found.
  117. """
  118. return 0
  119.  
  120. def isalnum(self):
  121. """ 是否是字母和数字 """
  122. """
  123. S.isalnum() -> bool
  124.  
  125. Return True if all characters in S are alphanumeric
  126. and there is at least one character in S, False otherwise.
  127. """
  128. return False
  129.  
  130. def isalpha(self):
  131. """ 是否是字母 """
  132. """
  133. S.isalpha() -> bool
  134.  
  135. Return True if all characters in S are alphabetic
  136. and there is at least one character in S, False otherwise.
  137. """
  138. return False
  139.  
  140. def isdigit(self):
  141. """ 是否是数字 """
  142. """
  143. S.isdigit() -> bool
  144.  
  145. Return True if all characters in S are digits
  146. and there is at least one character in S, False otherwise.
  147. """
  148. return False
  149.  
  150. def islower(self):
  151. """ 是否小写 """
  152. """
  153. S.islower() -> bool
  154.  
  155. Return True if all cased characters in S are lowercase and there is
  156. at least one cased character in S, False otherwise.
  157. """
  158. return False
  159.  
  160. def isspace(self):
  161. """
  162. S.isspace() -> bool
  163.  
  164. Return True if all characters in S are whitespace
  165. and there is at least one character in S, False otherwise.
  166. """
  167. return False
  168.  
  169. def istitle(self):
  170. """
  171. S.istitle() -> bool
  172.  
  173. Return True if S is a titlecased string and there is at least one
  174. character in S, i.e. uppercase characters may only follow uncased
  175. characters and lowercase characters only cased ones. Return False
  176. otherwise.
  177. """
  178. return False
  179.  
  180. def isupper(self):
  181. """
  182. S.isupper() -> bool
  183.  
  184. Return True if all cased characters in S are uppercase and there is
  185. at least one cased character in S, False otherwise.
  186. """
  187. return False
  188.  
  189. def join(self, iterable):
  190. """ 连接 """
  191. """
  192. S.join(iterable) -> string
  193.  
  194. Return a string which is the concatenation of the strings in the
  195. iterable. The separator between elements is S.
  196. """
  197. return ""
  198.  
  199. def ljust(self, width, fillchar=None):
  200. """ 内容左对齐,右侧填充 """
  201. """
  202. S.ljust(width[, fillchar]) -> string
  203.  
  204. Return S left-justified in a string of length width. Padding is
  205. done using the specified fill character (default is a space).
  206. """
  207. return ""
  208.  
  209. def lower(self):
  210. """ 变小写 """
  211. """
  212. S.lower() -> string
  213.  
  214. Return a copy of the string S converted to lowercase.
  215. """
  216. return ""
  217.  
  218. def lstrip(self, chars=None):
  219. """ 移除左侧空白 """
  220. """
  221. S.lstrip([chars]) -> string or unicode
  222.  
  223. Return a copy of the string S with leading whitespace removed.
  224. If chars is given and not None, remove characters in chars instead.
  225. If chars is unicode, S will be converted to unicode before stripping
  226. """
  227. return ""
  228.  
  229. def partition(self, sep):
  230. """ 分割,前,中,后三部分 """
  231. """
  232. S.partition(sep) -> (head, sep, tail)
  233.  
  234. Search for the separator sep in S, and return the part before it,
  235. the separator itself, and the part after it. If the separator is not
  236. found, return S and two empty strings.
  237. """
  238. pass
  239.  
  240. def replace(self, old, new, count=None):
  241. """ 替换 """
  242. """
  243. S.replace(old, new[, count]) -> string
  244.  
  245. Return a copy of string S with all occurrences of substring
  246. old replaced by new. If the optional argument count is
  247. given, only the first count occurrences are replaced.
  248. """
  249. return ""
  250.  
  251. def rfind(self, sub, start=None, end=None):
  252. """
  253. S.rfind(sub [,start [,end]]) -> int
  254.  
  255. Return the highest index in S where substring sub is found,
  256. such that sub is contained within S[start:end]. Optional
  257. arguments start and end are interpreted as in slice notation.
  258.  
  259. Return -1 on failure.
  260. """
  261. return 0
  262.  
  263. def rindex(self, sub, start=None, end=None):
  264. """
  265. S.rindex(sub [,start [,end]]) -> int
  266.  
  267. Like S.rfind() but raise ValueError when the substring is not found.
  268. """
  269. return 0
  270.  
  271. def rjust(self, width, fillchar=None):
  272. """
  273. S.rjust(width[, fillchar]) -> string
  274.  
  275. Return S right-justified in a string of length width. Padding is
  276. done using the specified fill character (default is a space)
  277. """
  278. return ""
  279.  
  280. def rpartition(self, sep):
  281. """
  282. S.rpartition(sep) -> (head, sep, tail)
  283.  
  284. Search for the separator sep in S, starting at the end of S, and return
  285. the part before it, the separator itself, and the part after it. If the
  286. separator is not found, return two empty strings and S.
  287. """
  288. pass
  289.  
  290. def rsplit(self, sep=None, maxsplit=None):
  291. """
  292. S.rsplit([sep [,maxsplit]]) -> list of strings
  293.  
  294. Return a list of the words in the string S, using sep as the
  295. delimiter string, starting at the end of the string and working
  296. to the front. If maxsplit is given, at most maxsplit splits are
  297. done. If sep is not specified or is None, any whitespace string
  298. is a separator.
  299. """
  300. return []
  301.  
  302. def rstrip(self, chars=None):
  303. """
  304. S.rstrip([chars]) -> string or unicode
  305.  
  306. Return a copy of the string S with trailing whitespace removed.
  307. If chars is given and not None, remove characters in chars instead.
  308. If chars is unicode, S will be converted to unicode before stripping
  309. """
  310. return ""
  311.  
  312. def split(self, sep=None, maxsplit=None):
  313. """ 分割, maxsplit最多分割几次 """
  314. """
  315. S.split([sep [,maxsplit]]) -> list of strings
  316.  
  317. Return a list of the words in the string S, using sep as the
  318. delimiter string. If maxsplit is given, at most maxsplit
  319. splits are done. If sep is not specified or is None, any
  320. whitespace string is a separator and empty strings are removed
  321. from the result.
  322. """
  323. return []
  324.  
  325. def splitlines(self, keepends=False):
  326. """ 根据换行分割 """
  327. """
  328. S.splitlines(keepends=False) -> list of strings
  329.  
  330. Return a list of the lines in S, breaking at line boundaries.
  331. Line breaks are not included in the resulting list unless keepends
  332. is given and true.
  333. """
  334. return []
  335.  
  336. def startswith(self, prefix, start=None, end=None):
  337. """ 是否起始 """
  338. """
  339. S.startswith(prefix[, start[, end]]) -> bool
  340.  
  341. Return True if S starts with the specified prefix, False otherwise.
  342. With optional start, test S beginning at that position.
  343. With optional end, stop comparing S at that position.
  344. prefix can also be a tuple of strings to try.
  345. """
  346. return False
  347.  
  348. def strip(self, chars=None):
  349. """ 移除两段空白 """
  350. """
  351. S.strip([chars]) -> string or unicode
  352.  
  353. Return a copy of the string S with leading and trailing
  354. whitespace removed.
  355. If chars is given and not None, remove characters in chars instead.
  356. If chars is unicode, S will be converted to unicode before stripping
  357. """
  358. return ""
  359.  
  360. def swapcase(self):
  361. """ 大写变小写,小写变大写 """
  362. """
  363. S.swapcase() -> string
  364.  
  365. Return a copy of the string S with uppercase characters
  366. converted to lowercase and vice versa.
  367. """
  368. return ""
  369.  
  370. def title(self):
  371. """
  372. S.title() -> string
  373.  
  374. Return a titlecased version of S, i.e. words start with uppercase
  375. characters, all remaining cased characters have lowercase.
  376. """
  377. return ""
  378.  
  379. def translate(self, table, deletechars=None):
  380. """
  381. 转换,需要先做一个对应表,最后一个表示删除字符集合
  382. intab = "aeiou"
  383. outtab = ""
  384. trantab = maketrans(intab, outtab)
  385. str = "this is string example....wow!!!"
  386. print str.translate(trantab, 'xm')
  387. """
  388.  
  389. """
  390. S.translate(table [,deletechars]) -> string
  391.  
  392. Return a copy of the string S, where all characters occurring
  393. in the optional argument deletechars are removed, and the
  394. remaining characters have been mapped through the given
  395. translation table, which must be a string of length 256 or None.
  396. If the table argument is None, no translation is applied and
  397. the operation simply removes the characters in deletechars.
  398. """
  399. return ""
  400.  
  401. def upper(self):
  402. """
  403. S.upper() -> string
  404.  
  405. Return a copy of the string S converted to uppercase.
  406. """
  407. return ""
  408.  
  409. def zfill(self, width):
  410. """方法返回指定长度的字符串,原字符串右对齐,前面填充0"""
  411. """
  412. S.zfill(width) -> string
  413.  
  414. Pad a numeric string S with zeros on the left, to fill a field
  415. of the specified width. The string S is never truncated.
  416. """
  417. return ""
  418.  
  419. def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
  420. pass
  421.  
  422. def _formatter_parser(self, *args, **kwargs): # real signature unknown
  423. pass
  424.  
  425. def __add__(self, y):
  426. """ x.__add__(y) <==> x+y """
  427. pass
  428.  
  429. def __contains__(self, y):
  430. """ x.__contains__(y) <==> y in x """
  431. pass
  432.  
  433. def __eq__(self, y):
  434. """ x.__eq__(y) <==> x==y """
  435. pass
  436.  
  437. def __format__(self, format_spec):
  438. """
  439. S.__format__(format_spec) -> string
  440.  
  441. Return a formatted version of S as described by format_spec.
  442. """
  443. return ""
  444.  
  445. def __getattribute__(self, name):
  446. """ x.__getattribute__('name') <==> x.name """
  447. pass
  448.  
  449. def __getitem__(self, y):
  450. """ x.__getitem__(y) <==> x[y] """
  451. pass
  452.  
  453. def __getnewargs__(self, *args, **kwargs): # real signature unknown
  454. pass
  455.  
  456. def __getslice__(self, i, j):
  457. """
  458. x.__getslice__(i, j) <==> x[i:j]
  459.  
  460. Use of negative indices is not supported.
  461. """
  462. pass
  463.  
  464. def __ge__(self, y):
  465. """ x.__ge__(y) <==> x>=y """
  466. pass
  467.  
  468. def __gt__(self, y):
  469. """ x.__gt__(y) <==> x>y """
  470. pass
  471.  
  472. def __hash__(self):
  473. """ x.__hash__() <==> hash(x) """
  474. pass
  475.  
  476. def __init__(self, string=''): # known special case of str.__init__
  477. """
  478. str(object='') -> string
  479.  
  480. Return a nice string representation of the object.
  481. If the argument is a string, the return value is the same object.
  482. # (copied from class doc)
  483. """
  484. pass
  485.  
  486. def __len__(self):
  487. """ x.__len__() <==> len(x) """
  488. pass
  489.  
  490. def __le__(self, y):
  491. """ x.__le__(y) <==> x<=y """
  492. pass
  493.  
  494. def __lt__(self, y):
  495. """ x.__lt__(y) <==> x<y """
  496. pass
  497.  
  498. def __mod__(self, y):
  499. """ x.__mod__(y) <==> x%y """
  500. pass
  501.  
  502. def __mul__(self, n):
  503. """ x.__mul__(n) <==> x*n """
  504. pass
  505.  
  506. @staticmethod # known case of __new__
  507. def __new__(S, *more):
  508. """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  509. pass
  510.  
  511. def __ne__(self, y):
  512. """ x.__ne__(y) <==> x!=y """
  513. pass
  514.  
  515. def __repr__(self):
  516. """ x.__repr__() <==> repr(x) """
  517. pass
  518.  
  519. def __rmod__(self, y):
  520. """ x.__rmod__(y) <==> y%x """
  521. pass
  522.  
  523. def __rmul__(self, n):
  524. """ x.__rmul__(n) <==> n*x """
  525. pass
  526.  
  527. def __sizeof__(self):
  528. """ S.__sizeof__() -> size of S in memory, in bytes """
  529. pass
  530.  
  531. def __str__(self):
  532. """ x.__str__() <==> str(x) """
  533. pass
  534.  
  535. str

字符串类

4. 列表

列表创建

  1. name_list = ['alex', 'seven', 'eric']

  2. name_list list(['alex', 'seven', 'eric'])

基本操作:

  1. names = ['Alex',"Tenglan",'Eric']
  2. >>> names[0]
  3. 'Alex'
  4. >>> names[2]
  5. 'Eric'
  6. >>> names[-1]
  7. 'Eric'
  8. >>> names[-2] #还可以倒着取
  9. 'Tenglan'

索引

  1. >>> names
  2. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
  3. >>> names.append("我是新来的")
  4. >>> names
  5. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

追加

  1. >>> names
  2. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  3. >>> names.insert(2,"强行从Eric前面插入")
  4. >>> names
  5. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  6.  
  7. >>> names.insert(5,"从eric后面插入试试新姿势")
  8. >>> names
  9. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

插入

  1. >>> names
  2. ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  3. >>> names[2] = "该换人了"
  4. >>> names
  5. ['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

修改

  1. >>> del names[2]
  2. >>> names
  3. ['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  4. >>> del names[4]
  5. >>> names
  6. ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  7. >>>
  8. >>> names.remove("Eric") #删除指定元素
  9. >>> names
  10. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
  11. >>> names.pop() #删除列表最后一个值
  12. '我是新来的'
  13. >>> names
  14. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

删除

  1. >>> names
  2. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
  3. >>> b = [1,2,3]
  4. >>> names.extend(b)
  5. >>> names
  6. ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

扩展

  1. >>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
  2. >>> names[1:4] #取下标1至下标4之间的数字,包括1,不包括4
  3. ['Tenglan', 'Eric', 'Rain']
  4. >>> names[1:-1] #取下标1至-1的值,不包括-1
  5. ['Tenglan', 'Eric', 'Rain', 'Tom']
  6. >>> names[0:3]
  7. ['Alex', 'Tenglan', 'Eric']
  8. >>> names[:3] #如果是从头开始取,0可以忽略,跟上句效果一样
  9. ['Alex', 'Tenglan', 'Eric']
  10. >>> names[3:] #如果想取最后一个,必须不能写-1,只能这么写
  11. ['Rain', 'Tom', 'Amy']
  12. >>> names[3:-1] #这样-1就不会被包含了
  13. ['Rain', 'Tom']
  14. >>> names[0::2] #后面的2是代表,每隔一个元素,就取一个
  15. ['Alex', 'Eric', 'Tom']
  16. >>> names[::2] #和上句效果一样
  17. ['Alex', 'Eric', 'Tom']

切片

  1. class list(object):
  2. """
  3. list() -> new empty list
  4. list(iterable) -> new list initialized from iterable's items
  5. """
  6. def append(self, p_object): # real signature unknown; restored from __doc__
  7. """ L.append(object) -- append object to end """
  8. pass
  9.  
  10. def count(self, value): # real signature unknown; restored from __doc__
  11. """ L.count(value) -> integer -- return number of occurrences of value """
  12. return 0
  13.  
  14. def extend(self, iterable): # real signature unknown; restored from __doc__
  15. """ L.extend(iterable) -- extend list by appending elements from the iterable """
  16. pass
  17.  
  18. def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
  19. """
  20. L.index(value, [start, [stop]]) -> integer -- return first index of value.
  21. Raises ValueError if the value is not present.
  22. """
  23. return 0
  24.  
  25. def insert(self, index, p_object): # real signature unknown; restored from __doc__
  26. """ L.insert(index, object) -- insert object before index """
  27. pass
  28.  
  29. def pop(self, index=None): # real signature unknown; restored from __doc__
  30. """
  31. L.pop([index]) -> item -- remove and return item at index (default last).
  32. Raises IndexError if list is empty or index is out of range.
  33. """
  34. pass
  35.  
  36. def remove(self, value): # real signature unknown; restored from __doc__
  37. """
  38. L.remove(value) -- remove first occurrence of value.
  39. Raises ValueError if the value is not present.
  40. """
  41. pass
  42.  
  43. def reverse(self): # real signature unknown; restored from __doc__
  44. """ L.reverse() -- reverse *IN PLACE* """
  45. pass
  46.  
  47. def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
  48. """
  49. L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
  50. cmp(x, y) -> -1, 0, 1
  51. """
  52. pass
  53.  
  54. def __add__(self, y): # real signature unknown; restored from __doc__
  55. """ x.__add__(y) <==> x+y """
  56. pass
  57.  
  58. def __contains__(self, y): # real signature unknown; restored from __doc__
  59. """ x.__contains__(y) <==> y in x """
  60. pass
  61.  
  62. def __delitem__(self, y): # real signature unknown; restored from __doc__
  63. """ x.__delitem__(y) <==> del x[y] """
  64. pass
  65.  
  66. def __delslice__(self, i, j): # real signature unknown; restored from __doc__
  67. """
  68. x.__delslice__(i, j) <==> del x[i:j]
  69.  
  70. Use of negative indices is not supported.
  71. """
  72. pass
  73.  
  74. def __eq__(self, y): # real signature unknown; restored from __doc__
  75. """ x.__eq__(y) <==> x==y """
  76. pass
  77.  
  78. def __getattribute__(self, name): # real signature unknown; restored from __doc__
  79. """ x.__getattribute__('name') <==> x.name """
  80. pass
  81.  
  82. def __getitem__(self, y): # real signature unknown; restored from __doc__
  83. """ x.__getitem__(y) <==> x[y] """
  84. pass
  85.  
  86. def __getslice__(self, i, j): # real signature unknown; restored from __doc__
  87. """
  88. x.__getslice__(i, j) <==> x[i:j]
  89.  
  90. Use of negative indices is not supported.
  91. """
  92. pass
  93.  
  94. def __ge__(self, y): # real signature unknown; restored from __doc__
  95. """ x.__ge__(y) <==> x>=y """
  96. pass
  97.  
  98. def __gt__(self, y): # real signature unknown; restored from __doc__
  99. """ x.__gt__(y) <==> x>y """
  100. pass
  101.  
  102. def __iadd__(self, y): # real signature unknown; restored from __doc__
  103. """ x.__iadd__(y) <==> x+=y """
  104. pass
  105.  
  106. def __imul__(self, y): # real signature unknown; restored from __doc__
  107. """ x.__imul__(y) <==> x*=y """
  108. pass
  109.  
  110. def __init__(self, seq=()): # known special case of list.__init__
  111. """
  112. list() -> new empty list
  113. list(iterable) -> new list initialized from iterable's items
  114. # (copied from class doc)
  115. """
  116. pass
  117.  
  118. def __iter__(self): # real signature unknown; restored from __doc__
  119. """ x.__iter__() <==> iter(x) """
  120. pass
  121.  
  122. def __len__(self): # real signature unknown; restored from __doc__
  123. """ x.__len__() <==> len(x) """
  124. pass
  125.  
  126. def __le__(self, y): # real signature unknown; restored from __doc__
  127. """ x.__le__(y) <==> x<=y """
  128. pass
  129.  
  130. def __lt__(self, y): # real signature unknown; restored from __doc__
  131. """ x.__lt__(y) <==> x<y """
  132. pass
  133.  
  134. def __mul__(self, n): # real signature unknown; restored from __doc__
  135. """ x.__mul__(n) <==> x*n """
  136. pass
  137.  
  138. @staticmethod # known case of __new__
  139. def __new__(S, *more): # real signature unknown; restored from __doc__
  140. """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
  141. pass
  142.  
  143. def __ne__(self, y): # real signature unknown; restored from __doc__
  144. """ x.__ne__(y) <==> x!=y """
  145. pass
  146.  
  147. def __repr__(self): # real signature unknown; restored from __doc__
  148. """ x.__repr__() <==> repr(x) """
  149. pass
  150.  
  151. def __reversed__(self): # real signature unknown; restored from __doc__
  152. """ L.__reversed__() -- return a reverse iterator over the list """
  153. pass
  154.  
  155. def __rmul__(self, n): # real signature unknown; restored from __doc__
  156. """ x.__rmul__(n) <==> n*x """
  157. pass
  158.  
  159. def __setitem__(self, i, y): # real signature unknown; restored from __doc__
  160. """ x.__setitem__(i, y) <==> x[i]=y """
  161. pass
  162.  
  163. def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
  164. """
  165. x.__setslice__(i, j, y) <==> x[i:j]=y
  166.  
  167. Use of negative indices is not supported.
  168. """
  169. pass
  170.  
  171. def __sizeof__(self): # real signature unknown; restored from __doc__
  172. """ L.__sizeof__() -- size of L in memory, in bytes """
  173. pass
  174.  
  175. __hash__ = None
  176.  
  177. list

列表类

5.元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表

创建元组

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

  2. ages = tuple((11, 22, 33, 44, 55))
基本操作:
  • 索引
  • 切片
    1. lass tuple(object):
    2. """
    3. tuple() -> empty tuple
    4. tuple(iterable) -> tuple initialized from iterable's items
    5.  
    6. If the argument is a tuple, the return value is the same object.
    7. """
    8. def count(self, value): # real signature unknown; restored from __doc__
    9. """ T.count(value) -> integer -- return number of occurrences of value """
    10. return 0
    11.  
    12. def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
    13. """
    14. T.index(value, [start, [stop]]) -> integer -- return first index of value.
    15. Raises ValueError if the value is not present.
    16. """
    17. return 0
    18.  
    19. def __add__(self, y): # real signature unknown; restored from __doc__
    20. """ x.__add__(y) <==> x+y """
    21. pass
    22.  
    23. def __contains__(self, y): # real signature unknown; restored from __doc__
    24. """ x.__contains__(y) <==> y in x """
    25. pass
    26.  
    27. def __eq__(self, y): # real signature unknown; restored from __doc__
    28. """ x.__eq__(y) <==> x==y """
    29. pass
    30.  
    31. def __getattribute__(self, name): # real signature unknown; restored from __doc__
    32. """ x.__getattribute__('name') <==> x.name """
    33. pass
    34.  
    35. def __getitem__(self, y): # real signature unknown; restored from __doc__
    36. """ x.__getitem__(y) <==> x[y] """
    37. pass
    38.  
    39. def __getnewargs__(self, *args, **kwargs): # real signature unknown
    40. pass
    41.  
    42. def __getslice__(self, i, j): # real signature unknown; restored from __doc__
    43. """
    44. x.__getslice__(i, j) <==> x[i:j]
    45.  
    46. Use of negative indices is not supported.
    47. """
    48. pass
    49.  
    50. def __ge__(self, y): # real signature unknown; restored from __doc__
    51. """ x.__ge__(y) <==> x>=y """
    52. pass
    53.  
    54. def __gt__(self, y): # real signature unknown; restored from __doc__
    55. """ x.__gt__(y) <==> x>y """
    56. pass
    57.  
    58. def __hash__(self): # real signature unknown; restored from __doc__
    59. """ x.__hash__() <==> hash(x) """
    60. pass
    61.  
    62. def __init__(self, seq=()): # known special case of tuple.__init__
    63. """
    64. tuple() -> empty tuple
    65. tuple(iterable) -> tuple initialized from iterable's items
    66.  
    67. If the argument is a tuple, the return value is the same object.
    68. # (copied from class doc)
    69. """
    70. pass
    71.  
    72. def __iter__(self): # real signature unknown; restored from __doc__
    73. """ x.__iter__() <==> iter(x) """
    74. pass
    75.  
    76. def __len__(self): # real signature unknown; restored from __doc__
    77. """ x.__len__() <==> len(x) """
    78. pass
    79.  
    80. def __le__(self, y): # real signature unknown; restored from __doc__
    81. """ x.__le__(y) <==> x<=y """
    82. pass
    83.  
    84. def __lt__(self, y): # real signature unknown; restored from __doc__
    85. """ x.__lt__(y) <==> x<y """
    86. pass
    87.  
    88. def __mul__(self, n): # real signature unknown; restored from __doc__
    89. """ x.__mul__(n) <==> x*n """
    90. pass
    91.  
    92. @staticmethod # known case of __new__
    93. def __new__(S, *more): # real signature unknown; restored from __doc__
    94. """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
    95. pass
    96.  
    97. def __ne__(self, y): # real signature unknown; restored from __doc__
    98. """ x.__ne__(y) <==> x!=y """
    99. pass
    100.  
    101. def __repr__(self): # real signature unknown; restored from __doc__
    102. """ x.__repr__() <==> repr(x) """
    103. pass
    104.  
    105. def __rmul__(self, n): # real signature unknown; restored from __doc__
    106. """ x.__rmul__(n) <==> n*x """
    107. pass
    108.  
    109. def __sizeof__(self): # real signature unknown; restored from __doc__
    110. """ T.__sizeof__() -- size of T in memory, in bytes """
    111. pass
    112.  
    113. tuple

    元组类

6.字典(无序)

字典是一种Key-value数据类型,无序但key必须是唯一值

创建字典

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

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

常用操作:

  1. >>> info["stu1104"] = "苍井空"
  2. >>> info
  3. {'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

增加

  1. >>> info['stu1101'] = "武藤兰"
  2. >>> info
  3. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}

修改

  1. >>> info
  2. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
  3. >>> info.pop("stu1101") #标准删除姿势
  4. '武藤兰'
  5. >>> info
  6. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  7. >>> del info['stu1103'] #换个姿势删除
  8. >>> info
  9. {'stu1102': 'LongZe Luola'}
  10. >>>
  11. >>>
  12. >>>
  13. >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  14. >>> info
  15. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
  16. >>> info.popitem()
  17. ('stu1102', 'LongZe Luola')
  18. >>> info
  19. {'stu1103': 'XiaoZe Maliya'}

删除

  1. >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  2. >>>
  3. >>> "stu1102" in info #标准用法
  4. True
  5. >>> info.get("stu1102") #获取
  6. 'LongZe Luola'
  7. >>> info["stu1102"] #同上,但是看下面
  8. 'LongZe Luola'
  9. >>> info["stu1105"] #如果一个key不存在,就报错,get不会,不存在只返回None
  10. Traceback (most recent call last):
  11. File "<stdin>", line 1, in <module>
  12. KeyError: 'stu1105'

查找

  1. av_catalog = {
  2. "欧美":{
  3. "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
  4. "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
  5. "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
  6. "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
  7. },
  8. "日韩":{
  9. "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
  10. },
  11. "大陆":{
  12. "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
  13. }
  14. }
  15.  
  16. av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
  17. print(av_catalog["大陆"][""])
  18. #ouput
  19. ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

字典嵌套

  1. #values
  2. >>> info.values()
  3. dict_values(['LongZe Luola', 'XiaoZe Maliya'])
  4.  
  5. #keys
  6. >>> info.keys()
  7. dict_keys(['stu1102', 'stu1103'])
  8.  
  9. #setdefault
  10. >>> info.setdefault("stu1106","Alex")
  11. 'Alex'
  12. >>> info
  13. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  14. >>> info.setdefault("stu1102","龙泽萝拉")
  15. 'LongZe Luola'
  16. >>> info
  17. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  18.  
  19. #update
  20. >>> info
  21. {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  22. >>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
  23. >>> info.update(b)
  24. >>> info
  25. {'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  26.  
  27. #items
  28. info.items()
  29. dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
  30.  
  31. #通过一个列表生成默认dict,有个没办法解释的坑,少用吧这个
  32. >>> dict.fromkeys([1,2,3],'testd')
  33. {1: 'testd', 2: 'testd', 3: 'testd'}

key-value

  1. #方法1
  2. for key in info:
  3. print(key,info[key])
  4.  
  5. #方法2
  6. for k,v in info.items(): #会先把dict转成list,数据里大时莫用
  7. print(k,v)

循环

    1. class dict(object):
    2. """
    3. dict() -> new empty dictionary
    4. dict(mapping) -> new dictionary initialized from a mapping object's
    5. (key, value) pairs
    6. dict(iterable) -> new dictionary initialized as if via:
    7. d = {}
    8. for k, v in iterable:
    9. d[k] = v
    10. dict(**kwargs) -> new dictionary initialized with the name=value pairs
    11. in the keyword argument list. For example: dict(one=1, two=2)
    12. """
    13.  
    14. def clear(self): # real signature unknown; restored from __doc__
    15. """ 清除内容 """
    16. """ D.clear() -> None. Remove all items from D. """
    17. pass
    18.  
    19. def copy(self): # real signature unknown; restored from __doc__
    20. """ 浅拷贝 """
    21. """ D.copy() -> a shallow copy of D """
    22. pass
    23.  
    24. @staticmethod # known case
    25. def fromkeys(S, v=None): # real signature unknown; restored from __doc__
    26. """
    27. dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
    28. v defaults to None.
    29. """
    30. pass
    31.  
    32. def get(self, k, d=None): # real signature unknown; restored from __doc__
    33. """ 根据key获取值,d是默认值 """
    34. """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
    35. pass
    36.  
    37. def has_key(self, k): # real signature unknown; restored from __doc__
    38. """ 是否有key """
    39. """ D.has_key(k) -> True if D has a key k, else False """
    40. return False
    41.  
    42. def items(self): # real signature unknown; restored from __doc__
    43. """ 所有项的列表形式 """
    44. """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
    45. return []
    46.  
    47. def iteritems(self): # real signature unknown; restored from __doc__
    48. """ 项可迭代 """
    49. """ D.iteritems() -> an iterator over the (key, value) items of D """
    50. pass
    51.  
    52. def iterkeys(self): # real signature unknown; restored from __doc__
    53. """ key可迭代 """
    54. """ D.iterkeys() -> an iterator over the keys of D """
    55. pass
    56.  
    57. def itervalues(self): # real signature unknown; restored from __doc__
    58. """ value可迭代 """
    59. """ D.itervalues() -> an iterator over the values of D """
    60. pass
    61.  
    62. def keys(self): # real signature unknown; restored from __doc__
    63. """ 所有的key列表 """
    64. """ D.keys() -> list of D's keys """
    65. return []
    66.  
    67. def pop(self, k, d=None): # real signature unknown; restored from __doc__
    68. """ 获取并在字典中移除 """
    69. """
    70. D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
    71. If key is not found, d is returned if given, otherwise KeyError is raised
    72. """
    73. pass
    74.  
    75. def popitem(self): # real signature unknown; restored from __doc__
    76. """ 获取并在字典中移除 """
    77. """
    78. D.popitem() -> (k, v), remove and return some (key, value) pair as a
    79. 2-tuple; but raise KeyError if D is empty.
    80. """
    81. pass
    82.  
    83. def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
    84. """ 如果key不存在,则创建,如果存在,则返回已存在的值且不修改 """
    85. """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
    86. pass
    87.  
    88. def update(self, E=None, **F): # known special case of dict.update
    89. """ 更新
    90. {'name':'alex', 'age': 18000}
    91. [('name','sbsbsb'),]
    92. """
    93. """
    94. D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
    95. If E present and has a .keys() method, does: for k in E: D[k] = E[k]
    96. If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
    97. In either case, this is followed by: for k in F: D[k] = F[k]
    98. """
    99. pass
    100.  
    101. def values(self): # real signature unknown; restored from __doc__
    102. """ 所有的值 """
    103. """ D.values() -> list of D's values """
    104. return []
    105.  
    106. def viewitems(self): # real signature unknown; restored from __doc__
    107. """ 所有项,只是将内容保存至view对象中 """
    108. """ D.viewitems() -> a set-like object providing a view on D's items """
    109. pass
    110.  
    111. def viewkeys(self): # real signature unknown; restored from __doc__
    112. """ D.viewkeys() -> a set-like object providing a view on D's keys """
    113. pass
    114.  
    115. def viewvalues(self): # real signature unknown; restored from __doc__
    116. """ D.viewvalues() -> an object providing a view on D's values """
    117. pass
    118.  
    119. def __cmp__(self, y): # real signature unknown; restored from __doc__
    120. """ x.__cmp__(y) <==> cmp(x,y) """
    121. pass
    122.  
    123. def __contains__(self, k): # real signature unknown; restored from __doc__
    124. """ D.__contains__(k) -> True if D has a key k, else False """
    125. return False
    126.  
    127. def __delitem__(self, y): # real signature unknown; restored from __doc__
    128. """ x.__delitem__(y) <==> del x[y] """
    129. pass
    130.  
    131. def __eq__(self, y): # real signature unknown; restored from __doc__
    132. """ x.__eq__(y) <==> x==y """
    133. pass
    134.  
    135. def __getattribute__(self, name): # real signature unknown; restored from __doc__
    136. """ x.__getattribute__('name') <==> x.name """
    137. pass
    138.  
    139. def __getitem__(self, y): # real signature unknown; restored from __doc__
    140. """ x.__getitem__(y) <==> x[y] """
    141. pass
    142.  
    143. def __ge__(self, y): # real signature unknown; restored from __doc__
    144. """ x.__ge__(y) <==> x>=y """
    145. pass
    146.  
    147. def __gt__(self, y): # real signature unknown; restored from __doc__
    148. """ x.__gt__(y) <==> x>y """
    149. pass
    150.  
    151. def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
    152. """
    153. dict() -> new empty dictionary
    154. dict(mapping) -> new dictionary initialized from a mapping object's
    155. (key, value) pairs
    156. dict(iterable) -> new dictionary initialized as if via:
    157. d = {}
    158. for k, v in iterable:
    159. d[k] = v
    160. dict(**kwargs) -> new dictionary initialized with the name=value pairs
    161. in the keyword argument list. For example: dict(one=1, two=2)
    162. # (copied from class doc)
    163. """
    164. pass
    165.  
    166. def __iter__(self): # real signature unknown; restored from __doc__
    167. """ x.__iter__() <==> iter(x) """
    168. pass
    169.  
    170. def __len__(self): # real signature unknown; restored from __doc__
    171. """ x.__len__() <==> len(x) """
    172. pass
    173.  
    174. def __le__(self, y): # real signature unknown; restored from __doc__
    175. """ x.__le__(y) <==> x<=y """
    176. pass
    177.  
    178. def __lt__(self, y): # real signature unknown; restored from __doc__
    179. """ x.__lt__(y) <==> x<y """
    180. pass
    181.  
    182. @staticmethod # known case of __new__
    183. def __new__(S, *more): # real signature unknown; restored from __doc__
    184. """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
    185. pass
    186.  
    187. def __ne__(self, y): # real signature unknown; restored from __doc__
    188. """ x.__ne__(y) <==> x!=y """
    189. pass
    190.  
    191. def __repr__(self): # real signature unknown; restored from __doc__
    192. """ x.__repr__() <==> repr(x) """
    193. pass
    194.  
    195. def __setitem__(self, i, y): # real signature unknown; restored from __doc__
    196. """ x.__setitem__(i, y) <==> x[i]=y """
    197. pass
    198.  
    199. def __sizeof__(self): # real signature unknown; restored from __doc__
    200. """ D.__sizeof__() -> size of D in memory, in bytes """
    201. pass
    202.  
    203. __hash__ = None
    204.  
    205. dict

    字典类

7.其他

  1. for循环(支持break ,continue
  2. li = [11,22,33,44]
  3. for item in li:
  4. print item
  5.  
  6. enumrate(为可迭代对象添加序号)
  7. li = [11,22,33]
  8. for k,v in enumerate(li, 1):
  9. print(k,v)
  10.  
  11. rangexrange(指定范围,生成随机数)
  12. print range(1, 10)
  13. # 结果:[1, 2, 3, 4, 5, 6, 7, 8, 9]
  14.  
  15. print range(1, 10, 2)
  16. # 结果:[1, 3, 5, 7, 9]
  17.  
  18. print range(30, 0, -2)
  19. # 结果:[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2] 

三、练习题

1、元素分类

有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。
即: {'k1': 大于66的所有值, 'k2': 小于66的所有值}
2、查找
查找列表中元素,移除每个元素的空格,并查找以 a或A开头 并且以 c 结尾的所有元素。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}

3、输出商品列表,用户输入序号,显示用户选中的商品
商品 li = ["手机", "电脑", '鼠标垫', '游艇']

4、购物车

功能要求:

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

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

5、用户交互,显示省市县三级联动的选择

dic = {
"河北": {
"石家庄": ["鹿泉", "藁城", "元氏"],
"邯郸": ["永年", "涉县", "磁县"],
}
"河南": {
...
}
"山西": {
...
}
}

Day02——Python基本数据类型的更多相关文章

  1. Day02 - Python 基本数据类型

    1 基本数据类型 Python有五个标准的数据类型: Numbers(数字) String(字符串) List(列表) Tuple(元组) Dictionary(字典) 1.1 数字 数字数据类型用于 ...

  2. day02 Python 的模块,运算,数据类型以及方法

    初识pyhton的模块: 什么是模块: 我的理解就是实现一个功能的函数,把它封装起来,在你需要使用的时候直接调用即可,我的印象里类似于shell 的单独函数脚本. python 的模块分为标准的和第三 ...

  3. python 基本数据类型分析

    在python中,一切都是对象!对象由类创建而来,对象所拥有的功能都来自于类.在本节中,我们了解一下python基本数据类型对象具有哪些功能,我们平常是怎么使用的. 对于python,一切事物都是对象 ...

  4. python常用数据类型内置方法介绍

    熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 下面介绍了python常用的集中数据类型及其方法,点开源代码,其中对主要方法都进行了中文注释. 一.整型 a = 100 a.xx ...

  5. 闲聊之Python的数据类型 - 零基础入门学习Python005

    闲聊之Python的数据类型 让编程改变世界 Change the world by program Python的数据类型 闲聊之Python的数据类型所谓闲聊,goosip,就是屁大点事可以咱聊上 ...

  6. python自学笔记(二)python基本数据类型之字符串处理

    一.数据类型的组成分3部分:身份.类型.值 身份:id方法来看它的唯一标识符,内存地址靠这个查看 类型:type方法查看 值:数据项 二.常用基本数据类型 int 整型 boolean 布尔型 str ...

  7. Python入门-数据类型

    一.变量 1)变量定义 name = 100(name是变量名 = 号是赋值号100是变量的值) 2)变量赋值 直接赋值 a=1 链式赋值  a=b=c=1 序列解包赋值  a,b,c = 1,2,3 ...

  8. Python基础:八、python基本数据类型

    一.什么是数据类型? 我们人类可以很容易的分清数字与字符的区别,但是计算机并不能,计算机虽然很强大,但从某种角度上来看又很傻,除非你明确告诉它,"1"是数字,"壹&quo ...

  9. python之数据类型详解

    python之数据类型详解 二.列表list  (可以存储多个值)(列表内数字不需要加引号) sort s1=[','!'] # s1.sort() # print(s1) -->['!', ' ...

随机推荐

  1. GCC 7.3.0版本编译http-parser-2.1问题

    http-paser是一个用c编写的http消息解析器,地址:https://github.com/nodejs/http-parser,目前版本2.9 今天用gcc 7.3.0编译其2.1版本时,编 ...

  2. Java - 冒泡排序的优化算法(尚学堂第七章数组)

    import java.util.Arrays; public class TestBubbleSort2 { public static void main(String[] args) { int ...

  3. (转)MySQL- 5.7 sys schema笔记,mysql-schema

    原文:http://www.bkjia.com/Mysql/1222405.html http://www.ywnds.com/?p=5045 performance_schema提供监控策略及大量监 ...

  4. JS框架设计之模块加载系统

    任何语言一到大规模应用阶段,必然要拆封模块,有利于维护和团队协作,与Java走得最近的dojo率先引进了加载器,使用document.write与同步Ajax请求实现,后台dojo以JSONP的方法来 ...

  5. execution(* *..BookManager.save(..))的解读

    execution(* *..BookManager.save(..))的解读: 第一颗* 代表ret-type-pattern 返回值可任意, *..BookManager 代表任意Pacakge里 ...

  6. 《图解http协议》之HTTPs学习笔记

    对于IP协议,并不陌生.TP协议是TCP/IP协议簇中的核心协议,也是TCP/IP的载体.所有的TCP,UDP,ICMP及IGMP数据都以IP数据报格式传输.IP提供不可靠的,无连接的数据传送服务.I ...

  7. 修改MyEclipse8.5的workspaces

    到MyEclipse8.5的安装目录下 我安装在D盘,路径为:D:\Genuitec\MyEclipse 8.5\configuration\config.ini   打开config.ini文件: ...

  8. 如何限制html标签input的长度

    如何限制html标签input的长度 示例: <form action="/example/html/form_action.asp" method="get&qu ...

  9. 有意思的MySQL之最

    写在前面 在平时工作中特别是架构设计阶段,咨询量最多的也就是MySQL之最了,在不经意间发现原来MySQL手册里面已经列举了,顺手拿来翻译下,如果有翻译错误或者不当的地方,欢迎批评指正. 最大和最小 ...

  10. input textbox tag

    aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAb8AAAB0CAIAAACaKavmAAAJ0klEQVR4nO3dO2wb5wHA8YOHIkOLrk