{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7.4 集合关系"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 方法            | 符号     | 含义                                          |\n",
    "| :---------------: | :--------: | :--------------------------------------------- |\n",
    "| s.issubset(t)   | s   <= t | s是否是t的子集，是返回True，否则返回False<br>  检测是否集合中的每个元素都在 t 之中。|\n",
    "|                 | s   < t  | s是否是t的真子集，是返回True，否则返回False   |\n",
    "| s.issuperset(t) | s   >= t | s是否是t的超集，是返回True，否则返回False<br>    检测是否t中的每个元素都在集合之中。  |\n",
    "|                 | s   > t  | s是否是t的真超集，是返回True，否则返回False     |\n",
    "| s.isdisjoint(t) |          | s和t是否无共同元素，是返回True，否则返回False |\n",
    "|                 | s ==   t | s是否和t相等，是返回True，否则返回False       |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 集合等价/不等价"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**s == t：  \n",
    "集合 s 是否和集合 t 相等，是返回True，否则返回False。**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果集合s的任何一个元素都是集合t的元素，同时集合t的任何一个元素都是集合s的元素，我们就说集合s等于集合t。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "s = set('python')                     #{'t', 'n', 'o', 'h', 'p', 'y'}\n",
    "t = {'o', 'y', 'p', 'g'}\n",
    "print(s == t)                         #False\n",
    "print(s != t)                         #True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/ch7/8.png\" style=\"zoom:50%;\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "s = set('python')  #{'t', 'n', 'o', 'h', 'p', 'y'}\n",
    "u = frozenset(s)   #frozenset({'p', 'y', 't', 'n', 'o', 'h'})\n",
    "print(s == u)      #True\n",
    "s = set('posh')\n",
    "t = set('shop')\n",
    "print(s == t)      # True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|   |   |\n",
    "|:---:|:----:|\n",
    "|<img src=\"images/ch7/9.png\" style=\"zoom:80%;\">|<img src=\"images/ch7/10.png\" style=\"zoom:80%;\">|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**s.isdisjoint(t)：  \n",
    "isdisjoint的方法可以判断s和t两个集合有没有相同的元素，如果没有相同元素，该方法返回True，否则该方法返回False**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "s = set('python')      # {'t', 'n', 'o', 'h', 'p', 'y'}\n",
    "t = set('java')        # {'j', 'v', 'a'}\n",
    "u = set('program')     # {'m', 'r', 'g', 'p', 'a', 'o'}\n",
    "\n",
    "print(s.isdisjoint(t)) # True\n",
    "print(s.isdisjoint(u)) # False\n",
    "print(t.isdisjoint(u)) # False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "set1 = {'Java', 'Python', 'C++', 'Kotlin'}\n",
    "set2 = {'Kotlin', 'Swift', 'Java', 'Dart'}\n",
    "set3 = {'HTML', 'CSS', 'JavaScript'}\n",
    "\n",
    "print(set1.isdisjoint(set2))  # False\n",
    "print(set1.isdisjoint(set3))  # True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/ch7/11.png\" style=\"zoom:60%;\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参数t可以接受任何可迭代对象，如字符串、列表、元组等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set('python')                         # {'t', 'n', 'o', 'h', 'p', 'y'}\n",
    "print(s.isdisjoint(['j', 'a', 'v', 'a'])) # 列表做参数，True\n",
    "print(s.isdisjoint('program'))            # 字符串做参数，False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 子集/超集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ **s <= t ：集合 s 是否是集合 t 的子集，是返回True，否则返回False。**\n",
    "+ **s < t ： 集合 s 是否是集合 t 的真子集，是返回True，否则返回False。**\n",
    "+ **s >= t ：集合 s 是否是集合 t 的超集，是返回True，否则返回False**\n",
    "+ **s > t ： 集合 s 是否是集合 t 的真超集，是返回True，否则返回False**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "对于两个集合s与t，如果集合s中任意一个元素都是集合t的元素，那么集合s叫做集合t的子集，集合t叫做集合s的超集。\n",
    "\n",
    "对于两个集合s与t，如果s是t的子集，且t中至少有一个元素不属于s，那么集合s叫做集合t的真子集，集合t叫做集合s的真超集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set('shop')         # {'h', 's', 'o', 'p'} \n",
    "t = set('posh')         # {'o', 'p', 's', 'h'}\n",
    "u = set('bookshop')     # {'o', 'k', 'h', 's', 'b', 'p'}\n",
    "print(s < t)            # s 不是 t 的真子集 ，False\n",
    "print(u > s)            # u 是 s 的真超集，True\n",
    "print(s <= t)           # s 是 t 的子集 ，True\n",
    "print(s >= t)           # s 是 t 的超集 ，True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ **s.issubset(t)：等价于s <= t**\n",
    "+ **s.issuperset(t)：等价于s >= t**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "参数t可以接受任何可迭代对象，如字符串、列表、元组等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = set('shop')                 # {'h', 's', 'o', 'p'} \n",
    "t = set('posh')                 # {'o', 'p', 's', 'h'}\n",
    "print(s.issuperset(t))          # True\n",
    "print(s.issubset('bookshop'))   # True\n",
    "print(t.issuperset('bookshop')) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 实例1：二进制IP 地址转十进制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个IP地址是由四个字节（每个字节8个位）的二进制数组成。请将32位二进制数表示的IP地址转换为十进制格式表示的IP地址输出。十进制格式的IP地址由用“.”分隔开4个十进制数组成（点分十进制表示法）。如果输入的数字不足32位或超过32位或输入的数字中有非0和1的数字时输出“data error!”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**分析**：  \n",
    "输入的字符串未必符合法，可能位数不是32，也可能包含其他字符，这里可以利用集合关系方便的判定输入中是否包括非'0'、'1' 的字符。  \n",
    "合法ip字符串 set(ip) 的结果只能是 {'0'}、 {'1'}、 {'0','1'}中的一个，且字符串长度应等于32。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**输入输出示例：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| 输入 | 输出 |\n",
    "|:----|:----|\n",
    "|00001010111100000000111110101010|10.240.15.170|\n",
    "|11000000101010000000000011|data error!|\n",
    "|11000000201010000000000000000004|data error!|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_ip(ip_bin):\n",
    "    \"\"\"接受由二进制数表示IP的字符串，判定是否为合法IP，\n",
    "    当其合法时返回其对应的十进制IP，否则返回'data error!'\n",
    "    \"\"\"\n",
    "    if len(ip_bin) == 32 and set(ip_bin) <= {'0', '1'}:\n",
    "        ls = []\n",
    "        for i in range(4):\n",
    "            ls.append(str(int(ip_bin[i * 8:(i + 1) * 8], 2)))\n",
    "        ip_dec = '.'.join(ls)\n",
    "        return ip_dec         # 输入合法时返回其对应的十进制IP\n",
    "    else:\n",
    "        return 'data error!'  # 输入不合法时返回'data error!'\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    IP = input()              # 输入二进制的IP地址字符串\n",
    "    print(check_ip(IP))       # 调用函数判定并完成IP转换"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}