# CHAPTER 2: BACK-OF-THE-ENVELOPE ESTIMATION  粗略估计
```
In a system design interview, sometimes you are asked to estimate system capacity or
performance requirements using a back-of-the-envelope estimation. According to Jeff Dean,
Google Senior Fellow, “back-of-the-envelope calculations are estimates you create using a
combination of thought experiments and common performance numbers to get a good feel for
which designs will meet your requirements” [1].
You need to have a good sense of scalability basics to effectively carry out back-of-theenvelope estimation. The following concepts should be well understood: power of two [2],
latency numbers every programmer should know, and availability numbers.



在系统设计面试中，有时要求您使用粗略的估计来估计系统容量或性能要求。根据谷歌高级研究员杰夫·迪恩（Jeff Dean）的说法，“粗略计算是你使用思想实验和常见性能数字的组合来创建的估计，以便很好地了解哪些设计将满足您的要求” [1]。

您需要对可伸缩性基础知识有很好的了解，才能有效地执行粗略估计。应该很好地理解以下概念：2 的幂 [2]、每个程序员都应该知道的延迟数字和可用性数字
```

## Power of two 数量化

```
Although data volume can become enormous when dealing with distributed systems,
calculation all boils down to the basics. To obtain correct calculations, it is critical to know
the data volume unit using the power of 2. A byte is a sequence of 8 bits. An ASCII character
uses one byte of memory (8 bits). Below is a table explaining the data volume unit (Table 2-
1).

尽管在处理分布式系统时，数据量可能会变得巨大，但计算都归结为基础知识。为了获得正确的计算，使用2的幂了解数据量单位至关重要。字节是 8 位的序列。ASCII 字符使用一个字节的内存（8 位）。下表解释了数据量单位（表 2- 1）。

approximative value 近似值
```

![image.png](https://www.choumaomi.com/static/img/39a3a9f10cd8ab7e8e7c54e7f6869a8d.image.png)


##  Latency numbers every programmer should know 每个程序员都应该知道的延迟数字

```
Dr. Dean from Google reveals the length of typical computer operations in 2010 [1]. Some
numbers are outdated as computers become faster and more powerful. However, those
numbers should still be able to give us an idea of the fastness and slowness of different
computer operations.


来自谷歌的Dean博士揭示了2010年[1]中典型计算机操作的长度。随着计算机变得更快和更强大，一些数字已经过时了。然而，这些数字仍然能够让我们了解不同计算机操作的速度和缓慢。
```

> Branch mispredict 分支预测错误
> Mutex lock/unlock 互斥锁机制
> compress 1k bytes with Zippy  使用 zippy 编写 1k 字节
> read 1MB sequentially from memory   从内存中按顺序读取1MB
> round trip within the same datacenter 在同一数据中心内的往返行程
> disk seek 磁盘查找

![image.png](https://www.choumaomi.com/static/img/35e2db8344d40504a2831b2224b96e06.image.png)

```
Notes
-----------
ns = nanosecond, µs = microsecond, ms = millisecond
1 ns = 10^-9 seconds
1 µs= 10^-6 seconds = 1,000 ns
1 ms = 10^-3 seconds = 1,000 µs = 1,000,000 ns
A Google software engineer built a tool to visualize Dr. Dean’s numbers. The tool also takes
the time factor into consideration. Figures 2-1 shows the visualized latency numbers as of
2020 (source of figures: reference material [3])

注释 
----------- 
ns = 纳秒，μs = 微秒，ms = 毫秒 
1 ns = 10^-9 秒 
1 μs = 10^-6 秒 = 1，000 ns 
1 ms = 10^-3 秒 = 1，000 μs = 1，000，000 ns 

一位谷歌软件工程师构建了一个工具来可视化迪恩博士的数字。该工具还考虑了时间因素。图 2-1 显示了截至 2020 年的可视化延迟数字（数据来源：参考资料 [3]）
```


![image.png](https://www.choumaomi.com/static/img/1780f12b7c02f00c5ea78e3b9f6dbc92.image.png)


```
By analyzing the numbers in Figure 2-1, we get the following conclusions:
• Memory is fast but the disk is slow.
• Avoid disk seeks if possible.
• Simple compression algorithms are fast.
• Compress data before sending it over the internet if possible.
• Data centers are usually in different regions, and it takes time to send data between them.

通过分析图 2-1 中的数字，我们得出以下结论： 
• 内存很快，但磁盘速度较慢。
• 尽可能避免磁盘寻道。
• 简单的压缩算法是快速的。
• 如果可能，在通过互联网发送数据之前压缩数据。
• 数据中心通常位于不同的区域，在它们之间发送数据需要时间。
```


## Availability numbers  可用性数字

```
High availability is the ability of a system to be continuously operational for a desirably long
period of time. High availability is measured as a percentage, with 100% means a service that
has 0 downtime. Most services fall between 99% and 100%.

A service level agreement (SLA) is a commonly used term for service providers. This is an
agreement between you (the service provider) and your customer, and this agreement
formally defines the level of uptime your service will deliver. Cloud providers Amazon [4],
Google [5] and Microsoft [6] set their SLAs at 99.9% or above. Uptime is traditionally
measured in nines. The more the nines, the better. As shown in Table 2-3, the number of
nines correlate to the expected system downtime.

高可用性是系统在理想的长时间内连续运行的能力。高可用性以百分比表示，100% 表示服务停机时间为 0。大多数服务介于 99% 到 100% 之间。

服务级别协议 （SLA） 是服务提供商的常用术语。这是您（服务提供商）与您的客户之间的协议，本协议正式定义了您的服务将提供的正常运行时间级别。云提供商亚马逊[4]，谷歌[5]和微软[6]将其SLA设置为99.9%或以上。正常运行时间传统上以九为单位。九越多越好。如表 2-3 所示，9 的数量与预期的系统停机时间相关。
```

![image.png](https://www.choumaomi.com/static/img/5c22d6f327be20ff04e38e0733e7a15b.image.png)

##  Example: Estimate Twitter QPS and storage requirements  示例：估算推特 QPS 和存储需求

```
Please note the following numbers are for this exercise only as they are not real numbers
from Twitter.
Assumptions:
• 300 million monthly active users.
• 50% of users use Twitter daily.
• Users post 2 tweets per day on average.
• 10% of tweets contain media.
• Data is stored for 5 years.
Estimations:
Query per second (QPS) estimate:
• Daily active users (DAU) = 300 million * 50% = 150 million
• Tweets QPS = 150 million * 2 tweets / 24 hour / 3600 seconds = ~3500
• Peek QPS = 2 * QPS = ~7000
We will only estimate media storage here.
• Average tweet size:
• tweet_id 64 bytes
• text 140 bytes
• media 1 MB
• Media storage: 150 million * 2 * 10% * 1 MB = 30 TB per day
• 5-year media storage: 30 TB * 365 * 5 = ~55 PB


请注意，以下数字仅用于本练习，因为它们不是推特上的真实数字。
假设：
• 活跃用户为每月3亿。
• 50%的用户每天都在使用推特。
• 用户平均每天发布2条推特。
• 有10%的推文包含媒体。
• 数据存储时间5年。

估计：
每秒查询（QPS）估计：
* 每日活跃用户（DAU）=3亿*50%=1.5亿条
* 推文QPS=1.5亿*2条推文/ 24小时/ 3600秒=~3500
* Peek QPS = 2 * QPS = ~7000

我们只估计这里的媒体存储。
• 平均tweet大小：
• tweet_id 64字节
• 文本140字节
• 媒体1 MB
• 媒体存储：1.5亿* 2 * 10% * 1 MB = 30 TB每天
• 5年媒体存储： 30 TB * 365 * 5 = ~55 PB
```

## Tips 技巧
```
Back-of-the-envelope estimation is all about the process. Solving the problem is more
important than obtaining results. Interviewers may test your problem-solving skills. Here are
a few tips to follow:
• Rounding and Approximation. It is difficult to perform complicated math operations
during the interview. For example, what is the result of “99987 / 9.1”? There is no need to
spend valuable time to solve complicated math problems. Precision is not expected. Use
round numbers and approximation to your advantage. The division question can be
simplified as follows: “100,000 / 10”.
• Write down your assumptions. It is a good idea to write down your assumptions to be
referenced later.
• Label your units. When you write down “5”, does it mean 5 KB or 5 MB? You might
confuse yourself with this. Write down the units because “5 MB” helps to remove
ambiguity.
• Commonly asked back-of-the-envelope estimations: QPS, peak QPS, storage, cache,
number of servers, etc. You can practice these calculations when preparing for an
interview. Practice makes perfect.
Congratulations on getting this far! Now give yourself a pat on the back. Good job!

事后估计的一切都是关于这个过程的。解决这个问题比获得结果更重要。面试官可能会测试你解决问题的能力。下面有一些建议：
* 四舍五入和近似值。在面试过程中，很难执行复杂的数学操作。例如，“99987/9.1”的结果是什么？没有必要花宝贵的时间来解决复杂的数学问题。精度不是预期的。最好使用整数和近似值。划分问题可以简化为：“100000/10”。
• 写下你的假设。写下你的假设以供以后引用是个好主意。
• 标记你的单位。当你写下“5”时，它是指5 KB还是5 MB？你可能会把自己搞混了。写下单位，因为“5MB”有助于消除歧义。
• 通常要求的信封背面估计： QPS、峰值QPS、存储、缓存、服务器数量等。你可以在准备面试时练习这些计算。

熟能生巧。祝贺你能走到这一步！现在拍拍自己的背。干得好！
```

## Reference materials
```
[1] J. Dean.Google Pro Tip: Use Back-Of-The-Envelope-Calculations To Choose The Best
Design:
http://highscalability.com/blog/2011/1/26/google-pro-tip-use-back-of-the-envelopecalculations-to-choo.html
[2] System design primer: https://github.com/donnemartin/system-design-primer
[3] Latency Numbers Every Programmer Should Know:
https://colin-scott.github.io/personal_website/research/interactive_latency.html
[4] Amazon Compute Service Level Agreement:
https://aws.amazon.com/compute/sla/
[5] Compute Engine Service Level Agreement (SLA):
https://cloud.google.com/compute/sla
[6] SLA summary for Azure services: https://azure.microsoft.com/enus/support/legal/sla/summary/
```

《系统设计访谈：内幕指南》02粗略估计

![image.png](https://www.choumaomi.com/static/img/b431536c0c316c57eb82805d5a1bd92b.image.png)

## 作者简介
```
About the author:
Alex Xu is an experienced software engineer and entrepreneur(/ˌɑːntrəprəˈnɜːr/). Previously, he worked at
Twitter, Apple, Zynga and Oracle. He received his M.S. from Carnegie Mellon University.
He has a passion for designing and implementing complex systems.
```
```
作者简介：Alex Xu是一位经验丰富的软件工程师和企业家。此前，他曾在Twitter，Apple，Zynga和Oracle工作。他在卡内基梅隆大学获得硕士学位。他对设计和实施复杂系统充满热情。
```



## 目录
```
System Design Interview: An Insider’s Guide
FORWARD
CHAPTER 1: SCALE FROM ZERO TO MILLIONS OF USERS
CHAPTER 2: BACK-OF-THE-ENVELOPE ESTIMATION  /ˈenvəloʊp/
CHAPTER 3: A FRAMEWORK FOR SYSTEM DESIGN INTERVIEWS
CHAPTER 4: DESIGN A RATE LIMITER
CHAPTER 5: DESIGN CONSISTENT HASHING
CHAPTER 6: DESIGN A KEY-VALUE STORE
CHAPTER 7: DESIGN A UNIQUE ID GENERATOR IN DISTRIBUTED SYSTEMS
CHAPTER 8: DESIGN A URL SHORTENER
CHAPTER 9: DESIGN A WEB CRAWLER
CHAPTER 10: DESIGN A NOTIFICATION SYSTEM
CHAPTER 11: DESIGN A NEWS FEED SYSTEM
CHAPTER 12: DESIGN A CHAT SYSTEM
CHAPTER 13: DESIGN A SEARCH AUTOCOMPLETE SYSTEM
CHAPTER 14: DESIGN YOUTUBE
CHAPTER 15: DESIGN GOOGLE DRIVE
CHAPTER 16: THE LEARNING CONTINUES
AFTERWORD
```
```
系统设计访谈：内幕指南
前言 
第 1 章：从零扩展到数百万用户 
第 2 章：粗略估计 
第 3 章：系统设计访谈框架 
第 4 章：设计速率限制器 
第 5 章：设计一致哈希 
第 6 章：设计键值存储 
第 7 章：在分布式系统中设计唯一 ID 生成器 
第 8 章： 设计 URL 缩短器 
第 9 章： 设计网络爬虫 
第 10 章：设计通知系统 
第 11 章：设计新闻源系统 
第 12 章：设计聊天系统 
第 13 章：设计搜索自动完成系统 
第 14 章：设计 YOUTUBE 
第 15 章：设计谷歌云端硬盘 
第 16 章：学习继续 
后记
```


## 前言
```
We are delighted that you have decided to join us in learning the system design interviews.
System design interview questions are the most difficult to tackle among all the technical
interviews. The questions require the interviewees to design an architecture for a software
system, which could be a news feed, Google search, chat system, etc. These questions are
intimidating, and there is no certain pattern to follow. The questions are usually very big
scoped and vague. The processes are open-ended and unclear without a standard or correct
answer.

我们很高兴您决定加入我们，学习系统设计面试。系统设计面试问题是所有技术面试中最难解决的。这些问题要求受访者为软件系统设计一个架构，可以是新闻提要、谷歌搜索、聊天系统等。这些问题令人生畏，没有一定的模式可以遵循。这些问题通常范围非常大且模糊。这些过程是开放式的，不清楚，没有标准或正确的答案

Companies widely adopt system design interviews because the communication and problemsolving skills tested in these interviews are similar to those required by a software engineer’s
daily work. An interviewee is evaluated based on how she analyzes a vague problem and how
she solves the problem step by step. The abilities tested also involve how she explains the
idea, discusses with others, and evaluates /ɪˈvæljueɪt/ and optimizes the system. In English, using “she”
flows better than “he or she” or jumping between the two. To make reading easier, we use the
feminine pronoun throughout this book. No disrespect is intended for male engineers.

公司广泛采用系统设计面试，因为在这些面试中测试的沟通和解决问题的技能与软件工程师日常工作所需的技能相似。根据受访者如何分析一个模糊的问题以及她如何逐步解决问题来评估受访者。测试的能力还涉及她如何解释想法、与他人讨论以及评估和优化系统。在英语中，使用“她”比使用“他或她”或介于两者之间更流畅。为了方便阅读，我们在整本书中使用女性代词。没有不尊重男性工程师的意思。


The system design questions are open-ended. Just like in the real world, there are many
differences and variations in the system. The desired outcome is to come up with an
architecture to achieve system design goals. The discussions could go in different ways
depending on the interviewer. Some interviewers may choose high-level architecture to cover
all aspects; whereas some might choose one or more areas to focus on. Typically, system
requirements, constraints and bottlenecks should be well understood to shape the direction of
both the interviewer and interviewee.

/kən'streint/

系统设计问题是开放式的。就像在现实世界中一样，系统中存在许多差异和变化。期望的结果是提出一个架构来实现系统设计目标。根据面试官的不同，讨论可以以不同的方式进行。一些面试官可能会选择高级架构来涵盖所有方面;而有些人可能会选择一个或多个领域来关注。通常，应充分了解系统要求、约束和瓶颈，以塑造面试官和受访者的方向

The objective of this book is to provide a reliable strategy to approach the system design
questions. The right strategy and knowledge are vital to the success of an interview.
This book provides solid knowledge in building a scalable system. The more knowledge
gained from reading this book, the better you are equipped in solving the system design
questions.

本书的目的是为系统设计提供可靠的策略问题。正确的策略和知识对于面试的成功至关重要。本书提供了构建可扩展系统的扎实知识。知识越多从阅读本书中获得的收获，你对解决系统设计的能力越好问题

This book also provides a step by step framework on how to tackle a system design question.
It provides many examples to illustrate the systematic approach with detailed steps that you
can follow. With constant practice, you will be well-equipped to tackle system design
interview questions.

本书还提供了有关如何解决系统设计问题的分步框架。它提供了许多示例来说明系统方法以及您可以遵循的详细步骤。通过不断的练习，您将能够很好地应对系统设计面试问题。
```

《系统设计访谈：内幕指南》00开篇

《系统设计访谈：内幕指南》01从0到百万用户的扩展

## 1. 官方文档
[官方文档](https://faker.readthedocs.io/en/master/index.html#)
faker用于造数据的，如人名、邮箱等等，常用于测试数据的生成



## 2.简单的安装与使用
```python
# 安装
pip install Faker
 
# 使用
from faker import Faker
fake = Faker(["en_US", "zh_CN"])  # 默认en_US，支持中文本地化zh_CN
print(fake.name())
print(fake.name())
print(fake.name())
```
## 3. 内置测试数据的使用
```python
from faker import Faker
from collections import OrderedDict
# fake = Faker(["en_US", "zh_CN", "ja_JP"])
fake = Faker(["zh_CN"])
# print(fake.name())
# print(fake['en-US'].name())
# print(fake.company())
 
# 1、使用？#自定义规则，随机生成字符串
print(fake.bothify())  # 默认生成字符串格式： 05 RW
print(fake.bothify(text="666????####", letters='我们的家'))  # letters的字符串随机给text的？使用，##默认数字代替，格式如： 我我的我4777
 
# 2、使用^自定义规则，随机生成16进制字符串
print(fake.hexify(text='MAC Address: ^^:^^:^^:^^:^^:^^', upper=True))  # MAC Address: CD:18:FC:9F:B6:49
 
# 3、随机生成 i18n 语言的代码
print(fake.language_code())  # yo
 
# 4、使用？自定义规则，随机生成ASCII字符串
print(fake.lexify(text='Random Identifier: ??????????', letters='我ABCDE'))  # Random Identifier: CBC我DD我ABE
 
# 5、随机生成 i18n 区域设置
print(fake.locale())  # zh_CH
 
# 6、使用#！@%自定义规则，随机生成字符串
print(fake.numerify(text='#  @!! @ %'))  # 1  98  7  （#=[0,9] %=[1,9] !=随机数字或空字符 @=非0数字或空字符）
 
# 7、随机选择对象元素，并随机生成列表
print(fake.random_choices(elements=('a', 'b', 'c', 'd'), length=10))  # ['a', 'c', 'c', 'd', 'a', 'd', 'd', 'b', 'b', 'a']
print(fake.random_choices(elements=OrderedDict([("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ])))  # ['b', 'c', 'a', 'a']
 
# 8、随机生成0-9整数
print(fake.random_digit())  # 0
 
# 9、随机生成1-9整数
print(fake.random_digit_not_null())  # 1
 
# 10、随机生成0-9整数或空值
print(fake.random_digit_or_empty())  # ""
 
# 11、随机选择元素，默认可重复、长度为1
print(fake.random_element(elements=('a', 'b', 'c', 'd')))  # a
print(fake.random_element(elements=OrderedDict([("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ])))  # a
 
# 12、随机选择元素，默认可重复、长度不定
print(fake.random_elements(elements=('a', 'b', 'c', 'd'), unique=False))
print(fake.random_elements(elements=OrderedDict([("a", 0.45), ("b", 0.35), ("c", 0.15), ("d", 0.05), ]), length=20, unique=False))
 
# 13、在指定范围内，随机生成整数
print(fake.random_int(min=0, max=15, step=3))
 
# 14、随机生成ASCII字符串 [a-zA-Z]
print(fake.random_letter())  # 'y'
 
# 15、随机生成ASCII字符串列表 [a-zA-Z]
print(fake.random_letters(length=10))  # ['R', 'N', 'v', 'n', 'A', 'v', 'O', 'p', 'y', 'E']
 
# 16、随机生成ASCII小写字符串
print(fake.random_lowercase_letter())  # c
 
# 17、随机生成整数
'''
如果digits为None(默认值)，则取值范围为1 ~ 9之间的随机整数。
如果fix_len为False(默认值)，则可以生成所有不超过位数的整数。
如果fix_len为True，则只能生成具有精确位数的整数。
'''
print(fake.random_number(fix_len=True))  # 297371
print(fake.random_number(digits=3, fix_len=False))  # 577
 
# 18、随机生成元素不重复的不超出元素数量的列表
print(fake.random_sample(elements=('a', 'b', 'c', 'd', 'f', 'f'), length=6))  # 元素可相同，但length不能大于6
 
# 19、生成大写字母的ASCII字符串
print(fake.random_uppercase_letter())
 
# 20、随机生成接近某个数字的整数
'''
如果le为False(默认值)，则允许生成数量的140%。如果为True，则上限生成为100%。
如果ge为False(默认值)，则允许生成数量减少到60%。如果为True，下限生成上限为100%。
如果提供了最小值的数值，则生成的小于最小值的值将被固定在最小值。
如果为max提供了一个数值，则生成的大于max的值将被固定在max。
如果le和ge都为True，则number的值将自动返回，而不管提供的min和max的值是什么。
'''
print(fake.randomize_nb_elements(number=100))  # 83
print(fake.randomize_nb_elements(number=100, le=True, ge=True, min=80))  # 100
 
# 21、随机生成地址和邮政编号
print(fake.address())
 
# 22、随机生成门牌号
print(fake.building_number())
 
# 23、随机生成城市
print(fake.city())
 
# 24、随机生成特殊市
print(fake.city_suffix())
 
# 25、随机生成国家
print(fake.country())
 
# 26、随机生成国家编号
print(fake.country_code())
 
# 27、生成当前国家
print(fake.current_country())
 
# 28、生成当前国家编号
print(fake.current_country_code())
 
# 29、随机生成邮编
print(fake.postcode())
 
# 30、随机生成街道地址
print(fake.street_address())
 
# 31、随机生成街道名称
print(fake.street_name())
 
# 32、随机生成街道名称后缀
print(fake.street_suffix())
 
# 33、随机生成汽车供应商牌照
print(fake.license_plate())  # 974-XXRA
 
# 34、生成ABA的路由传输号
print(fake.aba())
 
# 35、生成银行提供商的ISO 3166-1 alpha-2国家代码
print(fake.bank_country())  # GB
 
# 36、生成基本银行帐号(BBAN)
print(fake.bban())  # MAAN00447407504564
 
# 37、生成国际银行账号(IBAN)
print(fake.iban())
 
# 38、生成SWIFT代码
print(fake.swift(length=11, primary=True, use_dataset=True))  # SVWBGBNKXXX
 
# 39、生成11位的SWIFT代码
print(fake.swift11(use_dataset=True))  # SVWBGBNKXXX
 
# 40、生成8位的SWIFT代码
print(fake.swift8(use_dataset=True))
 
# 41、生成EAN码
print(fake.ean(prefixes=('45', '49'), length=13))  # 4532804944052
 
# 42、生成EAN13码
print(fake.ean13(prefixes=('45', '49')))  # 4518561138095
 
# 43、生成EAN8码
print(fake.ean8(prefixes=('45', '49')))  # 45877841
 
# 44、生成指定长度的本地化EAN条码
print(fake.localized_ean(length=8))
 
# 45、生成指定长度的本地化EAN13条码
print(fake.localized_ean13())
 
# 46、生成指定长度的本地化EAN8条码
print(fake.localized_ean8())
 
# 47、生成随机颜色值
print(fake.color(hue='red'))
print(fake.color(luminosity='light'))
print(fake.color(hue=(100, 200), color_format='rgb'))
print(fake.color(hue='orange', luminosity='bright'))
print(fake.color(hue=135, luminosity='dark', color_format='hsv'))
print(fake.color(hue=(300, 20), luminosity='random', color_format='hsl'))
 
# 48、随机生成颜色名称
print(fake.color_name())
 
# 49、生成一个十六进制三元组格式的颜色
print(fake.hex_color())
 
# 50、生成一个以逗号分隔的RGB值格式的颜色
print(fake.rgb_color())
 
# 51、用CSS rgb()函数生成颜色格式
print(fake.rgb_css_color())
 
# 52、生成一个网络安全的颜色名称
print(fake.safe_color_name())
 
# 53、生成一个网络安全的颜色格式为十六进制三重
print(fake.safe_hex_color())
 
# 54、公司相关(技术\思想\名称...)
print(fake.bs())  # leverage plug-and-play networks
print(fake.catch_phrase())
print(fake.company())
print(fake.company_suffix())
 
# 55、信用卡相关
print(fake.credit_card_expire())  # 09/28
print(fake.credit_card_full())  # 'Discover\nKatherine Fisher\n6587647593824218 05/26\nCVC: 892\n'
print(fake.credit_card_number())  # 6504876475938248
print(fake.credit_card_provider())  # VISA 19 digit
print(fake.credit_card_security_code())  # 604
 
# 56、货币相关
print(fake.cryptocurrency())
print(fake.cryptocurrency_code())
print(fake.cryptocurrency_name())
print(fake.currency())
print(fake.currency_code())
print(fake.currency_name())
print(fake.currency_symbol())
print(fake.pricetag())
 
# 57、时间相关
print(fake.am_pm())
print(fake.century())
print(fake.date())
print(fake.date_between())
print(fake.date_between_dates())
print(fake.date_object())
print(fake.date_of_birth())
print(fake.date_this_century())
print(fake.date_this_decade())
print(fake.date_this_month())
print(fake.date_this_year())
print(fake.date_time())
print(fake.date_time_ad())
print(fake.date_time_between())
print(fake.date_time_between_dates())
print(fake.date_time_this_century())
print(fake.date_time_this_decade())
print(fake.date_time_this_month())
print(fake.date_time_this_year())
print(fake.day_of_month())
print(fake.day_of_week())
print(fake.future_date())
print(fake.future_datetime())
print(fake.iso8601())
print(fake.month())
print(fake.month_name())
print(fake.past_date())
print(fake.past_datetime())
print(fake.pytimezone())
print(fake.time())
print(fake.time_delta())
print(fake.time_object())
print(fake.time_series())
print(fake.timezone())
print(fake.unix_time())
print(fake.year())
 
# 58、文件相关
print(fake.file_extension())
print(fake.file_extension(category='image'))
print(fake.file_name(category='audio'))
print(fake.file_name(extension='abcdef'))
print(fake.file_name(category='audio', extension='abcdef'))
print(fake.file_path(depth=3))
print(fake.file_path(depth=5, category='video'))
print(fake.file_path(depth=5, category='video', extension='abcdef'))
print(fake.mime_type())
print(fake.mime_type(category='application'))
print(fake.unix_device())
print(fake.unix_device(prefix='mmcblk'))
print(fake.unix_partition())
print(fake.unix_partition(prefix='mmcblk'))
 
# 59、陆地坐标数据
print(fake.coordinate())
print(fake.latitude())
print(fake.latlng())
print(fake.local_latlng())
print(fake.location_on_land())
print(fake.longitude())
 
# 60、因特网相关
print(fake.ascii_company_email()) # 邮箱
print(fake.ascii_email())  # ascii邮箱
print(fake.ascii_free_email())
print(fake.ascii_safe_email())
print(fake.company_email())  # 公司邮箱
print(fake.dga())  # 网址
print(fake.domain_name())  # 网址
print(fake.domain_word())
print(fake.email())
print(fake.free_email())
print(fake.free_email_domain())
print(fake.hostname())
print(fake.http_method())  # http请求方法
print(fake.iana_id())  # IANA注册ID
print(fake.ipv4())  # 随机ip
print(fake.ipv4_network_class())  # 网络类别
print(fake.ipv4_private())
print(fake.ipv4_public())
print(fake.ipv6())
print(fake.mac_address())  # mac地址
print(fake.nic_handle())  # 网卡处理ID
print(fake.nic_handles())
print(fake.port_number())  # 端口号
print(fake.ripe_id())  # 组织ID
print(fake.safe_domain_name()) # 域名
print(fake.safe_email())  # 邮箱
print(fake.slug())  # Django算法
print(fake.tld())  # 域名后缀
print(fake.uri())  # http请求路径
print(fake.uri_extension())
print(fake.uri_page())  # 请求页面名
print(fake.uri_path())  # 资源路径
print(fake.url())  # url
print(fake.user_name())  # 用户名
 
# 61、isbn规则相关
print(fake.isbn10())
print(fake.isbn13())
 
# 62、工作的职位名称
print(fake.job())
 
# 63、文章相关
print(fake.paragraph(nb_sentences=5)) # 生成段落
print(fake.paragraph(nb_sentences=5, variable_nb_sentences=False))
print(fake.paragraph(nb_sentences=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.paragraph(nb_sentences=5, variable_nb_sentences=False, ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.paragraphs(nb=5))  # 生成段落list
print(fake.sentence(nb_words=10))  # 生成一个句子
print(fake.sentence(nb_words=10, variable_nb_words=False))
print(fake.sentences())  # 生成句子list
print(fake.sentences(nb=5))
print(fake.text(max_nb_chars=20))  # 文本字符串
print(fake.text(max_nb_chars=80))
print(fake.text(max_nb_chars=160))
print(fake.text(ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.texts(nb_texts=5))  # 文本字符串列表
print(fake.texts(nb_texts=5, max_nb_chars=50))
print(fake.texts(nb_texts=5, max_nb_chars=50, ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.word())  # 词语字符串
print(fake.word(ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.words())  # 词语列表
print(fake.words(nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']))
print(fake.words(nb=4, ext_word_list=['abc', 'def', 'ghi', 'jkl'], unique=True))
 
# 数据类型相关
print(fake.binary(length=64))  # 创建字节
print(fake.boolean(chance_of_getting_true=75))  # 布尔类型
print(fake.csv(header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True))  # 生成随机的逗号分隔值
print(fake.dsv(data_columns=('{{name}}', '{{address}}'), num_rows=5, delimiter='$'))  # 生成随机分隔符分隔值。
print(fake.fixed_width(data_columns=[(20, 'name'), (3, 'pyint', {'min_value':50, 'max_value':100})], align='right', num_rows=2))  # 生成随机固定宽度值
print(fake.image(size=(16, 16), hue=[90, 270], image_format='ico'))  # 使用Python图像库生成一张图片并在上面绘制一个随机的多边形。如果没有安装它，这个提供程序将无法运行。以给定格式返回表示图像的字节。
print(fake.json(data_columns=[('Name', 'name'), ('Points', 'pyint', {'min_value':50, 'max_value':100})], num_rows=1))  # 生成随机的JSON结构值
print(fake.md5(raw_output=False))  # 生成MD5数据
print(fake.null_boolean())  # 生成空值或布尔值
print(fake.password(length=12))  # 生成密码
print(fake.password(length=40, special_chars=False, upper_case=False))
print(fake.psv(header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True))  # 生成随机的管道分隔值
print(fake.sha1(raw_output=False))  # 生成一个随机的SHA1哈希
print(fake.sha256(raw_output=False))  # 生成一个随机的SHA256哈希
print(fake.tar(uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'))  # 生成包含一个随机有效tar文件的字节对象。
print(fake.tsv(header=('Name', 'Address', 'Favorite Color'), data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'), num_rows=10, include_row_ids=True))  # 生成随机的制表符分隔值
print(fake.uuid4())  # 如果使用可调用对象指定，则生成一个随机UUID4对象并将其转换为另一种类型
print(fake.uuid4(cast_to=None))
print(fake.zip(uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'))  # 生成包含一个随机有效的zip归档文件的bytes对象。
 
# 人相关
print(fake.first_name())  # 人名
print(fake.first_name_female())  # 女名
print(fake.first_name_male())  # 男名
print(fake.first_name_nonbinary())
print(fake.language_name())
print(fake.last_name())
print(fake.last_name_female())
print(fake.last_name_male())
print(fake.last_name_nonbinary())
print(fake.name())
print(fake.name_female())
print(fake.name_male())
print(fake.name_nonbinary())
print(fake.prefix())
print(fake.prefix_female())
print(fake.prefix_male())
print(fake.prefix_nonbinary())
print(fake.suffix())
print(fake.suffix_female())
print(fake.suffix_male())
print(fake.suffix_nonbinary())
 
# 电话号码相关
print(fake.country_calling_code())  # 区号
print(fake.msisdn())
print(fake.phone_number())
 
# 个人信息相关
print(fake.profile())
print(fake.simple_profile())
 
# python相关（python数据类型）
print(fake.pybool())
print(fake.pydecimal())
print(fake.pydict())
print(fake.pyfloat())
print(fake.pyint())
print(fake.pyiterable())
print(fake.pylist())
print(fake.pyset())
print(fake.pystr())
print(fake.pystr_format())
print(fake.pystruct())
print(fake.pytuple())
 
# ssn
print(fake.ssn())  # 865-50-6891
 
# 默认用户代理相关、认证信息相关、通行证相关
print(fake.android_platform_token())
print(fake.chrome())
print(fake.firefox())
print(fake.internet_explorer())
print(fake.ios_platform_token())
print(fake.linux_platform_token())
print(fake.linux_processor())
print(fake.mac_platform_token())
print(fake.mac_processor())
print(fake.opera())
print(fake.safari())
print(fake.user_agent())
print(fake.windows_platform_token())
```

python的faker模块

## 1.使用 Flask-Mail 发送电子邮件



```shell
pipenv install flask-mail 
```
和其他扩展类似，我们实例化 lask-Mail 提供的 Mai 类井传入程序实例 完成初始化，如
下所示：
```python
from flask mail import Mail 
app = Flask( name ) 
mail = Mail (app)
```
### 1.1 配置Flask-Mail
Flask-Mail 通过连 SMTP ( Simple Mail Transfer Protocol 简单邮件传输协议）服务器来发送邮件

需要配置 SMTP 服务器，常见的配置量如下：

| 配置键|说明 |默认值 |
| ----|---- |---- |
|MAIL_SERVER |用于发送邮件的 SMTP 服务器 | localhost|
|MAIL_PORT |发信端口 |25 |
|MAIL_USE_TLS |是否使用STARTTLS |False |
|MAIL_USE_SSL |是否使用 SSL/TLS |False |
|MAIL_USERNAME | 发信服务器的用户名|None |
|MAIL_PASSWORD | 发信服务务器的密码|None |
|MAIL_DEFAULT SENDER | 默认的发信人|None |

对发送的邮件进行加密可以避免邮件在发送过程中被第 方截获和篡改 SSL ( Security 
Socket Layer ，安全套接字层）和 TLS ( Transport Layer Security ，传输层安全）是两种常用的
电子邮件安全协议

1) SSL/TLS 加密：
```
MAIL_USE_SSL = True 
MAIL_PORT = 465
```
3) STARTTLS 加密
```
MAIL_USE_TLS = True 
MAIL_PORT = 587
```

常用电子邮箱服务提供商的 SMT 配置信息如表所示
| 电子邮件服务提供商|MAIL_SERVER(发信服务器) |MAIL_USERNAME |MAIL_PASSWORD |额外步骤 |
| ----|---- |---- |---- |---- |
| Gmail| smtp.gmail.com|邮箱地址 |邮箱密码 | 开启"Allow less secure apps"，本地设置VPN代理|
| QQ邮箱|smtp.qq.com | |邮箱地址| 授权码| 开启SMTP服务并获取授权码|
| 新浪邮箱|smtp.sina.com | |邮箱地址|邮箱密码 | 开启SMTP服务|
| 163邮箱|smtp.163.com | |邮箱地址|授权码 |开启SMTP服务并设置授权码 |


app.py邮件服务器配置
```python
import os 
from flask import Flask 
from flask mail import Mail 
app = Flask(__name__）
app.config.update( 
    MAIL_SERVER= os.getenv('MAIL_SERVER') 
    MAIL_PORT = 587 
    MAIL_USE_TLS = True 
    MAIL_USERNAME = os.getenv('MAIL_USERNAME') 
    MAIL_PASSWORD= os.getenv('MAIL_PASSWORD') 
    MAIL_DEFAULT_SENDER = ('Grey Li ', os.getenv('MAIL_USERNAME')) 
mail = Mail (app)
```


### 1.2 构建邮件数据
```python
from flask_mail import Message
from app import mail
message = Message (subject='Hello, World', recipients=['Zorn <zorn@example.com>'l , body='Across the Great Wal l we can reach every corner in the world ' )

```
### 1.3 发送邮件
```python
mail.send(message)
```

#### 通用发信函数
```python
from flask_mail import Mail,Message
mail = Mail(app)
def send_mail(subject,to,body):
    message = Message(subject,recipients=[to],body=body)
    mail.send(message)
```



## 2.使用事务邮件服务SendGrid

在生产环境下，除了自己安装运行邮件服务器外，更方便的做法是使用事务邮件服务
( Transactional Email Service ），比如 Mailgun (https://www.mailgun.com／）、 Sendgrid ( https://sendgrid.com/）等 这两个邮件服务对免费账户分别提供每月 万封和 3000 封的免费额度，完
全足够测试使用或在小型程序中使用 Mailgun 在注册免费账户时需要填写信用卡，而 Sendgrid
没有这一限制





## 3. 电子邮件进阶实践
### 3.1 提供HTML正文
对于 HTML 邮件正文的编写， 下面是一些常见的“最佳实践”：
* 使用Table布局，而不是Div布局
* 使用行内(inline)样式定义，比如：
```html
<span sty 1 e=” f ont- family:Arial , Helvetica , sans-serif; font - size :l2px ; color : #OOOOOO ; ” >Hello , Email !</span>
```
* 尽量使用比较基础的CSS树形，避免使用快捷树形（比如：background）和定位属性（比如float、position）
* 邮件正文的宽度不应超过600px
* 避免使用JavaScript代码
* 避免使用背景图片
实践
```python
message = Message ( . .. ) 
message.body ='纯文本正'
message.html= '<hl>HTML正文</hl>'
```

### 3.2 使用Jinja2模板组织邮件正文

templates/email/subscribe.txt 纯文本邮件模板

```
Hello { { name } } ,
Thank you f or subscribing Flask Weekly ! 
Enjoy the r eading : ) 
Visit this link to unsubscribe : { { url for ( ' unsubscribe ’, external=True) ) )
```

为了同事支持纯文本格式和HTML格式的邮件正文，每一类邮件我们都需要分别创建HTML和纯文本格式的模板，对应上面的纯文本模板的HTML格式模板如下：
```html
<div style="width:580px;padding:20px;" > 
    <h3>Hello {{name}},</h3> 
    <p>Thank you for subscribing Flask Weekly !</p> 
    <p>Enjoy the reading : ) </p> 
    <small style="color:Jf868e96;”>
        click here to <a href="{{url_for('unsubscribe', external=True )}}" >unsubscribe</a>. 
    </small > 
</div>
```
代码：
```python
from flask import render_template
from flask_mail import Message
def send_subscribe_mail(subject,to,**kwargs):
    message = Message(subject,recipients=[to],sender='Flask Weekly <%s>'&(os.getenv('MAIL_USERNAME')))
    message.body = render_template('emails//subscribe.txt',**kwargs)
    message.html = render_template('emails/subscribe.html',**kwargs)
    mail.send(message)
```
### 3.3 异步发送邮件
```python
from threading import Thread
 def _send_async_mail(app,message):
     with app.app_context():
         mail.send(message)
 def send_mail(subject,to,body):
     message = Message(subject,recipients=[to],body=body)
     thr = Thread(target=_send_async_mail,args=[app,message])
     thr.start()
     return thr
```