python学习（4-6）

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

四、第四周课程学习

1、程序的分支结构

1.单分支结构

根据判断条件结果而选择不同向前路径的运行方式

if <条件>：
<语句块>

2.二分支结构

根据判断条件结果而选择不同向前路径的运行方式

if <条件>:
  <语句块1>
else:
  <语句块2>

紧凑形式：适用于简单表达式的二分支结构

<表达式1> if <条件> else <表达式2>

3.多分支结构

根据判断条件结果而选择不同向前路径的运行方式

if <条件>:
  <语句块>
elif:
  <语句块>
  ……
else:
  <语句块>

4.条件判断

操作符

5.异常处理

try：
  <语句块1>
except （<异常类型>）：
  <语句块2>

如果出现了异常，则执行语句块2，没有出现则执行语句块1。
如果规定了异常类型，那么只有在出现该异常类型时，才会执行语句块2。

异常处理的高级使用

try :
  <语句块1>
except :
  <语句块2>
else :
  <语句块3>
finally ：
  <语句块4>
#  finally 对应的语句块4一定执行
#  else对应的语句块3在不发生异常时执行

2、实例：身体质量指数BMI

#CalBMIv3.py
height, weight = eval(input("请输入身高（米）和体重\（公斤）[逗号隔开]："))
bmi = weight / pow(height,2)
print("BMI指数数值为：{:.2f}".format(bmi))
who , nat = "",""
if bmi < 18.5:
    who ,nat = "偏瘦" , "偏瘦"
elif bmi >= 18.5 and bmi < 24:
    who ,nat = "正常" , "正常"
elif bmi < 25 and bmi >=24:
    who ,nat = "正常" , "偏胖"
elif bmi < 28 and bmi >=25:
    who ,nat = "偏胖" , "偏胖"
elif bmi >= 18.5:
    who ,nat = "肥胖" , "肥胖"
print("BMI指标为：国际'{0}',国内'{1}'".format(who,nat))

3、程序的循环结构

1.遍历循环

遍历某个结构形成的循环运行方式

for <循环变量> in <遍历结构>
   <语句块>
   

2.无限循环

由条件控制的循环运行方式

while <条件>:
  <语句块>
#反复执行语句块，直到条件不满足时结束

3.循环控制保留字

break和continue
-break跳出并结束当前整个循环，执行循环后的语句（一个break跳出一个循环）
-continue结束当前循环，继续执行后续次数循环

4.循环的高级用法

for <循环变量> in <遍历结构>:
  <语句块>
else :
  <语句块2>

-当循环没有被break语句退出时，执行else语句块
-else语句块作为 正常 完成循环的奖励
-这里else的用法与异常处理中else用法相似

4、random库

random库是使用随机数的python标准库
-伪随机数：采用梅森旋转算法生成的（伪）随机序列中元素
-random库主要用于生成随机数
-使用random库： import random

-基本随机数函数：seed() ,random()
-扩展随机数函数：randint(),getrandbits(),uniform()
               randrange(),choice(),shuffle()

1.基本随机数函数

随机数种子—》梅森旋转算法—》随机序列
给定种子seed，则后续随机数可以复现
不给定，则默认使用当前系统时间，很难复现

2.扩展随机数函数

5、圆周率的计算

公式法

#CalPiV1.py
pi = 0
N = 100
for k in range(N):
  pi = pi + 1/pow(16,k)*(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))
print("圆周率的值为：{:.7f}".format(pi))

蒙特卡洛方法
随机撒点

#CalPiV2.py
from random import random
from time import perf_counter
DARTS= 1000*1000
hits = 0.0
start = perf_counter()
for i in range(1,DARTS+1):
  x,y = random(),random()
  dist = pow(x** 2+y**2,0.5)
  if dist <= 1.0:
      hits += 1
pi = 4 * (hits/DARTS)
print("圆周率的值是：{}".format(pi))
print("运行时间是：{:.5f}S".format(perf_counter()-start))

第九行中的 **表示指数运算，也可以用pow来算，但是不能用^来算，在python中是别的含义

五、第五周课程学习

1.函数的定义与使用

1)函数的理解和定义

函数是一段代码的表示
-函数是一段具有特定功能的、可以重复使用的语句组
-函数是一种功能的抽象，一般函数表达特定功能
-两个作用：降低编程难度和代码复用

def <函数名>(<参数(0个或者多个)>):
    <函数体>
    return <返回值>

函数是IPO的实现，也是完整代码的封装

2)函数的调用

调用时要给出实际参数，替换占位符，运算后给出结果

3)参数个数

函数可以有参数，也可以没有，但必须要有括号

def <函数名>(<非可选参数>，<可选参数>)：
  <函数体>
  return <返回值>

可选参数必须放在非可选参数后面。
函数调用时，参数可以按照位置或者名称方式传递

4)函数的返回值

函数可以返回0个或者多个结果
-return保留字用来传递返回值
-函数可以有返回值，也可以没有，可以有return，也可以没有。

def fact(n,m=1):
  s= 1
  for i in range(1,n+1):
  s *=i
  return s//m , n, m 

或者用

a,b,c = fact(10,5)

也是用元祖方式返回的

5)局部变量和全局变量

在函数体内部使用的变量叫局部变量，而在函数外使用的叫做全局变量。
规则1：局部变量和全局变量是不同变量
-局部变量是函数内部的占位符，与全局变量可能重名但不同
-函数运算结束后，局部变量将被释放
-可以用global保留字在函数内部使用全局变量

规则2：局部变量为组合数据类型，并且未创建，等同于全局变量

使用规则：
-基本数据类型，无论是否重名，局部变量和全局变量不同
-可以通过global保留字在函数内部生命全局变量
-组合数据类型，如果局部变量未真实创建，则是全局变量

6)lambda函数

lambda函数返回函数名作为结果
-lambda函数是一种匿名函数，即没有名字的函数
-使用lambda保留字定义，函数名是返回结果
-lambda函数用于定义简单的、能够在一行内表示的函数

<函数名> = lambda<参数>:<表达式>
#等价于
def <函数名>(<参数>):
    <函数体>
    return <返回值>

2.实例：七段数码管

import turtle,time
def drawGap():
    turtle.penup()
    turtle.fd(5)
def drawLine(draw):
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit):
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [2,3,0,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [2,6,8,0] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)
def drawDate(date):
    turtle.pencolor("red")
    for i in date:
        if i== '-':
          turtle.write("年" ,font=("Arial",18,"normal"))
          turtle.pencolor("green")
          turtle.fd(40)
        elif i == '=':
          turtle.write("月" ,font=("Arial",18,"normal"))
          turtle.pencolor("blue")
          turtle.fd(40)
        elif i == '+':
          turtle.write("日" ,font=("Arial",18,"normal"))
        else:
          drawDigit(eval(i))
def main ():
    turtle.setup(800,350,200,200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(time.strftime("%y-%m=%d+",time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()

3.代码复用和函数递归

函数和对象是代码复用的两种主要形式
函数：将代码命名在代码层面建立了初步抽象
对象：属性和方法< a>.< b>和< a>.< b>()在函数纸上再次组织进行抽象

1)模块化设计

分而治之
-通过函数或者对象封装将程序划分为模块及模块间的表达
-具体包括：主程序、子程序和子程序间关系
-分而治之：一种分而治之，分层抽象，体系化的设计思想

2)紧耦合&松耦合

紧耦合：两个部分之间交流很多，无法独立存在
松耦合：两个部分之间交流很少，可以独立存在
-模块内部紧耦合，模块之间松耦合

3)函数递归的理解

函数定义中调用函数自身的方式
两个关键特征
$$n!=\{\begin{array}{ll}1,& n=0\\ n(n-1)!& otherwise\end{array}$$
-链条：计算过程存在递归链条
-基例：存在一个或多个不需要再次递归的基例
只关心链条，而不是关注问题具体操作，即关心n和n-1之间的关系

4)函数递归实例

将字符串s反转后输出

def rvs(s):
  if s== ""
    return s 
  else :
    return rvs(s[1:])+s[0]

汉诺塔问题

#HanNuoTa.py
count = 0
def hanoi(n,src,dst,mid):
    global count
    if n == 1:
        print("{}:{}->{}".format(1,src,dst))
        count += 1
    else :
        hanoi(n-1,src,mid ,dst)
        print("{}:{}->{}".format(n,src,dst))
        count+=1
        hanoi(n-1,mid,dst,src)

3.PyInstaller库的使用

PyInstaller库是第三方库
-官方网站：http://www.puinstaller.org
-第三方库
-可以使用PIP
打包源代码，要在CMD里面执行，有点意思

4.科赫雪花小包裹

高大上的分形几何（什么鬼）
-分形几何是一种迭代的几何图形，广泛存在自然界中
科赫曲线也叫雪花曲线

#KochDrawV1.py
import turtle
def koch(size,n):
    if n==0:
        turtle.fd(size)
    else :
        for angle in [0,60,-120,60]:
            turtle.left(angle)
            koch(size/3,n-1)
        
def main():
    turtle.setup(800,800)
    turtle.delay(0)
    #turtle.speed(1)
    turtle.penup()
    turtle.goto(-200,100)
    turtle.pendown()
    turtle.pensize(2)
    level = 3
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    turtle.hideturtle()
main()

六、第六周课程学习

1、集合类型及操作

1.集合类型定义

集合是多个元素的无序组合
-集合类型与数学的概念一致
-集合元素之间无需，每个元素唯一，不存在相同元素
-集合元素不可更改，不能是可变数据类型
-用大括号{}表示，元素间用逗号分开
-建立集合用{}或者set函数
-建立空集合类型，必须使用set（）

2.集合操作符

此外还有= ,>=等

3.集合处理方法

可以利用集合无重复的特点，数据去重。

2、序列类型及操作

1.序列类型定义

序列是具有先后关系的一组元素
-序列是一维元素向量，元素类型可以不同
-类似数学元素序列：$s0,s1,...,sn-1$
-元素箭由序号引导，通过标访问序列的特定元素

序列是一个基类类型
演化成字符串类型，元组类型，列表类型，其基本特征在这三种类型中都成立

2.序列类型及其操作

ls = ["Python",123,".io"]
ls[::-1]
可得到
[".io",123,"Python"]

s="python123.io"
s[::-1]
'oi.321nohtyp'

3.元组类型及操作

元组是序列类型的一种扩展
-元组是一种序列类型，一旦创建就不能被修改
-使用小括号()或者tuple()创建，元素间用逗号，分隔
-可以使用或不适用小括号
就是将元素进行有序排列
-继承了序列类型的全部通用操作
-创建后不能修改，所以没有特别的操作
-可以不适用小括号

4.列表类型及其操作

列表是序列类型的一种拓展，十分常用
-列表是一种列表类型，创建后可以随意被修改
-使用方括号[]或者list()创建，元素间用逗号，分隔
-列表中各元素类型可以不同，无长度限制

只有使用了[]或者list()才是真正的创建了一个列表，如果只是用=进行赋值，那么仅仅创建了一个新的名字。

5.序列类型应用场景

-元组用于元素不改变的应用场景，更多用于固定搭配场景
-列表更加灵活，他是最常用的序列类型
-最主要作用：表示一组有序数据，进而操作它们
如果不希望数据被改变，可以变成元组类型

3、基本统计值

-总个数：len()
-求和：for … in
-平均值：求和/总个数
-方差：各个数据与平均数差的平方的和的平均数
-中位数：排序，奇数取中间，偶数…

sorted()函数可以对列表排序（可以用于求中位数）

#CalStatisticsV1.py
def getNum():
    nums = []
    iNumStr = input("请输入数字（回车退出）：")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        iNumStr = input("请输入数字（回车退出）：")
    return nums


def mean(numbers):
    s=0.0
    for num in numbers:
        s = s+ num
    return s/len(numbers)

def dev(numbers,mean):
    sdev =0.0
    for num in numbers:
        sdev = sdev +(num-mean )**2
    return pow(sdev /(len(numbers)-1),0.5)


def median(numbers):
    sorted(numbers)
    size = len (numbers)
    if size%2==0:
        med = (numbers[size//2-1]+numbers[size//2])/2
    else:
        med = numbers[size//2]
    return med

n=getNum()
m=mean(n)
print("平均值：{}，方差：{}，中位数：{}".format(m,dev(n,m),median(n)))

4、字典类型及其操作

理解“映射”
-映射是一种键（索引）和值（数据）的对应
序列类型由0……N整数作为数据的默认索引

字典类型是映射的体现
-键值对：键是数据索引的扩展
-字典是键值对的集合，键值对之间无序
-采用大括号{}和dict（）创建，键值对用：表示

操作函数

5、jieba库概述

是优秀的中文分词第三方库
-中文文本需要通过分词获得单个的词语
-jieba是优秀的中文分词第三方库，需要额外安装
-jieba库提供三种分词模式，最简单只需要掌握一个函数

-利用一个中文词库，确定汉子之间的关联概率
-汉字间概率大的组成词组，形成分词结果
-除了分词，用户还可以添加自定义的词组

-精确模式：吧文本精确的切开，不存在冗余单词
-全模式：吧文本中所有可能的次于都扫描出来，有冗余
-搜索引擎模式：在精确模式基础上，对长词再次切分

6、文本词频统计

英文hamlet词频统计：

#CalHamletV1.py
def getText():
    txt = open("hamlet.txt","r").read()
    txt = txt.lower()
    for ch in '!@#$%^&*()_+|{}":?><,./;~':
        txt = txt.replace(ch," ")
    return txt

hamletTxt = getText()
words = hamletTxt.split()
counts = {}
for word in words:
    counts[word] = counts.get(word,0)+1
items = list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(10):
    word,count = items[i]
    print("{0:<10}{1:>5}".format(word,count))

三国演义人物出场统计（初步）：

#CalThreekingdomsV2.py
import jieba
txt = open("threekingdoms.txt","r",encoding="utf-8").read()  #这段还没讲
excludes = {"将军","却说","荆州","二人","不可","不能","如此","商议","如何","主公"}
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word == "诸葛亮" or word == "孔明曰":
        rword = "孔明"
    elif word == "关公" or word == "云长":
        rword = "关羽"
    elif word == "玄德" or word == "玄德曰":
        rword = "刘备"
    elif word == "孟德" or word == "丞相":
        rword = "曹操"
    else:
        rword = word
    counts[rword] = counts.get(rword,0)+1
    
for word in excludes:
    del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)   #这段还没看懂
for i in range(10):
    word,count = items[i]
    print("{0:<10}{1:>5}".format(word,count))

---