视频

作业

基本数据类型

数值运算函数：

  • abs(x):绝对值函数
  • divmod(x,y):商余（x//y,x%y）。divmod(10,3)=(3,1)
  • pow(x,y[,z]):幂余(x**y)%z。3的3的99次方的最后四位，pow(3,pow(3,99),10000)=4587
  • round(x[,d]):四舍五入，d是保留小数位数，默认为0。round(-10.123,2)=-10.12
  • max(x1,x2,…,xn):最大值，返回x1,x2,…,xn中的最大值，n不限。max(1,9,5,4,3)=9
  • min(x1,x2,…,xn):最小值，返回x1,x2,…,xn中的最小值，n不限。min(1,9,5,4,3)=1
  • int(x):将x变成整数，舍弃小数部分。int(123.45)=123,int(“123”)=123
  • float(x):将x变成浮点数，增加小数部分。float(12)=12.0,float(“1.23”)=1.23
  • complex(x):将x变成复数，增加虚数部分complex(4)=4+0j

字符串：

  • 表示：单引号，双引号，一对三单或三双表示多行字符串
  • 序号：正向012，反向 -1-2…
  • 索引：s[0],s[-1]
  • 切片：s[1:3]=s[0,1,2],s[:-1],s[1::2]从1开始步长为2

字符串操作符：

  • x+y：连接两个字符串
  • x*n：复制n次字符串x
  • x in s：如果x是s的字串返回true，否则false
1
2
3
4

#获取星期字符串
weekStr = "一二三四五六日"
weekId = eval(input("请输入星期数字（1-7）:"))
print("星期" + weekStr[weekId-1])

注：evl(input(“请输入数字：")):将输入的字符串类型，去掉两侧的引号，变成数字

字符串处理函数：

  • len(x):字符串的长度
  • str(x):任意类型x所对应的字符串形式
  • hex(x),oct(x):整数x的十六进制或八进制小写形式字符串。hex(425)=“0x1a9”,oct(425)=“0o651”
  • ord(x):将字符变成Unicode编码形式
  • chr(x):将Unicode编码转化成字符形式

字符串处理方法：

  • str.lower()/str.upper():返回字符串的副本，全部字符小写/大写
  • str.split(sp=None):返回一个列表，由str根据sep被分隔的部分组成。“A,B,C”.split(”,")=[“A”,“B”,“C”]
  • str.count(sub):返回子串sub在str中出现的次数。“an apple a day”.count(“a”)=4
  • str.replace(old,new):所有old子串替换为old子串。
  • str.center(width[,fillchar]):字符串str根据宽度width居中，fillchar可选。“python”.center(20,"=")结果为20个字符串的居中位置，其余=填充，"====python===="
  • str.strip(chars):从str中去除其左侧和右侧chars中出现的字符。"= python=".strip(" =np")=“ytho”，去掉子串串左侧和右侧的" “,"=”,“n”,“p”
  • str.join(iter):在iter变量除最后元素外每个元素后都增加一个str。",".join(“12345”)=“1,2,3,4,5"主要用于字符串分隔

字符串类型的格式化：

  • “{}…".format(“hh”):槽，占位符。hh填到{}的位置

槽内部对格式化的配置方式

： <填充> <对齐> <宽度> <,> <.精度> <类型>
引号符号 用于填充的单个字符（默认空格） <左对齐,>右对齐，^居中对齐 槽设定的输出宽度 数字的千位分隔符 浮点数小数精度或字符串最大输出长度 整数类型b,c,d,o,x,X浮点数类型e,E,f,%
  • “{0:=^20}".format(“python”):填充=为20位，使python的第0个参数居中对齐
  • “{0:,.2f}".format(12345.6789):“12,345.68”
  • “{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425):“110101001,∑,425,651,1a9,1A9”
  • “{0:e},{0:E},{0:f},{0:%}".format(3.14):“3.140000e+00,3.140000E+00,3.140000,314.000000%”

time库

  • 时间获取：time(),ctime(),gmtime()

    • time.time():获取当前时间戳，即计算机内部时间值，浮点数。1516939876.602282
    • time.ctime():获取当前时间并以易读方式表示，返回字符串.“Fri Jan 26 12:11:16 2018”
    • time.gmtime():获取当前时间，表示为计算机可处理的时间格式。time.struct_time(tm_year=2018,tm_mon=1,tm_mday=26…)

  • 时间格式化：strftime(),strptime()

    • strftime(tpl,ts):tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量。time.strftime("%Y-%m-%d %H:%M:%S”,time.gmtime()):“2018-01-26 12:55:20”。（%Y：年份1990，%m：月份10，%B月份名称April,%b:月份名称缩写Apr，%d：日期25，%A星期Wednesday，%a：星期缩写Wed，%H：小时（24）14，%I小时（12）2，%p：上下午AM/PM,%M：分钟，%S：秒）
    • strptime(str,tpl):str是字符串形式的时间值，tpl是格式化模板字符串，用来定义输入效果。time.strptime(“2018-01-26 12:55:20”,"%Y-%m-%d %H:%M:%S”):time.struct_time(tm_year=2018,tm_mon=1,tm_mday=26…)

  • 程序计时：sleep(),per_counter()

    • per_counter():返回一个cpu级别的精确时间技术支持，单位为秒，由于这个计数值起点不确定，连续调用差值才有意义。start=time.perf_counter(),end =time.perf_counter(),end-start:22.724423423
    • sleep(s):s拟休眠的时间，单位为秒可以是浮点数

文本进度条：(不同设计函数：修改文本进度条的实现算法)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 单行动态刷新
import time
scale=50
print("执行开始".center(scale//2,"-"))
start = time.perf_counter()

for i in range(scale+1):
    a="*"*i
    b="."*(scale-i)
    c=(i/scale)*100
    dur=time.perf_counter()-start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end="")
    time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,"-"))
# IDLE开发环境并不会刷新，应该使用命令行等类型的工具打开

程序的控制结构

f分支结构：

  • 单分支结构：if …:
  • 二分支结构：if …: else:/紧凑形式：<表达式1> if <条件> else <表达式2> 注：只是表达式而不是语句
  • 多分支结构：if…: elif… : else:

异常处理：

  • try:<…> except:<…>
  • try:<…> expect<异常类型>：<…>
  • try:<> except:<> else:<> finally:<>（finally对应语句块一定会执行，else对应语句块在不发生异常时执行）

height,weight=eval(input(“请输入身高（米）和体重(公斤)[逗号隔开]："))

遍历循环：

  • for in:
  • for i in range(N):0~n-1,range(1,6):12345,range(1,6,2):135
  • 字符串遍历循环：for c in s:
  • 列表遍历循环：for item in ls:
  • 文件遍历循环：for line in fi:

无限循环：

  • while<…>:

循环控制保留字：

  • break:跳出并结束当前整个循环，执行循环后的语句
  • continue：结束当次循环，继续执行后续次数循环

循环的扩展：

  • for <…> in <…> : <…> else : <…>
  • while <…> : <…> else:<…>
  • 当循环没有被break语句退出时，执行else语句块（正常完成循环时执行）

random库

  • 基本随机数函数：seed(),random()
    • seed(a=None):初始化给定的随机数种子，默认为当前系统时间。random.seed(10)#产生种子10对应的随机数
    • random():生成[0.0,1.0)之间的随机小数。random.random() #0.5714025936877234
    • 种子？如果编程中给出了随机种子，只要种子相同产生的随机数（先设定种子再调用random）也是相同的，对于使用随机数的程序可以再现或者复现程序运行的过程。如果不使用随机数种子，那么它使用的是当前系统时间，精确到微秒的，这个时间是很难再现的，所有后面产生的程序运行的结果就是完全随机（直接使用random）的，是我们认为不可再现的。如果我么需要再现随机过程，就设定种子，如果只是用随机数，不关心程序别人复现的结果，就不设定种子。
  • 扩展随机数函数：randint(), getrandbits(), uniform(), randrange(), choice(), shuffle()
    • randint(a,b):生成一个[a,b]之间的整数
    • randrange(m,n[,k]):生成一个[m,n)之间步长为k的随机整数
    • getrandbits(k):生成一个k比特长的随机整数。random.getrandbits(16):37885
    • uniform(a,b):生成一个[a,b]之间的随机小数。（小数点后16位）
    • choice(seq):从序列seq中随机选择一个元素。random.choice([1,2,3,4,5,6,7,8,9])
    • shuffle(seq):将序列中的元素随机排列，返回打乱后的序列。random.shuffle([1,2,3,4,5])

圆周率的计算：

  • 公式法

    1
2
3
4
5
6
7

    pai=0
N=100
for k in range(N):
    pai+=1/pow(16,k)*( \
    4/(8*k+1)-2/(8*k+4)- \
    1/(8*k+5)-1/(8*k+6))
print("圆周率值是：{}".format(pai))

小技巧：一行代码特别长，可以用\进行换行

  • 蒙特卡罗方法

     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

    from random import random
from time import perf_counter
DARTS=100*100
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=hits+1
pai=4*(hits/DARTS)
#圆内点的数量比上总数就是π/4
print("圆周率值是：{}".format(pai))
print("运行时间是：{:.5f}s".format(perf_counter()-start))

函数和代码复现

定义：

1
2
3

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

  • 可选参数传递：函数在定义时可以为某些参数指定默认值，构成可选参数。但是可选参数必须放在非可选参数之后。

  • 可变参数传递：函数定义是可以设计可变数量参数，即不确定参数总数量。def<函数名>(<参数>,*b):

    1
2
3
4
5
6
7
8
9

    def fact(n,*b):
    s=1
    for i in range(1,n+1):
        s*=i
    for item in b:
        s*=item
    return s
fact(10,3)#10886400
fact(10,3,5,8)#435456000

函数传递的两种方式：

  • 函数调用时，参数可以按照位置或名称方式传递

函数返回值：

  • 函数可以返回0个或多个结果
  • return保留字用来传递返回值
  • 函数可以有返回值，也可以没有，可以有return，也可以没有
  • return可以传递0个返回值，也可以传递多个返回值。return s,m,n返回结果为（1,2,3）元组类型

局部变量和全局变量

  • 局部变量：函数内部变量及参数都是

  • 局部变量是函数内部的占位符，与全局可能重名但不同

  • 函数运算结束后，局部变量被释放

  • 可以使用global保留字在函数内部使用全局变量

  • 局部变量为组合数据类型且未创建，等同于全局变量

    1
2
3
4
5
6
7
8
9

    ls=["F","f"]#通过[]真实创建了一个全局变量列表s
def func(a):
    #ls=[]
    #若函数内部创建了ls列表则为局部变量
    ls.append(a)
	#此处ls是列表类型，未真实创建，则等同于全局变量
    return
func("c")#全局变量ls被修改
print(ls)#["F","f","s"]

lambda函数：<函数名> = lambda<参数>:<表达式>

  • 返回函数名作为结果
  • 是一种匿名函数，即没有名字的函数
  • 使用lambda保留字定义，函数名是返回结果
  • 用于定义简单的，能够在一行内表示的函数
  • f=lambda x,y:x+y ->f(10,15)=25
  • 谨慎使用，主要用作一些特定函数或方法的参数

七段数码管绘制：。。。

代码复用：

  • 函数和对象是代码复用的两种主要方式
  • 函数：将代码命名在代码层面建立了初步抽象
  • 对象：属性和方法，在函数之上再次组织抽象

汉诺塔：

三个柱子abc，初始在柱子a通过柱子b到达柱子c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

count=0
#n个圆盘需要移动，源柱子，目标柱子，中间柱子
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)
hanoi(3,"A","C","B")
print(count)

PyInstaller:

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

  • 第三方库,需安装。官网

    1

    pip install pyinstaller

  • 在源代码所在目录下通过window命令行

    1

    pyinstaller -F <文件名.py>

  • 常用参数

    • -h：查看帮助

    • .- - clean:清理打包过程中的临时文件

    • -D,- - onedir:默认值，生成dist文件夹

    • -F，- - onefile:在dist文件夹中只生成独立的打包文件

    • -i <图标文件名.ico>:指定打包程序使用的图标(icon)文件

      1

      pyinstaller -i <图标文件名.ico> -F <文件名.py>

科赫雪花：

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

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)
    level=3
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    
    turtle.hideturte()
main()