零基础学习Python个人笔记

环境搭建

官网下载python解释器即可
用idea还是编辑器自己定

先从一段代码入门，温度转换

#tmp.py
tmpStr = input("输入温度：");
if tmpStr[-1] in ['F', 'f']:C = (eval(tmpStr[0:-1]) - 32) / 1.8print("转换后为{:.2f}C".format(C))
elif tmpStr[-1] in ['C', 'c']:F = 1.8 * eval(tmpStr[0:-1]) + 32print("转换后为{:.2f}F".format(F))
else:print("格式错误!")

用缩进表达包含关系，即if，else，while等层次关系
#是单行注释，”’是多行注释（用三个单引号开头与结尾）
变量命名规则：大小写字母、数字、下划线和汉字，大小写敏感，首字符不能为数字
保留字的True与False的首字母是大写，要注意。

数据类型

字符串

定义：由一对单引号或者双引号表示的字符序列。单引号与双引号没有区别。

编号，从0开始表示第一个字符。提供两种体系，正向递增序号与反向递减序号。

正向从0到n-1，反向从-1到-n。用<字符串>[i]获取字符，用<字符串>[i:j]返回一段字符串，这是左闭右开，j位置取不到，如str[0:-1]表示0 ~ n-2的这么一段字符串。用[M: N: K]根据步长对字符串切片。[::-1]相当于将字符串逆序。

扩展字符串

由一对三单引号或者三双引号表示多的多行字符串。（也可当做注释）

''' python 语言 '''

希望在字符串中出现单引号，那么字符串就用双引号括起来；反之，希望出现双引号，就用单引号括起来。若又想单引号又想双引号，那么用三个单引号表示字符串。

数字类型

整数：无取值范围限制。pow(x, y)可计算x^y,想算多大算多大，不像C++。

浮点数：浮点数取值范围和小数精度都存在限制，常规计算可忽略。运算存在不确定尾数。多以浮点数比较用round(x,d),对x四舍五入,d是小数截取位数。round(0.1 + 0.2, 1) == 0.3 -> true。注意：round函数的第二个参数不加就表示取整。

复数：a + bj，a是实部，b是虚部。z = 1.23e-4 + 5.6 + 89j,z.real获取实部，z.imag获得虚部。

列表类型

由0个或多个数据组成的有序序列，用[]表示，中间元素用,分隔。

str[-1] in ['F','f']表示字符串str的最后一个字符是不是在列表元素总，即是否与某一个列表元素相同。

数值运算操作符

+ - * / 注意， x / y 产生的是浮点数，要求得整数除，用x // y。

-y表示y的负值。x ** y表示x的y次幂x^y，y可以是小数。

类型键可以进行混合运算，生成结果“最宽”。整数 -> 浮点数 -> 复数，由窄到宽。

字符串操作符

x + y：表示字符串连接
n * x 或 x * n：表示复制n次字符串x
x in s：判断x是否为s的子串，返回true / false

字符串方法

str.lower()或者str.upper()：将字符串中的字符变为全小写或者全大写。

str.split()：分割，返回一个列表。如："A,B,C".split(",") 结果为 ['A', 'B', 'C']

str.join(iter)：在iter变量除最后元素外每个元素后增加一个str。如：",".join("12345") 结果为 "1,2,3,4,5"，主要用于分隔字符串

str.count(sub)：返回子串sub在str中出现的次数。

str.replace(old, new)：返回符串str的副本，所有old子串被替换成new子串。

str.center(width[,fillchar])：字符串根据宽度width居中。如："Python".center(20,"=") 结果为 =======Python=======

str.strip(chars)：从str中去掉在其左侧和右侧chars中列出的字符。如："= python= ".strip(" =np") 结果为 "ytho，将左右两侧' ', '=', 'p', 'n'去掉。

str.join(iter)：在iter变量除最后元素外每个元素增加一个str。如："j".join("12345") 结果为 "1,2,3,4,5"，主要用于字符串分隔。

字符串的格式化

<模板字符串>.format()

槽：由一对大括号{}组成，每个槽需要添加的内容与.fomat()中的参数顺序一致，类似于printf。如：

"{}:计算机{}的CPU的占用率为{}%".format("2018","C",10)

槽内部对格式化的配置方式{<参数序号>:<格式控制标记>}，其中格式控制标记为<填充符><对齐方式><宽度><,(表示千位分隔符)><.精度><类型>，如：

"{0:=^20}".format("python")结果为 '=======python======='注意：^居中对齐，<左对齐，>右对齐"{:10}.format("BIT")"结果为 'BIT       '直接给出宽度，默认左对齐，填充空格"{:,.2f}".format(12345.6789)结果为 '12,345.68'"{0:b},{0:o},{0:X}".format(425)结果为 '110101001,651,1A9'b，o,X表示类型二进制、八进制、大写十六进制"{0:e},{0:%}".format(3.14)结果为 '3.140000e+00,314.000000%'

语句与函数

赋值语句

赋值语句的右侧数据类型同时作用于变量，如：

str = input("")，input返回一个字符串，那么str就是字符串类型。

分支语句

用if elif else构成条件判断语句，并且要加:,若条件成立则执行缩进的语句。

函数语句

input()：从控制台获得用户的输入。<变量> = input(<提示信息字符串>)，以字符串格式类型保存在<变量中>。

print()：向控制台输出。printf(<字符串>)。保留两位小数print("{:.2f}".format(变量))

eval()：去掉参数最外侧引号（单或双）并执行余下语句。如：eval("1") 将得到数字 1 ， eval("1 + 2") 将得到数字3，eval('"1"')得到字符串”1”，eval('"print("hello!)"')将执行print(“hello”)语句。

divmod(x, y)：商余，同时输出商和余数。divmod(10, 3)的结果为(3, 1)。

pow(x, y[, z])：等同于(x ** y) % z。

max(x1, x2, …, xn)：求最大值

min(x1, x2, …, xn)：求最小值

int(x)：取整数部分，int(123.6) = 123，int("123") = 123

float(x)：将x变成浮点数，增加小数部分。float(12) = 12.0，float("1.23") = 1.23

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

str(x)：任意类型x所对应的字符串形式，如str(1.23)结果为"1.23"，str([1,2])结果为"[1,2]"，与eval()函数相反。

hex(x)或者oct(x)：将x转化为16进制或者8进制的小写形式字符串，如：hex(425)结果为"0x1a9"

ord(char)：得到Ascll码

画画

import 引入了turtle库（海龟库）。是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.done()

画窗控制

turtle.setup(width, height, startx, starty),设置窗体大小以及位置。电脑的屏幕左上角为(0,0)，startx和starty是窗体的左上角在电脑屏幕的坐标（不指定则在正中心）。并不必须

turtle.done()，加上后窗体不会自动关闭。

画笔控制

turtle.penup()，拿起画笔，此时移动海龟不会留下线。turtle.pendown()，落下画笔，移动海龟会留下线。turtle.pensize(width)，设置画笔的粗细。turtle.pencolor(color)，修改画笔颜色，可以是颜色字符串、RGB小数值或者元组值。

运动控制

turtle.goto(x, y)，表示从当前位置到(x,y)位置，中途经过地方都会有线。这个坐标是turtle坐标，即窗体的最中心是(0,0)，x轴为横轴，y轴为纵轴。

turtle.fd(d)表示海龟向前移动d像素，turtle.bk(d)表示海龟后退d像素，turtle.circle(r,angle)表示以海龟当前位置左侧（若r为负数，那么就在右侧）某r处为圆心画圈，角度为angle（默认360）。

方向控制

turtle.seth(angle)设置当前海龟的前进方向，即面朝的方向，其中angle为绝对角度（即坐标轴的标准角度）。

turtle.left(angle)，海龟向左转一定角度；turtle.right(angle)，海龟向右转一定角度。(相对海龟角度)

循环语句

for <变量> in range(<函数名>):<被执行的语句>

range中的参数值控制循环次数，<变量>表示循环的计数，0到<次数>-1

for i in range(5):  #相当于从0到n-1print(i)结果:
0
1
2
3
4

range()函数：产生循环计数序列。range(N),产出从0到N-1的n和序列。range(m, n)产生从m开始到n-1的序列，共n-m个。

天天向上的力量（写函数）

问：A在周一到周五进步，在周六周天能力下降1%。B不休息，每天进步1%。那么A必须至少周一到周五每天进步多少才能赶上B？

#写函数，用 def name(factor): #函数，传入努力参数
def dayUp(df):dayup = 1for i in range(365):if i % 7 in [6, 0]:dayup = dayup * (1 - 0.01)else:dayup = dayup * (1 + df)return dayupdayFactor = 0.01
while dayUp(dayFactor) < 37.78:dayFactor += 0.001
print("{:.3f}".format(dayFactor))

time库

python中处理时间的标准库，需要import time，再使用time.<b>()函数。

时间获取

time.time()：获取当前时间戳，即计算机内部时间值，浮点数。如151693876.6022282

time.ctime()：获取当前时间，字符串。如：Fri Jan 26 12:11:16 2018

time.gmtime()：获取当前时间，表示为计算机可处理的时间格式。

时间格式化

time.strftime(tpl, ts)：tpl是格式化模板字符串，定义输出效果，ts是计算机内部时间类型变量。如：

t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:S", t)
结果为：'2018-01-26 12:55:20'%Y  年份      0000~9999
%m  月份      01~12
%B  月份名称  January~December
%b  月份缩写  Jan~Dec
%d  日期      01~31
%A  星期      Monday~Sunday
%a  星期缩写  Mon~Sun
%H  24小时    00~23
%h  12小时    01~12
%p  上午下午  AM, PM
%M  分钟      00~59
%S  秒        00~59

time.strptime(str, tpl)：与strftime()相反，用时间字符串构造出时间类型变量。如：

timeStr = '2018-01-26 12:55:20'
time.strptime(timeStr, "%Y-%m-%d %H:%M:S")

程序计时

程序计时指测量起止动作所经历的时间

time.perf_counter()：返回一个CPU级别的精确时间计数值，单位为秒。如：

start = time.perf_counter()
end = time.perf_counter()
end - start         #计算差值

sleep(s)：s是休眠时间，单位是秒，可以是浮点数

def wait():time.sleep(3.3)
wait()

基本进度条

import time
scale = 10
print("------start------")
for i in range(scale + 1):a = '*' * ib = '.' * (scale - i)c = (i/scale) * 100print("{:^3.0f}%[{}->{}]".format(c, a, b))time.sleep(1)
print("-------end-------")结果为：
------start------0 %[->..........]
10 %[*->.........]
20 %[**->........]
30 %[***->.......]
40 %[****->......]
50 %[*****->.....]
60 %[******->....]
70 %[*******->...]
80 %[********->..]
90 %[*********->.]
100%[**********->]
-------end-------

单行动态刷新

后打印的字符覆盖之前的字符，即不能换行，且退光标。

import time
scale = 100
print("------start------")
for i in range(scale + 1):print("\r{:3}%".format(i), end="")time.sleep(0.25)
print("-------end-------")print()有个参数为end,end="信息"，默认end="\n",意思是print执行后自动增加的信息。\r是指退回到行首

综合进度条

import time
scale = 50
print("执行开始".center(scale, "-"))
start = time.perf_counter()
for i in range(scale + 1):a = "*" * ib = "." * (scale - i)c = (i / scale) * 100dur = time.perf_counter() - startprint("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end = "")time.sleep(0.1)
print("\n执行结束".center(scale, "-"))

分支结构

单分支

if <条件> :<语句块>

二分支

if <条件1> :<语句块1>
else :<语句块3>

另外还有紧凑形式：<表达式1> if <条件> else <表达式2>

guess = eval(input())
print("猜{}了".format("对" if guess == 99 else "错"))

多分支

if <条件1> :<语句块1>
elif <条件2> :<语句块2>
......
else :<语句块3>

逻辑运算

逻辑与运算and： x and y

逻辑或运算or：x or y

逻辑非运算not：not x

异常处理

当语句块1有异常时，执行语句块2。

try :<语句块1>
except <异常类型>:      %异常类型可省略<语句块2>另有
try :<语句块1>
except <异常类型>:     <语句块2>
else :<语句块3>           %无异常时执行3
finally :<语句块4>           %有无异常都执行

BMI编程例子

注意：同时给两个变量赋值的方法

#CalBMIv.py
height, weight = eval(input("请输入身高(m)和体重(kg)[逗号隔开]："))
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 <遍历结构>:<语句块>#计数循环，range(n)产生n个数，0~n-1
for i in range(n):<语句块>#i从m到n-1，以k为步长
for i in range(m, n, k):<语句块>#字符串遍历循环；c是字符，s是字符串
for c in s:<语句块>#列表遍历循环，ls是一个列表，如[123,"22",23]
for item in ls:<语句块>

无限循环

while <条件> :<语句块>a = 3
while a > 0 :a = a - 1

有break与continue

高级循环

当循环没有被break时，执行else语句。即正常循环结束是需要执行else里面的语句的。

for <循环变量> in <遍历结构> :<语句块1>
else :<语句块2>while <条件> :<语句块>
else :<语句块2>

random库

random是使用随机数的python标准库，使用import random

基本随机函数

随机数种子->梅森旋转算法->随机序列，随机序列由随机数种子唯一确定

seed(a=None)：初始化给定的随机数种子；如果不调用此函数，默认种子为当前系统时间。random.seed(10) %产生种子10对应的序列

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

扩展随机函数

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

randrange(m, n, k)：生成一个[m, n)之间以k为步长的随机整数random.randrange(10, 100, 10) 可能结果为80

getrandbits(k)：生成一个k比特长的随机整数,random.getrandbits(16) 结果可能为37885

uniform(a, b)：生成一个[a, b]之间的随机小数，精度为小数点后16位。

choice(seq)：在序列中随机选取一个元素，random.choice([1,2,3])

shuffle(seq)：将序列元素随机排序，s = [1,2,3];random.shuffle(s);print(s),会改变s自身。

蒙特卡洛求圆周率的算法

#计算圆周率.py
import random
import time
import mathn = 1000 * 1000     #计算1e6次
hist = 0
start = time.perf_counter()   #计时
for i in range(1, n + 1) :x, y = random.random(), random.random() #得到随机的坐标[0,1]dist = math.sqrt(x ** 2 + y ** 2) #距离圆心的距离if dist <= 1.0 :hist = hist + 1pi = 4 * (hist / n);
print("圆周率是：{}".format(pi))
print("运行时间是：{:.5f}".format(time.perf_counter() - start))

函数

函数定义

def <函数名>(<参数(0个或多个)>):函数体return <返回值>#可选参数，注意可选参数必须在必选参数的后面
def fact(n, m=1):  ...return ...m是可选参数，如果调用时不给出，就使用默认值。可以是：fact(10)或者fact(10,2)#可变参数传递，可以不确定参数的总数量
def <函数名>(<参数>, *b):<函数体>return <返回值>#例子，这里必须有参数n，但是b可以有任意个
def fact(n, *b):s = 1for i in range(1, n+1):s *= ifor item in b:s *= itemreturn s

返回值

可以有return,也可以没有；同时，可以返回多个值。e.g.return a, b, c,返回的是元组类型(a, b, c)。

全局变量与局部变量

python中是有全局变量与局部变量的概念的。

使用global可以在函数中声明使用全局变量。

s = 100
def fact(n):
global s #此时使用的s是全局变量s
…
return …
局部变量为组合类型且未创建，等同于全局变量

ls = [“F”, “f”] #创建了一个列表
def fact(a):
ls.append(a) #此处ls是列表类型，未真实创建，等同于全局变量
return
func(“C”)
print(ls) #结果是[“F”,”f”,”C”]

真实创建

ls = [“F”, “f”]
def fact(a):
ls = []
ls.append(a)
return
func(“C”)
print(ls) #结果是[“C”]

s = 1
def fac():
s = 3 #创建了就是局部变量
print(s)
fac()
print(s) #结果是3 1

s = 1
def fac():
print(s) #未创建就是全局变量
fac()
print(s) #结果是1 1

s = 1
def fac():
global s #声明使用的是全局变量
s = 3
print(s)

fac()
print(s) #结果是3 3
lambda函数

lambda函数是一种匿名函数，即没有名字的函数，返回值就是函数的名字。仅用于在一行内表达的函数

<函数名> = lambda<参数>:<表达式>
f = lambda x, y : x + y   #定义了函数f，参数是(x, y)，返回值是x+yf = lambda : "hello"
print(f())       #结果是输出hello

7数码管的绘制

按照图中的线路走，比如0就是过1的时候不画，其他都画；8就是过每一条线的时候都画。

import turtle, timedef drawLine(draw):             #绘制单段数码管if draw:turtle.pendown()else:turtle.penup()turtle.fd(40)turtle.right(90)def drawdDigit(digit):          #根据数字画七段数码管drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)     #就是只有2,3,4...等数字需要画1号线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):             #date是个日期字符串，逐一解析里面的数字进行绘制,格式为'%Y-%m=%d+'turtle.color("red")for i in date:if i == '-':turtle.write('年', font = ("Arial", 18, "normal"))turtle.pencolor("green")turtle.penup()turtle.fd(40)elif i == '=':turtle.write('月', font = ("Arial", 18, "normal"))turtle.pencolor("blue")turtle.penup()turtle.fd(40)elif i == '+':turtle.write('日', font = ("Arial", 18, "normal"))else:drawdDigit(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()

PyInstaller库

将.py的源代码转换为可执行文件。
是第三方库，需要额外安装。

(cmd命令行) pyinstaller -F <文件名.py>

科赫曲线举例（递归）

import turtledef koch(size, n):          #绘制n阶的size长的koch曲线if n == 0:turtle.fd(size)     #0阶就是直线else:for angle in [0, 60, -120, 60]:     #一条线会分为4个部分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)            #把长为600的直线画为3阶的koch曲线turtle.hideturtle()
main()

组合数据类型

（1）集合类型

集合是多个元素的无序组合（不存在相同元素），与数学概念一致。
python中要求集合中的元素是不可更改的。（不可修改）列表类型是可修改的。
集合用{}表示,元素用,分隔。建立空集合，要用set()函数。

A = {“PYTHON”, 123, (“PYTHON”, 123)} #使用{}建立集合，()表示的数据叫元组
B = set(“123pypy”) #使用set()函数，结果将拆分为{‘1’, ‘2’, ‘3’, ‘p’, ‘y’}

集合运算：

S | T：并集

S - T：差集

S & T：交集

S ^ T：补集（包括集合S和T中的非相同元素）

S <= T 或者 S < T（也有>=,>）：用来判断S和T的包含关系，返回True/False

有|= -= &= ^=操作符，会改变原有操作集合

集合方法

S.add(x)：添加元素

S.discard(x)：删除元素，x不在集合中，不报错

S.remove(x)：删除元素，x不在集合中，会产生KeyError异常

S.clear()：清空集合

S.pop()：从集合中随机取出一个元素（并且删除），若S为空产生KeyError异常

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

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

x in S：判断x是否在集合S中，返回True/False

set(x)：其他类型转换为集合类型

#遍历集合，注意用for循环取出的顺序与定义顺序不一定一致
A = {"P", 123}
for item in A:print(item)try:while True:print(A.pop())
except:pass
#注意最后，A会成为空集合

集合应用场景

判断包含关系

“P” in {“P”, 123} #True
{“p”, “y”} >= {“p”, “y”, 123} #False
数据去重

ls = [1, 1, 2]
s = set(ls) #结果{1, 2}
lt = list(s) #结果[1, 2]

（2）序列类型

序列是具有先后关系的一组元素，是以为元素向量。元素类型可以不同。
元素可以由序号引导，通过下标进行访问。
序列类型是基类，衍生出的类型是字符串类型、元组类型、列表类型。

序列类型（基类）及操作

x in s：判断x是否在s中，返回True/False

s + t：连接两个序列s和t

s * n：将序列s复制n次

s[i]：返回第i个元素

s[i:j]或s[i:j:k]：切片，返回第i个到第j-1个以k为步长的元素子序列（左闭右开）

ls = ["p", 123, ".io"]
ls[::-1]    #逆序，得到[".io", 123, "p"]s = "123"
s[::-1]     #字符串也是序列类型，得到"312"

len(s)：返回序列元素的个数

min(s)/max(s)：返回序列s中最小/最大的元素，需要元素有可比性

s.index(x) 或 s.index(x, i, j)：s从i开始到j-1位置中第一次出现元素x的下标（左闭右开）

s. count(x)：序列s中x出现的总次数

元组类型及操作

是序列类型的拓展,继承了序列类型的所有操作，元组一旦被创建就不能被修改
使用()或tuple()创建，元素用,分隔
可以使用或不适用小括号

def func():
return 1, 2 #返回的是一个值，是元组类型(1, 2)

creature = “cat”, “dog”, “human”
color = (0x00100, “blue”, creature)
color[-1][2] == “human”

列表类型及操作

是序列类型的拓展，创建后元素可以随意修改
使用[] 或 list()创建，元素用,分隔

ls = [“cat”, “dog”, “tiger”, 1024]
lt = ls #仅通过赋值，系统中并没有再创建一个列表，仅仅传递了引用，使用[]或者list()才能创建列表

ls[i] = x：替换第i个元素

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

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

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

ls += lt：将lt的元素增加到ls后

ls *= n：更新ls，对元素重复n次

ls = [1, 2, 3]
ls[1:2] = [100, 100, 100]       #结果为[1, 100, 100, 100, 3]
del ls[::3]                     #结果为[100, 100, 3]    删除了0和3号元素

sorted(ls)：对列表ls进行排序

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

ls.clear(x)：清空

ls.copy()：复制列表

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

ls.pop(i, x)：将第i位置元素取出（并删除）

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

ls.reverse()：将ls元素反转

序列类型的应用场景

元组用于元素不改变的应用场景，进行数据保护
列表更加灵活
数据遍历

（3）字典类型

映射：一种键（索引）和值（数据）对应的关系。
字典类型是“映射”体现，字典是键值对的集合，键值对之间是没有顺序的。
使用{}和dict()创建，键值对用冒号:表示，键值对之间用,分隔

<字典变量> = {<键1>:<值1>, …, <键n>:<值n>} #创建
<字典变量>[<键>] #查询<值>
<字典变量>[<键>] = <值> #改变
dict = {} #生成空字典；注意，不能用这种方法生成空集合，要使用set()

字典类型操作方法

del d[k]：删除键k对应的数据值

d[<键>] = <值>：新增元素/修改元素

k in d：判断某个键是否在字典d中

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

d.values()：返回d中所有值的信息

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

d.get(k, )：键k存在则返回对应值，不存在就返回值

d.pop(k, )：键k存在则返回对应值，并删除，不存在就返回值

d.popitem()：随机取出一个键值对，以元组形式返回

d.clear()：清空

len(d)：返回元素个数

d = {...}  #d是字典
for k in d:     #这里k是键...

jieba库

中文分词的第三方库

精确模式：把文本精确切分开，不存在冗余单词
全模式：把文本中所有可能的词语都扫描出来，有冗余
搜索引擎模式：在精确模式的基础上，对长词再次切分

jieba.lcut(s)：精确模式，返回一个列表类型的分词结果
jieba.lcut(s, cut_all=True)：全模式，存在冗余
jieba.lcut_for_search(s)：搜索引擎模式，存在冗余
jieba.add_word(s)：增加新词

jieba.lcut("中国是一个伟大的国家") -> ['中国', '是', '一个', '伟大', '的', '国家']
jieba.lcut("中国是一个伟大的国家", cut_all=True) -> ['中国', '国是', '一个', '伟大', '的', '国家']
jieba.lcut_for_search("中华人民共和国是伟大的") -> ['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']

例子：文本词频统计

先获取文本的具体信息。
对于英文文本，需要有大小写转换，逗号、句号的处理。

英文：

#读取文件，并改为小写，并处理特殊字符为空格
def getText():txt = open("hamlet.txt", "r").read()    #打开文件读入txttxt = txt.lower()                       #变为小写for c in '!"$%^&*()+,-./:;<=>?@[\\]_\'{|}~':txt = txt.replace(c, " ")return txthamletTxt = getText()
words = hamletTxt.split()                   #默认以空格分隔
counts = {}                                 #空字典，用于统计单词频率for w in words:counts[w] = counts.get(w, 0) + 1        #用get()查找w对应的值（次数），如果没有返回0#将字典类型变为列表类型 便于排序
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)#对键值对的第二个元素进行排序  reverse为True是从大到小for i in range(10):word, count = items[i]print("{0:<10}{1:>5}".format(word, count))

中文：中文就需要分词，不存在大小写问题

import jieba#读取文件
txt = open("threekingdoms.txt", "r", encoding="UTF-8").read()
words = jieba.lcut(txt)counts = {}                                 #空字典，用于统计单词频率
for w in words:if len(w) == 1:continuecounts[w] = counts.get(w, 0) + 1        #用get()查找w对应的值（次数），如果没有返回0#将字典类型变为列表类型 便于排序
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)#对键值对的第二个元素进行排序  reverse为True是从大到小for i in range(15):word, count = items[i]print("{0:<10}{1:>5}".format(word, count))

文件操作

根据文件展示方式分为：文本文件和二进制文件。

文本文件：单一特定编码组成的文件，如UTF-8编码。也就是长的字符串。
二进制文件：由01构成的文件，没有统一字符编码。

文件处理步骤：打开-操作（读写）-关闭

打开：

<变量名> = open(<文件名>, <打开模式>)，变量名成为文件句柄打开模式：'r'，只读模式，文件不存在返回FileNotFoundError'w'，覆盖写模式，文件不存在则创建文件，存在则完全覆盖'x'，创建写模式，文件不存在则创建，存在则返回FileExistSError'a'，追加写模式，文件不存在则创建文件，存在则在文件后面追加内容'b'，以二进制模式打开't'，以文本模式打开（默认是t）'+'，与r/w/x/a一同使用，在原功能基础上增加同时读写的功能    r+/w+/a+f = open("f.txt")       #默认文本模式、只读模式f = open("f.txt", "rt") #跟默认一样f = open("f.txt", "w")  #文本模式，覆盖写模式f = open("f.txt", "a+") #文本形式，追加写模式 + 读模式，只有a只能写，不能读f = open("f.txt", "b")  #二进制、只读模式f = open("f.txt", "wb") #二进制模式、覆盖写模式

关闭：

<变量名>.close()

文件内容读取：

f.read(size=-1)：读入全部内容，如果给出参数size，则读入前size字符
f.readline(size=-1)：读入一行，如果给出参数size，则读入该行前size字符
f.readlines(hint=-1)：读入所有行，以每行为元素形成列表，给出参数则读入前hint行e.g:
#遍历全文本：一次性读入（占内存）
f = open(fname, "r")
txt = f.read()
...
f.close#遍历全文本：逐步读入
f = open(fname, "r")
txt = f.read(2)
while txt != "":...txt = f.read(2)
f.close#逐行操作：一次性读入
f = open(fname, "r")
for line in f.raedlines():...
f.close#逐行操作：逐步读入
f = open(fname, "r")
for line in f:          #逐行读入...
f.close

文件写入：

f.write(s)：向文件中写入一个字符串
f.writelines(lines)：将一个元素全部为字符串的列表写入文件。写进去字符串之间没有空格隔，也不会换行
f.seek(offset)：改变当前文件操作的指针的位置，0-文件开头；1-当前位置；2-文件结尾f = open("output.txt", "w+")
ls = ["中国","美国","法国"]
f.writelines(ls)
for line in f:...
f.close()
发现并没有输出，因为写完之后指针在最后，用for in 方法不能遍历解决办法：加个seek(0)
f = open("output.txt", "w+")
ls = ["中国","美国","法国"]
f.writelines(ls)
f.seek(0)
for line in f:...
f.close()
输出："中国美国法国"

列子：自动归集绘制

需求：根据脚本来绘制图形；读取一个文件，解析其中的数据，绘制出相应的图形。

文件：一行代表一次操作：行进距离,转向判断(0左转,1右转),转向角度,RGB三个通道的颜色
300,0,144,1,0,0
300,0,144,0,1,0
300,0,144,0,0,1
300,0,144,1,1,0
300,0,108,0,1,0import turtle as t
#画布参数设置
t.title('自动轨迹绘制')
t.setup(800, 600, 0, 0)
t.pencolor("red")
t.pensize(5)#数据读取
datals = []                     #将每一个操作读入到datals的每一行
f = open("data.txt")
for line in f:line.replace("\n", "")      #去掉换行符datals.append(list(map(eval, line.split(','))))     #map函数，将第一个参数的功能作用于第二个参数的每一个元素
f.close()#自动绘制
t.pendown()
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][1] == 1:t.right(datals[i][2])else:t.left(datals[i][2])

数据格式化

一维数据格式化

一维数据有序，可使用列表类型
无序，可使用集合类型（不可重复)

将存储的一维数据读入程序表达为列表或者集合

#读入用空格分隔的字符串文件
txt = open(fname).read()
ls = txt.split()
txt.close()#采用空格方式分隔字符串并写入文件
ls = ['1', '2', '3']
f = open("f.txt", 'w')
f.write(' '.join(ls))           #join方法，使用某参数分隔元素，形成一个字符串
f.close()

二维数据格式化

使用二维列表类型二维数据

CSV存储格式：用逗号分隔值，国际通用的一二维数据存储格式，一般用.csv扩展名；每行是一个一维数据，采用逗号分隔，并且文件中没有空行。不同行就是不同维度

#从csv格式文件读入数据
ls = []
f = open(filename)
for line in f:line.replace("\n", "")      #去掉换行符ls.append(ling.spilt(','))
f.close()#将数据写入CSV格式的文件中
ls = [[...], ..., [...]]           #二维文件
f = open(filename, 'w')
for item in ls:f.write(','.join(item) + '\n')  #增加逗号和回车
f.close()#遍历二维数据
for row in ls:for column in row:print(ls[row][column])

python生态

https://python123.io

https://pypi.org

安装第三方库命令：

pip install <name>
pip install -U <name>   #对已安装的更新
pip uninstall <name>    #卸载
pip download <name>     #下载不安装
pip show <name>         #列出详情
pip search <name>       #搜索相关的第三方库
pip list                #列出已经安装的第三方库

集成安装库：Anaconda

https://www.continuum.io
下载了后系统就有了800个第三方库（数据相关的，适合计算领域开发）

文件安装方法：

某些第三方库需要pip下载，结合本地操作系统编译后才能安装，但是本地不具有相应的安装环境。

可以去：http://www.lfd.uci.edu/~gohlke/pythonlibs/ UCI页面

然后直接找到已经编译好的文件，结合操作系统和python版本下载

然后使用pip install <文件名> 进行安装（同一目录下）

os库

os库提供通用的、基本的操作系统交互功能，是python标准库

路径操作——os.path

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

os.path.abspath(path)：返回path在当前操作系统的绝对路径，os.path.abspath("file.txt") -> C:\\user\\file.txt

os.path.normpath(path)：归一化path表示形式，统一用\\分隔，os.path.normpath("D://file.txt") -> D:\\file.txt

os.path.relpath(path)：返回当前程序与文件之间的相对路径，结果可能为：..\\..\\user//file.txt

os.path.dirname(path)：返回目录名

os.path.basename(path)：获得最后的文件名

os.path.join(path, *paths)：组合path和paths，返回一个路径字符串

os.path.exists(path)：判断文件或者目录是否存在，返回True False

os.path.getatime(path)：上一次的访问时间

os.path.getmtime(path)：最近一次的修改时间

os.path.getctime(path)：创建时间

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

进程管理——os.system

import os
os.system("C:\\dota.exe")   #直接调用程序

环境参数

os.chdir(path)：修改当前程序操作的路径

os.getcwd()：返回程序的当前路径

os.getlogin()：获得当前系统登录的用户名称

os.cpu_count()：返回当前系统的CPU数量

os.urandom(n)：获得n个字节长度的随机字符串，用于加密解密

例子：批量安装第三方库

import os
libs = {"", "", ..., ""}        #第三方库的名字
try:for lib in libs:os.system("pip install " + lib)print("successful!")
except:print("Failed Somhow!")

python生态

数据分析

Numpy：表达N为数组的最基础的库，计算速度优异（c语言实现），提供矩阵运算等功能。

Pandas：python数据分析的高层次应用库，提供简单易用的数据结构和数据分析工具，基于Numpy开发。

SciPy：数学、科学和工程计算功能库，类似matlab，提供个很多优化算法

数据可视化

Matplotlib：高质量的二维数据的可视化功能库，通过Matplotlib.pyplot字库调用各个可视化效果

Seaborn：统计类数据可视化功能（分布、分类、线性关系等）

Mayavi：三维科学数据可视化功能库

文本处理

PyPDF2：用来处理PDF文件，获取信息、分隔整合文件、加密解密

NLTK：自然语言文本处理第三方库，包括分类、标记、语法句法、语义分析等

Python-docx：创建或者更新word文件的第三方库

机器学习

Scikit-learn：机器学习方法工具集，聚类、分类、回归、强化学习等功能

TensorFlow：机器学习计算框架

MXNet：基于神经网络的深度学习计算框架

网络爬虫

Request：最友好的网络爬虫工具，主要是页面

Scrapy：网络爬虫框架，可以构建网络爬虫系统，支持批量和定时网页爬取，提供数据处理流程

pyspider：强大的web页面爬取系统，支持数据库后端，消息队列、分布式架构等

web信息提取

爬虫之后解析内容

Beautiful Soup：HTML和XML的解析库，可以加载多种解析引擎

Re：正则表达式解析和处理功能库，是python的标准库，无需安装

Python-Goose：提取文章类型web页面的功能库，文章信息、视频信息的元数据提取功能

网站开发、后端框架

Django：最流行的框架，MTV模式

Pyramid：规模适中的web应用框架

Flask：微型web框架

网络应用开发

WeRoBot：微信公众号开发框架

aip：百度AI开放平台接口，访问百度AI服务的python功能接口，包括语音、人脸、NLP、知识图谱、图像搜索等

MyQR：二维码生成第三方库

图形用户界面

PyQt5：Qt开发框架的python接口，桌面应用开发系统，完备的GUI

wxPython：跨平台GUI开发框架

PyGObject：使用GTK+开发GUI功能库

游戏开发

PyGame：简单的游戏开发功能库

Panda3D：开源、跨平台的3D游戏开发库

cocos2d：构建2D游戏和图形界面交互式应用的框架，支持GPU加速

虚拟现实

VR Zero：树莓派上开发VR应用的python库，适合初学者

pyovr：针对Oculus设备的python开发库，比较成熟

Vizard：通用vr开发引擎，支持多种VR设备

图形艺术

Quads：迭代的图形

ascii_art：ascll艺术库