Python基础课程笔记·嵩天

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

print(str(float(input("hh")) / 1000) + 's')

n = eval(input())
if n == 0:
    print("Hello World")
elif n > 0:
    print("He\nll\no \nWo\nrl\nd")
else:
    for c in "Hello World":
        print(c)

turtle库

turtle.setup (width, height, startx, starty）
Penup 抬起画笔或者pu或up
Pendown 放下画笔或pd或down
Pensize() 调整画笔尺寸
Pencolor()调整画笔颜色 colorstring 或(r,g,b)
White black grey darkgreen gold violet purple
Fd(distance) 向前行进一个距离
Seth(angle) 改变方向
Circle(半径,角度)
Goto(x,y)将画笔移动到坐标x,y处

#KochDrawV1.py
#科赫雪花小包裹
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(-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()

#RoseDraw.py
#玫瑰花绘制
import turtle as t

def DegreeCurve(n, r, d=1):
    for i in  range(n):
        t.left(d)
        t.circle(r, abs(d))
#初始位置设定
s=0.2 #size
t.setup(450*5*s, 750*5*s)
t.pencolor("black")
t.fillcolor("red")
t.speed(100)
t.penup()
t.goto(0,900*s)
t.pendown()
#绘制花朵形状
t.begin_fill()
t.circle(200*s,30)
DegreeCurve(60,50*s)
t. circle(200*s,30)
DegreeCurve(4,100*s)
t. circle(200*s,50)
DegreeCurve(50,50*s)
t. circle(350*s,65)
DegreeCurve(40,70*s)
t. circle(150*s,50)
DegreeCurve (20,50*s,-1)
t.circle(400*s,60)
DegreeCurve(18,50*s)
t.fd(250*s)
t.right(150)
t.circle(-500*s,12)
t.left(140)
t.circle(550*s,110)
t.left(27)
t.circle(650*s,100)
t.left(130)
t.circle(-300*s,20)
t.right(123)
t.circle(220*s,57)
t.end_fill()
#绘制花枝
t.left(120)
t.fd(280*s)
t.left(115)
t.circle(300*s,33)
t.left(180)
t.circle( -300*s,33)
DegreeCurve(70, 225*s, -1)
t.circle(350*s,104)
t.left(90)
t.circle(200*s,105)
t.circle(-500*s,63)
t.penup( )
t.goto(170*s,-30*s)
t.pendown( )
t.left(160)
DegreeCurve(20,2500*s)
DegreeCurve(220, 250*s, -1)
#绘制叶子
t.fillcolor('green')
t.penup()
t.goto(670*s,-180*s)
t.pendown 
t.right(140)
t.begin_fill( )
t.circle(300*s,120)
t.left(60)
t.circle(300*s,120)
t.end_fill()
t.penup()
t.goto(180*s,-550*s)
t.pendown
t.right(85)
t.circle( 600*s,40 )
#绘制另一个叶子
t.penup()
t.goto(-150*s, -1000*s)
t.pendown()
t.begin_fill()
t.rt(120)
t.circle(300*s,115)
t.left(75)
t.circle(300*s,100)
t.end_fill()
t.penup()
t.goto(430*s,-1070*s)
t.pendown()
t.right(30)
t.circle(-600*s,35)
t.done()

#七段数码管
import turtle

def drawLine(draw): #绘制单段数码管
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    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): #获得要输出的数字
    for i in date:
        drawDigit(eval(i)) 
        #通过eval()函数将数字字符串形式变为整数数字形式

def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate('20181010')
    turtle.hideturtle()
    turtle.done()

main()

#七段数码管2
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): #date为日期,格式为'%Y-%M=%D+'
    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()

#自动轨迹绘制
#AutoTraceDraw.py

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][1]:
        t.right(datals[i][2])
    else:
        t.left(datals[i][2])

#绘制等边三角形
from turtle import *
setup(650,350,300,200)
fd(100)
seth(-120)
fd(100)
seth(120)
fd(100)

#绘制叠加等边三角形

from turtle import *
setup(600,400)
seth(90)
penup()
fd(150)
pendown()
seth(-60)
fd(200)
seth(180)
fd(200)
seth(60)
fd(100)
seth(0)
fd(100)
seth(-120)
fd(100)
seth(120)
fd(100)
seth(60)
fd(100)

# 绘制正方形螺线
from turtle import*
setup(600,400)
for i in range(0,10):
    fd(150-i*5)
    seth(90)
    fd(150-i*5)
    seth(180)
    fd(149-i*5)
    seth(-90)
    fd(149-i*5)
    seth(0)

# 五角星绘制
from turtle import *
fillcolor("red")
begin_fill()
while True:
	forward(200)
	right(144)
	if abs(pos())<1:
		break
end_fill()

基础知识

Eval函数可以直接进行对字符串进行运算
输入10 + 100 1 / 20
输出110.00 0.05

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

range(开始,终点,步长)

# 九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print("{}*{}={:2}".format(j,i,i*j),end=' ')
    print(' ')

# 货币转换
a=input()
if a[0:2] in 'RMB':
    USD=eval(a[3:])/6.78
    print("USD{:.2f}".format(USD))
elif a[0:2] in 'USD':
    RMB=eval(a[3:])*6.78
    print("RMB{:.2f}".format(RMB))

基本数据

数字类型

整数类型

十进制前无引导
二进制 0b或0B 即0B101
八进制0o或0O
十六进制0x或0X
整数类型没有取值范围限制

浮点数类型

4.3e-2=0.043
Round(x,d)对x进行四舍五入，d是截取位数
因为0.1+0.2!=0.3

复数类型

12+4j或J
分别求取其实属部分和虚数部分，如对z字母操作
Z.real 实数 z.imag虚数

数字操作

操作符

//整数商
X**y x的y次幂
Int(X) 将x转化为整数，x可为浮点或字符串
Float(x) x可为整数或字符串
Complex(re,im)生成一个复数

字符串操作

字符串切片：

[1:8:2]:根据2这个步长来进行切片
[::-1]：倒序输出

字符串操作

连接两个字符串a+b
子串x in s

字符串处理函数

len(x)返回字符串长度，汉字英文字母符号均被认为是一个
str(x)将任意类型转换为字符串形式，与eval功能相反
hex(x)转换为十六进制
oct(x)转换为八进制
chr(u)u为Unicode编码，返回其对应字符
ord(x)x为字符，返回其对应的Unicode编码
chr(x) ord(x) (均对单字符操作)
1004对勾 9801金牛
输出十二星座符号

for i in range(12):
			print(chr(9800 + i),end=' ')
♈ ♉ ♊ ♋ ♌ ♍ ♎ ♏ ♐ ♑ ♒ ♓

内置字符串操作方法

str.lower()或str.upper()全部字符改为小写/大写
‘AbC’.lower()结果为 abc
str.split(sep=None)根据sep分割部分
‘A,B,C’.split(‘,’)结果为[‘A’, ‘B’, ‘C’]
str.count(sub)返回字串sub在str 中出现的次数
str.replace(old,new) 将old子串替换为new
str.center(width[,fillchar])字符串根据长度居中
其余填充为char的字符
str.strip(chars)去掉左右侧chars中列出的字符
‘= python=’.strip(‘ =np’)结果为 ‘ytho’
srt.join(iter) iter每个元素间增加一个str
‘,’.join(‘12345’)结果为 ‘1,2,3,4,5’

字符串格式化

槽 {}
参数槽{2}对应着.format 中第三个元素
{<参数序号>:<格式控制标记>}

• 格式:{:<填充><对齐><宽度><,><.精度><类型>}
• 填充:用于填充的单个字符
• 对齐:<左对齐 >右对齐 ^上对齐
• 宽度:槽设定的输出宽度
• ,数字的千位分隔符
• .精度:浮点小数精度或 字符串最大输出长度
• 类型:
  整数类型: b二进制,c字符Unicode形式,d十进制,
  o八进制, x,X十六进制
  浮点数类型:e,E科学计数法数,f通常形式,
  %百分数形式
• 例子：
  {0:,.2f}.format(12345.6789) 12,345.68

time库

时间获取

time.time()很长的浮点数
time.ctime()返回字符串 ‘Sun Feb 9 13:02:55 2020’
time.gmtime()计算机可处理的时间格式
time.struct_time(tm_year=2020, tm_mon=2, tm_mday=9, tm_hour=5, tm_min=4, tm_sec=26, tm_wday=6, tm_yday=40, tm_isdst=0)

时间格式化

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

>>>t = time.gmtime()
>>>time.strftime(“%Y-%m-%d %H:%M:%S”,t)
	‘2020-02-09 13:13:20’

%Y年份
%m月份 %B月份名称 %b月份缩写
%d 日期
%A 星期 %a星期缩写
%H 小时(24h制) %i 小时(12h制) %p 上午/下午
%M 分钟
%S 秒
strptime(str,tpl)
str字符串形式的时间值
tpl 格式化模板字符串，定义输入效果

>>>timeStr = ‘2020-02-09 13:13:20’
>>>time.strptime(timeStr,“%Y-%m-%d %H:%M:%S”)
	time.struct_time(tm_year=2020, tm_mon=2, tm_mday=9, tm_hour=5, tm_min=4, tm_sec=26, tm_wday=6, tm_yday=40, tm_isdst=0)

程序计时

perf_counter()返回一个CPU级别的精准时间计数值

>>>start = time.perf_counter()
			……
>>>end = time.perf_counter()
>>>end – start
	22.246465166546112

sleep() 休眠
文本进度条
/r 刷新关键

库引用

import turtle
from <库名>import <函数名>
from <库名>import *<函数名>
import <库名> as <库别名>
循环语句
for <变量> in range(<参数>):
<被循环执行的语句> 0-(参数-1)

range(N) 0–(N-1) N个
range(M,N) M–(N-1) N-M个

程序的控制结构

程序分支结构

单分支结构:

if<条件>:
<语句块>

二分支结构:

if<条件>:
<语句块1>
else:
<语句块2>
或：
<语句块1> if <条件> else <语句块2>

多分支结构:

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

与：x and y
或：x or y
非：not x
一直表示真值：TRUE

异常处理的使用

try:
<语句块1>
expect(<异常类型>):
<语句块2>
try中运行异常则运行expect语句
NameError 输入错误

高级异常处理:

try:
<语句块1>
expect(<异常类型>):
<语句块2>
else:
<语句块3>
finally:
<语句块4>
先执行1，如果报错执行2，不报错执行3，最后一起执行4

程序的循环结构

遍历循环

for <循环变量> in <遍历结构> :
<语句块>

计数循环:

for i in range(M,N,K)
<语句块>

字符串遍历循环

for c in s:
<语句块>
for c in ‘PYTHON’:
print(c, end= ‘,’)//P,Y,T,H,O,N

列表遍历循环

for item in ls:
<语句块>
for item in [123, ‘PY’, 456]:
print(item, end= ‘,’)//123,PY,456

文件遍历循环

for line in fi:
<语句块>
fi是一个文件标识符，遍历其每行，产生循环

无限循环

while <条件>:
<语句>         //按ctrl+c退出

循环控制
break:跳出并结束当前循环，向后执行
continue:结束当次循环，进行下一循环
else在循环中的使用:

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

如果程序正常结束则执行else,如果是break退出的程序则不执行

while <条件>:
<语句块1>
else:
<语句块2>

random库

使用随机数的Python标准库
伪随机数 import random
seed(a=None)初始化随机数种子，默认为当前系统时间
random.seed(10)
random()产生0到1之间的随机小数
random.random()

randint(a,b):生成[a,b]之间的整数
randrange(m,n[,k]):生成一个[m,n)之间以k为步长的整数
getrandbits(k)生成一个k比特长的随机整数
uniform(a,b)生成一个[a,b]之间的随机小数
choice(seq) 从序列seq中随机选择一个元素
>>>random.choice([1,2,3,4])
3
shuffle(seq)打乱排序一个序列
>>>random.shuffle([1,2,3,4])
[3,2,4,1]

如果公式一行打不下末尾跟上一个 \ 就可以换到下一行去打
from random import random 只加载random库中random

函数

def<函数名>(<参数>):
<函数体>
return <返回值>
计算阶乘:
def fact(n):
s = 1
for I in range(1, n+1)
s *= i
return s

def fact(n, m=1)
调用的时候是:fact(10) //n=10,m=1
fact(10,5) //n=10,m=5
fact( m=5, n=10) //n=10,m=5

可变自定义函数定义:
def <函数名> (<参数>, *b):

def fact(n, *b):
sum = 0
sum+=n
for item in b:
sum+=item
return sum

>>>print(fact(10,3,5))  //18
>>>print(fact(10,3))    //13 

函数返回多个值:
def fact(n):
s = 1
for I in range(1, n+1)
s *= i
return s, n, m
>>>(725760, 10, 5) 元组类型
或者: a, b, c = fact( 10, 5)

局部变量不影响全局变量:
n ,s = 10, 100
def fact(n):
s = 1 //内部s不影响外部s
for i in range(1, n+1):
s *= i
return s
print(fact(n), s) //>>>362800 100

n ,s = 10, 100
def fact(n):
global s //声明一个全局变量s
for i in range(1, n+1):
s *= i
return s
print(fact(n), s) //>>>362800 362800

局部变量为组合数据类型且未创建,等同于全局变量
ls = [‘F’, ‘f’]
def func(a):
ls.append(a)
return
func(‘C’)
print(ls)
>>>[‘F’, ‘f’, ‘C’]

ls = [‘F’, ‘f’]
def func(a):
ls = [] //此ls在此函数运行结束后就被释放了
ls.append(a)
return
func(‘C’)
print(ls)
>>>[‘F’, ‘f’]

lambda函数
<函数名> = lambda <参数> : <表达式>
等价于:
def <函数名＞

# 斐波那契数列
def fbi(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fbi(n-1) + fbi(n-2)

n = eval(input())
print(fbi(n))

# 汉诺塔实践
steps = 0

def hanoi(src, des, mid, n):
    global steps
    if n == 1:
        steps += 1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))
    else:
        hanoi(src, mid, des, n-1)
        steps += 1
        print("[STEP{:>4}] {}->{}".format(steps, src, des))        
        hanoi(mid, des, src, n-1)

N = eval(input())
hanoi("A", "C", "B", N)

集合

集合

建立集合：
集合不包括重复元素
a = {‘Python’, 123, (‘python’, 12)}
>>>{‘Python’, 123, (‘python’, 12)}

	b = set{‘pypy’}
	>>>{‘p’, ‘y’, ‘p’, ‘y’}	

	c = {123, 123}
	>>>{123} 

集合间操作：

	S|T
	S-T
	S&T
	S^T

S<=T 或 S S>=T 或 S>T 返回True/False 判定S和T 的包含关系

S|=T 更新集合S，包括在集合S和T中的所有元素
S-=T 更新集合S，包括在集合S但不在T中的元素
S&=T 更新集合S，包括同时在集合S和T中的元素
S^=T 更新集合S，包括在集合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
set(x) 将其他类型变量x转变为集合类型
序列类型:(向量)
字符串形式，元组类型，列表类型
in
not in
+直接连接
*复制
s[i]索引
s[i:j]切片
[::-1]取反
len(s)长度
min(s)max(s)
s.index(x)或s.index(x,i,j)第一次出现x的位置

元组

创建后不可修改,()或tuple(,)
可以元组套元组:
>>>a= (‘1’, ‘2’)
>>>b= (‘A’, ‘3’, a)
>>>((‘A’, ‘3’, (‘1’, ‘2’))
元组调用

>>>creature = (1, 2, 3)
>>>color = (red, blue, creature)
>>>color[-1][2]

列表

创建后可被修改
方括号[]或list() 创建,元素用逗号分隔
>>> ls = [‘a’, ‘b’, ‘c’, 1024]
>>> lt =ls

ls[i] = x 替换为x
ls[i: j: k] = lt 用lt替换为ls切片
del ls[i] 删除该元素
del ls[i:j:k]
ls += lt //ls后部续上lt
ls *= n //内部元素
ls.append(x) 在列表后增加元素x
ls.clear() 删除列表中所有元素
ls.copy() 生成新列表,等于ls
ls.insert(i, x) 在列表ls的第i位置增加元素x
ls.pop(i)将列表ls中第i位置取出并删除该元素
ls.reverse()将列表反转

将列表改为元组类型：
lt = tuple( [‘c’, ‘d’])
(‘c’, ‘d’)

sorted()可以对列表进行排序

字典类型:
{<键1>:<值1>,<键2>:<值2>,……,<键n>:<值n>}
<字典变量> = {<键1>:<值1>,……,<键n>:<值n>}
<值> = <字典变量>[<值>]
<字典变量>[<值>] = <值>

>>>d = {‘中国’: ‘北京’, ‘美国’: ‘华盛顿’}
>>>d[‘中国’]
    ‘北京’

使用{}生成一个空的字典

>>>de = {};
>>>type(de)//type用于返回变量x的类型
    

d.update
del d[k]删除字典d中键k对应的数据值
k in d 判断键k是否在字典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中元素个数

jieba库

分词第三方库
中文文本需要通过分词获得单个的词语

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

jieba.lcut(s) 精确模式
>>>jieba.lcut(‘中国是一个伟大的国家’)
>>>[‘中国’,‘是’,‘一个’,‘伟大’,‘的’,‘国家’]
jieba.lcut(s,cut_all=True) 全模式
>>>jieba.lcut(‘中国是一个伟大的国家’,cut_all=True)
>>>[‘中国’,‘国是’,‘是’,‘一个’,‘伟大’,‘的’,‘国家’]
jieba.lcut_for_search(s)
>>>jieba.lcut_for_search(‘中华人民共和国是伟大的’)
>>>[‘中华’,‘华人’,‘人民’,‘共和’,‘共和国’,‘中华人民共和国’,‘是’,‘伟大’,‘的’]
jieba.add_word(w)向词典增加新词
>>>jieba.add_word(“蟒蛇语言”)

文件

文本文件:可被认为是长字符串 如txt, py
二进制文件:直接由01组成，没有字符编码例如avi, jpg

读文件:
a.read(size)
a.readline(size)
a.readlines(hint)
写文件:
a.write(s)
a.writelines(lines)
s.seek(offset)
文件打开:
<变量名> = open(<文件名>, <打开模式>)
文件路径名称 文本or二进制 读or写
‘r’只读方式打开,文件不存在返回FileNotFoundError
‘w’覆盖写,文件不存在则创建,存在则覆盖
‘x’创建写模式,文件不存在则创建,存在则返回FileExistsError
‘a’追加写模式,文件不存在则创建,存在在文件后追加内容

‘b’二进制文件模式
‘t’文本文件模式

‘+’与rwxa一同使用,在原功能基础上增加同时读写功能

默认值是 ‘rt’

文件打开:
<变量名>.close()

文件内容读取:
.read(size=-1)
读入全部内容,默认为-1或读入前size长度
.readline(size=-1)
读入一行内容,默认为-1或读入该行前size长度
.readlines(hint=-1)
读入所有行内容,默认为-1或读入前hint行长度

遍历全文本:方法一
fname = input(“请输入要打开的文件名称:”)
fo = open(fname, “r”)
txt = fo.read()
#对全文txt进行处理
fo.close()

遍历全文本:方法二 有助于处理大文件
fname = input(“请输入要打开的文件名称:”)
fo = open(fname, “r”)
txt = fo.read(2)
while txt != “”:
#对txt进行处理
txt = fo.read(2)
fo.close()

逐行遍历文件:方法一
fname = input(“请输入要打开的文件名称:”)
fo = open(fname, “r”)
for line in fo.readlines():
print(line)
fo.close()

逐行遍历文件:方法二
fname = input(“请输入要打开的文件名称:”)
fo = open(fname, “r”)
for line in fo:
print(line)
fo.close()

文件写入:
.write(s) 向文件写入一个字符串
.writelines(lines)
将一个列表全为字符串的列表写入文件

>>>ls = [“中国”, “美国”]
>>>f.writelines(ls)直接拼接后写入文件

中国美国
.seek(offset)改变当前文件操作指针的位置
0- 文件开头 1-当前位置 2-文件结尾

一维数据:
数据读入:
空格分割:
fname.txt:中国 美国
txt = open(fname).read()
ls = txt.split()
f.close()
>>>ls = [‘中国’, ‘美国’]
特殊符号分割:
fname.txt:中国$美国txt=open(fname).read()ls=txt.split(“$”)
f.close()
>>>ls = [‘中国’, ‘美国’]

数据写入:
空格分割:
ls = [‘中国’, ‘美国’]
f = open(fname, ‘w’)
f.write(‘ ’.join(ls))
f.close()
特殊符号分割:
ls = [‘中国’, ‘美国’]
f = open(fname, ‘w’)
f.write(‘$’.join(ls))
f.close()
二维数据:
使用列表类型:
[ [3,4,5] [5,6,7] ]两层循环

CSV:Comma-Separated Values
国际通用的一二维数据存储格式，后缀为.csv
每行一个一维数据，由逗号来分开，无空行
可以用excel

数据读入: (从CSV文件中读入数据)
fo = open(fname)
ls = []
for line in fo:
line = line.replace(“\n”, “”)
ls.append(line.split(“,”))
fo.close()

数据写入: (从CSV文件中写入数据)
ls = [ [], [], [] ] #二位列表
f = open(fname, ‘w’)
for item in ls:
f.write(“,”.join(item) + ‘\n’)
f.close()

循环遍历:
#采用二次循环
ls = [ [1,2], [3,4], [5,6] ]
for row in ls:
for column in row:
print(column)

#数据文件写入
fo = open("outpu.txt","w+")
ls = ["中国","美国"]
fo.writelines(ls)

fo.seek(0)
#如果没有这个的话就会继续刚才的位置继续读，而不是从头读

for line in fo:
    print(line)
fo.close()

#CalHamletV1.py
#文本词频1
def getText():
    txt = open("halmet.txt","r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<>=?@[\\]^_"{|}~':
        txt = txt.replace(ch, " ")
    return txt

hamletTxt = getText()
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, counts = items[i]
    print("{0:<10}{1:>5}".format(word, counts))

#CalThreeKingdomsV1.py
#文本词频2
import jieba

txt = open("threekindoms.txt","r", encoding="utf-8").read()
words = jieba.lcut(txt)
counts = {
     }
for word in words:
    if len(word) == 1:
        continue
    else:
        counts[word] = counts.get(word,0) + 1
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

#CalThreeKingdomsV2.py
#文本词频3
import jieba

txt = open("threekindoms.txt","r", encoding="utf-8").read()
excludes = {
     "将军","却说","荆州","二人","不可","不能","如此"}
words = jieba.lcut(txt)
counts = {
     }
for word in words:
    if len(word) == 1:
        continue
    elif word == "诸葛亮" or word == "孔明曰" :
        rword = "孔明"
    elif word == "关公" or word == "关云长" :
        rword = "关羽"
    elif word == "玄德" or word == "玄德曰" :
        rword = "刘备"
    elif word == "孟德" or word == "丞相" :
        rword = "曹操"
    else:
        rword = word
    counts[rword] = counts.get(rword,0) + 1
for word in excludes:
    del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

wordcloud库

将文本变为词云
w = wordcloud.WordCloud()

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

>>>w.generate(“Python and WordCloud”)
	w.to_file(filename)

将词云输出为图像文件，.png或.jpg格式默认为400*200

w = wordcloud.WordCloud(<参数>)
width=600 height=400默认为400*200
min_font_size=10(默认4)
max_font_size=20 最大最小间隔
font_path=“msyh.ttc”指定字体为微软雅黑，默认None
max_words=20 显示最大单词数量，默认200
stop_words=(“Python”)不显示的单词
background_color = “white”

显示不是矩形的词云形状:
>>>from scipy.misc import imread
>>>mk = imread(“pic.png”)
>>>w = wordcloud.WordCloud(mask = mk)

import wordcloud

txt = "life is short, you need Python"
w = wordcloud.WordCloud(\
    background_color = "white")
w.generate(txt)
w.to_file("pywcloud.png")

import jieba
import wordcloud

txt = "程序设计是计算机能够理解和\
识别用户操作意图的一种交互体系，它按照\
特定规则组织计算机指令，使计算机能够自\
动进行各种运算处理"
w = wordcloud.WordCloud( width=1000,\
    font_path = "msyh.ttc", height=700)
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")

#GovRptWordCloudv1.py
# 政府工作报告
import jieba
import wordcloud

f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()

ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud( font_path="msyh.ttc",\
    width = 1000, height = 700,\
    background_color="white")
w.generate(txt)
w.to_file("grwordcloud.png")

OS库

os.path.abspath(path)绝对路径
os.path.normpath(path)归一化表示形式，用\ 分割路径
os.path.relpath(path)程序与文件之间的相对路径
os.path.dirname(path)返回文件的目录名称
os.path.basename(path)返回path中最后的文件名称
os.path.join(path, *paths)返回一个组合后的路径字符串
os.path.exists(path)判断该文件是否存在
os.path.isfile(path)判断该字符串是否是个文件
os.path.isdir(path)判断该字符串是否是个目录
os.path.getaatime(path)返回上一次访问时间
os.path.getmtime(path)上一次修改时间
os.path.getctime(path)返回创建时间
os.path.getsize(path)文件大小，单位:字节
os.system(“应用程序”)运行该程序后，正常运行返回一个0
os.system(“应用程序 文件”)用应用程序打开某个文件
os.chdir(path) 修改当前程序操作的路径
os.getcwd()返回当前路径
os.getlogin()获取当前系统登陆用户名称
os.cpu_count()获得CPU数量
os.urandom(n)获得n个字节长度的随机字符串

# Pandas尝试
import pandas as pd
from plotly import figure_factory as FF
from plotly.offline import plot

data=pd.DataFrame([["1111",'ZHJ','OKOK'],["2222",'FZY','HHHH']],columns=("code","name","shit"))
table=FF.create_table(data)
plot(table,show_link=False)

Tips

1. 将列表中的字符串转为数字
   numbers = [‘1’, ‘5’, ‘10’, ‘8’]变为[1, 5, 10, 8]
   numbers = [ int(x) for x in numbers ]
2. Scrapy:数据分析高层次应用库
3. Pyspider:强大的Web页面爬取系统 requests
4. Beautiful Soup:HTML和XML的解析库
5. Re正则表达式解析和处理功能库
6. Python-Goose:提取文章类型web页面功能
7. Django:构建web系统的基本应用框架, MTV(model模型,Template模板,Views视图)大型的
9. Pyramid:规模适中的Web应用框架
10. Flask:Web应用开发微框架
11. WeRoBot:微信公众号开发框架
12. aip百度AI开放平台接口
13. MyQR:生成二维码
14. PyQt5:Qt开发框架的Python接口 ，完备GUI(图形界面)
15. wxPython跨平台GUI开发框架
16. PyGObject使用GTK+开发GUI的功能库
17. PyGame游戏开发功能基于SDL
18. Panda3D开源跨平台的3D渲染和游戏开发库
19. cocos2d:构建2D游戏和图形界面交互式应用的框架，基于OpenGL支持GPU加速
20. VR Zero 开发VR应用的Python库
21. pyovr:Oculus VR设备库
22. Vizard:基于Python的通用VR开发引擎
23. Quads:迭代的艺术，形成像素风格
24. ascii_art ：ASCII艺术库
25. Random Art:用turtle
26. 双层循环
27. 二位数组初始化a = [[0 for i in range(n)] for j in range(n)]
28. 输入多个数字hang, num = map(int, input().split(" "))
29. 多种符号分割的输入a, b, c, d = map(int, re.split(’\s’, input()))
30. 两重循环直接退出

  for i in range(n):
          for j in range(n):
              if i > j and x[i][j] != 0:
                  print("NO")
                  break
          else:
              continue
          break
      else:
          print("YES")

31. 字典形式形成四则运算

  try:
      res = {
     '+': a + b, '-': a - b, '*': a * b, '/': a / b}
      print(f"{res[op]:.2f}")
  except:
      print("divided by zero")

32. 字符串替换

  a = a.replace('[', '').replace(']', '').replace('(', '')

33. 打印列表,用分隔符分开

  print(*ls, sep=' ')

34. 统计某字符b在a字符串中出现的次数

  a.count(b)