python学习

Word count: 6.1k   |   Reading time≈ 24 min

前言

恰逢机器学习要做实验，肯定选择用python写代码来完成实验，那就快速恶补一下Python基本知识，一些语法之类的，就简单做些笔记，一份面向已有编程基础的速成笔记，主要记录一些Python3基础语法不同之处所在，简单的、相似的就略去了。

Python3 基础语法

行和缩进

首先，我们需要注意的是缩进在Python中非常重要，因为Python不使用我们习惯的{}来划分逻辑块，有些痛苦，刚开始看起来比较费劲，但其目的是为了简明，就举个例子。

1
2
3
4
5
6
7
8
9
10
11
12
a, b = 10, 3
if a > 1:
    print("a>1")
    if b > 1:
        print("b>1")
    else:
        print("b<=1")
elif a == 1:
    print("a=1")
else:
    print("a<1")
print(a)

等价的C语言代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int a = 10;
int b = 3;
if(a>1){
	printf("a>1");
	if(b>1){
		printf("b>1");
	}
	else{
		printf("b<=1");
	}
}
else if(a==1){
	printf("a=1");
}
else{
	printf("a<1");
}
printf("%d",a);

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，一般建议在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 此外还要注意不能混用。

我们还可以注意到其不用以 ; 结束，可谓’;’遗忘患者的福音了，其一般用新行作为语句的结束符。

既然Python不用;结束，且行和缩进这么重要，那么多行语句该怎么办呢？可以用多行连接符\进行连接，但存在 [], {} 或 () 括号就不需要使用多行连接符。

1
2
3
4
5
c = 1 + \
    2 + \
    3
members = ["Hans", "Tom", "Jerry",
          "Stephen"]

或者是同一行显示多条语句，语句之间可以用;来分割，如下例。

1
x = 'runnoob'; y = "john"; print(x,y)

此外，空行也较为重要。

  • 空行分隔函数或类的方法，表示一段新的代码的开始。
  • 空行分隔类和函数入口，以突出函数入口的开始。
  • 不是Python语法的一部分，书写时不插入空行，也不会出错。
  • 空行分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

输入和输出

举例说明

1
a = input("请输入a的值:")  # 暂且不考虑变量a的类型，默认为int,后面再细讲。

等价C语言代码

1
2
3
int a;
printf("请输入a的值");
scanf("%d",&a);

print表示输出，但其默认换行，若要实现不换行需要在变量末尾加上逗号 ,来实现，或是在变量末尾加上 end=""。

1
2
3
4
5
6
7
print(a)
print(b)  # 换行输出
print(a,b) # 不换行输出

# 不换行输出
print( a, end=" " )
print( b, end=" " )

标识符

  • 第一个字符必须是字母表中字母或下划线 _。
  • 标识符的其他的部分由字母、数字和下划线组成。
  • 标识符对大小写敏感
  • Python3中可以用中文作为变量名，非 ASCII 标识符也是允许的了

Python保留字

保留字就表示其有特殊用途，不能用作标识符，像是变量名，类名之类的，就比如说java语言中的if和class一样。

and exec not
assert finally or
break for pass
class from print
continue global raise
def if return
del import try
elif in while
else is with
except lambda yield

注释

Python注释并不是用我们熟悉的 // 而是用# 注释，且#后面需要空一格进行注释；或者是用'''（三个单引号）或 """(三个双引号)进行多行注释。

import 和from…impor

Python方便的一点就是有大量的标准库可供调用。就要用相应语句进行导入库。

  • import表示将整个模块导入，格式：import somemodule。

  • import...as...可将导入的模块换个别名，格式：import time as abc,在引用时可用别名。

  • from...import表示从某个模块中导入某个函数，格式：from somemodule import somefunction，还可以同时从一个模块导入多个函数，格式：from somemodule import firstfunc, secondfunc, thirdfunc。

  • 将某个模块中的全部函数导入，格式： from somemodule import *

  • import和from...import在函数引用时还有区别，如下例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # 使用import，
    import time
    time.sleep(1)

    # 使用from...import
    from time import sleep
    sleep(1)

    #使用import...as
    import time as TIME
    TIME.sleep(1)

变量类型

变量赋值

依然用=进行变量赋值

允许为多个变量同时赋值

1
2
3
4
5
6
7
a = b = c = 1   # 为a,b,c三个整型变量赋值为1
a, b, c = 1, 2.1, "john" 
'''
为a整型变量赋值为1
b浮点类型赋值为2.1
c字符串类型赋值为“john
'''

标准数据类型

Python3有六个标准的数据类型：

  • Numbers（数字）
  • String（字符串）
  • List（列表）
  • Tuple （元组）
  • Set（集合）
  • Dictionary（字典）

其中要区分可变数据类型与不可变数据类型：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

关于不可变数据类型和可变数据类型，详情可见前面博客有关不可见数据类型的文章。

Python 与 C 和 Java有不同，即python变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的（前者静态编译，后者动态编译），变量的类型由赋予它的值来决定。

数字

Python支持四种不同的数字类型，用于存储数值，是不可改变的数据类型。

不可变数据类型，若改变数字数据类型的值，将重新分配内存空间。

  • int（整型），表示长整型，没有long，可充当long使用。
  • bool（布尔）
  • float（浮点型）
  • complex（复数），可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

不需要声明变量类型，其会自动识别，或者可以使用内置的 type() 函数可以用来查询变量所指的对象类型。

1
2
3
4
5
6
7
a = 1 # int型
b = 1.1 # 浮点型
c = 1 + 2j # 复数
d = complex(1, 2) # 复数：1为实部，2为虚部

print(type(a), type(b), type(c), type(d)) 
# <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断：

1
2
a = 11
print(isinstance(a, int)) # True

isinstance 和 type 的区别在于：

  • type 是用于求一个未知数据类型对象。
  • isinstance 是用于判断一个对象是否是已知类型。

  • type()不会认为子类是一种父类类型。

  • isinstance()会认为子类是一种父类类型，例如，在Python3中，bool是int的子类，此外，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

  • 可以用 isinstance 判断子类对象是否继承于父类，type 不行。

    1
    2
    3
    4
    5
    6
    7
    issubclass(bool, int)  # True
    True == 1  # True
    False == 0  # True
    True + 1  # 2
    False + 1  # 1
    1 is True # False
    0 is False # False

当你指定一个值时，Number 对象就会被创建，也可以使用del语句删除一些对象的引用。

1
2
3
a = 1
b = 2  # Number对象被创建
del a, b  # 删除对象引用

此外：

  • 一个变量可以通过赋值指向不同类型的对象。
  • 在混合计算时，Python会把整型转换成为浮点数。
数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

  • int(x) 将x转换为一个整数。
  • float(x) 将x转换到一个浮点数。
  • complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
  • complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

字符串

字符串表示格式：可以用'或"括起来，但前后要一致，前面用单引号，后面也用单引号。使用反斜杠 \转义特殊字符。

其字符列表有两种取值顺序。

  • 从左到右索引默认0开始的，最大范围是字符串长度少1
  • 从右到左索引默认-1开始的，最大范围是字符串开头
H e l l o
0 1 2 3 4
-5 -4 -3 -2 -1

一些其他操作：

  • 从字符在截取一段字符，采用[头下标:尾下标]来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾，此外它是“左闭右开”的形式，截取的子串包含头下标的字符，但不包含尾下标的字符；

  • *表示重复，+表示连接；

  • P字符串截取还可以有第三个参数，其表示的截取的步长，在索引 1 到索引 4 的区间内并设置为步长为 2（间隔1位）来截取字符串

  • Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    str = "Hello World!"

    print(str)            # 输出完整的字符串
    print(str[4])         # 输出字符串中第5个字符
    print(str[:5])        # 输出字符串中第1个至第5个之间的子串
    print(str[2:5])       # 输出字符串中第3个至第5个之间的子串
    print(str[3:])        # 输出字符串中第4个开始的子串
    print(str * 2)        # 输出字符串两次
    print(str + " test")  # 输出连接的字符串
    print(str[0:5:2])     # 从第1个字符开始至第5个字符间隔1位截取子串
    print(str[0:5:3])     # 从第1个字符开始至第5个字符间隔2位截取子串 
    print("Hello\nWorld")
    print(r"Hello\nWorld")

    '''
    输出结果：
    Hello World!
    o
    Hello
    llo
    lo World!
    Hello World!Hello World!
    Hello World! test
    Hlo
    Hl
    Hello
    World
    Hello\nWorld
    '''

此外：与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = ‘m’会导致错误。

列表

列表主要作用是：其可以完成大多数集合类的数据结构实现，它支持字符，数字，字符串甚至可以包含列表（即嵌套），即列表是个有序的大集合，里面可以存放字符串，数字，字符，甚至嵌套个列表，用[]标识。下面举例说明。

1
lisT = ["list", 'l', 1, 1.1, 1 + 2j, [1, 1.1, 1.2]]

同字符串类型一样，其也可以用切割操作，此外，其索引取值方式也同字符串类似，列表被截取后返回一个包含所需元素的新列表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
list1 = ['list', 't', 2.23, 'john', 1111, 1 + 2j]
tinylist = [123, 'john']

print(list1)  # 输出完整列表
print(list1[0])  # 输出列表的第一个元素
print(list1[1:3])  # 输出第二个至第三个元素
print(list1[2:])  # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2)  # 输出列表两次
print(list1 + tinylist)  # 打印组合的列表
'''
['list', 't', 2.23, 'john', 1111, (1+2j)]
list
['t', 2.23]
[2.23, 'john', 1111, (1+2j)]
[123, 'john', 123, 'john']
['list', 't', 2.23, 'john', 1111, (1+2j), 123, 'john']
'''

与Python字符串不一样的是，列表中的元素是可以改变的：

1
2
3
4
5
6
a = [1, 2, 3, 4, 5, 6]
a[0] = 9
print(a)
'''
[9, 2, 3, 4, 5, 6]
'''

List 内置了有很多方法，例如 append()、pop()。用时再进行查询。

同字符串一样，列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数，则表示逆向读取。

元组

元组是另一个数据类型，类似于 List（列表）。

元组用 ()标识。内部元素用逗号隔开。但是元组不能二次赋值，修改元组元素的值，赋完初值后，其就相当于只读列表。

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
tuple1 = ['list', 't', 2.23, 'john', 1111, 1 + 2j]
tinytuple = [123, 'john']

print(tuple1)  # 输出完整元组
print(tuple1[0])  # 输出元组的第一个元素
print(tuple1[1:3])  # 输出第二个至第三个元素
print(tuple1[2:])  # 输出从第三个开始至元组末尾的所有元素
print(tinytuple * 2)  # 输出元组两次
print(tuple1 + tinytuple)  # 打印组合的元组
'''
['list', 't', 2.23, 'john', 1111, (1+2j)]
list
['t', 2.23]
[2.23, 'john', 1111, (1+2j)]
[123, 'john', 123, 'john']
['list', 't', 2.23, 'john', 1111, (1+2j), 123, 'john']
'''

tuple1[2] = 0.13    # 元组中是非法应用
list1[2] = 1.13     # 列表中是合法操作

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

1
2
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

此外，string、list 和 tuple 都属于 sequence（序列）。

集合

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

  • 基本功能：成员关系测试、删除重复元素。

  • 创建集合：大括号{}、或是Set()函数

  • 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

  • 特点：无序的，不支持索引，且元素具有唯一性，一个集合中没有重复元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
sites = {'Google', 'Taobao', 'Douban', 'Facebook', 'Zhihu', 'Baidu', 'Taobao'}
print(sites)   # 乱序输出集合，重复的元素被自动去掉
'''
{'Runoob', 'Baidu', 'Taobao', 'Google', 'Zhihu', 'Facebook'}
'''

# 成员测试
if 'Douban' in sites :
    print('Douban 在集合中')
else :
    print('Douban 不在集合中')   
'''
Douban 在集合中
'''

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素
'''
{'b', 'c', 'd', 'r', 'a'}
{'d', 'b', 'r'}
{'b', 'm', 'z', 'c', 'd', 'r', 'a', 'l'}
{'c', 'a'}
{'d', 'b', 'm', 'r', 'z', 'l'}
'''

字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来访问存取的，而不是通过下标访问存取，有点类似于java中的Map。

字典用”{ }”标识。字典由索引(key)和它对应的值value组成，用:来区分键和值，1 : 123中，1表示键，123为整型值。

  • 键(key)必须使用不可变类型。
  • 在同一个字典中，键(key)必须是唯一的，若插入重复的键，但对应的值改变，则会覆盖原来的键值对。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

'''
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'runoob'}
['dept', 'code', 'name']
['sales', 6734, 'runoob']
'''

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。用时再进行查询。

在 python 中，类型属于对象，变量是没有类型的，如a = 10,10是整型的对象，a是一个变量，若要给a重新赋值，则a=1.1，则其值1.1为浮点型的对象，a依旧是一个变量，没有类型，只是这些对象的引用（一个指针）。

运算符

算术运算符

运算符 功能
+ 加法
- 减法或负数
* 两个数相乘或是返回一个被重复若干次的字符串
/ 除法
% 取余
x**y x的y次幂
// 整除（向下取整），例9//2=4

注：Python中没有++和--。

位、比较、逻辑运算符

位、比较、逻辑运算符无不同，与C相同。

比较：==, <=,>=,<,>,!=。

位：&, |, ^(异或), ~(取反), <<, >>。

逻辑：and, or, not。

赋值运算符

运算符 功能
+= c += a 等效于 c = c + a
-= c -= a 等效于 c = c - a
*= c *= a 等效于 c = c * a
/= c /= a 等效于 c = c / a
%= c %= a 等效于 c = c % a
**= c **= a 等效于 c = c ** a
//= c //= a 等效于 c = c // a
:= 海象运算符，可在表达式内部为变量赋值，if (n := len(a)) > 10:

成员运算符

成员运算符，顾名思义，就是判断一个元素是不是一个数据结构的成员。

运算符 功能 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

身份运算符用于比较两个对象的存储地址。

运算符 功能 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 **id(a) != id(b)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

运算符优先级

条件控制

与C语言无太大差别。格式如下：

1
2
3
4
5
6
if condition1:
    statement1
elif condition2:
    statement2
else:
    statement3

注：

  • 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
  • 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
  • 在Python中没有switch – case语句。

循环语句

while循环

格式：

1
2
while condition：
    statements

while循环使用else语句：

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

条件语句为 true 则执行 statement语句块，如果为 false，则执行 additional_statement。

语法格式如下：

1
2
3
4
while condition:
    statement
else:
    additional_statement

for循环

格式：

1
2
3
4
for <variable> in <sequence>:
    <statements>
else:
    <statements>

注：循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

break、continue和pass

break 跳出 for 和 while 的循环体，从当前位置跳出循环，不再进入循环。

continue 跳过当前循环块中的剩余语句，即不执行循环的剩余部分，然后继续进行下一轮循环。

pass是空语句，是为了保持程序结构的完整性，不做任何事情，一般用做占位语句。

函数

定义

  • 以 def 关键词开头，后接函数标识符名称和圆括号 **()**。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
  • 函数内容以冒号 : 起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

格式：

1
2
def 函数名（参数列表）:
    函数体

函数调用可直接调用。

传参

当传入参数为不可变对象实例时，在函数内修改形参的值，但不会改变实参的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def change(a):
    print(id(a))
    a = 10
    print(id(a))

a = 1
print(id(a))
change(a)
print(a)
'''
140733572060848
140733572060848
140733572061136
1
'''

当传入参数为可变对象实例时，在函数内修改了形参的值，则实参的值会随着改变。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def change(myList):
    print(id(myList))
    myList[0] = 2
    print(id(myList))

myList = [1, 2, 3, 4, 5]
print(id(myList))
change(myList)
print(myList)
'''
2023267500096
2023267500096
2023267500096
[2, 2, 3, 4, 5]
'''

参数

可使用的正式参数类型：

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。就是我们在C语言中传参时须遵守的那些规则。

关键字参数

​ 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

​ 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def printinfo(name, age=35):
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    return


# 调用printinfo函数
printinfo(age=50, name="Tom")  # 自动用参数名匹配参数值
printinfo(name="Tom")  # 使用默认参数值
'''
名字:  Tom
年龄:  50
名字:  Tom
年龄:  35
'''

不定长参数

  • 加了星号*的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

  • 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def printinfo( arg1, *vartuple ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       for var in vartuple:
          print (var)
       return
     
    # 调用printinfo 函数
    printinfo( 10 )
    printinfo( 70, 60, 50 )

  • 加了两个星号 ** 的参数会以字典的形式导入。

    1
    2
    3
    4
    5
    6
    7
    8
    def printinfo( arg1, **vardict ):
       "打印任何传入的参数"
       print ("输出: ")
       print (arg1)
       print (vardict)
     
    # 调用printinfo 函数
    printinfo(1, a=2,b=3)

  • 声明函数时，参数中星号 * 可以单独出现，星号 *后的参数必须用关键字传入

    1
    2
    3
    4
    def f(a, b, *, c):
        return a + b + c

    f(10, 20, c=20)

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

1
2
3
4
5
6
7
8
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    
f(10, 20, 30, d=40, e=50, f=60)  # 正确的传参方式

# 错误的传参方式
f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

函数返回值

函数返回值的注意事项: 不同于 C 语言，Python 函数可以返回多个值，多个值以元组的方式返回

1
2
3
4
5
def fun(a,b):    
    "返回多个值，结果以元组形式表示"
    return a,b,a+b
print(fun(1,2))
# 输出结果为(1, 2, 3)

匿名函数

  • 使用lambda 来创建匿名函数。
  • 匿名表示：不使用 def 语句这样标准的形式定义一个函数。
  • lambda 只是一个表达式，函数体比 def 简单很多，只能封装有限的逻辑进去
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
  • 不等同于C或C++的内联函数

格式：

1
lambda [arg1 [,arg2,.....argn]]:expression
  • Copyright： Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.
  • Copyrights © 2019-2022 1nvisble
  • Visitors: | Views:

请我喝杯咖啡吧~

支付宝
微信