yetao
/
awesome-cheatsheets
mirror of https://github.com/skywind3000/awesome-cheatsheets.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

编辑校对

Browse Source 
Markdown/Python代码规范

标点规范

格式以原文为准

纠正一些意义不明的翻译错误

commit@b7302bc 的勘误是有误的，这里原文的说法更正确，不在这里展开讲是为什么了。
pull/40/head
Sy 6 years ago committed by sy
parent e9b76d4873
commit e4ddff47bc
1 changed files with 344 additions and 354 deletions
Show Stats Download Patch File Download Diff File

264
languages/python.md
Unescape View File

@ -4,51 +4,40 @@ Python 速查表中文版
- 本手册是 [Python cheat sheet](http://datasciencefree.com/python.pdf) 的中文翻译版。原作者：Arianne Colton and Sean Chen(data.scientist.info@gmail.com) - 本手册是 [Python cheat sheet](http://datasciencefree.com/python.pdf) 的中文翻译版。原作者：Arianne Colton and Sean Chen(data.scientist.info@gmail.com)
- 编译：[ucasFL](https://github.com/ucasFL) - 编译：[ucasFL](https://github.com/ucasFL)
[惯例](#惯例) ## 目录
[获取帮助](#获取帮助) - [常规](#常规)
- [数值类类型](#数值类类型)
- [数据结构](#数据结构)
- [函数](#函数)
- [控制流](#控制流)
- [面向对象编程](#面向对象编程)
- [常见字符串操作](#常见字符串操作)
- [异常处理](#异常处理)
- [列表、字典以及元组的推导表达式](#列表、字典以及元组的推导表达式)
- [单元测试](#单元测试)
[模块](#模块) ## 常规
[数值类类型](#数值类类型) - Python 对大小写敏感
- Python 的索引从 0 开始
- Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号
[数据结构](#数据结构) ### 获取帮助
[函数](#函数)
[控制流](#控制流)
[面向对象编程](#面向对象编程)
[常见字符串操作](#常见字符串操作)
[异常处理](#异常处理)
[对列表、字典和元组的深入理解](#对列表和字典以及元组的深入理解)
[单元测试](#单元测试)
## 惯例
- Python 对大小写敏感；
- Python 的索引从 0 开始（所有编程语言均如此）；
- Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。
## 获取帮助
- 获取主页帮助：`help()` - 获取主页帮助：`help()`
- 获取函数帮助：`help(str.replace)` - 获取函数帮助：`help(str.replace)`
- 获取模块帮助：`help(re)` - 获取模块帮助：`help(re)`
## 模块 ### 模块(库)
模块亦称库，它只是一个简单地以 `.py` 为后缀的文件。 Python的模块只是一个简单地以 `.py` 为后缀的文件。
- 列出模块内容：`dir(module1)` - 列出模块内容：`dir(module1)`
- 导入模块：`import module` - 导入模块：`import module`
- 调用模块中的函数：`module1.func1()` - 调用模块中的函数：`module1.func1()`
**注：`import` 语句会创建一个新的名字空间，并且在该名字空间内执行 `.py` 文件中的所有语句。如果你想把模块内容导入到当前名字空间，请使用 `from module1 import *` 语句。** > **注**：`import`语句会创建一个新的命名空间(namespace)，并且在该命名空间内执行`.py`文件中的所有语句。如果你想把模块内容导入到当前命名空间，请使用`from module1 import *`语句。
## 数值类类型 ## 数值类类型
@ -56,16 +45,16 @@ Python 速查表中文版
### 六种经常使用的数据类型 ### 六种经常使用的数据类型
1. **int/long**：过大的 `int` 类型会被自动转化为 `long` 类型。 1. **int/long**：过大的 `int` 类型会被自动转化为 `long` 类型
2. **float**：64 位，Python 中没有 `double` 类型。 2. **float**：64 位，Python 中没有 `double` 类型
3. **bool**：真或假。 3. **bool**：真或假
4. **str**：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码； 4. **str**：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码
- 字符串可置于单/双/三引号中； - 字符串可置于单/双/三引号中
- 字符串是字符的序列，因此可以像处理其他序列一样处理字符串； - 字符串是字符的序列，因此可以像处理其他序列一样处理字符串
- 特殊字符可通过 `\` 或者前缀 `r` 实现： - 特殊字符可通过 `\` 或者前缀 `r` 实现：
```python ```python
@ -79,9 +68,9 @@ Python 速查表中文版
str1 = template % (4.88, 'hola', 2) str1 = template % (4.88, 'hola', 2)
``` ```
5. **NoneType(None)**：Python `null` 值（只有 None 对象的一个实例中存在）。 5. **NoneType(None)**：Python “null”值（`None`对象**只**存在一个实例）
- `None` 不是一个保留关键字，而是 **NoneType** 的一个唯一实例。 - `None`不是一个保留关键字，而是`NoneType`的一个唯一实例
- `None`通常是可选函数参数的默认值： - `None`通常是可选函数参数的默认值：
```python ```python
@ -94,10 +83,9 @@ Python 速查表中文版
if variable is None : if variable is None :
``` ```
6. **datetime**：Python 内建的 datetime 模块提供了 `datetime`、`data` 以及 `time` 类型。 6. **datetime**：Python内置的`datetime`模块提供了`datetime`、`data`以及`time`类型。
- `datetime` 组合了存储于 `date` 和 `time` 中的信息。
- `datetime`组合了存储于`date`和`time`中的信息
```python ```python
# 从字符串中创建 datetime # 从字符串中创建 datetime
@ -114,20 +102,21 @@ dt2 = dt1.replace(minute = 0, second = 30)
diff = dt1 - dt2 diff = dt1 - dt2
``` ```
** 注：Python中的不可变对象只有`numbers`,`str`,`tuple`。 可变（Mutable）与不可变（Immutable）关键在于对象初始化之后内存`id`会不会改变** > **注**：
> - `str`、`bool`、`int`和`float`同时也是显式类型转换函数。
> - 除字符串和元组外，Python 中的绝大多数对象都是可变的。
## 数据结构 ## 数据结构
**注：所有的 non-Get 函数调用，比如下面例子中的 `list1.sort()` 都是原地操作，即不会创建新的对象，除非特别声明。** > **注**：所有的“非只读(non-Get)”函数调用，比如下面例子中的`list1.sort()`，除非特别声明，都是原地操作(不会创建新的对象)。
### 元组 ### 元组
元组是 Python 中任何类型的对象的一个一维、固定长度、不可变的序列。 元组是 Python 中任何类型的对象的一个一维、固定长度、**不可变**的序列。
```python ```python
# 创建元组 # 创建元组
tup1 = 4, 5, 6 tup1 = 4, 5, 6
# or
tup1 = (6, 7, 8) tup1 = (6, 7, 8)
# 创建嵌套元组 # 创建嵌套元组
tup1 = (4, 5, 6), (7, 8) tup1 = (4, 5, 6), (7, 8)
@ -139,7 +128,7 @@ tup1 + tup2
a, b, c = tup1 a, b, c = tup1
``` ```
元组应用： **元组应用**：
```python ```python
# 交换两个变量的值 # 交换两个变量的值
@ -148,16 +137,14 @@ a, b = b, a
### 列表 ### 列表
列表是 Python 中任何类型的对象的一个一维、非固定长度、可变（比如内容可以被修改）的序列。 列表是 Python 中任何类型的对象的一个一维、非固定长度、**可变**（比如内容可以被修改）的序列。
```python ```python
# 创建列表 # 创建列表
list1 = [1, 'a', 3] list1 = [1, 'a', 3]
#or
list1 = list(tup1) list1 = list(tup1)
# 连接列表 # 连接列表
list1 + list2 list1 + list2
#or
list1.extend(list2) list1.extend(list2)
# 追加到列表的末尾 # 追加到列表的末尾
list1.append('b') list1.append('b')
@ -167,7 +154,7 @@ list1.insert(PosIndex, 'a')
ValueAtIdx = list1.pop(PosIndex) ValueAtIdx = list1.pop(PosIndex)
# 移除列表中的第一个值, a 必须是列表中第一个值 # 移除列表中的第一个值, a 必须是列表中第一个值
list1.remove('a') list1.remove('a')
#检查成员资格 # 检查成员
3 in list1 => True or False 3 in list1 => True or False
# 对列表进行排序 # 对列表进行排序
list1.sort() list1.sort()
@ -175,14 +162,15 @@ list1.sort()
list1.sort(key=len) # 按长度排序 list1.sort(key=len) # 按长度排序
``` ```
- 使用 + 连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用 `extend()` 是更明智的选择； > - 使用 + 连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用`extend()`是更明智的选择。
- `insert` 和 `append` 相比会有更大的开支（时间/空间）； > - `insert`和`append`相比会有更大的开支（时间/空间）。
- 在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。 > - 在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。
#### 内建的 `bisect` 模块 #### 内置的`bisect`模块
- 对一个排序好的列表进行二分查找或插入； - 对一个排序好的列表进行二分查找或插入
- `bisect.bisect`找到元素在列表中的位置，`bisect.insort`将元素插入到相应位置。用法： - `bisect.bisect`找到元素在列表中的位置，`bisect.insort`将元素插入到相应位置。
- 用法：
```python ```python
import bisect import bisect
@ -193,21 +181,23 @@ bisect.bisect(list1, 5)
bisect.insort(list1, 3.5) bisect.insort(list1, 3.5)
``` ```
**注：`bisect` 模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果。** > **注**：`bisect` 模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果。
### 针对序列类型的切片 ### 针对序列类型的切片
序列类型包括 `str`、`array`、`tuple`、`list` 等。 > 序列类型包括`str`、`array`、`tuple`、`list`等。
用法： 用法：
```python ```python
list1[start:stop] list1[start:stop]
# 如果使用 step # 如果使用 step
list1(start:stop:step) list1[start:stop:step]
``` ```
**注：切片结果包含 `start` 索引，但不包含 `stop` 索引；`start/stop` 索引可以省略，如果省略，则默认为序列从开始到结束，如 `list1 == list1[:]` 。** > **注**：
> - 切片结果包含 `start` 索引，但不包含 `stop` 索引
> - `start/stop` 索引可以省略，如果省略，则默认为序列从开始到结束，如 `list1 == list1[:]` 。
`step` 的应用： `step` 的应用：
@ -218,7 +208,7 @@ list1[::2]
str1[::-1] str1[::-1]
``` ```
### 字典（哈希映射） ### 字典（哈希表）
```python ```python
# 创建字典 # 创建字典
@ -240,24 +230,23 @@ dict1.values()
dict1.update(dict2) # dict1 的值被 dict2 替换 dict1.update(dict2) # dict1 的值被 dict2 替换
``` ```
- 如果键不存在，则会出现 `KeyError Exception` 。 > - 如果键不存在，则会出现 `KeyError Exception` 。
- 当键不存在时，如果 `get()`不提供默认值则会返回 `None` 。 > - 当键不存在时，如果 `get()`不提供默认值则会返回 `None` 。
- 以相同的顺序返回键列表和值列表，但顺序不是特定的，又称极大可能非排序。 > - 以相同的顺序返回键列表和值列表，但顺序不是特定的，也就是说极大可能非排序。
#### 有效字典键类型 #### 有效字典键类型
- 键必须是不可变的，比如标量类型(`int`、`float`、`string`)或者元组（元组中的所有对象也必须是不可变的）。 - 键必须是不可变的，比如标量类型(`int`、`float`、`string`)或者元组（元组中的所有对象也必须是不可变的）。
- 这儿涉及的技术术语是 `hashability`。可以用函数 `hash()`来检查一个对象是否是可哈希的，比如 `hash('This is a string')` 会返回一个哈希值，而 `hash([1,2])` 则会报错（不可哈希）。 - 这儿涉及的技术术语是“可哈希(hashability)”。可以用函数`hash()`来检查一个对象是否是可哈希的，比如 `hash('This is a string')`会返回一个哈希值，而`hash([1,2])`则会报错（不可哈希）。
### 集合 ### 集合
- 一个集合是一些无序且唯一的元素的聚集； - 一个集合是一些**无序**且唯一的元素的聚集；
- 你可以把它看成只有键的字典； - 你可以把它看成只有键的字典；
```python ```python
# 创建集合 # 创建集合
set([3, 6, 3]) set([3, 6, 3])
#or
{3, 6, 3} {3, 6, 3}
# 子集测试 # 子集测试
set1.issubset(set2) set1.issubset(set2)
@ -267,12 +256,11 @@ set1.issuperset(set2)
set1 == set2 set1 == set2
``` ```
#### 集合操作 - **集合操作**
- 并（或）：`set1 | set2`
- 并（又称或）：`set1 | set2` - 交（与）：`set1 & set2`
- 交（又称与）：`set1 & set2`
- 差：`set1 - set2` - 差：`set1 - set2`
- 对称差（又称异或）：`set1 ^ set2` - 对称差（异或）：`set1 ^ set2`
## 函数 ## 函数
@ -284,18 +272,16 @@ Python 的函数参数传递是通过**引用传递**。
def func1(posArg1, keywordArg1=1, ..) def func1(posArg1, keywordArg1=1, ..)
``` ```
**注** > **注**：
> - 关键字参数必须跟在位置参数的后面；
- 关键字参数必须跟在位置参数的后面； > - 默认情况下，Python 不会“延迟求值”，表达式的值会立刻求出来。
- 默认情况下，Python 不会“延迟求值”，表达式的值会立刻求出来。
### 函数调用机制
- 所有函数均位于模块内部作用域。见“模块”部分。 - 函数调用机制
- 在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组 `args` 和一个字典 `kwargs`，然后在函数内部解包。
1. 所有函数均位于模块内部作用域。见“模块”部分。
1. 在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组`args`和一个字典`kwargs`，然后在函数内部解包。
“函数是对象”的常见用法： - “函数是对象”的常见用法：
```python ```python
def func1(ops = [str.strip, user_define_func, ..], ..): def func1(ops = [str.strip, user_define_func, ..], ..):
@ -305,8 +291,8 @@ def func1(ops = [str.strip, user_define_func, ..], ..):
### 返回值 ### 返回值
- 如果函数末尾没有 `return` 语句，则不会返回任何东西。 - 如果函数直到结束都没有`return`语句，则返回`None`。
- 如果有多个返回值则通过一个元组来实现。 - 如果有多个返回值则通过**一个**元组来实现。
```python ```python
return (value1, value2) return (value1, value2)
@ -324,7 +310,7 @@ lambda x : x * 2
# def func1(x) : return x * 2 # def func1(x) : return x * 2
``` ```
- 匿名函数的应用：'curring'，又称利用已存在函数的部分参数来派生新的函数。 - 匿名函数的应用：“柯里化(curring)”，即利用已存在函数的部分参数来派生新的函数。
```python ```python
ma60 = lambda x : pd.rolling_mean(x, 60) ma60 = lambda x : pd.rolling_mean(x, 60)
@ -332,93 +318,93 @@ ma60 = lambda x : pd.rolling_mean(x, 60)
### 一些有用的函数（针对数据结构） ### 一些有用的函数（针对数据结构）
- `enumerate()` 返回一个序列`(i, value)`元组，`i` 是当前 `item` 的索引。 1. **Enumerate** 返回一个序列`(i, value)`元组，`i` 是当前 `item` 的索引。
```python ```python
for i, value in enumerate(collection): for i, value in enumerate(collection):
``` ```
应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。 - 应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。
- `sort()`可以从任意序列中返回一个排序好的序列。 1. **Sorted** 可以从任意序列中返回一个排序好的序列。
```python ```python
sorted([2, 1, 3]) => [1, 2, 3] sorted([2, 1, 3]) => [1, 2, 3]
``` ```
应用： - 应用：
```python ```python
sorted(set('abc bcd')) => [' ', 'a', 'b', 'c', 'd'] sorted(set('abc bcd')) => [' ', 'a', 'b', 'c', 'd']
# 返回一个字符串排序后无重复的字母序列 # 返回一个字符串排序后无重复的字母序列
``` ```
- `zip()`函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。 1. **Zip** 函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。
```python ```python
zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..] zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]
``` ```
1. `zip()`可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。 - `zip()`可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。
应用：多个序列同时迭代： - 应用：多个序列同时迭代：
```python ```python
for i, (a, b) in enumerate(zip(seq1, seq2)): for i, (a, b) in enumerate(zip(seq1, seq2)):
``` ```
2. `unzip`：另一种思考方式是把一些行转化为一些列： - `unzip`：另一种思考方式是把一些行转化为一些列：
```python ```python
seq1, seq2 = unzip(zipOutput) seq1, seq2 = unzip(zipOutput)
``` ```
- `reversed()` 将一个序列的元素以逆序迭代。 1. **Reversed** 将一个序列的元素以逆序迭代。
```python ```python
list(reversed(range(10))) list(reversed(range(10)))
``` ```
**`reversed()` 会返回一个迭代器，`list()` 使之成为一个列表。** > `reversed()` 会返回一个迭代器，`list()` 使之成为一个列表。
## 控制流 ## 控制流
- 用于 `if-else` 条件中的操作符： 1. 用于 `if-else` 条件中的操作符：
```python ```python
#检查两个变量是否是相同的对象 var1 is var2 # 检查两个变量是否是相同的对象
var1 is var2
#检查两个变量是否是不同的对象 var1 is not var2 # 检查两个变量是否是不同的对象
var1 is not var2
#检查两个变量的值是否相等 var1 == var2 # 检查两个变量的值是否相等
var1 == var2
``` ```
**注：Python 中使用 `and`、`or`、`not` 来组合条件，而不是使用 `&&`、`||`、`!` 。** > **注**：Python 中使用 `and`、`or`、`not` 来组合条件，而不是使用 `&&`、`||`、`!` 。
- `for`循环的常见用法： 1. `for`循环的常见用法：
```python ```python
#可迭代对象（list、tuple）或迭代器 for element in iterator: # 可迭代对象（list、tuple）或迭代器
for element in iterator: pass
#如果元素是可以解包的序列
for a, b, c in iterator: for a, b, c in iterator: # 如果元素是可以解包的序列
pass
``` ```
- `pass`：无操作语句，在不需要进行任何操作的块中使用。 1. `pass`：无操作语句，在不需要进行任何操作的块中使用。
- 三元表达式，又称简洁的 `if-else`，基本形式： 1. 三元表达式，又称简洁的 `if-else`，基本形式：
```python ```python
value = true-expr if condition else false-expr value = true-expr if condition else false-expr
``` ```
- Python 中没有 `switch/case` 语句，请使用 `if/elif`。 1. Python 中没有 `switch/case` 语句，请使用 `if/elif`。
## 面向对象编程 ## 面向对象编程
- **对象**是 Python 中所有类型的根。 1. **对象**是 Python 中所有类型的根。
- 万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个类型（type）。对象变量是一个指向变量在内存中位置的指针。 1. 万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个“类型(type)”。对象变量是一个指向变量在内存中位置的指针。
- 所有对象均为**引用计数**。 1. 所有对象均会被**引用计数**。
```python ```python
sys.getrefcount(5) => x sys.getrefcount(5) => x
@ -429,7 +415,7 @@ sys.getrefcount(5)
del(a); sys.getrefcount(5) => x + 1 del(a); sys.getrefcount(5) => x + 1
``` ```
- 类的基本形式： 1. 类的基本形式：
```python ```python
class MyObject(object): class MyObject(object):
@ -437,16 +423,16 @@ class MyObject(object):
def __init__(self, name): def __init__(self, name):
self.name = name self.name = name
def memberFunc1(self, arg1): def memberFunc1(self, arg1):
.. pass
@staticmethod @staticmethod
def classFunc2(arg1): def classFunc2(arg1):
.. pass
obj1 = MyObject('name1') obj1 = MyObject('name1')
obj1.memberFunc1('a') obj1.memberFunc1('a')
MyObject.classFunc2('b') MyObject.classFunc2('b')
``` ```
- 有用的交互式工具： 1. 有用的交互式工具：
```python ```python
dir(variable1) # 列出对象的所有可用方法 dir(variable1) # 列出对象的所有可用方法
@ -477,25 +463,25 @@ month = '12';
month.zfill(2) => '12' month.zfill(2) => '12'
month.zfill(3) => '012' month.zfill(3) => '012'
``` ```
对列表和字典以及元组的深入理解
## 异常处理 ## 异常处理
- 基本形式： 1. 基本形式：
```python ```python
try: try:
.. pass
except ValueError as e: except ValueError as e:
print e print e
except (TypeError, AnotherError): except (TypeError, AnotherError):
.. pass
except: except:
.. pass
finally: finally:
.. # 清理，比如 close db; pass # 清理，比如 close db;
``` ```
- 手动引发异常： 1. 手动引发异常：
```python ```python
raise AssertionError # 断言失败 raise AssertionError # 断言失败
@ -504,18 +490,22 @@ raise SystemExit
raise RuntimeError('错误信息 :..') raise RuntimeError('错误信息 :..')
``` ```
## 对列表和字典以及元组的深入理解 ## 列表、字典以及元组的推导表达式
语法糖（syntactic sugar）会使代码变得更加易读易写。 使代码更加易读易写的语法糖。
### 对列表的理解 1. **列表推导**
将一些元素通过一个简短的语句传入一个过滤器进行过滤和转化，然后可以组成一个新的列表。 - 用一个简练的表达式，通过筛选一个数据集并且转换经过筛选的元素的方式来简明地生成新列表。
- 基本形式：
```python ```python
#基本形式
[expr for val in collection if condition] [expr for val in collection if condition]
#ShortCut ```
等价于
```python
result = [] result = []
for val in collection: for val in collection:
if condition: if condition:
@ -524,21 +514,21 @@ for val in collection:
可以省略过滤条件，只留下表达式。 可以省略过滤条件，只留下表达式。
### 对字典的理解 2. **字典推导**
基本形式： - 基本形式：
```python ```python
{key-expr : value-expr for value in collection if condition} {key-expr : value-expr for value in collection if condition}
``` ```
### 对集合的理解 3. **集合推导**
基本形式：和列表一样，只是应该使用 `()` 而不是 `[]` 。 - 基本形式：和列表推导一样，不过是用 `()` 而不是 `[]` 。
### 嵌套列表 4. **嵌套列表**
基本形式： - 基本形式：
```python ```python
[expr for val in collection for innerVal in val if condition] [expr for val in collection for innerVal in val if condition]
@ -556,6 +546,7 @@ import unittest
```python ```python
class TestSubclass(unittest.TestCase): class TestSubclass(unittest.TestCase):
def test_func(self): def test_func(self):
self.assertEqual(0, 0) self.assertEqual(0, 0)
# 可以通过msg关键字参数提供测试失败时的提示消息 # 可以通过msg关键字参数提供测试失败时的提示消息
@ -595,4 +586,3 @@ def test_database(self):
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
``` ```

Write Preview
Loading…
Cancel
Save