第五课 - 日期,时间和文件操作

# 日期和时间
(一) time模块,python内置模块
(1)time()函数获取当前时间戳
(2)localtime([seconds])格式化时间戳为本地时间,返回时间元组
(3)unix时间戳网站获取时间戳数据
![](http://wenda.chinahadoop.cn/up ... ac.png)
实例:
```
import time
#获取当前时间戳,从1970年1月1号0点开始到当前时间的时间戳
print(time.time())

#返回struct_time时间元组
print(time.localtime(time.time()))
```
(二) 日期和时间的格式化
(1)time.strftime(format[, time_turple])
![](http://wenda.chinahadoop.cn/up ... 5e.png)
实例:
```
import time
print(time.strftime("%Y/%m/%d %H:%M:%S")) #格式可以自定义,当前时间元组格式化

#格式化指定时间元组
print(time.strftime("%Y/%m/%d %H:%M:%S", time.localtime()))
```
(2)time.strptime(string, format):将日期时间字符串转换成元组
```
print(time.strptime("2018-04-12 20:17:30", "%Y-%m-%d %H:%M:%S")) #返回时间元组
```
(3)time.mktime(time_turple):将时间元组转换成时间戳
```
print(time.mktime(time.strptime("2018-04-12 20:17:30", "%Y-%m-%d %H:%M:%S")))
```
(4)time.sleep(seconds):程序睡眠等待几秒钟
```
time.sleep(5) #睡眠5秒钟
```
(三) datetime模块:import datetime
(1)datetime.datetime.now():获取当前日期和时间
```
import datetime
print(datetime.datetime.now()) #获取当前时间
```
(2)strftime(format):日期时间格式化
```
print(datetime.datetime.now().strftime(%Y-%m-%d %H:%M:%S))
```
(3)datetime.datetime.fromtimestamp(timestamp):将时间戳转换为日期时间
```
ts = time.time() #当前时间戳
print(ts)

#还可以用strftime对日期时间进行再一次格式化
print(datetime.datetime.fromtimestamp(ts))
```
(4)datetime.timedelta(时间间隔):返回一个时间间隔对象,通过时间间隔可以对时间进行加减法得到新的时间。
```
#计算昨天的日期
today = datetime.datetime.today()
print(today.strftime(%Y-%m-%d %H:%M:%S))
timedelta = datetime.timedelta(days=1)
yersterday = today - timedelta
print(yersterday.strftime(%Y-%m-%d %H:%M:%S)) #日期和时间

#只格式化日期部分
print(yersterday.strftime(%Y-%m-%d))
```
# 文件、文件夹操作
(一) 文件操作
(1)open(文件路径,访问模式,ending=编码模式)方法打开一个存在的文件,或者创建新的文件
(2)close()方法关闭已打开的文件
(3)打开文件常用的三种访问模式:r - 只读模式(默认);w - 只写模式;a - 追加模式
(4)write(data)方法向文件中写入字符串
(5)read()方法读取文件全部内容

继续阅读 »
# 日期和时间
(一) time模块,python内置模块
(1)time()函数获取当前时间戳
(2)localtime([seconds])格式化时间戳为本地时间,返回时间元组
(3)unix时间戳网站获取时间戳数据
![](http://wenda.chinahadoop.cn/up ... ac.png)
实例:
```
import time
#获取当前时间戳,从1970年1月1号0点开始到当前时间的时间戳
print(time.time())

#返回struct_time时间元组
print(time.localtime(time.time()))
```
(二) 日期和时间的格式化
(1)time.strftime(format[, time_turple])
![](http://wenda.chinahadoop.cn/up ... 5e.png)
实例:
```
import time
print(time.strftime("%Y/%m/%d %H:%M:%S")) #格式可以自定义,当前时间元组格式化

#格式化指定时间元组
print(time.strftime("%Y/%m/%d %H:%M:%S", time.localtime()))
```
(2)time.strptime(string, format):将日期时间字符串转换成元组
```
print(time.strptime("2018-04-12 20:17:30", "%Y-%m-%d %H:%M:%S")) #返回时间元组
```
(3)time.mktime(time_turple):将时间元组转换成时间戳
```
print(time.mktime(time.strptime("2018-04-12 20:17:30", "%Y-%m-%d %H:%M:%S")))
```
(4)time.sleep(seconds):程序睡眠等待几秒钟
```
time.sleep(5) #睡眠5秒钟
```
(三) datetime模块:import datetime
(1)datetime.datetime.now():获取当前日期和时间
```
import datetime
print(datetime.datetime.now()) #获取当前时间
```
(2)strftime(format):日期时间格式化
```
print(datetime.datetime.now().strftime(%Y-%m-%d %H:%M:%S))
```
(3)datetime.datetime.fromtimestamp(timestamp):将时间戳转换为日期时间
```
ts = time.time() #当前时间戳
print(ts)

#还可以用strftime对日期时间进行再一次格式化
print(datetime.datetime.fromtimestamp(ts))
```
(4)datetime.timedelta(时间间隔):返回一个时间间隔对象,通过时间间隔可以对时间进行加减法得到新的时间。
```
#计算昨天的日期
today = datetime.datetime.today()
print(today.strftime(%Y-%m-%d %H:%M:%S))
timedelta = datetime.timedelta(days=1)
yersterday = today - timedelta
print(yersterday.strftime(%Y-%m-%d %H:%M:%S)) #日期和时间

#只格式化日期部分
print(yersterday.strftime(%Y-%m-%d))
```
# 文件、文件夹操作
(一) 文件操作
(1)open(文件路径,访问模式,ending=编码模式)方法打开一个存在的文件,或者创建新的文件
(2)close()方法关闭已打开的文件
(3)打开文件常用的三种访问模式:r - 只读模式(默认);w - 只写模式;a - 追加模式
(4)write(data)方法向文件中写入字符串
(5)read()方法读取文件全部内容

收起阅读 »

第十课 - Python人工智能基础篇总结

从第一节课老师用python打出hello world到第十节课用python调用三方库显示图表,以下对这十节课的学习做个简单的小结。

Note:点击标题,可进入每节课的笔记。

:tw-1f449:**[第一节课](http://wenda.chinahadoop.cn/article/646 "第一节课"):**
(1) 环境配置安装,pycharm
(2) 基本语法:输入输出
(3) 注释以及命名规则
(4) 基本数据类型,如number, bool, dictionary, list 等等
(5) 变量及类型转换
(6))运算操作符

:tw-1f449:**[第二节课](http://wenda.chinahadoop.cn/article/663 "第二节课"):**
(1) 程序执行顺序:顺序执行;选择执行;循环执行
(2) while循环,for循环
(3) break,continue跳出循环
(4) 字符串定义,以及切片
(5) 列表定义,以及对列表的操作的相关方法,修改,查询,排序等等

:tw-1f449:**[第三节课](http://wenda.chinahadoop.cn/article/659 "第三节课"):**
(1) 元组概念,特性,元组的遍历,操作
(2) 字典概念,特性,元素的访问,修改等操作
(3) 集合概念,特性,空集合
(4) 字符串内置方法的使用

:tw-1f449:**[第四节课](http://wenda.chinahadoop.cn/article/710 "第四节课"):**
(1) 函数的定义,形参,实参,函数返回
(2) 缺省参数,不定长参数,命名参数,拆包
(3) 递归函数
(4) 匿名函数:lambda

:tw-1f449:**[第五节课](http://wenda.chinahadoop.cn/article/721 "第五节课:"):**
(1) 时间,日期的格式化输出
(2) 文件/文件夹操作,打开,关闭,读写文件
(3) JSON文件,CSV文件

:tw-1f449:**[第六节课](http://wenda.chinahadoop.cn/article/685 "第六节课"):**
(1) 面向对象:类,对象,方法,属性
(2) 类的特性:继承,封装,多态
(3) 类的访问权限:私有,公有

:tw-1f449:**[第七节课](http://wenda.chinahadoop.cn/article/693 "第七节课"):**
(1) 类方法(不同于类对象的方法),静态方法
(2) 单例类:仅有一个类实例
(3) 异常处理
(4) 包和模块

:tw-1f449:**[第八节课](http://wenda.chinahadoop.cn/article/701 "第八节课"):**
(1) 正则表达式:re模块
(2) 单字符匹配;数量表示;边界表示
(3) 正则表达式的高级用法:search,finditer,sub
(4) 贪婪模式和非贪婪模式

:tw-1f449:**[第九节课](http://wenda.chinahadoop.cn/article/709 "第九节课"):**
(1) 冒泡排序
(2) 选择排序
(3) 快速排序
(4) 归并排序

:tw-1f449:**第十节课:**
(1) 利用以往学的pyton知识,对数据进行f分析
(2) 微信用户数据分析:安装第三方开源的微信个人号接口“pip install itcha”
(3) Python的2D绘图库:pip install matplotlib,
继续阅读 »
从第一节课老师用python打出hello world到第十节课用python调用三方库显示图表,以下对这十节课的学习做个简单的小结。

Note:点击标题,可进入每节课的笔记。

:tw-1f449:**[第一节课](http://wenda.chinahadoop.cn/article/646 "第一节课"):**
(1) 环境配置安装,pycharm
(2) 基本语法:输入输出
(3) 注释以及命名规则
(4) 基本数据类型,如number, bool, dictionary, list 等等
(5) 变量及类型转换
(6))运算操作符

:tw-1f449:**[第二节课](http://wenda.chinahadoop.cn/article/663 "第二节课"):**
(1) 程序执行顺序:顺序执行;选择执行;循环执行
(2) while循环,for循环
(3) break,continue跳出循环
(4) 字符串定义,以及切片
(5) 列表定义,以及对列表的操作的相关方法,修改,查询,排序等等

:tw-1f449:**[第三节课](http://wenda.chinahadoop.cn/article/659 "第三节课"):**
(1) 元组概念,特性,元组的遍历,操作
(2) 字典概念,特性,元素的访问,修改等操作
(3) 集合概念,特性,空集合
(4) 字符串内置方法的使用

:tw-1f449:**[第四节课](http://wenda.chinahadoop.cn/article/710 "第四节课"):**
(1) 函数的定义,形参,实参,函数返回
(2) 缺省参数,不定长参数,命名参数,拆包
(3) 递归函数
(4) 匿名函数:lambda

:tw-1f449:**[第五节课](http://wenda.chinahadoop.cn/article/721 "第五节课:"):**
(1) 时间,日期的格式化输出
(2) 文件/文件夹操作,打开,关闭,读写文件
(3) JSON文件,CSV文件

:tw-1f449:**[第六节课](http://wenda.chinahadoop.cn/article/685 "第六节课"):**
(1) 面向对象:类,对象,方法,属性
(2) 类的特性:继承,封装,多态
(3) 类的访问权限:私有,公有

:tw-1f449:**[第七节课](http://wenda.chinahadoop.cn/article/693 "第七节课"):**
(1) 类方法(不同于类对象的方法),静态方法
(2) 单例类:仅有一个类实例
(3) 异常处理
(4) 包和模块

:tw-1f449:**[第八节课](http://wenda.chinahadoop.cn/article/701 "第八节课"):**
(1) 正则表达式:re模块
(2) 单字符匹配;数量表示;边界表示
(3) 正则表达式的高级用法:search,finditer,sub
(4) 贪婪模式和非贪婪模式

:tw-1f449:**[第九节课](http://wenda.chinahadoop.cn/article/709 "第九节课"):**
(1) 冒泡排序
(2) 选择排序
(3) 快速排序
(4) 归并排序

:tw-1f449:**第十节课:**
(1) 利用以往学的pyton知识,对数据进行f分析
(2) 微信用户数据分析:安装第三方开源的微信个人号接口“pip install itcha”
(3) Python的2D绘图库:pip install matplotlib, 收起阅读 »

第六课:类,派生和继承

第六课的笔记,由于网站改版没能及时发出来,现在补上
 
http://note.youdao.com/notesha ... 3C875
继续阅读 »
第六课的笔记,由于网站改版没能及时发出来,现在补上
 
http://note.youdao.com/notesha ... 3C875 收起阅读 »

第四课 - 函数

# (一)概念:
实现单一功能或者相关功能的代码段,函数课最大化复用代码

# (二)函数定义:

```
def 函数名 (参数列表)
函数体
return [表达式] #返回的“表达式”是选择性的;如果没有value返回,那么返回值是None
```

实例(1):有参数有返回
```
def Sum(x, y):
sum = x + y
return sum

#函数调用
sum = Sum(1, 2)
print(sum)

输出结果:
3
```

实例(2):有多个返回
```
def x_y_comp_tuple(x, y):
res1 = x + y
res2 = x * y
return res1, res2

a, b = x_y_comp_tuple(2, 3)
print("a = {}, b = {}".format(a, b))

输出结果:
a = 5, b = 6
```

实例(3):列表作为返回值
```
稍后填充
```
# (三)函数参数列表形式
**(1)缺省参数**
函数定义带有初始值的形参
函数调用时,缺省参数可传,也可不传
缺省参数一定要位于参数列表的最后
缺省参数数量没有限制

实例:
```
def Sum(x, y = 10): #第二个参数y就是缺省默认参数
res = x + y
return res

sum = Sum(5)
print(sum)
```

输出结果:
```
15
```
**(2)不定长参数**
函数可以接收不定个数的参数传入
def function([formal_args,]*args)函数调用时,传入的不定长参数会被封装成元组。如果在函数调用时没有指定未命名的变量参数,那么它就是一个空元组
def function([formal_args,]\**args)函数调用时,如果传入key=value形式的不定长参数,会被封装成字典

实例一:def function([formal_args,]*args)
```
def any_num_sum(x,y=10,*args):
print("args={}".format(args))
rs = x + y
if len(args) > 0:
for arg in args:
rs += arg
return rs

#改变不定长参数的位置
def any_num_sum2(x,*args,y=10):
print("args={}".format(args))
print("x={}".format(x))
print("y={}".format(y))
rs = x + y
if len(args) > 0:
for arg in args:
rs += arg
return rs
rs1 = any_num_sum2(20)
rs2 = any_num_sum2(20,30,100) #注意rs2和rs3的区别
rs3 = any_num_sum2(20,30,40,50,60,y=100)
print(rs1)
print(rs2)
print(rs3)

```
实例二:def function([formal_args,]\**args
```
#养老 医疗 公积金

def social_insurance_comp(basic_money,**proportion):
print(proportion)
e_money = basic_money * proportion["e"]
m_money = basic_money * proportion["m"]
a_money = basic_money * proportion["a"]
total_money = e_money + m_money + a_money
return e_money,m_money,a_money,total_money

```

**(3)命名参数,也叫关键字参数**
调用带有参数的函数时,通过指定参数名称传入参数的值
可以不按函数定义的参数顺序传入

实例:
```
def Sum(x, y):
res = x + y
return res

sum = Sum(y=10, x= 15)
print(sum)
```
输出结果:
```
25
```
**(4)拆包**
对于定义了不定长参数的函数,在函数调用时需要把已定义好的元组或者列表传入到函数中,需要使用拆包方法

实例:
```
def salary_comp(basic_money,*other_money,**proportion):
print("缴费基数:{}".format(basic_money))
print("其他工资:{}".format(other_money))
print("比例:{}".format(proportion))

other_money = (500,200,100,1000)
proportion_dict = {"e":0.2,"m":0.1,"a":0.12}
#salary_comp(8000,other_money,proportion_dict) #未使用拆包

salary_comp(8000,*other_money,**proportion_dict)
```
(5)Python函数的参数传递
值传递:如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a) 内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。

引用传递:如 列表,字典。如 fun(list),则是将 list 真正的传过去,修改后fun外部的list也会受影响

python 中一切都是对象,严格意义我们不能说值传递还是引用传递。

#(四)匿名函数
用lambda关键字创建匿名函数
定义:lambda[参数列表]:表达式
匿名函数可以作为参数被传入其他函数

```
#匿名函数
sum = lambda x,y:x+y
print(sum(10,20))
#等价函数
def sum(x,y):
return x + y

#匿名函数作为参数传入到自定义函数中
def x_y_comp(x,y,func):
rs = func(x,y)
print(rs)

x_y_comp(3,5,lambda x,y:x+y)
print("----------------")
x_y_comp(4,7,lambda x,y:x*y)

#匿名函数作为python内置函数的参数使用
user_infos = [{"name":"zhangsan","age":20},{"name":"lisi","age":30},{"name":"wangwu","age":18}]

print(user_infos)
# user_infos.sort(key=lambda info:info["age"])
# print(user_infos)
user_infos.sort(key=lambda info:info["age"],reverse=True)
print(user_infos)
```
继续阅读 »
# (一)概念:
实现单一功能或者相关功能的代码段,函数课最大化复用代码

# (二)函数定义:

```
def 函数名 (参数列表)
函数体
return [表达式] #返回的“表达式”是选择性的;如果没有value返回,那么返回值是None
```

实例(1):有参数有返回
```
def Sum(x, y):
sum = x + y
return sum

#函数调用
sum = Sum(1, 2)
print(sum)

输出结果:
3
```

实例(2):有多个返回
```
def x_y_comp_tuple(x, y):
res1 = x + y
res2 = x * y
return res1, res2

a, b = x_y_comp_tuple(2, 3)
print("a = {}, b = {}".format(a, b))

输出结果:
a = 5, b = 6
```

实例(3):列表作为返回值
```
稍后填充
```
# (三)函数参数列表形式
**(1)缺省参数**
函数定义带有初始值的形参
函数调用时,缺省参数可传,也可不传
缺省参数一定要位于参数列表的最后
缺省参数数量没有限制

实例:
```
def Sum(x, y = 10): #第二个参数y就是缺省默认参数
res = x + y
return res

sum = Sum(5)
print(sum)
```

输出结果:
```
15
```
**(2)不定长参数**
函数可以接收不定个数的参数传入
def function([formal_args,]*args)函数调用时,传入的不定长参数会被封装成元组。如果在函数调用时没有指定未命名的变量参数,那么它就是一个空元组
def function([formal_args,]\**args)函数调用时,如果传入key=value形式的不定长参数,会被封装成字典

实例一:def function([formal_args,]*args)
```
def any_num_sum(x,y=10,*args):
print("args={}".format(args))
rs = x + y
if len(args) > 0:
for arg in args:
rs += arg
return rs

#改变不定长参数的位置
def any_num_sum2(x,*args,y=10):
print("args={}".format(args))
print("x={}".format(x))
print("y={}".format(y))
rs = x + y
if len(args) > 0:
for arg in args:
rs += arg
return rs
rs1 = any_num_sum2(20)
rs2 = any_num_sum2(20,30,100) #注意rs2和rs3的区别
rs3 = any_num_sum2(20,30,40,50,60,y=100)
print(rs1)
print(rs2)
print(rs3)

```
实例二:def function([formal_args,]\**args
```
#养老 医疗 公积金

def social_insurance_comp(basic_money,**proportion):
print(proportion)
e_money = basic_money * proportion["e"]
m_money = basic_money * proportion["m"]
a_money = basic_money * proportion["a"]
total_money = e_money + m_money + a_money
return e_money,m_money,a_money,total_money

```

**(3)命名参数,也叫关键字参数**
调用带有参数的函数时,通过指定参数名称传入参数的值
可以不按函数定义的参数顺序传入

实例:
```
def Sum(x, y):
res = x + y
return res

sum = Sum(y=10, x= 15)
print(sum)
```
输出结果:
```
25
```
**(4)拆包**
对于定义了不定长参数的函数,在函数调用时需要把已定义好的元组或者列表传入到函数中,需要使用拆包方法

实例:
```
def salary_comp(basic_money,*other_money,**proportion):
print("缴费基数:{}".format(basic_money))
print("其他工资:{}".format(other_money))
print("比例:{}".format(proportion))

other_money = (500,200,100,1000)
proportion_dict = {"e":0.2,"m":0.1,"a":0.12}
#salary_comp(8000,other_money,proportion_dict) #未使用拆包

salary_comp(8000,*other_money,**proportion_dict)
```
(5)Python函数的参数传递
值传递:如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a) 内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。

引用传递:如 列表,字典。如 fun(list),则是将 list 真正的传过去,修改后fun外部的list也会受影响

python 中一切都是对象,严格意义我们不能说值传递还是引用传递。

#(四)匿名函数
用lambda关键字创建匿名函数
定义:lambda[参数列表]:表达式
匿名函数可以作为参数被传入其他函数

```
#匿名函数
sum = lambda x,y:x+y
print(sum(10,20))
#等价函数
def sum(x,y):
return x + y

#匿名函数作为参数传入到自定义函数中
def x_y_comp(x,y,func):
rs = func(x,y)
print(rs)

x_y_comp(3,5,lambda x,y:x+y)
print("----------------")
x_y_comp(4,7,lambda x,y:x*y)

#匿名函数作为python内置函数的参数使用
user_infos = [{"name":"zhangsan","age":20},{"name":"lisi","age":30},{"name":"wangwu","age":18}]

print(user_infos)
# user_infos.sort(key=lambda info:info["age"])
# print(user_infos)
user_infos.sort(key=lambda info:info["age"],reverse=True)
print(user_infos)
``` 收起阅读 »

第九课 - 冒泡排序,选择排序,快速排序和归并排序

# 冒泡排序
**原理**
(1)循环遍历列表,每次循环找出本次循环最大的元素排在后面
(2)需要使用嵌套循环实现,外层循环控制总循数,内层循环负责每层的循环比较
![](http://wenda.chinahadoop.cn/up ... 63.png)

**算法:**
* 第一轮循环5次 = 循环列表的长度6 - 1,即元素之间比较次数;找出最大元素
* 第二轮循环4次 = 循环列表的长度6 - 找出的最大值个数1 - 1;依次类推。
* 第n轮循环n次 = 循环列表长度 m - 找出的最大值个数 j - 1
* n = 列表元素个数 - 1

**算法实现:**
```
# 排序的总轮数=列表元素个数 - 1
# 每轮元素互相比较的次数 = 列表元素个数 - 已经排好序的元素个数 - 1

#data_list:待排序列表
def bubble_sort(data_list):
num = len(data_list) #列表元素个数
for i in range(0,num -1):#排序的总轮数
print("第{}轮:".format(i))
for j in range(0,num-i-1):
if data_list[j] > data_list[j+1]:#前后两个元素比较
data_list[j],data_list[j+1] = data_list[j+1],data_list[j]
print(data_list)

```
# 选择排序
**原理**
(1)将待排序列表看成是未排序和已排序两部分
(2)每次从未排序列表中找出最小值放到已排序列表末尾
![](http://wenda.chinahadoop.cn/up ... 4d.png)

**算法实现**
```
#data_list:待排序列表
def select_sort(data_list):
list_len = len(data_list) #待排序元素个数
for i in range(0,list_len-1):#控制排序比较总轮数
tmp_min_index = i
for j in range(i+1,list_len):
if data_list[tmp_min_index] > data_list[j]:
tmp_min_index = j
if i != tmp_min_index:
data_list[i],data_list[tmp_min_index] = data_list[tmp_min_index],data_list[i]

print(data_list)
```

# 快速排序
**原理**
(1)一次排序按照一个基准值将待排序的列表分隔成两部分,基准值左边是比基准值小的元素,基准值右边是比基准值大的元素
(2)按照上一步的方法对基准值左右两部分数据分别进行快速排序
![](http://wenda.chinahadoop.cn/up ... 41.png)
**算法实现**
![](http://wenda.chinahadoop.cn/up ... c2.png)


# 归并排序
**原理**
先递归分解序列,再排序合并序列
![](http://wenda.chinahadoop.cn/up ... f4.png)
**算法**
(1)拆分到不能分为止
(2)合并的过程中进行排序
**算法实现**
```
def merge_sort(data_list):
if len(data_list)<=1:
return data_list
#根据列表长度确定拆分的中间位置
mid_index = len(data_list) // 2
# left_list = data_list[:mid_index] #使用切片实现对列表的切分
# right_list = data_list[mid_index:]
left_list = merge_sort(data_list[:mid_index])
right_list = merge_sort(data_list[mid_index:])
return merge(left_list,right_list)

def merge(left_list,right_list):
l_index = 0
r_index = 0
merge_list = []
while l_index < len(left_list) and r_index < len(right_list):
if left_list[l_index] < right_list[r_index]:
merge_list.append(left_list[l_index])
l_index += 1
else:
merge_list.append(right_list[r_index])
r_index += 1

merge_list += left_list[l_index:]
merge_list += right_list[r_index:]
return merge_list
```
**排序算法调用输出:**
```
list = [28,32,14,12,53,42]
#冒泡排序
bubble_sort(list)
#选择排序
select_sort(list)
#快速排序
quick_sort(list,0,len(list)-1)
#归并排序
new_list = merge_sort(list)
print("--------排序结果--------")
print(new_list)
```
继续阅读 »
# 冒泡排序
**原理**
(1)循环遍历列表,每次循环找出本次循环最大的元素排在后面
(2)需要使用嵌套循环实现,外层循环控制总循数,内层循环负责每层的循环比较
![](http://wenda.chinahadoop.cn/up ... 63.png)

**算法:**
* 第一轮循环5次 = 循环列表的长度6 - 1,即元素之间比较次数;找出最大元素
* 第二轮循环4次 = 循环列表的长度6 - 找出的最大值个数1 - 1;依次类推。
* 第n轮循环n次 = 循环列表长度 m - 找出的最大值个数 j - 1
* n = 列表元素个数 - 1

**算法实现:**
```
# 排序的总轮数=列表元素个数 - 1
# 每轮元素互相比较的次数 = 列表元素个数 - 已经排好序的元素个数 - 1

#data_list:待排序列表
def bubble_sort(data_list):
num = len(data_list) #列表元素个数
for i in range(0,num -1):#排序的总轮数
print("第{}轮:".format(i))
for j in range(0,num-i-1):
if data_list[j] > data_list[j+1]:#前后两个元素比较
data_list[j],data_list[j+1] = data_list[j+1],data_list[j]
print(data_list)

```
# 选择排序
**原理**
(1)将待排序列表看成是未排序和已排序两部分
(2)每次从未排序列表中找出最小值放到已排序列表末尾
![](http://wenda.chinahadoop.cn/up ... 4d.png)

**算法实现**
```
#data_list:待排序列表
def select_sort(data_list):
list_len = len(data_list) #待排序元素个数
for i in range(0,list_len-1):#控制排序比较总轮数
tmp_min_index = i
for j in range(i+1,list_len):
if data_list[tmp_min_index] > data_list[j]:
tmp_min_index = j
if i != tmp_min_index:
data_list[i],data_list[tmp_min_index] = data_list[tmp_min_index],data_list[i]

print(data_list)
```

# 快速排序
**原理**
(1)一次排序按照一个基准值将待排序的列表分隔成两部分,基准值左边是比基准值小的元素,基准值右边是比基准值大的元素
(2)按照上一步的方法对基准值左右两部分数据分别进行快速排序
![](http://wenda.chinahadoop.cn/up ... 41.png)
**算法实现**
![](http://wenda.chinahadoop.cn/up ... c2.png)


# 归并排序
**原理**
先递归分解序列,再排序合并序列
![](http://wenda.chinahadoop.cn/up ... f4.png)
**算法**
(1)拆分到不能分为止
(2)合并的过程中进行排序
**算法实现**
```
def merge_sort(data_list):
if len(data_list)<=1:
return data_list
#根据列表长度确定拆分的中间位置
mid_index = len(data_list) // 2
# left_list = data_list[:mid_index] #使用切片实现对列表的切分
# right_list = data_list[mid_index:]
left_list = merge_sort(data_list[:mid_index])
right_list = merge_sort(data_list[mid_index:])
return merge(left_list,right_list)

def merge(left_list,right_list):
l_index = 0
r_index = 0
merge_list = []
while l_index < len(left_list) and r_index < len(right_list):
if left_list[l_index] < right_list[r_index]:
merge_list.append(left_list[l_index])
l_index += 1
else:
merge_list.append(right_list[r_index])
r_index += 1

merge_list += left_list[l_index:]
merge_list += right_list[r_index:]
return merge_list
```
**排序算法调用输出:**
```
list = [28,32,14,12,53,42]
#冒泡排序
bubble_sort(list)
#选择排序
select_sort(list)
#快速排序
quick_sort(list,0,len(list)-1)
#归并排序
new_list = merge_sort(list)
print("--------排序结果--------")
print(new_list)
``` 收起阅读 »

第九课 排序算法

这部分内容我比较熟,本周也才给学生们讲了排序算法,不过我讲的是比较交换法、选择法、冒泡法、插入法排序和希尔排序,所以这次笔记内容更多的是排序算法编写及调用,算法思想要好好悟哦。

IMG_1572(20180430-202408).jpg


IMG_1573(20180430-202417).jpg


IMG_1574(20180430-202427).jpg

 
继续阅读 »
这部分内容我比较熟,本周也才给学生们讲了排序算法,不过我讲的是比较交换法、选择法、冒泡法、插入法排序和希尔排序,所以这次笔记内容更多的是排序算法编写及调用,算法思想要好好悟哦。

IMG_1572(20180430-202408).jpg


IMG_1573(20180430-202417).jpg


IMG_1574(20180430-202427).jpg

  收起阅读 »

第二课:循环、字符串、列表

'''
第二课:循环、字符串、列表
循环语句
字符串操作
列表
项目实践
'''
'''
程序三大执行流程
1、顺序执行
2、选择执行
3、循环执行
'''
#while循环
# num=1
# while num <=10:
# print(num)
# num+=1
#打印倒三角形
# i=0#行号
# while i <4:
# print(" "*i,end="")
# j=0#个数
# while j<7-i*2:
# print("*",end="")
# j+=1
# print("")#实现打印完换行
# i+=1
#打印正三角形
# while i>0:
# i-=1
# print(" "*i,end="")#打印开头空格
# j=0
# while j<7-i*2:
# print("*",end="")
# j+=1
# print("")
#合并打印沙漏
m=7#控制总行数
i=0#
h=0#控制空格数
middle=m//2
# while i<m:
# if i<=middle:
# h=i
# else:
# h-=1
# n=m-h*2
# print(" "*h,end="")
# j=0
# while j<n:
# print("*",end="")
# j+=1
# print("")
# i+=1
'''
for循环
'''
#打印0-9十个数字(左闭右开)
# for i in range (0,10,2):
# print(i)
#break跳出循环
# i=1
# while i<=20:
# if i%2==0:
# if i==0:
# break
# print(i)
# i+=1
#break跳出for循环(结束他所在循环的整个循环)
# for i in range(0,5):
# for j in range(0,i):
# if j==3:
# break
# print("*",end="")
# print("")
# print(i)
#continue跳出本次循环(结束当次循环,如果后面还有循环,会继续进行)
# i=1
# while i<=20:
# i += 1
# if i%2==0:
# if i==0:
# continue
# print(i)
# print("********")
'''
字符串:脚标、切片
'''
#字符串脚标
# s="hello"
# print(len(s))
# print(s[-2])
# for i in range(0,len(s)):
# print(s[i])
#字符串切片
# line="zhangsan,20"
# name=line[0:8]
# print(name)
# age=line[9:]
# print(age)
'''
列表
1、可以顺序存储相同或者不同类型数据的集合
2、可通过下标获取内部元素
3、内容可变,可通过下标修改元素值
4、使用循环遍历列表
5、嵌套列表
'''
# name_list=["LD","BIGRICE","STRAW"]
# print(name_list[0])
# print(name_list[2])
info_list=["LD",23,173]
# print(info_list[0])
# print(info_list[1])
# print(info_list[2])
#while遍历
# i=0
# while i<len(info_list):
# print(info_list[i])
# i+=1
#for遍历
# for i in range(0,len(info_list)):
# print(info_list[i])
#简便方法
# for item in info_list:
# print(item)
#嵌套列表
# infos_list=[["zhangsan",20,178],["lisi",23,180],["dami",22,160]]
# print(infos_list[0][0])
# print(infos_list[1])
#通过嵌套循环读取嵌套列表里面的每一个元素
# for i in infos_list:
# print(i)
# for item in i:
# print(item)
'''
列表
1、append()/insert()添加元素
2“+”组成两个两个列表生成新的列表
3、extend()向调用它的列表中添加另外一个列表的元素
4、del()/pop()/remove()删除元素
5、切片
6、in/not in判断元素在列表中是否存在
7、sort()列表内元素重排序
8、reverse()列表内容倒置
9、count()统计列表内指定元素个数
'''
#append列表末尾添加元素
# infos_list=[["zhangsan",20,178],["lisi",23,180],["dami",22,160]]
# infos_list.append(["xiaobai",23,189])
# print(infos_list)
#insert向列表指定位置添加元素
# new_info=["孙悟空",18,160]
# new_info.insert(1,50)
# print(new_info)
#“+”拼接两个列表
# name_list1=["zhangsan"]
# name_list2=["lisi","wangwu"]
# name_list3=name_list1+name_list2
# print(name_list3)
#extend向一个列表添加另一个列表的元素
# name_list1.extend(name_list2)
# print(name_list1)
#删除列表元素
# group=["唐僧","悟空","八戒","沙僧"]
# del group[1]#删除第几位
# group.remove("悟空")#删除具体人物
# group.pop()#删除最后一个
# print(group)
# if "唐僧" in group:
# print("师傅还在")
# else:
# print("师傅没了")
#sort()升序排列
# num_list=[4,7,6,2]
# num_list.sort()
# print(num_list)
#reverse将列表内容倒置
# num_list=[4,7,6,2]
# num_list.reverse()
# print(num_list)
#count(元素)计算有几个元素
# group=["唐僧","悟空","八戒","沙僧","唐僧"]
# print(group.count("唐僧"))
继续阅读 »
'''
第二课:循环、字符串、列表
循环语句
字符串操作
列表
项目实践
'''
'''
程序三大执行流程
1、顺序执行
2、选择执行
3、循环执行
'''
#while循环
# num=1
# while num <=10:
# print(num)
# num+=1
#打印倒三角形
# i=0#行号
# while i <4:
# print(" "*i,end="")
# j=0#个数
# while j<7-i*2:
# print("*",end="")
# j+=1
# print("")#实现打印完换行
# i+=1
#打印正三角形
# while i>0:
# i-=1
# print(" "*i,end="")#打印开头空格
# j=0
# while j<7-i*2:
# print("*",end="")
# j+=1
# print("")
#合并打印沙漏
m=7#控制总行数
i=0#
h=0#控制空格数
middle=m//2
# while i<m:
# if i<=middle:
# h=i
# else:
# h-=1
# n=m-h*2
# print(" "*h,end="")
# j=0
# while j<n:
# print("*",end="")
# j+=1
# print("")
# i+=1
'''
for循环
'''
#打印0-9十个数字(左闭右开)
# for i in range (0,10,2):
# print(i)
#break跳出循环
# i=1
# while i<=20:
# if i%2==0:
# if i==0:
# break
# print(i)
# i+=1
#break跳出for循环(结束他所在循环的整个循环)
# for i in range(0,5):
# for j in range(0,i):
# if j==3:
# break
# print("*",end="")
# print("")
# print(i)
#continue跳出本次循环(结束当次循环,如果后面还有循环,会继续进行)
# i=1
# while i<=20:
# i += 1
# if i%2==0:
# if i==0:
# continue
# print(i)
# print("********")
'''
字符串:脚标、切片
'''
#字符串脚标
# s="hello"
# print(len(s))
# print(s[-2])
# for i in range(0,len(s)):
# print(s[i])
#字符串切片
# line="zhangsan,20"
# name=line[0:8]
# print(name)
# age=line[9:]
# print(age)
'''
列表
1、可以顺序存储相同或者不同类型数据的集合
2、可通过下标获取内部元素
3、内容可变,可通过下标修改元素值
4、使用循环遍历列表
5、嵌套列表
'''
# name_list=["LD","BIGRICE","STRAW"]
# print(name_list[0])
# print(name_list[2])
info_list=["LD",23,173]
# print(info_list[0])
# print(info_list[1])
# print(info_list[2])
#while遍历
# i=0
# while i<len(info_list):
# print(info_list[i])
# i+=1
#for遍历
# for i in range(0,len(info_list)):
# print(info_list[i])
#简便方法
# for item in info_list:
# print(item)
#嵌套列表
# infos_list=[["zhangsan",20,178],["lisi",23,180],["dami",22,160]]
# print(infos_list[0][0])
# print(infos_list[1])
#通过嵌套循环读取嵌套列表里面的每一个元素
# for i in infos_list:
# print(i)
# for item in i:
# print(item)
'''
列表
1、append()/insert()添加元素
2“+”组成两个两个列表生成新的列表
3、extend()向调用它的列表中添加另外一个列表的元素
4、del()/pop()/remove()删除元素
5、切片
6、in/not in判断元素在列表中是否存在
7、sort()列表内元素重排序
8、reverse()列表内容倒置
9、count()统计列表内指定元素个数
'''
#append列表末尾添加元素
# infos_list=[["zhangsan",20,178],["lisi",23,180],["dami",22,160]]
# infos_list.append(["xiaobai",23,189])
# print(infos_list)
#insert向列表指定位置添加元素
# new_info=["孙悟空",18,160]
# new_info.insert(1,50)
# print(new_info)
#“+”拼接两个列表
# name_list1=["zhangsan"]
# name_list2=["lisi","wangwu"]
# name_list3=name_list1+name_list2
# print(name_list3)
#extend向一个列表添加另一个列表的元素
# name_list1.extend(name_list2)
# print(name_list1)
#删除列表元素
# group=["唐僧","悟空","八戒","沙僧"]
# del group[1]#删除第几位
# group.remove("悟空")#删除具体人物
# group.pop()#删除最后一个
# print(group)
# if "唐僧" in group:
# print("师傅还在")
# else:
# print("师傅没了")
#sort()升序排列
# num_list=[4,7,6,2]
# num_list.sort()
# print(num_list)
#reverse将列表内容倒置
# num_list=[4,7,6,2]
# num_list.reverse()
# print(num_list)
#count(元素)计算有几个元素
# group=["唐僧","悟空","八戒","沙僧","唐僧"]
# print(group.count("唐僧"))
收起阅读 »

第八课 正则表达式

     这节课内容很多,例子很多,可是悲催的是刚听到兴趣正浓的时候停电了……差点气的把桌子掀了。课和笔记都是周五补的,唉,虽然很少遇见停电,但还是希望周六别停电。
IMG_1557(20180427-222236).jpg


IMG_1558(20180427-222244).jpg


IMG_1559(20180427-222252).jpg


IMG_1560(20180427-222300).jpg


IMG_1561(20180427-222307).jpg

 
继续阅读 »
     这节课内容很多,例子很多,可是悲催的是刚听到兴趣正浓的时候停电了……差点气的把桌子掀了。课和笔记都是周五补的,唉,虽然很少遇见停电,但还是希望周六别停电。
IMG_1557(20180427-222236).jpg


IMG_1558(20180427-222244).jpg


IMG_1559(20180427-222252).jpg


IMG_1560(20180427-222300).jpg


IMG_1561(20180427-222307).jpg

  收起阅读 »

第八课 - 正则表达式 (作业)

奶茶馆价格结算系统优化:
1、 使用正则表达式判断顾客输入的手机号是否符合手机号设置规则:
1) 以数字 1 开头
2) 第二位为 3578 中的任意数字
3) 其余 9 位为 0-9 任意数字
2、 输出手机号运营商,判断规则:
 移动运营商:手机号前三位为 134、135、136、137、138、139
 联通运营商:手机号前三位为 130、131、132、155、156、176
 电信运营商:手机号前三位为 133、153、173、177、180、181
```
def OutputPhoneProvider(str):
cell_phone_info = {"(134|135|136|137|138|139)":"China Mobile", "(130|131|132|155|156|176)":"China Unicom", "(133|153|173|177|180|181)":"ChinaTelecom"}
for key in cell_phone_info.keys():
field = re.match(key, str)
if field != None:
print (cell_phone_info[key])
return

phoneNum = input("Please input the cell phone number:")
rs = re.match(r"1[3578]\d{9}$", phoneNum);
if rs != None:
OutputPhoneProvider(phoneNum)
else:
print("others")
```

3、 使用正则表达式判断输入奶茶编号,如果不在 1-5 范围内,输出: Woops!我们只售卖以上五种奶茶哦!新口味敬请期待!
```
import re
teaNum = input("Please input the tea number:")

rs = re.match(r"[1-5]$", teaNum)
if rs == None:
print("Woops! Please re-input the tea number!")
```
继续阅读 »
奶茶馆价格结算系统优化:
1、 使用正则表达式判断顾客输入的手机号是否符合手机号设置规则:
1) 以数字 1 开头
2) 第二位为 3578 中的任意数字
3) 其余 9 位为 0-9 任意数字
2、 输出手机号运营商,判断规则:
 移动运营商:手机号前三位为 134、135、136、137、138、139
 联通运营商:手机号前三位为 130、131、132、155、156、176
 电信运营商:手机号前三位为 133、153、173、177、180、181
```
def OutputPhoneProvider(str):
cell_phone_info = {"(134|135|136|137|138|139)":"China Mobile", "(130|131|132|155|156|176)":"China Unicom", "(133|153|173|177|180|181)":"ChinaTelecom"}
for key in cell_phone_info.keys():
field = re.match(key, str)
if field != None:
print (cell_phone_info[key])
return

phoneNum = input("Please input the cell phone number:")
rs = re.match(r"1[3578]\d{9}$", phoneNum);
if rs != None:
OutputPhoneProvider(phoneNum)
else:
print("others")
```

3、 使用正则表达式判断输入奶茶编号,如果不在 1-5 范围内,输出: Woops!我们只售卖以上五种奶茶哦!新口味敬请期待!
```
import re
teaNum = input("Please input the tea number:")

rs = re.match(r"[1-5]$", teaNum)
if rs == None:
print("Woops! Please re-input the tea number!")
``` 收起阅读 »