Python笔记——类与对象

面向对象的程序设计具有封装、继承、多态3个基本特征，可以大大增加程序可靠性、代码可重用行和程序可维护性，从而提高程序的开发效率。

类对象与实例对象

类对象

# 类对象
class 类名:
    类体

class Person1:
    pass
# 测试代码
p1 = Person1()
print(Person1, type(Person1), id(Person1))
print(p1, type(p1), id(p1))

实例对象

# 实例对象
anObject = 类名(参数列表)
anObject.对象函数 或 anObject.对象属性

Python创建实例对象的方法无需使用关键字new，而是直接调用类对象并传递参数。因此，类对象是可调用对象。

Python内置函数中，可调用内置类对象bool / int / str / list / dict / set

# 实例对象的创建实例
c1 = complex(1, 2)
c1.conjugate()
c1.real

# output
(1-2j)
1.0

属性

Python变量不需要声明，可直接使用。

实例对象属性

通过“self.变量名”定义的属性称为实例对象属性，也称为实例对象变量。类的每个实例都包含了该类的实例对象变量的一个单独副本，实例对象变量属于特定的实例。实例对象变量在类的内部通过self访问，在外部通过对象实例访问。

# 实例对象属性一般在__init__()方法中初始化
self.实例变量名 = 初始值
# 在其他实例函数中通过self访问
self.实例变量名 = 值
# 创建对象实例后通过对象实例访问
obj1 = 类名()
obj1.实例变量名 = 值
obj1.实例变量名

class Person2:
    def __init__(self, name, age): # 初始化__init__()方法
        self.name = name
        self.age = age
    def say_hi(self):
        print('您好,我叫', self.name)
        
# 测试代码
p1 = Person2('张三', 25)
p1.say_hi()
print(p1.age)

类对象属性

class Person3:
    count = 0
    name = "Person"

类属性如果通过obj.属性名来访问，则属于实例的实例属性。虽然类属性可以使用对象实例来访问，但容易造成困惑，访问类属性建议使用标准的访问方式"类名.变量名"

私有属性和共有属性

Python类的成员没有范文控制限制。

# 私有属性：以两下划线开头，但不以两下划线结束
class A:
    __name = 'class A'
    def get_name():
        print(A.__name)
    
A.get_name()
A.__name # 不可访问私有类属性

@property装饰器

面向对象编程的封装性原则要求不直接访问类中的数据成员。在Python中可以定义私有属性，然后定义相应的访问该私有属性的函数，并使用@property装饰器来装饰这些函数。程序可以把函数“当作”属性访问，从而提供更加友好的访问方式。

class Person11:
    def __init__(self, name):
        self.__name = name
    @property
    def name(self):
        return self.__name
    
# 测试代码
p = Person11('Estellasy')
print(p.name)

class Person12:
    def __init__(self, name):
        self.__name = name
    @property
    def name(self):
        return self.__name
    @name.setter
    def name(self, value):
        self.__name = value
    @name.deleter
    def name(self):
        del self.__name
#测试代码
p = Person12('姚六')
p.name = '王依依'
print(p.name)

# property的调用格式如下
property(fget=None, fset=None, fdel=None, doc=None)
# 其中，fget为get访问器；fset为set访问器；fdel为del访问器

特殊属性

以双下划线开始和结束的属性

自定义属性

@Override

方法

对象实例方法

在一般情况下，类方法的第一个参数一般为self，这种方法称为对象实例方法。

def 方法名(self, [形参列表]):
    函数体
    
对象.方法名([实参列表])
class Person4:            #定义类Person4
    def say_hi(self, name): #定义方法say_hi
        self.name = name #把参数name赋值给self.name，即成员变量name（域）
        print('您好, 我叫', self.name)
p4 = Person4()    #创建对象实例
p4.say_hi('Alice')  #调用对象实例的方法

静态方法

与类的对象实例无关的方法，称之为静态方法。

静态方法不对特定实例进行操作，在静态方法中访问对象实例会导致错误。静态方法通过装饰器@staticmethod来定义，其声明格式如下。

@staticmetho
def 静态方法名([形参列表]):
    函数体

一般通过类名来访问，也可以通过对象实例来调用。

class TemperatureConverter:
    @staticmethod 
    def c2f(t_c): #摄氏温度到华氏温度的转换
            t_c = float(t_c)
            t_f = (t_c * 9/5) + 32
            return t_f
    @staticmethod 
    def f2c(t_f): #华氏温度到摄氏温度的转换
            t_f = float(t_f)
            t_c = (t_f - 32) * 5 /9
            return t_c
        
#测试代码
print("1. 从摄氏温度到华氏温度.")
print("2. 从华氏温度到摄氏温度.")
choice = int(input("请选择转换方向："))
if choice == 1:
    t_c = float(input("请输入摄氏温度： "))
    t_f = TemperatureConverter.c2f(t_c)
    print("华氏温度为： {0:.2f}".format(t_f))
elif choice == 2:
    t_f = float(input("请输入华氏温度： "))
    t_c = TemperatureConverter.f2c(t_f)
    print("摄氏温度为： {0:.2f}".format(t_c))
else:
    print("无此选项，只能选择1或2！")

类方法

Python也允许声明属于类本身的方法，即类方法。类方法不对特定实例进行操作，在类方法中访问对象实例属性会导致错误。类方法通过装饰器@classmethod来定义，第一个形式参数必须为类对象本身，通常为cls。

@classmethod
def 类方法名(cls, [形参列表]):
    函数体
# 类方法一般通过类名来访问，也可以通过对象实例来调用。
类名.类方法名([实参列表])

class Foo:
    classname = "Foo"
    def __init__(delf, name):
        self.name = name
    def f1(self):
        print(self.name)
    @staticmethod
    def f2():
        print("static")
    @classmethod
    def f3():
        print(cls.classname)
        
#测试代码
f = Foo("李")
f.f1()
Foo.f2()
Foo.f3()

在Python类体中可以定义特殊的方法，例如__new__()方法和__init__()方法。
__new__()方法是一个类方法，在创建对象时调用，返回当前对象的一个实例，一般无须重载该方法。
__init__()方法即构造函数（构造方法），用于执行类的实例的初始化工作。在创建完对象后调用，初始化当前对象的实例，无返回值。

class Person5:             #定义类Person5
    def __init__(self, name): #__init__方法
        self.name = name #把参数name赋值给self.name，即成员变量name（域）
    def say_hi(self):     #定义类Person的方法say_hi
        print('您好, 我叫', self.name)
p5 = Person5('Helen')    #创建对象
p5.say_hi()            #调用对象的方法

__del__方法即析构函数（析构方法），用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源（例如：打开的文件、网络连接等）
默认情况下，当对象不再被使用时，__del__方法运行，由于Python解释器实现自动垃圾回收，即无法保证这个方法究竟在什么时候运行
通过del语句，可以强制销毁一个对象实例，从而保证调用对象实例的__del__方法。

class Person3: 
    count = 0                #定义类域count，表示计数
    def __init__(self, name,age): #构造函数
        self.name = name #把参数name赋值给self.name，即成员变量name（域）
        self.age = age    #把参数age赋值给self.age，即成员变量age（域）
        Person3.count += 1   #创建一个实例时，计数加1
    def __del__(self):        #析构函数
        Person3.count -= 1   #销毁一个实例时，计数减1
    def say_hi(self):        #定义类Person3的方法say_hi()
        print('您好, 我叫', self.name)
    def get_count():        #定义类Person3的方法get_count()
        print('总计数为：', Person3.count)
print('总计数为：',Person3.count) #类名访问
p31 = Person3('张三',25)    #创建对象
p31.say_hi()        #调用对象的方法
Person3.get_count()  #通过类名访问
p32 = Person3('李四',28)   #创建对象
p32.say_hi()        #调用对象的方法
Person3.get_count()  #通过类名访问
del p31            #删除对象p31
Person3.get_count()  #通过类名访问
del p32            #删除对象p32
Person3.get_count()  #通过类名访问

两个下划线开头，但不以两个下划线结束的方法是私有的（private），其他为公共的（public）.
以双下划线开始和结束的方法是Python的专有特殊方法。不能直接访问私有方法，但可以在其他方法中访问

class Book:                     #定义类Book
    def __init__(self, name, author, price):
        self.name = name  #把参数name赋值给self.name，即成员变量name（域）
        self.author = author#把参数author赋值给self.author，即成员变量author（域）
        self.price = price   #把参数price赋值给self.price，即成员变量price（域）
    def __check_name(self):       #定义私有方法，判断name是否为空
        if self.name == '' : return False
        else: return True
    def get_name(self):          #定义类Book的方法get_name
        if self.__check_name():print(self.name,self.author) #调用私有方法
        else:print('No value')
b = Book('Python程序设计教程','江红',59.0)    #创建对象
b.get_name()                    #调用对象的方法
b.__check_name()           #直接调用私有方法，非法

方法重载

可以定义多个重名的方法，只要保证方法签名是唯一的
方法签名包括三个部分：方法名、参数数量和参数类型

class Person21:
    def say_hi(self, name = None):
        self.name = name
        if name == None:
            print('您好')
        else:
            print('您好，我叫', self.name)
       
p21 = Person21()
p21.say_hi()
p21.say_hi('任思怡')

class Person22:                   #定义类Person22
    def say_hi(self, name):    #定义类方法say_hi，带两个参数
        print('您好, 我叫', self.name)
    def say_hi(self, name, age): #定义类方法say_hi，带三个参数
        print('hi, {0}, 年龄：{1}'.format(name,age))
p22 = Person22()               #创建对象
p22.say_hi('Lisa', 22)        #调用对象的方法
#p22.say_hi('Bob')        #TypeError: say_hi() missing 1 required positional argument: 'age'

Python类体中定义多个重名的方法虽然不会报错，但只有最后一个方法有效，所以建议不要定义重名的方法。

继承

派生类：python支持多重继承，即一个派生可以继承多个基类

声明派生类时，必须在其构造函数中调用基类的构造函数

class Person:                 #基类
    def __init__(self, name, age): #构造函数
        self.name = name     #姓名
        self.age = age        #年龄
    def say_hi(self):         #定义基类方法say_hi
        print('您好, 我叫{0}, {1}岁'.format(self.name,self.age))
class Student(Person):         #派生类
    def __init__(self, name, age, stu_id): #构造函数
        Person.__init__(self, name, age) #调用基类构造函数
        self.stu_id = stu_id    #学号
    def say_hi(self):          #定义派生类方法say_hi
        Person.say_hi(self)    #调用基类方法say_hi
        print('我是学生, 我的学号为：', self.stu_id)
p1 = Person('张王一', 33)            #创建对象
p1.say_hi()
s1 = Student('李姚二', 20, '2018101001') #创建对象
s1.say_hi()

查看继承的层次关系

通过类的方法mro()或类的属性__mro__可以输出其继承的层次关系

class A: pass
class B(A): pass
class C(B): pass
class D(A): pass
class E(B, D): pass
D.mro()
E.__mro__

类成员的继承和重写

通过继承，派生类继承基类中除构造方法之外的所有成员

如果在派生类中重新定义从基类继承的方法，则派生类中定义的方法覆盖从基类中继承的方法

class Dimension:  #定义类Dimensions
    def __init__(self, x, y): #构造函数
        self.x = x       #x坐标
        self.y = y       #y坐标
    def area(self):       #基类的方法area()
        pass
class Circle(Dimension):  #定义类Circle（圆）
    def __init__(self, r): #构造函数
        Dimension.__init__(self, r, 0)
    def area(self):        #覆盖基类的方法area()
        return 3.14 * self.x * self.x   #计算圆面积
class Rectangle(Dimension):  #定义类Rectangle（矩形）
    def __init__(self, w, h): #构造函数
        Dimension.__init__(self, w, h)
    def area(self):  #覆盖基类的方法area()
        return self.x * self.y  #计算矩形面积
d1 = Circle(2.0)          #创建对象：圆
d2 = Rectangle(2.0, 4.0)   #创建对象：矩形
print(d1.area(), d2.area())  #计算并打印圆和矩形面积

Python面向对象程序设计 续

对象的特殊方法

  • 包含许多以双下划线开始和结束的方法
  • 创建对象实例时，自动调用__init__方法，a<b时，自动调用对象a的__It__方法
class Person:
    def __init__(self, name, age): #特殊方法（构造函数）
        self.name = name
        self.age = age
    def __str__(self):          #特殊方法，输出成员变量
        return '{0}, {1}'.format(self.name,self.age)
#测试代码
p1 = Person('张三', 23)
print(p1)

运算符重载与对象的特殊方法

Python的运算符实际上是通过调用对象的特殊方法实现的


# 运算符重载示例
class MyList:             #定义类MyList
    def __init__(self, *args): #构造函数
        self.__mylist = []  #初始化私有属性，空列表
        for arg in args:
            self.__mylist.append(arg)
    def __add__(self, n):   #重载运算符"+"，每个元素增加n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] += n 
    def __sub__(self, n):   #重载运算符"-"，每个元素减少n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] -= n 
    def __mul__(self, n):   #重载运算符"*"，每个元素乘以n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] *= n 
    def __truediv__(self, n): #重载运算符"/"，每个元素除以n
        for i in range(0, len(self.__mylist)):
            self.__mylist[i] /= n 
    def __len__(self):     #对应于内置函数len()，返回列表长度
        return(len(self.__mylist))
    def __repr__(self):    #对应于内置函数str()，显示列表
        str1 = ''
        for i in range(0, len(self.__mylist)):
            str1 += str(self.__mylist[i]) + ' '
        return str1
#测试代码
m = MyList(1, 2, 3, 4, 5) #创建对象
m + 2; print(repr(m))   #每个元素加2
m - 1; print(repr(m))   #每个元素减1
m * 4; print(repr(m))   #每个元素乘4
m / 2; print(repr(m))   #每个元素除2
print(len(m))         #列表长度

@functools.total ordering装饰器

支持大小比较的对象需要实现特殊方法：__eq__、__lt__、__le__、__ge__、__gt__
使用functools模块的total_ordering装饰器装饰类，则只需要实现__eq__，以及__lt__、__le__、__ge__、__gt__中的任意一个
total_ordering装饰器实现其他比较运算，以简化代码量

import functools
@functools.total_ordering
class Student:
    def __init__(self, firstname, secondname):
        self.firstname = firstname
        self.secondname = secondname
    def __eq__(self, other):     #判断姓名是否一致
        return ((self.lastname.lower(), self.firstname.lower()) == (other.lastname.lower(), other.firstname.lower()))
    def __lt__(self, other):     #self姓名<other姓名
        return ((self.lastname.lower(), self.firstname.lower()) < (other.lastname.lower(), other.firstname.lower()))
    
#测试代码
if __name__ == '__main__':
    s1 = Student('Mary','Clinton')
    s2 = Student('Mary','Clinton')
    s3 = Student('Charlie','Clinton')
    print(s1==s2)
    print(s1>s3)

__call__方法和可调用对象(callabe)

Python类体中可以定义一个特殊的方法:__call__方法

定义了__call__方法的对象称之为可调用对象

class GDistance:
    def __init__(self, g):
        self.g = g
    def __call__(self, t):
        return (self.g*t**2)/2
    
# 测试代码
if __name__ = '__main__':
    e_gdist = GDistance(9.8)
    for t in range(11):
        print(format(e_gdist(t), "0.2f"),end=' ')

对象的引用、浅拷贝和深拷贝

  • 对象的引用：对象的赋值，id相同

  • 对象的浅拷贝：对象的赋值会引用同一个对象，即不拷贝对象

    • 切片操作

    • 对象实例化

    • copy函数

    • import copy
acc1 = ['Charlie', ['credit', 0.0]]
acc2 = acc1[:] # 使用切片方式拷贝对象
acc3 = list(ac1) # 使用对象实例化方法拷贝对象
acc4 = copy.copy(acc1) # 使用copy.copy函数拷贝对象
acc2[0] = 'Mary'
acc2[1][1] = -99.9

  • 对象的深拷贝：如果要递归复制对象中包含的子对象，可以使用copy模块的deepcopy()函数

    import copy
acc1 = ['Charlie', ['credit', 0.0]]
acc5 = copy.deepcopy(acc1)
acc5[0] = 'Clinton'
acc5[1][1] = -19.9

可迭代对象：迭代器和生成其

可循环迭代的对象称之为可迭代对象，迭代器和生成器函数是可迭代对象。

相对于序列，可迭代序列仅在迭代时产生数据，故可节省内存空间。

Python语言提供了若干内置可迭代对象：range\map\filter\enumerate\zip
标准库itertools模块中包含各种迭代器。

可迭代对象：实现了__iter__()的对象是可迭代对象
collections.abc模块中定义了抽象基类Iterable，使用内置的isinstance，可以判断一个对象是否为可迭代对象。

import collections.abc
isinstance((1, 2, 3), collections.abc.Iterable)
isinstance('python33',collections.abc.Iterable)   
isinstance(123,collections.abc.Iterable)

系列对象都是可迭代对象，生成器函数和生成器表达式也是可迭代对象。

迭代器：实现了__next__()的对象是迭代器

可以使用内置函数next(), 调用迭代器的__next__方法，一次返回下一个项目值

使用迭代器可以实现对象的迭代循环，迭代器让程序更加通用、优雅、高校，更加python化。

import collections.abc
i1 = (i**2 for i in range(10))
insinstance(i1, collections.abc.Iterator)

迭代器对象必须实现两个方法：__iter__()和__next()__，二者合称为迭代器协议。__iter__()用于返回对象本身，以方便for语句进行迭代，__next()__用于返回下一元素

自定义可迭代对象和迭代器

class Fib:
    def __init__(self):
        self.a, self.b = 0, 1
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a
    def __iter__(self):
        return self
# 测试代码
fibs = Fib()
for f in fibs:
    if f < 1000: print(f, end = ',')
    else: break

生成器函数

生成器函数使用yield语句返回一个值，然后保存当前函数整个执行状态，等待下一次调用。

生成器函数是一个迭代器，是可迭代对象，支持迭代

def gentripls(n):
    for i in range(n):
        yield i*3
f = gentripls(10)

反向迭代 reversed迭代器

使用内置函数reversed()，可以实现一个系列的反向系列

如果一个可迭代对象实现了__reversed__()方法，则可以使用reversed()函数获得其反向迭代对象

生成器表达式

生成器表达式的语法和列表解析基本一样，只不过生成器表达式使用()代替[]

表达式expr使用每次迭代内容iter_var，计算生成一个列表。如果指定了条件表达式cond_expr，则只有满足条件的iterable元素参与迭代

range可迭代对象

迭代时产生指定范围的数字序列，可以节省内存空间

map迭代器和itertool.starmap迭代器

map是可迭代对象，使用指定函数处理可迭代对象的每个元素（如果函数需要多个参数，则对应各可迭代对象），返回结果可迭代对象

filter迭代器和itertools.filterfalse迭代器

filter是可迭代对象，使用指定函数处理可迭代对象的每个元素，函数返回bool类型的值。若结果为True，则返回该元素。如果function为None，则返回元素为True的元素

>>> filter                                                         
<class 'filter'>
>>> list(filter(lambda x: x>0, (-1, 2, -3, 0, 5)))       
[2, 5]
>>> list(filter(None, (1, 2, 3, 0, 5)))                          
[1, 2, 3, 5]

如果需要返回结果为False的元素，则需要使用itertools.filterfalse迭代器
filterfalse根据条件函数predicate处理可迭代对象的每个元素，若结果为True，则丢弃；否则返回该元素

>>> import itertools
>>> list(itertools.filterfalse(lambda x: x%2, range(10))) 
[0, 2, 4, 6, 8]

zip迭代器和itertools.zip_longest迭代器

zip是可迭代对象，拼接多个可迭代对象iter1、iter2…的元素，返回新的可迭代对象，其元素为各系列iter1、iter2…对象元素组成的元组。如果各系列iter1、iter2…的长度不一致，则截断至最小系列长度。可以节省内存空间

>>> zip                                              #<class 'zip'>
>>> zip((1,2,3),'abc', range(3))        # <zip object at 0x000001ED6C5A72C8>
>>> list(zip((1,2,3),'abc', range(3)))  #[(1, 'a', 0), (2, 'b', 1), (3, 'c', 2)]
>>> list(zip('abc', range(10)))            #[('a', 0), ('b', 1), ('c', 2)]

多个可迭代对象的元素个数不一致时，如果需要取最大的长度，则需要使用itertools. zip_longest迭代器

>>> import itertools
>>> list(itertools.zip_longest('ABCD', 'xy', fillvalue='-'))
[('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')]

enumerate迭代器

enumerate是可迭代对象，用于枚举可迭代对象iterable中的元素，返回元素为元组（计数, 元素）的可迭代对象

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