day01-变量和数据类型.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 变量的命名 ##\n",
    "1. 变量名只能包含字母，数字，下划线。变量名可以字母或者下划线打头。但不能数字开头\n",
    "2. 变量名不可以有空格\n",
    "3. 不要将python关键字和函数名作为变量名\n",
    "4. 变量名应间断又具有描述性\n",
    "5. 慎用小写字母l和大写字母O，因为可能被看成数字1和0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello python'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message=\"hello python\"\n",
    "message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 注释"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#大家好"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。\n",
    "如果参数包含方法__dir__()，该方法将被调用\n",
    "如果参数不包含__dir__()，该方法将最大限度地收集参数信息。\n",
    "\n",
    "help() 函数用于查看函数或模块用途的详细说明。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# import使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pep8介绍：https://www.jianshu.com/p/52f4416c267d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数值类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 整数\n",
    "python中，整数可以进行+-*/运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 浮点数\n",
    "python将带小数点的数字都成为浮点数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*0.1\n",
    "0.2+0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# bool\n",
    "Python的布尔类型有两个值：True和False（注意大小写要区分）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "box=True\n",
    "box"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 算数运算符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"reference\">\n",
    "<tbody><tr>\n",
    "<th>运算符</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+</td><td>加 - 两个对象相加</td><td> a + b 输出结果 30</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>-</td><td>减 - 得到负数或是一个数减去另一个数</td><td> a - b 输出结果 -10</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*</td><td>乘 - 两个数相乘或是返回一个被重复若干次的字符串</td><td> a * b 输出结果 200</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>/</td><td>除 - x除以y</td><td> b / a 输出结果 2</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>%</td><td>取模 - 返回除法的余数</td><td> b % a 输出结果 0</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>**</td><td>幂 - 返回x的y次幂</td><td> a**b 为10的20次方， 输出结果 100000000000000000000</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>//</td><td>取整除 - 返回商的整数部分（<strong>向下取整</strong>）</td><td> \n",
    "<pre>&gt;&gt;&gt; 9//2\n",
    "4\n",
    "&gt;&gt;&gt; -9//2\n",
    "-5</pre></td>\n",
    "</tr>\n",
    "</tbody></table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 - c 的值为： 31\n",
      "2 - c 的值为： 11\n",
      "3 - c 的值为： 210\n",
      "4 - c 的值为： 2.1\n",
      "5 - c 的值为： 1\n",
      "6 - c 的值为： 8\n",
      "7 - c 的值为： 2\n"
     ]
    }
   ],
   "source": [
    "a = 21\n",
    "b = 10\n",
    "c = 0\n",
    "#加法 \n",
    "c = a + b\n",
    "print (\"1 - c 的值为：\", c)\n",
    " #减法\n",
    "c = a - b\n",
    "print (\"2 - c 的值为：\", c )\n",
    " #乘法\n",
    "c = a * b\n",
    "print (\"3 - c 的值为：\", c) \n",
    " #除法\n",
    "c = a / b\n",
    "print (\"4 - c 的值为：\", c )\n",
    " #求余\n",
    "c = a % b\n",
    "print (\"5 - c 的值为：\", c)\n",
    " \n",
    "# 修改变量 a 、b 、c\n",
    "a = 2\n",
    "b = 3\n",
    "c = a**b#幂运算 \n",
    "print (\"6 - c 的值为：\", c)\n",
    " \n",
    "a = 10\n",
    "b = 5\n",
    "c = a//b #整除\n",
    "print (\"7 - c 的值为：\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑运算符\n",
    "\n",
    "<table class=\"reference\">\n",
    "<tbody><tr>\n",
    "<th>运算符</th><th>逻辑表达式</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>and</td><td>x and y</td><td> 布尔\"与\" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。\t</td><td> (a and b) 返回 20。</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>or</td><td>x or y</td><td>布尔\"或\"\t- 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。</td><td> (a or b) 返回 10。</td>\n",
    "</tr>\n",
    "<tr><td>not</td><td>not x</td><td>布尔\"非\" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td><td> not(a and b) 返回 False </td>\n",
    "</tr>\n",
    "</tbody></table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a=True\n",
    "b=False\n",
    "print(a and b)\n",
    "print(a or b)\n",
    "print(not b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 成员运算符\n",
    "<table class=\"reference\">\n",
    "<tbody><tr>\n",
    "<th>运算符</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>in</td><td>\n",
    "如果在指定的序列中找到值返回 True，否则返回 False。</td>\n",
    "<td> x 在 y 序列中 , 如果 x 在 y 序列中返回 True。</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not in</td><td>如果在指定的序列中没有找到值返回 True，否则返回 False。</td>\n",
    "<td>x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。</td>\n",
    "</tr>\n",
    "</tbody></table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 is in\n",
      "5 is not in\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,4]\n",
    "if 1 in a:\n",
    "    print(\"1 is in\")\n",
    "if 5 not in a:\n",
    "    print(\"5 is not in\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 身份运算符\n",
    "<table class=\"reference\">\n",
    "<tbody><tr>\n",
    "<th width=\"10%\">运算符</th><th>描述</th><th>实例</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>is</td><td>\n",
    "is 是判断两个标识符是不是引用自一个对象</td><td> <strong>x is y</strong>, 类似 <strong>id(x) == id(y)</strong> , 如果引用的是同一个对象则返回 True，否则返回 False</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>is not</td><td>is not 是判断两个标识符是不是引用自不同对象</td><td><strong> x is not y</strong> ， 类似 <strong>id(a) != id(b)</strong>。如果引用的不是同一个对象则返回结果 True，否则返回 False。 </td>\n",
    "</tr>\n",
    "</tbody></table>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a=30\n",
    "b=10\n",
    "print(a is b)\n",
    "b=30\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 运算优先级\n",
    "<table class=\"reference\">\n",
    "<tbody><tr><th>运算符</th><th>描述</th></tr>\n",
    "<tr>\n",
    "<td>**</td>\n",
    "<td>指数 (最高优先级)</td>\n",
    "</tr><tr>\n",
    "<td>~ + -</td>\n",
    "<td>按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)</td>\n",
    "</tr><tr>\n",
    "<td>* / % //</td>\n",
    "<td>乘，除，取模和取整除</td>\n",
    "</tr><tr>\n",
    "<td>+ -</td>\n",
    "<td>加法减法</td>\n",
    "</tr><tr>\n",
    "<td>&gt;&gt; &lt;&lt;</td>\n",
    "<td>右移，左移运算符</td>\n",
    "</tr><tr>\n",
    "<td>&amp;</td>\n",
    "<td>位 'AND'</td>\n",
    "</tr><tr>\n",
    "<td>^ |</td>\n",
    "<td>位运算符</td>\n",
    "</tr><tr>\n",
    "<td>&lt;= &lt; &gt; &gt;=</td>\n",
    "<td>比较运算符</td>\n",
    "</tr><tr>\n",
    "<td>&lt;&gt; == !=</td>\n",
    "<td>等于运算符</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>= %= /= //= -= += *= **=</td>\n",
    "<td>赋值运算符</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>is is not</td>\n",
    "<td>身份运算符</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>in not in</td>\n",
    "<td>成员运算符</td>\n",
    "</tr><tr>\n",
    "<td>not and or</td>\n",
    "<td>逻辑运算符</td>\n",
    "</tr>\n",
    "</tbody></table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'adddddd'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a\"+\"dddddd\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hahahahahahahaha'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"haha\"*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 删除空白 ##\n",
    "python使用strip()删除空白"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python '"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str=' python '\n",
    "str.lstrip() #删除左侧空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str.rstrip()#右"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'python'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str.strip()#左右"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 其他字符串常用方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "['1', '2', '3', '4', '5']\n",
      "1+2+3+4+5\n",
      "000235\n"
     ]
    }
   ],
   "source": [
    "#类似于java中的indexOf。在字符串中查找子串。返回子串第一次出现在字符串中的索引，没找到返回-1\n",
    "s = \"hello,it's me me\"\n",
    "print(s.find('me'))\n",
    "#split用于将字符串分割成序列\n",
    "print('1+2+3+4+5'.split('+'))\n",
    "#join方法是split的逆方法，用来连接序列中的元素：\n",
    "seq = list('12345')\n",
    "sep='+'\n",
    "print(sep.join(seq))\n",
    "#replace 替换字符串\n",
    "'This is a test'.replace('is','eez')\n",
    "#补0操作\n",
    "print(\"235\".zfill(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 字符串格式化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Vamei. I'm 99 year old\n"
     ]
    }
   ],
   "source": [
    "print(\"I'm %s. I'm %d year old\" % ('Vamei', 99))#和c一样"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 作业\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please input your namelv\n",
      "please input your sexman\n",
      "please input your age18\n",
      "您的姓名是lv,您的性别是man,您是2001年出生的\n"
     ]
    }
   ],
   "source": [
    "\n",
    "name=input(\"please input your name\")\n",
    "sex=input(\"please input your sex\")\n",
    "age=input(\"please input your age\")\n",
    "print(\"您的姓名是{},您的性别是{},您是{}年出生的\".format(name,sex,2019-int(age)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}