Python 学习笔记（三）

发表于

欢迎来到 Python 的世界

程序的控制结构

  • 顺序结构
  • 分支结构
  • 循环结构
二分支结构的紧凑形式

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

1
2
guess = eval(input())
print("猜{}了".format("对" if guess == 11 else "错"))
条件组合
逻辑操作符 描述
x and y 两个条件 x 和 y 的逻辑与
x or y 两个条件 x 和 y 的逻辑或
not x 条件 x 的逻辑非
程序异常处理

基本使用一

1
2
3
4
5
try:
    num = eval(input("请输入一个整数: "))
    print(num**2)
except:
    print("输入不是整数")

基本使用二

1
2
3
4
5
try:
    num = eval(input("请输入一个整数: "))
    print(num**2)
except NameError:
    print("输入不是整数")

高级使用

1
2
3
4
5
6
7
8
9
try:
    num = eval(input("请输入一个整数: "))
    print(num**2)
except:
    print("输入不是整数")
else: # else对应语句块在不发生异常时执行
    print("没有异常")
finally: # finally对应语句块一定执行
    print("异常处理结束")
身体质量指标 BMI 示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
height, weight = eval(input("请输入身高（米）和体重（公斤）[逗号隔开]："))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
who, nat = "", ""
if bmi < 18.5:
    who, nat = "偏瘦", "偏瘦"
elif 18.5 <= bmi < 24:
    who, nat = "正常", "正常"
elif 24 <= bmi < 25:
    who, nat = "正常", "偏胖"
elif 25 <= bmi < 28:
    who, nat = "偏胖", "偏胖"
elif 28 <= bmi < 30:
    who, nat = "偏胖", "肥胖"
else:
    who, nat = "肥胖", "肥胖"
print("BMI 指标为：国际'{0}',国内'{1}'".format(who, nat))

循环结构

  • for in
  • while
break 和 continue
  • break 跳出并结束当前循环，执行循环后的语句
  • continue 结束当次循环，继续执行后续次数循环
  • break 和 continue 可以与 for 和 while 循环搭配使用
循环与 else

当循环没有被 break 语句退出时，执行 else 语句块

1
2
3
4
5
6
7
for c in "PYTHON":
    if c == "T":
        continue
    print(c, end="")
else:
    print("正常退出")
# PYHON正常退出

当循环被 break 语句退出时，不执行 else 语句块

1
2
3
4
5
6
7
for c in "PYTHON":
    if c == "T":
        break
    print(c, end="")
else:
    print("正常退出")
# PY

Random 库

random 库主要用于生成随机数

伪随机数: 采用梅森旋转算法生成的(伪)随机序列中元素

  • seed(a=None) 初始化给定的随机数种子，默认为当前系统时间。每次设置的种子相同，第一次出现的随机数也相同

    1
    random.seed(10) # 产生种子10对应的序列

  • random() 生成一个[0.0, 1.0)之间的随机小数

    1
    print(random.random()) # 0.3892003129270416

  • randint(a, b) 生成一个[a, b]之间的整数

    1
    random.randint(10, 100)

  • randrange(m, n[, k]) 生成一个[m, n)之间以 k 为步长的随机整数

    1
    random.randrange(10, 100, 10) #得到的结果都是10的整数倍

  • getrandbits(k) 生成一个 k 比特长的随机整数

    1
    random.getrandbits(16)

  • uniform(a, b) 生成一个[a, b]之间的随机小数

    1
    random.uniform(10, 100) # 37.06551832446411

  • choice(seq) 从序列 seq 中随机选择一个元素

    1
    random.choice([1,2,3,4,5,6,7,8,9]) # 7

  • shuffle(seq) 将序列seq中元素随机排列，返回打乱后的序列

    1
    2
    3
    s=[1,2,3,4,5,6,7,8,9]; random.shuffle(s); print(s)
    # [7, 2, 5, 8, 3, 1, 9, 4, 6]
    # 写成一排的时候可以用 ;

圆周率的计算示例

采用圆周率的近似计算公式

1
2
3
4
5
6
7
8
9
10
11
pi = 0
N = 100
for k in range(N):
    pi += 1 / pow(16, k) * ( \
        4 / (8 * k + 1) \
        - 2 / (8 * k + 4) \
        - 1 / (8 * k + 5) \
        - 1 / (8 * k + 6))
print("圆周率值是: {}".format(pi))
# 3.141592653589793
# 一行表达式太长，可以用 \ 然后换行接着写

采用蒙特卡罗方法

1
2
3
4
5
6
7
8
9
10
11
12
13
DARTS = 1000 * 1000
hits = 0
start = perf_counter()
for i in range(1, DARTS + 1):
    x, y = random.random(), random.random()
    dist = pow(x**2 + y**2, 0.5)
    if dist <= 1.0:
        hits = hits + 1
pi = 4 * (hits / DARTS)
print("圆周率值是：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter() - start))
# 圆周率值是：3.143376
# 运行时间是：0.70919s

函数

定义

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

作用

  • 降低编程难度
  • 代码复用

可选参数

1
2
3
4
5
6
# 其中 m 是可选参数
def fact(n, m=1):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s // m

可变参数

1
2
3
4
5
6
7
8
# 在参数前面加 * 号表示可变参数，0个或者多个都可以
def fact(n, *b):
    s = 1
    for i in range(1, n + 1):
        s *= i
    for item in b:
        s *= item
    return s

多个返回值

1
2
3
4
5
6
7
8
def fact(n, m=1):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s // m, n, m
print(fact(3)) # (6, 3, 1)
# 函数可以有多个返回值，如果用一个变量存，是一个元组类型
# 上面的例子可以用 a,b,c = fact(3) 这样来存返回的三个值

全局变量和局部变量

  • 基本数据类型，无论是否重名，局部变量与全局变量不同
  • 可以通过 global 保留字在函数内部声明全局变量
  • 组合数据类型（比如列表、字典），如果局部变量未真实创建，则是全局变量

lambda 函数

是一种匿名函数，定义

1
2
3
4
5
6
7
8
9
10
11
<函数名> = lambda <参数>: <表达式>
# 等效
def <函数名>(<参数>) :
    <函数体>
    return <返回值>
# 示例
f = lambda x, y : x + y
print(f(10,15)) # 25

f = lambda : "lambda函数"
print(f()) # lambda函数

####7 段数码管绘制示例

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import turtle
import 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 [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 6, 8] 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 d in date:
        if d == '-':
            turtle.write('年', font=('Arial', 18, "normal"))
            turtle.pencolor('green')
            turtle.fd(40)
        elif d == '=':
            turtle.write('月', font=('Arial', 18, "normal"))
            turtle.pencolor('blue')
            turtle.fd(40)
        elif d == '+':
            turtle.write('日', font=('Arial', 18, "normal"))
        else:
            drawDigit(eval(d))


def getDate():
    return time.strftime("%Y-%m=%d+", time.gmtime())


def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.speed(0)
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(getDate())
    turtle.hideturtle()
    turtle.done()


main()

递归

  • 链条：计算过程存在递归链条
  • 基例：存在一个或多个不需要再次递归的基例

阶乘

1
2
3
4
5
def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1)

斐波那契数列

1
2
3
4
5
def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n - 1) + f(n - 2)

汉诺塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
count = 0

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

    count += 1

hanoi(3, 'A', 'B', 'C')
print(count)

# 1:A->B
# 2:A->C
# 1:B->C
# 3:A->B
# 1:C->A
# 2:C->B
# 1:A->B
# 7

科赫雪花示例

  • 递归思想：函数+分支
  • 递归链条：线段的组合
  • 递归基例：初始线段
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
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(600, 600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    turtle.speed(0)
    level = 3
    n = 3
    for i in range(0, n):
        koch(400, level)
        turtle.right(360 / n)

    turtle.hideturtle()
    turtle.done()

main()

PyInstaller 库的使用

将 .py 源代码转换成无需源代码的可执行文件

官网：http://www.pyinstaller.org/

安装

1
pip3 install pyinstaller

使用

1
pyinstaller -F <文件名.py>

常用参数

参数 描述
-h 查看帮助
–clean 清理打包过程中的临时文件
-D, –onedir 默认值，生成 dist 文件夹
-F, –onefile 在dist文件夹中只生成独立的打包文件
-i <图标文件名 .ico> 指定打包程序使用的图标 ( icon ) 文件