python django开发教程 & 机器学习

---

title: python语法练习

参考阮一峰等多个文件用来练习python基本语法

[TOC]

import文件

1. 参考文献

   • Python如何import文件夹下的文件： http://www.qttc.net/201209214.html
   • http://codingpy.com/article/python-import-101/

2. 常规导入

   import sys
   import os, sys, time 
   import sys as system #重命名
   import urllib.error #某些子模块必须要使用点标记法才能导入。
   
   如果两个python文件位于同一文件夹下，可以直接通过import导入另一个.py文件，并且使用其中的函数
   

3. 使用from语句导入

   很多时候你只想要导入一个模块或库中的某个部分：

   from functools import lru_cache 
   from os import path, walk, unlink  #从一个包中导入多项
   

4. 相对导入

5. 可选导入

6. 本地导入

if name == "main": 作用

1. 参考文献

   • https://taizilongxu.gitbooks.io/stackoverflow-about-python/content/18/README.html
   • ​

2. 上代码

   # Threading example
   import time, thread
   
   def myfunction(string, sleeptime, lock, *args):
       while 1:
           lock.acquire()
           time.sleep(sleeptime)
           lock.release()
           time.sleep(sleeptime)
   if __name__ == "__main__":
       lock = thread.allocate_lock()
       thread.start_new_thread(myfunction, ("Thread #: 1", 2, lock))
       thread.start_new_thread(myfunction, ("Thread #: 2", 2, lock))
   

3. if __name__ == '__main__' 我们简单的理解就是： 如果模块是被直接运行的，则代码块被运行，如果模块是被导入的，则代码块不被运行。

4. over

python格式化输出

1. 打印

   print ("和 is name is %s"%("gaolong")) #整数
   print ("He is %d years old"%(25)) #字符串
   print ("His height is %f m"%(1.83))
   

2. ​

3. over

python多线程

1. 参考文献

   • Python2或者之前的多线程的模式：http://blog.csdn.net/jeanphorn/article/details/45195339
   • 本人使用python3.6.1 因此参考这篇文档：http://www.cnblogs.com/fnng/p/3670789.html
   • ​

2. 多线程的使用

   
   def move(func):
       for i in range(5):
           print ("I was at the %s! %s" %(func, ctime()))
   
   def move(func):
       for i in range(2):
           print ("I was at the %s ! %s" %(func, ctime()))
           sleep(4)
   threads = []
   
   t1 = threading.Thread(target=music, args=(u'aiqingmaima'))
   threads.append(t1)
   t2 = threading.Thread(target=move,args=(u'阿凡达',))
   threads.append(t2)
   
   if __name__ == '__main__':
       for t in threads:
           t.setDaemon(True)
           t.start()
   
       print ("all over %s" %ctime())
   

3. over

python魔术方法

1. 参考http://pycoders-weekly-chinese.readthedocs.io/en/latest/issue6/a-guide-to-pythons-magic-methods.html

python global

1. 使用方法

   a = 5  
     
   def test():  
       global a  
    #此处声明，告诉执行引擎：我要用全局变量a，不要整成局部的了！  
       a = 1  
       print 'In test func: a = %d' % a  
     
   test()  
   print 'Global a = %d' % a  
   首先：python使用的变量，在默认情况下一定是用局部变量。
   其次：python如果想使用作用域之外的全局变量，则需要加global前缀。
   

2. over

requests框架学习

这个框架的作用类似于iOS的post请求、get请求，即url请求，获取数据。数据类型可能是json，可能是html网页。

1. 参考文献

   requests基本用法： https://zhuanlan.zhihu.com/p/26681429

2. 基本用法

   使用pycharm+virtualenv， 导入requests框架。requests抓取网页。

   #made by schiller
   
   import requests
   
   payload = dict(catCircleCategoryId=2, sortType=1)
   r = requests.post("http://app.yirimao.com/cat-circle/list", data=payload)
   # print(r.text)
   
   def getHtmlText(url):
       try:
           r = requests.get(url, timeout=30)
           r.raise_for_status()
           r.encoding = r.apparent_encoding
           return r.text
       except:
           return "Something wrong!"
   

if name == 'main':
print(getHtmlText("http://www.aidu.com"))

3. **kwargs参数

4. 两个常用控制访问的参数

- 假设我们需要在GET请求里自定义一个header头文件：

  ```python
  import requests

  hd = {'User-agent':'123'}
  r = requests.get('http://www.baidu.com', headers=hd)
  print(r.request.headers)
  '''
  OUT:
  {'User-agent': '123', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive
  '}
  '''

• 假设我们要自定义一个代理池

  pxs = { 'http': 'http://user:[email protected]:1234',
          'https': 'https://10.10.10.1:4321' }
  r = requests.get('http://www.baidu.com', proxies=pxs)
  

• over

5. 详解response对象

   import requests
   r = requests.get("http://www.baidu.com")
   
   '''
   Response(self)
   
   The :class:Response  object, which contains a server's response to an HTTP request.
   
   '''
   #HTTP请求的返回状态，比如，200表示成功，404表示失败
   print (r.status_code)
   #HTTP请求中的headers
   print (r.headers)
   #从header中猜测的响应的内容编码方式 
   print (r.encoding)
   #从内容中分析的编码方式（慢）
   print (r.apparent_encoding)
   #响应内容的二进制形式
   print (r.content)
   
   '''
   status_code:200 
   
   headers:
   {'Server': 'bfe/1.0.8.18', 'Date': 'Tue, 02 May 2017 12:01:47 GMT', 'Content-Type': 'text/html', 'La
   st-Modified': 'Mon, 23 Jan 2017 13:28:27 GMT', 'Transfer-Encoding': 'chunked', 'Connection': 'Keep-A
   live', 'Cache-Control': 'private, no-cache, no-store, proxy-revalidate, no-transform', 'Pragma': 'no
   -cache', 'Set-Cookie': 'BDORZ=27315; max-age=86400; domain=.baidu.com; path=/', 'Content-Encoding':
   'gzip'}
   
   encoding: ISO-8859-1
   
   apparent_encoding:utf-8
   '''
   

6. over

beautifulsoup4 html 解析器

beautifulsoup4是一个强大的html解析器

1. 参考文献

   https://zhuanlan.zhihu.com/p/26691931

2. 基本用法

   from bs4 import BeautifulSoup
   import myrequest
   
   html = myrequest.getHtmlText('http://www.baidu.com')
   
   soup = BeautifulSoup(html, 'html.parser')
   
   print(soup.prettify())
   
   def getSoupValue():
       title = soup.title
       name = soup.title.name
       titleString = soup.title.string
       titleParentString = soup.title.parent.name
       ptag = soup.p
       aAll = soup.find_all('a')
       print("title = %s, name = %s, titlestring = %s,titlePrentstring = %s, ptag = %s, a = %s"
             % (title, name, titleString, titleParentString, ptag, aAll))
   

if name == 'main':
getSoupValue()

3. bs4库 是解析、遍历、维护、“标签树“的功能库。

4. over

bs4解析器 lxml

网络爬虫的最终目的就是过滤选取网络信息，最重要的部分可以说是解析器。解析器的优劣决定了爬虫的速度和效率。bs4库除了支持我们上文用过的‘html.parser’解析器外，还支持很多第三方的解析器，下面我们来对他们进行对比分析。

1. 参考文献

   https://zhuanlan.zhihu.com/p/26691931

2. 基本用法

   import bs4
   
   html_doc = """
   
   
   The Dormouse's story
   
   Once upon a time there were three little sisters; and their names were
   Elsie,
   Lacie and
   Tillie;
   and they lived at the bottom of a well.
   
   ...
   """
   
   #soup = bs4.BeautifulSoup(open(''), 'lxml')
   soup = bs4.BeautifulSoup(html_doc, 'lxml')
   print(soup.prettify())
   
   def dealWithTags():
       head = soup.head
       title = soup.title
       body = soup.body.b
       tag = soup.find_all('a')
       nee = tag[1]
   

3. over

爬虫实践：获取百度贴吧内容

over

python经典编码问题

参考文献：https://stackoverflow.com/questions/9942594/unicodeencodeerror-ascii-codec-cant-encode-character-u-xa0-in-position-20

1. http://www.jb51.net/article/17560.htm
2. http://blog.csdn.net/zuyi532/article/details/8851316

python scrapy爬虫框架入门

参考文献：

1. 使用virtaulenv和pycharm导入Scrapy
2. 使用案例，新建jianshuSpider.py文件
3. 配置setting.py
4. 新建main.py用来执行python脚本
5. 也可以通过virtaulenv的命令，cd到项目中，执行scrapy startproject jianshu 脚本来执行该项目
6. over

爬取文档数据

参考文献：http://www.jianshu.com/p/61911e00abd0

over

使用scrapy框架爬取天气资讯

参考文献：https://zhuanlan.zhihu.com/p/26885412

步骤：

1. 安装scrapy

   直接通过pycharm 导入该框架即可
   

2. 生成 uuu scrapy项目

   $ cd .virtualenvs/py3env_test #进入该虚拟目录
   $ source bin/activate # 激活env
   $ cd 
   $ cd python_test 
   (py3env_test) ➜  python_test git:(master) ✗ scrapy startproject spiderDemo # 使用scrapy快速建立新项目，使用的是py3env_test虚拟目录的python框架
   $ cd spiderDemo 
   $ 再进入pycharm就能看到自己新建的scrapy项目了。
   

3. 编写items.py

   
   import scrapy
   

class WeatherItem(scrapy.Item):
# define the fields for your item here like:
# name = scrapy.Field()
date = scrapy.Field()
week = scrapy.Field()
img = scrapy.Field()
temperature = scrapy.Field()
weather = scrapy.Field()
wind = scrapy.Field()

4. 编写spider

```python
在spiders目录下新建：SZtianqi.py文件
# -*- coding: utf-8 -*-
import scrapy
from weather.items import WeatherItem


class SztianqiSpider(scrapy.Spider):
    name = "SZtianqi"
    # 我们修改一下host，使得Scrapy可以爬取除了苏州之外的天气
    allowed_domains = ["tianqi.com"]

    # 建立需要爬取信息的url列表
    start_urls = []

    # 需要爬的城市名称
    citys = ['nanjing', 'suzhou', 'shanghai']

    # 用一个很简答的循环来生成需要爬的链接：
    for city in citys:
        start_urls.append('http://' + city + '.tianqi.com')

    def parse(self, response):
        '''
        筛选信息的函数：
        date = 今日日期
        week = 星期几
        img = 表示天气的图标
        temperature = 当天的温度
        weather = 当天的天气
        wind = 当天的风向
        '''

        # 先建立一个列表，用来保存每天的信息
        items = []

        # 找到包裹着每天天气信息的div
        sixday = response.xpath('//div[@class="tqshow1"]')

        # 循环筛选出每天的信息：
        for day in sixday:
            # 先申请一个weatheritem 的类型来保存结果
            item = WeatherItem()

            # 观察网页，知道h3标签下的不单单是一行str，我们用trick的方式将它连接起来
            date = ''
            for datetitle in day.xpath('./h3//text()').extract():
                date += datetitle
            
            item['date'] = date

            item['week'] = day.xpath('./p//text()').extract()[0]
            item['img'] = day.xpath(
                './ul/li[@class="tqpng"]/img/@src').extract()[0]
            tq = day.xpath('./ul/li[2]//text()').extract()
            # 我们用第二种取巧的方式，将tq里找到的str连接
            item['temperature'] = ''.join(tq)
            item['weather'] = day.xpath('./ul/li[3]/text()').extract()[0]
            item['wind'] = day.xpath('./ul/li[4]/text()').extract()[0]
            items.append(item)
        return items

5. 编写pipelines

   pipelines.py是用来处理收尾爬虫抓到的数据的，一般情况下，我们会将数据存到本地：
   1、文本形式：最基本
   2、json格式：方便调用
   3、数据库：数据量大
   
   此处使用json格式
   class W2json(object):
       def process_item(self, item, spider):
           '''
           讲爬取的信息保存到json
           方便其他程序员调用
           '''
           base_dir = os.getcwd()
           filename = base_dir + '/data/weather.json'
   
           # 打开json文件，向里面以dumps的方式吸入数据
           # 注意需要有一个参数ensure_ascii=False ，不然数据会直接为utf编码的方式存入比如:“/xe15”
           with codecs.open(filename, 'a') as f:
               line = json.dumps(dict(item), ensure_ascii=False) + '\n'
               f.write(line)
   
           return item
   

6. 编写settings.py

   我们需要在Settings.py将我们写好的PIPELINE添加进去，
   scrapy才能够跑起来
   这里只需要增加一个dict格式的ITEM_PIPELINES，
   数字value可以自定义，数字越小的优先处理

   BOT_NAME = 'weather'
   
   SPIDER_MODULES = ['weather.spiders']
   NEWSPIDER_MODULE = 'weather.spiders'
   ITEM_PIPELINES = {'weather.pipelines.W2json': 400}
   
   ROBOTSTXT_OBEY = True
   

7. 让项目跑起来

   $ cd weather 项目目录
   $ 在weather目录下新建一个 data/weather.json文件用来收录抓取的数据
   $ scrapy crawl SZtianqi    
   

8. over

over

需要解决的问题

1. virtaulenv 使用pip列出virtaulenv安装过的第三方库
2. python爬虫框架scrapy
3. python爬取有关于猫的一切资料
4. ​

python序列化

python序列化，将字典转成json或者将json转成字典

参考:http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/00143192607210600a668b5112e4a979dd20e4661cc9c97000

1. 案

   import hashlib
   import json
   
   md5 = hashlib.md5()
   md5.update('how to use md5 in python'.encode('utf-8'))
   print(md5.hexdigest())
   
   d = dict(name='Bob', age=20,score=90)
   print(json.dumps(d)) #此处是dumps而不是dump
   
   json_str = '{"name": "Bob", "age": 20, "score": 90, "result":true}'
   print(json.loads(json_str))
   
   adict = json.loads(json_str)
   print(adict)
   
   #定义类
   class Student(object):
       def __init__(self, name, age, score):
           self.name = name
           self.age = age
           self.score = score
   
   def student2dict(std):
       return {
           'name': std.name,
           'age': std.age,
           'score': std.score
       }
   
   a = Student('Bob', 20, 88) 
   print(json.dumps(a, default=student2dict)) #将对象转成json
   
   print(json.dumps(a, default=lambda  obj: obj.__dict__)) #将任意对象转成json，定义一个匿名函数
   
   

2. over

over

高阶函数

map、reduce、filter、sorted

1. 参考文献

   http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317852443934a86aa5bb5ea47fbbd5f35282b331335000

2. 案例

   over
   

3. over

python Django入门

采用virtualenv引入django。

参考文档：https://www.lijinlong.cc/django/djxs/1920.html

经典入门参考：https://www.jianshu.com/p/b0be1bc89f74?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

自学入门：https://code.ziqiangxuetang.com/django/django-intro.html

1. 打开pycharm，打开工程tieba，本工程采用的env是virtualenv。来自 ~/.virtualenvs/ py3env_test

2. 可以用Pycharm/Preferences/ 去下载最新的django。我下载的是2.1版本。下载好的django会存放到这个virtualenv的site-packages目录下。

3. 然后进入到py3env_test , 运行source bin/activate，激活这个虚拟环境

4. ok，激活后，执行pip3 install django。由于我用pycharm导入的这个框架，所以此处提醒我已经安装好了。

5. 使用命令创建项目：django-admin.py startproject myfirstDjangoProject 。这个项目最后会存放到 ~/ 目录下。

6. 可以指定创建目录到python_test

7. cd 到 工程 myfirstDjangoProject，然后执行 python manage.py runserver

8. 打开浏览器：

   Django version 2.0.1, using settings 'myfirstDjangoProject.settings'
   Starting development server at http://127.0.0.1:8000/
   

9. 创建mydjango_app ，并且，创建views.py， 创建第一个django应用。

10. 总结一句：第一步，打开虚拟环境；第二步，创建项目（如果已经有项目则cd到项目） ；第三步，到工程里运行项目

11. 去掉提示 migration提醒

    
    #Django 1.7.x 以下版本
    python manage.py syncdb
     
    # Django 1.7.x 以及上要用
    python manage.py migrate
    

    ​

12. over

Django视图与网址以及进阶

参考文档：https://code.ziqiangxuetang.com/django/django-views-urls.html

参考文档2：https://code.ziqiangxuetang.com/django/django-views-urls2.html

1. 新建一个APP，名称为learn python manage.py startapp learn ``# learn 是一个app的名称

2. 把我们新定义的app加到settings.py中的****INSTALL_APPS中

   INSTALLED_APPS = (
       'django.contrib.admin',
       'django.contrib.auth',
       'django.contrib.contenttypes',
       'django.contrib.sessions',
       'django.contrib.messages',
       'django.contrib.staticfiles',
    
       'learn',
   )
   

3. 我们在learn这个目录中,把views.py打开,修改其中的源代码,改成下面的

   # coding:utf-8
   from django.http import HttpResponse
    
    
   def index(request):
       return HttpResponse(u"欢迎光临 自强学堂!")
   

4. 定义视图函数相关的url

   from django.conf.urls import url
   from django.contrib import admin
   from learn import views as learn_views  # new
    
    
   urlpatterns = [
       url(r'^$', learn_views.index),  # new
       url(r'^admin/', admin.site.urls),
   ]
   

5. 修改视图views.py文件为

   from django.shortcuts import render
   from django.http import HttpResponse
    
   def add(request):
       a = request.GET['a']
       b = request.GET['b']
       c = int(a)+int(b)
       return HttpResponse(str(c))
   

6. 修改为

   from django.conf.urls import url
   from django.contrib import admin
   from calc import views as calc_views
    
    
   urlpatterns = [
       url(r'^add/$', calc_views.add, name='add'),  # 注意修改了这一行
       url(r'^admin/', admin.site.urls),
   ]
   

7. 打开网址：http://127.0.0.1:8000/add/

   http://127.0.0.1:8000/add/?a=4&b=5

8. 已经学到QuerySet API 这一章节

python细微语法总结

1. 函数

   1. 函数、参数、高阶函数、None
   
   位置参数
   def add_end(L=None):
       if L is None:
           L = []
       L.append('END')
       return L
     
     可变参数
     def calc(*numbers):
       sum = 0
       for n in numbers:
           sum = sum + n * n
       return sum
     关键字参数 **args
     可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
     
     命名关键字参数，如果要限制关键字参数的名字，就可以用命名关键字参数。用*分隔符 分割
     
     如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
     
     命名关键字参数必须传入参数名，这和位置参数不同
     
    //总结  
     必选参数、默认参数、位置参数、可变参数、关键字参数、命名关键字参数、参数组合
     参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
   2. list、tuple
   3. 高级特性
   切片
   L = list(range(100))
   L[0:3] 同L[:3]
   L[1:3]
   L[-2:] 
   L[:10:2] 前10个数，每两个取一个：[0, 2, 4, 6, 8]
   'ABCDEFG'[::2]
   迭代
   列表生成式
   生成器
   迭代器
   4. 函数式编程
   map
   reduce
   filter
   sorted
   返回函数
   匿名函数: list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
   
    装饰器
   def now():
   ...     print('2015-3-25')
   假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
   #装饰器
   def log(func):
       def wrapper(*arg, **kw):
           print('call %s():' % func.__name__)
           return func(*arg, **kw)
       return wrapper
   
   @log
   def now():
       print('2018-4-26')
   
   now()
   
   偏函数
   

2. 模块

   1. 使用模块
   任何模块代码的第一个字符串都被视为模块的文档注释
   __author__ = 'Michael Liao'
   2. 运行
   if __name__=='__main__':
       test()
   当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败。
   
   3. 作用域
   public：正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等
   
   __xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量
   
   类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等
   

3. 面向对象

   1. __init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身
   2.类： 要定义一个方法，除了第一个参数是self外，其他和普通函数一样。
   3. 访问限制
   4. 继承+多态
   5. 获取对象信息
   type()
   isinstance()
   
   6. __slots__
   Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性
   class Student(object):
       __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
   7. 使用@property
   class Student(object):
   
       @property
       def score(self):
           return self._score
   
       @score.setter
       def score(self, value):
           if not isinstance(value, int):
               raise ValueError('score must be an integer!')
           if value < 0 or value > 100:
               raise ValueError('score must between 0 ~ 100!')
           self._score = value
           
           
   8. 多重继承、枚举类
   

4. 正则表达式

   • \d可以匹配一个数字，\w可以匹配一个字母或数字，\s匹配空格

   • .可以匹配任意字符

   • 用*表示任意个字符（包括0个），用+表示至少一个字符，用?表示0个或1个字符，用{n}表示n个字符，用{n,m}表示n-m个字符

   • '-'是特殊字符，在正则表达式中，要用'\'转义

   • 要做更精确地匹配，可以用[]表示范围

   • [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线

   • A|B可以匹配A或B

   • ^表示行的开头，^\d表示必须以数字开头。

   • $表示行的结束，\d$表示必须以数字结束

   • re模块

   • 强烈建议使用Python的r前缀，就不用考虑转义的问题了

     def matchResult(test):
         if re.match(r'^\d{3}\-\d{3,8}$', test):
             print('ok,hhh,match ok')
         else:
             print('failed')
     
     matchResult('010-12345')
     
     分组:
     贪婪匹配：
     编译：
     
     

5. over

python常用内建模块

1. datetime & collections & base64 & struct & hashlib & hmac & zip

   zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
   >>>a = [1,2,3]
   >>> b = [4,5,6]
   >>> zipped = zip(a,b)  
   [(1, 4), (2, 5), (3, 6)]
   

2. itertools & contextlib & contextlib & urllib & XML & HTMLParser

3. argparse

   该模块用于解析通过命令行运行的参数
   $ python a.py 10 20 
   解析10 20这些基本参数
   该模块有基本用法，
   import argparse
   parser = argparse.ArgumentParser()
   parser.add_argument('--batch_size', default=100, type=int, help='batch size')
   #然后
   args = parser.parse_args()
   

4. python内置函数：http://www.runoob.com/python/python-built-in-functions.html

5. over

模块

1. 连接数据库

   #MySQL官方提供了mysql-connector-python驱动，但是安装的时候需要给pip命令加上参数--allow-external
   import mysql.connector
   def connectMysql():
       conn = mysql.connector.connect(user='root', password='gaolong', database='yirimao_2018_4')
       cursor = conn.cursor()
       sql = 'select * from user where id = 144'
       cursor.execute(sql)
       print(cursor.fetchall())
   
   connectMysql()
   
   

2. 异步IO

   ​

3. over

pandas库学习

1. 参考文献：http://codingpy.com/article/a-quick-intro-to-pandas/

   import pandas as pd
   
   def load_data(y_name='Species'):
       CSV_COLUMN = ['SepalLength', 'SepalWidth',
                       'PetalLength', 'PetalWidth', 'Species']
       path = '/Users/gl/Desktop/iris_training.csv'
       train = pd.read_csv(path, names=CSV_COLUMN, header=0)
       #pop删除某列，返回删除的那一列的数据，此处为简单赋值
       train_x, train_y = train, train.pop(y_name)
       return (train_x, train_y)
   
   print(load_data())
   
   接口：
   df.tail() 
   df.head()
   df['rain_octsep']或者df.rain_octsep
   布尔过滤：df.rain_octsep < 1000
   索引：df.iloc[30]
   对数据集应用函数：
   def base_year(year):
       base_year = year[:4]
       base_year= pd.to_datetime(base_year).year
       return base_year
   
   df['year'] = df.water_year.apply(base_year)
   df.head(5)
   数据集结构操作
   合并数据集：
   使用Pandas快速作图：
   

2. ove

Numpy快速入门

1. 参考文献：http://codingpy.com/article/an-introduction-to-numpy/

2. Python 学习数据科学或者机器学习，就必须学习 NumPy

   1. 创建二位数组、矩阵
   2. 多维数组切片
   3. 数组属性
   4. 
   

3. over

TensorFlow入门

机器学习新手入门：https://www.tensorflow.org/get_started/get_started_for_beginners

1. 模型与训练

   模型即特征与标签之间的关系。对于鸢尾花问题，模型定义了花萼和花瓣测量值与鸢尾花品种之间的关系。一些简单的模型可以用几行代数进行描述；比较复杂的机器学习模型则包含大量的交错数学函数和参数，以至于难以从数学角度进行总结
   监督式学习
   非监督式学习
   

2. 获取示例程序

   1. 安装TensorFlow(使用virtualenv直接导入该pachkage)
   2. 安装Pandas库
   3. 获取代码：git clone https://github.com/tensorflow/models
   4. cd models/samples/core/get_started/
   5. python premade_estimator.py
   

3. 高阶API：Estimator和Dataset

4. 程序流程

   1. 导入和解析数据集。
   2. 创建特征列以描述数据。
   3. 选择模型类型。
   4. 训练模型。
   5. 评估模型的效果。
   6. 让经过训练的模型进行预测。
   

   ​

5. over