【机器学习】0 环境准备及Python基础

前言

想当时学生阶段，一看到Andrew Ng吴恩达的机器学习就困，转眼间已经过去两年，时光荏苒。
好久没有写博客了，又回来啦~~
下周开始CCB-bk机器学习的培训，借此机会将之前的机器学习相关的知识进行一下梳理。
开始之前，先把环境搭好。

---

环境准备

俗话说，工欲善其事必先利其器。

软件准备

两方面，一方面为编译和运行环境，另一方面为编辑环境IDE:
1.python3(1和2选一个，后文会介绍区别)
2.anaconda3
3.pycharm

Python2.x与3​​.x版本区别

1. 
   
2. 为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下相容。许多针对早期Python版本都无法在Python 3.0上正常执行。
3. 为了照顾现有程序，Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移，允许使用部分Python 3.0的语法与函数。目前不支援Python 3.0的第三方库有Twisted, py2exe, PIL等。
4. 细节区别：
   

1. print函数 ， 没有了print语句
   
2. Unicode . python3 默认utf8 ； 2.X 会遇到转码问题
   
3. 除法运算, 3.X 规范了 / 与 //
   
4. range() , 去除了xrange() ; 去除了不等号<>，只留下!= ； 去除了 long数据类型， 整形中只留下int
   
5. 根据PEP8 将多个模块修改了名字 ， eg. SocketServer -> socketserver

Python与Anaconda的关系（类似于Java中的JDK与J2EE的关系）

1. 首先说一下对应关系： python 2.X 对应 Anaconda2.X ; python 3.X 对应 anaconda 3.X
2. Anaconda是一个科学计算环境，是一个python的发行版，包括了Python和很多常见的软件库和一个包管理器conda。当装好Anaconda3以后，就相当于安装好了Python3，还有一些常用的库，如numpy，scrip，matplotlib等库。
3. 这里没有安装anaconda的话，直接安装了Python，装完Python 想要使用这些库的话 还要在cmd中运行 pip install ….;

Python IDE

1. IDE 有很多 ：Pycharm 、 Sublime 、 VSCode 、 Eclipse+Pydev等
2. IntelliJ IDEA用户果断Pycharm呀！
3. 一个原因是快捷键及JetBrains倡导的沉浸式开发，另一个原因是JetBrains旗下的产品包含两种类型：社区版和专业版，社区办包含开发的大部分功能，且免费，专业版收费，但是对于学生或者教师等拥有学校后缀（@**.edu.cn等）邮箱的用户免费，每年需激活一次，即专业版的学生免费ID。

Anaconda与PyCharm的安装

1. Anaconda官网下载巨慢。可采用国内清华镜像下载。搜索引擎： Anaconda 清华镜像 即可
2. PyCharm 官网下载

3. Python环境变量配置：

   当安装完Anaconda以后，添加环境变量，比如安装路径为：F:\Anaconda3 ;那么安装完成后 就要做接下来的操作：
   右键我的电脑—属性—高级系统设置—-高级选项里面有一个环境变量，点击环境变量——系统变量里面 找path——双击path，>>添加路径，路径间用；隔开。需要添加的路径有三个（以本文为例）：F:\Anaconda3; F:\Anaconda3\Scripts;
   F:\Anaconda3\Library\bin; 完了之后，再cmd中直接输入python , 有版本反馈即为配置成功

4. PyCharm安装完成后自动识别或者按说明配置Python环境，一般可自动识别到；

运行Pycharm，开始学习之旅

python基础

#!/usr/bin/python
#conding=utf-8

#上边是编码格式，pycharm setting设置 python3默认utf-8
#1 入门
print("你好，世界");

#2 缩进(与Java极大不同) 缩进代表模块 ， 可用Tab或者空格，但是要统一
if True:
    print("True")
else:
    print("False")

#3 多行语句
total = "a" + "b" + \
        "c";
print(total)
#4 语句中包含[]{}()就不需要使用\进行多行连接了
days = ['monday','Tuesday','Wednesday',
         'Thurday','Friday']
print(days)

#5 使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串,其中三引号可以由多行组成
word = 'word'
sentence = "sentence。"
paragraph = '''这是一个段落。
            包含了好多句子
            这是最后了'''
print(paragraph)

#6 注释 单行注释 多行注释（三个单引号(''')或三个双引号(""")）
'''
这是
一种
多行
注释
'''

"""
这是
另一种
多行注释
"""

#7 空行
'''
函数之间或类的方法之间用空行分隔
表示一段新的代码的开始
类和函数入口之间也用一行空行分隔
以突出函数入口的开始
空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
'''

#8 输入输出 print输出默认是换行的，若不想换行，则在输出时加逗号
# text = input("Please input:")
# print(text)
a = 'a'
b = 'b'
print(a)
print(b)
print(a, end='')
print(b, end='')
print(a + b)


#9 同一行多条语句
x = "abc"; print(x);

#10 变量赋值 Python 中的变量赋值不需要类型声明
counter = 100 #整形
miles = 100.123 #浮点型
name = 'John' #字符串
a = b = c = 1 ; #多变量赋值
print(c)
a, b, c = 1, 1.3, 'Will'
print(c)

#11 标准数据类型
'''
Python有五个标准的数据类型：
Numbers（数字） int、long(可用大写L和小写l结尾来表示long类型，建议大写L)、float(也可表示科学计数法32.3e+18)、
                complex(复数 a+bj，a为实部，b为虚部或者complex(a,b),例如3+26j)
String（字符串） python的字串列表有2种取值顺序:
                        1. 从左到右索引默认0开始的，最大范围是字符串长度少1
                        2. 从右到左索引默认-1开始的，最大范围是字符串开头
                加号（+）是字符串连接运算符，星号（*）是重复操作
List（列表）
    列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
Tuple（元组）
    元组是另一个数据类型，类似于List（列表）。
    元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
Dictionary（字典）
    列表是有序的对象集合，字典是无序的对象集合。
    两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
    字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
'''
# String（字符串）
str = 'Hello World!'
print(str)  # 输出完整字符串
print(str[0])  # 输出字符串中的第一个字符
print(str[2:5])  # 输出字符串中第三个至第五个之间的字符串
print(str[2:])  # 输出从第三个字符开始的字符串
print(str * 2)  # 输出字符串两次
print(str + "TEST")  # 输出连接的字符串

# List（列表）
list = ['John', 123, 0x14f, complex(3,4), "Hello World"]
print(list)
tinylist = list[-3:-1] #不输出倒数第一个
print(tinylist)
tinylist = list[-3:] #输出倒数第一个
print(tinylist)
list = list + tinylist
print(list)

# Tuple（元组）
tupledemo = ('word', "hello world", 123, 0x1f3, complex(1, 2))
print(tupledemo)
tupledemo = tupledemo + tupledemo[3:]
print(tupledemo)

# Dictionary（字典）
dict = {}
dict['one'] = 'hello'
dict['two'] = 'world'
dict[2] = 3.14 # key可以为非string
print(dict['one'])
print(dict)

otherdict = {'big': 1.9, 'small': '1.2', 2: 3.14}
print(otherdict.values())
print(otherdict[2])

# Python数据类型转换
iStr = "123"
print(iStr)
iNum = int(iStr)
print(iNum)

#12 运算符
'''
算术运算符
+   加 - 两个对象相加  a + b 输出结果 30
-   减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
*   乘 - 两个数相乘或是返回一个被重复若干次的字符串   a * b 输出结果 200
/   除 - x除以y    b / a 输出结果 2
%   取模 - 返回除法的余数    b % a 输出结果 0
**  幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
//  取整除 - 返回商的整数部分（向下取整）    9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
比较运算符
==  等于 - 比较对象是否相等   (a == b) 返回 False。
!=  不等于 - 比较两个对象是否不相等   (a != b) 返回 true.
<>  不等于 - 比较两个对象是否不相等   (a <> b) 返回 true。这个运算符类似 != 。
>   大于 - 返回x是否大于y   (a > b) 返回 False。
<   小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。   (a < b) 返回 true。
>=  大于等于    - 返回x是否大于等于y。   (a >= b) 返回 False。
<=  小于等于 -  返回x是否小于等于y。 (a <= b) 返回 true。
赋值运算符
=   简单的赋值运算符    c = a + b 将 a + b 的运算结果赋值为 c
+=  加法赋值运算符 c += a 等效于 c = c + a
-=  减法赋值运算符 c -= a 等效于 c = c - a
*=  乘法赋值运算符 c *= a 等效于 c = c * a
/=  除法赋值运算符 c /= a 等效于 c = c / a
%=  取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符  c **= a 等效于 c = c ** a
//= 取整除赋值运算符    c //= a 等效于 c = c // a
位运算符
&   按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0    (a & b) 输出结果 12 ，二进制解释： 0000 1100
|   按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^   按位异或运算符：当两对应的二进位相异时，结果为1    (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~  按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<  左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。    a << 2 输出结果 240 ，二进制解释： 1111 0000
>>  右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
逻辑运算符
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or  x or y  布尔"或"   - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。  (a or b) 返回 10。
not not x   布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。    not(a and b
成员运算符
in  如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in  如果在指定的序列中没有找到值返回 True，否则返回 False。   x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
身份运算符
is  is 是判断两个标识符是不是引用自一个对象   x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not  is not 是判断两个标识符是不是引用自不同对象   x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
运算符优先级
**  指数 (最高优先级)
~ + -  按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //    乘，除，取模和取整除
+ - 加法减法
>> <<   右移，左移运算符
&   位 'AND'
^ | 位运算符
<= < > >=   比较运算符
<> == !=    等于运算符
= %= /= //= -= += *= **=    赋值运算符
is is not   身份运算符
in not in   成员运算符
not and or  逻辑运算符
'''
list = [1, 2, 3, 4, 5]
a = 3
b = 13
if (a in list):
    print('Yes, a in list')
if (b not in list):
    print('b is not in list')

#13 条件语句
'''
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……
注：由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

'''
num = 10
if (num > 0 and num <20):
    print(num)
elif ( num >=20 and num < 30):
    print(num)
else:
    print(num)

#14 循环语句
'''
while 循环    在给定的判断条件为 true 时执行循环体，否则退出循环体。
for 循环  重复执行语句
    for iterating_var in sequence:
        statements(s)
嵌套循环    你可以在while循环体中嵌套for循环

循环控制语句
break 语句    在语句块执行过程中终止循环，并且跳出整个循环
continue 语句 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句 pass是空语句，是为了保持程序结构的完整性。
'''
# while
numbers = [12, 37, 11,112, 123123]
even=[]
old=[]
while(len(numbers)> 0 ):
    number = numbers.pop();
    if(number % 2 == 0):
        even.append(number)
    else:
        old.append(number)
print(numbers)
print(even)
print(old)
# for
fruits = ['Apple', 'Banana', 'Mango']
for fruit in fruits :
    print(fruit)
# 通过序列索引迭代
for index in range(len(fruits)):
    print(fruits[index])
for num in range(20,30):
    print(num)
# eg. 2-100间的素数
i = 2
while (i < 100):
    j = 2
    while (j <= (i / j)):
        if not (i % j): break
        j = j + 1
    if (j > i / j): print(i, " 是素数")
    i = i + 1

#15 Number
'''
Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。
Python math 模块提供了许多对浮点数的数学运算函数。
Python cmath 模块包含了一些用于复数运算的函数。
cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。
要使用 math 或 cmath 函数必须先导入：import math
'''
import cmath
reb = cmath.sqrt(-1)
print(reb)
import math
print(math.pow(2,3))
import random
print(random.random())

#16 字符串
'''
+   字符串连接   
>>>a + b
'HelloPython'
*   重复输出字符串 
>>>a * 2
'HelloHello'
[]  通过索引获取字符串中字符    
>>>a[1]
'e'
[ : ]   截取字符串中的一部分  
>>>a[1:4]
'ell'
in  成员运算符 - 如果字符串中包含给定的字符返回 True    
>>>"H" in a
True
not in  成员运算符 - 如果字符串中不包含给定的字符返回 True   
>>>"M" not in a
True
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 
>>>print r'\n'
\n
>>> print R'\n'
\n
%   格式字符串
'''
name = 'Zara'
age = 21
print('my name is %s and I am %d years old' %(name, age) )
print(name.upper())

#17 列表(List)
'''
append 添加
remove 移除列表中某个值的第一个匹配项
del 删除某个元素
'''

#18 元组
'''
创建空元组 : tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号 : tup1 = (50,)
'''
tup1 = (50,)
#  tup1[0] = 20  : 该语句非法， 元组中元素不允许修改
print(tup1)
del tup1

#19 日期和时间
'''
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:
时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
'''
import time
localtime = time.localtime(time.time())
print(localtime)
localtime = time.asctime(time.localtime(time.time()))
print(localtime)
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
import calendar
cal = calendar.month(2016, 1)
print(cal)
'''
    January 2016
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
'''

#20 函数
'''
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数

   '''
#必备参数
def my_print( str ):
    "函数_我的新函数"
    print(str)
    return str + "finished";

ret = my_print('John ');
print(ret)
#关键字参数
def printinfo(name, age):
    "打印任何传入的字符串"
    print("Name: ", name)
    print("Age ", age)
    return;
# 调用printinfo函数
printinfo(age=50, name="miki");
#缺省参数
def printinfo(name, age=35):
    "打印任何传入的字符串"
    print("Name: ", name)
    print("Age ", age)
    return;
# 调用printinfo函数
printinfo(age=50, name="miki");
printinfo(name="miki");
#不定长参数
def printinfo(arg1, *vartuple):
    "打印任何传入的参数"
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return;
# 调用printinfo 函数
printinfo(10);
printinfo(70, 60, 50);
#匿名函数  python 使用 lambda 来创建匿名函数。
#lambda函数的语法只包含一个语句，如：lambda [arg1 [,arg2,.....argn]]:expression

#21 变量作用域
'''
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
1.全局变量
2.局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
'''
total = 0;  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2;  # total在这里是局部变量.

    return total;
# 调用sum函数
sum(10, 20);


#22 Python 模块
'''
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
eg. 新建support.py 在里边写函数
def print_func( par ):
    print('hello '+par)
    return

如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

'''
import support
support.print_func('Will.Guo')
from support import print_func
print_func('John')
#局部变量和全局变量
Money = 2000
def AddMoney():
    # 想改正代码就取消以下注释:
    global Money
    Money = Money + 1
    print(Money)
AddMoney()
print(Money)

#23 文件I/O  file object = open(file_name [, access_mode][, buffering])
fopen = open('a.txt','a+',-1)
fopen.write("Hello World\n")
fopen.close()
import os  #操作系统相关的shell命令包含在os内，例如创建目录、删除文件等。
os.rename('a.txt','a.txt')
'''
File 对象和 OS 对象提供了很多文件与目录的操作方法,可以查找相关文档查看详情：
File 对象方法: file 对象提供了操作文件的一系列方法。
OS 对象方法: 提供了处理文件及目录的一系列方法。
'''

#24 Python 异常处理
'''
try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生


我们可以使用raise语句自己触发异常
raise语法格式如下：
raise [Exception [, args [, traceback]]]
'''
try :
    fh = open('b.txt','w')
    fh.write('this is a test file !')
except IOError:
    print('IOError')
except (FileExistsError, ZeroDivisionError):
    print('FileExistsError')
except:
    print('catch every error')
else:
    print('没有异常执行这里')
    fh.close()
finally:
    print('不管有没有异常都会执行')

#25 面向对象
'''
通常需要在单独的文件中定义一个类
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体
'''
class Employee:
    '员工基类'
    empCount = 0
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1  # 与 self.empCount是不一样的，前者代表类，后者代表实例化的对象
        return

    def displayCount(self):
        print(self.empCount)
        return

    def displayEmploy(self):
        print("Name : ", self.name,  ", Salary: ", self.salary)
        return

e1 = Employee('Will.Guo',123);
e2 = Employee('John',321)
e1.displayCount()
e1.displayEmploy()
doc = e1.__doc__
print(doc)

#继承
'''
序号  方法, 描述 & 简单的调用
1   __init__ ( self [,args...] )
构造函数
简单的调用方法: obj = className(args)
2   __del__( self )
析构方法, 删除一个对象
简单的调用方法 : del obj
3   __repr__( self )
转化为供解释器读取的形式
简单的调用方法 : repr(obj)
4   __str__( self )
用于将值转化为适于人阅读的形式
简单的调用方法 : str(obj)
5   __cmp__ ( self, x )
对象比较
简单的调用方法 : cmp(obj, x)
'''
class Parent:  # 定义父类
    parentAttr = 100

    def __init__(self):
        print("调用父类构造函数")

    def parentMethod(self):
        print('调用父类方法')

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print("父类属性 :", Parent.parentAttr)

class Child(Parent):  # 定义子类
    def __init__(self):
        print("调用子类构造方法")

    def childMethod(self):
        print('调用子类方法')
c = Child()  # 实例化子类
c.childMethod()  # 调用子类的方法
c.parentMethod()  # 调用父类方法
c.setAttr(200)  # 再次调用父类的方法 - 设置属性值
c.getAttr()  # 再次调用父类的方法 - 获取属性值

'''
单下划线、双下划线、头尾双下划线说明：
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
'''

#26 正则 （规则一致，包为re）

#27 CGI common gateway interface 通用网关协议 原始版本 类似于java的jsp

#28 python操作mysql数据库
'''
不同的数据库你需要下载不同的DB API模块，例如你需要访问Oracle数据库和Mysql数据，你需要下载Oracle和MySQL数据库模块。
DB-API 是一个规范. 它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口 。
Python DB-API使用流程：
1.引入 API 模块。
2.获取与数据库的连接。
3.执行SQL语句和存储过程。
4.关闭数据库连接。
'''
import pymysql
# 打开数据库连接
db = pymysql.connect("localhost", "root", "root", "mydemo", charset='utf8' )
# 使用cursor()方法获取操作游标
cursor = db.cursor()
# 使用execute方法执行SQL语句
cursor.execute("SELECT * from student")
# 使用 fetchone() 方法获取一条数据
data = cursor.fetchone()
print(data[0])
# 关闭数据库连接
db.close()

#29 网络编程socket  SMTP邮件服务器编程(类似于jmail)

#30 多线程
#TODO 多线程 important
import thread
import time
# 为线程定义一个函数
def print_time(threadName, delay):
    count = 0
    while count < 5:
        time.sleep(delay)
        count += 1
        print("%s: %s" % (threadName, time.ctime(time.time())))
# 创建两个线程
try:
    thread.start_new_thread(print_time, ("Thread-1", 2,))
    thread.start_new_thread(print_time, ("Thread-2", 4,))
except:
    print("Error: unable to start thread")
while 1:
    pass

TODO

多线程部分继续学习

---

Finally

终于写完了。哇，竟然写了1.2+字。。。
新手上路，很不专业，感谢批评指正。
明天又是新的一周。哦，不对，是今天。晚安~~~

Reference

Python tutorial
菜鸟教程
浅谈机器学习步骤

---

stay hungry， stay foolish.