Python3: 基本数据类型与数学运算

忘是亡心i 2021-09-21 22:32 355阅读 0赞

本文链接: [https://blog.csdn.net/xietansheng/article/details/115557286][https_blog.csdn.net_xietansheng_article_details_115557286]

[Python3 学习笔记（目录）][Python3]

# 1. Python3 基础数据类型 #

Python 官网介绍:

*  数据结构: [Data Structures][]
 *  内置类型: [Built-in Types][]

## 1.1 变量 ##

Python 中的变量不需要声明，每个变量在使用前必须赋值，变量赋值以后才会被创建。Python 中变量就是变量，它没有类型。我们所说的“类型”是指变量所指的内存中对象的类型，同一个变量名可以指向不同的类型(一般不这么做)。变量赋值使用等号(=)。

i = 10                  # 整型变量
    f = 2.3                 # 浮点型变量
    s = "Hello"             # 字符串

同行多个变量赋值:

# 从右到左, 1 赋值给 c, c 再赋值 b, b 再赋值给 a
    a = b = c = 1
    
    # a = 10, b = 3.5, c = "hello"
    a, b, c = 10, 3.5, "hello"

获取对象的内存地址: `id(obj)`

删除对象的引用:

a = 10
    b = 3.5
    c = "hello"
    d = [1, 2, 3]
    
    del a           # 删除后内存中将没有这个变量
    del b, c, d

## 1.2 标准数据类型 ##

Python3 有六种标准的数据类型:

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

除了 Number（数字）外，其他 5 种数据类型可称为是 **序列类型（sequence）**。

这 6 种标准数据类型中:

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

## 1.3 对象的类型（type 和 isinstance 函数） ##

在 Python 中一切数据（包括六种标准的数据类型）皆是对象，每个变量/对象都有其对于的对象类型。

标准类型的具体对象类型名称:

<table> 
 <thead> 
  <tr> 
   <th align="left">标准数据类型</th> 
   <th align="left">程序中的具体对象类型的名称</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Number（数字）</td> 
   <td align="left"><code>int, float, bool, complex</code></td> 
  </tr> 
  <tr> 
   <td align="left">String（字符串）</td> 
   <td align="left"><code>str</code></td> 
  </tr> 
  <tr> 
   <td align="left">Tuple（元祖）</td> 
   <td align="left"><code>tuple</code></td> 
  </tr> 
  <tr> 
   <td align="left">List（列表）</td> 
   <td align="left"><code>list</code></td> 
  </tr> 
  <tr> 
   <td align="left">Set（集合）</td> 
   <td align="left"><code>set</code></td> 
  </tr> 
  <tr> 
   <td align="left">Dictionary（字典）</td> 
   <td align="left"><code>dict</code></td> 
  </tr> 
 </tbody> 
</table>

**type(obj)** 函数返回对象的类型:

type(10)                            # int
    type(2.5)                           # float
    type(True)                          # bool
    type(2 + 3j)                        # complex
    type("Hello")                       # str
    type((10, 2.5, "Hello"))            # tuple
    type([1, 2, 3])                     # list
    type({ 1, 2, 3})                     # set
    type({ "name":"hello", "age":20})    # dict
    
    a = 10
    type(10) == int                     # 结果为 True
    type(a)  == int                     # 结果为 True
    type(a)  != bool                    # 结果为 True
    type(a)  == list                    # 结果为 False

**isinstance(obj, type)** 函数判断对象是否是指定类型:

a = 10
    isinstance(a, int)                  # 返回 True
    
    class Demo:
        pass
    
    d = Demo()
    isinstance(d, Demo)                 # 返回 True
    type(d) == Demo                     # 结果为 True
    
    isinstance(d, object)               # 返回 True, object 是所为对象类的超类
    isinstance(10, object)              # 返回 True

type 和 isinstance 的区别:

*  type() 不会认为子类是一种父类类型（不支持继承判断）
 *  isinstance() 会认为子类是一种父类类型（支持继承判断）

## 1.4 数据类型转换 ##

#
    # Number（数字）
    #
    int(x[, base])          # 将x转换为一个整数, x为数字 或 进制表示的字符串
    float(x)                # 将x转换为一个浮点数, x为数字 或 浮点数的字符串形式
    bool(x)                 # 将x转换为bool, 如果x为0/None/空字符, 返回False
    complex(real[, imag])   # 创建一个复数
    
    #
    # String（字符串）
    #
    str(obj)                # 转换为字符串
    repr(obj)               # 转换为表达式字符串
    
    chr(int)                # 整数（Unicode）x 转换为 一个字符
    ord(char)               # 字符 转换 为整数（Unicode）
    
    bin(int)                # 整数转换为 二进制 字符串
    oct(int)                # 整数转换为 八进制 字符串
    hex(int)                # 整数转换为 十六进制 字符串
    
    eval(str)               # 把字符串str当做Python语句/表达式执行, 并返回计算结果
    
    #
    # Tuple（元祖）, List（列表）, Set（集合）, Dictionary（字典）
    #
    tuple(seq)              # 将序列(list/set/tuple/dict/str)转换为元祖
    list(seq)               # 将序列转换为列表
    set(seq)                # 将序列转换为集合
    
    frozenset([iterable])   # 返回一个不可修改的集合
    
    dict(..)                # 创建一个字典

# 2. 六种标准数据类型 #

## 2.1 Number（数字） ##

Python3 支持的数字类型有（4种）：**int**、**float**、**bool**、**complex（复数）**

Python3 中只有一种整数类型 int，表示长整型，没有 Python2 中的 Long 类型。

四种数值类型:

*  **整型(int)**: 整型，可以使用二、八、十、十六进制表示，Python3 中的整型没有限制大小。
 *  **浮点型(float)**: 浮点型小数，可以使用科学计数法表示（2.5e8 == 2.5 \* 108）。
 *  **复数(complex)**: 复数有实数和虚数两部分构成，可以用 a + bj 或 complex(a, b) 表示, 其中实部 a 和 b 都是浮点型。
 *  **布尔类型(bool)**: bool 实际上继承自 int, 值为 True 或 False, 参与数学运算时, True 值为 1, False 值为 0。

数字对象创建:

#
    # 整型
    #
    a = 18              # 十进制表示的整数, 值为 18
    b = 0b1010          # 二进制表示的整数, 值为 10
    c = 0o10            # 八进制表示的整数, 值为 8
    d = 0xFF            # 十六进制表示的整数, 值为 255
    
    #
    # 浮点型
    #
    a = 2.3             # 小数 2.3
    b = 2.3e-2          # 科学计数法表示, 值为 0.023
    c = 4.2E1           # 科学计数法表示, 值为 42.0
    
    #
    # 复数
    #
    a = 3.14j
    b = 5.12J
    c = 2.3 + 5.4j
    
    #
    # 布尔类型
    #
    a = True
    b = False

## 2.2 String（字符串） ##

### 2.2.1 创建字符串 ###

字符串（str）是一组有序不可修改的字符序列，在 Python 中使引号（`'`或`"`）引起来创建字符串。

# 简单创建字符串
    s1 = "Hello World"
    s2 = 'Hello World'
    
    # 支持使用 反斜杠\ 转义字符, \n 表示换行
    s3 = "Hello\nWorld"
    
    # 创建原生字符串, 不使用转义, 直接按字面输出
    s4 = r"Hello\nWorld"
    
    # 支持格式化创建字符串, 使用 % 号运算符, % 后面的是 元组
    s5 = "我叫 %s, 今年 %d 岁" % ("小明", 25)
    
    # f-string, 格式化字符串常量（formatted string literals）创建字符串
    name = "Tom"
    age = 25
    s6 = f"NAME: {name}, AGE: {age}, 4 + 5 = {4 + 5}" # { } 内可以是有值的任意表达式
    
    # 可以使用 3 个引号跨多行创建字符串
    s7 = """第一行 第二行 第三行 """
    
    # 支持使用 Unicode 字符表达式创建字符串
    s8 = "\u0048\u0065\u006c\u006c\u006f"

Python 不支持单字符类型，单字符(char)在 Python 中也作为普通字符串使用。

字符串格式化详细参考官网：

*  [formatstrings][]
 *  [str.format(…)][str.format]

### 2.2.2 字符串运算符 ###

运算符:

+               # 两个字符串链接
    *               # 重复输出字符串
    [index]         # 通过索引获取字符串中的单个字符（支持反向索引, 右边第一个字符索引为 -1）
    [start:end]     # 通过索引截取字符串, 包括 start, 不包括 end
    in              # 成员运算符, 判断左边的字符串是否包含在右边的字符串中
    not in          # 成员运算符, 与 in 相反
    r/R             # (Raw)原始字符串, 创建字符串时在引号前加r, 所有字符按字面解析
    %               # 创建字符串时, 字符串格式化符号

示例:

a = "abc"
    b = "123"
    
    print(a + b)                        # 输出 "abc123"
    print(a * 2)                        # 输出 "abcabc"
    print(a[1])                         # 输出 "b"
    print(a[0:2])                       # 输出 "ab"
    print(a[1:])                        # 输出 "bc"
    print(a[:2])                        # 输出 "ab"
    print("ab" in a)                    # 输出 True
    print("bc" not in a)                # 输出 False
    print(r"abc\n123")                  # 输出 "abc\n123" (没有换行)
    print("%s, %d" % ("Hello", 25))     # 输出 "Hello, 25"

### 2.2.3 字符串与数字/字节之间的相关转换 ###

#
    # str -> int/float
    #
    int(x[, base=10])           # x为数字, 则返回其整数部分; x为进制表示的字符串, 则返回base进制对应的整数
    float(x)                    # x为数字 或 浮点数的字符串形式, 返回浮点数
    
    #
    # int -> str
    #
    bin(int)                    # 整数转换为 二进制字符串
    oct(int)                    # 整数转换为 八进制字符串
    hex(int)                    # 整数转换为 十六进制字符串
    
    #
    # str -> Unicode str
    #
    ascii(str)                  # 转换字符串, 把字符串中的非 ASCII 字符转换为 Unicode 码的形式输出
    
    #
    # Unicode <-> int
    #
    chr(int)                    # Unicode整数值 -> 字符(单个字符)
    ord(str)                    # 字符(单个字符) -> Unicode整数值
    
    #
    # 字符串的编码与解码
    #
    bytes.decode(encoding="UTF-8", errors="strict")     # 将 bytes 对象 解码 为字符串, errors 为异常处理方案
    str.encode(encoding="UTF-8", errors="strict")       # 把字符串 编码 为 bytes, errors 为异常处理方案

### 2.2.4 字符串内置函数和方法 ###

len(str)                    # 计算字符串的长度
    max(str)                    # 返回 Unicode 值最大的字符
    min(str)                    # 返回 Unicode 值最小的字符
    
    
    str.lstrip()                            # 删除左边的 空格, \r, \n, \t
    str.rstrip()                            # 删除右边的 空格, \r, \n, \t
    str.strip()                             # 删除左右两边的 空格, \r, \n, \t
    
    
    str.find(str, beg=0, end=len(str))      # 从左往右查找字符串, 返回第1个找到的位置的(左)开始索引, 没找到返回 -1
    str.rfind(str, beg=0, end=len(str))     # 从右往左查找字符串, 返回第1个找到的位置的(左)开始索引, 没找到返回 -1
    str.index(str, beg=0, end=len(str))     # 与 find() 相同, 不过如果找不到将抛异常
    str.rindex(str, beg=0, end=len(str))    # 与 rfind() 相同, 不过如果找不到将抛异常
    
    
    str.startswith(substr, beg=0,end=len(str))      # 判断是否以指定的字符串开头
    str.endswith(suffix, beg=0, end=len(str))       # 判断是否以指定的字符串结尾
    
    
    str.upper()                                     # 所有字母转换为大写
    str.lower()                                     # 所有字母转换为小写
    str.swapcase()                                  # 字符串中的字母, 大写转换为小写, 小写转换为大写
    str.title()                                     # 标题化字符串, 所有单词首字母大写, 其他字母小写
    str.capitalize()                                # 将字符串的第一个字符转换为大写
    
    
    str.count(str, beg=0, end=len(str))             # 指定字符串出现的次数
    str.replace(old, new[, max])                    # 字符串替换, 可以指定最多替换次数
    str.expandtabs(tabsize=8)                       # 把字符串中的 TAB 符号转换为空格, 默认 TAB 符号为8个空格
    
    
    str.split(sep, maxsplit=-1)         # 从左往右切分字符串, maxsplit 表示最大切分次数, -1表示不限制
    str.rsplit(sep, maxsplit=-1)        # 从右往左切分字符串, maxsplit 表示最大切分次数, -1表示不限制
    str.splitlines(keepends=False)      # 以换行符("\r", "\r\n", "\n")作为分隔符截取字符串,
                                        # keepends 表示结果子字符串是否包含换行符
    
    str.join(seq)                       # 把序列的所有元素以字符串 str 作为分隔符连接成一个新字符串
    
    
    str.ljust(width, fillchar=" ")      # 原字符串左对齐返回, 最小宽度为 width, 不够使用 fillchar 字符填充
    str.rjust(width, fillchar=" ")      # 原字符串右对齐返回, 最小宽度为 width, 不够使用 fillchar 字符填充
    str.center(width, fillchar=" ")     # 原字符串居中对齐返回, 最小宽度为 width, 不够使用 fillchar 字符填充
    str.zfill(width)                    # 原字符串右对齐返回, 最小宽度为 width, 不够使用 "0" 填充
    
    
    str.isupper()                       # 所有字母是否为大写（不包括无大小写的字符）
    str.islower()                       # 所有字母是否为小写（不包括无大小写的字符）
    str.isdigit()                       # 字符串是否只包含数字字符
    str.isnumeric()                     # 字符串是否只包含数字字符
    str.isdecimal()                     # 字符串是否只包含十进制字符
    str.isalnum()                       # 字符串是否只由字母和数字组成
    str.isalpha()                       # 字符串是否只由字母组成
    str.isascii()                       # 字符串是否为空 或 所有字符均为 ASCII 字符（U+0000-U+007F）
    str.isspace()                       # 字符串是否只包含空格
    str.istitle()                       # 字符串是否是标题（所有的单词首字大写, 其他字母小写）
    
    
    str.maketrans(intab, outtab)        # 创建字符映射的 转换表, intab 和 outtab 是长度相同的字符串（字符相对映）
    str.translate(table, delchars="")   # 根据 转换表, 转换字符串中的字符, delchars 表示需要删除的字符

## 2.3 Tuple（元组） ##

元组（tuple）是一组不可修改的有序可重复的序列。元组的元素写在小括号`( )`内，元素之间用逗号`,`隔开。元组中的元素数据可以是不同的类型。

### 2.3.1 创建元组 ###

t1 = ("hello", 256, 3.14, True)
    t2 = ()             # 空元组
    t3 = (10,)          # 元组只有一个元素时, 需要在元素后面加逗号, 否则括号将被当做是运算符
    
    # 元组的元素可以是任意对象（包括元组本身、集合、列表等其他任意对象）
    l4 = [(3, 4), [1, 2], "hello", object]

### 2.3.2 元组运算符 ###

t = ("hello", 256, 3.14, True)
    
    # 元组元素给多个变量赋值
    a, b, c, d = t
    
    # 元组长度
    len(t)                  # 结果为 4
    
    # 访问元素
    print(t[0])             # 输出 "hello"
    print(t[1])             # 输出 256
    print(t[-1])            # 支持反向索引, 右边第一个元素索引为 -1, 输出 True
    print("hello" in t)     # 判断是否存指定成员, 输出 True
    
    # 元组元素遍历
    for x in t:
        print(x, end=", ")  # 输出: hello, 256, 3.14, True,
    
    # 元组截取（返回新的元组）
    print(t[0:2])           # 输出 ("hello", 256)
    print(t[1:])            # 输出 (256, 3.14, True)
    print(t[:2])            # 输出 ("hello", 256)
    
    # 元组加法和乘法
    t1 = ("aa", "bb")
    t2 = ("11", "22")
    t3 = t1 + t2            # 加法, 结果为 ("aa", "bb", "11", "22")
    t4 = t1 * 2             # 乘法, 结果为 ("aa", "bb", "aa", "bb")
    
    # 删除元组
    del t                   # 删除后, t 将变为 is not defined

### 2.3.3 元组内置函数 ###

len(tuple)              # 计算元组元素个数
    max(tuple)              # 返回元组中元素最大值
    min(tuple)              # 返回元组中元素最小值
    sum(tuple)              # 计算元组元素的数值总和
    tuple(seq)              # 将序列转换为元组

## 2.4 List（列表） ##

列表（list）是一组可修改的有序可重复的序列。列表的元素写在方括号`[ ]`内，元素之间用逗号`,`隔开。列表中的元素数据可以是不同的类型。

### 2.4.1 创建列表 ###

l1 = ["hello", 256, 3.14, True]
    l2 = [0, 1, 2, 3, 4, 5]
    l3 = []                 # 创建一个空列表
    
    # 列表的元素可以是任意对象（包括列表本身、集合、元组等其他任意对象）
    l4 = [[1, 2], (3, 4), "hello", object]

### 2.4.2 列表运算符 ###

lt = ["hello", 256, 3.14, True]
    
    # 列表长度
    len(lt)                 # 结果为 4
    
    # 访问元素
    print(lt[0])            # 输出 "hello"
    print(lt[1])            # 输出 256
    print(lt[-1])           # 支持反向索引, 右边第一个元素索引为 -1, 输出 True
    print("hello" in lt)    # 判断是否存指定成员, 输出 True
    
    # 列表元素遍历
    for x in lt:
        print(x, end=", ")  # 输出: hello, 256, 3.14, True,
    
    # 列表截取（返回新的列表）
    print(lt[0:2])          # 输出 ["hello", 256]
    print(lt[1:])           # 输出 [256, 3.14, True]
    print(lt[:2])           # 输出 ["hello", 256]
    
    # 列表加法和乘法
    l1 = ["aa", "bb"]
    l2 = ["11", "22"]
    l3 = l1 + l2            # 加法, 结果为 ["aa", "bb", "11", "22"]
    l4 = l1 * 2             # 乘法, 结果为 ["aa", "bb", "aa", "bb"]
    l1 += [cc, dd]          # 拼接赋值, 结果 l1 == ["aa", "bb", "cc", "dd"]
    
    # 更新列表元素
    lt[0] = "world"         # 修改成员的值（索引不能越界）
    
    # 删除列表元素
    del lt[1]               # 删除列表元素, 删除后列表为 ["hello", 3.14, True]
    del lt                  # 删除整个列表
    
    # 列表嵌套（多维列表）
    lt = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    print(lt[0][1])         # 结果输出 2

### 2.4.3 列表内置函数和方法 ###

len(list)                   # 计算列表元素的个数
    max(list)                   # 返回列表元素的最大值
    min(list)                   # 返回列表元素的最小值
    sum(list)                   # 计算列表元素的数值总和
    list(seq)                   # 将序列转换为列表
    
    list.append(obj)            # 添加元素到列表末尾
    list.insert(index, obj)     # 在指定索引位置插入元素, 如果索引大于列表长度, 则插到末尾
    list.extend(seq)            # 批量添加序列中的元素到列表末尾
    
    list.count(obj)             # 统计某个元素在列表中出现的次数
    list.index(obj)             # 查找某个元素在列表中第一次出现的索引位置（找不到会报错）
    
    list.pop([index=-1])        # 移除并返回列表中指定索引位置的元素（默认是最后一个元素, 索引越界会报错）
    list.remove(obj)            # 移除列表中元素第一次出现的匹配项
    list.clear()                # 清空列表（移除所有元素）
    
    list.reverse()              # 反转列表中的所有元素
    list.copy()                 # 复制列表, 返回列表的副本
    list.sort(cmp=None, key=None, reverse=False)    # 对列表中的元素进行排序

## 2.5 Set（集合） ##

集合（set）是一组可修改的无序不可重复的序列。集合的元素写在大括号`{ }`内，元素之间用逗号`,`隔开。集合中的元素数据可以是不同的类型。

### 2.5.1 创建集合 ###

s1 = { "hello", 256, 3.14, True}
    s2 = { 0, 1, 2, 3, 4, 5}
    s3 = set()                  # 空集合, 创建空集合时使用 set(), 因为 { } 用于创建字典
    s4 = set(seq)               # 将序列中的元素作为集合的元素创建集合
    
    # 集合中的元素可以是 tuple, 但不支持可修改的序列（list、set、dict）
    s4 = { (3, 4), "hello", 256, object}

### 2.5.2 集合的基本操作 ###

s = { "hello", 256, 3.14, True}
    
    # 集合的长度
    len(s)                  # 结果为 4
    
    # 添加元素
    s.add("world")          # 添加一个元素到集合中, 该元素不能是可修改的序列（list、set、dict）
    s.update([1, 2, 3])     # 把序列中的元素逐一添加到集合
    
    # 判断集合中是否存在某个元素
    "hello" in s
    
    # 遍历集合
    for x in s:
        print(x)
    
    # 移除某个元素（如果指定元素不存在, 则报错）
    s.remove("hello")

### 2.5.3 集合的数学运算 ###

s1 = { 1, 2, 3, 4}
    s2 = { 3, 4, 5}
    
    s1 - s2         # 差集, s1 中的元素减去 s2 中存在的元素, 结果为 {1, 2}
    s1 | s2         # 并集, s1 中的元素加上 s2 中的元素, 结果为 {1, 2, 3, 4, 5}
    s1 & s2         # 交集, s1 和 s2 中同时存在的元素, 结果为 {3, 4}
    s1 ^ s2         # 并集 - 交集, 不同时存在于 s1 和 s2 中的元素, 结果为 {1, 2, 5}

### 2.5.4 集合内置函数和方法 ###

len(set)                    # 计算集合元素的个数
    max(set)                    # 返回集合元素的最大值
    min(set)                    # 返回集合元素的最小值
    sum(set)                    # 计算集合元素的数值总和
    set(seq)                    # 将序列转换为集合
    
    set.add(obj)                # 添加元素, 该元素不能是可修改的序列（list、set、dict）
    set.update(seq)             # 批量添加元素, 把序列中的元素逐一添加到集合
    set.copy()                  # 复制集合, 返回集合的副本
    
    set.pop()                   # 随机移除集合中的一个元素并返回
    set.remove(obj)             # 移除集合中的指定元素, 元素不存在会报错
    set.discard(obj)            # 移除集合中的指定元素, 元素不存在不会报错
    set.clear()                 # 清空集合（移除所有元素）
    
    set.union(set1, set2...)                # 并集, 返回 set、set1、set2... 多个集合的并集
    set.intersection(set1, set2...)         # 交集, 返回 set、set1、set2... 多个集合的交集
    set.difference(set1, set2...)           # 差集, 返回 set - set1 - set2...
    set.symmetric_difference(set1)          # 并集 - 交集, 返回 set ^ set1
    
    set.intersection_update(set1, set2...)  # 交集, 结果不返回, 结果直接保存到 set 中（保存前会先清空集合）
    set.difference_update(set1, set2...)    # 差集, 结果不返回, 结果直接保存到 set 中（保存前会先清空集合）
    set.symmetric_difference_update(set1)   # 并集 - 交集, 结果不返回, 结果直接保存到 set 中（保存前会先清空集合）
    
    set.isdisjoint(set1)            # 是否互斥, 即 set 和 set1 没有相同的要元素（交集为空集合）
    set.issubset(set1)              # set 是否是 set1 的子集, 即 set1 中是否包含了 set 的所有元素
    set.issuperset(set1)            # set1 是否是 set 的自己, 即 set 中是否包含了 set1 的所有元素

## 2.6 Dictionary（字典） ##

字典（dict）是一组可修改的无序不可重复的键值对序列。字典中的元素以`key:value`形式保存，元素写在大括号`{ }`内，元素`key-value`之间用逗号`,`隔开。

字典的键不能重复，值则无要求。值可以是任意类型，但键必须是不可变的类型，例如 字符串、数字、元组等。

### 2.6.1 创建字典 ###

d1 = { "name":"Tom", "age":25}
    d2 = { 256:"hello", 3.14:"PI"}
    
    d3 = dict(name="Tom", age=25)

### 2.6.2 字典的基本操作 ###

dt =  { "name":"Tom", "age":25}
    
    # 字典的长度
    len(dt)                     # 结果为 4
    
    # 判断字典中是否有某个键
    "name" in dt                # 结果为 True
    
    # 访问元素
    print(dt["name"])           # 输出 "Tom"
    print(dt["age"])            # 输出 25
    
    # 遍历字典
    for key in dt:
        print(dt[key], end=", ")    # 输出: Tom, 25, 
    
    # 修改元素的值
    dt["name"] = "hello"        # 如果键不存在, 则会报错
    
    # 删除元素
    del dt["name"]              # 删除某个键指定的元素
    del dt                      # 删除整个字典

### 2.6.3 字典内置函数和方法 ###

len(dict)                   # 计算字典元素的个数
    str(dict)                   # 把字典转换为字符串形式
    key in dict                 # 判断某个键在字典中是否存在
    
    dict.get(key, default=None)         # 获取 key 对应的 value, 如果 key 不存在, 则返回默认值 default
    dict.setdefault(key, default=None)  # 如果 key 在字典中不存在, 则创建该 key, 并设置默认值 default
                                        # 如果 key 在字典中存在, 则忽略, 并返回该 key 对应的 value
    
    dict.update(dict1)              # 把字典 dict1 中的所有 key:value 元素添加/更新到 dict 中
    dict.fromkeys(seq[, value])     # 创建新字典, 以序列 seq 中的元素作为字典的键, value 作为所有键对应的初始值
    dict.copy()                     # 浅复制字典, 返回复制的副本
    
    dict.keys()                 # 返回所有 key 的可迭代对象, 可以使用 list() 转换为列表
    dict.values()               # 返回所有 value 的可迭代对象, 可以使用 list() 转换为列表
    dict.items()                # 返回所有 key:value 的可迭代对象, 可以使用 list() 转换为列表
                                # 列表元素为由 key 和 value 组成的元祖(key, value)
    
    dict.pop(key[, default])    # 移除 key 指定的元素, 并返回 key 对应的 value
    dict.popitem()              # 随机移除并返回一个元素（一般删除末尾的元素）, 以元祖(key, value)的形式返回
    dict.clear()                # 清空字典的左右元素（移除所有的key:value）

# 3. 运算符 #

## 3.1 算数运算 ##

运算符   描述          示例
    ----------------------------------------------
    +       加法          2 + 3 结果为 5
    -       减法          5 - 2 结果为 3
    *       乘法          2 * 3 结果为 6
    /       除法          3 / 2 结果为 1.5
    %       取模          9 % 2 结果为 1
    **      求幂          2**10 结果为 1024
    //      整除          9 // 2 结果为 4（除数取整）
    ----------------------------------------------

## 3.2 比较（关系）运算 ##

比较运算，结果返回 bool 类型（True 或 False）。

运算符   描述          示例
    --------------------------------------------------------------
    ==      等于          2 == 2 结果为 True
    !=      不等于        "abc" != "abc" 结果为 False
    >       大于          3 > 2 结果为 True; "a" < "b" 结果为 True
    <       小于          4 < 2 结果为 False
    >=      大于等于       3 >= 3 结果为 True
    <=      小于等于       5 <= 10 结果为 False
    --------------------------------------------------------------

## 3.3 赋值运算 ##

运算符   描述           示例
    --------------------------------------------------------
    =       简单赋值        c = a + b, 将 a + b 的结果赋值给 c
    +=      加法赋值        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
    --------------------------------------------------------

## 3.4 逻辑运算 ##

运算符   描述           示例
    --------------------------------------------------------
    and     逻辑与         a and b, a 和 b 为布尔表达式
    or      逻辑或         a or b
    not     逻辑非         not a
    --------------------------------------------------------

## 3.5 位运算 ##

运算符   描述          示例
    --------------------------------------------------------------------
    &       位与          a & b, 整数a 和 整数b 按位与运算
    |       位或          a | b, 整数a 和 整数b 按位或运算
    ^       异或          a ^ b, 整数a 和 整数b 按位异或运算
    ~       取反          ~a, 对 整数a 按位取反
    <<      左移          a << 1, 整数a 左移 1 位, 0b111 << 1 结果为 0b1110
    >>      右移          a >> 1, 整数a 右移 1 位, 0b111 >> 1 结果为 0b11
    --------------------------------------------------------------------

*  `& | ^`：两个整数的位与、或、异或运算，整数的位数必须相同，位数不够的，正数高位补0，负数高位补1。
 *  `<<` 左移：左移低位补0。
 *  `>>` 右移：正数右移，高位补0；负数右移，高位补1。

> 负数的二进制表示：负数绝对值的二进制按位取反后+1。

## 3.6 成员运算 ##

成员运算符`in`和`not in`用于判断序列中是否包含某个成员。

运算符     描述                                       示例
    ------------------------------------------------------------------
    in        成员在序列中存在返回 True, 否则返回 False       x in seq
    not in    成员在序列中不存在返回 True, 否则返回 False     x not in seq
    ------------------------------------------------------------------

成员运算符支持的序列有：**str**、**tuple**、**list**、**set**、**dict**

*  `x in str`：对于字符串序列，判断的是 x 是否为 str 的子字符串。
 *  `x in dict`：对于字典序列，判断的是 x 是否为 dict 的键。

## 3.7 身份运算 ##

身份运算符`is`和`is not`用于判断两个变量名引用的是否是同一个对象（即是否指向的是同一个内存地址）。

运算符     描述                            示例
    -------------------------------------------------------------------------
    is        两个变量名引用的是同一个对象？       a is b 等价于 id(a) == id(b)
    is not    两个变量名引用的不是同一个对象？     a is not b 等价于 id(a) != id(b)
    -------------------------------------------------------------------------

> id(obj) 函数用于获取对象的内存地址。

## 3.8 运算符优先级 ##

运算符优先级列表（从高到低优先级排列）:

<table> 
 <thead> 
  <tr> 
   <th align="left">#</th> 
   <th align="left">运算符</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><code>()</code></td> 
   <td align="left">分组圆括号</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><code>f(args...)</code></td> 
   <td align="left">函数调用</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><code>x[index:index]</code></td> 
   <td align="left">序列切片</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><code>x[index]</code></td> 
   <td align="left">访问序列的成员</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><code>x.attribute</code></td> 
   <td align="left">访问对象的属性</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><code>**</code></td> 
   <td align="left">求幂</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><code>~x</code></td> 
   <td align="left">按位取反</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><code>+x</code>, <code>-x</code></td> 
   <td align="left">正负符号</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><code>*</code>, <code>/</code>, <code>%</code></td> 
   <td align="left">乘法, 除法, 取模(余数)</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><code>+</code>, <code>-</code></td> 
   <td align="left">加法, 减法</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><code>&lt;&lt;</code>, <code>&gt;&gt;</code></td> 
   <td align="left">按位移动</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><code>&amp;</code></td> 
   <td align="left">位与</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><code>^</code></td> 
   <td align="left">异或</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><code>|</code></td> 
   <td align="left">位或</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><code>in</code>, <code>not in</code> <br> <code>is</code>, <code>is not</code> <br> <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, <code>&gt;=</code>, <code>!=</code>, <code>==</code></td> 
   <td align="left">成员运算 <br> 身份运算 <br> 比较（关系）运算</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><code>not x</code></td> 
   <td align="left">逻辑非</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><code>and</code></td> 
   <td align="left">逻辑与</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><code>or</code></td> 
   <td align="left">逻辑或</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><code>lambda</code></td> 
   <td align="left">Lambda 表达式</td> 
  </tr> 
 </tbody> 
</table>

# 4. 数学库函数 #

## 4.1 数学函数 ##

数学库函数在`math`模块中，[官网 math 模块文档][math]。

abs(x)                  # 求绝对值, abs 函数是内置函数, 不再 math 模块中
    
    #
    # 常用的数学函数
    #
    math.fabs(x)            # 求绝对值, 返回 float 类型
    math.remainder(x, y)    # 浮点数求余, x 除以 y 的余数, x、y 和 结果 都可为浮点数
    math.ceil(x)            # 向正无穷取整
    math.floor(x)           # 向负无穷取整
    math.pow(x, y)          # 求幂, x 的 y 次方
    math.sqrt(x)            # x 的平方根
    math.gcd(a, b)          # a 和 b 的最大公约数
    math.log(x[, base])     # 对数函数, base 默认为 e
    math.exp(x)             # e 的 x 次幂
    
    math.isfinite(x)        # x 是否为 有限的（非正无穷, 非负无穷, 非NaN）
    math.isinf(x)           # x 是否为 正无穷
    math.isnan(x)           # x 是否为 非数字
    
    #
    # 三角函数（使用的单位为 弧度）
    #
    math.sin(r)             # 正弦
    math.cos(r)             # 余弦
    math.tan(r)             # 正切
    
    math.asin(x)            # 反正弦
    math.acos(x)            # 反余弦
    math.atan(x)            # 反正切
    
    math.degrees(r)         # 弧度 r 转换为 角度
    math.radians(d)         # 角度 d 转换为 弧度
    
    #
    # 数学常量
    #
    math.pi                 # 圆周率 π
    math.e                  # 自然对数
    math.tau                # 数学常数 τ
    math.inf                # 浮点正无穷（浮点负无穷为 -math.inf）, 相当于 float("inf")
    math.nan                # 浮点“非数字”（NaN）, 相当于 float("nan")

## 4.2 随机数函数 ##

随机数函数在`random`模块中，[官网 random 模块文档][random]。

random.seed(x)              # 初始化随机数种子, 如果不调用或传None, 则默认使用系统时间作为随机数种子
    
    random.random()             # [0.0, 1.0) 之间产生随机数
    random.randint(a, b)        # 整数区间 [a, b] 之间产生随机数
    
    random.choice(seq)          # 从序列中随机返回一个元素
    
    random.randrange(stop)                  # 从正数区间 [0, stop) 直接产生随机数
    random.randrange(start, stop[, step])   # 从区间 range(start, stop[, step]) 之中产生随机数

[https_blog.csdn.net_xietansheng_article_details_115557286]: https://blog.csdn.net/xietansheng/article/details/115557286
[Python3]: https://blog.csdn.net/xietansheng/article/details/109266600
[Data Structures]: https://docs.python.org/zh-cn/3/tutorial/datastructures.html
[Built-in Types]: https://docs.python.org/zh-cn/3/library/stdtypes.html
[formatstrings]: https://docs.python.org/zh-cn/3/library/string.html#formatstrings
[str.format]: https://docs.python.org/zh-cn/3/library/stdtypes.html#str.format
[math]: https://docs.python.org/zh-cn/3/library/math.html
[random]: https://docs.python.org/zh-cn/3/library/random.html