零基础学习Python个人笔记

环境搭建

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

---

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

#tmp.py
tmpStr = input("输入温度：");    
if tmpStr[-1] in ['F', 'f']:
    C = (eval(tmpStr[0:-1]) - 32) / 1.8
    print("转换后为{:.2f}C".format(C))
elif tmpStr[-1] in ['C', 'c']:
    F = 1.8 * eval(tmpStr[0:-1]) + 32
    print("转换后为{:.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-1
    print(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 = 1
    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))

---

time库

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

时间获取

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 = '*' * i
    b = '.' * (scale - i)
    c = (i/scale) * 100
    print("{:^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 = "*" * 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, "-"))

---

分支结构

单分支

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 math

n = 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 + 1

pi = 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 = 1
    for i in range(1, n+1):
        s *= i
    for item in b:
        s *= item
    return s

返回值

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

全局变量与局部变量

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

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

   s = 100
   def fact(n):
   global s #此时使用的s是全局变量s
   …
   return …

2. 局部变量为组合类型且未创建，等同于全局变量

   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

3. lambda函数

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

<函数名> = lambda<参数>:<表达式>
f = lambda x, y : x + y   #定义了函数f，参数是(x, y)，返回值是x+y

f = lambda : "hello"
print(f())       #结果是输出hello

7数码管的绘制

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

import turtle, time

def 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 turtle

def 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会成为空集合

集合应用场景

1. 判断包含关系

   “P” in {“P”, 123} #True
   {“p”, “y”} >= {“p”, “y”, 123} #False

2. 数据去重

   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("中华人民共和国是伟大的") -> ['中华', '华人', '人民', '共和', '共和国', '中华人民共和国', '是', '伟大', '的']

例子：文本词频统计

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

英文：

#读取文件，并改为小写，并处理特殊字符为空格
def getText():
    txt = open("hamlet.txt", "r").read()    #打开文件读入txt
    txt = txt.lower()                       #变为小写
    for c in '!"$%^&*()+,-./:;<=>?@[\\]_\'{|}~':
        txt = txt.replace(c, " ")
    return txt

hamletTxt = 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:
        continue
    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(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,0

import 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 
pip install -U    #对已安装的更新
pip uninstall     #卸载
pip download      #下载不安装
pip show          #列出详情
pip search        #搜索相关的第三方库
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艺术库