1、for语句--遍历循环

for 循环变量 in 遍历结构：

    语句1

else：

    语句2

2、while语句--无限循环

while 条件：

    语句1

else：

    语句2

3、循环保留字

break：跳出最内层for或while循环，跳出该循环后从循环代码后继续执行

for s in "BIT":
    for i in range(10):
        print(s,end="")
        if s == "T":
            break


"""
BBBBBBBBBBIIIIIIIIIIT
"""

coutinue结束当前当次循环，跳出循环体中下面尚未执行的语句，但是不跳出当前循环

for s in "PYTHON":
    if s == "T":
        continue
    print(s,end="")


"""
PYHON
"""

for s in "PYTHON":
    if s == "T":
        break
    print(s,end="")


"""
PY
"""

4、random库（伪随机数）

5、蒙特卡罗方法求解值

from random import random
from math import sqrt
import time
DARTS = 10000
hits = 0.0
time.perf_counter()
for i in range(1,DARTS+1):
    x,y = random(),random()
    dist = sqrt(x**2 + y**2)
    if dist <= 1.0:
        hits = hits +1
pi = 4 * (hits/DARTS)
print("Pi值是{}。".format(pi))
print("运行时间是：{:5.5}s".format(time.perf_counter()))

"""
Pi值是3.158。
运行时间是：0.044677s
"""

6、异常处理

try：

    语句1

except 异常类型：

    语句2

try:
    num = eval(input("请输入一个整数："))
    print(num **2)
except NameError:
    print("输入错误，请输入一个整数！")

try：

    语句1

except  异常类型1：

    语句2

else：

    语句3

finally：

    语句4

7、函数的定义

函数是具有特定功能的、可重用的语句组，用函数名表示并通过函数名进行功能调用。

使用函数的2个目的：降低编程难度；代码重用

def  函数名   参数：

    函数体

    return 返回值

def happy():
    print("Happy birthday to you!")
def happyB(name):
    happy()
    happy()
    print("Happy birthday,dear{}!".format(name))
    happy()
happyB("Mike")
print()
happyB("Lily")

"""
Happy birthday to you!
Happy birthday to you!
Happy birthday,dearMike!
Happy birthday to you!

Happy birthday to you!
Happy birthday to you!
Happy birthday,dearLicy!
Happy birthday to you!


"""

8、函数的调用

1）调用程序在调用处暂停执行

2）在调用时将实参复制给函数的形参

3）执行函数体语句

4）函数调用结束给出返回值，程序回到调用前的暂停处继续执行

9、lambda函数

lambda是保留字，该函数定义一个匿名函数，意义是将函数名作为函数结果返回

函数名 = lambda  参数列表：表达式

f = lambda x,y : x + y
type(f)
print(f(10,22))


"""
32
"""

10、函数的参数传递

def dup(str,times = 2):
    print(str * times)
dup("knock!")
dup("knock!",4)

"""
knock!knock!
knock!knock!knock!knock!
"""

参数存在默认值，在定义函数时可以直接为这些参数指定默认值；

函数调用时需要按顺序输入参数，可选参数必须定义在非可选参数的后面；

可以设计可变数量参数，通过在参数前增加星号实现，带有星号的可变参数只能出现在参数列表的最后

def vfunc(a, *b):
    print(type(b))
    for n in b:
        a += n
    return a
print(vfunc(1,2,3,4,5))   #1是赋给a的，2、3、4、5是b，b是元组

"""
<class 'tuple'>
15
"""

11、函数的返回值

return语句退回函数并将程序返回到函数被调用的位置继续执行

函数也可以没有return语句，此时不返回值

函数可以有多个return返回多个值

12、函数的变量

程序中的变量有2种：全局变量和局部变量

全局变量：函数之外定义的变量

全局变量：函数内部使用的变量，只在函数内有效

n  = 1
def func(a,b):
    c = a * b
    return c
s = func("knock!",2)
print(c)


"""
Traceback (most recent call last):
  File "F:\Tools\pythonProject\main.py", line 6, in <module>
    print(c)
NameError: name 'c' is not defined
"""

n = 1
def func(a,b):
    n = b
    return a * b
s = func("knock!",2)
print(s,n)

"""
knock!knock! 1
"""

global n 可以将n变为全局变量

ls = []
def func(a,b):
    ls.append(b)
    return a*b
s = func("konck!",2)
print(s,ls)


# konck!konck! [2]

注意列表在func函数调用后发生了变化。这是因为列表等组合数据类型由于操作多个数据，所以他们在使用中有创建和引用的分别。

当列表变量被[]赋值时，这个列表才被真实创建，否则之前都是一次引用。

若func函数内部存在一个已经真实创建过且名称为ls的列表，那么func函数将操作该列表且不会修改全局变量

13、datetime库

提供了一系列由简单到复杂的时间处理方法

1）datetime.now() 获取当前时间和事件对象

2）datetime.utcnow() 获取当前日期和时间对应的UTC世界标准时间

3）datetime(year,month,day,hour,minute,second,microsecond) 构造一个日期和时间对象

4）.min 返回最小时间对象

5）.max 返回最大时间对象

6）.year 返回包含的年份

7）.month 返回包含的月份

8）.day 返回包含的日期

9）.hour 返回包含的小时

10）.minute 返回包含的分钟

11） .second 返回包含的秒钟

12） .microsecond 返回包含的微妙钟

13） .isoformat 采用ISO 8601标准显示时间

14）.isoweekday 根据日期计算星期后返回1-7

15）.strftime 根据格式化字符串format进行格式显示的方法

18、strftime()方法

时间格式化最有效的方式

%Y表示年份，%m表示月份，%B表示月名，%b表示月名缩写

%d表示日期，%A表示星期，%a表示星期缩写，%H表示小时

%I表示小时（12小时制） %p表示上午或者下午 %M表示分钟 %S表示秒

strftime方法格式化字符串的数字左侧会自动补零

19、七段数码管绘制

输入：当前日期的数字形式

处理：根据每个数字绘制七段数码管表示

输出：绘制当前的七段数码表示

import turtle,datetime
def drawLine(draw):
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)
def drawDight(d):
    drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,3,4,5,6,7,8,9,] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)
def drawDate(date):
    for i in date:
        drawDight(eval(i))
def main():
    turtle.setup(800,350,200,200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(datetime.datetime.now().strftime('%Y%m%d'))
    turtle.hideturtle()
main()

20、代码复用和模块化设计

函数封装的直接好处就是代码复用

面向过程是一种以过程描述为主要方法的编程方式

对象是程序的一种高级抽象方式，它将程序代码组织成更高级别的类，对象包括表征对象特征的属性和代表对象操作的方法，即由属性和方法组成。

模块化设计是对程序合理划分功能模块并基于模块设计程序，通常将程序划分为主程序、子程序和子程序间关系

紧耦合：尽可能合理划分功能块，功能块内部耦合紧密

松耦合：模块间关系尽可能简单，功能块之间耦合度低

21、函数递归

函数被函数内部代码调用，即调用函数自身

存在一个或者多个基例，基例不需要再次递归而且它确定的表达式

所有递归链都要以一个或多个基例结尾

# 阶乘
def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n-1)
num = eval(input("请输入一个整数："))
print(fact(abs(int(num))))

#字符串反转

def reverse(s):
    return reverse(s[1:]) + s[0]
reverse("ABC")

"""
RecursionError: maximum recursion depth exceeded 超出基例
"""

def reverse(s):
    if s == "":
        return s
    else:
        return reverse(s[1:]) + s[0]
str = input("请输入一个字符串：")
print(reverse(str))

22、绘制科赫曲线

正整数n代表科赫曲线的阶数，表示生成科赫曲线过程的操作次数，科赫曲线的初始化阶阶数是0，表示一个长度为L的直线。对L分为3段，中间1段被边长为L/3的等边三角形的2个边代替，得到1阶科赫曲线，包含4条线段。重复即刻得到n阶科赫曲线。

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,400)
    turtle.speed(0)
    turtle.penup()
    turtle.goto(-300,-50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600,3)
    turtle.hideturtle()
main()

 23、python内置函数

python提供68个内置函数

24、组合数据类型

可以分为3类：

序列类型：一个元素向量，元素之间存在先后关系，通过序号访问，元素间不排他

集合类型：元素集合，元素间无序，相同元素在集合中唯一存在

映射类型：键-值数据项的组合，每个元素都是一个键值对

25、序列类型

一维元素向量，元素间存在先后关系，通过序号访问

有字符串、元组和列表3种

字符串：单一字符的有序组合

元组：包含0个或多个数据项的不可变序列

列表：可以修改数据项的序列

26、序列类型的操作符和函数

27、元组

一旦创建就不能修改 用圆括号表示

28、集合类型

包含0个或多个数据项的无序组合，元素不可重复，元素类型只能是固定数据类型

能够进行哈希运算的类型都可以作为集合元素

数据类型 set

聚合没有索引和位置的概念，不能分片，用{}表示

29、集合类型操作符

30、映射类型

键对值类型，每个元素都是1个键值对，元素无序。

主要是字典类型。

31、列表类型

list列表是包含0个或多个对象引用的有序序列，属于序列类型。

列表十分灵活，支持多种操作符和函数

32、列表类型的操作

33、基本统计值计算

输入：从用户输入、文件、网络等途径获得一组数据

处理：适当的数据结构和算法

输出：平均值、标准差和中位数

from math import sqrt
def getNum():
    nums = []
    iNumStr = input("请输入数字（直接按回车退出）：")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        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 sqrt(sdev / (len(numbers)-1))
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)))

这个代码在pycharm运行会出现ZeroDivisionError: float division by zero的错误，还在排查原因中

34、字典类型

键对值，见前面介绍，不赘叙。

35、字典类型的操作

36、jieba库

一个第三方中文分词函数库

安装方法：pip install jieba

jieba库支持3种分词模式：

精确模式：将句子最精确分开，最适合文本分析

全模式：把句子中所有可以成词的词语都扫描出来 但是无法消除歧义

搜索引擎模式：在精确模式的基础上对长词再次切分

37、jieba库常用分词函数

38、文本词频统计

统计英文版hamlet的最高10组词频

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))

"""
the        1137
and         963
to          736
of          669
you         546
i           540
a           527
my          513
hamlet      459
in          435

"""

注意文本要放在pythonproject的文件夹里面才能读取txt。文本已放在我的空间可自取。

39、《三国演义》任务出场次数统计

若出现 'utf-8' codec can't decode byte 0xa1 in position 0: invalid start byte很可能是编码的问题，在保存文本的txt时应当选择utf-8的格式，如图。

同上，需要txt文本在空间自取。 

import jieba
txt = open("三国演义.txt","r",encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    else:
        counts[word] = counts.get(word,0) +1
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse=True)
for i in range(15):
    word,count = items[i]
    print("{0:<10}{1:>5}".format(word,count))

"""
Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\14375\AppData\Local\Temp\jieba.cache
Loading model cost 0.561 seconds.
Prefix dict has been built successfully.
曹操          953
孔明          836
将军          772
却说          656
玄德          585
关公          510
丞相          491
二人          469
不可          440
荆州          425
玄德曰         390
孔明曰         390
不能          384
如此          378
张飞          358

"""

升级版

import jieba
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
txt = open("三国演义.txt","r",encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word == '诸葛亮' or 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(5):
    word,count = items[i]
    print("{0:<10}{1:>5}".format(word,count))

原本的作者写的代码逻辑漏洞很大，本来他把丞相直接赋给了曹操，实际上诸葛亮也是丞相，因此很难判断丞相到底指的是曹操还是诸葛亮。而且这个代码也不严谨，所以只能当作娱乐程序，大家不要当真。