【Python】学习笔记

抽空总结的一篇笔记，顺便复习一下python语法，通俗易懂 ~

第1章 变量和数据类型

  • 数据类型

①整数
计算机由于使用二进制，所以有时候用十六进制表示整数比较方便，用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3等等
②浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的
③字符串
字符串是以' '或" "括起来的任意文本，例如：'abc'，"xyz"等等
④布尔值
布尔值只有True、False两种值，它可以用and、or和not运算
⑤空值
空值是Python里一个特殊的值，用None表示
None不能理解为0，因为0是有意义的，而None是一个特殊的空值

  • print语句
print 'hello, world'
  • 注释

注释是用来说明代码的，给自己或别人看，不影响结果

# 这是我写的代码
print 'hello, world'
  • 变量

变量不仅可以是数字，还可以是任意数据类型
变量名必须是大小写英文、数字和下划线（_）的组合，且不能用数字开头
比如：a = 1，变量a是一个整数。t_007 = 'T007'，变量t_007是一个字符串。

  • 整数和浮点数

整数运算结果是整数
浮点数运算结果是浮点数
整数和浮点数混合运算结果是浮点数

  • 字符串

如果字符串既包含 ' 又包含 " ，这个时候对某些特殊字符可以用 \ 进行转义

s = 'Python was started in 1989 by \"Guido\".'
print s

①如果一个字符串包含多个需要转义的字符，转义会很麻烦。我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了
②要表示多行字符串，可以用 '''...''' 表示

print r'\(~_~)/ \(~_~)/'
print '''Line 1
Line 2
Line 3'''

中国制定了GB2312编码，用来把中文编进去。类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode编码把所有语言都统一起来，这样就不会再有乱码问题了。

print u'''
床前明月光
疑是地上霜
举头望明月
低头思故乡'''
  • 布尔类型

与运算：只有两个布尔值都为 True 时，计算结果才为 True
True and True # ==> True
True and False # ==> False
False and True # ==> False
False and False # ==> False
或运算：只要有一个布尔值为 True，计算结果就是 True
True or True # ==> True
True or False # ==> True
False or True # ==> True
False or False # ==> False
非运算：把True变为False，或者把False变为True
not True # ==> False
not False # ==> True

print 100 < 99 or 0xff == 255

Python把0、空字符串和None看成 False，其他数值和非空字符串都看成 True
短路计算法则：
1.在计算 a and b 时，如果 a 是 False，返回 a；如果 a 是 True，返回 b。
2.在计算 a or b 时，如果 a 是 True，返回 a；如果 a 是 False，返回 b。

a = 'python'
print 'hello,', a or 'world'
b = ''
print 'hello,', b or 'world'

第2章 List和Tuple类型

  • 创建list

list是数学意义上的有序集合，元素是按照顺序排列的，可以随时添加和删除其中的元素
构造list非常简单，直接用 [ ] 把list的所有元素都括起来，就是一个list对象

L = ['Adam', 95, 'Lisa', 85, 'Bart', 59]
print L
  • 索引访问list

①索引从 0 开始，第一个元素的索引是0，第二个元素的索引是1，以此类推
②使用索引时，千万注意不要越界

L = ['Adam', 'Lisa', 'Bart']
print L[0]
print L[1]
print L[2]
  • 倒序访问list
L = [95, 85, 59]
print L[-1]
print L[-2]
print L[-3]
  • 添加元素

①list 的 append() 方法，可以把新的元素添加到尾部
②list 的 insert() 方法，第一个参数是索引号，第二个参数是待添加的新元素

L = ['A', 'B', 'C']
L.insert(2, 'YYDL')
L.append('SSY')
print L
  • 删除元素

list 的 pop()方法，可以删掉最后一个元素，也可以添加索引删除指定元素

L = ['Adam', 'Lisa', 'Paul', 'Bart']
L.pop(2)
print L
L.pop()
print L
  • 替换元素
L = ['Adam', 'Lisa', 'Bart']
L[0] = 'Bart'
L[2] = 'Adam'
print L
  • 创建tuple

①tuple是另一种有序的列表，和 list 类似，但是tuple一旦创建完毕就不能修改了
用 ( ) 把tuple的所有元素都括起来，就是一个tuple对象
②用 ( ) 定义单元素的tuple有歧义，所以要多加一个逗号，更明确地告诉你这是一个tuple

t = (0 ,1, 2, 3, 4, 5, 6, 7, 8, 9)
print t
t = ('Adam',)
print t
  • “可变”的tuple

tuple所谓的不变是说每个元素指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象。但指向的这个list本身是可变的

t = ('a', 'b', ['A', 'B'])
L = t[2]
print L
L[0] = 1
L[1] = 2
print t

第3章 条件判断和循环

  • if 语句
score = 75
if score >= 60:
    print 'passed'
  • if-else 语句
score = 55
if score >= 60:
    print 'passed'
else:
    print 'failed'
  • if-elif-else 语句
score = 85
if score >= 90:
    print 'excellent'
elif score >= 80:
    print 'good'
elif score >= 60:
    print 'passed'
else:
    print 'failed'
  • for 循环

for 循环可以依次把 list 或 tuple 的每个元素迭代出来

# 计算平均成绩
L = [75, 92, 59, 68]
sum = 0.0
for x in L:
    sum += x
print sum / 4
  • while 循环

while 循环不会迭代元素，而是根据表达式判断循环是否结束

# 计算100以内奇数的和
sum , x = 0 , 1
while x < 100:
    sum += x
    x += 2
print sum
  • break语句

break语句可以直接退出循环

t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
for x in t:
    if x ==7:
        break
    print x
  • continue语句

continue语句可以跳过后续代码，继续下次循环

t = (0, 1, 2, 3)
for x in t:
    if x ==2:
        continue
    print x
  • 多重循环
for x in ['A', 'B', 'C']:
    for y in ['1', '2', '3']:
        print x + y

第4章 Dict和Set类型

  • 什么是dict

①list 和 tuple 可以用来表示顺序集合，例如班里同学的名字和考试成绩，但是要根据名字找到对应的成绩，用两个 list 表示就不方便，而 dict 就是专门干这件事的
②我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。
花括号 { } 表示这是一个dict，然后按照 key: value 写出来即可
③由于dict也是集合，len() 函数可以计算大小，一个 key-value 算一个

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
print len(d)
  • 访问dict

①list 使用索引返回对应的元素，而 dict 使用 key 返回对应的 value
②使用dict本身提供的一个 get 方法，在 key 不存在的时候，返回 None
③用 in 操作符可以判断 key 是否存在

d = {
    'Adam': 90,
    'Lisa': 80,
    'Bart': 70
}
print d['Adam']
print d.get('Lisa')
if 'Bart' in d:
    print d['Bart']
  • dict的特点

①查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。
而list的查找速度随着元素增加而逐渐下降，缺点是占用内存大
②存储的key-value序对是没有顺序的，这和list不一样
③key不能重复，且作为 key 的元素不可变

d = {
    90: 'Adam',
    80: 'Lisa',
    70: 'Bart'
}
print d
  • 更新dict
d = {
    95: 'Adam',
    85: 'Lisa'
}
d[72] = 'Paul'
print d
  • 遍历dict
d= {
    'A':1,
    'B':2,
    'C':3
}
for i in d:
    print i,d[i]
  • 什么是set

set 有一系列元素，这点和 list 很像，但是元素没有重复且无序，这点和 dict 的 key很像

s = set(['A', 'B', 'C', 'C'])
print len(s)
print s
  • 访问set

由于 set 存储的是无序集合，所以我们没法通过索引来访问。
访问 set 中的某个元素实际上就是判断一个元素是否在 set 中

s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
print 'Adam' in s
print 'bart' in s
  • set的特点

set的内部结构和dict很像，唯一区别是不存储value，因此判断元素是否在set中速度很快
set存储的元素和dict的key类似，必须是不变对象，因此任何可变对象是不能放入set中的

months = set(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'])
x1 = 'Feb'
x2 = 'Sun'
if x1 not in months:
    print 'x1: error'
if x2 not in months:
    print 'x2: error'
  • 遍历set
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    print x[0] , x[1]
  • 更新set

由于set存储的是一组不重复的无序元素，因此更新set要做两件事：
一是 add() 把新的元素添加到set中，二是 remove() 把已有元素从set中删除

s = set(['A', 'B', 'C'])
L = ['C', 'D', 'E', 'F']
for x in L:
    if x in s:
        s.remove(x)
    else:
        s.add(x)
print s

第5章 函数

  • 什么是函数

当我们知道半径r的值时，就可以根据公式计算出面积
假设我们需要计算10个不同大小的圆的面积，每次写s = 3.1415926535 * r * r很麻烦
有了函数，我们就写成函数调用 s = S(r)，而函数本身只需要写一次，而且可以多次调用

  • 内置函数

Python内置了很多有用的函数，要调用一个函数，需要知道函数名和参数，例如：
①求绝对值的函数 abs， abs(-20) = 20
②比较函数 cmp(x, y) 需要两个参数，x<y，返回 -1；x==y，返回 0 ；x>y，返回 1
③把其他数据类型转换为整数的函数 int()，int('123') = 123
④把其他类型转换成字符串的函数 str()，str(123) = '123'

  • 编写函数

定义一个函数要使用 def 语句，依次写出函数名、括号、参数和冒号，然后编写函数体，函数返回值用 return 语句返回。如果没有返回值，可以简写为return

# 定义一个函数，它返回 list 的元素平方和
def f(L):
    sum = 0
    for x in L:
        sum += x * x
    return sum
print f([1, 2, 3, 4, 5])
print f([-5, 0, 5, 15, 25])
  • 函数之返回多值

Python的函数返回多值其实就是返回一个tuple，但写起来更方便

'''
请编写一个函数，返回一元二次方程 ax² + bx + c = 0 的两个解。
注意：Python的math包提供了sqrt()函数用于计算平方根
'''
import math

def f(a, b, c):
    t = math.sqrt(b * b - 4 * a * c)
    return (-b + t) / (2 * a),( -b - t )/ (2 * a)
print f(1, -6, 5)
  • 递归函数

如果一个函数在内部调用了自己，这个函数就是递归函数

# 计算阶乘 50! = 1 * 2 * 3 * ... * 50
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
print fact(50)
  • 默认参数
def greet(name='world'):
    print 'Hello ' + name
greet()
greet('ABC')
  • 可变参数
def average( *p ):
    sum = 0.0
    if len(p) == 0:
        return sum
    for x in p:
        sum += x
    return sum / len(p)
print average()
print average(1, 2, 2, 4.3)

第6章 切片

  • 正序切片

L[1:4] 表示从索引1开始，到4为止，但不包括4。即索引1，2，3正好是3个元素
L[a:b:N] 表示从a开始，到b为止，每N个取一个元素。索引为第一个或最后一个可以省略
L[:] 表示从头到尾全部元素

# L = [0,1,2...,99]
L = range(100)
print L[1:4]
print L[3:8:2]
print L[1: :3]
print L[:]
  • 倒序切片

L[-a:-b:N] 表示从倒数第a个开始，到倒数第b个为止，每隔N个取一个元素

L = range(1, 101)
print L[-10:-1]
print L[-46:  :5]
  • 字符串切片

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

'''
实现将首字母大写
注意：函数upper()可以把字符变成大写字母
'''
def UP(s):
    return s[0].upper() + s[1: ]
print UP('hello')
print UP('sunday')

第7章 迭代

  • 什么是迭代

迭代是通过 for ... in 来完成的

# 循环迭代数列 1-100，打印出7的倍数
for i in range(1, 101):
    if i % 7 == 0:
        print i
  • 索引迭代

①迭代是取出元素本身，而非元素的索引
②enumerate() 函数可以在 for 循环中同时绑定索引和元素
['Adam', 'Lisa', 'Bart', 'Paul'] --> [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
③zip()函数可以把两个 list 变成一个 list
zip([10, 20, 30], ['A', 'B', 'C']) -- > [(10, 'A'), (20, 'B'), (30, 'C')]

L = ['Adam', 'Lisa', 'Bart', 'Paul']
for i, name in zip(range(1,5), L):
    print i, '-', name
  • 迭代dict的value
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for v in d.values():
    sum += v
print sum / len(d)
  • 迭代dict的key和value
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 74 }
sum = 0.0
for i, j in d.items():
    sum += j
    print i, ':', j
print sum / len(d)

第8章 列表生成式

  • 生成列表

把要生成的元素放到前面，后面跟 for 循环,就可以把 list 创建出来

print [x*x for x in range(1, 100, 2)]
  • 复杂表达式

字符串可以用指定的参数替代 %s。join() 方法可以把一个 list 拼接成一个字符串

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
def M(name, score):
    return '<tr><td> %s </td><td> %s </td></tr>' % (name, score)
tds = [M(name, score) for name, score in d.items()]

print '<table border="1">'
print '<tr><th> name </th><th> score </th><tr>'
print '\n'.join(tds)
print '</table>'
  • 条件过滤

在列表生成式中，for 循环后面还可以加上 if 判断
①isinstance(x, str) 可以判断变量 x 是否是字符串
②upper() 可以返回大写字母

def f(L):
    return [x.upper() for x in L if isinstance(x, str)]
print f(['hello', 'world', 101])
  • 多层表达式

在列表生成式中，也可以用多层 for 循环来生成列表

print [ 100 * n1 + 10 * n2 + n3 
for n1 in range(1, 10) for n2 in range(10) for n3 in range(10) 
if n1 == n3 ]

第9章 函数式编程

  • 把函数作为参数
import math

def add(x, y, f):
    return f(x) + f(y)
print add(25, 9, math.sqrt)
  • map()函数

map() 函数是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 依次作用在 list 的每个元素上，得到一个新的 list 并返回

def F(s):
    return s[0].upper() + s[1:].lower()
print map(F, ['adam', 'LISA', 'barT'])
  • reduce()函数

reduce() 函数也是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 必须接收两个参数，reduce() 对 list 的每个元素反复调用 f 并返回

def p(x, y):
    return x * y
print reduce(p, [1, 2, 3, 4])
  • filter()函数

filter() 函数也是 python 内置的高阶函数，它接收一个函数 f 和一个 list，
f 对 list 每个元素进行判断，filter() 根据判断返回符合条件元素组成的新 list

import math
# 能否开方返回True，不能开方返回False
def f(x):
    r = int(math.sqrt(x))
    return r*r==x
print filter(f, range(1, 101))
  • 自定义排序函数

①python内置的 sorted() 函数可对 list 进行排序
sorted( [36, 5, 12, 9, 21] ) --> [5, 9, 12, 21, 36]
②它可以接收一个比较函数来实现自定义，传入两个元素x，y，

如果x排在y的前面返回 -1，如果x排在y的后面返回 1，如果x和y相等，返回 0

# 自定义倒序排列
def f(s1, s2):
    if s1 > s2:
        return -1
    if s1 < s2:
        return 1
    return 0
print sorted(['bob', 'about', 'zoo', 'credit'], f)
  • 返回函数

函数不但可以返回int、str、list、dict等数据类型，还可以返回函数

def p1(l):
    def p2():
        def f(x, y):
            return x * y
        return reduce(f, l)
    return p2  
f = p1([1, 2, 3, 4])
print f()
  • 闭包

闭包：内层函数引用了外层函数的变量，然后返回内层函数的情况
特点：返回的函数引用了外层函数的局部变量，所以要确保变量在函数返回后不能变

def count():
    fs = []
    for i in range(1, 4):
        # 返回一个闭包g，g所引用的m不是循环变量
        def f(m):
            def g():
                return m*m
            return g
        fs.append(f(i))
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
  • 匿名函数

①关键字 lambda 表示匿名函数，冒号前面的 x 表示函数参数
匿名函数只能有一个表达式，不写return，返回值就是表达式的结果
②匿名函数不定义函数名，直接创建一个函数对象，很多时候可以简化代码

print map(lambda x: x * x, [1, 2, 3, 4])
  • decorator装饰器
  • 无参数decorator

①decorator 本质上是高阶函数，它接收一个函数作为参数，然后返回一个新函数
使用 decorator 用@语法，这样可以避免手动编写 f = decorate(f) 这样的代码
②可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用

import time
# 编写一个@Performance，打印出函数ABC()调用的时间
def Performance(f):
    def P(*args, **kw):
        t1 = time.time()
        x = f(*args, **kw)
        t2 = time.time()
        print 'call %s () in %f s' % (f.__name__, (t2 - t1))
        return x
    return P
@ Performance
def ABC(x,y,z):
    return x+y+z
print ABC(10,11,12)
  • 带参数decorator
import time

def Performance(s):
    def P1(f):
        def P2(*args, **kw):
            t1 = time.time()
            x = f(*args, **kw)
            t2 = time.time()
            print 'call %s () in %f %s' % (f.__name__, (t2 - t1) * 1000, s)
            return x
        return P2
    return P1
@ Performance('ms')
def ABC(x,y,z):
    return x+y+z
print ABC(10,11,12)
  • 偏函数

functools.partial 就是帮助我们创建一个偏函数的,
它可以把一个参数多的函数变成一个参数少的新函数，这样函数调用的难度就降低了

# 二进制转换十进制
def f(x, base=2):
    return int(x, base)
print f('1000000')

第10章 模块

  • 模块和包

①包 --> 文件夹
模块 --> xxx.py 文件
包里必须有 _init _.py 文件，以此来区分普通文件夹
②因为模块名也可能相同，把模块放入不同包即可避免冲突

  • 导入模块

① math是Python自带的模块，导入后可以使用其中所有公开的函数、变量和类
② os.path是Python自带的模块，它的isdir() 和 isfile()函数可以判断目录和文件是否存在
③ from ... import * 这样导入，后面使用就可以省略模块名

import math

print math.pow(2, 0.5) # pow是函数
print math.pi # pi是变量

from os.path import *

print isdir(r'C:\Program Files')
print isfile(r'C:\123.txt')
  • 动态导入模块

① 利用 import ... as ... 可以动态导入不同名称的模块
② try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句
③ Python2.7 提供了 json 模块，但 Python 2.5 以及更早版本没有 json 模块
只有 simplejson 模块，这两个模块功能一模一样

# 先尝试导入json，如果失败再 import simplejson as json
try:
    import json
except ImportError:
    import simplejson as json
print json.dumps({'python':2.7})
  • 使用__future __

①Python 2 的整数除法结果仍是整数
Python 3 改进了整数除法运算，“ / ” 除将得到浮点数，“ // ” 除才是整数
②要在Python 2 中引入Python 3的除法规则，可以导入__future __的division

from __future__ import division
print 10 / 3
  • 第三方模块

使用 Python 内置模块管理工具 pip 可以安装第三方模块
例如安装 web 模块，命令行输入 pip install web.py 即可

第11章 面向对象编程基础

第12章 类的继承

第13章 定制类

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