├── code ├── __init__.py ├── __pycache__ │ ├── __init__.cpython-36.pyc │ ├── company.cpython-36.pyc │ ├── employee.cpython-36.pyc │ └── person.cpython-36.pyc ├── employee.py ├── company.py └── person.py ├── data ├── out.json ├── bikes.csv ├── out.csv ├── out.tsv ├── sample.json ├── df.csv ├── df.tsv ├── sample.csv ├── out.txt └── out2.txt ├── README.md ├── main.py ├── homework ├── homework.ipynb ├── homework 2.ipynb └── homework-answer.ipynb ├── pandas-1-student.ipynb ├── python-basic-2-student.ipynb ├── python-basic-2.ipynb ├── python-basic.ipynb └── python-basic-student.ipynb /code/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /data/out.json: -------------------------------------------------------------------------------- 1 | {"name": "July", "salary": 999999, "title": "CEO", "manager": null} -------------------------------------------------------------------------------- /data/bikes.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZeweiChu/python-basics/HEAD/data/bikes.csv -------------------------------------------------------------------------------- /data/out.csv: -------------------------------------------------------------------------------- 1 | july,baidu,ali,tencent 2 | fb,goog,aapl,msft 3 | 1.2,3.5,amazon,5 4 | -------------------------------------------------------------------------------- /data/out.tsv: -------------------------------------------------------------------------------- 1 | july baidu ali tencent 2 | fb goog aapl msft 3 | 1.2 3.5 amazon 5 4 | -------------------------------------------------------------------------------- /data/sample.json: -------------------------------------------------------------------------------- 1 | {"name": "July", "salary": 999999, "title": "CEO", "manager": null} 2 | -------------------------------------------------------------------------------- /data/df.csv: -------------------------------------------------------------------------------- 1 | ,,x,y,y 2 | ,,1,1,2 3 | a,1,0,1,2 4 | a,2,3,4,5 5 | b,1,6,7,8 6 | c,2,9,10,11 7 | -------------------------------------------------------------------------------- /data/df.tsv: -------------------------------------------------------------------------------- 1 | x y y 2 | 1 1 2 3 | a 1 0 1 2 4 | a 2 3 4 5 5 | b 1 6 7 8 6 | c 2 9 10 11 7 | -------------------------------------------------------------------------------- /code/__pycache__/__init__.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZeweiChu/python-basics/HEAD/code/__pycache__/__init__.cpython-36.pyc -------------------------------------------------------------------------------- /code/__pycache__/company.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZeweiChu/python-basics/HEAD/code/__pycache__/company.cpython-36.pyc -------------------------------------------------------------------------------- /code/__pycache__/employee.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZeweiChu/python-basics/HEAD/code/__pycache__/employee.cpython-36.pyc -------------------------------------------------------------------------------- /code/__pycache__/person.cpython-36.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ZeweiChu/python-basics/HEAD/code/__pycache__/person.cpython-36.pyc -------------------------------------------------------------------------------- /data/sample.csv: -------------------------------------------------------------------------------- 1 | 4/5/2015 13:34,Apples,73 2 | 4/5/2015 3:41,Cherries,85 3 | 4/6/2015 12:46,Pears,14 4 | 4/8/2015 8:59,Oranges,52 5 | 4/10/2015 2:07,Apples,152 6 | 4/10/2015 18:10,Bananas,23 7 | 4/10/2015 2:40,Strawberries,98 -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # [python basics](https://github.com/ZeweiChu/python-basics) 2 | 3 | GitHub repo: [https://github.com/ZeweiChu/python-basics](https://github.com/ZeweiChu/python-basics) 4 | 5 | julyedu线上集训notes 6 | 7 | 褚则伟 8 | 9 | - [第一课](python-basic.ipynb) 10 | - [第二课](python-basic-2.ipynb) 11 | -------------------------------------------------------------------------------- /data/out.txt: -------------------------------------------------------------------------------- 1 | 4/5/2015 13:34,Apples,73 2 | 4/5/2015 3:41,Cherries,85 3 | 4/6/2015 12:46,Pears,14 4 | 4/8/2015 8:59,Oranges,52 5 | 4/10/2015 2:07,Apples,152 6 | 4/10/2015 18:10,Bananas,23 7 | 4/10/2015 2:40,Strawberries,98aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssss -------------------------------------------------------------------------------- /data/out2.txt: -------------------------------------------------------------------------------- 1 | 4/5/2015 13:34,Apples,73 2 | 4/5/2015 3:41,Cherries,85 3 | 4/6/2015 12:46,Pears,14 4 | 4/8/2015 8:59,Oranges,52 5 | 4/10/2015 2:07,Apples,152 6 | 4/10/2015 18:10,Bananas,23 7 | 4/10/2015 2:40,Strawberries,98aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssss -------------------------------------------------------------------------------- /code/employee.py: -------------------------------------------------------------------------------- 1 | from code.person import Person 2 | 3 | class Employee(Person): 4 | def __init__(self, name, ID, title, salary, manager=None): 5 | super().__init__(name, ID) 6 | self.title = title 7 | self.salary = salary 8 | self.manager = manager 9 | 10 | def get_info(self): 11 | return "({}, title: {}, salary: {}, manager: {})".format(super().get_info(), self.title, self.salary, self.manager.get_info() if self.manager is not None else "") 12 | 13 | -------------------------------------------------------------------------------- /code/company.py: -------------------------------------------------------------------------------- 1 | class Company(object): 2 | def __init__(self, name, employees=[]): 3 | self.name = name 4 | self.employees = employees 5 | 6 | def hire(self, employee): 7 | if not employee in self.employees: 8 | self.employees.append(employee) 9 | 10 | def fire(self, employee): 11 | if employee in self.employees: 12 | self.employees.remove(employee) 13 | 14 | def get_info(self): 15 | res = "Company: {}, employees: ".format(self.name) 16 | for employee in self.employees: 17 | res += ", {}".format(employee.get_info()) 18 | return res 19 | 20 | 21 | 22 | 23 | 24 | 25 | -------------------------------------------------------------------------------- /main.py: -------------------------------------------------------------------------------- 1 | from code.employee import Employee 2 | from code.company import * 3 | 4 | if __name__ == "__main__": 5 | july = Employee("July", 1, "CEO", 99999999) 6 | # print(july.get_info()) 7 | zewei = Employee("Zewei", 2, "Lecturer", 1, july) 8 | # print(zewei.get_info()) 9 | 10 | c = Company("Julyedu") 11 | c.hire(july) 12 | c.hire(zewei) 13 | 14 | han = Employee("Han Xiaoyang", 3, "Lecturer", 1000000, july) 15 | c.hire(han) 16 | 17 | print(c.get_info()) 18 | 19 | print("Firing Zewei!!!") 20 | c.fire(zewei) 21 | print(c.get_info()) 22 | 23 | print("Firing Zewei!!!") 24 | c.fire(zewei) 25 | print(c.get_info()) 26 | 27 | c.hire(zewei) 28 | print(c.get_info()) 29 | 30 | # sublime 31 | # namespace 32 | 33 | 34 | -------------------------------------------------------------------------------- /code/person.py: -------------------------------------------------------------------------------- 1 | from abc import ABC, abstractmethod 2 | 3 | class Person(ABC): 4 | @abstractmethod 5 | def __init__(self, name, ID): 6 | self.name = name 7 | self.ID = ID 8 | 9 | @abstractmethod 10 | def get_info(self): 11 | return "name: {}".format(self.name) 12 | 13 | def __eq__(self, other): 14 | return self.ID == other.ID 15 | 16 | # tongjun = Person("Tongjun", "11") 17 | # print(tongjun.get_info()) 18 | 19 | class Student(Person): 20 | def __init__(self, name, ID, level=0): 21 | super().__init__(name, ID) 22 | self.level = level 23 | 24 | def get_info(self): 25 | return "{}, level: {}".format(super().get_info(), self.level) 26 | 27 | def take_exam(self, grade): 28 | if grade.upper() in ["A", "B", "C"]: 29 | self.level += 1 30 | return self.level 31 | 32 | def graduate(self): 33 | print(self.get_info()) 34 | if self.level >= 12: 35 | print("Congratulations! You've graduated from Julyedu.") 36 | return True 37 | else: 38 | print("Sorry, you need to pass {} extra exams!".format(12 - self.level)) 39 | return False 40 | 41 | hongyu = Student("Hongyu", 10, 3) 42 | print(hongyu.get_info()) 43 | hongyu.take_exam("A") 44 | 45 | print(hongyu.get_info()) 46 | hongyu.graduate() 47 | hongyu.take_exam("B") 48 | hongyu.take_exam("B") 49 | hongyu.take_exam("B") 50 | hongyu.take_exam("B") 51 | hongyu.take_exam("B") 52 | hongyu.take_exam("B") 53 | hongyu.take_exam("B") 54 | hongyu.take_exam("B") 55 | hongyu.take_exam("B") 56 | hongyu.take_exam("B") 57 | hongyu.take_exam("B") 58 | hongyu.take_exam("B") 59 | hongyu.take_exam("B") 60 | hongyu.take_exam("B") 61 | print(hongyu.get_info()) 62 | hongyu.graduate() 63 | 64 | 65 | 66 | 67 | -------------------------------------------------------------------------------- /homework/homework.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Python基础作业" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": { 15 | "collapsed": true 16 | }, 17 | "source": [ 18 | "- 在自己的电脑上安装Anaconda，用conda create创建一个python 3.6版本的environment。今后我们的程序都在这个环境下执行" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "- 上网查询，并且自己在jupyter notebook上实验，看看python 3.6当中有哪些常用的数据类型。" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "- 用range创建一个list，命名为variable **numbers**，这个list从100到0，间隔为8。结果应该长下面这样:\n", 33 | "([100, 92, 84, 76, 68, 60, 52, 44, 36, 28, 20, 12, 4])" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "- 用if-elif-else语句判断某个年龄是未成年(<18)，成年(18-60)，还是老年(>=60)。" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "- 用list comprehension把我们前面的**numbers**每个数字都变成它的平方" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "- 用for语句构建一个fibonacci数列，只需要前十个数字即可" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "- 随机写下六个人的名字，构成一个list。" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "- 把这个list变成一个dict，按照顺序给这些名字编号，号码从1开始。key是名字，value是编号。" 69 | ] 70 | } 71 | ], 72 | "metadata": { 73 | "kernelspec": { 74 | "display_name": "Python 3", 75 | "language": "python", 76 | "name": "python3" 77 | }, 78 | "language_info": { 79 | "codemirror_mode": { 80 | "name": "ipython", 81 | "version": 3 82 | }, 83 | "file_extension": ".py", 84 | "mimetype": "text/x-python", 85 | "name": "python", 86 | "nbconvert_exporter": "python", 87 | "pygments_lexer": "ipython3", 88 | "version": "3.6.1" 89 | } 90 | }, 91 | "nbformat": 4, 92 | "nbformat_minor": 2 93 | } 94 | -------------------------------------------------------------------------------- /homework/homework 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## homework:\n", 8 | "\n", 9 | "#### design and implement the following classes\n", 10 | "\n", 11 | "The purpose of this homework is to let you be familiar with writing classes in Python. You are encouraged to be creative when working on this assignment. There is no \"best solution\" to the design of your classes. \n", 12 | "\n", 13 | "- A class **Bank**, including bank name, bank balance, bank ID, accounts, employees. The bank class should have the following functions: adding an account to the bank, remove an account from the bank, and the balance shall be updated accordingly, etc. \n", 14 | "- A class **Customer**, including customer ID, customer name, accounts associated with the customer. Methods include: adding a new account, remove an account, check total balance, etc. \n", 15 | "- A class **Account**, including the account ID, bank ID, balanace, customer ID. Methods of the class are: updating account balanace, get account info, etc. \n", 16 | "- A class **Employee**, including the employee ID, employee name. \n", 17 | "- Write some demo scripts to show how your class can be uses, such as creating a new Bank object, creating a new Customer object, creating a new account at a bank for a customer, remove an account from a bank, update balanace of an account, etc. \n", 18 | "- The aforementioned facts are the aspects that must be implemented, you are encouraged to be creative. Add whatever features(classes, fields, methods, super class) you think are useful to your code. \n", 19 | "- organize your class prototypes and your script of code in different files and import them properly. " 20 | ] 21 | } 22 | ], 23 | "metadata": { 24 | "kernelspec": { 25 | "display_name": "Python 3", 26 | "language": "python", 27 | "name": "python3" 28 | }, 29 | "language_info": { 30 | "codemirror_mode": { 31 | "name": "ipython", 32 | "version": 3 33 | }, 34 | "file_extension": ".py", 35 | "mimetype": "text/x-python", 36 | "name": "python", 37 | "nbconvert_exporter": "python", 38 | "pygments_lexer": "ipython3", 39 | "version": "3.6.1" 40 | } 41 | }, 42 | "nbformat": 4, 43 | "nbformat_minor": 2 44 | } 45 | -------------------------------------------------------------------------------- /homework/homework-answer.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "collapsed": true 7 | }, 8 | "source": [ 9 | "# Python基础作业" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": { 15 | "collapsed": true 16 | }, 17 | "source": [ 18 | "- 在自己的电脑上安装Anaconda，用conda create创建一个python 3.6版本的environment。今后我们的程序都在这个环境下执行" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "- 上网查询，并且自己在jupyter notebook上实验，看看python 3.6当中有哪些常用的数据类型。" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "str, int, float, bool, list, tuple, dict, set ..." 33 | ] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "- 用range创建一个list，命名为variable **numbers**，这个list从100到0，间隔为8。结果应该长下面这样:\n", 40 | "([100, 92, 84, 76, 68, 60, 52, 44, 36, 28, 20, 12, 4])" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "- 用if-elif-else语句判断某个年龄是未成年(<18)，成年(18-60)，还是老年(>=60)。" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 2, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "data": { 57 | "text/plain": [ 58 | "[100, 92, 84, 76, 68, 60, 52, 44, 36, 28, 20, 12, 4]" 59 | ] 60 | }, 61 | "execution_count": 2, 62 | "metadata": {}, 63 | "output_type": "execute_result" 64 | } 65 | ], 66 | "source": [ 67 | "numbers = list(range(100, 0, -8))\n", 68 | "numbers" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "- 用list comprehension把我们前面的**numbers**每个数字都变成它的平方" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 3, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "data": { 85 | "text/plain": [ 86 | "[10000, 8464, 7056, 5776, 4624, 3600, 2704, 1936, 1296, 784, 400, 144, 16]" 87 | ] 88 | }, 89 | "execution_count": 3, 90 | "metadata": {}, 91 | "output_type": "execute_result" 92 | } 93 | ], 94 | "source": [ 95 | "[number ** 2 for number in numbers]" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "- 用for语句构建一个fibonacci数列，只需要前十个数字即可" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 4, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "for loop:\n", 115 | "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n" 116 | ] 117 | } 118 | ], 119 | "source": [ 120 | "print(\"for loop:\")\n", 121 | "fibs = [0, 1]\n", 122 | "for i in range(10):\n", 123 | " fibs.append(fibs[-1] + fibs[-2])\n", 124 | "print(fibs)" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "- 随机写下六个人的名字，构成一个list。" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "- 把这个list变成一个dict，按照顺序给这些名字编号，号码从1开始。" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": { 145 | "collapsed": true 146 | }, 147 | "outputs": [], 148 | "source": [] 149 | } 150 | ], 151 | "metadata": { 152 | "kernelspec": { 153 | "display_name": "Python 3", 154 | "language": "python", 155 | "name": "python3" 156 | }, 157 | "language_info": { 158 | "codemirror_mode": { 159 | "name": "ipython", 160 | "version": 3 161 | }, 162 | "file_extension": ".py", 163 | "mimetype": "text/x-python", 164 | "name": "python", 165 | "nbconvert_exporter": "python", 166 | "pygments_lexer": "ipython3", 167 | "version": "3.6.1" 168 | } 169 | }, 170 | "nbformat": 4, 171 | "nbformat_minor": 2 172 | } 173 | -------------------------------------------------------------------------------- /pandas-1-student.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Pandas教程\n", 8 | "\n", 9 | "### 2017七月在线 机器学习在线集训 julyedu.com\n", 10 | "by 褚则伟 " 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "source": [ 19 | "pandas是一个专门用于数据分析的python library" 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "## [Pandas](http://pandas.pydata.org/)简介\n", 27 | "- python数据分析library\n", 28 | "- 基于numpy (对ndarray的操作)\n", 29 | "- 有一种用python做Excel/SQL/R的感觉" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "## 目录\n", 37 | "- Series\n", 38 | "- DataFrame\n", 39 | "- Index\n", 40 | "- csv文件读写" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "## 数据结构Series\n", 48 | "\n", 49 | "### 2017七月在线 机器学习在线集训 julyedu.com" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "### 构造和初始化Series" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": { 62 | "collapsed": true 63 | }, 64 | "source": [ 65 | "Series是一个一维的数据结构，下面是一些初始化Series的方法。" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "pandas会默认用0到n来作为Series的index，但是我们也可以自己指定index。index我们可以把它理解为dict里面的key。" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "还可以用dictionary来构造一个Series，因为Series本来就是key value pairs。" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "numpy ndarray构建一个Series" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "### 选择数据" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "我们可以像对待一个list一样对待Series" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "为什么下面这样会拿到两个NaN呢？" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "Series就像一个dict，前面定义的index就是用来选择数据的" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "boolean indexing，与numpy类似。" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "下面我再详细展示一下这个boolean indexing是如何工作的" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "### Series元素赋值" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "Series的元素可以被赋值" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "前面讲过的boolean indexing在赋值的时候也可以用" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "### 数学运算" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "下面我们来讲一些基本的数学运算。" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "numpy的运算可以被运用到pandsa上去" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "我们再定义一个新的Series做加法" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "### 数据缺失\n", 185 | "\n", 186 | "[reference](https://pandas.pydata.org/pandas-docs/stable/missing_data.html)" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "## 数据结构[Dataframe](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)\n", 194 | "\n", 195 | "### 2017七月在线 机器学习在线集训 julyedu.com" 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "一个Dataframe就是一张表格，Series表示的是一维数组，Dataframe则是一个二维数组，可以类比成一张excel的spreadsheet。也可以把Dataframe当做一组Series的集合。" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "### 创建一个DataFrame" 210 | ] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "dataframe可以由一个dictionary构造得到。" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "columns的名字和顺序可以指定" 224 | ] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "也可以从几个Series构建一个DataFrame" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "也可以用一个list of dicts来构建DataFrame" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "## 练习" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "metadata": {}, 250 | "source": [ 251 | "- 构建三个Series，分别是一系列商品的单价，计量单位，和数量。至于是什么商品什么计量单位由大家自己决定。\n", 252 | "- 然后把这三个Series合并成一个DataFrame。" 253 | ] 254 | }, 255 | { 256 | "cell_type": "markdown", 257 | "metadata": {}, 258 | "source": [ 259 | "### 2017七月在线 机器学习在线集训 julyedu.com" 260 | ] 261 | }, 262 | { 263 | "cell_type": "markdown", 264 | "metadata": {}, 265 | "source": [ 266 | "## 数据结构DataFrame" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "加入一个新的column,默认会broadcast" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "DataFrame的行由index决定" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "DataFrame的列由column names决定" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "loc方法可以用index选中行" 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "下面这种方法默认用来选列而不是选行" 302 | ] 303 | }, 304 | { 305 | "cell_type": "markdown", 306 | "metadata": {}, 307 | "source": [ 308 | "iloc方法可以用数字选中行" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "行列一起选" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "### DataFrame元素赋值" 323 | ] 324 | }, 325 | { 326 | "cell_type": "markdown", 327 | "metadata": {}, 328 | "source": [ 329 | "可以给一整列赋值" 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "给一整行赋值" 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "还可以用Series来指定需要修改的index以及相对应的value，没有指定的默认用NaN." 344 | ] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "metadata": {}, 349 | "source": [ 350 | "一个DataFrame就和一个numpy 2d array一样，可以被转置" 351 | ] 352 | }, 353 | { 354 | "cell_type": "markdown", 355 | "metadata": {}, 356 | "source": [ 357 | "用info查看DataFrame的信息" 358 | ] 359 | }, 360 | { 361 | "cell_type": "markdown", 362 | "metadata": {}, 363 | "source": [ 364 | "我们还可以指定index的名字和列的名字" 365 | ] 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": [ 371 | "## 课后作业\n", 372 | "- 研究一下pandas当中的broadcast是怎么用的，对比一下numpy中的broadcast" 373 | ] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": {}, 378 | "source": [ 379 | "### 2017七月在线 机器学习在线集训 julyedu.com" 380 | ] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": {}, 385 | "source": [ 386 | "## Index" 387 | ] 388 | }, 389 | { 390 | "cell_type": "markdown", 391 | "metadata": {}, 392 | "source": [ 393 | "### index object" 394 | ] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "自己建一个index object" 401 | ] 402 | }, 403 | { 404 | "cell_type": "markdown", 405 | "metadata": {}, 406 | "source": [ 407 | "从Series里面拿出一个index object" 408 | ] 409 | }, 410 | { 411 | "cell_type": "markdown", 412 | "metadata": {}, 413 | "source": [ 414 | "index的值是不能被更改的" 415 | ] 416 | }, 417 | { 418 | "cell_type": "markdown", 419 | "metadata": {}, 420 | "source": [ 421 | "创建Series时声明index" 422 | ] 423 | }, 424 | { 425 | "cell_type": "markdown", 426 | "metadata": {}, 427 | "source": [ 428 | "sex_index" 429 | ] 430 | }, 431 | { 432 | "cell_type": "markdown", 433 | "metadata": {}, 434 | "source": [ 435 | "### 针对index进行索引和切片" 436 | ] 437 | }, 438 | { 439 | "cell_type": "markdown", 440 | "metadata": {}, 441 | "source": [ 442 | "默认的数字index依旧可以使用" 443 | ] 444 | }, 445 | { 446 | "cell_type": "markdown", 447 | "metadata": {}, 448 | "source": [ 449 | "下面是如何对Series进行切片" 450 | ] 451 | }, 452 | { 453 | "cell_type": "markdown", 454 | "metadata": {}, 455 | "source": [ 456 | "对DataFrame进行Indexing与Series基本相同" 457 | ] 458 | }, 459 | { 460 | "cell_type": "code", 461 | "execution_count": 41, 462 | "metadata": {}, 463 | "outputs": [ 464 | { 465 | "data": { 466 | "text/html": [ 467 | "
\n", 468 | "\n", 481 | "\n", 482 | " \n", 483 | " \n", 484 | " \n", 485 | " \n", 486 | " \n", 487 | " \n", 488 | " \n", 489 | " \n", 490 | " \n", 491 | " \n", 492 | " \n", 493 | " \n", 494 | " \n", 495 | " \n", 496 | " \n", 497 | " \n", 498 | " \n", 499 | " \n", 500 | " \n", 501 | " \n", 502 | " \n", 503 | " \n", 504 | " \n", 505 | " \n", 506 | " \n", 507 | " \n", 508 | " \n", 509 | " \n", 510 | "
xyz
a012
b345
c678
\n", 511 | "
" 512 | ], 513 | "text/plain": [ 514 | " x y z\n", 515 | "a 0 1 2\n", 516 | "b 3 4 5\n", 517 | "c 6 7 8" 518 | ] 519 | }, 520 | "execution_count": 41, 521 | "metadata": {}, 522 | "output_type": "execute_result" 523 | } 524 | ], 525 | "source": [ 526 | "df" 527 | ] 528 | }, 529 | { 530 | "cell_type": "markdown", 531 | "metadata": {}, 532 | "source": [ 533 | "DataFrame也可以用condition selection" 534 | ] 535 | }, 536 | { 537 | "cell_type": "markdown", 538 | "metadata": {}, 539 | "source": [ 540 | "### [reindex](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.reindex.html)" 541 | ] 542 | }, 543 | { 544 | "cell_type": "markdown", 545 | "metadata": {}, 546 | "source": [ 547 | "把一个Series或者DataFrame按照新的index顺序进行重排" 548 | ] 549 | }, 550 | { 551 | "cell_type": "markdown", 552 | "metadata": {}, 553 | "source": [ 554 | "既然我们可以对Series进行reindex，相应地，我们也可以用同样的方法对DataFrame进行reindex。" 555 | ] 556 | }, 557 | { 558 | "cell_type": "markdown", 559 | "metadata": {}, 560 | "source": [ 561 | "在reindex的同时，我们还可以重新指定columns" 562 | ] 563 | }, 564 | { 565 | "cell_type": "markdown", 566 | "metadata": { 567 | "collapsed": true 568 | }, 569 | "source": [ 570 | "下面介绍如何用drop来删除Series和DataFrame中的index" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "drop不仅仅可以删除行，还可以删除列" 578 | ] 579 | }, 580 | { 581 | "cell_type": "markdown", 582 | "metadata": {}, 583 | "source": [ 584 | "### hierarchical index" 585 | ] 586 | }, 587 | { 588 | "cell_type": "markdown", 589 | "metadata": {}, 590 | "source": [ 591 | "Series的hierarchical indexing" 592 | ] 593 | }, 594 | { 595 | "cell_type": "markdown", 596 | "metadata": {}, 597 | "source": [ 598 | "unstack和stack可以帮助我们在hierarchical indexing和DataFrame之间进行切换。" 599 | ] 600 | }, 601 | { 602 | "cell_type": "markdown", 603 | "metadata": {}, 604 | "source": [ 605 | "DataFrame的hierarchical indexing" 606 | ] 607 | }, 608 | { 609 | "cell_type": "markdown", 610 | "metadata": {}, 611 | "source": [ 612 | "## csv文件读写" 613 | ] 614 | }, 615 | { 616 | "cell_type": "markdown", 617 | "metadata": {}, 618 | "source": [ 619 | "- [read_csv](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html)\n", 620 | "- [to_csv](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_csv.html)" 621 | ] 622 | }, 623 | { 624 | "cell_type": "markdown", 625 | "metadata": {}, 626 | "source": [ 627 | "## 课后练习\n", 628 | "download stock data from yahoo finance, and use read_csv to create dataframe, and play with the dataframe. " 629 | ] 630 | } 631 | ], 632 | "metadata": { 633 | "kernelspec": { 634 | "display_name": "Python 3", 635 | "language": "python", 636 | "name": "python3" 637 | }, 638 | "language_info": { 639 | "codemirror_mode": { 640 | "name": "ipython", 641 | "version": 3 642 | }, 643 | "file_extension": ".py", 644 | "mimetype": "text/x-python", 645 | "name": "python", 646 | "nbconvert_exporter": "python", 647 | "pygments_lexer": "ipython3", 648 | "version": "3.6.1" 649 | } 650 | }, 651 | "nbformat": 4, 652 | "nbformat_minor": 2 653 | } 654 | -------------------------------------------------------------------------------- /python-basic-2-student.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "data": { 10 | "text/plain": [ 11 | "1" 12 | ] 13 | }, 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "output_type": "execute_result" 17 | } 18 | ], 19 | "source": [ 20 | "1" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 2, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "8.5" 32 | ] 33 | }, 34 | "execution_count": 2, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "2.5 + 6" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 9, 46 | "metadata": {}, 47 | "outputs": [], 48 | "source": [ 49 | "numbers = [1,2,3,4,5,2,3,4]" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 5, 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/plain": [ 60 | "{1, 2, 3, 4}" 61 | ] 62 | }, 63 | "execution_count": 5, 64 | "metadata": {}, 65 | "output_type": "execute_result" 66 | } 67 | ], 68 | "source": [ 69 | "{1,2,3,4,2,3,3,3,}" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 7, 75 | "metadata": {}, 76 | "outputs": [ 77 | { 78 | "data": { 79 | "text/plain": [ 80 | "2" 81 | ] 82 | }, 83 | "execution_count": 7, 84 | "metadata": {}, 85 | "output_type": "execute_result" 86 | } 87 | ], 88 | "source": [ 89 | "d = {\"key\":\"value\", 1:2}\n", 90 | "d[1]" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 8, 96 | "metadata": {}, 97 | "outputs": [ 98 | { 99 | "name": "stdout", 100 | "output_type": "stream", 101 | "text": [ 102 | "between 10 and 20\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "x = 12\n", 108 | "if x < 10:\n", 109 | " print(\"less than 10\")\n", 110 | "elif x < 20:\n", 111 | " print(\"between 10 and 20\")\n", 112 | "else:\n", 113 | " print(\"larger than or equal to 20\")" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 10, 119 | "metadata": {}, 120 | "outputs": [ 121 | { 122 | "name": "stdout", 123 | "output_type": "stream", 124 | "text": [ 125 | "1\n", 126 | "2\n", 127 | "3\n", 128 | "4\n", 129 | "5\n", 130 | "2\n", 131 | "3\n", 132 | "4\n" 133 | ] 134 | } 135 | ], 136 | "source": [ 137 | "for n in numbers:\n", 138 | " print(n)" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 13, 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "1\n", 151 | "2\n", 152 | "4\n", 153 | "5\n", 154 | "7\n", 155 | "8\n", 156 | "10\n", 157 | "11\n", 158 | "13\n", 159 | "14\n", 160 | "16\n", 161 | "17\n", 162 | "19\n" 163 | ] 164 | } 165 | ], 166 | "source": [ 167 | "i = 0\n", 168 | "while 1:\n", 169 | " if i % 3 == 0:\n", 170 | " i += 1\n", 171 | " continue\n", 172 | " print(i)\n", 173 | " i += 1\n", 174 | " if i >= 20:\n", 175 | " break" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": {}, 181 | "source": [ 182 | "# python 线上集训第二课" 183 | ] 184 | }, 185 | { 186 | "cell_type": "markdown", 187 | "metadata": {}, 188 | "source": [ 189 | "## 目录\n", 190 | "- function\n", 191 | "- class, subclass\n", 192 | "- module\n", 193 | "- read/write\n", 194 | "- csv, json" 195 | ] 196 | }, 197 | { 198 | "cell_type": "markdown", 199 | "metadata": {}, 200 | "source": [ 201 | "## function\n", 202 | "\n", 203 | "- def关键词\n", 204 | "- 用括号包含list of parameters\n", 205 | "- statements都要indent\n" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 29, 211 | "metadata": {}, 212 | "outputs": [ 213 | { 214 | "ename": "UnboundLocalError", 215 | "evalue": "local variable 'res' referenced before assignment", 216 | "output_type": "error", 217 | "traceback": [ 218 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 219 | "\u001b[1;31mUnboundLocalError\u001b[0m Traceback (most recent call last)", 220 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 13\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 15\u001b[1;33m \u001b[0mr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfib\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 16\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mr\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 17\u001b[0m \u001b[1;31m#fib(10, 2)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 221 | "\u001b[1;32m\u001b[0m in \u001b[0;36mfib\u001b[1;34m(n, start)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mfib\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mstart\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mres\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 222 | "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'res' referenced before assignment" 223 | ] 224 | } 225 | ], 226 | "source": [ 227 | "def fib(n,start=0):\n", 228 | " a, b = 0, 1\n", 229 | " print(res)\n", 230 | " res = []\n", 231 | " for i in range(n):\n", 232 | " if i < start:\n", 233 | " a, b = b, a+b\n", 234 | " continue\n", 235 | " # print(a, end=\" \")\n", 236 | " res.append(a)\n", 237 | " a, b = b, a+b\n", 238 | " #print()\n", 239 | " return res\n", 240 | "\n", 241 | "r = fib(5)\n", 242 | "print(r)\n", 243 | "#fib(10, 2)" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "metadata": {}, 249 | "source": [ 250 | "### 不定长度的arguments" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 39, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "name": "stdout", 260 | "output_type": "stream", 261 | "text": [ 262 | "(12, 15, 'a', 'July')\n" 263 | ] 264 | }, 265 | { 266 | "data": { 267 | "text/plain": [ 268 | "'12,15,a,July'" 269 | ] 270 | }, 271 | "execution_count": 39, 272 | "metadata": {}, 273 | "output_type": "execute_result" 274 | } 275 | ], 276 | "source": [ 277 | "def concatenate(*args, sep=\" \"):\n", 278 | " aaaa = [str(a) for a in args]\n", 279 | " print(args)\n", 280 | " return sep.join(aaaa)\n", 281 | " \n", 282 | "concatenate(12, 15, \"a\", \"July\", sep=\",\")" 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "### default argument\n", 290 | "concat例子" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "### 把一个tuple/list当做arguments\n", 298 | "\n" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": 50, 304 | "metadata": {}, 305 | "outputs": [ 306 | { 307 | "name": "stdout", 308 | "output_type": "stream", 309 | "text": [ 310 | "2 5\n" 311 | ] 312 | }, 313 | { 314 | "data": { 315 | "text/plain": [ 316 | "function" 317 | ] 318 | }, 319 | "execution_count": 50, 320 | "metadata": {}, 321 | "output_type": "execute_result" 322 | } 323 | ], 324 | "source": [ 325 | "def unpack_args(a, b):\n", 326 | " print(a, b)\n", 327 | "\n", 328 | "r = [2, 5]\n", 329 | "# r = (2, 5)\n", 330 | "unpack_args(*r)\n", 331 | "\n", 332 | "type(unpack_args)" 333 | ] 334 | }, 335 | { 336 | "cell_type": "markdown", 337 | "metadata": {}, 338 | "source": [ 339 | "### 关于模块化(modularity)\n", 340 | "\n", 341 | "function的作用是拿到一些参数，做一些运算或者别的更加复杂的操作，然后返回一些结果。\n", 342 | "\n", 343 | "(25min)" 344 | ] 345 | }, 346 | { 347 | "cell_type": "markdown", 348 | "metadata": {}, 349 | "source": [ 350 | "# Class入门\n", 351 | "\n", 352 | "\n", 353 | "## Object oriented programming 面向对象编程\n", 354 | "\n", 355 | "```class```关键字用来定义一个class(类)。\n", 356 | "\n", 357 | "之前我们学习的都是python自带的数据类型，class是我们自己定义的类型。\n", 358 | "\n", 359 | "- object和class之间的关系\n", 360 | "class是一个模板，我们可以把class类比成一个数据类型。object是class的一个实例，就好比a是一个int，我们可以把int类比成一个class,把a类比成一个object。\n", 361 | "\n", 362 | "- 什么是```self```?\n", 363 | "- 什么是```__init__```?\n", 364 | "- pass statement\n", 365 | "- 用dir inspect一个object\n", 366 | "\n", 367 | "\n" 368 | ] 369 | }, 370 | { 371 | "cell_type": "markdown", 372 | "metadata": {}, 373 | "source": [ 374 | "# subclass(子类)\n", 375 | "\n", 376 | "## 什么是subclass\n", 377 | "\n", 378 | "subclass是base class的继承，一个subclass可以继承所有base class的field和method，在base class的基础上做拓展。\n", 379 | "\n", 380 | "\n", 381 | "- Abstract Base Class (abc)" 382 | ] 383 | }, 384 | { 385 | "cell_type": "markdown", 386 | "metadata": {}, 387 | "source": [ 388 | "# Iterator and Generator\n", 389 | "\n", 390 | "## iterator\n", 391 | "\n" 392 | ] 393 | }, 394 | { 395 | "cell_type": "markdown", 396 | "metadata": { 397 | "collapsed": true 398 | }, 399 | "source": [ 400 | "定义一个class的时候，如果我们在class中定义```__iter__```和```__next__```两个method就能把这个class变成一个iterator。\n" 401 | ] 402 | }, 403 | { 404 | "cell_type": "markdown", 405 | "metadata": {}, 406 | "source": [ 407 | "## Generator\n", 408 | "\n" 409 | ] 410 | }, 411 | { 412 | "cell_type": "markdown", 413 | "metadata": {}, 414 | "source": [ 415 | "还有一个function叫做zip" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": null, 421 | "metadata": { 422 | "collapsed": true 423 | }, 424 | "outputs": [], 425 | "source": [] 426 | }, 427 | { 428 | "cell_type": "markdown", 429 | "metadata": {}, 430 | "source": [ 431 | "## File IO" 432 | ] 433 | }, 434 | { 435 | "cell_type": "code", 436 | "execution_count": 84, 437 | "metadata": { 438 | "collapsed": true 439 | }, 440 | "outputs": [], 441 | "source": [ 442 | "in_file = open(\"data/sample.csv\", \"r\")" 443 | ] 444 | }, 445 | { 446 | "cell_type": "code", 447 | "execution_count": 85, 448 | "metadata": {}, 449 | "outputs": [], 450 | "source": [ 451 | "content = in_file.read()" 452 | ] 453 | }, 454 | { 455 | "cell_type": "code", 456 | "execution_count": 68, 457 | "metadata": { 458 | "scrolled": true 459 | }, 460 | "outputs": [ 461 | { 462 | "name": "stdout", 463 | "output_type": "stream", 464 | "text": [ 465 | "4/5/2015 13:34,Apples,73\n", 466 | "\n", 467 | "4/5/2015 3:41,Cherries,85\n", 468 | "\n", 469 | "4/6/2015 12:46,Pears,14\n", 470 | "\n", 471 | "4/8/2015 8:59,Oranges,52\n", 472 | "\n", 473 | "4/10/2015 2:07,Apples,152\n", 474 | "\n", 475 | "4/10/2015 18:10,Bananas,23\n", 476 | "\n", 477 | "4/10/2015 2:40,Strawberries,98\n" 478 | ] 479 | } 480 | ], 481 | "source": [ 482 | "for line in in_file:\n", 483 | " print(line)" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 70, 489 | "metadata": {}, 490 | "outputs": [ 491 | { 492 | "name": "stdout", 493 | "output_type": "stream", 494 | "text": [ 495 | "4/5/2015 13:34,Apples,73\n", 496 | "\n", 497 | "4/5/2015 3:41,Cherries,85\n", 498 | "\n", 499 | "4/6/2015 12:46,Pears,14\n", 500 | "\n", 501 | "4/8/2015 8:59,Oranges,52\n", 502 | "\n", 503 | "4/10/2015 2:07,Apples,152\n", 504 | "\n", 505 | "4/10/2015 18:10,Bananas,23\n", 506 | "\n", 507 | "4/10/2015 2:40,Strawberries,98\n" 508 | ] 509 | } 510 | ], 511 | "source": [ 512 | "with open(\"data/sample.csv\", \"r\") as fin:\n", 513 | " for line in fin:\n", 514 | " print(line)" 515 | ] 516 | }, 517 | { 518 | "cell_type": "code", 519 | "execution_count": 63, 520 | "metadata": {}, 521 | "outputs": [ 522 | { 523 | "data": { 524 | "text/plain": [ 525 | "str" 526 | ] 527 | }, 528 | "execution_count": 63, 529 | "metadata": {}, 530 | "output_type": "execute_result" 531 | } 532 | ], 533 | "source": [ 534 | "type(content)" 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 65, 540 | "metadata": {}, 541 | "outputs": [ 542 | { 543 | "data": { 544 | "text/plain": [ 545 | "[['4/5/2015 13:34', 'Apples', '73'],\n", 546 | " ['4/5/2015 3:41', 'Cherries', '85'],\n", 547 | " ['4/6/2015 12:46', 'Pears', '14'],\n", 548 | " ['4/8/2015 8:59', 'Oranges', '52'],\n", 549 | " ['4/10/2015 2:07', 'Apples', '152'],\n", 550 | " ['4/10/2015 18:10', 'Bananas', '23'],\n", 551 | " ['4/10/2015 2:40', 'Strawberries', '98']]" 552 | ] 553 | }, 554 | "execution_count": 65, 555 | "metadata": {}, 556 | "output_type": "execute_result" 557 | } 558 | ], 559 | "source": [ 560 | "[line.split(\",\") for line in content.split(\"\\n\")]" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": 86, 566 | "metadata": { 567 | "collapsed": true 568 | }, 569 | "outputs": [], 570 | "source": [ 571 | "in_file.close()" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 89, 577 | "metadata": {}, 578 | "outputs": [ 579 | { 580 | "data": { 581 | "text/plain": [ 582 | "'4/5/2015 13:34,Apples,73\\n4/5/2015 3:41,Cherries,85\\n4/6/2015 12:46,Pears,14\\n4/8/2015 8:59,Oranges,52\\n4/10/2015 2:07,Apples,152\\n4/10/2015 18:10,Bananas,23\\n4/10/2015 2:40,Strawberries,98aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssssaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssss'" 583 | ] 584 | }, 585 | "execution_count": 89, 586 | "metadata": {}, 587 | "output_type": "execute_result" 588 | } 589 | ], 590 | "source": [ 591 | "content += \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasssssssssssssssssssssssss\"\n", 592 | "content" 593 | ] 594 | }, 595 | { 596 | "cell_type": "code", 597 | "execution_count": 93, 598 | "metadata": {}, 599 | "outputs": [], 600 | "source": [ 601 | "out_file = open(\"data/out.txt\", \"w\")\n", 602 | "out_file.write(content)\n", 603 | "out_file.close()" 604 | ] 605 | }, 606 | { 607 | "cell_type": "code", 608 | "execution_count": 94, 609 | "metadata": { 610 | "collapsed": true 611 | }, 612 | "outputs": [], 613 | "source": [ 614 | "with open(\"data/out2.txt\", \"w\") as fout:\n", 615 | " fout.write(content)" 616 | ] 617 | }, 618 | { 619 | "cell_type": "markdown", 620 | "metadata": {}, 621 | "source": [ 622 | "# csv和json格式数据\n", 623 | "\n", 624 | "## csv(comma separated values)\n", 625 | "\n", 626 | "关于module csv\n", 627 | "\n", 628 | "- reader\n", 629 | "- writer" 630 | ] 631 | }, 632 | { 633 | "cell_type": "code", 634 | "execution_count": 114, 635 | "metadata": { 636 | "collapsed": true 637 | }, 638 | "outputs": [], 639 | "source": [ 640 | "import csv\n", 641 | "in_file = open(\"data/sample.csv\", \"r\")\n", 642 | "csv_reader = csv.reader(in_file)" 643 | ] 644 | }, 645 | { 646 | "cell_type": "code", 647 | "execution_count": 96, 648 | "metadata": { 649 | "collapsed": true 650 | }, 651 | "outputs": [], 652 | "source": [] 653 | }, 654 | { 655 | "cell_type": "code", 656 | "execution_count": 102, 657 | "metadata": {}, 658 | "outputs": [], 659 | "source": [ 660 | "data = list(csv_reader)" 661 | ] 662 | }, 663 | { 664 | "cell_type": "code", 665 | "execution_count": 115, 666 | "metadata": {}, 667 | "outputs": [ 668 | { 669 | "name": "stdout", 670 | "output_type": "stream", 671 | "text": [ 672 | "line #: 1, content: ['4/5/2015 13:34', 'Apples', '73']\n", 673 | "line #: 2, content: ['4/5/2015 3:41', 'Cherries', '85']\n", 674 | "line #: 3, content: ['4/6/2015 12:46', 'Pears', '14']\n", 675 | "line #: 4, content: ['4/8/2015 8:59', 'Oranges', '52']\n", 676 | "line #: 5, content: ['4/10/2015 2:07', 'Apples', '152']\n", 677 | "line #: 6, content: ['4/10/2015 18:10', 'Bananas', '23']\n", 678 | "line #: 7, content: ['4/10/2015 2:40', 'Strawberries', '98']\n" 679 | ] 680 | } 681 | ], 682 | "source": [ 683 | "for line in csv_reader:\n", 684 | " print(\"line #: {}, content: {}\".format(csv_reader.line_num, line))" 685 | ] 686 | }, 687 | { 688 | "cell_type": "code", 689 | "execution_count": 113, 690 | "metadata": { 691 | "collapsed": true 692 | }, 693 | "outputs": [], 694 | "source": [ 695 | "in_file.close()" 696 | ] 697 | }, 698 | { 699 | "cell_type": "code", 700 | "execution_count": 117, 701 | "metadata": { 702 | "collapsed": true 703 | }, 704 | "outputs": [], 705 | "source": [ 706 | "out_file = open(\"data/out.tsv\", \"w\")\n", 707 | "out_writer = csv.writer(out_file, delimiter=\"\\t\")\n", 708 | "out_writer.writerow([\"july\", \"baidu\", \"ali\", \"tencent\"])\n", 709 | "out_writer.writerow([\"fb\", \"goog\", \"aapl\", \"msft\"])\n", 710 | "out_writer.writerow([1.2, 3.5, \"amazon\", 5])\n", 711 | "out_file.close()" 712 | ] 713 | }, 714 | { 715 | "cell_type": "markdown", 716 | "metadata": {}, 717 | "source": [ 718 | "## json (javascript object notation)\n", 719 | "\n", 720 | "关于module json\n", 721 | "\n", 722 | "- loads\n", 723 | "- load\n", 724 | "- dumps\n", 725 | "- dump\n" 726 | ] 727 | }, 728 | { 729 | "cell_type": "code", 730 | "execution_count": 118, 731 | "metadata": { 732 | "collapsed": true 733 | }, 734 | "outputs": [], 735 | "source": [ 736 | "import json\n", 737 | "data = '{\"name\": \"July\", \"salary\": 999999, \"title\": \"CEO\", \"manager\": null}'" 738 | ] 739 | }, 740 | { 741 | "cell_type": "code", 742 | "execution_count": 119, 743 | "metadata": {}, 744 | "outputs": [ 745 | { 746 | "data": { 747 | "text/plain": [ 748 | "{'manager': None, 'name': 'July', 'salary': 999999, 'title': 'CEO'}" 749 | ] 750 | }, 751 | "execution_count": 119, 752 | "metadata": {}, 753 | "output_type": "execute_result" 754 | } 755 | ], 756 | "source": [ 757 | "json_data = json.loads(data)\n", 758 | "json_data" 759 | ] 760 | }, 761 | { 762 | "cell_type": "code", 763 | "execution_count": 121, 764 | "metadata": {}, 765 | "outputs": [ 766 | { 767 | "data": { 768 | "text/plain": [ 769 | "'July'" 770 | ] 771 | }, 772 | "execution_count": 121, 773 | "metadata": {}, 774 | "output_type": "execute_result" 775 | } 776 | ], 777 | "source": [ 778 | "type(json_data)\n", 779 | "json_data[\"name\"]" 780 | ] 781 | }, 782 | { 783 | "cell_type": "code", 784 | "execution_count": 122, 785 | "metadata": {}, 786 | "outputs": [ 787 | { 788 | "name": "stdout", 789 | "output_type": "stream", 790 | "text": [ 791 | "\n", 792 | "{'name': 'July', 'salary': 999999, 'title': 'CEO', 'manager': None}\n" 793 | ] 794 | } 795 | ], 796 | "source": [ 797 | "in_file = open(\"data/sample.json\", \"r\")\n", 798 | "json_data = json.load(in_file)\n", 799 | "in_file.close()\n", 800 | "print(type(json_data))\n", 801 | "print(json_data)\n" 802 | ] 803 | }, 804 | { 805 | "cell_type": "code", 806 | "execution_count": 124, 807 | "metadata": {}, 808 | "outputs": [ 809 | { 810 | "data": { 811 | "text/plain": [ 812 | "dict" 813 | ] 814 | }, 815 | "execution_count": 124, 816 | "metadata": {}, 817 | "output_type": "execute_result" 818 | } 819 | ], 820 | "source": [ 821 | "type(json_data)" 822 | ] 823 | }, 824 | { 825 | "cell_type": "code", 826 | "execution_count": 125, 827 | "metadata": {}, 828 | "outputs": [ 829 | { 830 | "name": "stdout", 831 | "output_type": "stream", 832 | "text": [ 833 | "\n" 834 | ] 835 | }, 836 | { 837 | "data": { 838 | "text/plain": [ 839 | "'{\"name\": \"July\", \"salary\": 999999, \"title\": \"CEO\", \"manager\": null}'" 840 | ] 841 | }, 842 | "execution_count": 125, 843 | "metadata": {}, 844 | "output_type": "execute_result" 845 | } 846 | ], 847 | "source": [ 848 | "json_dumped = json.dumps(json_data)\n", 849 | "print(type(json_dumped))\n", 850 | "json_dumped" 851 | ] 852 | }, 853 | { 854 | "cell_type": "code", 855 | "execution_count": 126, 856 | "metadata": { 857 | "collapsed": true 858 | }, 859 | "outputs": [], 860 | "source": [ 861 | "json.dump(json_data, open(\"data/out.json\", \"w\"))" 862 | ] 863 | }, 864 | { 865 | "cell_type": "code", 866 | "execution_count": 6, 867 | "metadata": { 868 | "collapsed": true 869 | }, 870 | "outputs": [], 871 | "source": [ 872 | "# 120min" 873 | ] 874 | } 875 | ], 876 | "metadata": { 877 | "kernelspec": { 878 | "display_name": "Python 3", 879 | "language": "python", 880 | "name": "python3" 881 | }, 882 | "language_info": { 883 | "codemirror_mode": { 884 | "name": "ipython", 885 | "version": 3 886 | }, 887 | "file_extension": ".py", 888 | "mimetype": "text/x-python", 889 | "name": "python", 890 | "nbconvert_exporter": "python", 891 | "pygments_lexer": "ipython3", 892 | "version": "3.6.1" 893 | } 894 | }, 895 | "nbformat": 4, 896 | "nbformat_minor": 2 897 | } 898 | -------------------------------------------------------------------------------- /python-basic-2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# python 线上集训第二课" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## 目录\n", 15 | "- function\n", 16 | "- class, subclass\n", 17 | "- module" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## function\n", 25 | "\n", 26 | "- def关键词\n", 27 | "- 用括号包含list of parameters\n", 28 | "- statements都要indent\n" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 2, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stdout", 38 | "output_type": "stream", 39 | "text": [ 40 | "0 1 1 2 3 \n", 41 | "0 1 1 2 3 5 8 13 21 34 \n" 42 | ] 43 | } 44 | ], 45 | "source": [ 46 | "def fib(n):\n", 47 | " a, b = 0, 1\n", 48 | " for i in range(n):\n", 49 | " print(a, end=\" \")\n", 50 | " a, b = b, a+b\n", 51 | " print()\n", 52 | "\n", 53 | "fib(5)\n", 54 | "fib(10)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "### 不定长度的arguments" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 4, 67 | "metadata": { 68 | "scrolled": true 69 | }, 70 | "outputs": [ 71 | { 72 | "name": "stdout", 73 | "output_type": "stream", 74 | "text": [ 75 | "\n", 76 | "('hello', 'world', 'julyter', 'notebook')\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "def print_all(*args):\n", 82 | " print(type(args))\n", 83 | " print(args)\n", 84 | "\n", 85 | "print_all(\"hello\", \"world\", \"julyter\", \"notebook\")" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "### default argument\n", 93 | "concat例子" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": 7, 99 | "metadata": { 100 | "scrolled": true 101 | }, 102 | "outputs": [ 103 | { 104 | "name": "stdout", 105 | "output_type": "stream", 106 | "text": [ 107 | "hello,world,jupyter,notebook,julyedu,1,2,3,4,5\n" 108 | ] 109 | } 110 | ], 111 | "source": [ 112 | "def concatenate(*args, sep=\" \"):\n", 113 | " args = [str(a) for a in args]\n", 114 | " print(sep.join(args))\n", 115 | "\n", 116 | "concatenate(\"hello\", \"world\", \"jupyter\", \"notebook\", \\\n", 117 | " \"julyedu\", 1, 2, 3, 4, 5, sep=\",\")" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "### 把一个tuple/list当做arguments\n", 125 | "\n" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 10, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "name": "stdout", 135 | "output_type": "stream", 136 | "text": [ 137 | "2 5\n" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "def unpack_args(a, b):\n", 143 | " print(a, b)\n", 144 | "\n", 145 | "r = [2,5]\n", 146 | "r = 2,5\n", 147 | "# unpack_args(r) # 会报错\n", 148 | "unpack_args(*r) # 运行正常了" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "### 关于模块化(modularity)\n", 156 | "\n", 157 | "function的作用是拿到一些参数，做一些运算或者别的更加复杂的操作，然后返回一些结果。\n", 158 | "\n", 159 | "(25min)" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "# Class入门\n", 167 | "\n", 168 | "\n", 169 | "## Object oriented programming 面向对象编程\n", 170 | "\n", 171 | "```class```关键字用来定义一个class(类)。\n", 172 | "\n", 173 | "之前我们学习的都是python自带的数据类型，class是我们自己定义的类型。\n", 174 | "\n", 175 | "- object和class之间的关系\n", 176 | "class是一个模板，我们可以把class类比成一个数据类型。object是class的一个实例，就好比a是一个int，我们可以把int类比成一个class,把a类比成一个object。\n", 177 | "\n", 178 | "- 什么是```self```?\n", 179 | "- 什么是```__init__```?\n", 180 | "- pass statement\n", 181 | "- 用dir inspect一个object\n", 182 | "\n", 183 | "\n" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 2, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "name": "stdout", 193 | "output_type": "stream", 194 | "text": [ 195 | "(Employee name: July, title: CEO, salary: 99999999, manager: )\n", 196 | "(Employee name: Zewei, title: Lecturer, salary: 1, manager: (Employee name: July, title: CEO, salary: 99999999, manager: ))\n" 197 | ] 198 | } 199 | ], 200 | "source": [ 201 | "class Employee(object):\n", 202 | "\n", 203 | "\tdef __init__(self, name, ID, title, salary, manager=None):\n", 204 | "\t\tself.name = name\n", 205 | "\t\tself.ID = ID\n", 206 | "\t\tself.title = title\n", 207 | "\t\tself.salary = salary\n", 208 | "\t\tself.manager = manager\n", 209 | "\n", 210 | "\tdef get_info(self):\n", 211 | "\t\treturn \"(Employee name: {}, title: {}, salary: {}, manager: {})\".format(self.name, self.title, self.salary, self.manager.get_info() if self.manager is not None else \"\")\n", 212 | "\n", 213 | "\tdef __eq__(self, other):\n", 214 | "\t\treturn self.ID == other.ID\n", 215 | "\n", 216 | "july = Employee(\"July\", 1, \"CEO\", 99999999)\n", 217 | "print(july.get_info())\n", 218 | "zewei = Employee(\"Zewei\", 2, \"Lecturer\", 1, july)\n", 219 | "print(zewei.get_info())\n", 220 | "\n", 221 | "# (40min)" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": 3, 227 | "metadata": {}, 228 | "outputs": [ 229 | { 230 | "name": "stdout", 231 | "output_type": "stream", 232 | "text": [ 233 | "Company: Julyedu, employees: , (Employee name: July, title: CEO, salary: 99999999, manager: ), (Employee name: Zewei, title: Lecturer, salary: 1, manager: (Employee name: July, title: CEO, salary: 99999999, manager: )), (Employee name: Han, title: Lecturer, salary: 100000, manager: (Employee name: July, title: CEO, salary: 99999999, manager: ))\n", 234 | "Firing zewei!\n", 235 | "Company: Julyedu, employees: , (Employee name: July, title: CEO, salary: 99999999, manager: ), (Employee name: Han, title: Lecturer, salary: 100000, manager: (Employee name: July, title: CEO, salary: 99999999, manager: ))\n", 236 | "Firing zewei!\n", 237 | "Company: Julyedu, employees: , (Employee name: July, title: CEO, salary: 99999999, manager: ), (Employee name: Han, title: Lecturer, salary: 100000, manager: (Employee name: July, title: CEO, salary: 99999999, manager: ))\n" 238 | ] 239 | } 240 | ], 241 | "source": [ 242 | "class Company(object):\n", 243 | "\n", 244 | "\tdef __init__(self, name, employees = []):\n", 245 | "\t\tself.name = name\n", 246 | "\t\tself.employees = employees\n", 247 | "\n", 248 | "\tdef hire(self, employee):\n", 249 | "\t\tif not employee in self.employees:\n", 250 | "\t\t\tself.employees.append(employee)\n", 251 | "\n", 252 | "\tdef fire(self, employee):\n", 253 | "\t\tif employee in self.employees:\n", 254 | "\t\t\tself.employees.remove(employee)\n", 255 | "\n", 256 | "\tdef get_info(self):\n", 257 | "\t\tres = \"Company: {}, employees: \".format(self.name)\n", 258 | "\t\tfor employee in self.employees:\n", 259 | "\t\t\tres += \", {}\".format(employee.get_info())\n", 260 | "\t\treturn res\n", 261 | "\n", 262 | "c = Company(\"Julyedu\")\n", 263 | "c.hire(july)\n", 264 | "c.hire(zewei)\n", 265 | "\n", 266 | "han = Employee(\"Han\", 3, \"Lecturer\", 100000, july)\n", 267 | "\n", 268 | "c.hire(han)\n", 269 | "\n", 270 | "print(c.get_info())\n", 271 | "\n", 272 | "print(\"Firing zewei!\")\n", 273 | "c.fire(zewei)\n", 274 | "print(c.get_info())\n", 275 | "\n", 276 | "print(\"Firing zewei!\")\n", 277 | "c.fire(zewei)\n", 278 | "print(c.get_info())\n", 279 | "\n", 280 | "# (55min)" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "# subclass(子类)\n", 288 | "\n", 289 | "## 什么是subclass\n", 290 | "\n", 291 | "subclass是base class的继承，一个subclass可以继承所有base class的field和method，在base class的基础上做拓展。\n", 292 | "\n", 293 | "\n", 294 | "- Abstract Base Class (abc)" 295 | ] 296 | }, 297 | { 298 | "cell_type": "code", 299 | "execution_count": 4, 300 | "metadata": {}, 301 | "outputs": [ 302 | { 303 | "name": "stdout", 304 | "output_type": "stream", 305 | "text": [ 306 | "(name: July, title: CEO, salary: 99999999, manager: No manager)\n", 307 | "(name: Zewei, title: Lecturer, salary: 1, manager: (name: July, title: CEO, salary: 99999999, manager: No manager))\n", 308 | "Company: Julyedu, employees: , (name: July, title: CEO, salary: 99999999, manager: No manager), (name: Zewei, title: Lecturer, salary: 1, manager: (name: July, title: CEO, salary: 99999999, manager: No manager)), (name: Han, title: Lecturer, salary: 100000, manager: (name: July, title: CEO, salary: 99999999, manager: No manager))\n", 309 | "Firing zewei!\n", 310 | "Company: Julyedu, employees: , (name: July, title: CEO, salary: 99999999, manager: No manager), (name: Han, title: Lecturer, salary: 100000, manager: (name: July, title: CEO, salary: 99999999, manager: No manager))\n", 311 | "Firing zewei!\n", 312 | "Company: Julyedu, employees: , (name: July, title: CEO, salary: 99999999, manager: No manager), (name: Han, title: Lecturer, salary: 100000, manager: (name: July, title: CEO, salary: 99999999, manager: No manager))\n" 313 | ] 314 | } 315 | ], 316 | "source": [ 317 | "from abc import ABC, abstractmethod\n", 318 | "\n", 319 | "\n", 320 | "class Person(ABC):\n", 321 | "\t@abstractmethod\n", 322 | "\tdef __init__(self, name, ID):\n", 323 | "\t\tself.name = name\n", 324 | "\t\tself.ID = ID\n", 325 | "\n", 326 | "\t@abstractmethod\n", 327 | "\tdef get_info(self):\n", 328 | "\t\treturn \"name: {}\".format(self.name)\n", 329 | "\n", 330 | "# a = Person(\"Aaron\", 20)\n", 331 | "# print(a.get_info())\n", 332 | "\n", 333 | "'''\n", 334 | "Student class\n", 335 | "\n", 336 | "'''\n", 337 | "class Student(Person):\n", 338 | "\n", 339 | "\t# method\n", 340 | "\tdef __init__(self, name, ID, level=0):\n", 341 | "\t\t# field\n", 342 | "\t\t# self refers to the object that is being created\n", 343 | "\t\tsuper().__init__(name, ID)\n", 344 | "\t\tself.level = level\n", 345 | "\n", 346 | "\tdef get_info(self):\n", 347 | "\t\treturn \"{} ,level: {}\".format(super().get_info(), self.level)\n", 348 | "\n", 349 | "\tdef take_exam(self, grade):\n", 350 | "\t\tif grade.upper() in [\"A\", \"B\", \"C\"]:\n", 351 | "\t\t\tself.level += 1\n", 352 | "\t\treturn self.level\n", 353 | "\n", 354 | "\tdef graduate(self):\n", 355 | "\t\tself.print_info()\n", 356 | "\t\tif self.level >= 12:\n", 357 | "\t\t\tprint(\"Congratulations, you've graduated from Julyedu\")\n", 358 | "\t\t\treturn True\n", 359 | "\t\telse:\n", 360 | "\t\t\tprint(\"Sorry, you need to pass {} extra exams\".format(12-self.level))\n", 361 | "\t\t\treturn False\n", 362 | "\n", 363 | "\n", 364 | "class Employee(Person):\n", 365 | "\n", 366 | "\tdef __init__(self, name, ID, title, salary, manager=None):\n", 367 | "\t\tsuper().__init__(name, ID)\n", 368 | "\t\tself.title = title\n", 369 | "\t\tself.salary = salary\n", 370 | "\t\tself.manager = manager\n", 371 | "\n", 372 | "\tdef get_info(self):\n", 373 | "\t\treturn \"({}, title: {}, salary: {}, manager: {})\".format(super().get_info(), self.title, self.salary, self.manager.get_info() if self.manager is not None else \"No manager\")\n", 374 | "\n", 375 | "\n", 376 | "\n", 377 | "july = Employee(\"July\", 1, \"CEO\", 99999999)\n", 378 | "print(july.get_info())\n", 379 | "zewei = Employee(\"Zewei\", 2, \"Lecturer\", 1, july)\n", 380 | "print(zewei.get_info())\n", 381 | "\n", 382 | "\n", 383 | "class Company(object):\n", 384 | "\n", 385 | "\tdef __init__(self, name, employees = []):\n", 386 | "\t\tself.name = name\n", 387 | "\t\tself.employees = employees\n", 388 | "\n", 389 | "\tdef hire(self, employee):\n", 390 | "\t\tif not employee in self.employees:\n", 391 | "\t\t\tself.employees.append(employee)\n", 392 | "\n", 393 | "\tdef fire(self, employee):\n", 394 | "\t\tif employee in self.employees:\n", 395 | "\t\t\tself.employees.remove(employee)\n", 396 | "\n", 397 | "\tdef get_info(self):\n", 398 | "\t\tres = \"Company: {}, employees: \".format(self.name)\n", 399 | "\t\tfor employee in self.employees:\n", 400 | "\t\t\tres += \", {}\".format(employee.get_info())\n", 401 | "\t\treturn res\n", 402 | "\n", 403 | "c = Company(\"Julyedu\")\n", 404 | "c.hire(july)\n", 405 | "c.hire(zewei)\n", 406 | "\n", 407 | "han = Employee(\"Han\", 3, \"Lecturer\", 100000, july)\n", 408 | "\n", 409 | "c.hire(han)\n", 410 | "\n", 411 | "print(c.get_info())\n", 412 | "\n", 413 | "print(\"Firing zewei!\")\n", 414 | "c.fire(zewei)\n", 415 | "print(c.get_info())\n", 416 | "\n", 417 | "print(\"Firing zewei!\")\n", 418 | "c.fire(zewei)\n", 419 | "print(c.get_info())\n", 420 | "# (70min)" 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "# Iterator and Generator\n", 428 | "\n", 429 | "## iterator\n", 430 | "\n" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 14, 436 | "metadata": {}, 437 | "outputs": [ 438 | { 439 | "name": "stdout", 440 | "output_type": "stream", 441 | "text": [ 442 | "0\n", 443 | "1\n", 444 | "2\n", 445 | "3\n" 446 | ] 447 | }, 448 | { 449 | "ename": "StopIteration", 450 | "evalue": "", 451 | "output_type": "error", 452 | "traceback": [ 453 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 454 | "\u001b[1;31mStopIteration\u001b[0m Traceback (most recent call last)", 455 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 456 | "\u001b[1;31mStopIteration\u001b[0m: " 457 | ] 458 | } 459 | ], 460 | "source": [ 461 | "x = iter([0, 1, 2, 3])\n", 462 | "print(next(x))\n", 463 | "print(next(x))\n", 464 | "print(next(x))\n", 465 | "print(next(x))\n", 466 | "print(next(x))" 467 | ] 468 | }, 469 | { 470 | "cell_type": "markdown", 471 | "metadata": { 472 | "collapsed": true 473 | }, 474 | "source": [ 475 | "定义一个class的时候，如果我们在class中定义```__iter__```和```__next__```两个method就能把这个class变成一个iterator。\n" 476 | ] 477 | }, 478 | { 479 | "cell_type": "code", 480 | "execution_count": 15, 481 | "metadata": {}, 482 | "outputs": [ 483 | { 484 | "name": "stdout", 485 | "output_type": "stream", 486 | "text": [ 487 | "0\n", 488 | "1\n", 489 | "2\n", 490 | "3\n", 491 | "4\n", 492 | "5\n", 493 | "6\n", 494 | "7\n", 495 | "8\n", 496 | "9\n", 497 | "10\n", 498 | "11\n" 499 | ] 500 | } 501 | ], 502 | "source": [ 503 | "class Yrange(object):\n", 504 | " def __init__(self, n):\n", 505 | " self.i = 0\n", 506 | " self.n = n\n", 507 | " def __iter__(self):\n", 508 | " return self\n", 509 | " def __next__(self):\n", 510 | " if self.i < self.n:\n", 511 | " i = self.i\n", 512 | " self.i += 1\n", 513 | " return i\n", 514 | " else:\n", 515 | " raise StopIteration\n", 516 | "for i in Yrange(12):\n", 517 | " print(i)" 518 | ] 519 | }, 520 | { 521 | "cell_type": "markdown", 522 | "metadata": {}, 523 | "source": [ 524 | "## Generator\n", 525 | "\n" 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 16, 531 | "metadata": {}, 532 | "outputs": [ 533 | { 534 | "name": "stdout", 535 | "output_type": "stream", 536 | "text": [ 537 | "0\n", 538 | "1\n", 539 | "2\n", 540 | "3\n", 541 | "4\n" 542 | ] 543 | } 544 | ], 545 | "source": [ 546 | "def zrange(n):\n", 547 | " i = 0\n", 548 | " while i < n:\n", 549 | " yield(i)\n", 550 | " i += 1\n", 551 | "\n", 552 | "for i in zrange(5):\n", 553 | " print(i)" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": null, 559 | "metadata": { 560 | "collapsed": true 561 | }, 562 | "outputs": [], 563 | "source": [ 564 | "## enumerate和zip\n", 565 | "\n", 566 | "- enumerator\n", 567 | "\n", 568 | "\n" 569 | ] 570 | }, 571 | { 572 | "cell_type": "code", 573 | "execution_count": 21, 574 | "metadata": {}, 575 | "outputs": [ 576 | { 577 | "name": "stdout", 578 | "output_type": "stream", 579 | "text": [ 580 | "0 FB\n", 581 | "1 GOOGLE\n", 582 | "2 APPLE\n", 583 | "3 AMAZON\n" 584 | ] 585 | } 586 | ], 587 | "source": [ 588 | "names = [\"FB\", \"GOOGLE\", \"APPLE\", \"AMAZON\"]\n", 589 | "for i, name in enumerate(names):\n", 590 | " print(i, name)" 591 | ] 592 | }, 593 | { 594 | "cell_type": "markdown", 595 | "metadata": {}, 596 | "source": [ 597 | "还有一个function叫做zip" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": 5, 603 | "metadata": { 604 | "scrolled": true 605 | }, 606 | "outputs": [ 607 | { 608 | "ename": "NameError", 609 | "evalue": "name 'names' is not defined", 610 | "output_type": "error", 611 | "traceback": [ 612 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 613 | "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", 614 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mnumbers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;33m[\u001b[0m \u001b[1;34m\"{} {}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnames\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnumbers\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m# 90min\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", 615 | "\u001b[1;31mNameError\u001b[0m: name 'names' is not defined" 616 | ] 617 | } 618 | ], 619 | "source": [ 620 | "numbers = list(range(4))\n", 621 | "[ \"{} {}\".format(a, b) for a, b in zip(names, numbers) ]\n", 622 | "\n", 623 | "# 90min" 624 | ] 625 | }, 626 | { 627 | "cell_type": "markdown", 628 | "metadata": {}, 629 | "source": [ 630 | "# csv和json格式数据\n", 631 | "\n", 632 | "## csv(comma separated values)\n", 633 | "\n", 634 | "关于module csv\n", 635 | "\n", 636 | "- reader\n", 637 | "- writer" 638 | ] 639 | }, 640 | { 641 | "cell_type": "code", 642 | "execution_count": 28, 643 | "metadata": { 644 | "scrolled": true 645 | }, 646 | "outputs": [ 647 | { 648 | "name": "stdout", 649 | "output_type": "stream", 650 | "text": [ 651 | "[['4/5/2015 13:34', 'Apples', '73'], ['4/5/2015 3:41', 'Cherries', '85'], ['4/6/2015 12:46', 'Pears', '14'], ['4/8/2015 8:59', 'Oranges', '52'], ['4/10/2015 2:07', 'Apples', '152'], ['4/10/2015 18:10', 'Bananas', '23'], ['4/10/2015 2:40', 'Strawberries', '98']]\n", 652 | "line #: 1, content: ['4/5/2015 13:34', 'Apples', '73']\n", 653 | "line #: 2, content: ['4/5/2015 3:41', 'Cherries', '85']\n", 654 | "line #: 3, content: ['4/6/2015 12:46', 'Pears', '14']\n", 655 | "line #: 4, content: ['4/8/2015 8:59', 'Oranges', '52']\n", 656 | "line #: 5, content: ['4/10/2015 2:07', 'Apples', '152']\n", 657 | "line #: 6, content: ['4/10/2015 18:10', 'Bananas', '23']\n", 658 | "line #: 7, content: ['4/10/2015 2:40', 'Strawberries', '98']\n" 659 | ] 660 | } 661 | ], 662 | "source": [ 663 | "import csv\n", 664 | "\n", 665 | "\n", 666 | "in_file = open(\"data/sample.csv\", \"r\")\n", 667 | "csv_reader = csv.reader(in_file)\n", 668 | "data = list(csv_reader)\n", 669 | "print(data)\n", 670 | "in_file.close()\n", 671 | "\n", 672 | "in_file = open(\"data/sample.csv\", \"r\")\n", 673 | "csv_reader = csv.reader(in_file)\n", 674 | "for line in csv_reader:\n", 675 | "\tprint(\"line #: {}, content: {}\".format(csv_reader.line_num, line))\n", 676 | "in_file.close()\n", 677 | "\n", 678 | "out_file = open(\"output.csv\", \"w\")\n", 679 | "out_writer = csv.writer(out_file)\n", 680 | "out_writer.writerow([\"julyedu\", \"baidu\", \"tencent\", \"alibaba\"])\n", 681 | "out_writer.writerow([\"fb\", \"goog\", \"aapl\", \"amzn\"])\n", 682 | "out_writer.writerow([1, -2, 3.1111, 4.5])\n", 683 | "out_file.close()\n", 684 | "\n", 685 | "out_file = open(\"output.tsv\", \"w\")\n", 686 | "out_writer = csv.writer(out_file, delimiter=\"\\t\")\n", 687 | "out_writer.writerow([\"julyedu\", \"baidu\", \"tencent\", \"alibaba\"])\n", 688 | "out_writer.writerow([\"fb\", \"goog\", \"aapl\", \"amzn\"])\n", 689 | "out_writer.writerow([1, -2, 3.1111, 4.5])\n", 690 | "out_file.close()\n" 691 | ] 692 | }, 693 | { 694 | "cell_type": "markdown", 695 | "metadata": {}, 696 | "source": [ 697 | "## json (javascript object notation)\n", 698 | "\n", 699 | "关于module json\n", 700 | "\n", 701 | "- loads\n", 702 | "- load\n", 703 | "- dumps\n", 704 | "- dump\n" 705 | ] 706 | }, 707 | { 708 | "cell_type": "code", 709 | "execution_count": 31, 710 | "metadata": { 711 | "scrolled": true 712 | }, 713 | "outputs": [ 714 | { 715 | "name": "stdout", 716 | "output_type": "stream", 717 | "text": [ 718 | "\n", 719 | "{'name': 'July', 'salary': 999999, 'title': 'CEO', 'manager': None}\n", 720 | "\n", 721 | "{'name': 'July', 'salary': 999999, 'title': 'CEO', 'manager': None}\n", 722 | "\n", 723 | "{\"name\": \"July\", \"salary\": 999999, \"title\": \"CEO\", \"manager\": null}\n" 724 | ] 725 | } 726 | ], 727 | "source": [ 728 | "import json\n", 729 | "\n", 730 | "data = '{\"name\": \"July\", \"salary\": 999999, \"title\": \"CEO\", \"manager\": null}'\n", 731 | "\n", 732 | "json_data = json.loads(data)\n", 733 | "\n", 734 | "print(type(json_data))\n", 735 | "print(json_data)\n", 736 | "\n", 737 | "json_data = json.load(open(\"data/sample.json\", \"r\"))\n", 738 | "print(type(json_data))\n", 739 | "print(json_data)\n", 740 | "\n", 741 | "dumped_json = json.dumps(json_data)\n", 742 | "print(type(dumped_json))\n", 743 | "print(dumped_json)\n", 744 | "\n", 745 | "json.dump(json_data, open(\"data/out.json\", \"w\"))" 746 | ] 747 | }, 748 | { 749 | "cell_type": "code", 750 | "execution_count": 6, 751 | "metadata": { 752 | "collapsed": true 753 | }, 754 | "outputs": [], 755 | "source": [ 756 | "# 120min" 757 | ] 758 | } 759 | ], 760 | "metadata": { 761 | "kernelspec": { 762 | "display_name": "Python 3", 763 | "language": "python", 764 | "name": "python3" 765 | }, 766 | "language_info": { 767 | "codemirror_mode": { 768 | "name": "ipython", 769 | "version": 3 770 | }, 771 | "file_extension": ".py", 772 | "mimetype": "text/x-python", 773 | "name": "python", 774 | "nbconvert_exporter": "python", 775 | "pygments_lexer": "ipython3", 776 | "version": "3.6.1" 777 | } 778 | }, 779 | "nbformat": 4, 780 | "nbformat_minor": 2 781 | } 782 | -------------------------------------------------------------------------------- /python-basic.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Python基础\n", 8 | "\n", 9 | "### 目录\n", 10 | "- python简介\n", 11 | "- 安装和运行\n", 12 | "- 基本数据类型\n", 13 | "- 变量和表达式\n", 14 | "- 字符串\n", 15 | "- list\n", 16 | "- 判断语句\n", 17 | "- 循环语句\n", 18 | "- set, tuple, dictionary" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "# Python简介\n", 26 | "- 官网: https://www.python.org/\n", 27 | "- 版本: **3.6**/2.7\n", 28 | "- 脚本语言，语法、调试都很方便，非常适合编程菜鸟入门\n", 29 | "\n", 30 | "## Python安装\n", 31 | "\n", 32 | "### Anaconda安装\n", 33 | "- Anaconda是一个常用的用于数据分析的Python版本管理系统\n", 34 | "- 从[官网](https://www.continuum.io/downloads)下载相应版本\n", 35 | "- 按照提示安装\n", 36 | "\n", 37 | "### Anaconda environment安装\n", 38 | "- 安装一个新的environment: conda create -n [your_environment_name] python=[your_python_version]\n", 39 | "- 进入已经安装的environment: source activate [your_environment_name]\n", 40 | "- 在windows下使用: activate [your_environment_name]\n", 41 | "- 退出当前environment: source deactivate\n", 42 | "- 查看environment: conda info --envs\n", 43 | "- 更多的conda命令请查询官网文档: https://conda.io/docs/index.html\n", 44 | "\n", 45 | "### 在environment下安装libraries\n", 46 | "- pip install [package_name]\n", 47 | "\n", 48 | "## 运行Python\n", 49 | "1. 在命令行上输入python\n", 50 | "2. 用文本编辑器写完一段程序然后运行\n", 51 | "\n", 52 | "## 如何寻找帮助\n", 53 | "- 官方文档\n", 54 | "- debug: 学会读报错信息\n", 55 | "- Goole和Stackoverflow\n", 56 | "\n", 57 | "（10 mins）" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "## python程序基础\n", 65 | "### 用python做计算器\n", 66 | "- +, -, *\n", 67 | "- /, //\n", 68 | "- \\*\\*" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 2, 74 | "metadata": {}, 75 | "outputs": [ 76 | { 77 | "data": { 78 | "text/plain": [ 79 | "34" 80 | ] 81 | }, 82 | "execution_count": 2, 83 | "metadata": {}, 84 | "output_type": "execute_result" 85 | } 86 | ], 87 | "source": [ 88 | "12 + 22" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 3, 94 | "metadata": {}, 95 | "outputs": [ 96 | { 97 | "data": { 98 | "text/plain": [ 99 | "54.0" 100 | ] 101 | }, 102 | "execution_count": 3, 103 | "metadata": {}, 104 | "output_type": "execute_result" 105 | } 106 | ], 107 | "source": [ 108 | "15 * 3.6" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 4, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "data": { 118 | "text/plain": [ 119 | "20.7" 120 | ] 121 | }, 122 | "execution_count": 4, 123 | "metadata": {}, 124 | "output_type": "execute_result" 125 | } 126 | ], 127 | "source": [ 128 | "25 - 4.3" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 5, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "text/plain": [ 139 | "6.25" 140 | ] 141 | }, 142 | "execution_count": 5, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "25 / 4" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": 7, 154 | "metadata": {}, 155 | "outputs": [ 156 | { 157 | "data": { 158 | "text/plain": [ 159 | "6" 160 | ] 161 | }, 162 | "execution_count": 7, 163 | "metadata": {}, 164 | "output_type": "execute_result" 165 | } 166 | ], 167 | "source": [ 168 | "25 // 4" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": 9, 174 | "metadata": {}, 175 | "outputs": [ 176 | { 177 | "data": { 178 | "text/plain": [ 179 | "280.7412308013823" 180 | ] 181 | }, 182 | "execution_count": 9, 183 | "metadata": {}, 184 | "output_type": "execute_result" 185 | } 186 | ], 187 | "source": [ 188 | "3.5 ** 4.5" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "- =, ==\n", 196 | "- string\n", 197 | "- escape" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "# Python基本数据类型、变量、运算和表达式\n", 205 | "\n", 206 | "## 变量\n", 207 | "- 变量赋值(assignment)\n", 208 | "\n", 209 | "## 基本数据类型\n", 210 | "- 整型int\n", 211 | "- 浮点float\n", 212 | "- 数据类型强制转换\n", 213 | "- 四则运算\n", 214 | "- 字符串str\n", 215 | "- bool\n", 216 | "\n", 217 | "## 动态类型\n", 218 | "- python是一种动态类型的语言\n", 219 | "- type(来查看变量类型)" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 10, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "data": { 229 | "text/plain": [ 230 | "int" 231 | ] 232 | }, 233 | "execution_count": 10, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "x = 12\n", 240 | "type(x)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 11, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "text/plain": [ 251 | "float" 252 | ] 253 | }, 254 | "execution_count": 11, 255 | "metadata": {}, 256 | "output_type": "execute_result" 257 | } 258 | ], 259 | "source": [ 260 | "x = -5.4\n", 261 | "type(x)" 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 12, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "data": { 271 | "text/plain": [ 272 | "str" 273 | ] 274 | }, 275 | "execution_count": 12, 276 | "metadata": {}, 277 | "output_type": "execute_result" 278 | } 279 | ], 280 | "source": [ 281 | "x = \"Julyedu\"\n", 282 | "type(x)" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 13, 288 | "metadata": {}, 289 | "outputs": [ 290 | { 291 | "data": { 292 | "text/plain": [ 293 | "NoneType" 294 | ] 295 | }, 296 | "execution_count": 13, 297 | "metadata": {}, 298 | "output_type": "execute_result" 299 | } 300 | ], 301 | "source": [ 302 | "x = None\n", 303 | "type(x)" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "metadata": { 310 | "collapsed": true 311 | }, 312 | "outputs": [], 313 | "source": [] 314 | }, 315 | { 316 | "cell_type": "markdown", 317 | "metadata": {}, 318 | "source": [ 319 | "## 表达式(expression)\n", 320 | "- 引用变量\n", 321 | "- x += x, x *= y, x /= y\n", 322 | "- python会用表达式计算（返回）出一个结果\n", 323 | "\n", 324 | "## 指令(statement)\n", 325 | "- python会执行一条指令，未必会返回一个结果\n", 326 | "- expression可以被当做一个statement，但是statement一般不是一个expression\n", 327 | "- 赋值statement\n", 328 | "\n" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 14, 334 | "metadata": { 335 | "scrolled": true 336 | }, 337 | "outputs": [ 338 | { 339 | "data": { 340 | "text/plain": [ 341 | "17" 342 | ] 343 | }, 344 | "execution_count": 14, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "x = 12\n", 351 | "x + 5" 352 | ] 353 | }, 354 | { 355 | "cell_type": "markdown", 356 | "metadata": {}, 357 | "source": [ 358 | "x" 359 | ] 360 | }, 361 | { 362 | "cell_type": "code", 363 | "execution_count": 16, 364 | "metadata": {}, 365 | "outputs": [ 366 | { 367 | "data": { 368 | "text/plain": [ 369 | "17" 370 | ] 371 | }, 372 | "execution_count": 16, 373 | "metadata": {}, 374 | "output_type": "execute_result" 375 | } 376 | ], 377 | "source": [ 378 | "x += 5\n", 379 | "x" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": 8, 385 | "metadata": { 386 | "collapsed": true 387 | }, 388 | "outputs": [], 389 | "source": [ 390 | "# 25min" 391 | ] 392 | }, 393 | { 394 | "cell_type": "markdown", 395 | "metadata": {}, 396 | "source": [ 397 | "## 字符串(string)\n", 398 | "\n", 399 | "quote ' 和double quote \" 都可以用作字符串" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 17, 405 | "metadata": {}, 406 | "outputs": [ 407 | { 408 | "data": { 409 | "text/plain": [ 410 | "'Julyedu'" 411 | ] 412 | }, 413 | "execution_count": 17, 414 | "metadata": {}, 415 | "output_type": "execute_result" 416 | } 417 | ], 418 | "source": [ 419 | "'Julyedu'" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 18, 425 | "metadata": {}, 426 | "outputs": [ 427 | { 428 | "data": { 429 | "text/plain": [ 430 | "'Julyedu'" 431 | ] 432 | }, 433 | "execution_count": 18, 434 | "metadata": {}, 435 | "output_type": "execute_result" 436 | } 437 | ], 438 | "source": [ 439 | "\"Julyedu\"" 440 | ] 441 | }, 442 | { 443 | "cell_type": "markdown", 444 | "metadata": {}, 445 | "source": [ 446 | "两者之间在表示一个字符串上没有区别，但是一个字符串的开头和结尾必须使用同一种引号。\n", 447 | "backslash \\ 可以用来escape引号。" 448 | ] 449 | }, 450 | { 451 | "cell_type": "code", 452 | "execution_count": 20, 453 | "metadata": {}, 454 | "outputs": [ 455 | { 456 | "data": { 457 | "text/plain": [ 458 | "\"I'm gonna get up at 4am tomorrow\"" 459 | ] 460 | }, 461 | "execution_count": 20, 462 | "metadata": {}, 463 | "output_type": "execute_result" 464 | } 465 | ], 466 | "source": [ 467 | "'I\\'m gonna get up at 4am tomorrow'" 468 | ] 469 | }, 470 | { 471 | "cell_type": "markdown", 472 | "metadata": {}, 473 | "source": [ 474 | "当然也可以使用两种不同的引号来区分究竟是字符串结尾还是字符串中出现了引号。" 475 | ] 476 | }, 477 | { 478 | "cell_type": "code", 479 | "execution_count": 22, 480 | "metadata": {}, 481 | "outputs": [ 482 | { 483 | "data": { 484 | "text/plain": [ 485 | "\"I'm gonna get up at 4am tomorrow\"" 486 | ] 487 | }, 488 | "execution_count": 22, 489 | "metadata": {}, 490 | "output_type": "execute_result" 491 | } 492 | ], 493 | "source": [ 494 | "\"I'm gonna get up at 4am tomorrow\"" 495 | ] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "如果一个string有好多行" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": 23, 507 | "metadata": {}, 508 | "outputs": [ 509 | { 510 | "name": "stdout", 511 | "output_type": "stream", 512 | "text": [ 513 | "first line\n", 514 | "second line\n", 515 | "third line\n" 516 | ] 517 | } 518 | ], 519 | "source": [ 520 | "print(\"\"\"first line\n", 521 | "second line\n", 522 | "third line\"\"\")" 523 | ] 524 | }, 525 | { 526 | "cell_type": "markdown", 527 | "metadata": {}, 528 | "source": [ 529 | "\\n 是换行符，可以用在strign中换行" 530 | ] 531 | }, 532 | { 533 | "cell_type": "code", 534 | "execution_count": 25, 535 | "metadata": {}, 536 | "outputs": [ 537 | { 538 | "name": "stdout", 539 | "output_type": "stream", 540 | "text": [ 541 | "first line\n", 542 | "second line\n", 543 | "thirdline\n" 544 | ] 545 | } 546 | ], 547 | "source": [ 548 | "print(\"first line\\nsecond line\\nthirdline\")" 549 | ] 550 | }, 551 | { 552 | "cell_type": "markdown", 553 | "metadata": {}, 554 | "source": [ 555 | "\\t是tab键" 556 | ] 557 | }, 558 | { 559 | "cell_type": "markdown", 560 | "metadata": {}, 561 | "source": [ 562 | "+可以把两个string连到一起(concatenation)" 563 | ] 564 | }, 565 | { 566 | "cell_type": "code", 567 | "execution_count": 26, 568 | "metadata": {}, 569 | "outputs": [ 570 | { 571 | "data": { 572 | "text/plain": [ 573 | "'hello world'" 574 | ] 575 | }, 576 | "execution_count": 26, 577 | "metadata": {}, 578 | "output_type": "execute_result" 579 | } 580 | ], 581 | "source": [ 582 | "\"hello\" + \" \" + \"world\"" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "metadata": {}, 588 | "source": [ 589 | "## string indexing and slicing\n", 590 | "- indexing" 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": 28, 596 | "metadata": {}, 597 | "outputs": [ 598 | { 599 | "data": { 600 | "text/plain": [ 601 | "'J'" 602 | ] 603 | }, 604 | "execution_count": 28, 605 | "metadata": {}, 606 | "output_type": "execute_result" 607 | } 608 | ], 609 | "source": [ 610 | "w = \"Julyedu\"\n", 611 | "w[0]" 612 | ] 613 | }, 614 | { 615 | "cell_type": "code", 616 | "execution_count": 29, 617 | "metadata": {}, 618 | "outputs": [ 619 | { 620 | "data": { 621 | "text/plain": [ 622 | "'u'" 623 | ] 624 | }, 625 | "execution_count": 29, 626 | "metadata": {}, 627 | "output_type": "execute_result" 628 | } 629 | ], 630 | "source": [ 631 | "w[1]" 632 | ] 633 | }, 634 | { 635 | "cell_type": "code", 636 | "execution_count": 31, 637 | "metadata": {}, 638 | "outputs": [ 639 | { 640 | "data": { 641 | "text/plain": [ 642 | "'u'" 643 | ] 644 | }, 645 | "execution_count": 31, 646 | "metadata": {}, 647 | "output_type": "execute_result" 648 | } 649 | ], 650 | "source": [ 651 | "w[-1]" 652 | ] 653 | }, 654 | { 655 | "cell_type": "code", 656 | "execution_count": 32, 657 | "metadata": {}, 658 | "outputs": [ 659 | { 660 | "data": { 661 | "text/plain": [ 662 | "'e'" 663 | ] 664 | }, 665 | "execution_count": 32, 666 | "metadata": {}, 667 | "output_type": "execute_result" 668 | } 669 | ], 670 | "source": [ 671 | "w[-3]" 672 | ] 673 | }, 674 | { 675 | "cell_type": "code", 676 | "execution_count": 33, 677 | "metadata": {}, 678 | "outputs": [ 679 | { 680 | "ename": "IndexError", 681 | "evalue": "string index out of range", 682 | "output_type": "error", 683 | "traceback": [ 684 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 685 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 686 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mw\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 687 | "\u001b[1;31mIndexError\u001b[0m: string index out of range" 688 | ] 689 | } 690 | ], 691 | "source": [ 692 | "w[-100]" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "- slicing" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": 34, 705 | "metadata": {}, 706 | "outputs": [ 707 | { 708 | "data": { 709 | "text/plain": [ 710 | "'ul'" 711 | ] 712 | }, 713 | "execution_count": 34, 714 | "metadata": {}, 715 | "output_type": "execute_result" 716 | } 717 | ], 718 | "source": [ 719 | "w[1:3]" 720 | ] 721 | }, 722 | { 723 | "cell_type": "code", 724 | "execution_count": 35, 725 | "metadata": {}, 726 | "outputs": [ 727 | { 728 | "data": { 729 | "text/plain": [ 730 | "'Jul'" 731 | ] 732 | }, 733 | "execution_count": 35, 734 | "metadata": {}, 735 | "output_type": "execute_result" 736 | } 737 | ], 738 | "source": [ 739 | "w[:3]" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": 36, 745 | "metadata": {}, 746 | "outputs": [ 747 | { 748 | "data": { 749 | "text/plain": [ 750 | "'du'" 751 | ] 752 | }, 753 | "execution_count": 36, 754 | "metadata": {}, 755 | "output_type": "execute_result" 756 | } 757 | ], 758 | "source": [ 759 | "w[5:7]" 760 | ] 761 | }, 762 | { 763 | "cell_type": "code", 764 | "execution_count": 37, 765 | "metadata": {}, 766 | "outputs": [ 767 | { 768 | "data": { 769 | "text/plain": [ 770 | "'d'" 771 | ] 772 | }, 773 | "execution_count": 37, 774 | "metadata": {}, 775 | "output_type": "execute_result" 776 | } 777 | ], 778 | "source": [ 779 | "w[5:-1]" 780 | ] 781 | }, 782 | { 783 | "cell_type": "code", 784 | "execution_count": 38, 785 | "metadata": {}, 786 | "outputs": [ 787 | { 788 | "data": { 789 | "text/plain": [ 790 | "'du'" 791 | ] 792 | }, 793 | "execution_count": 38, 794 | "metadata": {}, 795 | "output_type": "execute_result" 796 | } 797 | ], 798 | "source": [ 799 | "w[5:]" 800 | ] 801 | }, 802 | { 803 | "cell_type": "code", 804 | "execution_count": 39, 805 | "metadata": {}, 806 | "outputs": [ 807 | { 808 | "data": { 809 | "text/plain": [ 810 | "'du'" 811 | ] 812 | }, 813 | "execution_count": 39, 814 | "metadata": {}, 815 | "output_type": "execute_result" 816 | } 817 | ], 818 | "source": [ 819 | "w[5:100]" 820 | ] 821 | }, 822 | { 823 | "cell_type": "code", 824 | "execution_count": 40, 825 | "metadata": {}, 826 | "outputs": [ 827 | { 828 | "data": { 829 | "text/plain": [ 830 | "'u'" 831 | ] 832 | }, 833 | "execution_count": 40, 834 | "metadata": {}, 835 | "output_type": "execute_result" 836 | } 837 | ], 838 | "source": [ 839 | "w[-1:100]" 840 | ] 841 | }, 842 | { 843 | "cell_type": "markdown", 844 | "metadata": {}, 845 | "source": [ 846 | "## 字符串函数\n", 847 | "\n", 848 | "- upper and lower" 849 | ] 850 | }, 851 | { 852 | "cell_type": "code", 853 | "execution_count": 41, 854 | "metadata": {}, 855 | "outputs": [ 856 | { 857 | "data": { 858 | "text/plain": [ 859 | "'JULYEDU'" 860 | ] 861 | }, 862 | "execution_count": 41, 863 | "metadata": {}, 864 | "output_type": "execute_result" 865 | } 866 | ], 867 | "source": [ 868 | "w.upper()" 869 | ] 870 | }, 871 | { 872 | "cell_type": "code", 873 | "execution_count": 42, 874 | "metadata": {}, 875 | "outputs": [ 876 | { 877 | "data": { 878 | "text/plain": [ 879 | "'julyedu'" 880 | ] 881 | }, 882 | "execution_count": 42, 883 | "metadata": {}, 884 | "output_type": "execute_result" 885 | } 886 | ], 887 | "source": [ 888 | "w.lower()" 889 | ] 890 | }, 891 | { 892 | "cell_type": "code", 893 | "execution_count": 43, 894 | "metadata": {}, 895 | "outputs": [ 896 | { 897 | "data": { 898 | "text/plain": [ 899 | "'Julyedu'" 900 | ] 901 | }, 902 | "execution_count": 43, 903 | "metadata": {}, 904 | "output_type": "execute_result" 905 | } 906 | ], 907 | "source": [ 908 | "w.capitalize()" 909 | ] 910 | }, 911 | { 912 | "cell_type": "markdown", 913 | "metadata": {}, 914 | "source": [ 915 | "- startswith and endswith" 916 | ] 917 | }, 918 | { 919 | "cell_type": "code", 920 | "execution_count": 44, 921 | "metadata": {}, 922 | "outputs": [ 923 | { 924 | "data": { 925 | "text/plain": [ 926 | "True" 927 | ] 928 | }, 929 | "execution_count": 44, 930 | "metadata": {}, 931 | "output_type": "execute_result" 932 | } 933 | ], 934 | "source": [ 935 | "w.endswith(\"du\")" 936 | ] 937 | }, 938 | { 939 | "cell_type": "code", 940 | "execution_count": 45, 941 | "metadata": {}, 942 | "outputs": [ 943 | { 944 | "data": { 945 | "text/plain": [ 946 | "True" 947 | ] 948 | }, 949 | "execution_count": 45, 950 | "metadata": {}, 951 | "output_type": "execute_result" 952 | } 953 | ], 954 | "source": [ 955 | "w.endswith(\"u\")" 956 | ] 957 | }, 958 | { 959 | "cell_type": "code", 960 | "execution_count": 46, 961 | "metadata": {}, 962 | "outputs": [ 963 | { 964 | "data": { 965 | "text/plain": [ 966 | "True" 967 | ] 968 | }, 969 | "execution_count": 46, 970 | "metadata": {}, 971 | "output_type": "execute_result" 972 | } 973 | ], 974 | "source": [ 975 | "w.startswith(\"J\")" 976 | ] 977 | }, 978 | { 979 | "cell_type": "code", 980 | "execution_count": 47, 981 | "metadata": {}, 982 | "outputs": [ 983 | { 984 | "data": { 985 | "text/plain": [ 986 | "False" 987 | ] 988 | }, 989 | "execution_count": 47, 990 | "metadata": {}, 991 | "output_type": "execute_result" 992 | } 993 | ], 994 | "source": [ 995 | "w.startswith(\"j\")" 996 | ] 997 | }, 998 | { 999 | "cell_type": "code", 1000 | "execution_count": 48, 1001 | "metadata": {}, 1002 | "outputs": [ 1003 | { 1004 | "data": { 1005 | "text/plain": [ 1006 | "True" 1007 | ] 1008 | }, 1009 | "execution_count": 48, 1010 | "metadata": {}, 1011 | "output_type": "execute_result" 1012 | } 1013 | ], 1014 | "source": [ 1015 | "w.startswith(\"Ju\")" 1016 | ] 1017 | }, 1018 | { 1019 | "cell_type": "markdown", 1020 | "metadata": {}, 1021 | "source": [ 1022 | "- strip" 1023 | ] 1024 | }, 1025 | { 1026 | "cell_type": "code", 1027 | "execution_count": 50, 1028 | "metadata": {}, 1029 | "outputs": [ 1030 | { 1031 | "data": { 1032 | "text/plain": [ 1033 | "'Julyedu'" 1034 | ] 1035 | }, 1036 | "execution_count": 50, 1037 | "metadata": {}, 1038 | "output_type": "execute_result" 1039 | } 1040 | ], 1041 | "source": [ 1042 | "w = \" Julyedu \"\n", 1043 | "w.strip()" 1044 | ] 1045 | }, 1046 | { 1047 | "cell_type": "code", 1048 | "execution_count": 51, 1049 | "metadata": {}, 1050 | "outputs": [ 1051 | { 1052 | "data": { 1053 | "text/plain": [ 1054 | "'Julyedu '" 1055 | ] 1056 | }, 1057 | "execution_count": 51, 1058 | "metadata": {}, 1059 | "output_type": "execute_result" 1060 | } 1061 | ], 1062 | "source": [ 1063 | "w.lstrip()" 1064 | ] 1065 | }, 1066 | { 1067 | "cell_type": "code", 1068 | "execution_count": 52, 1069 | "metadata": {}, 1070 | "outputs": [ 1071 | { 1072 | "data": { 1073 | "text/plain": [ 1074 | "' Julyedu'" 1075 | ] 1076 | }, 1077 | "execution_count": 52, 1078 | "metadata": {}, 1079 | "output_type": "execute_result" 1080 | } 1081 | ], 1082 | "source": [ 1083 | "w.rstrip()" 1084 | ] 1085 | }, 1086 | { 1087 | "cell_type": "markdown", 1088 | "metadata": {}, 1089 | "source": [ 1090 | "- split\n", 1091 | "把一个string拆成一个list of strings" 1092 | ] 1093 | }, 1094 | { 1095 | "cell_type": "code", 1096 | "execution_count": 54, 1097 | "metadata": {}, 1098 | "outputs": [ 1099 | { 1100 | "data": { 1101 | "text/plain": [ 1102 | "['burger', 'spaghetti', 'fries', 'steak', 'dimsum', 'ramen']" 1103 | ] 1104 | }, 1105 | "execution_count": 54, 1106 | "metadata": {}, 1107 | "output_type": "execute_result" 1108 | } 1109 | ], 1110 | "source": [ 1111 | "s = \"burger spaghetti fries steak dimsum ramen\"\n", 1112 | "s.split()" 1113 | ] 1114 | }, 1115 | { 1116 | "cell_type": "code", 1117 | "execution_count": 55, 1118 | "metadata": { 1119 | "collapsed": true 1120 | }, 1121 | "outputs": [], 1122 | "source": [ 1123 | "s = \"burger,spaghetti,fries,steak,dimsum,ramen\"" 1124 | ] 1125 | }, 1126 | { 1127 | "cell_type": "code", 1128 | "execution_count": 56, 1129 | "metadata": {}, 1130 | "outputs": [ 1131 | { 1132 | "data": { 1133 | "text/plain": [ 1134 | "['burger', 'spaghetti', 'fries', 'steak', 'dimsum', 'ramen']" 1135 | ] 1136 | }, 1137 | "execution_count": 56, 1138 | "metadata": {}, 1139 | "output_type": "execute_result" 1140 | } 1141 | ], 1142 | "source": [ 1143 | "s.split(\",\")" 1144 | ] 1145 | }, 1146 | { 1147 | "cell_type": "markdown", 1148 | "metadata": {}, 1149 | "source": [ 1150 | "- find: 找到第一个substring出现的位置" 1151 | ] 1152 | }, 1153 | { 1154 | "cell_type": "code", 1155 | "execution_count": 57, 1156 | "metadata": {}, 1157 | "outputs": [ 1158 | { 1159 | "data": { 1160 | "text/plain": [ 1161 | "5" 1162 | ] 1163 | }, 1164 | "execution_count": 57, 1165 | "metadata": {}, 1166 | "output_type": "execute_result" 1167 | } 1168 | ], 1169 | "source": [ 1170 | "w.find(\"ly\")" 1171 | ] 1172 | }, 1173 | { 1174 | "cell_type": "code", 1175 | "execution_count": 59, 1176 | "metadata": {}, 1177 | "outputs": [ 1178 | { 1179 | "data": { 1180 | "text/plain": [ 1181 | "5" 1182 | ] 1183 | }, 1184 | "execution_count": 59, 1185 | "metadata": {}, 1186 | "output_type": "execute_result" 1187 | } 1188 | ], 1189 | "source": [ 1190 | "w.find(\"l\")" 1191 | ] 1192 | }, 1193 | { 1194 | "cell_type": "markdown", 1195 | "metadata": {}, 1196 | "source": [ 1197 | "如果输入一个不存在的substring那就会返回-1了" 1198 | ] 1199 | }, 1200 | { 1201 | "cell_type": "code", 1202 | "execution_count": 60, 1203 | "metadata": {}, 1204 | "outputs": [ 1205 | { 1206 | "data": { 1207 | "text/plain": [ 1208 | "-1" 1209 | ] 1210 | }, 1211 | "execution_count": 60, 1212 | "metadata": {}, 1213 | "output_type": "execute_result" 1214 | } 1215 | ], 1216 | "source": [ 1217 | "w.find(\"a\")" 1218 | ] 1219 | }, 1220 | { 1221 | "cell_type": "markdown", 1222 | "metadata": {}, 1223 | "source": [ 1224 | "- replace" 1225 | ] 1226 | }, 1227 | { 1228 | "cell_type": "code", 1229 | "execution_count": 61, 1230 | "metadata": {}, 1231 | "outputs": [ 1232 | { 1233 | "data": { 1234 | "text/plain": [ 1235 | "'burger|spaghetti|fries|steak|dimsum|ramen'" 1236 | ] 1237 | }, 1238 | "execution_count": 61, 1239 | "metadata": {}, 1240 | "output_type": "execute_result" 1241 | } 1242 | ], 1243 | "source": [ 1244 | "s.replace(\",\", \"|\")" 1245 | ] 1246 | }, 1247 | { 1248 | "cell_type": "code", 1249 | "execution_count": 9, 1250 | "metadata": { 1251 | "collapsed": true 1252 | }, 1253 | "outputs": [], 1254 | "source": [ 1255 | "# 40min" 1256 | ] 1257 | }, 1258 | { 1259 | "cell_type": "markdown", 1260 | "metadata": {}, 1261 | "source": [ 1262 | "# List\n", 1263 | "\n", 1264 | "list 是一种python的数据类型，表示一连串的数据的集合。\n", 1265 | "\n", 1266 | "- 如何创建一个list" 1267 | ] 1268 | }, 1269 | { 1270 | "cell_type": "code", 1271 | "execution_count": 62, 1272 | "metadata": {}, 1273 | "outputs": [ 1274 | { 1275 | "data": { 1276 | "text/plain": [ 1277 | "['Tensorflow', 'July', 'Keras', 'Torch', 'Caffe']" 1278 | ] 1279 | }, 1280 | "execution_count": 62, 1281 | "metadata": {}, 1282 | "output_type": "execute_result" 1283 | } 1284 | ], 1285 | "source": [ 1286 | "names = [\"Tensorflow\", \"July\", \"Keras\", \"Torch\", \"Caffe\"]\n", 1287 | "names" 1288 | ] 1289 | }, 1290 | { 1291 | "cell_type": "code", 1292 | "execution_count": 63, 1293 | "metadata": {}, 1294 | "outputs": [ 1295 | { 1296 | "data": { 1297 | "text/plain": [ 1298 | "list" 1299 | ] 1300 | }, 1301 | "execution_count": 63, 1302 | "metadata": {}, 1303 | "output_type": "execute_result" 1304 | } 1305 | ], 1306 | "source": [ 1307 | "type(names)" 1308 | ] 1309 | }, 1310 | { 1311 | "cell_type": "markdown", 1312 | "metadata": {}, 1313 | "source": [ 1314 | "- list indexing" 1315 | ] 1316 | }, 1317 | { 1318 | "cell_type": "code", 1319 | "execution_count": 64, 1320 | "metadata": {}, 1321 | "outputs": [ 1322 | { 1323 | "data": { 1324 | "text/plain": [ 1325 | "'Tensorflow'" 1326 | ] 1327 | }, 1328 | "execution_count": 64, 1329 | "metadata": {}, 1330 | "output_type": "execute_result" 1331 | } 1332 | ], 1333 | "source": [ 1334 | "names[0]" 1335 | ] 1336 | }, 1337 | { 1338 | "cell_type": "code", 1339 | "execution_count": 65, 1340 | "metadata": {}, 1341 | "outputs": [ 1342 | { 1343 | "data": { 1344 | "text/plain": [ 1345 | "'July'" 1346 | ] 1347 | }, 1348 | "execution_count": 65, 1349 | "metadata": {}, 1350 | "output_type": "execute_result" 1351 | } 1352 | ], 1353 | "source": [ 1354 | "names[1]" 1355 | ] 1356 | }, 1357 | { 1358 | "cell_type": "code", 1359 | "execution_count": 66, 1360 | "metadata": {}, 1361 | "outputs": [ 1362 | { 1363 | "ename": "IndexError", 1364 | "evalue": "list index out of range", 1365 | "output_type": "error", 1366 | "traceback": [ 1367 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 1368 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 1369 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnames\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 1370 | "\u001b[1;31mIndexError\u001b[0m: list index out of range" 1371 | ] 1372 | } 1373 | ], 1374 | "source": [ 1375 | "names[5]" 1376 | ] 1377 | }, 1378 | { 1379 | "cell_type": "code", 1380 | "execution_count": 67, 1381 | "metadata": {}, 1382 | "outputs": [ 1383 | { 1384 | "data": { 1385 | "text/plain": [ 1386 | "'Caffe'" 1387 | ] 1388 | }, 1389 | "execution_count": 67, 1390 | "metadata": {}, 1391 | "output_type": "execute_result" 1392 | } 1393 | ], 1394 | "source": [ 1395 | "names[4]" 1396 | ] 1397 | }, 1398 | { 1399 | "cell_type": "code", 1400 | "execution_count": 68, 1401 | "metadata": {}, 1402 | "outputs": [ 1403 | { 1404 | "data": { 1405 | "text/plain": [ 1406 | "'Caffe'" 1407 | ] 1408 | }, 1409 | "execution_count": 68, 1410 | "metadata": {}, 1411 | "output_type": "execute_result" 1412 | } 1413 | ], 1414 | "source": [ 1415 | "names[-1]" 1416 | ] 1417 | }, 1418 | { 1419 | "cell_type": "code", 1420 | "execution_count": 70, 1421 | "metadata": {}, 1422 | "outputs": [ 1423 | { 1424 | "data": { 1425 | "text/plain": [ 1426 | "'Tensorflow'" 1427 | ] 1428 | }, 1429 | "execution_count": 70, 1430 | "metadata": {}, 1431 | "output_type": "execute_result" 1432 | } 1433 | ], 1434 | "source": [ 1435 | "names[-5]" 1436 | ] 1437 | }, 1438 | { 1439 | "cell_type": "code", 1440 | "execution_count": 71, 1441 | "metadata": {}, 1442 | "outputs": [ 1443 | { 1444 | "ename": "IndexError", 1445 | "evalue": "list index out of range", 1446 | "output_type": "error", 1447 | "traceback": [ 1448 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 1449 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 1450 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnames\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 1451 | "\u001b[1;31mIndexError\u001b[0m: list index out of range" 1452 | ] 1453 | } 1454 | ], 1455 | "source": [ 1456 | "names[-10]" 1457 | ] 1458 | }, 1459 | { 1460 | "cell_type": "markdown", 1461 | "metadata": {}, 1462 | "source": [ 1463 | "- list slicing" 1464 | ] 1465 | }, 1466 | { 1467 | "cell_type": "code", 1468 | "execution_count": 72, 1469 | "metadata": {}, 1470 | "outputs": [ 1471 | { 1472 | "data": { 1473 | "text/plain": [ 1474 | "['July', 'Keras']" 1475 | ] 1476 | }, 1477 | "execution_count": 72, 1478 | "metadata": {}, 1479 | "output_type": "execute_result" 1480 | } 1481 | ], 1482 | "source": [ 1483 | "names[1:3]" 1484 | ] 1485 | }, 1486 | { 1487 | "cell_type": "code", 1488 | "execution_count": 73, 1489 | "metadata": {}, 1490 | "outputs": [ 1491 | { 1492 | "data": { 1493 | "text/plain": [ 1494 | "['July', 'Keras', 'Torch', 'Caffe']" 1495 | ] 1496 | }, 1497 | "execution_count": 73, 1498 | "metadata": {}, 1499 | "output_type": "execute_result" 1500 | } 1501 | ], 1502 | "source": [ 1503 | "names[1:5]" 1504 | ] 1505 | }, 1506 | { 1507 | "cell_type": "code", 1508 | "execution_count": 74, 1509 | "metadata": {}, 1510 | "outputs": [ 1511 | { 1512 | "data": { 1513 | "text/plain": [ 1514 | "['July', 'Keras', 'Torch', 'Caffe']" 1515 | ] 1516 | }, 1517 | "execution_count": 74, 1518 | "metadata": {}, 1519 | "output_type": "execute_result" 1520 | } 1521 | ], 1522 | "source": [ 1523 | "names[1:7]" 1524 | ] 1525 | }, 1526 | { 1527 | "cell_type": "code", 1528 | "execution_count": 75, 1529 | "metadata": {}, 1530 | "outputs": [ 1531 | { 1532 | "data": { 1533 | "text/plain": [ 1534 | "['July', 'Keras', 'Torch']" 1535 | ] 1536 | }, 1537 | "execution_count": 75, 1538 | "metadata": {}, 1539 | "output_type": "execute_result" 1540 | } 1541 | ], 1542 | "source": [ 1543 | "names[1:-1]" 1544 | ] 1545 | }, 1546 | { 1547 | "cell_type": "code", 1548 | "execution_count": 76, 1549 | "metadata": {}, 1550 | "outputs": [ 1551 | { 1552 | "data": { 1553 | "text/plain": [ 1554 | "[]" 1555 | ] 1556 | }, 1557 | "execution_count": 76, 1558 | "metadata": {}, 1559 | "output_type": "execute_result" 1560 | } 1561 | ], 1562 | "source": [ 1563 | "names[1:0]" 1564 | ] 1565 | }, 1566 | { 1567 | "cell_type": "markdown", 1568 | "metadata": {}, 1569 | "source": [ 1570 | "- 我们可以直接把string变成一个list" 1571 | ] 1572 | }, 1573 | { 1574 | "cell_type": "code", 1575 | "execution_count": 77, 1576 | "metadata": {}, 1577 | "outputs": [ 1578 | { 1579 | "data": { 1580 | "text/plain": [ 1581 | "['J', 'u', 'l', 'y', 'e', 'd', 'u']" 1582 | ] 1583 | }, 1584 | "execution_count": 77, 1585 | "metadata": {}, 1586 | "output_type": "execute_result" 1587 | } 1588 | ], 1589 | "source": [ 1590 | "list(\"Julyedu\")" 1591 | ] 1592 | }, 1593 | { 1594 | "cell_type": "markdown", 1595 | "metadata": {}, 1596 | "source": [ 1597 | "- 求list的长度" 1598 | ] 1599 | }, 1600 | { 1601 | "cell_type": "markdown", 1602 | "metadata": {}, 1603 | "source": [ 1604 | "- append方法可以在list的末尾添加element" 1605 | ] 1606 | }, 1607 | { 1608 | "cell_type": "code", 1609 | "execution_count": 80, 1610 | "metadata": {}, 1611 | "outputs": [ 1612 | { 1613 | "data": { 1614 | "text/plain": [ 1615 | "['Tensorflow', 'July', 'Keras', 'Torch', 'Caffe', 'Jack', 'Jack']" 1616 | ] 1617 | }, 1618 | "execution_count": 80, 1619 | "metadata": {}, 1620 | "output_type": "execute_result" 1621 | } 1622 | ], 1623 | "source": [ 1624 | "names.append(\"Jack\")\n", 1625 | "names" 1626 | ] 1627 | }, 1628 | { 1629 | "cell_type": "code", 1630 | "execution_count": 81, 1631 | "metadata": {}, 1632 | "outputs": [ 1633 | { 1634 | "data": { 1635 | "text/plain": [ 1636 | "['Tensorflow',\n", 1637 | " 'July',\n", 1638 | " 'Keras',\n", 1639 | " 'Torch',\n", 1640 | " 'Caffe',\n", 1641 | " 'Jack',\n", 1642 | " 'Jack',\n", 1643 | " 12,\n", 1644 | " 12.5,\n", 1645 | " [1, 2, 3]]" 1646 | ] 1647 | }, 1648 | "execution_count": 81, 1649 | "metadata": {}, 1650 | "output_type": "execute_result" 1651 | } 1652 | ], 1653 | "source": [ 1654 | "names.append(12)\n", 1655 | "names.append(12.5)\n", 1656 | "names.append([1,2,3])\n", 1657 | "names" 1658 | ] 1659 | }, 1660 | { 1661 | "cell_type": "markdown", 1662 | "metadata": {}, 1663 | "source": [ 1664 | "- 两个list相加合并成新的list" 1665 | ] 1666 | }, 1667 | { 1668 | "cell_type": "code", 1669 | "execution_count": 82, 1670 | "metadata": {}, 1671 | "outputs": [ 1672 | { 1673 | "data": { 1674 | "text/plain": [ 1675 | "['Tensorflow',\n", 1676 | " 'July',\n", 1677 | " 'Keras',\n", 1678 | " 'Torch',\n", 1679 | " 'Caffe',\n", 1680 | " 'Jack',\n", 1681 | " 'Jack',\n", 1682 | " 12,\n", 1683 | " 12.5,\n", 1684 | " [1, 2, 3],\n", 1685 | " 1,\n", 1686 | " 2,\n", 1687 | " 3,\n", 1688 | " 4,\n", 1689 | " 5]" 1690 | ] 1691 | }, 1692 | "execution_count": 82, 1693 | "metadata": {}, 1694 | "output_type": "execute_result" 1695 | } 1696 | ], 1697 | "source": [ 1698 | "numbers = [1,2,3,4,5]\n", 1699 | "names + numbers" 1700 | ] 1701 | }, 1702 | { 1703 | "cell_type": "markdown", 1704 | "metadata": {}, 1705 | "source": [ 1706 | "- 判断一个element是否在一个list里面" 1707 | ] 1708 | }, 1709 | { 1710 | "cell_type": "code", 1711 | "execution_count": 83, 1712 | "metadata": { 1713 | "collapsed": true 1714 | }, 1715 | "outputs": [], 1716 | "source": [ 1717 | "names = [\"Tensorflow\", \"July\", \"Keras\", \"Torch\", \"Caffe\"]" 1718 | ] 1719 | }, 1720 | { 1721 | "cell_type": "code", 1722 | "execution_count": 84, 1723 | "metadata": {}, 1724 | "outputs": [ 1725 | { 1726 | "data": { 1727 | "text/plain": [ 1728 | "True" 1729 | ] 1730 | }, 1731 | "execution_count": 84, 1732 | "metadata": {}, 1733 | "output_type": "execute_result" 1734 | } 1735 | ], 1736 | "source": [ 1737 | "\"July\" in names" 1738 | ] 1739 | }, 1740 | { 1741 | "cell_type": "markdown", 1742 | "metadata": {}, 1743 | "source": [ 1744 | "- insert" 1745 | ] 1746 | }, 1747 | { 1748 | "cell_type": "code", 1749 | "execution_count": 85, 1750 | "metadata": {}, 1751 | "outputs": [ 1752 | { 1753 | "data": { 1754 | "text/plain": [ 1755 | "['Tensorflow', 'July', 'Happy', 'Keras', 'Torch', 'Caffe']" 1756 | ] 1757 | }, 1758 | "execution_count": 85, 1759 | "metadata": {}, 1760 | "output_type": "execute_result" 1761 | } 1762 | ], 1763 | "source": [ 1764 | "names.insert(2, \"Happy\")\n", 1765 | "names" 1766 | ] 1767 | }, 1768 | { 1769 | "cell_type": "code", 1770 | "execution_count": 86, 1771 | "metadata": {}, 1772 | "outputs": [ 1773 | { 1774 | "data": { 1775 | "text/plain": [ 1776 | "['Tensorflow', 'July', 'Happy', 'Keras', 'Torch', 'Sad', 'Caffe']" 1777 | ] 1778 | }, 1779 | "execution_count": 86, 1780 | "metadata": {}, 1781 | "output_type": "execute_result" 1782 | } 1783 | ], 1784 | "source": [ 1785 | "names.insert(-1, \"Sad\")\n", 1786 | "names" 1787 | ] 1788 | }, 1789 | { 1790 | "cell_type": "code", 1791 | "execution_count": 87, 1792 | "metadata": {}, 1793 | "outputs": [ 1794 | { 1795 | "data": { 1796 | "text/plain": [ 1797 | "['Tensorflow', 'July', 'Happy', 'Keras', 'Torch', 'Sad', 'Caffe', 'Awesome']" 1798 | ] 1799 | }, 1800 | "execution_count": 87, 1801 | "metadata": {}, 1802 | "output_type": "execute_result" 1803 | } 1804 | ], 1805 | "source": [ 1806 | "names.insert(12, \"Awesome\")\n", 1807 | "names" 1808 | ] 1809 | }, 1810 | { 1811 | "cell_type": "code", 1812 | "execution_count": 88, 1813 | "metadata": {}, 1814 | "outputs": [ 1815 | { 1816 | "data": { 1817 | "text/plain": [ 1818 | "['Bazinga',\n", 1819 | " 'Tensorflow',\n", 1820 | " 'July',\n", 1821 | " 'Happy',\n", 1822 | " 'Keras',\n", 1823 | " 'Torch',\n", 1824 | " 'Sad',\n", 1825 | " 'Caffe',\n", 1826 | " 'Awesome']" 1827 | ] 1828 | }, 1829 | "execution_count": 88, 1830 | "metadata": {}, 1831 | "output_type": "execute_result" 1832 | } 1833 | ], 1834 | "source": [ 1835 | "names.insert(-100, \"Bazinga\")\n", 1836 | "names" 1837 | ] 1838 | }, 1839 | { 1840 | "cell_type": "markdown", 1841 | "metadata": {}, 1842 | "source": [ 1843 | "- pop" 1844 | ] 1845 | }, 1846 | { 1847 | "cell_type": "code", 1848 | "execution_count": 90, 1849 | "metadata": {}, 1850 | "outputs": [ 1851 | { 1852 | "data": { 1853 | "text/plain": [ 1854 | "'Caffe'" 1855 | ] 1856 | }, 1857 | "execution_count": 90, 1858 | "metadata": {}, 1859 | "output_type": "execute_result" 1860 | } 1861 | ], 1862 | "source": [ 1863 | "names.pop()" 1864 | ] 1865 | }, 1866 | { 1867 | "cell_type": "code", 1868 | "execution_count": null, 1869 | "metadata": { 1870 | "collapsed": true 1871 | }, 1872 | "outputs": [], 1873 | "source": [] 1874 | }, 1875 | { 1876 | "cell_type": "code", 1877 | "execution_count": 91, 1878 | "metadata": {}, 1879 | "outputs": [ 1880 | { 1881 | "data": { 1882 | "text/plain": [ 1883 | "['Bazinga', 'Tensorflow', 'July', 'Happy', 'Keras', 'Torch', 'Sad']" 1884 | ] 1885 | }, 1886 | "execution_count": 91, 1887 | "metadata": {}, 1888 | "output_type": "execute_result" 1889 | } 1890 | ], 1891 | "source": [ 1892 | "names" 1893 | ] 1894 | }, 1895 | { 1896 | "cell_type": "markdown", 1897 | "metadata": {}, 1898 | "source": [ 1899 | "- count\n" 1900 | ] 1901 | }, 1902 | { 1903 | "cell_type": "code", 1904 | "execution_count": 92, 1905 | "metadata": {}, 1906 | "outputs": [ 1907 | { 1908 | "data": { 1909 | "text/plain": [ 1910 | "1" 1911 | ] 1912 | }, 1913 | "execution_count": 92, 1914 | "metadata": {}, 1915 | "output_type": "execute_result" 1916 | } 1917 | ], 1918 | "source": [ 1919 | "names.count(\"Tensorflow\")" 1920 | ] 1921 | }, 1922 | { 1923 | "cell_type": "markdown", 1924 | "metadata": {}, 1925 | "source": [ 1926 | "- reverse" 1927 | ] 1928 | }, 1929 | { 1930 | "cell_type": "code", 1931 | "execution_count": 95, 1932 | "metadata": {}, 1933 | "outputs": [ 1934 | { 1935 | "data": { 1936 | "text/plain": [ 1937 | "['Sad', 'Torch', 'Keras', 'Happy', 'July', 'Tensorflow', 'Bazinga']" 1938 | ] 1939 | }, 1940 | "execution_count": 95, 1941 | "metadata": {}, 1942 | "output_type": "execute_result" 1943 | } 1944 | ], 1945 | "source": [ 1946 | "names.reverse()\n", 1947 | "names" 1948 | ] 1949 | }, 1950 | { 1951 | "cell_type": "markdown", 1952 | "metadata": {}, 1953 | "source": [ 1954 | "- del删除element" 1955 | ] 1956 | }, 1957 | { 1958 | "cell_type": "code", 1959 | "execution_count": 96, 1960 | "metadata": { 1961 | "collapsed": true 1962 | }, 1963 | "outputs": [], 1964 | "source": [ 1965 | "del(names[1])" 1966 | ] 1967 | }, 1968 | { 1969 | "cell_type": "code", 1970 | "execution_count": 97, 1971 | "metadata": {}, 1972 | "outputs": [ 1973 | { 1974 | "data": { 1975 | "text/plain": [ 1976 | "['Sad', 'Keras', 'Happy', 'July', 'Tensorflow', 'Bazinga']" 1977 | ] 1978 | }, 1979 | "execution_count": 97, 1980 | "metadata": {}, 1981 | "output_type": "execute_result" 1982 | } 1983 | ], 1984 | "source": [ 1985 | "names" 1986 | ] 1987 | }, 1988 | { 1989 | "cell_type": "code", 1990 | "execution_count": 10, 1991 | "metadata": { 1992 | "collapsed": true 1993 | }, 1994 | "outputs": [], 1995 | "source": [ 1996 | "# 55min" 1997 | ] 1998 | }, 1999 | { 2000 | "cell_type": "markdown", 2001 | "metadata": {}, 2002 | "source": [ 2003 | "## control statement" 2004 | ] 2005 | }, 2006 | { 2007 | "cell_type": "code", 2008 | "execution_count": 98, 2009 | "metadata": {}, 2010 | "outputs": [ 2011 | { 2012 | "name": "stdout", 2013 | "output_type": "stream", 2014 | "text": [ 2015 | "between 10 and 15\n" 2016 | ] 2017 | } 2018 | ], 2019 | "source": [ 2020 | "x = 12\n", 2021 | "if x < 10:\n", 2022 | " print(\"less than 10\")\n", 2023 | "elif x <= 15:\n", 2024 | " print(\"between 10 and 15\")\n", 2025 | "else:\n", 2026 | " print(\"larger than 15\")" 2027 | ] 2028 | }, 2029 | { 2030 | "cell_type": "markdown", 2031 | "metadata": {}, 2032 | "source": [ 2033 | "### 关于Boolean" 2034 | ] 2035 | }, 2036 | { 2037 | "cell_type": "code", 2038 | "execution_count": 11, 2039 | "metadata": { 2040 | "collapsed": true 2041 | }, 2042 | "outputs": [], 2043 | "source": [ 2044 | "# 60 min" 2045 | ] 2046 | }, 2047 | { 2048 | "cell_type": "markdown", 2049 | "metadata": {}, 2050 | "source": [ 2051 | "## loops\n", 2052 | "### for loop" 2053 | ] 2054 | }, 2055 | { 2056 | "cell_type": "code", 2057 | "execution_count": 99, 2058 | "metadata": {}, 2059 | "outputs": [ 2060 | { 2061 | "name": "stdout", 2062 | "output_type": "stream", 2063 | "text": [ 2064 | "Tensorflow\n", 2065 | "July\n", 2066 | "Keras\n", 2067 | "Torch\n", 2068 | "Caffe\n" 2069 | ] 2070 | } 2071 | ], 2072 | "source": [ 2073 | "names = [\"Tensorflow\", \"July\", \"Keras\", \"Torch\", \"Caffe\"]\n", 2074 | "for name in names:\n", 2075 | " print(name)" 2076 | ] 2077 | }, 2078 | { 2079 | "cell_type": "markdown", 2080 | "metadata": {}, 2081 | "source": [ 2082 | "range function" 2083 | ] 2084 | }, 2085 | { 2086 | "cell_type": "code", 2087 | "execution_count": 100, 2088 | "metadata": {}, 2089 | "outputs": [ 2090 | { 2091 | "name": "stdout", 2092 | "output_type": "stream", 2093 | "text": [ 2094 | "0\n", 2095 | "1\n", 2096 | "2\n", 2097 | "3\n", 2098 | "4\n" 2099 | ] 2100 | } 2101 | ], 2102 | "source": [ 2103 | "for i in range(5):\n", 2104 | " print(i)" 2105 | ] 2106 | }, 2107 | { 2108 | "cell_type": "markdown", 2109 | "metadata": {}, 2110 | "source": [ 2111 | "关于range的用法" 2112 | ] 2113 | }, 2114 | { 2115 | "cell_type": "code", 2116 | "execution_count": 101, 2117 | "metadata": {}, 2118 | "outputs": [ 2119 | { 2120 | "data": { 2121 | "text/plain": [ 2122 | "[1, 2, 3, 4, 5, 6, 7, 8, 9]" 2123 | ] 2124 | }, 2125 | "execution_count": 101, 2126 | "metadata": {}, 2127 | "output_type": "execute_result" 2128 | } 2129 | ], 2130 | "source": [ 2131 | "list(range(1,10))" 2132 | ] 2133 | }, 2134 | { 2135 | "cell_type": "code", 2136 | "execution_count": 102, 2137 | "metadata": {}, 2138 | "outputs": [ 2139 | { 2140 | "data": { 2141 | "text/plain": [ 2142 | "[5, 6, 7, 8, 9]" 2143 | ] 2144 | }, 2145 | "execution_count": 102, 2146 | "metadata": {}, 2147 | "output_type": "execute_result" 2148 | } 2149 | ], 2150 | "source": [ 2151 | "list(range(5,10))" 2152 | ] 2153 | }, 2154 | { 2155 | "cell_type": "code", 2156 | "execution_count": 103, 2157 | "metadata": {}, 2158 | "outputs": [ 2159 | { 2160 | "data": { 2161 | "text/plain": [ 2162 | "[5, 10, 15]" 2163 | ] 2164 | }, 2165 | "execution_count": 103, 2166 | "metadata": {}, 2167 | "output_type": "execute_result" 2168 | } 2169 | ], 2170 | "source": [ 2171 | "list(range(5,20,5))" 2172 | ] 2173 | }, 2174 | { 2175 | "cell_type": "code", 2176 | "execution_count": 104, 2177 | "metadata": {}, 2178 | "outputs": [ 2179 | { 2180 | "data": { 2181 | "text/plain": [ 2182 | "[5, 8, 11, 14, 17]" 2183 | ] 2184 | }, 2185 | "execution_count": 104, 2186 | "metadata": {}, 2187 | "output_type": "execute_result" 2188 | } 2189 | ], 2190 | "source": [ 2191 | "list(range(5,20,3))" 2192 | ] 2193 | }, 2194 | { 2195 | "cell_type": "code", 2196 | "execution_count": 105, 2197 | "metadata": {}, 2198 | "outputs": [ 2199 | { 2200 | "data": { 2201 | "text/plain": [ 2202 | "[]" 2203 | ] 2204 | }, 2205 | "execution_count": 105, 2206 | "metadata": {}, 2207 | "output_type": "execute_result" 2208 | } 2209 | ], 2210 | "source": [ 2211 | "list(range(5,20,-1))" 2212 | ] 2213 | }, 2214 | { 2215 | "cell_type": "code", 2216 | "execution_count": 106, 2217 | "metadata": {}, 2218 | "outputs": [ 2219 | { 2220 | "data": { 2221 | "text/plain": [ 2222 | "[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6]" 2223 | ] 2224 | }, 2225 | "execution_count": 106, 2226 | "metadata": {}, 2227 | "output_type": "execute_result" 2228 | } 2229 | ], 2230 | "source": [ 2231 | "list(range(20,5,-1))" 2232 | ] 2233 | }, 2234 | { 2235 | "cell_type": "code", 2236 | "execution_count": 107, 2237 | "metadata": {}, 2238 | "outputs": [ 2239 | { 2240 | "data": { 2241 | "text/plain": [ 2242 | "[20, 16, 12, 8]" 2243 | ] 2244 | }, 2245 | "execution_count": 107, 2246 | "metadata": {}, 2247 | "output_type": "execute_result" 2248 | } 2249 | ], 2250 | "source": [ 2251 | "list(range(20,5,-4))" 2252 | ] 2253 | }, 2254 | { 2255 | "cell_type": "code", 2256 | "execution_count": 108, 2257 | "metadata": {}, 2258 | "outputs": [ 2259 | { 2260 | "data": { 2261 | "text/plain": [ 2262 | "[20, 16, 12, 8]" 2263 | ] 2264 | }, 2265 | "execution_count": 108, 2266 | "metadata": {}, 2267 | "output_type": "execute_result" 2268 | } 2269 | ], 2270 | "source": [ 2271 | "list(range(20,5,-4))" 2272 | ] 2273 | }, 2274 | { 2275 | "cell_type": "markdown", 2276 | "metadata": {}, 2277 | "source": [ 2278 | "如果我们想在每个element前面加个数字编号呢？" 2279 | ] 2280 | }, 2281 | { 2282 | "cell_type": "code", 2283 | "execution_count": 109, 2284 | "metadata": {}, 2285 | "outputs": [ 2286 | { 2287 | "name": "stdout", 2288 | "output_type": "stream", 2289 | "text": [ 2290 | "0 Tensorflow\n", 2291 | "1 July\n", 2292 | "2 Keras\n", 2293 | "3 Torch\n", 2294 | "4 Caffe\n" 2295 | ] 2296 | } 2297 | ], 2298 | "source": [ 2299 | "for i in range(len(names)):\n", 2300 | " print(i, names[i])" 2301 | ] 2302 | }, 2303 | { 2304 | "cell_type": "markdown", 2305 | "metadata": {}, 2306 | "source": [ 2307 | "其实用enumerate更简单，直接帮你带上数字" 2308 | ] 2309 | }, 2310 | { 2311 | "cell_type": "code", 2312 | "execution_count": 110, 2313 | "metadata": {}, 2314 | "outputs": [ 2315 | { 2316 | "name": "stdout", 2317 | "output_type": "stream", 2318 | "text": [ 2319 | "0 Tensorflow\n", 2320 | "1 July\n", 2321 | "2 Keras\n", 2322 | "3 Torch\n", 2323 | "4 Caffe\n" 2324 | ] 2325 | } 2326 | ], 2327 | "source": [ 2328 | "for i, name in enumerate(names):\n", 2329 | " print(i, name)" 2330 | ] 2331 | }, 2332 | { 2333 | "cell_type": "markdown", 2334 | "metadata": {}, 2335 | "source": [ 2336 | "for与list在一起使用可以写很多简洁的语句, list comprehension" 2337 | ] 2338 | }, 2339 | { 2340 | "cell_type": "code", 2341 | "execution_count": 111, 2342 | "metadata": {}, 2343 | "outputs": [ 2344 | { 2345 | "data": { 2346 | "text/plain": [ 2347 | "['stupid Tensorflow',\n", 2348 | " 'stupid July',\n", 2349 | " 'stupid Keras',\n", 2350 | " 'stupid Torch',\n", 2351 | " 'stupid Caffe']" 2352 | ] 2353 | }, 2354 | "execution_count": 111, 2355 | "metadata": {}, 2356 | "output_type": "execute_result" 2357 | } 2358 | ], 2359 | "source": [ 2360 | "[\"stupid \" + name for name in names]\n", 2361 | "['stupid Tensorflow', 'stupid July', 'stupid Keras', 'stupid Torch', 'stupid Caffe']" 2362 | ] 2363 | }, 2364 | { 2365 | "cell_type": "code", 2366 | "execution_count": 12, 2367 | "metadata": { 2368 | "collapsed": true 2369 | }, 2370 | "outputs": [], 2371 | "source": [ 2372 | "# 80 min" 2373 | ] 2374 | }, 2375 | { 2376 | "cell_type": "markdown", 2377 | "metadata": {}, 2378 | "source": [ 2379 | "## while loop\n", 2380 | "\n", 2381 | "下面的这个小程序可以输出0-9" 2382 | ] 2383 | }, 2384 | { 2385 | "cell_type": "code", 2386 | "execution_count": 112, 2387 | "metadata": {}, 2388 | "outputs": [ 2389 | { 2390 | "name": "stdout", 2391 | "output_type": "stream", 2392 | "text": [ 2393 | "0\n", 2394 | "1\n", 2395 | "2\n", 2396 | "3\n", 2397 | "4\n", 2398 | "5\n", 2399 | "6\n", 2400 | "7\n", 2401 | "8\n", 2402 | "9\n" 2403 | ] 2404 | } 2405 | ], 2406 | "source": [ 2407 | "i = 0\n", 2408 | "while i < 10:\n", 2409 | "\tprint(i)\n", 2410 | "\ti += 1" 2411 | ] 2412 | }, 2413 | { 2414 | "cell_type": "markdown", 2415 | "metadata": {}, 2416 | "source": [ 2417 | "注意千万别忘了最后这一句```i += 1```否则就陷入死循环了。\n", 2418 | "\n", 2419 | "### break和continue的用法\n", 2420 | "- break会直接让你跳出当前的循环" 2421 | ] 2422 | }, 2423 | { 2424 | "cell_type": "code", 2425 | "execution_count": 113, 2426 | "metadata": {}, 2427 | "outputs": [ 2428 | { 2429 | "name": "stdout", 2430 | "output_type": "stream", 2431 | "text": [ 2432 | "0\n", 2433 | "1\n", 2434 | "2\n", 2435 | "3\n", 2436 | "4\n", 2437 | "5\n", 2438 | "6\n", 2439 | "7\n", 2440 | "8\n", 2441 | "9\n" 2442 | ] 2443 | } 2444 | ], 2445 | "source": [ 2446 | "i = 0\n", 2447 | "while 1:\n", 2448 | "\tprint(i)\n", 2449 | "\ti += 1\n", 2450 | "\tif i >= 10:\n", 2451 | "\t\tbreak" 2452 | ] 2453 | }, 2454 | { 2455 | "cell_type": "markdown", 2456 | "metadata": {}, 2457 | "source": [ 2458 | "\n", 2459 | "- continue则会让你结束当前循环的环节直接跳到下一循环" 2460 | ] 2461 | }, 2462 | { 2463 | "cell_type": "code", 2464 | "execution_count": 114, 2465 | "metadata": {}, 2466 | "outputs": [ 2467 | { 2468 | "name": "stdout", 2469 | "output_type": "stream", 2470 | "text": [ 2471 | "1\n", 2472 | "2\n", 2473 | "3\n", 2474 | "4\n", 2475 | "6\n", 2476 | "7\n", 2477 | "8\n", 2478 | "9\n", 2479 | "11\n", 2480 | "12\n", 2481 | "13\n", 2482 | "14\n", 2483 | "16\n", 2484 | "17\n", 2485 | "18\n", 2486 | "19\n" 2487 | ] 2488 | } 2489 | ], 2490 | "source": [ 2491 | "i = 0\n", 2492 | "while 1:\n", 2493 | "\tif i % 5 == 0:\n", 2494 | "\t\ti += 1\n", 2495 | "\t\tcontinue\n", 2496 | "\tprint(i)\n", 2497 | "\ti += 1\n", 2498 | "\t\n", 2499 | "\tif i >= 20:\n", 2500 | "\t\tbreak" 2501 | ] 2502 | }, 2503 | { 2504 | "cell_type": "markdown", 2505 | "metadata": {}, 2506 | "source": [ 2507 | "## 小练习：输出一个fibonacci数列" 2508 | ] 2509 | }, 2510 | { 2511 | "cell_type": "code", 2512 | "execution_count": null, 2513 | "metadata": { 2514 | "collapsed": true 2515 | }, 2516 | "outputs": [], 2517 | "source": [] 2518 | }, 2519 | { 2520 | "cell_type": "code", 2521 | "execution_count": 116, 2522 | "metadata": {}, 2523 | "outputs": [ 2524 | { 2525 | "name": "stdout", 2526 | "output_type": "stream", 2527 | "text": [ 2528 | "while loop:\n", 2529 | "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n" 2530 | ] 2531 | } 2532 | ], 2533 | "source": [ 2534 | "print(\"while loop:\")\n", 2535 | "fibs = []\n", 2536 | "i = 0\n", 2537 | "j = 1\n", 2538 | "while i < 500:\n", 2539 | "\tfibs.append(i)\n", 2540 | "\ttmp = j\n", 2541 | "\tj = i + j\n", 2542 | "\ti = tmp\n", 2543 | "print(fibs)" 2544 | ] 2545 | }, 2546 | { 2547 | "cell_type": "code", 2548 | "execution_count": 13, 2549 | "metadata": { 2550 | "collapsed": true 2551 | }, 2552 | "outputs": [], 2553 | "source": [ 2554 | "# 95 min" 2555 | ] 2556 | }, 2557 | { 2558 | "cell_type": "code", 2559 | "execution_count": null, 2560 | "metadata": { 2561 | "collapsed": true 2562 | }, 2563 | "outputs": [], 2564 | "source": [] 2565 | }, 2566 | { 2567 | "cell_type": "markdown", 2568 | "metadata": {}, 2569 | "source": [ 2570 | "## set" 2571 | ] 2572 | }, 2573 | { 2574 | "cell_type": "code", 2575 | "execution_count": 117, 2576 | "metadata": {}, 2577 | "outputs": [ 2578 | { 2579 | "data": { 2580 | "text/plain": [ 2581 | "{'julyedu', 'jupyter', 'numpy', 'python', 'pytorch', 'tensorflow'}" 2582 | ] 2583 | }, 2584 | "execution_count": 117, 2585 | "metadata": {}, 2586 | "output_type": "execute_result" 2587 | } 2588 | ], 2589 | "source": [ 2590 | "names = {\"tensorflow\", \"pytorch\", \"julyedu\", \"jupyter\", \"python\", \"numpy\"}\n", 2591 | "names" 2592 | ] 2593 | }, 2594 | { 2595 | "cell_type": "code", 2596 | "execution_count": 118, 2597 | "metadata": {}, 2598 | "outputs": [ 2599 | { 2600 | "data": { 2601 | "text/plain": [ 2602 | "set" 2603 | ] 2604 | }, 2605 | "execution_count": 118, 2606 | "metadata": {}, 2607 | "output_type": "execute_result" 2608 | } 2609 | ], 2610 | "source": [ 2611 | "type(names)" 2612 | ] 2613 | }, 2614 | { 2615 | "cell_type": "code", 2616 | "execution_count": 119, 2617 | "metadata": {}, 2618 | "outputs": [ 2619 | { 2620 | "data": { 2621 | "text/plain": [ 2622 | "set()" 2623 | ] 2624 | }, 2625 | "execution_count": 119, 2626 | "metadata": {}, 2627 | "output_type": "execute_result" 2628 | } 2629 | ], 2630 | "source": [ 2631 | "empty_set = set()\n", 2632 | "empty_set" 2633 | ] 2634 | }, 2635 | { 2636 | "cell_type": "markdown", 2637 | "metadata": {}, 2638 | "source": [ 2639 | "- list可以被转换成set，可以用于去重" 2640 | ] 2641 | }, 2642 | { 2643 | "cell_type": "code", 2644 | "execution_count": null, 2645 | "metadata": { 2646 | "collapsed": true 2647 | }, 2648 | "outputs": [], 2649 | "source": [] 2650 | }, 2651 | { 2652 | "cell_type": "code", 2653 | "execution_count": 120, 2654 | "metadata": {}, 2655 | "outputs": [ 2656 | { 2657 | "data": { 2658 | "text/plain": [ 2659 | "[1, 4, 5, 2, 1, 5, 4, 2]" 2660 | ] 2661 | }, 2662 | "execution_count": 120, 2663 | "metadata": {}, 2664 | "output_type": "execute_result" 2665 | } 2666 | ], 2667 | "source": [ 2668 | "numbers = [1,4,5,2,1,5,4,2]\n", 2669 | "numbers" 2670 | ] 2671 | }, 2672 | { 2673 | "cell_type": "code", 2674 | "execution_count": 121, 2675 | "metadata": {}, 2676 | "outputs": [ 2677 | { 2678 | "data": { 2679 | "text/plain": [ 2680 | "{1, 2, 4, 5}" 2681 | ] 2682 | }, 2683 | "execution_count": 121, 2684 | "metadata": {}, 2685 | "output_type": "execute_result" 2686 | } 2687 | ], 2688 | "source": [ 2689 | "set(numbers)" 2690 | ] 2691 | }, 2692 | { 2693 | "cell_type": "code", 2694 | "execution_count": 122, 2695 | "metadata": {}, 2696 | "outputs": [ 2697 | { 2698 | "data": { 2699 | "text/plain": [ 2700 | "[1, 2, 4, 5]" 2701 | ] 2702 | }, 2703 | "execution_count": 122, 2704 | "metadata": {}, 2705 | "output_type": "execute_result" 2706 | } 2707 | ], 2708 | "source": [ 2709 | "list(set(numbers))" 2710 | ] 2711 | }, 2712 | { 2713 | "cell_type": "markdown", 2714 | "metadata": {}, 2715 | "source": [ 2716 | "- string也可以被转换成set" 2717 | ] 2718 | }, 2719 | { 2720 | "cell_type": "code", 2721 | "execution_count": 123, 2722 | "metadata": {}, 2723 | "outputs": [ 2724 | { 2725 | "data": { 2726 | "text/plain": [ 2727 | "{'a', 'b', 'n'}" 2728 | ] 2729 | }, 2730 | "execution_count": 123, 2731 | "metadata": {}, 2732 | "output_type": "execute_result" 2733 | } 2734 | ], 2735 | "source": [ 2736 | "set(\"banana\")" 2737 | ] 2738 | }, 2739 | { 2740 | "cell_type": "markdown", 2741 | "metadata": {}, 2742 | "source": [ 2743 | "- 比较fancy的一个例子, set comprehension\n" 2744 | ] 2745 | }, 2746 | { 2747 | "cell_type": "code", 2748 | "execution_count": 124, 2749 | "metadata": {}, 2750 | "outputs": [ 2751 | { 2752 | "data": { 2753 | "text/plain": [ 2754 | "{'b'}" 2755 | ] 2756 | }, 2757 | "execution_count": 124, 2758 | "metadata": {}, 2759 | "output_type": "execute_result" 2760 | } 2761 | ], 2762 | "source": [ 2763 | "{x for x in \"banana\" if x not in \"an\"}" 2764 | ] 2765 | }, 2766 | { 2767 | "cell_type": "markdown", 2768 | "metadata": {}, 2769 | "source": [ 2770 | "## tuple\n", 2771 | "tuples有点像list，不过一个很大的区别是tuples是immutable的，也就是说它的element一旦创建之后就无法更改了。" 2772 | ] 2773 | }, 2774 | { 2775 | "cell_type": "code", 2776 | "execution_count": 125, 2777 | "metadata": {}, 2778 | "outputs": [ 2779 | { 2780 | "data": { 2781 | "text/plain": [ 2782 | "(1, 'facebook', 'palo alto')" 2783 | ] 2784 | }, 2785 | "execution_count": 125, 2786 | "metadata": {}, 2787 | "output_type": "execute_result" 2788 | } 2789 | ], 2790 | "source": [ 2791 | "t = 1, \"facebook\", \"palo alto\"\n", 2792 | "t" 2793 | ] 2794 | }, 2795 | { 2796 | "cell_type": "code", 2797 | "execution_count": 126, 2798 | "metadata": {}, 2799 | "outputs": [ 2800 | { 2801 | "data": { 2802 | "text/plain": [ 2803 | "'palo alto'" 2804 | ] 2805 | }, 2806 | "execution_count": 126, 2807 | "metadata": {}, 2808 | "output_type": "execute_result" 2809 | } 2810 | ], 2811 | "source": [ 2812 | "x, y, z = t\n", 2813 | "x\n", 2814 | "y\n", 2815 | "z" 2816 | ] 2817 | }, 2818 | { 2819 | "cell_type": "markdown", 2820 | "metadata": {}, 2821 | "source": [ 2822 | "## dictionary\n", 2823 | "\n", 2824 | "dictionary就是字典，也就是把一个元素map到另一个元素上" 2825 | ] 2826 | }, 2827 | { 2828 | "cell_type": "code", 2829 | "execution_count": 127, 2830 | "metadata": { 2831 | "collapsed": true 2832 | }, 2833 | "outputs": [], 2834 | "source": [ 2835 | "fruit = {'apple': 0, 'banana': 2, 'orange': 3, 'pineapple': 4}" 2836 | ] 2837 | }, 2838 | { 2839 | "cell_type": "code", 2840 | "execution_count": 128, 2841 | "metadata": {}, 2842 | "outputs": [ 2843 | { 2844 | "data": { 2845 | "text/plain": [ 2846 | "0" 2847 | ] 2848 | }, 2849 | "execution_count": 128, 2850 | "metadata": {}, 2851 | "output_type": "execute_result" 2852 | } 2853 | ], 2854 | "source": [ 2855 | "fruit[\"apple\"]" 2856 | ] 2857 | }, 2858 | { 2859 | "cell_type": "code", 2860 | "execution_count": 129, 2861 | "metadata": {}, 2862 | "outputs": [ 2863 | { 2864 | "data": { 2865 | "text/plain": [ 2866 | "2" 2867 | ] 2868 | }, 2869 | "execution_count": 129, 2870 | "metadata": {}, 2871 | "output_type": "execute_result" 2872 | } 2873 | ], 2874 | "source": [ 2875 | "fruit[\"banana\"]" 2876 | ] 2877 | }, 2878 | { 2879 | "cell_type": "markdown", 2880 | "metadata": {}, 2881 | "source": [ 2882 | "下面的方法可以帮助我们查看一个dictionary的keys和values" 2883 | ] 2884 | }, 2885 | { 2886 | "cell_type": "code", 2887 | "execution_count": 130, 2888 | "metadata": {}, 2889 | "outputs": [ 2890 | { 2891 | "data": { 2892 | "text/plain": [ 2893 | "dict_keys(['apple', 'banana', 'orange', 'pineapple'])" 2894 | ] 2895 | }, 2896 | "execution_count": 130, 2897 | "metadata": {}, 2898 | "output_type": "execute_result" 2899 | } 2900 | ], 2901 | "source": [ 2902 | "fruit.keys()" 2903 | ] 2904 | }, 2905 | { 2906 | "cell_type": "code", 2907 | "execution_count": 131, 2908 | "metadata": {}, 2909 | "outputs": [ 2910 | { 2911 | "data": { 2912 | "text/plain": [ 2913 | "dict_values([0, 2, 3, 4])" 2914 | ] 2915 | }, 2916 | "execution_count": 131, 2917 | "metadata": {}, 2918 | "output_type": "execute_result" 2919 | } 2920 | ], 2921 | "source": [ 2922 | "fruit.values()" 2923 | ] 2924 | }, 2925 | { 2926 | "cell_type": "markdown", 2927 | "metadata": {}, 2928 | "source": [ 2929 | "- 一个list of tuples也可以转换成dict。" 2930 | ] 2931 | }, 2932 | { 2933 | "cell_type": "code", 2934 | "execution_count": 132, 2935 | "metadata": {}, 2936 | "outputs": [ 2937 | { 2938 | "data": { 2939 | "text/plain": [ 2940 | "{'Chicago': 6,\n", 2941 | " 'Harvard': 1,\n", 2942 | " 'MIT': 5,\n", 2943 | " 'Princeton': 2,\n", 2944 | " 'Stanford': 4,\n", 2945 | " 'Yale': 3}" 2946 | ] 2947 | }, 2948 | "execution_count": 132, 2949 | "metadata": {}, 2950 | "output_type": "execute_result" 2951 | } 2952 | ], 2953 | "source": [ 2954 | "schools = dict([(\"Harvard\",1), (\"Princeton\",2), (\"Yale\",3), (\"Stanford\",4), (\"MIT\",5), (\"Chicago\",6)])\n", 2955 | "schools" 2956 | ] 2957 | }, 2958 | { 2959 | "cell_type": "markdown", 2960 | "metadata": {}, 2961 | "source": [ 2962 | "有时候我们想把一个list编号做成一个dictionary，比如下面这种情况:" 2963 | ] 2964 | }, 2965 | { 2966 | "cell_type": "code", 2967 | "execution_count": 133, 2968 | "metadata": { 2969 | "collapsed": true 2970 | }, 2971 | "outputs": [], 2972 | "source": [ 2973 | "vocab = [\"apple\", \"bit\", \"chrome\", \"face\", \"google\", \"hack\", \"intern\", \"jack\", \"kaggle\"]" 2974 | ] 2975 | }, 2976 | { 2977 | "cell_type": "code", 2978 | "execution_count": 134, 2979 | "metadata": {}, 2980 | "outputs": [ 2981 | { 2982 | "data": { 2983 | "text/plain": [ 2984 | "['apple',\n", 2985 | " 'bit',\n", 2986 | " 'chrome',\n", 2987 | " 'face',\n", 2988 | " 'google',\n", 2989 | " 'hack',\n", 2990 | " 'intern',\n", 2991 | " 'jack',\n", 2992 | " 'kaggle']" 2993 | ] 2994 | }, 2995 | "execution_count": 134, 2996 | "metadata": {}, 2997 | "output_type": "execute_result" 2998 | } 2999 | ], 3000 | "source": [ 3001 | "vocab" 3002 | ] 3003 | }, 3004 | { 3005 | "cell_type": "code", 3006 | "execution_count": 135, 3007 | "metadata": { 3008 | "collapsed": true 3009 | }, 3010 | "outputs": [], 3011 | "source": [ 3012 | "vocab2idx = {v:k for k, v in enumerate(vocab)}" 3013 | ] 3014 | }, 3015 | { 3016 | "cell_type": "code", 3017 | "execution_count": 136, 3018 | "metadata": {}, 3019 | "outputs": [ 3020 | { 3021 | "data": { 3022 | "text/plain": [ 3023 | "{'apple': 0,\n", 3024 | " 'bit': 1,\n", 3025 | " 'chrome': 2,\n", 3026 | " 'face': 3,\n", 3027 | " 'google': 4,\n", 3028 | " 'hack': 5,\n", 3029 | " 'intern': 6,\n", 3030 | " 'jack': 7,\n", 3031 | " 'kaggle': 8}" 3032 | ] 3033 | }, 3034 | "execution_count": 136, 3035 | "metadata": {}, 3036 | "output_type": "execute_result" 3037 | } 3038 | ], 3039 | "source": [ 3040 | "vocab2idx" 3041 | ] 3042 | }, 3043 | { 3044 | "cell_type": "code", 3045 | "execution_count": 15, 3046 | "metadata": { 3047 | "collapsed": true 3048 | }, 3049 | "outputs": [], 3050 | "source": [ 3051 | "# 115 min" 3052 | ] 3053 | }, 3054 | { 3055 | "cell_type": "markdown", 3056 | "metadata": {}, 3057 | "source": [ 3058 | "## function\n", 3059 | "\n", 3060 | "- def关键词\n", 3061 | "- 用括号包含list of parameters\n", 3062 | "- statements都要indent\n" 3063 | ] 3064 | }, 3065 | { 3066 | "cell_type": "markdown", 3067 | "metadata": {}, 3068 | "source": [ 3069 | "\n", 3070 | "### 不定长度的arguments\n", 3071 | "\n" 3072 | ] 3073 | }, 3074 | { 3075 | "cell_type": "markdown", 3076 | "metadata": {}, 3077 | "source": [ 3078 | "### default argument\n", 3079 | "concat例子\n", 3080 | "\n" 3081 | ] 3082 | }, 3083 | { 3084 | "cell_type": "markdown", 3085 | "metadata": {}, 3086 | "source": [ 3087 | "\n", 3088 | "\n", 3089 | "### 把一个tuple/list当做arguments\n", 3090 | "\n" 3091 | ] 3092 | } 3093 | ], 3094 | "metadata": { 3095 | "kernelspec": { 3096 | "display_name": "Python 3", 3097 | "language": "python", 3098 | "name": "python3" 3099 | }, 3100 | "language_info": { 3101 | "codemirror_mode": { 3102 | "name": "ipython", 3103 | "version": 3 3104 | }, 3105 | "file_extension": ".py", 3106 | "mimetype": "text/x-python", 3107 | "name": "python", 3108 | "nbconvert_exporter": "python", 3109 | "pygments_lexer": "ipython3", 3110 | "version": "3.6.1" 3111 | } 3112 | }, 3113 | "nbformat": 4, 3114 | "nbformat_minor": 2 3115 | } 3116 | -------------------------------------------------------------------------------- /python-basic-student.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Python基础\n", 8 | "\n", 9 | "### 目录\n", 10 | "- python简介\n", 11 | "- 安装和运行\n", 12 | "- 基本数据类型\n", 13 | "- 变量和表达式\n", 14 | "- 字符串\n", 15 | "- list\n", 16 | "- 判断语句\n", 17 | "- 循环语句\n", 18 | "- set, tuple, dictionary" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "# Python简介\n", 26 | "- 官网: https://www.python.org/\n", 27 | "- 版本: **3.6**/2.7\n", 28 | "- 脚本语言，语法、调试都很方便，非常适合编程菜鸟入门\n", 29 | "\n", 30 | "## Python安装\n", 31 | "\n", 32 | "### Anaconda安装\n", 33 | "- Anaconda是一个常用的用于数据分析的Python版本管理系统\n", 34 | "- 从[官网](https://www.continuum.io/downloads)下载相应版本\n", 35 | "- 按照提示安装\n", 36 | "\n", 37 | "### Anaconda environment安装\n", 38 | "- 安装一个新的environment: conda create -n [your_environment_name] python=[your_python_version]\n", 39 | "- 进入已经安装的environment: source activate [your_environment_name]\n", 40 | "- 在windows下使用: activate [your_environment_name]\n", 41 | "- 退出当前environment: source deactivate\n", 42 | "- 查看environment: conda info --envs\n", 43 | "- 更多的conda命令请查询官网文档: https://conda.io/docs/index.html\n", 44 | "\n", 45 | "### 在environment下安装libraries\n", 46 | "- pip install [package_name]\n", 47 | "\n", 48 | "## 运行Python\n", 49 | "1. 在命令行上输入python\n", 50 | "2. 用文本编辑器写完一段程序然后运行\n", 51 | "\n", 52 | "## 如何寻找帮助\n", 53 | "- 官方文档\n", 54 | "- debug: 学会读报错信息\n", 55 | "- Goole和Stackoverflow" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 1, 61 | "metadata": {}, 62 | "outputs": [ 63 | { 64 | "name": "stdout", 65 | "output_type": "stream", 66 | "text": [ 67 | "hello july\n" 68 | ] 69 | } 70 | ], 71 | "source": [ 72 | "print(\"hello july\")" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 2, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "data": { 82 | "text/plain": [ 83 | "4" 84 | ] 85 | }, 86 | "execution_count": 2, 87 | "metadata": {}, 88 | "output_type": "execute_result" 89 | } 90 | ], 91 | "source": [ 92 | "1 + 3" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 3, 98 | "metadata": {}, 99 | "outputs": [ 100 | { 101 | "data": { 102 | "text/plain": [ 103 | "2.5" 104 | ] 105 | }, 106 | "execution_count": 3, 107 | "metadata": {}, 108 | "output_type": "execute_result" 109 | } 110 | ], 111 | "source": [ 112 | "5 / 2" 113 | ] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "## python程序基础\n", 120 | "### 用python做计算器\n", 121 | "- +, -, *\n", 122 | "- /, //\n", 123 | "- \\*\\*" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 4, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "data": { 133 | "text/plain": [ 134 | "2.3" 135 | ] 136 | }, 137 | "execution_count": 4, 138 | "metadata": {}, 139 | "output_type": "execute_result" 140 | } 141 | ], 142 | "source": [ 143 | "5 - 2.7" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 5, 149 | "metadata": {}, 150 | "outputs": [ 151 | { 152 | "data": { 153 | "text/plain": [ 154 | "13.5" 155 | ] 156 | }, 157 | "execution_count": 5, 158 | "metadata": {}, 159 | "output_type": "execute_result" 160 | } 161 | ], 162 | "source": [ 163 | "5.4 * 2.5" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 1, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "data": { 173 | "text/plain": [ 174 | "0.75" 175 | ] 176 | }, 177 | "execution_count": 1, 178 | "metadata": {}, 179 | "output_type": "execute_result" 180 | } 181 | ], 182 | "source": [ 183 | "3 / 4" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 3, 189 | "metadata": {}, 190 | "outputs": [ 191 | { 192 | "data": { 193 | "text/plain": [ 194 | "0" 195 | ] 196 | }, 197 | "execution_count": 3, 198 | "metadata": {}, 199 | "output_type": "execute_result" 200 | } 201 | ], 202 | "source": [ 203 | "3 // 4" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 4, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "data": { 213 | "text/plain": [ 214 | "1" 215 | ] 216 | }, 217 | "execution_count": 4, 218 | "metadata": {}, 219 | "output_type": "execute_result" 220 | } 221 | ], 222 | "source": [ 223 | "4 // 3" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": 5, 229 | "metadata": {}, 230 | "outputs": [ 231 | { 232 | "data": { 233 | "text/plain": [ 234 | "1" 235 | ] 236 | }, 237 | "execution_count": 5, 238 | "metadata": {}, 239 | "output_type": "execute_result" 240 | } 241 | ], 242 | "source": [ 243 | "4 % 3" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": 6, 249 | "metadata": {}, 250 | "outputs": [ 251 | { 252 | "data": { 253 | "text/plain": [ 254 | "2" 255 | ] 256 | }, 257 | "execution_count": 6, 258 | "metadata": {}, 259 | "output_type": "execute_result" 260 | } 261 | ], 262 | "source": [ 263 | "5 % 3" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": 7, 269 | "metadata": {}, 270 | "outputs": [ 271 | { 272 | "data": { 273 | "text/plain": [ 274 | "25" 275 | ] 276 | }, 277 | "execution_count": 7, 278 | "metadata": {}, 279 | "output_type": "execute_result" 280 | } 281 | ], 282 | "source": [ 283 | "5 ** 2" 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "execution_count": 8, 289 | "metadata": {}, 290 | "outputs": [ 291 | { 292 | "data": { 293 | "text/plain": [ 294 | "55.90169943749474" 295 | ] 296 | }, 297 | "execution_count": 8, 298 | "metadata": {}, 299 | "output_type": "execute_result" 300 | } 301 | ], 302 | "source": [ 303 | "5 ** 2.5" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 9, 309 | "metadata": {}, 310 | "outputs": [ 311 | { 312 | "data": { 313 | "text/plain": [ 314 | "2.23606797749979" 315 | ] 316 | }, 317 | "execution_count": 9, 318 | "metadata": {}, 319 | "output_type": "execute_result" 320 | } 321 | ], 322 | "source": [ 323 | "5 ** 0.5" 324 | ] 325 | }, 326 | { 327 | "cell_type": "markdown", 328 | "metadata": {}, 329 | "source": [ 330 | "- =, ==" 331 | ] 332 | }, 333 | { 334 | "cell_type": "code", 335 | "execution_count": 11, 336 | "metadata": {}, 337 | "outputs": [ 338 | { 339 | "data": { 340 | "text/plain": [ 341 | "True" 342 | ] 343 | }, 344 | "execution_count": 11, 345 | "metadata": {}, 346 | "output_type": "execute_result" 347 | } 348 | ], 349 | "source": [ 350 | "5 == 5" 351 | ] 352 | }, 353 | { 354 | "cell_type": "code", 355 | "execution_count": 12, 356 | "metadata": {}, 357 | "outputs": [ 358 | { 359 | "data": { 360 | "text/plain": [ 361 | "True" 362 | ] 363 | }, 364 | "execution_count": 12, 365 | "metadata": {}, 366 | "output_type": "execute_result" 367 | } 368 | ], 369 | "source": [ 370 | "2.5 == 2.50" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": null, 376 | "metadata": { 377 | "collapsed": true 378 | }, 379 | "outputs": [], 380 | "source": [] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": {}, 385 | "source": [ 386 | "# Python基本数据类型、变量、运算和表达式\n", 387 | "\n", 388 | "## 变量\n", 389 | "- 变量赋值(assignment)\n", 390 | "\n", 391 | "## 基本数据类型\n", 392 | "- 整型int\n", 393 | "- 浮点float\n", 394 | "- 数据类型强制转换\n", 395 | "- 四则运算\n", 396 | "- 字符串str\n", 397 | "- bool\n", 398 | "\n", 399 | "## 动态类型\n", 400 | "- python是一种动态类型的语言\n", 401 | "- type(来查看变量类型)" 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 14, 407 | "metadata": {}, 408 | "outputs": [], 409 | "source": [ 410 | "x = 2" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": 15, 416 | "metadata": {}, 417 | "outputs": [ 418 | { 419 | "data": { 420 | "text/plain": [ 421 | "True" 422 | ] 423 | }, 424 | "execution_count": 15, 425 | "metadata": {}, 426 | "output_type": "execute_result" 427 | } 428 | ], 429 | "source": [ 430 | "x == 2" 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": 16, 436 | "metadata": { 437 | "collapsed": true 438 | }, 439 | "outputs": [], 440 | "source": [ 441 | "y = 2.0" 442 | ] 443 | }, 444 | { 445 | "cell_type": "code", 446 | "execution_count": 17, 447 | "metadata": {}, 448 | "outputs": [ 449 | { 450 | "data": { 451 | "text/plain": [ 452 | "2.0" 453 | ] 454 | }, 455 | "execution_count": 17, 456 | "metadata": {}, 457 | "output_type": "execute_result" 458 | } 459 | ], 460 | "source": [ 461 | "y" 462 | ] 463 | }, 464 | { 465 | "cell_type": "code", 466 | "execution_count": 18, 467 | "metadata": {}, 468 | "outputs": [ 469 | { 470 | "data": { 471 | "text/plain": [ 472 | "True" 473 | ] 474 | }, 475 | "execution_count": 18, 476 | "metadata": {}, 477 | "output_type": "execute_result" 478 | } 479 | ], 480 | "source": [ 481 | "x == y" 482 | ] 483 | }, 484 | { 485 | "cell_type": "code", 486 | "execution_count": 21, 487 | "metadata": {}, 488 | "outputs": [ 489 | { 490 | "data": { 491 | "text/plain": [ 492 | "'Julyedu'" 493 | ] 494 | }, 495 | "execution_count": 21, 496 | "metadata": {}, 497 | "output_type": "execute_result" 498 | } 499 | ], 500 | "source": [ 501 | "name = \"Julyedu\"\n", 502 | "name" 503 | ] 504 | }, 505 | { 506 | "cell_type": "code", 507 | "execution_count": 22, 508 | "metadata": {}, 509 | "outputs": [ 510 | { 511 | "data": { 512 | "text/plain": [ 513 | "True" 514 | ] 515 | }, 516 | "execution_count": 22, 517 | "metadata": {}, 518 | "output_type": "execute_result" 519 | } 520 | ], 521 | "source": [ 522 | "name == \"Julyedu\"" 523 | ] 524 | }, 525 | { 526 | "cell_type": "code", 527 | "execution_count": null, 528 | "metadata": { 529 | "collapsed": true 530 | }, 531 | "outputs": [], 532 | "source": [] 533 | }, 534 | { 535 | "cell_type": "markdown", 536 | "metadata": {}, 537 | "source": [ 538 | "## 表达式(expression)\n", 539 | "- 引用变量\n", 540 | "\n", 541 | "- python会用表达式计算（返回）出一个结果\n", 542 | "\n", 543 | "## 指令(statement)\n", 544 | "- python会执行一条指令，未必会返回一个结果\n", 545 | "- expression可以被当做一个statement，但是statement一般不是一个expression\n", 546 | "- 赋值statement\n", 547 | "- x += x, x *= y, x /= y\n" 548 | ] 549 | }, 550 | { 551 | "cell_type": "code", 552 | "execution_count": 23, 553 | "metadata": {}, 554 | "outputs": [ 555 | { 556 | "data": { 557 | "text/plain": [ 558 | "2" 559 | ] 560 | }, 561 | "execution_count": 23, 562 | "metadata": {}, 563 | "output_type": "execute_result" 564 | } 565 | ], 566 | "source": [ 567 | "x" 568 | ] 569 | }, 570 | { 571 | "cell_type": "code", 572 | "execution_count": 24, 573 | "metadata": {}, 574 | "outputs": [ 575 | { 576 | "data": { 577 | "text/plain": [ 578 | "6" 579 | ] 580 | }, 581 | "execution_count": 24, 582 | "metadata": {}, 583 | "output_type": "execute_result" 584 | } 585 | ], 586 | "source": [ 587 | "x + 4" 588 | ] 589 | }, 590 | { 591 | "cell_type": "code", 592 | "execution_count": 25, 593 | "metadata": {}, 594 | "outputs": [ 595 | { 596 | "data": { 597 | "text/plain": [ 598 | "4" 599 | ] 600 | }, 601 | "execution_count": 25, 602 | "metadata": {}, 603 | "output_type": "execute_result" 604 | } 605 | ], 606 | "source": [ 607 | "x + x" 608 | ] 609 | }, 610 | { 611 | "cell_type": "code", 612 | "execution_count": 26, 613 | "metadata": {}, 614 | "outputs": [ 615 | { 616 | "data": { 617 | "text/plain": [ 618 | "2" 619 | ] 620 | }, 621 | "execution_count": 26, 622 | "metadata": {}, 623 | "output_type": "execute_result" 624 | } 625 | ], 626 | "source": [ 627 | "x" 628 | ] 629 | }, 630 | { 631 | "cell_type": "code", 632 | "execution_count": 28, 633 | "metadata": {}, 634 | "outputs": [ 635 | { 636 | "data": { 637 | "text/plain": [ 638 | "5" 639 | ] 640 | }, 641 | "execution_count": 28, 642 | "metadata": {}, 643 | "output_type": "execute_result" 644 | } 645 | ], 646 | "source": [ 647 | "x = 5\n", 648 | "x" 649 | ] 650 | }, 651 | { 652 | "cell_type": "code", 653 | "execution_count": 33, 654 | "metadata": { 655 | "collapsed": true 656 | }, 657 | "outputs": [], 658 | "source": [ 659 | "x = x + 2" 660 | ] 661 | }, 662 | { 663 | "cell_type": "code", 664 | "execution_count": 34, 665 | "metadata": {}, 666 | "outputs": [ 667 | { 668 | "data": { 669 | "text/plain": [ 670 | "11" 671 | ] 672 | }, 673 | "execution_count": 34, 674 | "metadata": {}, 675 | "output_type": "execute_result" 676 | } 677 | ], 678 | "source": [ 679 | "x" 680 | ] 681 | }, 682 | { 683 | "cell_type": "code", 684 | "execution_count": 40, 685 | "metadata": {}, 686 | "outputs": [ 687 | { 688 | "data": { 689 | "text/plain": [ 690 | "23" 691 | ] 692 | }, 693 | "execution_count": 40, 694 | "metadata": {}, 695 | "output_type": "execute_result" 696 | } 697 | ], 698 | "source": [ 699 | "x += 2\n", 700 | "x" 701 | ] 702 | }, 703 | { 704 | "cell_type": "code", 705 | "execution_count": 44, 706 | "metadata": {}, 707 | "outputs": [ 708 | { 709 | "data": { 710 | "text/plain": [ 711 | "368" 712 | ] 713 | }, 714 | "execution_count": 44, 715 | "metadata": {}, 716 | "output_type": "execute_result" 717 | } 718 | ], 719 | "source": [ 720 | "x *= 2\n", 721 | "x" 722 | ] 723 | }, 724 | { 725 | "cell_type": "code", 726 | "execution_count": 48, 727 | "metadata": {}, 728 | "outputs": [ 729 | { 730 | "data": { 731 | "text/plain": [ 732 | "23.0" 733 | ] 734 | }, 735 | "execution_count": 48, 736 | "metadata": {}, 737 | "output_type": "execute_result" 738 | } 739 | ], 740 | "source": [ 741 | "x /= 2\n", 742 | "x" 743 | ] 744 | }, 745 | { 746 | "cell_type": "markdown", 747 | "metadata": {}, 748 | "source": [ 749 | "## 字符串(string)\n", 750 | "\n", 751 | "quote ' 和double quote \" 都可以用作字符串" 752 | ] 753 | }, 754 | { 755 | "cell_type": "code", 756 | "execution_count": 49, 757 | "metadata": {}, 758 | "outputs": [ 759 | { 760 | "data": { 761 | "text/plain": [ 762 | "'Julyedu'" 763 | ] 764 | }, 765 | "execution_count": 49, 766 | "metadata": {}, 767 | "output_type": "execute_result" 768 | } 769 | ], 770 | "source": [ 771 | "\"Julyedu\"" 772 | ] 773 | }, 774 | { 775 | "cell_type": "code", 776 | "execution_count": 50, 777 | "metadata": {}, 778 | "outputs": [ 779 | { 780 | "data": { 781 | "text/plain": [ 782 | "'Julyedu'" 783 | ] 784 | }, 785 | "execution_count": 50, 786 | "metadata": {}, 787 | "output_type": "execute_result" 788 | } 789 | ], 790 | "source": [ 791 | "'Julyedu'" 792 | ] 793 | }, 794 | { 795 | "cell_type": "code", 796 | "execution_count": 51, 797 | "metadata": {}, 798 | "outputs": [ 799 | { 800 | "ename": "SyntaxError", 801 | "evalue": "EOL while scanning string literal (, line 1)", 802 | "output_type": "error", 803 | "traceback": [ 804 | "\u001b[1;36m File \u001b[1;32m\"\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m \"July'\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m EOL while scanning string literal\n" 805 | ] 806 | } 807 | ], 808 | "source": [ 809 | "\"July'" 810 | ] 811 | }, 812 | { 813 | "cell_type": "code", 814 | "execution_count": null, 815 | "metadata": { 816 | "collapsed": true 817 | }, 818 | "outputs": [], 819 | "source": [] 820 | }, 821 | { 822 | "cell_type": "markdown", 823 | "metadata": {}, 824 | "source": [ 825 | "两者之间在表示一个字符串上没有区别，但是一个字符串的开头和结尾必须使用同一种引号。\n", 826 | "backslash \\ 可以用来escape引号。" 827 | ] 828 | }, 829 | { 830 | "cell_type": "markdown", 831 | "metadata": {}, 832 | "source": [ 833 | "当然也可以使用两种不同的引号来区分究竟是字符串结尾还是字符串中出现了引号。" 834 | ] 835 | }, 836 | { 837 | "cell_type": "code", 838 | "execution_count": 52, 839 | "metadata": {}, 840 | "outputs": [ 841 | { 842 | "data": { 843 | "text/plain": [ 844 | "\"I'm gonna get up at 4am tomorrow\"" 845 | ] 846 | }, 847 | "execution_count": 52, 848 | "metadata": {}, 849 | "output_type": "execute_result" 850 | } 851 | ], 852 | "source": [ 853 | "\"I'm gonna get up at 4am tomorrow\"" 854 | ] 855 | }, 856 | { 857 | "cell_type": "code", 858 | "execution_count": 53, 859 | "metadata": {}, 860 | "outputs": [ 861 | { 862 | "data": { 863 | "text/plain": [ 864 | "'I\"m gonna get up at 4am tomorrow'" 865 | ] 866 | }, 867 | "execution_count": 53, 868 | "metadata": {}, 869 | "output_type": "execute_result" 870 | } 871 | ], 872 | "source": [ 873 | "'I\"m gonna get up at 4am tomorrow'" 874 | ] 875 | }, 876 | { 877 | "cell_type": "code", 878 | "execution_count": 55, 879 | "metadata": {}, 880 | "outputs": [ 881 | { 882 | "data": { 883 | "text/plain": [ 884 | "\"I'm gonna get up at 4\"" 885 | ] 886 | }, 887 | "execution_count": 55, 888 | "metadata": {}, 889 | "output_type": "execute_result" 890 | } 891 | ], 892 | "source": [ 893 | "'I\\'m gonna get up at 4'" 894 | ] 895 | }, 896 | { 897 | "cell_type": "markdown", 898 | "metadata": {}, 899 | "source": [ 900 | "如果一个string有好多行" 901 | ] 902 | }, 903 | { 904 | "cell_type": "code", 905 | "execution_count": 58, 906 | "metadata": {}, 907 | "outputs": [ 908 | { 909 | "name": "stdout", 910 | "output_type": "stream", 911 | "text": [ 912 | "first line\n", 913 | "second line\n", 914 | "third line\n" 915 | ] 916 | } 917 | ], 918 | "source": [ 919 | "print(\"\"\"first line\n", 920 | "second line\n", 921 | "third line\"\"\")" 922 | ] 923 | }, 924 | { 925 | "cell_type": "markdown", 926 | "metadata": {}, 927 | "source": [ 928 | "\\n 是换行符，可以用在strign中换行" 929 | ] 930 | }, 931 | { 932 | "cell_type": "code", 933 | "execution_count": 59, 934 | "metadata": {}, 935 | "outputs": [ 936 | { 937 | "name": "stdout", 938 | "output_type": "stream", 939 | "text": [ 940 | "first line\n", 941 | "second line\n", 942 | "third line\n" 943 | ] 944 | } 945 | ], 946 | "source": [ 947 | "print(\"first line\\nsecond line\\nthird line\")" 948 | ] 949 | }, 950 | { 951 | "cell_type": "markdown", 952 | "metadata": {}, 953 | "source": [ 954 | "\\t是tab键" 955 | ] 956 | }, 957 | { 958 | "cell_type": "code", 959 | "execution_count": 60, 960 | "metadata": {}, 961 | "outputs": [ 962 | { 963 | "name": "stdout", 964 | "output_type": "stream", 965 | "text": [ 966 | "first line\tsecond line\tthird line\n" 967 | ] 968 | } 969 | ], 970 | "source": [ 971 | "print(\"first line\\tsecond line\\tthird line\")" 972 | ] 973 | }, 974 | { 975 | "cell_type": "markdown", 976 | "metadata": {}, 977 | "source": [ 978 | "+可以把两个string连到一起(concatenation)" 979 | ] 980 | }, 981 | { 982 | "cell_type": "code", 983 | "execution_count": 67, 984 | "metadata": {}, 985 | "outputs": [ 986 | { 987 | "data": { 988 | "text/plain": [ 989 | "'Hello Julyedu33'" 990 | ] 991 | }, 992 | "execution_count": 67, 993 | "metadata": {}, 994 | "output_type": "execute_result" 995 | } 996 | ], 997 | "source": [ 998 | "\"Hello\" + \" \" + \"Julyedu\" + str(33)" 999 | ] 1000 | }, 1001 | { 1002 | "cell_type": "code", 1003 | "execution_count": 70, 1004 | "metadata": {}, 1005 | "outputs": [ 1006 | { 1007 | "data": { 1008 | "text/plain": [ 1009 | "float" 1010 | ] 1011 | }, 1012 | "execution_count": 70, 1013 | "metadata": {}, 1014 | "output_type": "execute_result" 1015 | } 1016 | ], 1017 | "source": [ 1018 | "type(12.5)" 1019 | ] 1020 | }, 1021 | { 1022 | "cell_type": "code", 1023 | "execution_count": 71, 1024 | "metadata": {}, 1025 | "outputs": [ 1026 | { 1027 | "data": { 1028 | "text/plain": [ 1029 | "'23.0, 2.0, 25.0'" 1030 | ] 1031 | }, 1032 | "execution_count": 71, 1033 | "metadata": {}, 1034 | "output_type": "execute_result" 1035 | } 1036 | ], 1037 | "source": [ 1038 | "\"{}, {}, {}\".format(x, y, x+y)" 1039 | ] 1040 | }, 1041 | { 1042 | "cell_type": "code", 1043 | "execution_count": 74, 1044 | "metadata": {}, 1045 | "outputs": [ 1046 | { 1047 | "data": { 1048 | "text/plain": [ 1049 | "float" 1050 | ] 1051 | }, 1052 | "execution_count": 74, 1053 | "metadata": {}, 1054 | "output_type": "execute_result" 1055 | } 1056 | ], 1057 | "source": [ 1058 | "type(x+y)" 1059 | ] 1060 | }, 1061 | { 1062 | "cell_type": "markdown", 1063 | "metadata": {}, 1064 | "source": [ 1065 | "## string indexing and slicing\n", 1066 | "- indexing" 1067 | ] 1068 | }, 1069 | { 1070 | "cell_type": "code", 1071 | "execution_count": 63, 1072 | "metadata": { 1073 | "collapsed": true 1074 | }, 1075 | "outputs": [], 1076 | "source": [ 1077 | "w = \"Julyedu\"" 1078 | ] 1079 | }, 1080 | { 1081 | "cell_type": "code", 1082 | "execution_count": 64, 1083 | "metadata": {}, 1084 | "outputs": [ 1085 | { 1086 | "data": { 1087 | "text/plain": [ 1088 | "'Julyedu'" 1089 | ] 1090 | }, 1091 | "execution_count": 64, 1092 | "metadata": {}, 1093 | "output_type": "execute_result" 1094 | } 1095 | ], 1096 | "source": [ 1097 | "w" 1098 | ] 1099 | }, 1100 | { 1101 | "cell_type": "code", 1102 | "execution_count": 65, 1103 | "metadata": {}, 1104 | "outputs": [ 1105 | { 1106 | "data": { 1107 | "text/plain": [ 1108 | "'J'" 1109 | ] 1110 | }, 1111 | "execution_count": 65, 1112 | "metadata": {}, 1113 | "output_type": "execute_result" 1114 | } 1115 | ], 1116 | "source": [ 1117 | "w[0]" 1118 | ] 1119 | }, 1120 | { 1121 | "cell_type": "code", 1122 | "execution_count": 75, 1123 | "metadata": {}, 1124 | "outputs": [ 1125 | { 1126 | "data": { 1127 | "text/plain": [ 1128 | "'u'" 1129 | ] 1130 | }, 1131 | "execution_count": 75, 1132 | "metadata": {}, 1133 | "output_type": "execute_result" 1134 | } 1135 | ], 1136 | "source": [ 1137 | "w[1]" 1138 | ] 1139 | }, 1140 | { 1141 | "cell_type": "code", 1142 | "execution_count": 76, 1143 | "metadata": {}, 1144 | "outputs": [ 1145 | { 1146 | "data": { 1147 | "text/plain": [ 1148 | "'u'" 1149 | ] 1150 | }, 1151 | "execution_count": 76, 1152 | "metadata": {}, 1153 | "output_type": "execute_result" 1154 | } 1155 | ], 1156 | "source": [ 1157 | "w[6]" 1158 | ] 1159 | }, 1160 | { 1161 | "cell_type": "code", 1162 | "execution_count": 77, 1163 | "metadata": {}, 1164 | "outputs": [ 1165 | { 1166 | "ename": "IndexError", 1167 | "evalue": "string index out of range", 1168 | "output_type": "error", 1169 | "traceback": [ 1170 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 1171 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 1172 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mw\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 1173 | "\u001b[1;31mIndexError\u001b[0m: string index out of range" 1174 | ] 1175 | } 1176 | ], 1177 | "source": [ 1178 | "w[7]" 1179 | ] 1180 | }, 1181 | { 1182 | "cell_type": "code", 1183 | "execution_count": 78, 1184 | "metadata": {}, 1185 | "outputs": [ 1186 | { 1187 | "data": { 1188 | "text/plain": [ 1189 | "'u'" 1190 | ] 1191 | }, 1192 | "execution_count": 78, 1193 | "metadata": {}, 1194 | "output_type": "execute_result" 1195 | } 1196 | ], 1197 | "source": [ 1198 | "w[-1]" 1199 | ] 1200 | }, 1201 | { 1202 | "cell_type": "code", 1203 | "execution_count": 79, 1204 | "metadata": {}, 1205 | "outputs": [ 1206 | { 1207 | "data": { 1208 | "text/plain": [ 1209 | "'d'" 1210 | ] 1211 | }, 1212 | "execution_count": 79, 1213 | "metadata": {}, 1214 | "output_type": "execute_result" 1215 | } 1216 | ], 1217 | "source": [ 1218 | "w[-2]" 1219 | ] 1220 | }, 1221 | { 1222 | "cell_type": "code", 1223 | "execution_count": 80, 1224 | "metadata": {}, 1225 | "outputs": [ 1226 | { 1227 | "data": { 1228 | "text/plain": [ 1229 | "'J'" 1230 | ] 1231 | }, 1232 | "execution_count": 80, 1233 | "metadata": {}, 1234 | "output_type": "execute_result" 1235 | } 1236 | ], 1237 | "source": [ 1238 | "w[-7]" 1239 | ] 1240 | }, 1241 | { 1242 | "cell_type": "code", 1243 | "execution_count": 81, 1244 | "metadata": {}, 1245 | "outputs": [ 1246 | { 1247 | "ename": "IndexError", 1248 | "evalue": "string index out of range", 1249 | "output_type": "error", 1250 | "traceback": [ 1251 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 1252 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 1253 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mw\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 1254 | "\u001b[1;31mIndexError\u001b[0m: string index out of range" 1255 | ] 1256 | } 1257 | ], 1258 | "source": [ 1259 | "w[-8]" 1260 | ] 1261 | }, 1262 | { 1263 | "cell_type": "markdown", 1264 | "metadata": {}, 1265 | "source": [ 1266 | "- slicing" 1267 | ] 1268 | }, 1269 | { 1270 | "cell_type": "code", 1271 | "execution_count": 82, 1272 | "metadata": {}, 1273 | "outputs": [ 1274 | { 1275 | "data": { 1276 | "text/plain": [ 1277 | "'Julyedu'" 1278 | ] 1279 | }, 1280 | "execution_count": 82, 1281 | "metadata": {}, 1282 | "output_type": "execute_result" 1283 | } 1284 | ], 1285 | "source": [ 1286 | "w" 1287 | ] 1288 | }, 1289 | { 1290 | "cell_type": "code", 1291 | "execution_count": 83, 1292 | "metadata": {}, 1293 | "outputs": [ 1294 | { 1295 | "data": { 1296 | "text/plain": [ 1297 | "'ul'" 1298 | ] 1299 | }, 1300 | "execution_count": 83, 1301 | "metadata": {}, 1302 | "output_type": "execute_result" 1303 | } 1304 | ], 1305 | "source": [ 1306 | "w[1:3]" 1307 | ] 1308 | }, 1309 | { 1310 | "cell_type": "code", 1311 | "execution_count": 84, 1312 | "metadata": {}, 1313 | "outputs": [ 1314 | { 1315 | "data": { 1316 | "text/plain": [ 1317 | "'du'" 1318 | ] 1319 | }, 1320 | "execution_count": 84, 1321 | "metadata": {}, 1322 | "output_type": "execute_result" 1323 | } 1324 | ], 1325 | "source": [ 1326 | "w[5:7]" 1327 | ] 1328 | }, 1329 | { 1330 | "cell_type": "code", 1331 | "execution_count": 85, 1332 | "metadata": {}, 1333 | "outputs": [ 1334 | { 1335 | "data": { 1336 | "text/plain": [ 1337 | "'ed'" 1338 | ] 1339 | }, 1340 | "execution_count": 85, 1341 | "metadata": {}, 1342 | "output_type": "execute_result" 1343 | } 1344 | ], 1345 | "source": [ 1346 | "w[4:-1]" 1347 | ] 1348 | }, 1349 | { 1350 | "cell_type": "code", 1351 | "execution_count": 86, 1352 | "metadata": {}, 1353 | "outputs": [ 1354 | { 1355 | "data": { 1356 | "text/plain": [ 1357 | "'yedu'" 1358 | ] 1359 | }, 1360 | "execution_count": 86, 1361 | "metadata": {}, 1362 | "output_type": "execute_result" 1363 | } 1364 | ], 1365 | "source": [ 1366 | "w[3:]" 1367 | ] 1368 | }, 1369 | { 1370 | "cell_type": "code", 1371 | "execution_count": 87, 1372 | "metadata": {}, 1373 | "outputs": [ 1374 | { 1375 | "data": { 1376 | "text/plain": [ 1377 | "'Julye'" 1378 | ] 1379 | }, 1380 | "execution_count": 87, 1381 | "metadata": {}, 1382 | "output_type": "execute_result" 1383 | } 1384 | ], 1385 | "source": [ 1386 | "w[:5]" 1387 | ] 1388 | }, 1389 | { 1390 | "cell_type": "code", 1391 | "execution_count": 88, 1392 | "metadata": {}, 1393 | "outputs": [ 1394 | { 1395 | "data": { 1396 | "text/plain": [ 1397 | "'du'" 1398 | ] 1399 | }, 1400 | "execution_count": 88, 1401 | "metadata": {}, 1402 | "output_type": "execute_result" 1403 | } 1404 | ], 1405 | "source": [ 1406 | "w[5:100]" 1407 | ] 1408 | }, 1409 | { 1410 | "cell_type": "code", 1411 | "execution_count": 89, 1412 | "metadata": {}, 1413 | "outputs": [ 1414 | { 1415 | "data": { 1416 | "text/plain": [ 1417 | "'u'" 1418 | ] 1419 | }, 1420 | "execution_count": 89, 1421 | "metadata": {}, 1422 | "output_type": "execute_result" 1423 | } 1424 | ], 1425 | "source": [ 1426 | "w[-1:100]" 1427 | ] 1428 | }, 1429 | { 1430 | "cell_type": "markdown", 1431 | "metadata": {}, 1432 | "source": [ 1433 | "## 字符串函数\n", 1434 | "\n", 1435 | "- upper and lower" 1436 | ] 1437 | }, 1438 | { 1439 | "cell_type": "code", 1440 | "execution_count": 90, 1441 | "metadata": {}, 1442 | "outputs": [ 1443 | { 1444 | "data": { 1445 | "text/plain": [ 1446 | "'JULYEDU'" 1447 | ] 1448 | }, 1449 | "execution_count": 90, 1450 | "metadata": {}, 1451 | "output_type": "execute_result" 1452 | } 1453 | ], 1454 | "source": [ 1455 | "w.upper()" 1456 | ] 1457 | }, 1458 | { 1459 | "cell_type": "markdown", 1460 | "metadata": {}, 1461 | "source": [ 1462 | "- startswith and endswith" 1463 | ] 1464 | }, 1465 | { 1466 | "cell_type": "code", 1467 | "execution_count": 95, 1468 | "metadata": {}, 1469 | "outputs": [ 1470 | { 1471 | "data": { 1472 | "text/plain": [ 1473 | "'julyedu'" 1474 | ] 1475 | }, 1476 | "execution_count": 95, 1477 | "metadata": {}, 1478 | "output_type": "execute_result" 1479 | } 1480 | ], 1481 | "source": [ 1482 | "w.lower()" 1483 | ] 1484 | }, 1485 | { 1486 | "cell_type": "code", 1487 | "execution_count": 93, 1488 | "metadata": {}, 1489 | "outputs": [ 1490 | { 1491 | "data": { 1492 | "text/plain": [ 1493 | "'Julyedu'" 1494 | ] 1495 | }, 1496 | "execution_count": 93, 1497 | "metadata": {}, 1498 | "output_type": "execute_result" 1499 | } 1500 | ], 1501 | "source": [ 1502 | "w.lower().capitalize()" 1503 | ] 1504 | }, 1505 | { 1506 | "cell_type": "code", 1507 | "execution_count": 98, 1508 | "metadata": {}, 1509 | "outputs": [ 1510 | { 1511 | "data": { 1512 | "text/plain": [ 1513 | "True" 1514 | ] 1515 | }, 1516 | "execution_count": 98, 1517 | "metadata": {}, 1518 | "output_type": "execute_result" 1519 | } 1520 | ], 1521 | "source": [ 1522 | "w.startswith(\"July\")" 1523 | ] 1524 | }, 1525 | { 1526 | "cell_type": "code", 1527 | "execution_count": 100, 1528 | "metadata": {}, 1529 | "outputs": [ 1530 | { 1531 | "data": { 1532 | "text/plain": [ 1533 | "False" 1534 | ] 1535 | }, 1536 | "execution_count": 100, 1537 | "metadata": {}, 1538 | "output_type": "execute_result" 1539 | } 1540 | ], 1541 | "source": [ 1542 | "w.endswith(\"ud\")" 1543 | ] 1544 | }, 1545 | { 1546 | "cell_type": "markdown", 1547 | "metadata": {}, 1548 | "source": [ 1549 | "- strip" 1550 | ] 1551 | }, 1552 | { 1553 | "cell_type": "code", 1554 | "execution_count": 103, 1555 | "metadata": {}, 1556 | "outputs": [ 1557 | { 1558 | "data": { 1559 | "text/plain": [ 1560 | "' Julyedu '" 1561 | ] 1562 | }, 1563 | "execution_count": 103, 1564 | "metadata": {}, 1565 | "output_type": "execute_result" 1566 | } 1567 | ], 1568 | "source": [ 1569 | "w = \" Julyedu \"\n", 1570 | "w" 1571 | ] 1572 | }, 1573 | { 1574 | "cell_type": "code", 1575 | "execution_count": 102, 1576 | "metadata": {}, 1577 | "outputs": [ 1578 | { 1579 | "data": { 1580 | "text/plain": [ 1581 | "'Julyedu'" 1582 | ] 1583 | }, 1584 | "execution_count": 102, 1585 | "metadata": {}, 1586 | "output_type": "execute_result" 1587 | } 1588 | ], 1589 | "source": [ 1590 | "w.strip()" 1591 | ] 1592 | }, 1593 | { 1594 | "cell_type": "code", 1595 | "execution_count": 104, 1596 | "metadata": {}, 1597 | "outputs": [ 1598 | { 1599 | "data": { 1600 | "text/plain": [ 1601 | "'Julyedu '" 1602 | ] 1603 | }, 1604 | "execution_count": 104, 1605 | "metadata": {}, 1606 | "output_type": "execute_result" 1607 | } 1608 | ], 1609 | "source": [ 1610 | "w.lstrip()" 1611 | ] 1612 | }, 1613 | { 1614 | "cell_type": "code", 1615 | "execution_count": 105, 1616 | "metadata": {}, 1617 | "outputs": [ 1618 | { 1619 | "data": { 1620 | "text/plain": [ 1621 | "' Julyedu'" 1622 | ] 1623 | }, 1624 | "execution_count": 105, 1625 | "metadata": {}, 1626 | "output_type": "execute_result" 1627 | } 1628 | ], 1629 | "source": [ 1630 | "w.rstrip()" 1631 | ] 1632 | }, 1633 | { 1634 | "cell_type": "markdown", 1635 | "metadata": {}, 1636 | "source": [ 1637 | "- split\n", 1638 | "把一个string拆成一个list of strings" 1639 | ] 1640 | }, 1641 | { 1642 | "cell_type": "code", 1643 | "execution_count": 106, 1644 | "metadata": { 1645 | "collapsed": true 1646 | }, 1647 | "outputs": [], 1648 | "source": [ 1649 | "s = \"burger ramen fries spaghetti steak dimsum\"" 1650 | ] 1651 | }, 1652 | { 1653 | "cell_type": "code", 1654 | "execution_count": 107, 1655 | "metadata": {}, 1656 | "outputs": [ 1657 | { 1658 | "data": { 1659 | "text/plain": [ 1660 | "['burger', 'ramen', 'fries', 'spaghetti', 'steak', 'dimsum']" 1661 | ] 1662 | }, 1663 | "execution_count": 107, 1664 | "metadata": {}, 1665 | "output_type": "execute_result" 1666 | } 1667 | ], 1668 | "source": [ 1669 | "s.split()" 1670 | ] 1671 | }, 1672 | { 1673 | "cell_type": "code", 1674 | "execution_count": 108, 1675 | "metadata": { 1676 | "collapsed": true 1677 | }, 1678 | "outputs": [], 1679 | "source": [ 1680 | "s = \"burger,ramen,fries,spaghetti,steak,dimsum\"" 1681 | ] 1682 | }, 1683 | { 1684 | "cell_type": "code", 1685 | "execution_count": 110, 1686 | "metadata": {}, 1687 | "outputs": [ 1688 | { 1689 | "data": { 1690 | "text/plain": [ 1691 | "['burger', 'ramen', 'fries', 'spaghetti', 'steak', 'dimsum']" 1692 | ] 1693 | }, 1694 | "execution_count": 110, 1695 | "metadata": {}, 1696 | "output_type": "execute_result" 1697 | } 1698 | ], 1699 | "source": [ 1700 | "s.split(\",\")" 1701 | ] 1702 | }, 1703 | { 1704 | "cell_type": "code", 1705 | "execution_count": null, 1706 | "metadata": { 1707 | "collapsed": true 1708 | }, 1709 | "outputs": [], 1710 | "source": [] 1711 | }, 1712 | { 1713 | "cell_type": "markdown", 1714 | "metadata": {}, 1715 | "source": [ 1716 | "- find: 找到第一个substring出现的位置" 1717 | ] 1718 | }, 1719 | { 1720 | "cell_type": "code", 1721 | "execution_count": 113, 1722 | "metadata": {}, 1723 | "outputs": [ 1724 | { 1725 | "data": { 1726 | "text/plain": [ 1727 | "'Julyedu'" 1728 | ] 1729 | }, 1730 | "execution_count": 113, 1731 | "metadata": {}, 1732 | "output_type": "execute_result" 1733 | } 1734 | ], 1735 | "source": [ 1736 | "w = w.strip()\n", 1737 | "w" 1738 | ] 1739 | }, 1740 | { 1741 | "cell_type": "code", 1742 | "execution_count": 115, 1743 | "metadata": {}, 1744 | "outputs": [ 1745 | { 1746 | "data": { 1747 | "text/plain": [ 1748 | "2" 1749 | ] 1750 | }, 1751 | "execution_count": 115, 1752 | "metadata": {}, 1753 | "output_type": "execute_result" 1754 | } 1755 | ], 1756 | "source": [ 1757 | "w.find(\"ly\")" 1758 | ] 1759 | }, 1760 | { 1761 | "cell_type": "markdown", 1762 | "metadata": {}, 1763 | "source": [ 1764 | "如果输入一个不存在的substring那就会返回-1了" 1765 | ] 1766 | }, 1767 | { 1768 | "cell_type": "code", 1769 | "execution_count": 116, 1770 | "metadata": {}, 1771 | "outputs": [ 1772 | { 1773 | "data": { 1774 | "text/plain": [ 1775 | "-1" 1776 | ] 1777 | }, 1778 | "execution_count": 116, 1779 | "metadata": {}, 1780 | "output_type": "execute_result" 1781 | } 1782 | ], 1783 | "source": [ 1784 | "w.find(\"a\")" 1785 | ] 1786 | }, 1787 | { 1788 | "cell_type": "code", 1789 | "execution_count": 118, 1790 | "metadata": {}, 1791 | "outputs": [ 1792 | { 1793 | "data": { 1794 | "text/plain": [ 1795 | "True" 1796 | ] 1797 | }, 1798 | "execution_count": 118, 1799 | "metadata": {}, 1800 | "output_type": "execute_result" 1801 | } 1802 | ], 1803 | "source": [ 1804 | "\"ly\" in w" 1805 | ] 1806 | }, 1807 | { 1808 | "cell_type": "markdown", 1809 | "metadata": {}, 1810 | "source": [ 1811 | "- replace" 1812 | ] 1813 | }, 1814 | { 1815 | "cell_type": "code", 1816 | "execution_count": 123, 1817 | "metadata": {}, 1818 | "outputs": [ 1819 | { 1820 | "data": { 1821 | "text/plain": [ 1822 | "'burger\\nramen\\nfries\\nspaghetti\\nsteak\\ndimsum'" 1823 | ] 1824 | }, 1825 | "execution_count": 123, 1826 | "metadata": {}, 1827 | "output_type": "execute_result" 1828 | } 1829 | ], 1830 | "source": [ 1831 | "s.replace(\",\", \"\\n\")" 1832 | ] 1833 | }, 1834 | { 1835 | "cell_type": "markdown", 1836 | "metadata": {}, 1837 | "source": [ 1838 | "# List\n", 1839 | "\n", 1840 | "list 是一种python的数据类型，表示一连串的数据的集合。\n", 1841 | "\n", 1842 | "- 如何创建一个list" 1843 | ] 1844 | }, 1845 | { 1846 | "cell_type": "code", 1847 | "execution_count": 124, 1848 | "metadata": {}, 1849 | "outputs": [ 1850 | { 1851 | "data": { 1852 | "text/plain": [ 1853 | "['Tensorflow', 'Keras', 'Torch', 'Caffe', 'Julyedu']" 1854 | ] 1855 | }, 1856 | "execution_count": 124, 1857 | "metadata": {}, 1858 | "output_type": "execute_result" 1859 | } 1860 | ], 1861 | "source": [ 1862 | "names = [\"Tensorflow\", \"Keras\", \"Torch\", \"Caffe\", \"Julyedu\"]\n", 1863 | "names" 1864 | ] 1865 | }, 1866 | { 1867 | "cell_type": "code", 1868 | "execution_count": 125, 1869 | "metadata": {}, 1870 | "outputs": [ 1871 | { 1872 | "data": { 1873 | "text/plain": [ 1874 | "list" 1875 | ] 1876 | }, 1877 | "execution_count": 125, 1878 | "metadata": {}, 1879 | "output_type": "execute_result" 1880 | } 1881 | ], 1882 | "source": [ 1883 | "type(names)" 1884 | ] 1885 | }, 1886 | { 1887 | "cell_type": "markdown", 1888 | "metadata": {}, 1889 | "source": [ 1890 | "- list indexing" 1891 | ] 1892 | }, 1893 | { 1894 | "cell_type": "code", 1895 | "execution_count": 126, 1896 | "metadata": {}, 1897 | "outputs": [ 1898 | { 1899 | "data": { 1900 | "text/plain": [ 1901 | "'Tensorflow'" 1902 | ] 1903 | }, 1904 | "execution_count": 126, 1905 | "metadata": {}, 1906 | "output_type": "execute_result" 1907 | } 1908 | ], 1909 | "source": [ 1910 | "names[0]" 1911 | ] 1912 | }, 1913 | { 1914 | "cell_type": "code", 1915 | "execution_count": 127, 1916 | "metadata": {}, 1917 | "outputs": [ 1918 | { 1919 | "data": { 1920 | "text/plain": [ 1921 | "'Keras'" 1922 | ] 1923 | }, 1924 | "execution_count": 127, 1925 | "metadata": {}, 1926 | "output_type": "execute_result" 1927 | } 1928 | ], 1929 | "source": [ 1930 | "names[1]" 1931 | ] 1932 | }, 1933 | { 1934 | "cell_type": "code", 1935 | "execution_count": 128, 1936 | "metadata": {}, 1937 | "outputs": [ 1938 | { 1939 | "data": { 1940 | "text/plain": [ 1941 | "'Julyedu'" 1942 | ] 1943 | }, 1944 | "execution_count": 128, 1945 | "metadata": {}, 1946 | "output_type": "execute_result" 1947 | } 1948 | ], 1949 | "source": [ 1950 | "names[-1]" 1951 | ] 1952 | }, 1953 | { 1954 | "cell_type": "code", 1955 | "execution_count": 130, 1956 | "metadata": {}, 1957 | "outputs": [ 1958 | { 1959 | "ename": "IndexError", 1960 | "evalue": "list index out of range", 1961 | "output_type": "error", 1962 | "traceback": [ 1963 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 1964 | "\u001b[1;31mIndexError\u001b[0m Traceback (most recent call last)", 1965 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnames\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 1966 | "\u001b[1;31mIndexError\u001b[0m: list index out of range" 1967 | ] 1968 | } 1969 | ], 1970 | "source": [ 1971 | "names[-10]" 1972 | ] 1973 | }, 1974 | { 1975 | "cell_type": "markdown", 1976 | "metadata": {}, 1977 | "source": [ 1978 | "- list slicing" 1979 | ] 1980 | }, 1981 | { 1982 | "cell_type": "code", 1983 | "execution_count": 132, 1984 | "metadata": {}, 1985 | "outputs": [ 1986 | { 1987 | "data": { 1988 | "text/plain": [ 1989 | "['Tensorflow', 'Keras', 'Torch', 'Caffe', 'Julyedu']" 1990 | ] 1991 | }, 1992 | "execution_count": 132, 1993 | "metadata": {}, 1994 | "output_type": "execute_result" 1995 | } 1996 | ], 1997 | "source": [ 1998 | "names" 1999 | ] 2000 | }, 2001 | { 2002 | "cell_type": "code", 2003 | "execution_count": 137, 2004 | "metadata": {}, 2005 | "outputs": [ 2006 | { 2007 | "data": { 2008 | "text/plain": [ 2009 | "['Tensorflow', 'Keras', 'Torch', 'Caffe']" 2010 | ] 2011 | }, 2012 | "execution_count": 137, 2013 | "metadata": {}, 2014 | "output_type": "execute_result" 2015 | } 2016 | ], 2017 | "source": [ 2018 | "names[:-1]" 2019 | ] 2020 | }, 2021 | { 2022 | "cell_type": "markdown", 2023 | "metadata": {}, 2024 | "source": [ 2025 | "- 我们可以直接把string变成一个list" 2026 | ] 2027 | }, 2028 | { 2029 | "cell_type": "code", 2030 | "execution_count": 138, 2031 | "metadata": {}, 2032 | "outputs": [ 2033 | { 2034 | "data": { 2035 | "text/plain": [ 2036 | "['J', 'u', 'l', 'y', 'e', 'd', 'u']" 2037 | ] 2038 | }, 2039 | "execution_count": 138, 2040 | "metadata": {}, 2041 | "output_type": "execute_result" 2042 | } 2043 | ], 2044 | "source": [ 2045 | "list(\"Julyedu\")" 2046 | ] 2047 | }, 2048 | { 2049 | "cell_type": "markdown", 2050 | "metadata": {}, 2051 | "source": [ 2052 | "- 求list的长度" 2053 | ] 2054 | }, 2055 | { 2056 | "cell_type": "code", 2057 | "execution_count": 140, 2058 | "metadata": {}, 2059 | "outputs": [ 2060 | { 2061 | "data": { 2062 | "text/plain": [ 2063 | "5" 2064 | ] 2065 | }, 2066 | "execution_count": 140, 2067 | "metadata": {}, 2068 | "output_type": "execute_result" 2069 | } 2070 | ], 2071 | "source": [ 2072 | "len(names)" 2073 | ] 2074 | }, 2075 | { 2076 | "cell_type": "markdown", 2077 | "metadata": {}, 2078 | "source": [ 2079 | "- append方法可以在list的末尾添加element" 2080 | ] 2081 | }, 2082 | { 2083 | "cell_type": "code", 2084 | "execution_count": 141, 2085 | "metadata": {}, 2086 | "outputs": [ 2087 | { 2088 | "data": { 2089 | "text/plain": [ 2090 | "['Tensorflow', 'Keras', 'Torch', 'Caffe', 'Julyedu', 'PyTorch']" 2091 | ] 2092 | }, 2093 | "execution_count": 141, 2094 | "metadata": {}, 2095 | "output_type": "execute_result" 2096 | } 2097 | ], 2098 | "source": [ 2099 | "names.append(\"PyTorch\")\n", 2100 | "names" 2101 | ] 2102 | }, 2103 | { 2104 | "cell_type": "code", 2105 | "execution_count": 142, 2106 | "metadata": {}, 2107 | "outputs": [ 2108 | { 2109 | "data": { 2110 | "text/plain": [ 2111 | "['Tensorflow',\n", 2112 | " 'Keras',\n", 2113 | " 'Torch',\n", 2114 | " 'Caffe',\n", 2115 | " 'Julyedu',\n", 2116 | " 'PyTorch',\n", 2117 | " 12,\n", 2118 | " -5.4,\n", 2119 | " [2, 4, 'Title']]" 2120 | ] 2121 | }, 2122 | "execution_count": 142, 2123 | "metadata": {}, 2124 | "output_type": "execute_result" 2125 | } 2126 | ], 2127 | "source": [ 2128 | "names.append(12)\n", 2129 | "names.append(-5.4)\n", 2130 | "names.append([2,4,\"Title\"])\n", 2131 | "names" 2132 | ] 2133 | }, 2134 | { 2135 | "cell_type": "code", 2136 | "execution_count": 143, 2137 | "metadata": {}, 2138 | "outputs": [ 2139 | { 2140 | "data": { 2141 | "text/plain": [ 2142 | "[2, 4, 'Title']" 2143 | ] 2144 | }, 2145 | "execution_count": 143, 2146 | "metadata": {}, 2147 | "output_type": "execute_result" 2148 | } 2149 | ], 2150 | "source": [ 2151 | "names[-1]" 2152 | ] 2153 | }, 2154 | { 2155 | "cell_type": "markdown", 2156 | "metadata": {}, 2157 | "source": [ 2158 | "- 两个list相加合并成新的list" 2159 | ] 2160 | }, 2161 | { 2162 | "cell_type": "code", 2163 | "execution_count": 145, 2164 | "metadata": {}, 2165 | "outputs": [ 2166 | { 2167 | "data": { 2168 | "text/plain": [ 2169 | "False" 2170 | ] 2171 | }, 2172 | "execution_count": 145, 2173 | "metadata": {}, 2174 | "output_type": "execute_result" 2175 | } 2176 | ], 2177 | "source": [ 2178 | "\"aaaaaa\" in names" 2179 | ] 2180 | }, 2181 | { 2182 | "cell_type": "markdown", 2183 | "metadata": {}, 2184 | "source": [ 2185 | "- 判断一个element是否在一个list里面" 2186 | ] 2187 | }, 2188 | { 2189 | "cell_type": "markdown", 2190 | "metadata": {}, 2191 | "source": [ 2192 | "- insert" 2193 | ] 2194 | }, 2195 | { 2196 | "cell_type": "code", 2197 | "execution_count": 150, 2198 | "metadata": { 2199 | "collapsed": true 2200 | }, 2201 | "outputs": [], 2202 | "source": [ 2203 | "names.insert(-100, \"Bazinga\")" 2204 | ] 2205 | }, 2206 | { 2207 | "cell_type": "code", 2208 | "execution_count": 151, 2209 | "metadata": {}, 2210 | "outputs": [ 2211 | { 2212 | "data": { 2213 | "text/plain": [ 2214 | "['Bazinga',\n", 2215 | " 'Tensorflow',\n", 2216 | " 'Keras',\n", 2217 | " 'Happy',\n", 2218 | " 'Torch',\n", 2219 | " 'Caffe',\n", 2220 | " 'Julyedu',\n", 2221 | " 'PyTorch',\n", 2222 | " 12,\n", 2223 | " -5.4,\n", 2224 | " 'Sad',\n", 2225 | " [2, 4, 'Title']]" 2226 | ] 2227 | }, 2228 | "execution_count": 151, 2229 | "metadata": {}, 2230 | "output_type": "execute_result" 2231 | } 2232 | ], 2233 | "source": [ 2234 | "names" 2235 | ] 2236 | }, 2237 | { 2238 | "cell_type": "code", 2239 | "execution_count": null, 2240 | "metadata": { 2241 | "collapsed": true 2242 | }, 2243 | "outputs": [], 2244 | "source": [] 2245 | }, 2246 | { 2247 | "cell_type": "markdown", 2248 | "metadata": {}, 2249 | "source": [ 2250 | "- pop" 2251 | ] 2252 | }, 2253 | { 2254 | "cell_type": "code", 2255 | "execution_count": 155, 2256 | "metadata": {}, 2257 | "outputs": [ 2258 | { 2259 | "name": "stdout", 2260 | "output_type": "stream", 2261 | "text": [ 2262 | "-5.4\n", 2263 | "['Bazinga', 'Tensorflow', 'Keras', 'Happy', 'Torch', 'Caffe', 'Julyedu', 'PyTorch', 12]\n" 2264 | ] 2265 | } 2266 | ], 2267 | "source": [ 2268 | "last_element = names.pop()\n", 2269 | "print(last_element)\n", 2270 | "print(names)" 2271 | ] 2272 | }, 2273 | { 2274 | "cell_type": "code", 2275 | "execution_count": 153, 2276 | "metadata": {}, 2277 | "outputs": [ 2278 | { 2279 | "data": { 2280 | "text/plain": [ 2281 | "['Bazinga',\n", 2282 | " 'Tensorflow',\n", 2283 | " 'Keras',\n", 2284 | " 'Happy',\n", 2285 | " 'Torch',\n", 2286 | " 'Caffe',\n", 2287 | " 'Julyedu',\n", 2288 | " 'PyTorch',\n", 2289 | " 12,\n", 2290 | " -5.4,\n", 2291 | " 'Sad']" 2292 | ] 2293 | }, 2294 | "execution_count": 153, 2295 | "metadata": {}, 2296 | "output_type": "execute_result" 2297 | } 2298 | ], 2299 | "source": [ 2300 | "names" 2301 | ] 2302 | }, 2303 | { 2304 | "cell_type": "markdown", 2305 | "metadata": {}, 2306 | "source": [ 2307 | "- count\n" 2308 | ] 2309 | }, 2310 | { 2311 | "cell_type": "code", 2312 | "execution_count": 156, 2313 | "metadata": {}, 2314 | "outputs": [ 2315 | { 2316 | "data": { 2317 | "text/plain": [ 2318 | "['Bazinga',\n", 2319 | " 'Tensorflow',\n", 2320 | " 'Keras',\n", 2321 | " 'Happy',\n", 2322 | " 'Torch',\n", 2323 | " 'Caffe',\n", 2324 | " 'Julyedu',\n", 2325 | " 'PyTorch',\n", 2326 | " 12]" 2327 | ] 2328 | }, 2329 | "execution_count": 156, 2330 | "metadata": {}, 2331 | "output_type": "execute_result" 2332 | } 2333 | ], 2334 | "source": [ 2335 | "names" 2336 | ] 2337 | }, 2338 | { 2339 | "cell_type": "code", 2340 | "execution_count": 158, 2341 | "metadata": {}, 2342 | "outputs": [ 2343 | { 2344 | "data": { 2345 | "text/plain": [ 2346 | "2" 2347 | ] 2348 | }, 2349 | "execution_count": 158, 2350 | "metadata": {}, 2351 | "output_type": "execute_result" 2352 | } 2353 | ], 2354 | "source": [ 2355 | "names.count(12)\n", 2356 | "names.append(12)\n", 2357 | "names.count(12)" 2358 | ] 2359 | }, 2360 | { 2361 | "cell_type": "code", 2362 | "execution_count": 159, 2363 | "metadata": {}, 2364 | "outputs": [ 2365 | { 2366 | "data": { 2367 | "text/plain": [ 2368 | "['Bazinga',\n", 2369 | " 'Tensorflow',\n", 2370 | " 'Keras',\n", 2371 | " 'Happy',\n", 2372 | " 'Torch',\n", 2373 | " 'Caffe',\n", 2374 | " 'Julyedu',\n", 2375 | " 'PyTorch',\n", 2376 | " 12,\n", 2377 | " 12]" 2378 | ] 2379 | }, 2380 | "execution_count": 159, 2381 | "metadata": {}, 2382 | "output_type": "execute_result" 2383 | } 2384 | ], 2385 | "source": [ 2386 | "names" 2387 | ] 2388 | }, 2389 | { 2390 | "cell_type": "markdown", 2391 | "metadata": {}, 2392 | "source": [ 2393 | "- reverse" 2394 | ] 2395 | }, 2396 | { 2397 | "cell_type": "code", 2398 | "execution_count": 167, 2399 | "metadata": {}, 2400 | "outputs": [], 2401 | "source": [ 2402 | "names.reverse()" 2403 | ] 2404 | }, 2405 | { 2406 | "cell_type": "code", 2407 | "execution_count": 175, 2408 | "metadata": {}, 2409 | "outputs": [ 2410 | { 2411 | "data": { 2412 | "text/plain": [ 2413 | "['Bazinga', 'Tensorflow', 'Keras', 'Happy', 'Caffe', 'Julyedu', 'PyTorch']" 2414 | ] 2415 | }, 2416 | "execution_count": 175, 2417 | "metadata": {}, 2418 | "output_type": "execute_result" 2419 | } 2420 | ], 2421 | "source": [ 2422 | "names" 2423 | ] 2424 | }, 2425 | { 2426 | "cell_type": "markdown", 2427 | "metadata": {}, 2428 | "source": [ 2429 | "- del删除element" 2430 | ] 2431 | }, 2432 | { 2433 | "cell_type": "code", 2434 | "execution_count": 174, 2435 | "metadata": {}, 2436 | "outputs": [], 2437 | "source": [ 2438 | "del names[4]" 2439 | ] 2440 | }, 2441 | { 2442 | "cell_type": "code", 2443 | "execution_count": null, 2444 | "metadata": { 2445 | "collapsed": true 2446 | }, 2447 | "outputs": [], 2448 | "source": [] 2449 | }, 2450 | { 2451 | "cell_type": "markdown", 2452 | "metadata": {}, 2453 | "source": [ 2454 | "## control statement" 2455 | ] 2456 | }, 2457 | { 2458 | "cell_type": "code", 2459 | "execution_count": 190, 2460 | "metadata": {}, 2461 | "outputs": [ 2462 | { 2463 | "name": "stdout", 2464 | "output_type": "stream", 2465 | "text": [ 2466 | "equal to or larger than 20\n" 2467 | ] 2468 | } 2469 | ], 2470 | "source": [ 2471 | "if False:\n", 2472 | " print(\"less than 10\")\n", 2473 | "elif x < 20:\n", 2474 | " print(\"between 10 and 20\")\n", 2475 | "else: \n", 2476 | " print(\"equal to or larger than 20\")" 2477 | ] 2478 | }, 2479 | { 2480 | "cell_type": "markdown", 2481 | "metadata": {}, 2482 | "source": [ 2483 | "### 关于Boolean" 2484 | ] 2485 | }, 2486 | { 2487 | "cell_type": "code", 2488 | "execution_count": 181, 2489 | "metadata": {}, 2490 | "outputs": [ 2491 | { 2492 | "name": "stdout", 2493 | "output_type": "stream", 2494 | "text": [ 2495 | "23.0\n" 2496 | ] 2497 | }, 2498 | { 2499 | "data": { 2500 | "text/plain": [ 2501 | "True" 2502 | ] 2503 | }, 2504 | "execution_count": 181, 2505 | "metadata": {}, 2506 | "output_type": "execute_result" 2507 | } 2508 | ], 2509 | "source": [ 2510 | "print(x)\n", 2511 | "x > 1" 2512 | ] 2513 | }, 2514 | { 2515 | "cell_type": "markdown", 2516 | "metadata": {}, 2517 | "source": [ 2518 | "## loops\n", 2519 | "### for loop" 2520 | ] 2521 | }, 2522 | { 2523 | "cell_type": "markdown", 2524 | "metadata": {}, 2525 | "source": [ 2526 | "range function" 2527 | ] 2528 | }, 2529 | { 2530 | "cell_type": "code", 2531 | "execution_count": 191, 2532 | "metadata": {}, 2533 | "outputs": [ 2534 | { 2535 | "data": { 2536 | "text/plain": [ 2537 | "['Bazinga', 'Tensorflow', 'Keras', 'Happy', 'Caffe', 'Julyedu', 'PyTorch']" 2538 | ] 2539 | }, 2540 | "execution_count": 191, 2541 | "metadata": {}, 2542 | "output_type": "execute_result" 2543 | } 2544 | ], 2545 | "source": [ 2546 | "names" 2547 | ] 2548 | }, 2549 | { 2550 | "cell_type": "code", 2551 | "execution_count": 206, 2552 | "metadata": {}, 2553 | "outputs": [ 2554 | { 2555 | "name": "stdout", 2556 | "output_type": "stream", 2557 | "text": [ 2558 | "Bazinga\n", 2559 | "Tensorflow\n", 2560 | "Keras\n", 2561 | "Happy\n", 2562 | "Caffe\n", 2563 | "Julyedu\n", 2564 | "PyTorch\n" 2565 | ] 2566 | } 2567 | ], 2568 | "source": [ 2569 | "for name in names:\n", 2570 | " print(name)" 2571 | ] 2572 | }, 2573 | { 2574 | "cell_type": "code", 2575 | "execution_count": null, 2576 | "metadata": { 2577 | "collapsed": true 2578 | }, 2579 | "outputs": [], 2580 | "source": [] 2581 | }, 2582 | { 2583 | "cell_type": "markdown", 2584 | "metadata": {}, 2585 | "source": [ 2586 | "关于range的用法" 2587 | ] 2588 | }, 2589 | { 2590 | "cell_type": "code", 2591 | "execution_count": 197, 2592 | "metadata": {}, 2593 | "outputs": [ 2594 | { 2595 | "name": "stdout", 2596 | "output_type": "stream", 2597 | "text": [ 2598 | "0\n", 2599 | "1\n", 2600 | "2\n", 2601 | "3\n", 2602 | "4\n" 2603 | ] 2604 | } 2605 | ], 2606 | "source": [ 2607 | "for i in range(5):\n", 2608 | " print(i)" 2609 | ] 2610 | }, 2611 | { 2612 | "cell_type": "code", 2613 | "execution_count": 199, 2614 | "metadata": {}, 2615 | "outputs": [ 2616 | { 2617 | "data": { 2618 | "text/plain": [ 2619 | "[0, 1, 2, 3, 4]" 2620 | ] 2621 | }, 2622 | "execution_count": 199, 2623 | "metadata": {}, 2624 | "output_type": "execute_result" 2625 | } 2626 | ], 2627 | "source": [ 2628 | "list(range(5))" 2629 | ] 2630 | }, 2631 | { 2632 | "cell_type": "code", 2633 | "execution_count": 200, 2634 | "metadata": {}, 2635 | "outputs": [ 2636 | { 2637 | "data": { 2638 | "text/plain": [ 2639 | "[1, 2, 3, 4, 5, 6, 7]" 2640 | ] 2641 | }, 2642 | "execution_count": 200, 2643 | "metadata": {}, 2644 | "output_type": "execute_result" 2645 | } 2646 | ], 2647 | "source": [ 2648 | "list(range(1,8))" 2649 | ] 2650 | }, 2651 | { 2652 | "cell_type": "code", 2653 | "execution_count": 203, 2654 | "metadata": {}, 2655 | "outputs": [ 2656 | { 2657 | "data": { 2658 | "text/plain": [ 2659 | "[]" 2660 | ] 2661 | }, 2662 | "execution_count": 203, 2663 | "metadata": {}, 2664 | "output_type": "execute_result" 2665 | } 2666 | ], 2667 | "source": [ 2668 | "list(range(5, 20, -2))" 2669 | ] 2670 | }, 2671 | { 2672 | "cell_type": "code", 2673 | "execution_count": 205, 2674 | "metadata": {}, 2675 | "outputs": [ 2676 | { 2677 | "data": { 2678 | "text/plain": [ 2679 | "[20, 13, 6]" 2680 | ] 2681 | }, 2682 | "execution_count": 205, 2683 | "metadata": {}, 2684 | "output_type": "execute_result" 2685 | } 2686 | ], 2687 | "source": [ 2688 | "list(range(20, 5, -7))" 2689 | ] 2690 | }, 2691 | { 2692 | "cell_type": "markdown", 2693 | "metadata": {}, 2694 | "source": [ 2695 | "如果我们想在每个element前面加个数字编号呢？" 2696 | ] 2697 | }, 2698 | { 2699 | "cell_type": "code", 2700 | "execution_count": 211, 2701 | "metadata": {}, 2702 | "outputs": [ 2703 | { 2704 | "name": "stdout", 2705 | "output_type": "stream", 2706 | "text": [ 2707 | "1 Bazinga\n", 2708 | "2 Tensorflow\n", 2709 | "3 Keras\n", 2710 | "4 Happy\n", 2711 | "5 Caffe\n", 2712 | "6 Julyedu\n", 2713 | "7 PyTorch\n" 2714 | ] 2715 | } 2716 | ], 2717 | "source": [ 2718 | "for i in range(len(names)):\n", 2719 | " print(i+1, names[i])" 2720 | ] 2721 | }, 2722 | { 2723 | "cell_type": "code", 2724 | "execution_count": null, 2725 | "metadata": { 2726 | "collapsed": true 2727 | }, 2728 | "outputs": [], 2729 | "source": [] 2730 | }, 2731 | { 2732 | "cell_type": "markdown", 2733 | "metadata": {}, 2734 | "source": [ 2735 | "其实用enumerate更简单，直接帮你带上数字" 2736 | ] 2737 | }, 2738 | { 2739 | "cell_type": "code", 2740 | "execution_count": 216, 2741 | "metadata": {}, 2742 | "outputs": [ 2743 | { 2744 | "name": "stdout", 2745 | "output_type": "stream", 2746 | "text": [ 2747 | "0 Bazinga\n", 2748 | "1 Tensorflow\n", 2749 | "2 Keras\n", 2750 | "3 Happy\n", 2751 | "4 Caffe\n", 2752 | "5 Julyedu\n", 2753 | "6 PyTorch\n" 2754 | ] 2755 | } 2756 | ], 2757 | "source": [ 2758 | "for i, name in enumerate(names):\n", 2759 | " print(i, name)" 2760 | ] 2761 | }, 2762 | { 2763 | "cell_type": "markdown", 2764 | "metadata": {}, 2765 | "source": [ 2766 | "for与list在一起使用可以写很多简洁的语句, list comprehension" 2767 | ] 2768 | }, 2769 | { 2770 | "cell_type": "code", 2771 | "execution_count": 217, 2772 | "metadata": {}, 2773 | "outputs": [ 2774 | { 2775 | "data": { 2776 | "text/plain": [ 2777 | "['Bazinga', 'Tensorflow', 'Keras', 'Happy', 'Caffe', 'Julyedu', 'PyTorch']" 2778 | ] 2779 | }, 2780 | "execution_count": 217, 2781 | "metadata": {}, 2782 | "output_type": "execute_result" 2783 | } 2784 | ], 2785 | "source": [ 2786 | "names" 2787 | ] 2788 | }, 2789 | { 2790 | "cell_type": "code", 2791 | "execution_count": 224, 2792 | "metadata": {}, 2793 | "outputs": [ 2794 | { 2795 | "data": { 2796 | "text/plain": [ 2797 | "['stupid Bazinga',\n", 2798 | " 'stupid Tensorflow',\n", 2799 | " 'stupid Keras',\n", 2800 | " 'stupid Happy',\n", 2801 | " 'stupid Caffe',\n", 2802 | " 'stupid Julyedu',\n", 2803 | " 'stupid PyTorch']" 2804 | ] 2805 | }, 2806 | "execution_count": 224, 2807 | "metadata": {}, 2808 | "output_type": "execute_result" 2809 | } 2810 | ], 2811 | "source": [ 2812 | "[\"stupid \" + aaaa12 for aaaa12 in names]" 2813 | ] 2814 | }, 2815 | { 2816 | "cell_type": "markdown", 2817 | "metadata": {}, 2818 | "source": [ 2819 | "## while loop\n", 2820 | "\n", 2821 | "下面的这个小程序可以输出0-9" 2822 | ] 2823 | }, 2824 | { 2825 | "cell_type": "code", 2826 | "execution_count": 225, 2827 | "metadata": {}, 2828 | "outputs": [ 2829 | { 2830 | "name": "stdout", 2831 | "output_type": "stream", 2832 | "text": [ 2833 | "0\n", 2834 | "1\n", 2835 | "2\n", 2836 | "3\n", 2837 | "4\n" 2838 | ] 2839 | } 2840 | ], 2841 | "source": [ 2842 | "i = 0\n", 2843 | "while i < 5:\n", 2844 | " print(i)\n", 2845 | " i += 1\n", 2846 | " " 2847 | ] 2848 | }, 2849 | { 2850 | "cell_type": "markdown", 2851 | "metadata": {}, 2852 | "source": [ 2853 | "注意千万别忘了最后这一句```i += 1```否则就陷入死循环了。\n", 2854 | "\n", 2855 | "### break和continue的用法\n", 2856 | "- break会直接让你跳出当前的循环" 2857 | ] 2858 | }, 2859 | { 2860 | "cell_type": "code", 2861 | "execution_count": 226, 2862 | "metadata": {}, 2863 | "outputs": [ 2864 | { 2865 | "name": "stdout", 2866 | "output_type": "stream", 2867 | "text": [ 2868 | "0\n", 2869 | "1\n", 2870 | "2\n", 2871 | "3\n", 2872 | "4\n" 2873 | ] 2874 | } 2875 | ], 2876 | "source": [ 2877 | "i = 0\n", 2878 | "while True:\n", 2879 | " print(i)\n", 2880 | " i += 1\n", 2881 | " if i >= 5:\n", 2882 | " break" 2883 | ] 2884 | }, 2885 | { 2886 | "cell_type": "code", 2887 | "execution_count": 228, 2888 | "metadata": {}, 2889 | "outputs": [ 2890 | { 2891 | "name": "stdout", 2892 | "output_type": "stream", 2893 | "text": [ 2894 | "1\n", 2895 | "2\n", 2896 | "4\n", 2897 | "5\n", 2898 | "7\n", 2899 | "8\n", 2900 | "10\n", 2901 | "11\n", 2902 | "13\n", 2903 | "14\n", 2904 | "16\n", 2905 | "17\n", 2906 | "19\n" 2907 | ] 2908 | } 2909 | ], 2910 | "source": [ 2911 | "i = 0\n", 2912 | "while True:\n", 2913 | " if i % 3 == 0:\n", 2914 | " i += 1\n", 2915 | " continue\n", 2916 | " \n", 2917 | " print(i)\n", 2918 | " i += 1\n", 2919 | " if i >= 20:\n", 2920 | " break" 2921 | ] 2922 | }, 2923 | { 2924 | "cell_type": "markdown", 2925 | "metadata": { 2926 | "collapsed": true 2927 | }, 2928 | "source": [ 2929 | "## 小练习：输出一个fibonacci数列¶\n", 2930 | "\n" 2931 | ] 2932 | }, 2933 | { 2934 | "cell_type": "code", 2935 | "execution_count": 230, 2936 | "metadata": {}, 2937 | "outputs": [ 2938 | { 2939 | "name": "stdout", 2940 | "output_type": "stream", 2941 | "text": [ 2942 | "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n" 2943 | ] 2944 | } 2945 | ], 2946 | "source": [ 2947 | "# 0, 1, 1, 2, 3, 5, 8, 13\n", 2948 | "\n", 2949 | "fibs = []\n", 2950 | "a = 0\n", 2951 | "b = 1\n", 2952 | "while a < 500:\n", 2953 | " fibs.append(a)\n", 2954 | " # a = 2, b = 3\n", 2955 | " tmp = b\n", 2956 | " # tmp = 3, b = 3, a = 2\n", 2957 | " b = a + b\n", 2958 | " # tmp = 3, a = 2, b = 5\n", 2959 | " a = tmp\n", 2960 | " # tmp = 3, a = 3, b = 5\n", 2961 | "print(fibs)" 2962 | ] 2963 | }, 2964 | { 2965 | "cell_type": "code", 2966 | "execution_count": 251, 2967 | "metadata": {}, 2968 | "outputs": [ 2969 | { 2970 | "name": "stdout", 2971 | "output_type": "stream", 2972 | "text": [ 2973 | "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n" 2974 | ] 2975 | } 2976 | ], 2977 | "source": [ 2978 | "# 0, 1, 1, 2, 3, 5, 8, 13\n", 2979 | "\n", 2980 | "fibs = []\n", 2981 | "a = 0\n", 2982 | "b = 1\n", 2983 | "while a < 500:\n", 2984 | " fibs.append(a)\n", 2985 | " a, b = (b, a+b)\n", 2986 | "print(fibs)" 2987 | ] 2988 | }, 2989 | { 2990 | "cell_type": "markdown", 2991 | "metadata": {}, 2992 | "source": [ 2993 | "## set" 2994 | ] 2995 | }, 2996 | { 2997 | "cell_type": "markdown", 2998 | "metadata": {}, 2999 | "source": [ 3000 | "- list可以被转换成set，可以用于去重" 3001 | ] 3002 | }, 3003 | { 3004 | "cell_type": "code", 3005 | "execution_count": 257, 3006 | "metadata": {}, 3007 | "outputs": [], 3008 | "source": [ 3009 | "names.append(\"Tensorflow\")" 3010 | ] 3011 | }, 3012 | { 3013 | "cell_type": "code", 3014 | "execution_count": 258, 3015 | "metadata": {}, 3016 | "outputs": [ 3017 | { 3018 | "data": { 3019 | "text/plain": [ 3020 | "['Bazinga',\n", 3021 | " 'Tensorflow',\n", 3022 | " 'Keras',\n", 3023 | " 'Happy',\n", 3024 | " 'Caffe',\n", 3025 | " 'Julyedu',\n", 3026 | " 'PyTorch',\n", 3027 | " 'Tensorflow',\n", 3028 | " 'Tensorflow',\n", 3029 | " 'Tensorflow',\n", 3030 | " 'Tensorflow',\n", 3031 | " 'Tensorflow']" 3032 | ] 3033 | }, 3034 | "execution_count": 258, 3035 | "metadata": {}, 3036 | "output_type": "execute_result" 3037 | } 3038 | ], 3039 | "source": [ 3040 | "names" 3041 | ] 3042 | }, 3043 | { 3044 | "cell_type": "code", 3045 | "execution_count": 278, 3046 | "metadata": { 3047 | "scrolled": true 3048 | }, 3049 | "outputs": [ 3050 | { 3051 | "data": { 3052 | "text/plain": [ 3053 | "['PyTorch', 'Keras', 'Julyedu', 'Happy', 'Caffe', 'Bazinga', 'Tensorflow']" 3054 | ] 3055 | }, 3056 | "execution_count": 278, 3057 | "metadata": {}, 3058 | "output_type": "execute_result" 3059 | } 3060 | ], 3061 | "source": [ 3062 | "list(set(names))" 3063 | ] 3064 | }, 3065 | { 3066 | "cell_type": "code", 3067 | "execution_count": 262, 3068 | "metadata": { 3069 | "collapsed": true 3070 | }, 3071 | "outputs": [], 3072 | "source": [ 3073 | "empty_set = set()" 3074 | ] 3075 | }, 3076 | { 3077 | "cell_type": "code", 3078 | "execution_count": 275, 3079 | "metadata": {}, 3080 | "outputs": [], 3081 | "source": [ 3082 | "empty_set.add(\"aaaaa\")" 3083 | ] 3084 | }, 3085 | { 3086 | "cell_type": "code", 3087 | "execution_count": 276, 3088 | "metadata": {}, 3089 | "outputs": [ 3090 | { 3091 | "data": { 3092 | "text/plain": [ 3093 | "{'aaaaa'}" 3094 | ] 3095 | }, 3096 | "execution_count": 276, 3097 | "metadata": {}, 3098 | "output_type": "execute_result" 3099 | } 3100 | ], 3101 | "source": [ 3102 | "empty_set" 3103 | ] 3104 | }, 3105 | { 3106 | "cell_type": "code", 3107 | "execution_count": 282, 3108 | "metadata": {}, 3109 | "outputs": [ 3110 | { 3111 | "data": { 3112 | "text/plain": [ 3113 | "{1, 2, 3, 4, 5}" 3114 | ] 3115 | }, 3116 | "execution_count": 282, 3117 | "metadata": {}, 3118 | "output_type": "execute_result" 3119 | } 3120 | ], 3121 | "source": [ 3122 | "numbers = {1,2,2,2,2,2,3,3,2,2,3,3,3,4,5}\n", 3123 | "numbers\n", 3124 | "#type(numbers)" 3125 | ] 3126 | }, 3127 | { 3128 | "cell_type": "markdown", 3129 | "metadata": {}, 3130 | "source": [ 3131 | "- string也可以被转换成set" 3132 | ] 3133 | }, 3134 | { 3135 | "cell_type": "code", 3136 | "execution_count": 283, 3137 | "metadata": {}, 3138 | "outputs": [ 3139 | { 3140 | "data": { 3141 | "text/plain": [ 3142 | "{'a', 'b', 'n'}" 3143 | ] 3144 | }, 3145 | "execution_count": 283, 3146 | "metadata": {}, 3147 | "output_type": "execute_result" 3148 | } 3149 | ], 3150 | "source": [ 3151 | "set(\"banana\")" 3152 | ] 3153 | }, 3154 | { 3155 | "cell_type": "markdown", 3156 | "metadata": {}, 3157 | "source": [ 3158 | "- 比较fancy的一个例子, set comprehension\n" 3159 | ] 3160 | }, 3161 | { 3162 | "cell_type": "code", 3163 | "execution_count": 286, 3164 | "metadata": {}, 3165 | "outputs": [ 3166 | { 3167 | "data": { 3168 | "text/plain": [ 3169 | "['b']" 3170 | ] 3171 | }, 3172 | "execution_count": 286, 3173 | "metadata": {}, 3174 | "output_type": "execute_result" 3175 | } 3176 | ], 3177 | "source": [ 3178 | "[x for x in \"banana\" if x not in \"an\"]" 3179 | ] 3180 | }, 3181 | { 3182 | "cell_type": "markdown", 3183 | "metadata": {}, 3184 | "source": [ 3185 | "## tuple\n", 3186 | "tuples有点像list，不过一个很大的区别是tuples是immutable的，也就是说它的element一旦创建之后就无法更改了。" 3187 | ] 3188 | }, 3189 | { 3190 | "cell_type": "code", 3191 | "execution_count": 237, 3192 | "metadata": {}, 3193 | "outputs": [ 3194 | { 3195 | "data": { 3196 | "text/plain": [ 3197 | "(1, 2, 3, 'Facebook', 'Google')" 3198 | ] 3199 | }, 3200 | "execution_count": 237, 3201 | "metadata": {}, 3202 | "output_type": "execute_result" 3203 | } 3204 | ], 3205 | "source": [ 3206 | "t = 1, 2,3, \"Facebook\", \"Google\"\n", 3207 | "t" 3208 | ] 3209 | }, 3210 | { 3211 | "cell_type": "code", 3212 | "execution_count": 238, 3213 | "metadata": {}, 3214 | "outputs": [ 3215 | { 3216 | "data": { 3217 | "text/plain": [ 3218 | "tuple" 3219 | ] 3220 | }, 3221 | "execution_count": 238, 3222 | "metadata": {}, 3223 | "output_type": "execute_result" 3224 | } 3225 | ], 3226 | "source": [ 3227 | "type(t)" 3228 | ] 3229 | }, 3230 | { 3231 | "cell_type": "code", 3232 | "execution_count": 240, 3233 | "metadata": {}, 3234 | "outputs": [ 3235 | { 3236 | "data": { 3237 | "text/plain": [ 3238 | "'Facebook'" 3239 | ] 3240 | }, 3241 | "execution_count": 240, 3242 | "metadata": {}, 3243 | "output_type": "execute_result" 3244 | } 3245 | ], 3246 | "source": [ 3247 | "t[3]" 3248 | ] 3249 | }, 3250 | { 3251 | "cell_type": "code", 3252 | "execution_count": 241, 3253 | "metadata": {}, 3254 | "outputs": [ 3255 | { 3256 | "ename": "TypeError", 3257 | "evalue": "'tuple' object does not support item assignment", 3258 | "output_type": "error", 3259 | "traceback": [ 3260 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 3261 | "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", 3262 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"333333\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 3263 | "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" 3264 | ] 3265 | } 3266 | ], 3267 | "source": [ 3268 | "t[2] = \"333333\"" 3269 | ] 3270 | }, 3271 | { 3272 | "cell_type": "code", 3273 | "execution_count": 249, 3274 | "metadata": {}, 3275 | "outputs": [], 3276 | "source": [ 3277 | "a, b, c, d, e = t" 3278 | ] 3279 | }, 3280 | { 3281 | "cell_type": "code", 3282 | "execution_count": 250, 3283 | "metadata": {}, 3284 | "outputs": [ 3285 | { 3286 | "data": { 3287 | "text/plain": [ 3288 | "'Google'" 3289 | ] 3290 | }, 3291 | "execution_count": 250, 3292 | "metadata": {}, 3293 | "output_type": "execute_result" 3294 | } 3295 | ], 3296 | "source": [ 3297 | "e" 3298 | ] 3299 | }, 3300 | { 3301 | "cell_type": "markdown", 3302 | "metadata": {}, 3303 | "source": [ 3304 | "## dictionary\n", 3305 | "\n", 3306 | "dictionary就是字典，也就是把一个元素map到另一个元素上" 3307 | ] 3308 | }, 3309 | { 3310 | "cell_type": "code", 3311 | "execution_count": 292, 3312 | "metadata": {}, 3313 | "outputs": [ 3314 | { 3315 | "data": { 3316 | "text/plain": [ 3317 | "{'apple': 0, 'banana': 12, 'orange': 22, 'pineapple': 5}" 3318 | ] 3319 | }, 3320 | "execution_count": 292, 3321 | "metadata": {}, 3322 | "output_type": "execute_result" 3323 | } 3324 | ], 3325 | "source": [ 3326 | "fruit = {\"apple\": 0, \"orange\":22, \"pineapple\": 5, \"banana\": 12}\n", 3327 | "fruit\n", 3328 | "# key value pairs" 3329 | ] 3330 | }, 3331 | { 3332 | "cell_type": "code", 3333 | "execution_count": 293, 3334 | "metadata": {}, 3335 | "outputs": [ 3336 | { 3337 | "data": { 3338 | "text/plain": [ 3339 | "12" 3340 | ] 3341 | }, 3342 | "execution_count": 293, 3343 | "metadata": {}, 3344 | "output_type": "execute_result" 3345 | } 3346 | ], 3347 | "source": [ 3348 | "fruit[\"banana\"]" 3349 | ] 3350 | }, 3351 | { 3352 | "cell_type": "code", 3353 | "execution_count": 294, 3354 | "metadata": {}, 3355 | "outputs": [ 3356 | { 3357 | "data": { 3358 | "text/plain": [ 3359 | "dict" 3360 | ] 3361 | }, 3362 | "execution_count": 294, 3363 | "metadata": {}, 3364 | "output_type": "execute_result" 3365 | } 3366 | ], 3367 | "source": [ 3368 | "type(fruit)" 3369 | ] 3370 | }, 3371 | { 3372 | "cell_type": "markdown", 3373 | "metadata": {}, 3374 | "source": [ 3375 | "下面的方法可以帮助我们查看一个dictionary的keys和values" 3376 | ] 3377 | }, 3378 | { 3379 | "cell_type": "code", 3380 | "execution_count": 298, 3381 | "metadata": {}, 3382 | "outputs": [ 3383 | { 3384 | "name": "stdout", 3385 | "output_type": "stream", 3386 | "text": [ 3387 | "apple\n", 3388 | "orange\n", 3389 | "pineapple\n", 3390 | "banana\n" 3391 | ] 3392 | } 3393 | ], 3394 | "source": [ 3395 | "for i in fruit.keys():\n", 3396 | " print(i)" 3397 | ] 3398 | }, 3399 | { 3400 | "cell_type": "markdown", 3401 | "metadata": {}, 3402 | "source": [ 3403 | "- 一个list of tuples也可以转换成dict。" 3404 | ] 3405 | }, 3406 | { 3407 | "cell_type": "code", 3408 | "execution_count": 299, 3409 | "metadata": { 3410 | "collapsed": true 3411 | }, 3412 | "outputs": [], 3413 | "source": [ 3414 | "schools = [(\"Harvard\", 1), (\"Princeton\", 2), (\"Yale\",3), (\"Stanford\",4), (\"MIT\",5), (\"Chicago\",6)]" 3415 | ] 3416 | }, 3417 | { 3418 | "cell_type": "code", 3419 | "execution_count": 300, 3420 | "metadata": {}, 3421 | "outputs": [ 3422 | { 3423 | "data": { 3424 | "text/plain": [ 3425 | "{'Chicago': 6,\n", 3426 | " 'Harvard': 1,\n", 3427 | " 'MIT': 5,\n", 3428 | " 'Princeton': 2,\n", 3429 | " 'Stanford': 4,\n", 3430 | " 'Yale': 3}" 3431 | ] 3432 | }, 3433 | "execution_count": 300, 3434 | "metadata": {}, 3435 | "output_type": "execute_result" 3436 | } 3437 | ], 3438 | "source": [ 3439 | "dict(schools)" 3440 | ] 3441 | }, 3442 | { 3443 | "cell_type": "markdown", 3444 | "metadata": {}, 3445 | "source": [ 3446 | "有时候我们想把一个list编号做成一个dictionary，比如下面这种情况:" 3447 | ] 3448 | }, 3449 | { 3450 | "cell_type": "code", 3451 | "execution_count": 303, 3452 | "metadata": { 3453 | "collapsed": true 3454 | }, 3455 | "outputs": [], 3456 | "source": [ 3457 | "vocab = [\"apple\", \"bit\", \"chrome\", \"facebook\", \"google\", \"hack\", \"iteration\", \"jupyter\", \"kaggle\"]" 3458 | ] 3459 | }, 3460 | { 3461 | "cell_type": "code", 3462 | "execution_count": 304, 3463 | "metadata": {}, 3464 | "outputs": [ 3465 | { 3466 | "data": { 3467 | "text/plain": [ 3468 | "['apple',\n", 3469 | " 'bit',\n", 3470 | " 'chrome',\n", 3471 | " 'facebook',\n", 3472 | " 'google',\n", 3473 | " 'hack',\n", 3474 | " 'iteration',\n", 3475 | " 'jupyter',\n", 3476 | " 'kaggle']" 3477 | ] 3478 | }, 3479 | "execution_count": 304, 3480 | "metadata": {}, 3481 | "output_type": "execute_result" 3482 | } 3483 | ], 3484 | "source": [ 3485 | "vocab" 3486 | ] 3487 | }, 3488 | { 3489 | "cell_type": "code", 3490 | "execution_count": 311, 3491 | "metadata": {}, 3492 | "outputs": [ 3493 | { 3494 | "data": { 3495 | "text/plain": [ 3496 | "{'apple': 1,\n", 3497 | " 'bit': 2,\n", 3498 | " 'chrome': 3,\n", 3499 | " 'facebook': 4,\n", 3500 | " 'google': 5,\n", 3501 | " 'hack': 6,\n", 3502 | " 'iteration': 7,\n", 3503 | " 'jupyter': 8,\n", 3504 | " 'kaggle': 9}" 3505 | ] 3506 | }, 3507 | "execution_count": 311, 3508 | "metadata": {}, 3509 | "output_type": "execute_result" 3510 | } 3511 | ], 3512 | "source": [ 3513 | "{k:v+1 for v, k in enumerate(vocab)}" 3514 | ] 3515 | }, 3516 | { 3517 | "cell_type": "code", 3518 | "execution_count": null, 3519 | "metadata": { 3520 | "collapsed": true 3521 | }, 3522 | "outputs": [], 3523 | "source": [ 3524 | "JSON\n", 3525 | "javascript object notation\n", 3526 | "import json\n" 3527 | ] 3528 | }, 3529 | { 3530 | "cell_type": "markdown", 3531 | "metadata": {}, 3532 | "source": [ 3533 | "## function\n", 3534 | "\n", 3535 | "- def关键词\n", 3536 | "- 用括号包含list of parameters\n", 3537 | "- statements都要indent\n" 3538 | ] 3539 | }, 3540 | { 3541 | "cell_type": "markdown", 3542 | "metadata": {}, 3543 | "source": [ 3544 | "\n", 3545 | "### 不定长度的arguments\n", 3546 | "\n" 3547 | ] 3548 | }, 3549 | { 3550 | "cell_type": "markdown", 3551 | "metadata": {}, 3552 | "source": [ 3553 | "### default argument\n", 3554 | "concat例子\n", 3555 | "\n" 3556 | ] 3557 | }, 3558 | { 3559 | "cell_type": "markdown", 3560 | "metadata": {}, 3561 | "source": [ 3562 | "\n", 3563 | "\n", 3564 | "### 把一个tuple/list当做arguments\n", 3565 | "\n" 3566 | ] 3567 | } 3568 | ], 3569 | "metadata": { 3570 | "kernelspec": { 3571 | "display_name": "Python 3", 3572 | "language": "python", 3573 | "name": "python3" 3574 | }, 3575 | "language_info": { 3576 | "codemirror_mode": { 3577 | "name": "ipython", 3578 | "version": 3 3579 | }, 3580 | "file_extension": ".py", 3581 | "mimetype": "text/x-python", 3582 | "name": "python", 3583 | "nbconvert_exporter": "python", 3584 | "pygments_lexer": "ipython3", 3585 | "version": "3.6.1" 3586 | } 3587 | }, 3588 | "nbformat": 4, 3589 | "nbformat_minor": 2 3590 | } 3591 | --------------------------------------------------------------------------------