CNU 2020级 生科院 PYTHON 部分整理

写在前面的一些说明：

1. 本文章为个人整理与考试等无关，所列重点均为个人理解
2. 所有的程序编写不唯一！不唯一！不唯一！本人提供的非最优解，仅供参考
3. 部分程序提供多种解决思路仅供参考
4. 本文仅提供本人认为的重要内容（用【*】标出）,其他内容请参阅书或PPT
5. 如有错误请提出，本人也随时原意为各位答疑，可以随意联系
6. 如果有些问题问的比较多，我也会继续补充。

第一部分 初识PYTHON语言

第一章 程序设计基本方法

一般程序

一切的开始

print('Hello World')

圆面积的计算

r= 25
area = 3.1415 * r * r
print(area)
print("{:.2f}".format(area))

Turtle绘图库

五角星的绘制

import turtle //导入Turtle库
from turtle import *
color('red', 'red')
begin_fill()
for i in range(5):
    fd(200)
    rt(144)
end_fill()
done()

第二章 PYTHON程序实例解析

命名规则等其他内容自行看书复习

保留字（33个）【*】

注意True False None 首字母大写
以及在判定（比较大小，下同）时
True=1 False=0

True	False	None	–
and	elif	import	raise
as	else	in	return
assert	except	is	try
break	finally	lambda	while
class	for	nonlocal	with
continue	from	not	yield
def	global	or
del	if	pass

语句类型

赋值语句
分支语句
循环语句
函数

注意：分支和循环的冒号！

实例

温度转换【*】

分析每行代码的意义
理解缩进的作用/意义

TempStr = input("请输入带有符号的温度值: ")
if TempStr[-1] in ['F', 'f']:
    C = (eval(TempStr[0:-1]) -32)/1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
    F = 1.8*eval(TempStr[0:-1]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

Python蟒蛇绘制

最好可以知道每个函数的作用~

#PythonDraw.py
import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
    turtle.circle(40, 80)
    turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.done()

第二部分 深入PYTHON语言

第三章 基本数据类型

数据类型

字符串、数字、组合元素类型……

数字类型

2、8、10、16进制 前缀：0b | 0o | 无 | 0x
整数，浮点数（不确定尾数，处理），复数 各自的规则与相互的转换
四则运算的顺序
二元数值操作符的识别
内置数学函数pow() round() int() float() max() min()

字符串类型【*】

序号规则
从左到右0至正无穷
从右到左-1至负无穷

大小比较
比较原理：依靠ASCII码值（不知道ASCII码值？自己查去）
总结：大写字母一律小于小写字母
同类按顺序增大
即 A<B<C<…<Z<a<b<c<…<z

操作

索引：返回字符串中单个字符 <字符串>[M]
“请输入带有符号的温度值: “[0] 或者 TempStr[-1]

切片：返回字符串中一段字符子串 <字符串>[M:N]
[M: N]获取字符串中从M到N【但不包含N】间连续的子字符串
“请输入带有符号的温度值: “[1:3] 或者 TempStr[0:-1]

运算： +、*、in 在字符串运算中的意思
内置函数的运用
len() str() hex() oct() chr() ord()
str.lower()或str.upper()
str.split(sep=None)
str.count(sub)
str.replace(old, new)
str.center(width[,fillchar])
str.strip(chars)
str.join(iter)

Unicode编码 科普内容 但是很有趣
转义符（虽然很重要 但是咱们基本没涉及 故基本无视）

格式化（format）

槽{}的概念和规则

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充的单个字符	< 左对齐	槽设定的输出宽度	数字的千位分隔符	浮点数小数精度或字符串最大输出长度	整数类型
–	–	> 右对齐	–	–	–	b,c, d,o,x,X
–	–	^ 居中对齐	–	–	–	浮点数类型
–	–	–	–	–	–	e, E, f, %

出于系统限制 表格就请凑合看吧=3=（其实还是懒）

强调！！！！
填充是指将输出的内容 填充至指定长度（当长度不满足所写数值时才填充！）
举例：{0:3}是将字符串a填充至3位（字符串默认填充在末尾，数字默认填充在开始）
如果a=‘a’
此时a不满足三位 所以默认填充空格（在这里用—替代空格） 输出’a——’
如果a=‘abcd’ 此时a满足三位 不进行填充，输出为’abcd’
所以，此代码{0:3}只负责填充（即加法），不会进行减法！

判断是否为回文数字

这是我能想到的最简化版本

n=input('请输入数字:')
print('该数字是否为字符串：',n==n[::-1])

天天向上的力量

（通过代码理解各语句的关系和使用方法）

每天1%

dayup= pow(1.001, 365)
daydown= pow(0.999, 365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown

每天5‰

#DayDayUpQ2.py
dayfactor= 0.005
dayup= pow(1+dayfactor, 365)
daydown= pow(1-dayfactor, 365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))

工作日的力量

#DayDayUpQ3.py
dayup=1.0
dayfactor= 0.01
for i in range(365):
   if i % 7 in[6,0]:
       dayup= dayup*(1-dayfactor)
   else:
       dayup= dayup*(1+dayfactor)
print("工作日的力量：{:.2f}".format(dayup))

#DayDayUpQ4.py
def dayUP(df):
    dayup=1.0
    for i in range(365):
       if i % 7 in[6,0]:
           dayup= dayup*(1-0.01)
       else:
           dayup= dayup*(1+df)
    return dayup
dayfactor= 0.01
while dayUP(dayfactor) < 37.78:
    dayfactor+= 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

下面这个是我瞎魔改的 康康就好=3=

a=int(input('周期：'))
d=int(input('总时间：'))
c=int(input('奋斗时间：'))
b=int(input('摸鱼时间：'))
y=float(input('向上变化量：'))
z=float(input('向下变化量：'))
x=1
if b+c==a:
    for i in range(d):
        if i % a in range(c):
            x=(1+y)*x
        else :
            x=(1-z)*x
    print('结果',x)
else :
    print('错误')

文本进度条（不作要求）

基础

import time
scale = 10
print("------执行开始------")
for i in range(scale+1):
    a = '*'* i
    b = '.'* (scale -i)
    c = (i/scale)*100
    print("{:^3.0f}%[{}->{}]".format(c,a,b))
    time.sleep(0.1)
print("------执行结束------")

单行动态刷新

import time
for i in range(101):
    print("\r{:3}%".format(i), end="")
    time.sleep(0.1)

整合

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

第四章 程序的控制结构

程序流程图

参阅书和PPT

分支结构

单分支结构（少见）
二分支结构（简易形式）
多分支结构
注意冒号！！！！

操作符与三个保留字

循环结构

遍历循环 for … in …
无限循环 while （可以设定条件执行有限次的循环）
两个保留字：
break跳出并结束当前整个循环，执行循环后的语句
continue结束当次循环，继续执行后续次数循环
二者都只对最内层循环起作用

异常处理（低要求）

学会查看错误提示（包括错误类型，错误原因，发生位置，有助于你修改程序）
try、except的应用（依旧是 注意冒号！！！）

random库

几个常用函数（万一又让你生成随机数呢…）
random()
randint()

身体质量指数BMI

PPT里是图片 我也懒得手敲了 =3=

PM指数

a=eval(input('PM数值：'))
if 0<=a<50:
    print('优秀')
elif 50<=a<100:
    print('良好')
else:
    print('污染')

π 的计算（不作要求）

近似计算公式

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=

生成随机密码

#生成随机密码
from random import choice
import string #一个库 这个库可以理解为用几个字母的函数来表示a-z，A-Z，0-9
def GenPassword(length=8,chars=string.ascii_letters+string.digits):
    return ''.join([choice(chars) for i in range(length)])
 
if __name__=="__main__":
    #生成10个随机密码   
    for i in range(10):
        #密码的长度为8
        print(GenPassword(8))

第五章 函数和代码复用

基础

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
也就是说你用def()定义的函数和print()等本质是一个东西
函数在定义之后只有调用！调用！调用！才会有作用！（你问我什么是调用？罚你回去抄书！）（我寻思我这一个月发现好几个因为不调用/调用不对而出错的）
什么？你问我什么是调用？罚你回去抄书！（生气

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

lambda

因为一些（可能超纲的 ）原因，要谨慎使用（说白了就是不用会写，但你要能认出别人写的 ）lambda函数

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

等价于

def  <函数名>(<参数>)：
        <函数体>
       return <返回值>

参数

函数可以有参数，也可以没有，但必须保留括号
区分实参（有实际意义的参数）和虚参（虚假的参数，只用来占位）
参数的传递（名字，顺序）
即必须以 def 函数名() 的形式出现 括号不能省略
括号后面要有冒号！！！！！！

函数定义时可以为某些参数指定默认值，构成可选参数

def  函数名(非可选参数，可选参数)：
        函数体（即函数内容）
        return 返回值

return 后面的返回值可有0至n多个（默认以元组形式返回），0就是没有返回值（你甚至可以不写return 233）
^{（但是没有return你调用这个函数为了什么呢？这就相当于你让你同学帮你算1+1，你的同学只告诉你他算完了，但并不告诉你结果（你没有return计算机甚至都不告诉你他算完了，除非你写进去-1-）（虽然有时候也有一些别的目的，但是不展开说了））}

变量

全局变量与局部变量（不理解的还是直接问吧，变量能说一年（雾））
二者不同，当局部变量含有未创建的组合数据类型等同于全局变量，
global的使用

代码复用和模块化设计

这一节在编程中（尤其是大程序（就像下面那个七段数码管那么大（其实它很小 ）的程序））十分重要，但是吧，咱们课上几乎就没怎么用，各位也没有机会写这种程序，就被迫显得没那么重要了orz，但是这种模块化的思维，真的很重要。

模块内部紧耦合、模块之间松耦合（其他的我就不强调了）

递归【*】

由函数+分支结构构成
会认 会写 虽然这个玩意执行速度并不快，但依然很重要
递归，理解成套娃就好了，但是这个套娃最里面必须得有奖品（基例），不能是空的

n的阶乘

def fact(date):   
    if n == 0 :
        return 1
    else :
        return n*fact(n-1)

字符串反转

[::-1]比递归香多了（

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

斐波那契数列

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

科赫曲线的绘制1[一段]

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.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600, 3)      # 3阶科赫曲线，阶数
    turtle.hideturtle()
main()

科赫曲线的绘制2[封闭]

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      # 3阶科赫雪花，阶数
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.hideturtle()
main()

七段数码管的绘制

没啥内容，给你们放一个可以伪实时刷新的代码，运行玩玩（如果不是实时刷新的，请去问你的Python，至少我这里是时时刷新 ）

#绘制七段数码管，动态显示当前时间
from turtle import *
from datetime import datetime
from time import sleep
#绘制数码管间的空白间隔
def drawGap():
    up()
    fd(5)
#绘制单段数码管，方向控制
def drawLine(draw):   
    drawGap()
    down() if draw== True else up()   
    fd(40)   
    drawGap()   
    right(90)
#根据数字绘制数码管
def drawDigit(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)   
    left(90)    #第4段到第5段无需右转，相当于修正了方向   
    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)   
    left(180)   
    up()   
    fd(20)
#绘制当前时间
def drawDate(date):   
    pencolor("red")   
    for i in date:       
        if i == '-':           
            write('年',font=('Arial',18,'normal'))           
            pencolor('orange')           
            fd(40)       
        elif i == '=':           
            write('月',font=('Arial',18,'normal'))           
            pencolor('yellow')           
            fd(40)       
        elif i == '+':           
            write('日',font=('Arial',18,'normal'))           
            pencolor('green')           
            fd(40)       
        elif i == '*':           
            write('时',font=('Arial',18,'normal'))           
            pencolor('blue')           
            fd(40)       
        elif i == '#':           
            write('分',font=('Arial',18,'normal'))           
            pencolor('purple')           
            fd(40)       
        elif i == '?':           
            write('秒',font=('Arial',18,'normal'))           
            fd(40)       
        else:           
            drawDigit(eval(i))
#主函数
def main():   
    setup(1300,280,50,300)   
    speed(0)   
    up()   
    fd(-600)   
    pensize(5)   
    while(1):       
        penup()       
        goto(-600,0)       
        pendown()       
        tracer(False)       
        pencolor('red')       
        drawDate(datetime.now().strftime('%Y-%m=%d+%H*%M#%S?'))    #获取当前系统时间         
        hideturtle()       
        sleep(1)       
        clear()  #清屏   
    done()
main()

第六章 组合数据类型

序列类型（字符串str，元组tuple，列表list）、集合类型（集合set）和映射类型（字典map）
各部分的操作暂略

序列类型

具有先后关系
可以存在相同数值但位置不同的元素
元组用 () 和 tuple() 创建，列表用 [] 和 list() 创建
6个通用操作符 5个函数和方法
特别注意了列表类型17个操作函数和方法

集合类型

无序，每个元素唯一,不能是可变数据类型
集合用大括号 {} 表示，元素间用 逗号 分隔
建立集合类型用 {} 或 set()
建立空集合类型，必须使用 set()
6个操作符 4个增强操作符 处理方法10个
主要应用于：包含关系比较、数据去重

字典类型

理解“映射” 键(索引)和值(数据)
键值对：键是数据索引的扩展
字典是键值对的集合，键值对之间无序
采用大括号 {} 和 dict() 创建，键值对用冒号: 表示
13个操作函数和方法

jieba库

了解即可

文本词频统计

了解

最后再给大家推荐一个小网址
https://www.runoob.com/python3/python3-list.html
进去就知道了，毕竟人家叫“菜鸟教程”应该都能看得懂吧=3=