Python语法基础之. Task01 变量、运算符与数据类型(1/17)

秒速五厘米 2023-06-09 10:24 2阅读 0赞

### Python基础——Task01.变量、运算符与数据类型 ###

*   *  写在前面
     *  1. 变量
     *  2. 运算符
     *   *  2.1 Python算术运算符
         *  2.2 Python比较运算符
         *  2.3 Python赋值运算符
         *  2.4 Python位运算符
         *  2.5 Python逻辑运算符
         *  2.6 Python成员运算符
         *  2.7 Python身份运算符
     *  3. 数据类型
     *   *  3.1 Number（数字）
         *  3.2 String（字符串）
         *  3.3 List（列表）
         *  3.4 Tuple（元组）
         *  3.5 Set（集合）
         *  3.6 Dictionary（字典）
         *  补充：Python数据类型转换
     *  写在最后

## 写在前面 ##

[Python简介\_廖雪峰的博客][Python]  
[Python简介\_菜鸟博客][Python 1]

Python语法部分规范：

*  以\#开头的语句是注释
 *  以:结束时，缩进的语句是为代码块应该始终坚持
 *  使用4个空格的缩进

**编码**  
默认情况下，Python 3源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码。

**标识符**

*  第一个字符必须是字母表中字母或下划线’\_’。
 *  标识符的其他的部分有字母、数字和下划线组成。
 *  标识符对大小写敏感。  
    注：在Python 3中，非-ASCII 标识符也是被允许的。

**Python保留字**  
保留字即关键字，我们不能把它们用作任何标识符名称。Python的标准库提供了一个keyword module，可以输出当前版本的所有关键字：

>>> import keyword
    >>> keyword.kwlist
    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

**注释**  
Python中允许两种注释格式

*  单行注释

a = 3  # 将整型3赋值给变量a

*  多行注释（单引号形式 & 双引号形式）

'''
    这是多行注释，用三个单引号
    这是多行注释，用三个单引号 
    '''
    """
    这是多行注释，用三个双引号
    这是多行注释，用三个双引号
    """

**行与缩进**  
python最具特色的就是使用缩进来表示代码块，不需要使用大括号 \{\} 。  
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

**多行语句的换行**  
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
            item_two + \
            item_three

特别的：在 \[\], \{\}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
            'item_four', 'item_five']

## 1. 变量 ##

变量的概念和代数系统中变量是一致的。只不过，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是`大小写英文`、`数字`和`_`的组合，且`不能用数字开头`，比如：  
`abc`、`a1b2c3`、`_abc` 都是合法的；  
`123abc`、`123_` 都是非法的；

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，等号`=`是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

应该注意的是，这种类型不固定的语言叫做**动态语言**  
事实上，在赋值语句中，诸如：a = ‘ABC123’，python编译器分两步完成：

*  1.在内存中创建了一个`‘ABC123‘`的字符串
 *  2.在内存中创建了一个名为`a`的变量，并把它指向`’ABC123’`

这就意味着：当一个变量a赋值给另外一个变量b时，实际上是把变量b指向变量a所指向的数据。

**多个变量赋值**  
两种情况：

*  `a = b = c = 1` // 同时为多个变量赋值
 *  `a, b, c = 1, 2, "abc"` // 为多个对象指定多个变量

注：常量与变量对立——常量：一经创建赋值后，不能修改的量；在Python中，通常用全部大写的变量名表示常量。

## 2. 运算符 ##

Python语言支持以下类型的运算符:

*  算术运算符
 *  比较（关系）运算符
 *  赋值运算符
 *  位运算符
 *  逻辑运算符
 *  成员运算符
 *  身份运算符

### 2.1 Python算术运算符 ###

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>加 - 两个对象相加</td> 
   <td>a + b 输出结果 31</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减 - 得到负数或是一个数减去另一个数</td> 
   <td>a - b 输出结果 -11</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘 - 两个数相乘或是返回一个被重复若干次的字符串</td> 
   <td>a * b 输出结果 210</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除 - x 除以 y</td> 
   <td>b / a 输出结果 2.1</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取模 - 返回除法的余数</td> 
   <td>b % a 输出结果 1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂 - 返回x的y次幂</td> 
   <td>a**b 为10的21次方</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>取整除 - 向下取接近除数的整数 </td> 
   <td> &gt;&gt;&gt; 9//2 4 &gt;&gt;&gt; -9//2 -5</td> 
  </tr> 
 </tbody> 
</table>

### 2.2 Python比较运算符 ###

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于 - 比较对象是否相等</td> 
   <td>(a == b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于 - 比较两个对象是否不相等</td> 
   <td>(a != b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于 - 返回x是否大于y</td> 
   <td>(a &gt; b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。</td> 
   <td>(a &lt; b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于 - 返回x是否大于等于y。</td> 
   <td>(a &gt;= b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于 - 返回x是否小于等于y。</td> 
   <td>(a &lt;= b) 返回 True。</td> 
  </tr> 
 </tbody> 
</table>

### 2.3 Python赋值运算符 ###

以下假设变量a为10，变量b为20：

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>=</td> 
   <td>简单的赋值运算符</td> 
   <td>c = a + b 将 a + b 的运算结果赋值为 c</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等效于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等效于 c = c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等效于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等效于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模赋值运算符</td> 
   <td>c %= a 等效于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>c **= a 等效于 c = c ** a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整除赋值运算符</td> 
   <td>c //= a 等效于 c = c // a</td> 
  </tr> 
 </tbody> 
</table>

### 2.4 Python位运算符 ###

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：  
下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100
    
    b = 0000 1101
    
    -----------------
    
    a&b = 0000 1100
    
    a|b = 0011 1101
    
    a^b = 0011 0001
    
    ~a  = 1100 0011

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0</td> 
   <td>(a &amp; b) 输出结果 12 ，二进制解释： 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。</td> 
   <td>(a | b) 输出结果 61 ，二进制解释： 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>按位异或运算符：当两对应的二进位相异时，结果为1</td> 
   <td>(a ^ b) 输出结果 49 ，二进制解释： 0011 0001</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1</td> 
   <td>(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移动运算符：运算数的各二进位全部左移若干位，由"&lt;&lt;"右边的数指定移动的位数，高位丢弃，低位补0。</td> 
   <td>a &lt;&lt; 2 输出结果 240 ，二进制解释： 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移动运算符：把"&gt;&gt;"左边的运算数的各二进位全部右移若干位，"&gt;&gt;"右边的数指定移动的位数</td> 
   <td>a &gt;&gt; 2 输出结果 15 ，二进制解释： 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

### 2.5 Python逻辑运算符 ###

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>逻辑表达式</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。</td> 
   <td>(a and b) 返回 20。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。</td> 
   <td>(a or b) 返回 10。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not(a and b) 返回 False</td> 
  </tr> 
 </tbody> 
</table>

### 2.6 Python成员运算符 ###

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>如果在指定的序列中找到值返回 True，否则返回 False。</td> 
   <td>x 在 y 序列中 , 如果 x 在 y 序列中返回 True。</td> 
  </tr> 
  <tr> 
   <td>not in</td> 
   <td>如果在指定的序列中没有找到值返回 True，否则返回 False。</td> 
   <td>x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。</td> 
  </tr> 
 </tbody> 
</table>

### 2.7 Python身份运算符 ###

身份运算符用于比较两个对象的存储单元

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
   <td>实例</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>is 是判断两个标识符是不是引用自一个对象</td> 
   <td>x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>is not 是判断两个标识符是不是引用自不同对象</td> 
   <td>x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

**特别的，Python运算符优先级，下表格列出了**`从最高到最低优先级的所有运算符`：

<table> 
 <tbody> 
  <tr> 
   <td>运算符</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>指数 (最高优先级)</td> 
  </tr> 
  <tr> 
   <td>~ + -</td> 
   <td>按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)</td> 
  </tr> 
  <tr> 
   <td>* / % //</td> 
   <td>乘，除，取模和取整除</td> 
  </tr> 
  <tr> 
   <td>+ -</td> 
   <td>加法减法</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt; &lt;&lt;</td> 
   <td>右移，左移运算符</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>位 'AND'</td> 
  </tr> 
  <tr> 
   <td>^ |</td> 
   <td>位运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;= &lt; &gt; &gt;=</td> 
   <td>比较运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt; == !=</td> 
   <td>等于运算符</td> 
  </tr> 
  <tr> 
   <td>= %= /= //= -= += *= **=</td> 
   <td>赋值运算符</td> 
  </tr> 
  <tr> 
   <td>is is not</td> 
   <td>身份运算符</td> 
  </tr> 
  <tr> 
   <td>in not in</td> 
   <td>成员运算符</td> 
  </tr> 
  <tr> 
   <td>not and or</td> 
   <td>逻辑运算符</td> 
  </tr> 
 </tbody> 
</table>

## 3. 数据类型 ##

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

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

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

*  不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
 *  可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

### 3.1 Number（数字） ###

Python3 支持 int、float、bool、complex（复数）  
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long  
像大多数语言一样，数值类型的赋值和计算都是很直观的  
内置的 type() 函数可以用来查询变量所指的对象类型  
`type(a)`  
此外还可以用 isinstance 来判断：  
`isinstance(a, int)`

isinstance 和 type 的区别在于：

*  type()不会认为子类是一种父类类型
 *  isinstance()会认为子类是一种父类类型

当你指定一个值时，Number 对象就会被创建：

var1 = 1
    var2 = 10

您也可以使用del语句删除一些对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

可以通过使用del语句删除单个或多个对象。例如：

del var
    del var_a, var_b

注意：

1.  Python可以同时为多个变量赋值，如a, b = 1, 2。
2.  一个变量可以通过赋值指向不同类型的对象。
3.  数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4.  在混合计算时，Python会把整型转换成为浮点数。
5.  Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

### 3.2 String（字符串） ###

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \\ 转义特殊字符。  
字符串的截取的语法格式如下：

> 变量\[头下标:尾下标\]

*  索引值以 0 为开始值，-1 为从末尾的开始位置
 *  加号 + 是字符串的连接符， 星号 \* 表示复制当前字符串，紧跟的数字为复制的次数
 *  Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
 *  另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行
 *  与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word\[0\] = 'm’会导致错误

### 3.3 List（列表） ###

List（列表） 是 Python 中使用最频繁的数据类型。  
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。  
列表是写在方括号 \[\] 之间、用逗号分隔开的元素列表。  
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

> 变量\[头下标:尾下标\]

*  加号 + 是列表连接运算符，星号 \* 是重复操作
 *  与Python字符串不一样的是，`列表中的元素是可以改变的`
 *  List 内置了有很多方法，例如 append()、pop() 等等

注意：

1.  List写在方括号之间，元素用逗号隔开
2.  和字符串一样，list可以被索引和切片
3.  List可以使用+操作符进行拼接。
4.  List中的元素是可以改变的。
5.  **Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串；如果第三个参数为负数表示逆向读取**

### 3.4 Tuple（元组） ###

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 `()`里，元素之间用逗号隔开。元组中的元素类型也可以不相同。

> 变量(头下标:尾下标)

*  元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取
 *  可以把字符串看作一种特殊的元组
 *  虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
 *  构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则

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

注意：

1.  string、list 和 tuple 都属于 sequence（序列）
2.  与字符串一样，元组的元素不能修改
3.  元组也可以被索引和切片，方法一样
4.  注意构造包含 0 或 1 个元素的元组的特殊语法规则
5.  元组也可以使用+操作符进行拼接

### 3.5 Set（集合） ###

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。  
基本功能是进行成员关系测试和删除重复元素。  
可以使用大括号`{ }`或者 `set()`函数创建集合，注意：创建一个空集合必须用 `set()`而不是`{ }`，因为`{ }`是用来创建一个空字典。  
创建格式：

parame = {
        value01,value02,...}
    or
    set(value)

### 3.6 Dictionary（字典） ###

字典（dictionary）是Python中另一个非常有用的内置数据类型。  
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。  
字典是一种映射类型，字典用 `{ }`标识，它是一个无序的 `键(key) : 值(value)`的集合。  
***键(key)必须使用不可变类型***  
***在同一个字典中，键(key)必须是唯一的***

*  构造函数 dict() 可以直接从键值对序列中构建字典
 *  另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等

注意：

1.  字典是一种映射类型，它的元素是键值对
2.  字典的关键字必须为不可变类型，且不能重复
3.  创建空字典使用 `{ }`。

### 补充：Python数据类型转换 ###

通过几个内置的函数可以执行数据类型之间的转换：这些函数返回一个新的对象，表示转换的值。

<table> 
 <tbody> 
  <tr> 
   <td>函数</td> 
   <td>描述</td> 
  </tr> 
  <tr> 
   <td>int(x [,base])</td> 
   <td>将x转换为一个整数</td> 
  </tr> 
  <tr> 
   <td>float(x)</td> 
   <td>将x转换到一个浮点数</td> 
  </tr> 
  <tr> 
   <td>complex(real [,imag])</td> 
   <td>创建一个复数</td> 
  </tr> 
  <tr> 
   <td>str(x)</td> 
   <td>将对象 x 转换为字符串</td> 
  </tr> 
  <tr> 
   <td>repr(x)</td> 
   <td>将对象 x 转换为表达式字符串</td> 
  </tr> 
  <tr> 
   <td>eval(str)</td> 
   <td>用来计算在字符串中的有效Python表达式,并返回一个对象</td> 
  </tr> 
  <tr> 
   <td>tuple(s)</td> 
   <td>将序列 s 转换为一个元组</td> 
  </tr> 
  <tr> 
   <td>list(s)</td> 
   <td>将序列 s 转换为一个列表</td> 
  </tr> 
  <tr> 
   <td>set(s)</td> 
   <td>转换为可变集合</td> 
  </tr> 
  <tr> 
   <td>dict(d)</td> 
   <td>创建一个字典。d 必须是一个 (key, value)元组序列。</td> 
  </tr> 
  <tr> 
   <td>frozenset(s)</td> 
   <td>转换为不可变集合</td> 
  </tr> 
  <tr> 
   <td>chr(x)</td> 
   <td>将一个整数转换为一个字符</td> 
  </tr> 
  <tr> 
   <td>ord(x)</td> 
   <td>将一个字符转换为它的整数值</td> 
  </tr> 
  <tr> 
   <td>hex(x)</td> 
   <td>将一个整数转换为一个十六进制字符串</td> 
  </tr> 
  <tr> 
   <td>oct(x)</td> 
   <td>将一个整数转换为一个八进制字符串</td> 
  </tr> 
 </tbody> 
</table>

## 写在最后 ##

插入表格，并非必须用富文本编辑器——在Markdown中插入表格

*  使用Markdown的表格语法

| 一个普通标题 | 一个普通标题 | 一个普通标题 |
    | ------ | ------ | ------ |
    | 短文本 | 中等文本 | 稍微长一点的文本 |
    | 稍微长一点的文本 | 短文本 | 中等文本 |

<table> 
 <thead> 
  <tr> 
   <th>一个普通标题</th> 
   <th>一个普通标题</th> 
   <th>一个普通标题</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>短文本</td> 
   <td>中等文本</td> 
   <td>稍微长一点的文本</td> 
  </tr> 
  <tr> 
   <td>稍微长一点的文本</td> 
   <td>短文本</td> 
   <td>中等文本</td> 
  </tr> 
 </tbody> 
</table>

*  使用`<table`>标签创建

<table> 
 <tbody> 
  <tr> 
   <td>"团队"</td> 
   <td>"活动"</td> 
  </tr> 
  <tr> 
   <td>LSGO</td> 
   <td>Python基础刻意练习</td> 
  </tr> 
 </tbody> 
</table>

[No-Cruft Excel to HTML Table Converter][]

[Python]: https://www.liaoxuefeng.com/wiki/1016959663602400/1016959735620448
[Python 1]: https://www.runoob.com/python3/python3-intro.html
[No-Cruft Excel to HTML Table Converter]: http://pressbin.com/tools/excel_to_html_table/index.html