• Number：数字
    • int：有符号整型
      • long：长整型，3.x版本由int代替。l、L字符结尾
    • float：浮点型
    • complex：复数
  • String（字符串）
    • 正负值索引，0第一个，-1倒数第一个。
    • 支持[beg : end]截取字符串。
  • List（列表）
    • lua 数组形式的table
  • Tuple（元组）
    • 只读列表
  • Dictionary（字典）
    • 键值对

  • Set（集合）

    • 元素不重复，内部会自动过滤

  • 不可更改对象（immutable）

    • 内部元素值不可改变
    • String
    • Number
    • tuple
      • 元素内部是否可以改变，不做要求，比如元素是列表。
  • • 可更改对象（mutable）
    • 内部元素值可改变
    • List
    • Dict

      一、Number（数字）

      存储数值。
      Number类型是不允许改变的，这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
int long float complex
10 51924361L 15.20 3.14j
-786 -0x19323L -21.9 45.j
080 0122L 32.3e+18，科学计数法 9.322e-36j
-0490，八进制 0xABCDEFl -90. .876j
-0x260，16进制 -052335L -32.54e100 -.6545+0J
0x69 -472129L 70.2E-12 3e+26J
4.53e-7j

二、string（字符串）

只要字符串，没有字符的概念。

  1. string = 'word'                     #单引号，不可以换行
  2. string = "this is fucker."            #双引号
  4. #三引号，可以换行，
  5. string = '''
  6. <HTML><HEAD><TITLE>        '""'"可以有双引号、单引号
  7. Friends CGI Demo</TITLE></HEAD>        \r\n\t\v可以有转义字符
  8. <BODY><H3>ERROR</H3>
  9. <B>%s</B><P>
  10. <FORM><INPUT TYPE=button VALUE=Back
  11. ONCLICK="window.history.back()"></FORM>
  12. </BODY></HTML>
  13. '''
  15. #同上，三引号，可以换行
  16. string = """
  17. CREATE TABLE users (  
  18. login VARCHAR(8), 
  19. uid INTEGER,
  20. prid INTEGER)
  21. """
  23. string = u'Hello World !'        # Unicode 字符串
  25. string[1]            #1
  26. string[-1]            #6
  27. string[1:5]        #'1234'，左闭右开区间，和C++一样。返回的是新的串，并不会截断str本身。
  28. string[1:]            #123456
  29. string[:3]            #012
  30. string[:]            #返回一个string的拷贝。
  31. string * 2            #'01234560123456'
  32. print string + "TEST"  # '0123456TEST'，字符串连接

转义字符

  1. \        #在行尾时，续行符
  2. \\        #反斜杠符号
  3. \'        #单引号
  4. \"        #双引号
  5. \a        #响铃
  6. \b        #退格(Backspace)
  7. \e        #转义
  8. \000    #空
  9. \n        #换行
  10. \v        #纵向制表符
  11. \t        #横向制表符
  12. \r        #回车
  13. \f        #换页
  14. \oyy    #八进制数，yy代表的字符，例如：\o12代表换行
  15. \xyy    #十六进制数，yy代表的字符，例如：\x0a代表换行
  16. \other    #其它的字符以普通格式输出

字符串运算符

  1. stra, strb = "stra", "strb"
  2. stra + strb                #strastrb
  3. stra * 2                #strastra
  4. stra[1]                    #t
  5. stra[1:2]                #t
  6. "a" in stra                #True
  7. "a" not in stra            #False
  9. #不转义字符串中的转义字符，原模原样的输出。
  10. r"\v\r\n\t\000"            #"\\v\\r\\n\\t\\000"
  11. R"\v\r\n\t\000"            #"\\v\\r\\n\\t\\000"
  13. format % str1, ...        #格式化字符
  15. #与C 中 sprintf 函数一样的语法
  16. "my name is %s, im %d years old" % ("bitch", 100)    #这是使老版的格式化方法，已经有str.format优化
  17. #my name is bitch, im 100 years old

格式说明符

  1. #######################字符串格式说明符#######################
  2. %c         #格式化字符及其ASCII码
  3. %s         #格式化字符串
  4. %d         #格式化整数
  5. %u         #格式化无符号整型
  6. %o         #格式化无符号八进制数
  7. %x         #格式化无符号十六进制数
  8. %X         #格式化无符号十六进制数（大写）
  9. %f         #格式化浮点数字，可指定小数点后的精度
  10. %e, %E    #用科学计数法格式化浮点数
  11. %E         #作用同%e，用科学计数法格式化浮点数
  12. %g         #%f和%e的简写
  13. %G         #%F 和 %E 的简写
  14. %p         #用十六进制数格式化变量的地址
  16. #######################格式说明符辅助指令#######################
  17. *        #定义宽度或者小数点精度
  18. -        #用做左对齐
  19. +        #在正数前面显示加号( + )
  20. <sp>    #在正数前面显示空格
  21. #        #在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
  22. 0        #显示的数字前面填充'0'而不是默认的空格
  23. %        #'%%'输出一个单一的'%'
  24. (var)    #映射变量(字典参数)
  25. m.n.    #m是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

格式化函数format

  1. str.format()    #{} 和 : 来代替以前的 %
  3. "{} {}".format("hello", "world")               # 位置参数，按默认顺序
  4. "{0} {1}".format("hello", "world")          # 位置参数
  5. "{1} {0} {1}".format("hello", "world")         # 位置参数，'world hello world'
  6. "a:{f1}, b:{f2}".format(f1="f", f2="f")        # 关键字参数，"a:f, b:f"
  7. "a:{0}, b:{f2}".format("f", f2="f")            # 位置参数好关键字参数可以组合
  9. args = {"f1": "f", "f2": "f"}    
  10. print("a:{f1}, b:{f2}".format(**args))        # 字典参数，"a:f, b:f"
  11. print("a:{0[f1]}, b:{0[f2]}".format(args))    # 同上
  13. mlist = ['f1', 'f2']
  14. print("a:{0[0]}, b:{0[1]}".format(mlist))      # 列表参数，"0" 是必须的
  16. class Obj(object):
  17.     def __init__(self, value):
  18.         self.value = value
  19. obj = Obj(6)
  20. print('value = {0.value}'.format(obj))      # 对象参数，"0" 是可选的

format的格式化符号

  1. {:b}     11     1011    
  2. {:d}     11     11
  3. {:o}     11     13
  4. {:x}     11     b
  5. {:#x}     11        0xb
  6. {:#X}     11     0XB
  8. {:.2f}     3.141     3.14        保留小数点后两位
  9. {:+.2f}     3.141     +3.14        带符号保留小数点后两位
  10. {:+.2f}  -1     -1.00        带符号保留小数点后两位
  11. {:.0f}     2.71        3        不带小数
  13. {:0>2d}  5        05            数字补零(填充左边, 宽度为2)
  14. {:x<4d}     5        5xxx        数字补x(填充右边, 宽度为4)
  15. {:x<4d}     10        10xx        数字补x(填充右边, 宽度为4)
  16. {:,}     1000   1,000        以逗号分隔的数字格式
  17. {:.2%}     0.25   25.00%        百分比格式
  18. {:.2e}     100    1.00e+02    指数记法
  19. {:>10d}     13        ________13    右对齐(默认, 宽度为10)
  20. {:<10d}     13        13________    左对齐(宽度为10)
  21. {:^10d}     13        ____13____    中间对齐(宽度为10)

格式化字符串

f-字符串，在字符串前加f/F，在字符串中通过{expression}来包含表达式的值。

  1. import math
  2. print(f'pi =  {math.pi:.3f}.')    #:冒号后面可以接格式说明符
  5. table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
  6. for name, phone in table.items():
  7.     print(f'{name:10} ==> {phone:10d}')
  8. #Sjoerd     ==>       4127
  9. #Jack       ==>       4098
  10. #Dcab       ==>       7678
  12. #'!a'调用ascii()
  13. #'!s'调用str()
  14. #'!r'调用repr():
  15. string = 'fucker'
  16. print(f'{string}.')        #fucker
  17. print(f'{string!r}')    #'fucker'

三、list（列表）

最基本，最常用数据类型。
元素可以是字符，数字，字符串、列表，类型可缓和。
支持[beg : end]截取（注意返回的是副本），支持正负值索引，都和string一样。
“隐式索引的“lua table”。

  1. #列表
  2. lst = [ '0', '1', '2', '3', '4', '5', '6' ]
  4. #[beg : end]和string一样。
  5. lst[1:4:2]        #for循环三参数for(i=1;i<4;i+=2)
  7. lst = [ '0', 1 , 2.0, '3', 4.0 ]
  8. f1, f2, f3, f4, f5 = tupl1            # 序列解包：左侧数量=tupl1的元素数量，同样适用于元组。
  9. tinylist = [5, '6']
  11. print(tinylist * 2)        #输出列表两次     
  12.                         #[1, '2', 1, '2']
  14. print(lst + tinylist)   #打印组合的列表
  15.                         #['0', 1 , 2.0, '3', 4.0, 5, '6']
  17. len(lst)                #列表长度
  19. lst.append('Runoob')
  21. del lst[2]                #删除元素

常用函数和方法

  1. ##################函数##################
  2. cmp(list1, list2)    #比较两个列表的元素
  3. len(list)            #列表元素个数
  4. max(list)            #返回列表元素最大值
  5. min(list)            #返回列表元素最小值
  6. list(iterable)        #通过迭代器构建列表
  8. ##################成员方法##################
  9. #诸如insert、remove、sort方法，只修改列表，没有返回值，这是Python中所有可变数据结构的设计原则。
  11. list.append(x)            #在列表的末尾添加一个元素。相当于 a[len(a):] = [x] 。
  12. list.count(obj)            #统计某个元素在列表中出现的次数
  13. list.extend(iterable)    #使用可迭代对象中的所有元素来扩展列表。相当于 a[len(a):] = iterable 。
  14. list.index(obj)            #从列表中找出某个值第一个匹配项的索引位置
  16. list.index(x[, start[, end]])    
  17. #返回第一个值为x的索引，start、end可选，限制搜索范围，没找到将会抛出 ValueError 异常
  19. list.insert(index, obj)    #将对象插入列表
  20.                         #a.insert(0, x)插入列表头部
  21.                         #a.insert(len(a), x)等同于a.append(x)
  22. list.pop(index=-1)        #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
  23. list.remove(obj)        #移除列表中第一个值为 obj 的元素，如果没有这样的元素，则抛出 ValueError 异常。
  24. list.reverse()            #翻转列表中的元素。
  25. list.clear()            #移除列表中的所有元素。等价于 del a[:]
  26. list.copy()                #返回列表的一个浅拷贝，等价于 a[:]。
  27. list.sort(key=None, reverse=False)                #排序，使用内置函数sorted排序
  28. list.sort(cmp=None, key=None, reverse=False)    #对原列表进行排序

创建列表常用技巧

  1. lst = []
  2. for i in range(10):
  3.     lst.append(i)
  5. squares = list(map(lambda x: x**2, range(10)))    #map见内置函数说明，返回一个迭代器
  6. squares = [x**2 for x in range(10)]                #列表推导式

列表推导式

  1. #expression for... for... if...
  2. #    推导式的结构。
  3. #        expression可以是任何表达式，比如是另一个推导式（嵌套）
  4. #        后面接1个或多个for、if语句。
  5. #    效果：
  6. #        for ...
  7. #            for ...
  8. #                if ...
  9. #                    expression()
  11. #列表的推导式：[expression for... for... if...]，返回一个列表
  12. #集合的推导式：{expression for... for... if...}，返回一个集合
  14. [x for x in range(10)]
  15. ################等价于
  16. lst = []
  17. for x in range(10)
  18.     lst.append(x)    #最后的效果就是lst.append(expression)
  22. [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
  23. ################等价于
  24. lst = []
  25. for x in [1,2,3]:
  26.     for y in [3,1,4]:
  27.         if x != y:
  28.             lst.append((x, y))
  31. from math import pi
  32. print([str(round(pi, i)) for i in range(1, 6)])        #复杂的表达式
  33. #['3.1', '3.14', '3.142', '3.1416', '3.14159']
  36. matrix = [
  37.     [1, 2, 3, 4, 5],
  38.     [1, 2, 3, 4, 5],
  39.     [1, 2, 3, 4, 5],
  40. ]
  41. [[row[i] for row in matrix] for i in range(4)]        #嵌套的推导式
  42. ################等价于                                  #记住一对[]堆成一个list列表
  43. lst = []
  44. for i in range(4)
  45.     lst.append([row[i] for row in matrix])
  46. ################等价于
  47. lst = []
  48. for i in range(4)        #外层[]，生成lst
  49.     lst_1 = []
  50.     for row in matrix:        #内存[]，生成lst_1
  51.         lst_1.append(row[i])
  52.     lst.append(lst_1)
  54. list(zip(*matrix))    
  55. [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
  56. #zip效果如下；
  57. #(iter_1, iter_2, ..., iter_n) = zip(lst_1, lst_2, ..., lst_n)    lst可以换成所有可迭代对象
  58. #参数是一个序列，序列的每个元素都是一个可迭代对象
  59. #返回一个元组，元素是每个元素的迭代器。

列表作为栈使用

  1. stack = [1, 2, 3, 4]
  2. stack.append(5)
  3. stack.pop()
  4. stack.append(6)
  5. stack.pop()
  6. stack.pop()

四、tuple（元组）

只读List（列表），但元素本身可以是可改变对象。
列表[]方括号，元组()圆括号。
支持上面string、list的操作。

  1. tup1 = ( '1', 2 , 300, '4', 5 )
  2. tup1 = 50 ,            # 同上，等价于tup1 = (50)
  4. tup1 = 1, 2, 3        # 等价于(1, 2, 3, 4)，叫序列打包
  5. x, y, z = tupl1        # 左侧数量=tupl1的元素数量，叫序列解包，同样适用于list
  7. x, y, z = 1, 2, 3    # 多重赋值，本质上就是右侧序列打包成元组，左侧序列解包。
  9. tup1[2] = 1000        # 错误，不可以修改删除元组元素，只能读取。
  10. del tup1[2]            # 错误
  12. tup3 = tup1 + tup2    # 可以元组进行连接组合，不改原元组，生成新元组。
  14. #任意无符号的对象，以逗号隔开，默认为元组，如：
  16. print '1', -2, 3.0, '4'        # 元组
  17. x, y = 1, 2
  18. print "x, y:", x, y            # 元组

常用函数

列表的函数都有，但是成员方法都没有。

  1. cmp(tuple1, tuple2)        #比较两个元组元素。
  2. len(tuple1)                #计算元组元素个数。
  3. max(tuple1)                #返回元组中元素最大值。
  4. min(tuple1)                #返回元组中元素最小值。
  5. tuple(seq)                #将列表转换为元组。

五、Dictionary（字典）

列表是有序对象集合（索引从0开始递增）
字典是无序对象集合，key-value形式。

  • 关键字key
    • 可以重复，但后者覆盖前者。
    • 不可改变，可以是字符串、数字、元组，列表就不行。
    • 如果是元组，则必须只包含字符串、数字或元组，否则不能作为key
    • 访问不存在的key，会KeyError。
  • 元素值value
    • 任意类型
    • 值不唯一

类似lua table。

  1. ##############创建
  2. d = {}    
  3. d = {1:1, '2':2, 3.0:'3.0'}
  4. d = dict(fuck=1, shit=2, bitch=3)            #key是字符串时，最常见用法
  5. d = dict([('1', 1), ('2', 2), ('3', 3)])    #{'1': 1, '2': 2, '3': 3}
  6. #内置函数dict()，更多用法见《Python_内置函数》
  8. #字典推导式创建，推导式介绍见列表，列表、集合、字典都支持推导式。
  9. {x: x**2 for x in (2, 4, 6)}    #{2:4, 4:16, 6:36}
  13. ##############查插删改
  14. d['1'] = "one"            #添加元素
  15. d[ 2 ] = "two"            #添加元素
  16. 'one' in d                #元素是否存在
  17. list(d)                    #返回字典的key的列表，['1', 2]，按插入次序排列，如需其他排列，sorted(d)
  18. del d["2"]                #删除元素
  19. d.clear()                 #清空字典：删除全部元素
  22. print d['one']          # 输出键为'one' 的值
  23. print d[2]              # 输出键为 2 的值
  24. print d[1]               # KeyError，不存在的Key
  25. print d             # 输出完整的字典
  26. print d.keys()      # 输出所有键
  27. print d.values()    # 输出所有值

常用函数和方法

  1. ##################函数##################
  2. cmp(dict1, dict2)    #比较两个字典元素。
  3. len(dict)            #计算字典元素个数，即键的总数。
  4. str(dict)            #输出字典可打印的字符串表示。
  5. type(variable)        #返回输入的变量类型，如果变量是字典就返回字典类型。
  7. ##################成员方法##################
  8. dict.clear()                # 删除字典内所有元素
  9. dict.copy()                    # 返回一个字典的浅复制
  11. dict.fromkeys(seq[, val])    # 创建一个新字典
  12.                             # 以seq元素为key，val为key初始值
  14. dict.has_key(key)            # dict是否有key键。
  15. dict.items()                # 返回列表，元素为(k, v)元组。
  16. dict.keys()                    # 返回key列表。
  17. dict.values()                # 返回value列表
  18. dict.update(dict2)            # 把dict2的kv更新到dict里
  20. dict.get(key, default=None)    # 返回指定键的值，不存在，返回default
  22. dict.setdefault(key, default=None)    #如果key不存在，添加key，value=default
  24. pop(key[,default])            #删除kv，并返回value，不存在返回default
  26. popitem()                    #返回并删除字典中的最后一对键和值。

六、Set（集合）

由不重复元素组成的无序的集，它的基本用法包括成员检测和消除重复元素。集合对象也支持像联合，交集，差集，对称差分等数学运算。

  1. ###########{}括号创建
  2. set1 = {1, 2, 3, 4, 1, 2, 3, 4}        #集合，{1, 2, 3, 4}
  3. set1 = {}                            #这不是集合，是字典。
  4. ###########set()函数创建
  5. set(iterable)                        #参数是一个可迭代对象
  6. set1 = set("abcdabcdabcd")            #set1 = {'a', 'b', 'c', 'd'}
  8. set1 - set2        #差集，在set1，不在set2的元素集合
  9. set1 | set2        #并集，在set1或者set2中的元素集合
  10. set1 & set2        #交集，在set1且在set2的元素集合
  11. set1 ^ set2        #异或，不同时在set1、set2中的元素的集合。
  13. #集合推导式，推导式的介绍，见列表中。
  14. a = {x for x in 'abracadabra' if x not in 'abc'}
  15. a        #{'r', 'd'}

七、操作技巧

相互类型转换

  1. #以数据类型名字作为函数，返回一个新的对象。
  3. int(x [,base])            #将x转换为一个整数
  4. long(x [,base] )        #将x转换为一个长整数
  5. float(x)                #将x转换到一个浮点数
  6. str(x)                    #将对象 x 转换为字符串
  7. repr(x)                    #将对象 x 转换为表达式字符串
  8. complex(real [,imag])    #创建一个复数
  10. eval(str)        #用来计算在字符串中的有效Python表达式,并返回一个对象
  11. tuple(s)        #将序列 s 转换为一个元组
  12. list(s)            #将序列 s 转换为一个列表
  13. set(s)            #转换为可变集合
  14. dict(d)            #创建一个字典。d 必须是一个序列 (key,value)元组。
  15. frozenset(s)    #转换为不可变集合
  17. chr(x)            #将一个整数转换为一个字符
  18. unichr(x)        #将一个整数转换为Unicode字符
  20. ord(x)            #将一个字符转换为它的整数值
  22. hex(x)            #将一个整数转换为一个十六进制字符串
  23. oct(x)            #将一个整数转换为一个八进制字符串

序列循环技巧

序列：字符串、列表、元组、集合和字典

  1. ###################循环字典d.items()
  2. for k, v in d.items():
  3.     print(k, v)
  5. ###################循环非字典序列，enumerate()函数
  6. for i, v in enumerate(['1', '2', '3']):
  7.     print(i, v)
  9. ###################多个序列同时循环
  10. lst1 = ['1', '2', '3']
  11. lst2 = ['4', '5', '6']
  12. for q, a in zip(lst1, lst2):
  13.     print('{0}:{1}'.format(q, a))
  15. ###################逆向循环
  16. for i in reversed(range(1, 10, 2)):
  17.     print(i)
  19. ###################指定顺序循环
  20. lst = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
  21. for f in sorted(set(lst)):
  22.     print(f)
  23. #apple
  24. #banana
  25. #orange
  26. #pear
  28. ###################循环中插删元素，一般创建一个新表才安全。
  29. import math
  30. raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
  31. filtered_data = []
  32. for value in raw_data:
  33.     if not math.isnan(value):
  34.         filtered_data.append(value)
  35. print(filtered_data)
  36. #[56.2, 51.7, 55.3, 52.5, 47.8]