【Python学习】9.切片、迭代、列表生成式、生成器、迭代器与杨辉三角

本节摘要：切片；迭代；列表生成器；生成器 generator；迭代器 iterator

Daily Record：每天一纪念，记录下python的学习历程，入门学习笔记与心得。本学习笔记主要基于廖雪峰大大的Python教程。不积跬步，无以至千里～ .ﾟ(ง •̀_•́)ง

@[toc]

在Python中，代码不是越多越好，而是越少越好。代码不是越复杂越好，而是越简单越好。代码越少，开发效率越高。

高级特性

切片

取一个list或tuple的部分元素，例如：

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
>>> [L[0], L[1], L[2]]             # 取前3个元素
['Michael', 'Sarah', 'Tracy']

取前N个元素，也就是索引为0-(N-1)的元素，可以用循环：

>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(L[i])
... 
>>> r
['Michael', 'Sarah', 'Tracy']

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

slice，即切片的意思。在Python中可以用切片的方式来取一个list、tuple或者是字符串的其中一部分。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：

>>> L[0:3]     # L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
['Michael', 'Sarah', 'Tracy']

如果第一个索引是0，还可以省略：

>>> L[:3]
['Michael', 'Sarah', 'Tracy']

>>> L[1:3]          # 从索引1开始，取出2个元素出来
['Sarah', 'Tracy']

既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片：

>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]          # 倒数第一个元素的索引是-1
['Bob']

例子，创建一个0到100的list：

>>> L = list(range(0,101))                  #创建一个0到100的list
>>> L
[0, 1, 2, 3, ..., 100]
>>> L[1:10]                                 #取索引1开始，到索引10为止但不含10的元素
[1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> L[0:10]                                 #取索引0开始，到索引10为止但不含10的元素
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> L[:10]                                  #如果从索引0开始取，那么0可以省略
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> L[:]                                    #取所有元素，原样复制一个list
[0, 1, 2, 3, 4, 5...96, 97, 98, 99, 100]

也可以直接取后面的元素，需要注意的是第一个元素的索引号是0，倒数第一个元素的索引号是-1。切片必须顺序取值，如L[10:1]、L[-1:-10]都是无法取值的。

>>>L[-10:-1]                               #从索引-10开始到索引-1为止但不含-1的元素
[91, 92, 93, 94, 95, 96, 97, 98, 99] 
>>>L[-10:]                                 #取最后10个元素
[91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

后面再加一个冒号可以实现间隔取值，如

>>>L[:10:2]                                #从索引号0开始，每2个取1个，到索引号10为止不含10
[0, 2, 4, 6, 8] 
>>>L[:30:3]                                #从索引号0开始，每3个取1个，到索引号30为止不含30
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

>>>T=(0,1,2,3,4)                           #tuple切片
>>>T[1:3]
(1, 2)

字符串'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'
>>> S='abcdef'                              #字符串切片
>>> S[1:3]
>>> 'bc'

在很多编程语言中，针对字符串提供了很多各种截取函数（例如，substring），其实目的就是对字符串切片。Python没有针对字符串的截取函数，只需要切片一个操作就可以完成，非常简单。

有了切片操作，很多地方循环就不再需要了。Python的切片非常灵活，一行代码就可以实现很多行循环才能完成的操作。

【练习】去除字符串首尾空格的函数实现

利用切片操作，实现一个trim()函数，去除字符串首尾的空格，注意不要调用str的strip()方法：

【交作业】

  1. 掐头去尾 while循环1
# -*- coding: utf-8 -*-
def trim(s):
    n = len(s)
    i = 0
    b = -1
    while i <= n-1 and s[i] == ' ':
        i = i + 1
    while b >= -n and s[b] == ' ':
        b = b - 1
    s = s[i:b+1]
    return s

print trim('  Hello ')
  1. while循环2
def trim(s):
     n = 0
     while len(s)!=0 and s[n] == ' '  and n < len(s)-1:
         n+=1 # n = n + 1
     m = -1
     while len(s)!=0 and s[m] == ' '  and m > (-1)*len(s):
         m-=1 # m = m - 1
     ts = s[n:m+1] # ts = s[n:len(s)+(m+1)]
     return ts

  print trim('  Hello ')
  1. for in循环 加if
# -*- coding: utf-8 -*-
def trim(s):
     start = 0
     end = len(s)-1
     for str in s:
         if s[start] == ' ':
             start = start + 1
         elif s[end] == ' ':
             end = end - 1
         elif start == end:
             return ' '
     return s[start:end + 1]

print trim('  Hello ')
  1. 递归 左右循环
# -*- coding: utf-8 -*-
def trim(s):
     if s[:1] == ' ':
         return trim(s[1:])
     elif s[-1:] == ' ':
         return trim(s[:-1])
     else:
         return s

print trim('  Hello ')

def trim(s):
    if len(s) == 0:
        return ''
    else:
        if s[-1:] == ' ':
            return trim(s[:-1])
        elif s[:1] == ' ':
            return trim(s[1:])
        return s[:]

# -*- coding: utf-8 -*-
def trim(s):
    while s[:1] == ' ':
        s = s[1:]
    while s[-1:] == ' ':
        s = s[:-1]
    return s

递归会出现函数调用栈溢出问题，当字符串前后空格长度为1000，程序就报错了

  1. 查找起始位置
def trim(s):
    b = 0
    e = len(s)
    for i in range(e):
        if s[i] != ' ':
            break
        b += 1
    for i in range(e)[::-1]:
        if s[i] != ' ':
            break
        e = i
    return s[b:e]

def trim(s):
    while s and s[0] == ' ':  # while语句的判断条件中加上s，是为了排除s为空字符串的情况。因为s为空时，对变量s进行切片时，会报错“索引错误”。
        s = s[1:]
    while s and s[-1] == ' ':
        s = s[:-1]
    return s

迭代

Iteration，当我们用for循环来遍历list或tuple时，这种遍历就是Iteration，即迭代。

Python的for循环抽象程度要高于C的for循环，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

在其他语言中如c，在迭代时需要通过下标来实现，而在Python中，没有下标也能实现迭代，Python的可迭代对象有很多，如list、tuple、dict、字符串等。

字符串也是可迭代对象，也可以作用于for循环：

>>> for ch in 'ABC':
...     print ch
...
A
B
C

• 判断是否为可迭代对象

方法是通过collections模块的Iterable类型判断：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

• 迭代tuple

>>> T = (1, 2, 3)
>>> for a in T:                                  #迭代tuple
...     print a
...
1
2
3

• 迭代dict中的key

>>> D = {'Zhao':20, 'Qian':50, 'Sun':100}
>>> for key in D:                                #迭代dict中的key
...     print key
...
Sun                     # 因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样。
Zhao
Qian

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。

• 迭代dict中的value

>>> for value in D.values():                     #迭代dict中的value
...     print value
...
100
20
50

• 同时迭代dict中的key和value

>>> for k, v in D.items():                       #同时迭代dict中的key和value
...     print k, v
...
Sun 100
Zhao 20
Qian 50

• 拥有迭代下标

如果想要和其他语言类似Java一样想要有下标，可以通过Python内置的enumerate( )函数来实现，把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print i, value
...
0 A
1 B
2 C

>>>for i, a in enumerate(T):                    #同时迭代去索引和元素本身
...    print i,a
...
0 1 
1 2 
2 3

上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如：

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print x, y
...
1 1
2 4
3 9

总结

任何可迭代对象都可以作用于for循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用for循环。

【练习】取list中的最大最小值的函数实现

请使用迭代查找一个list中最小和最大值，并返回一个tuple：

# -*- coding: utf-8 -*-
def findMinAndMax(L):
    return (None, None)

【交作业】

# -*- coding: utf-8 -*-
def findMinAndMax(L):

     if len(L) == 0:
         return (None, None)                 # MIN=MAX=None
     else:
         min = L[0]
         max = L[0]
         for x in L:
             if x < min:
                 min = x
             elif x > max:
                 max = x
                 
     return (min, max)

L = [3, 6, 10]
print findMinAndMax(L)

# -*- coding: utf-8 -*-
def findMinAndMax(L):

     if len(L) != 0:
         maxnum = minnum = L[0]
         for x in L:
             maxnum = max(x, maxnum)
             minnum = min(x, minnum)
         return (minnum, maxnum)
     else:
         return (None, None)

# -*- coding: utf-8 -*-
def findMinAndMax(L):

    if L == []:
        return (None, None)
    max, min = L[0], L[0]
    for i in range(len(L)):
        if L[i]>= max:
            max = L[i]
        elif L[i]< min:
            min = L[i]
    return (min, max)

列表生成式

列表生成器可通过[ ]直接构建。
我们想要生成一个列表的话可以先通过list(range(,))生成初始列表，然后在循环语句或判断语句加入条件与算法从而得到想要的列表，但这种方法有点麻烦。而列表生成器可以把这个过程用一行代码实现！

例如，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

要生成1^2，2^2，3^2…10^2这样的数列：
方法一用循环：

>>> L = []
>>> for x in range(1, 11):
...    L.append(x * x)
...
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

方法二用列表生成式（简单用一行语句就可以实现），写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

for循环后面还可以加上if判断，只算奇数的平方：

>>> [x * x for x in range(1, 11) if x % 2 != 0]
[1, 9, 25, 49, 81]

只筛选出仅偶数的平方：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还能采用两层循环，生成全排列

>>> [m + n for m in 'ABC' for n in "123"]
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
>>> [a + b for a in 'ABC' for b in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

三层和三层以上的循环就很少用到了。

for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C

因此，列表生成式也可以使用两个变量来生成list：

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
>>> D={'A':'a', 'B':'b', "C":'c'}
>>> [k + '-->' + v for k, v in D.items()]
['A-->a', 'C-->c', 'B-->b']

把一个list中所有的字符串变成小写：

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

if ... else

使用列表生成式的时候，要搞清楚if...else的用法。

例如，输出偶数：

>>> [x for x in range(1, 11) if x % 2 == 0]
[2, 4, 6, 8, 10]

但是，不能在最后的if加上else：

>>> [x for x in range(1, 11) if x % 2 == 0 else 0]
  File "<stdin>", line 1
    [x for x in range(1, 11) if x % 2 == 0 else 0]
                                              ^
SyntaxError: invalid syntax

这是因为跟在for后面的if是一个筛选条件，不能带else，否则如何筛选？

另一些童鞋发现把if写在for前面必须加else，否则报错：

>>> [x if x % 2 == 0 for x in range(1, 11)]
  File "<stdin>", line 1
    [x if x % 2 == 0 for x in range(1, 11)]
                       ^
SyntaxError: invalid syntax

这是因为for前面的部分是一个表达式，它必须根据x计算出一个结果。因此，考察表达式：x if x % 2 == 0，它无法根据x计算出结果，因为缺少else，必须加上else：

>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

上述for前面的表达式x if x % 2 == 0 else -x才能根据x计算出确定的结果。

可见，在一个列表生成式中，for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。

总结

运用列表生成式，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分简洁。

【练习】

如果list中既包含字符串，又包含整数，由于非字符串类型没有lower()方法，所以列表生成式会报错：

>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() for s in L]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'lower'

使用内建的isinstance函数可以判断一个变量是不是字符串：

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

请修改列表生成式，通过添加if语句保证列表生成式能正确地执行：

# -*- coding: utf-8 -*-
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = ???

【交作业】

>>> [x for x in L1 if isinstance(x, str)]
['Hello', 'World', 'Apple']
>>> [x.lower() for x in L1 if isinstance(x, str)]
['hello', 'world', 'apple']

生成器 generator

generator，是生产者的意思。在Python中，generator意为生成器，是一种可以一边循环一边计算的机制。相比列表生成式，generator的优点在于算法不用生成全部数列，而只生成我们需要的一部分，从而节省很多空间。

• generator的定义

generator的定义有两种方式:

第一种：是直接通过( )创建，这种方式与列表生成器相似，只是把[ ]换成( )。

>>> L = [x * x for x in range(1, 11)]
>>> L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>> g = (x * x for x in range(1, 11))
>>> g
<generator object <genexpr> at 0x109b9fbe0>

第二种：是通过函数的形式创建，在定义函数的过程中加入yield关键字，yield后面需生成的值，则这个函数不是一个普通的函数而是一个generator。如我们可以构建一个斐波拉契数列生成器

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1

赋值语句：a, b = b, a + b
相当于：

t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

上面的函数可以输出斐波那契数列的前N个数：

>>> f = fib(6)
1
1
2
3
5
8

要把fib函数变成generator，只需要把print b改为yield b就可以了：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

>>> f = fib(6)
>>> f
<generator object fib at 0x109b9fb90>

generator和函数的执行流程不一样。直到return返回，则退出函数。而generator的执行方式是顺序执行，直到yield返回停止，下次再调用时从上次返回的yield语句后继续执行。

举例如下：定义一个generator，依次返回数字1，3，5

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

调用该generator时，首先要生成一个generator对象，然后用next()函数不断获得下一个返回值：

>>> o = odd()
>>> next(o)
step 1
1
>>> next(o)
step2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

可以看到，odd不是普通函数，而是generator，在执行过程中，遇到yield就中断，下次又继续执行。执行3次yield后，已经没有yield可以执行了，所以，第4次调用next(o)就报错。

回到fib的例子，我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

同样的，把函数改成generator后，我们基本上从来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：

>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8

但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中，具体操作会在后面介绍。

• generator的调用

打印出generator的每一个元，可以一个一个打印出来，可以通过next()函数获得generator的下一个返回值：

>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
100
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator保存的是算法，每次调用next()，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

这种方式太过繁琐，generator是可迭代对象，一般采用for…in循环来调用。

>>> g = (x * x for x in range(1, 11))
>>> for n in g:
...     print n
...
1
4
9
16
25
36
49
64
81
100

创建了一个generator后，基本上永远不会调用next()方法，而是通过for循环来迭代它。

【练习】杨辉三角排列的生成

杨辉三角定义如下：

          1
        1   1
      1   2   1
    1   3   3   1
  1   4   6   4   1
1   5  10  10   5   1

把每一行看做一个list，试写一个generator，不断输出下一行的list：

# -*- coding: utf-8 -*-

def triangles():

【交作业】

# -*- coding: utf-8 -*-

def triangles():
    L = [1]                      #初始排列L为[1]
    while True:    
        yield L                  #返回L
        if L == [1]:
            L = L + [1]          #在L只有一个元素时，在加[1]，时排列为[1,1]
        else:
            L = [1]+[L[x]+L[x+1]for x in range(len(L)-1)]+[1]    
                                 #当排列L有两个或以上的元素时，按顺序把每两个值相加生成一个值，并在前后加[1]

n = 0
results = []
for t in triangles():
    print(t)
    results.append(t)
    n = n + 1
    if n == 10:                  #生成十行排列
        break

输出结果

[1] 
[1, 1] 
[1, 2, 1] 
[1, 3, 3, 1] 
[1, 4, 6, 4, 1] 
[1, 5, 10, 10, 5, 1] 
[1, 6, 15, 20, 15, 6, 1] 
[1, 7, 21, 35, 35, 21, 7, 1] 
[1, 8, 28, 56, 70, 56, 28, 8, 1] 
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
  1. 同一列表首尾插入项{0} ，形成2个不同的列表，错位相加生成新的列表
# -*- coding: utf-8 -*-

def triangles():
    L = [1]
    while True:
        yield L
        L1 = [0] + L
        L2 = L + [0]
        L = [L1[i]+L2[i] for i in range(0,len(L1))]

……

  li  = [1]    # 错位相加即可
    while True:
        yield li[:]
        li.append(0)
        for index,value in enumerate(li[:-1]):
            li[index+1] += value

?

def triangles():
    L = [1]
    yield L
    n = 1    while True:
        Ln = []
        for i in range(n + 1):
            if i == 0 or i == n:
                Ln.append(1)
            else:
                Ln.append(L[n - 1][i - 1] + L[n - 1][i])
        yield Ln
        L.append(Ln)
        n = n + 1

while True:

L = [1 if x == 0 or x == n else results[n-1][x-1]+results[n-1][x] for x in range(n+1)]

yield L

pass

总结

generator是非常强大的工具，在Python中，可以简单地把列表生成式改成generator，也可以通过函数实现复杂逻辑的generator。

要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

注意区分普通函数和generator函数，普通函数调用直接返回结果：

>>> r = abs(6)
>>> r
6

generator函数的“调用”实际返回一个generator对象：

>>> g = fib(6)
>>> g
<generator object fib at 0x1022ef948>

迭代器 Iterator

• 可迭代对象 Iterable

可用for循环来迭代的对象称可迭代对象——Iterable，包括list、tuple、set、str、generator。

Python3中可通过isinstance()来判断一个对象是否为可迭代对象：

>>> from collections.abc import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(5, Iterable)
False

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

• 迭代器 Iterator

可以被next( )函数调用不断返回下个值得对象称迭代器——Iterator，如generator。可通过isinstance()来判断一个对象是否为迭代器。

>>> from collections.abc import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abcd', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是`Iterator。

• Iterable转成Iterator

可以通过 iter() 函数把list、dict、str等Iterable可迭代对象转成Iterator迭代器。

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abcd'), Iterator)
True

总结

凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,390评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,821评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,632评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,170评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,033评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,098评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,511评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,204评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,479评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,572评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,341评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,213评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,576评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,893评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,171评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,486评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,676评论 2赞 335