Python基本内置函数及常用库汇总（加用法）

在初学Python时的基础内置函数汇总

---

微信关注公众号：夜寒信息
致力于为每一位用户免费提供更优质技术帮助与资源供给，感谢支持！

---

  最近暑假想学习Python，为了让自己未来的就业多一分竞争力，也为了让自己掌握多一项技能，于是就去看了大学MOOC嵩天老师的Python程序设计基础。课程内容很不错，讲的细致全面，由浅入深，最后的思维提高也令人深思，但我的脑子老化生锈记不住函数，再加上懒惰不去背记，忘得很快，于是写这个博客帮助自己背记。

此博文后续持续更新中…

Python中的33个保留字

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

---

一、Python的基本语法元素

#
井号是注释的标志符号，用于单行注释

"""
一对三引号为多行注释，Python中并无特定的多行注释，双三引号为字符串，但在程序中单独出现字符串却并未赋值给变量则不做理会，于是可以用作注释

TempStr[-1]
<字符串>[M] 形式，索引，使用[ ]返回字符串中单个字符，此例表示从第-1个字符

TempStr[0:-1]
<字符串>[M] 形式，切片，使用[ ]返回字符串中一串字符子串，此例表示从开始但不到-1的字符串

[‘F’,‘f’]
列表，使用[ ]表示，采用(,)分隔各元素，此例表示列表中两元素’F’和’f’

’f’in [‘F’,‘f’]
保留字，用于判断前者是否与列表中某个元素相同，存在返回True，不存在返回False，此例中返回True

if
分支语句，如果条件为True则执行冒号后语句，分支语句后加冒号，冒号不可省略
elif
分支语句，如果条件为True则执行冒号后语句，分支语句后加冒号，冒号不可省略
else
分支语句，配合if,elif使用如果if,elif皆不成立则执行冒号后语句，分支语句后加冒号，冒号不可省略

input(“input:”)
输入函数，从控制台获得用户输入，引号内为提示信息，此例显示input:然后接收用户输入，以字符串形式保存于变量中

print(“a”)
输出函数，打印输出括号内容，此例中显示字符串a

print("{.2f}".format(a))
print函数格式化输出，{}表示槽，此例表示将变量a填充到槽位置时取小数点后两位

eval(“1+2”)
评估函数，去掉参数最外侧引号并执行余下语句函数,此例为语句1+2，输出3

正向递增序号和反向递减序号图例

例题：摄氏度转华氏度

输入带符号的摄氏度温度值或华氏度温度值，转化后输出对应带符号的华氏度温度值或摄氏度温度

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("输入格式错误")

例题：Hello World的条件输出

获得用户输入的一个整数，参考该整数值，打印输出"Hello World"，要求：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
如果输入值是0，直接输出"Hello World"‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
如果输入值大于0，以两个字符一行方式输出"Hello World"（空格也是字符）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
如果输入值小于0，以垂直方式输出"Hello World"

s = "Hello World"
n = int(input())
if n==0:
    print(s)
elif n>0:
    st =""
    for n in range(len(s)):
        if(n+1)%2 != 0:
            st = st+s[n]
            if len(s)==(n+1):
                print(st)
        else:
            st = st+s[n]
            print(st)
            st=""
else:
    for n in s:
        print(n)

例题：数值运算

获得用户输入的一个字符串，格式如下：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
M OP N‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
其中，M和N是任何数字，OP代表一种操作，表示为如下四种：+，-，*，/（加减乘除）‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
根据OP，输出M OP N的运算结果，统一保存小数点后2位。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
注意：M和OP、OP和N之间可以存在多个空格，不考虑输入错误情况。

s = input()
print("{:.2f}".format(eval(s)))

---

二、Python基本图形绘制

import<库名>
保留字，用于引入一个库
同样可用from<库名>import<函数名> 不需要加<库名>.
    from<库名>import * 不需要加<库名>.
    import<库名>as<库别名>使用<库名>.<库别名>

turtle.setup(width, height, startx, starty)
用于设置窗体大小及位置，width和height是窗体宽和高，x和y是窗体左上角起始位置坐标

turtle.goto(x, y)
让任意位置的海龟到达指定的坐标位置去

turtle.fd(d)
向海龟的正前方向运行，d是距离，d为负数时反方向

turtle.bk(d)
向海龟的反方向运行，d是距离，d为负数时反方向

turtle.circle(r, extent=None)
以海龟左侧的某一个点为圆心进行曲线运行，r为半径，ectent为运行的弧的角度

turtle.seth(angle)
改变绝对角度海龟的行进方向 angle为绝对角度

turtle.left(angle)
让当前海龟向左改变运行方向，angle为行进方向上改变的角度

turtle.right(angle)
让当前海龟向右改变运行方向，angle为行进方向上改变的角度

turtle.penup()
别名**turtle.pu()**抬起画笔，海归在飞行轨迹不形成图案

turtle.pendown()
别名**turtle.pd()**落下画笔，海龟再爬行轨迹形成图案

turtle.pensize(width)
别名**turtle.width(width)**画笔宽度，海龟的腰围

turtle.down()
海龟绘图程序运行结束后不会退出，需手工关闭窗体退出

turtle.colormode(mode)
turtle的RGB色彩模式，1.0为RGB小数模式，255为RGB整数模式

turtle.pencolor(color)
画笔颜色，可以通过字符串或RGB值来赋予颜色
例：turtle.pencolor(“purple”) 颜色字符串
  turtle.pencolor(0.63, 0.13, 0.94) RGB小数值
  turtle.pencolor((0.63, 0.13, 0.94)) RGB元组值

for<变量>in range(<参数>):
  <被循环执行的语句>
循环语句，将被执行语句循环参数减1次，冒号不可省略

range(N)
产生从0到N-1的整数序列共N个

range(M,N)
产生M到N-1的整数序列，共N-M个

海归绘图的绝对角度图例

海龟绘图的绝对坐标系图例

海龟绘图的海龟坐标系图例

Python蟒蛇绘制实例

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.down()

例题：turtle八边形绘制

使用turtle库，绘制一个八边形。

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(100)
    t.left(45)

例题：turtle八角图形绘制

使用turtle库，绘制一个八角图形。

import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(150)
    t.left(135)

---

三、基本数据类型

round(x,d)
对x四舍五入，d是小数截取位数

pow(x,y)
幂运算，计算x^y，例：pow(3,2)=9

< a >e< b >或< a >E< b >
表示a*10^b(a乘10的b次方)

12+3j
j为复数，例z=12+3j：z.real获得实部12
          z.imag获得虚部3

+，-，*，/
加，减，乘，除四种运算操作符

x//y整除，例：10//3=3

x%y余数，模运算，例：10%3=1

xy幂运算，例：32=3^2=9

abs(x)
求解x的绝对值

divmod(x,y)
商余操作，同时输出商和余数，例：divmod(10,3)=(3,1)

pow(x,y,z)
幂余操作，例：pow(3,3,26)=(3**3)%26=1

max(x1,x2,…,xn)
最大值，例：max(1,5,9,6,2)=9

min(x1,x2,…,xn)
最小值，例：min(1,5,9,6,2)=1

int(x)
将x变为整数，舍弃小数部分

float(x)
将x变为浮点数，增加小数部分

complex(x)
将x变成复数，增加虚数部分

<字符串>[M:N:K]
根据步长K对字符串切片

<字符串>[::-1]
将字符串逆序输出

**
转义符，变大特定字符的本意，也可组合，例：
\b回退
\n换行（光标移动到下行首）
\r回车（光标移动到本行首）

x+y
连接两个字符串x和y

nx或xn
复制n次字符串x

x in s
如果x是s的子串，返回True,否则反回False

len(x)
长度，返回字符串x的长度

str(x)
返回任意类型x所对应字符串形式

hex(x)或oct(x)
整数x的十六进制或八进制小写形式字符串

chr(u)或ord(x)
u为Unicode编码，x为字符，返回其对应的字符或Unnicode编码

str.lower()或str.upper()
返回字符串的副本，全部字符小写或大写
例：“AbCdEf”.lower="abcdef"

str.split(sep=None)
返回一个列表，由str根据sep被分隔的部分组成
例：“A,B,C”.split(",")结果为[‘A’,‘B’,‘C’]

str.count(sub)
返回字串在str中出现的次数
例：“an apple”.count(“a”)=4

str.replace(old,new)
返回字符串str副本，所有old子串被替换为new
例：“python”.replace(“n”,“p”)=pythop

str.center(width,fillchar)
字符串str根据宽度width居中，fillchar可选
例：“python”.center(20,"=")=’=python='

str.strip(chars)
从str中去掉在其左侧和右侧chars中列出的字符串
例：“python”.strip(“po”)="ythn"

str.join(iter)
在iter变量除最后元素外每个元素后增加一个str
例：",".join(“12345”)="1,2,3,4,5"

<模板字符串>.format(<逗号分隔的参数>)
字符串格式化处理方法函数
可搭配槽{}使用


槽可以搭配冒号进行参数格式控制

Time库的使用

time()
获取当前时间戳，即计算机内部时间值，浮点数
例：time.time()=1581771893.6198866

ctime()
获取当前时间并以易读方式表示，返回字符串
例：time.ctime()='Sat Feb 15 21:06:37 2020’

gmtime()
获取当前时间，表示为计算机课处理的时间格式
例：time.gmtime()=time.struct_time(tm_year=2020, tm_mon=2, tm_mday=15, tm_hour=13, tm_min=8, tm_sec=26, tm_wday=5, tm_yday=46, tm_isdst=0)

strftime(tpl,ts)
tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
例：t=time.gmtime()
  time.strftime("%Y-%m-%d %H:%M:%S",t)=2020-02-15 13:17:03

%<字符串>
时间格式化


strptime(str,tpl)
str是字符串形式的时间值，tpl是格式化模板字符串，用来定义输入效果
例：timeStr=‘2020-02-15 13:27:03’
  time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")=time.struct_time(tm_year=2020, tm_mon=2, tm_mday=15, tm_hour=13, tm_min=27, tm_sec=3, tm_wday=5, tm_yday=46, tm_isdst=-1)

perf_counter()
返回一个CPU级别的精确时间计数值，单位为秒由于这个计数值起点不确定，连续调用差值才有意义
例：start=time.perf_counter()=0.3203189
  end=time.perf_counter()=107.5258944
  end-start=107.2055755

sleep(s)
s拟休眠时间，程序休眠等待，单位是秒，可以是浮点数

print(,end=“str”)
在输出的字符串后增加str的信息，str可以为空，加入end后print函数不自动换行

文本进度条实例

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

例题：平方根格式化

获得用户输入的一个整数a，计算a的平方根，保留小数点后3位，并打印输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
输出结果采用宽度30个字符、右对齐输出、多余字符采用加号(+)填充。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
如果结果超过30个字符，则以结果宽度为准。

s=eval(input())
d=pow(s,0.5)
print("{:+>30.3f}".format(d))

例题：字符串分段组合

获得输入的一个字符串s，以字符减号(-)分割s，将其中首尾两段用加号(+)组合后输出。

s=input()
l=s.split('-')
print(l[0]+'+'+l[-1])

---

四、程序控制结构

try :
　　<语句块1>
except :
　　<语句块2>
异常处理，将要执行的语句放在语句块1中，如果语句块1执行过程中出现异常则执行语句块2，如果不出现异常则不执行语句块2，继续执行后续语句。

try :
　　<语句块1>
except <异常类型>:
　　<语句块2>
异常处理，将要执行的语句放在语句块1中，如果语句块1执行过程中出现**<异常类型>**中的异常则执行语句块2，如果不出现则不执行语句块2，继续执行后续语句，如果出现其他类型异常则报错。

try :
　　<语句块1>
except <异常类型>:
　　<语句块2>
else :
　　<语句块3>
finally :
　　<语句块4>
异常处理，程序首先执行语句块1，不发生异常则执行语句块3，若发生异常则执行语句块2，不论是否发生异常都执行语句块4

continue
结束档次循环，继续执行后续循环
例：for c in “Python”:
　　　　if c==“t”:
　　　　　　continue
　　　　print(c,end="")
>>> Pyhon

break
结束整个循环
例：for c in “Python”:
　　　　if c==“t”:
　　　　　　break
　　　　print(c,end="")
>>> Py

for <循环条件>
　　<语句块1>
else:
　　<语句块2>
当循环没有被break语句退出时，执行else语句块，当被break打断时则不执行else语句块

random库的使用

seed(a=None)
初始化给定的随机数种子，可复现，默认为当前系统时间

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

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

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

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

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

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

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

身体质量数BMI

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

蒙特卡洛方法(撒点)计算圆周率

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 = hits +1
pi = 4 * (hits/DARTS)
print("圆周率值是：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter()-start))

四位玫瑰数

四位玫瑰数是4位数的自幂数。自幂数是指一个Ñ位数，它的每个位上的数字的Ñ次幂之和等于它本身。 ‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮ ‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
例如：当n为3时，有1 ^ 3 + 5 ^ 3 + 3 ^ 3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬ ‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行。

for i in range(1000,10000):
    t=str(i)
    if pow(eval(t[0]),4)+pow(eval(t[1]),4)+pow(eval(t[2]),4)+pow(eval(t[3]),4)==i:
        print(i)

100以内素数之和

求100以内所有素数之和并输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
素数指从大于1，且仅能被1和自己整除的整数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
提示：可以逐一判断100以内每个数是否为素数，然后求和。

sum = 2
for i in range(3,100):
    for j in range(2,i):
        if i % j == 0:
            break
    else:    #同样else与for对齐
        sum += i
 
print(sum)

---

五、函数和代码复用

def <函数名>(<非可选参数>,<可选参数>):
可选参数，定义函数时可以为某些参数指定默认值，构成可选参数(可有可无)，可选参数必须放在必选参数后面
例：def fact(n,m-1):　　　　　　　　　>>>fact(10)
　　　　s=1　　　　　　　　　　　　 3628800
　　　　for i in range(1,n+1):
　　　　　　s*=i　　　　　　　　　　 >>>fac(10,5)
　　　　return s//m　　　　　　　　　725760

def <函数名>(<参数>, *b):
可变参数，函数定义时可以设计可变参数，即不确定参数的数量，可变参数必须放在必选参数后面
例：def fact(n,*b):　　　　　　　　　 >>>fact(10,3)
　　　　s=1　　　　　　　　　　　　 10886400
　　　　for i in range(1,n+1):
　　　　　　s*=i　　　　　　　　　  >>>fac(10,3,5,8)
　　　　for item in b:　　　　　　　　435456000
　　　　　　s*=item
　　　　return s

<函数名>=lambda<参数>:<表达式>
函数的紧凑表达形式
例：>>>f=lambda x,y:x+y
　　>>>f(10,15)
　　25

PyInstaller库的使用

(cmd命令行) pyinstaller -F <文件名.py>
将Python文件打包成exe文件

-h
查看帮助

–clean
清理打包过程中的临时文件

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

-F,–onefile
在dist文件夹中只生成独立的打包文件

-i <图标文件名.ico>
指定打包程序使用的图标(icon)文件
例：pyinstaller -i curve.ico -F Test.py

七段数码管绘制实例

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

汉诺塔问题

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)
hanoi(3, "A", "C", "B")
print(count)

科赫曲线小包裹

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.hideturtle()
main()

随机密码生成

补充编程模板中代码，完成如下功能：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
以整数17为随机数种子，获取用户输入整数N为长度，产生3个长度为N位的密码，密码的每位是一个数字。每个密码单独一行输出。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
产生密码采用random.randint()函数。

import random

def genpwd(length):
    a = 10**(length-1)
    b = 10**length - 1
    return "{}".format(random.randint(a, b))

length = eval(input())
random.seed(17)
for i in range(3):
    print(genpwd(length))

连续质数计算

补充编程模板中代码，完成如下功能：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
获得用户输入数字N，计算并输出从N开始的5个质数，单行输出，质数间用逗号,分割。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
注意：需要考虑用户输入的数字N可能是浮点数，应对输入取整数；最后一个输出后不用逗号。

def prime(m):
    for i in range(2,m):
        if m % i == 0:
            return False
    return True

n = eval(input())
n_ = int(n)
n_ = n_+1 if n_ < n else n_
count = 5

while count > 0:
    if prime(n_):
        if count > 1:
            print(n_, end=",")
        else:
            print(n_, end="")
        count -= 1 
    n_ += 1

组合数据类型

集合

集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型(被放到集合中的元素不可被修改

集合使用{}建立
例：>>>A={“python”,123,(“python”,123)}
　　{123,‘python’,(‘python’,123)}

使用set()建立集合（空集合只能用set()建立）
例：>>>B=set(“pypy123”)
　　{‘1’,‘p’,‘2’,‘3’,‘y’}

S|T
返回一个集合，包括在集合S和T中的所有元素并

S-T
返回一个集合，包括在集合S但不在T中的元素减

S&T
返回一个集合，包括同时在集合S和T中的元素并

S^T
返回一个集合，包括集合S和T中的非相同元素补

>,=,<,>=,<=
关系操作符，返回True或False

|=,-=,&=,^=
增强操作符，用于更新S中的元素
例：**S^=T　用S和T补运算的结果更新集合元素 **

S.add(x)
如果x不在集合S中，将x增加到S

S.discard(x)
移除S中的元素x，如果x不在集合S中，不报错

S.remove(x)
移除S中元素x，如果x不在集合S中，产生KeyError异常

S.clear()
移除S中所有元素

S.pop()
随即返回S的一个元素，更新S，若S为空产生KeyError异常

S.copy
返回集合S的一个副本

len(S)
返回集合S的元素个数

x in S
判断S中元素x，x在集合S中，返回True，否则返回False

x not in S
判断S中元素x，x不在集合S中，返回True，否则返回False

set(x)
将其他类型变量x转变为集合类型

序列

序列是一维元素向量，元素类型可以不同
类似数学元素序列：S0,S1,…,Sn-1
元素间由序号引导，通过下标访问序列的特定元素

len(s)
返回序列s的长度

min(s)
返回序列s的最小元素，s中元素需要可比较

max(s)
返回序列s的最大元素，s中元素需要可比较

s.index(x)或s.index(x,i,j)
返回序列s从i开始到j位置中第一次出现元素x的位置

s.count(x)
返回s中出现x元素的总次数

元组

元组是一种序列类型，一旦创建就不能被修改
使用小括号()或tuple()创建，元素间用逗号，分隔
可以使用或不使用小括号

元组类型继承了序列的所有操作

列表

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

ls[i]=x
替换列表ls第i元素为x

ls[i:j:k]=lt
用列表lt替换ls切片后所对应的元素子列表

del ls[i]
删除列表ls中第i元素

del ls[i:j:k]
删除列表ls中第i到第j以k为步长的元素

ls+=lt
更新列表ls，将列表lt元素增加到列表ls中

ls=n*
更新列表ls，其元素重复n次

ls.append(x)
在列表ls最后增加一个元素x

ls.clear()
删除列表ls中所有元素

ls.copy()
生成一个新列表，赋值ls中所有元素

ls.insert(i,x)
在列表ls第i位置增加元素x

ls.pop(i)
将列表ls中第i位置元素取出并删除该元素

ls.remove(x)
将列表ls中出现的第一个元素x删除

ls.reverse()
将列表ls中的元素反转

sorted(ls)
对列表ls按从小到大排序

字典

字典类型是"映射"的体现
键值对：键是数据索引的扩展
字典是键值对的集合，键值对之间无序
采用大括号{}和dict()创见，键值对用冒号:表示

del d[k]
删除字典d中键k对应的数据值

k in d
判断键k是否存在字典d中，如果在返回True，否则返回False

d.keys()
返回字典d中所有的键信息

d.values
返回字典d中所有的值信息

d.items()
返回字典d中所有的键值对信息

d.get(k,< default >)
键k存在，则返回相应值，不存在则返回< default >值

d.pop(k,< default >)
键k存在，则取出相应值，不存在则返回< default >值

d.popitem()
随即从字典d中取出一个键值对，以元组形式返回

d.clear()
删除所有键值对

len(d)
返回字典d中元素的个数

jieba库

jieba.lcut(s)
精确模式，返回一个列表类型的分词结果

jieba.lcut(s,cut_all=True)
全模式，返回一个列表类型的分词结果，存在冗余

jieba.lcut_for_searxc(s)
搜索引擎模式，返回一个列表类型的分词结果，存在冗余

jieba.add_word(w)
香氛此次点增加新词w

基本统计值计算

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 media(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("平均值:{},方差:{:.2},中位数:{}.".format(m, dev(n,m), media(n)))

哈姆雷特词频统计

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

hamletTxt = getTxt()
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))

数字不同数之和

获得用户输入的一个整数N，输出N中所出现不同数字的和。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
例如：用户输入 123123123，其中所出现的不同数字为：1、2、3，这几个数字和为6。

n = input()
ss = set(n)
s = 0
for i in ss:
    s += eval(i)
print(s)

人名最多数统计

编程模板中给出了一个字符串，其中包含了含有重复的人名，请直接输出出现最多的人名。

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''
ls = s.split()
d = {}
for i in ls:
    d[i] = d.get(i, 0) + 1
max_name, max_cnt = "", 0
for k in d:
    if d[k] > max_cnt:
        max_name, max_cnt = k, d[k]
print(max_name)

七、文件

<变量名>=open(<文件名>,<打开方式>)
打开文件，路径使用/或者\

打开方式：

<变量名>.close()
关闭文件

< f >.read(size=-1)
读入全部内容，如果给出参数，读入前size长度

< f >.readline(size=-1)
读入一行内容，如果给出参数，读入前size长度

< f >.readlines(hints=-1)
读入文件所有行，以每行元素形成列表，如果给出参数，读入前hint行

< f >.write(s)
像文件写入一个字符串或字节流

< f >.writelines(lines)
将一个元素全为字符串的列表写入文件
例：>>>ls=[“中国”,“法国”,“美国”]
　　>>>f.writelines(ls)
　　中国法国美国

< f >.seek(offset)
改变当前文件操作的指针的位置，offset含义如下：
0-文件开头；1-当前位置；2-文件结尾

worldcloud库

<变量名>-worldcloud.WorldCloud()
定义一个worldcloud词云

w.generate(txt)
向WorldCloud对象w中加载文本txt

w.to_file(filename)
将词云输出为图像文件，,png或.jpg格式

配置对象参数：



max_worlds
设置词云的最大单词数

import turtle as t
t.title('自动轨迹绘制')
t.setup(800,600,0,0)
t.pencolor("red")
t.pensize(5)
#数据读取
datals = []
f = open("data.txt")
for line in f:
	line = line.replace("\n","")
	datals.append(list(map(eval, line.split(","))))
f.close()
#自动绘制
for i in range(len(datals)):
	t.pencolor(datals[i][3], datals[i][4],datals[i][5])
	t.fd(datals[i][0])
	if datals[i][2]:
		t.right(datals[i][2])
	else:
		t.left(datals[i][2])

八、程序设计方法学

os库的使用

os.path
os.path子库以path为入口，用于操作和处理文件路径

so.path.getsize(path)
返回path对应文件的大小，以字节为单位

import os.path 用法函数：




import os 用法函数：

os.system(command)
执行程序或命令command
在Windows系统中，返回cmd的调用返回信息
例1：
调用Windows系统中的计算器程序
返回0指程序正确运行
例2：

调用画图程序，同时通过空格给出要打开的文件，即可在画图中打开要打开的文件

os库的环境参数
获取或改变系统环境信息
os.getlogin()
获得当前系统登陆的用户名称
例：>>>os.getlogin()
　　'王晓文’

os.cpu_count()
获得当前系统的CPU数量
例：>>>os.cpu_count()
　　8

第三方库安装脚本

import os
libs = {"numpy", "matplotlib", "pillow", "sklearn", "requests",\
		"jieba", "beautifulsoup4", "wheel", "networkx", "sympy",\
		"pyinstaller", "django", "flask", "werobot", "pyqt5",\
		"pandas", "pyopeng1", "pypdf2", "docopt", "pygame"}
try:
	for lib in libs:
		os.system("pip install " + lib)
	print("Successful")
except:
	print("Failed Somehow")

英文字符的鲁棒输入

获得用户的任何可能输入，将其中的英文字符进行打印输出，程序不出现错误。

s = input()
for c in s:
    c = str(c)
    if 'z'>=c>='a' or 'Z'>=c>="A":
        print(c, end="")

数字的鲁棒输入

获得用户输入的一个数字，可能是浮点数或复数，如果是整数仅接收十进制形式，且只能是数字。对输入数字进行平方运算，输出结果。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
要求：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
（1）无论用户输入何种内容，程序无错误；‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬
（2）如果输入有误，请输出"输入有误"。

s = input()
try:
    if complex(s) == complex(eval(s)):
        print(eval(s)**2)
except:
    print("输入有误")

---

微信关注公众号：夜寒信息
致力于为每一位用户免费提供更优质技术帮助与资源供给，感谢支持！