第二章  1 运算符、表达式.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.1 Python常用内置对象\n",
    "- 数字 -- int，float，complex\n",
    "- 字符串 -- str\n",
    "- 字节串 -- bytes -- e.g.  *b'hello world'*\n",
    "- 列表 -- list -- #其中元素可以是任意类型\n",
    "- 字典 -- dict -- #元素形式:*\"键:值\"*\n",
    "- 元组 -- tuple -- #如果元组中只有一个元素，后面的逗号不能省略 --e.g. *(3,)*\n",
    "- 集合 -- set，frozenset -- #元素不重复；set可变，frozenset不可变\n",
    "- 布尔型 -- bool\n",
    "- 空类型 -- NoneType -- 空值\n",
    "- 异常\n",
    "- 文件 -- f=open('data.dat','rb') --#返回文件对象\n",
    "- 其他迭代对象\n",
    "- 编程单元 -- e.g.   *函数，类，模块*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1.1 常量与变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=3\n",
    "isinstance(x,int)         #内置函数isinstance()用来测试变量是否为指定类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Python中的变量并不直接存储值，而是存储了值的内存地址或引用地址_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 3]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "x[1] = 5    #修改列表元素值\n",
    "print(x)\n",
    "print(x[2])    #输出显示列表制定元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在Python中定义变量名需注意：\n",
    "     - 变量名**必须**以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义\n",
    "     - 变量名中**不能**有空格或标点符号\n",
    "     - **不能**使用关键字作为变量名  #print(keyword,kwlist)查看此版本关键字，在此之前需import keyword\n",
    "     - 不建议使用系统内置模块名、类型名或函数以及已导入的模块及其成员作为变量名  #可通过dir(__builtins__)查看所有内置对象名称\n",
    "     - 变量名对英文字母的**大小写敏感**，如student与Student是不同的变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1.2 数字\n",
    "### 1. 内置的整数、实数与复数\n",
    "- 整数\n",
    "     - 二进制：0b 开头\n",
    "     - 八进制：0o 开头\n",
    "     - 十六进制：0x 开头 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "9\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "print(0b11)\n",
    "print(0o11)\n",
    "print(0x11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_避免在实数之间直接进行相等性测试，以两者之差的绝对值是否足够小作为两实数是否相等的依据_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(0.4 - 0.1 == 0.3)\n",
    "print(abs(0.4 - 0.1 - 0.3)<1e-6)  #1e-6表示10的-6次方"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "复数类型及其运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8+10j)\n",
      "(-9+38j)\n",
      "4.0\n",
      "3.0\n",
      "5.0\n",
      "(3-4j)\n"
     ]
    }
   ],
   "source": [
    "x = 3+4j\n",
    "y = 5+6j\n",
    "print(x+y)\n",
    "print(x*y)\n",
    "print(x.imag)  #实部\n",
    "print(x.real)  #虚部\n",
    "print(abs(x))  #模\n",
    "print(x.conjugate())  #共轭复数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 分数       \n",
    "### 3.高精度实数 (详见教材p14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1.3 字符串与字节串\n",
    "- 单引号、双引号、三单、三双作为定界符，不同定界符见可相互嵌套"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'good' + ' morning'  #连接字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom said,\"Let's go.\"\n",
      "Tom said,\"Let's go.\"\n"
     ]
    }
   ],
   "source": [
    "x = '''Tom said,\"Let's go.\"'''\n",
    "y = \"Tom said,\\\"Let's go.\\\"\"\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1.4 列表、元组、字典、集合"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "97\n",
      "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_list = [1,2,3,4]\n",
    "print(x_list[2])  #元组同\n",
    "x_dict = {'a':97,'b':98,'c':99}\n",
    "print(x_dict['a'])  #字典对象的下标是“键”\n",
    "x_set = {5,6,7,5,6,8,7,2,3,7,9,8,5,2,1,4,6,8,6,3,8}\n",
    "print(x_set)  #集合中重复项会自动筛去\n",
    "12 in x_set  #成员测试"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.2 Python运算符与表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.1 算术运算符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- +运算符可用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-aab67777ee5f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'abcdefg'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "'abcdefg' + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(True + 3)  #Python内部把True当作1处理\n",
    "print(False + 4)  #把False当作0处理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- *运算符可用于列表、元组、字符串几个序列类型与整数的乘法，表示序列元素的重复，生成新的序列对象。\n",
    "- 字典和集合不支持与整数的相乘，因为其中的元素不允许重复"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 运算符/和//在Python中分别表示算术除法和算术求整商"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4\n",
      "-7\n"
     ]
    }
   ],
   "source": [
    "print(-15//4)\n",
    "print(-19//3)  #保证余数为正"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- %运算符可以用于整数或实数的求余数运算，还可以用于字符串格式化（不推荐）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(-10%8)  #-10减去6可以整除8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A,65\n",
      "65.000000,65\n"
     ]
    }
   ],
   "source": [
    "print('%c,%d'%(65,65))  #把65分别格式化为字符(用c表示)和整数(用d表示)\n",
    "print('%f,%s'%(65,65))  #把65分别格式化为实数(用f表示)和字符串(用s表示)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **运算符表示幂乘，等价于内置函数pow()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(3**2)\n",
    "print(pow(3,2,8))  #等价于(3**2)%8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.2 关系运算符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print('Hello'>'hello')\n",
    "print([1,1,3]<[2,4])  #？？？？？？？？？？？？？？？？？？？\n",
    "print({1,2,3}<{1,2,3,4})  #测试是否为子集\n",
    "print({1,2,3} == {2,3,1})  #测试两集合是否相等"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.3 成员测试运算符in与同一性测试运算符is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 成员测试运算符in测试一个对象是否为另一个对象的元素\n",
    "- 同一性测试运算符is用来测试两个对象是否是同一个，返回结果为True或False。\n",
    "    - 如果两个对象是同一个，则两者具有相同的内存地址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 256\n",
    "y = 256\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 257\n",
    "y = 257\n",
    "print(x is y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = [1,2,3]\n",
    "y = [1,2,3]\n",
    "print(x is y)\n",
    "print(x[2] is y[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.4位运算符与集合运算符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 位运算符只能用于整数，转化为二进制后运算\n",
    "- 位异或运算规则：1^1=0^0=0 、1^0=0^1=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 集合的交集、并集、对称差集、等运算借助于位运算符来实现，二差集测使用减号运算符实现\n",
    "- 需注意，并集运算符不是加号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{2, 3}\n",
      "{1, 4}\n",
      "{1}\n"
     ]
    }
   ],
   "source": [
    "print({1,2,3} | {2,3,4})  #并集\n",
    "print({1,2,3} & {2,3,4})  #交集\n",
    "print({1,2,3} ^ {2,3,4})  #对称差集\n",
    "print({1,2,3} - {2,3,4})  #差集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://img-blog.csdn.net/20171213204214081)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.5 逻辑运算符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 短路问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(3>5 and 4<6)  #and中，由于前者为False，不需要计算后者的值\n",
    "print(3>2 or 4<3)  #or中，由于由于前者为True，不需要计算后者的值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.6 矩阵乘法运算符@（详见p22）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.7 复合赋值运算符\n",
    "- x += 3 等同于 x = x+3 \n",
    "- 其余同理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.3 Python关键字简要说明（详见p24）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)  #查看所有关键字"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}