Python语言程序设计--学习笔记

<>点击学习PY

以下为本人学习嵩老师python学习笔记，如有侵权，请联系删除，谢谢

0.字符串基础知识

#字符串知识点
"""
字符串是由0个或多个字符组成的有序字符序列
字符串由一堆单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引
转义字符:\b回退 \n换行 \r回车

x+y:连接两个字符串x和y
n*x 或 x*n:复制n次字符串x
x in s:如x是s的子串返回True否则返回False
len(x)：返回字符串x的长度
str(x):将任意类型x的字符串形式
hex(x):整数x的十六进制小写字符串
oct(x):整数x的八进制小写字符串
chr(u):u为Unicode编码，返回其对应的字符
ord(x):x为字符,返回其对应的Unicode编码(整数)

字符串的方法:
1.str.lower():将字符串str转换为小写
2.str.upper():将字符串str转换为大写
3.str.split(sep=None):返回一个列表,由sep分隔
如"A,B,C".split(",")-->['A','B','C']
4.str.count(sub):返回子串sub在str中出现的次数
5.str.replace(old,new):将str中old子串替换为new
6.str.center(width[,fillchar]:将字符串str根据宽度width居中,fillchar可选
如"python".center(20,"=")-->=======python=======
7.str.strip(chars):从str中去掉在其左侧和右侧chars中列出的字符
如"= python= ".strip(" =np")-->ytho
8.str.join(iter):在iter变量除最后元素外每个元素后增加一个str
如",".join(12345)-->1,2,3,4,5#主要用于字符串分隔
"""
Str="python"
print(Str[0])#返回字符串的第一个字符p
print(Str[-1])#返回字符串的最后一个字符n
print(Str[0:-1])#返回字符串中除了最后一个字符外的字符串pytho
print(Str[1:3])#返回第1个字符串到第2个字符串yt
print(Str[::-1])#将字符串翻转输出
print(Str[:4])#开始位置省略表示取出开头到第3个字符
print(Str[0:])#结束位置省略表示取出开头到结尾

print("1+1=2"+chr(1004))#1+1=2Ϭ
print("这个字符串a的Unicode编码是:"+str(ord("a")))
for i in range(12):
    print(chr(9800+i),end='')#♈♉♊♋♌♍♎♏♐♑♒♓
    

1.温度转换

#温度转换练习1.py
tempstr=input("请输入带有单位符号(F/C)的温度值:")
if tempstr[-1] in ['F','f']:#温度单位是大写或者小写
    C=(eval(tempstr[0:-1])-32)/1.8#从tempstr中第0位置取到最后一个位置不包含最后一个位置
    print("转换后的温度是{:.2f}C".format(C))
elif tempstr[-1] in ['C','c']:
    F=1.8*eval(tempstr[0:-1])+32
    print("转换后的温度是{:.2f}F".format(F))#{:.2f}取两位有效数字
else:
    print('输入格式错误')

2.turtle库之蟒蛇绘制

#蟒蛇绘制
import turtle as t

t.setup(650,350,200,200)

t.penup()#抬起笔，不然后退会画出一条线
t.fd(-250)
t.pendown()#落笔准备画线
t.pensize(25)
t.pencolor("purple")
t.seth(-40)#turtle.seth(angle):只改变海龟的行进方向,角度按逆时针为正

for i in range(4):
    t.circle(40,80)#turtle.circle(r,extent=None)根据半径r，绘制一个extent角度的弧度
    t.circle(-40,80)
t.circle(40,80/2)
t.fd(40)
t.circle(16,180)
t.fd(40*2/3)
t.done()#turtle.done()用来停止画笔绘制,但绘图窗体不关闭

3.BMI指数计算

#BMI.py
height,weight=eval(input("请输入身高(cm)和体重(公斤),逗号隔开:"))
bmi=weight/pow(height/100,2)

print("BMI数值为：{:.2f}".format(bmi))
who,nat="",""
if bmi<18.5:
    who,nat="偏瘦","偏瘦"
elif 18.5

4.货币转换

#货币转换 I 
ls=input()

if ls[0:3].upper()=="RMB":
    USD=eval(ls[3:])/6.78
    print("USD{:.2f}".format(USD))
elif ls[0:3].upper()=="USD":
    RMB=eval(ls[3:])*6.78
    print("RMB{:.2f}".format(RMB))

5.时钟

# coding=utf-8
  
import turtle
from datetime import *
  
# 抬起画笔，向前运动一段距离放下
def Skip(step):
    turtle.penup()
    turtle.forward(step)
    turtle.pendown()
  
def mkHand(name, length):
    # 注册Turtle形状，建立表针Turtle
    turtle.reset()
    Skip(-length * 0.1)
    # 开始记录多边形的顶点。当前的乌龟位置是多边形的第一个顶点。
    turtle.begin_poly()
    turtle.forward(length * 1.1)
    # 停止记录多边形的顶点。当前的乌龟位置是多边形的最后一个顶点。将与第一个顶点相连。
    turtle.end_poly()
    # 返回最后记录的多边形。
    handForm = turtle.get_poly()
    turtle.register_shape(name, handForm)
  
def Init():
    global secHand, minHand, hurHand, printer
    # 重置Turtle指向北
    turtle.mode("logo")
    # 建立三个表针Turtle并初始化
    mkHand("secHand", 135)
    mkHand("minHand", 125)
    mkHand("hurHand", 90)
    secHand = turtle.Turtle()
    secHand.shape("secHand")
    minHand = turtle.Turtle()
    minHand.shape("minHand")
    hurHand = turtle.Turtle()
    hurHand.shape("hurHand")
    
    for hand in secHand, minHand, hurHand:
        hand.shapesize(1, 1, 3)
        hand.speed(0)
    
    # 建立输出文字Turtle
    printer = turtle.Turtle()
    # 隐藏画笔的turtle形状
    printer.hideturtle()
    printer.penup()
     
def SetupClock(radius):
    # 建立表的外框
    turtle.reset()
    turtle.pensize(7)
    for i in range(60):
        Skip(radius)
        if i % 5 == 0:
            turtle.forward(20)
            Skip(-radius - 20)
            
            Skip(radius + 20)
            if i == 0:
                turtle.write(int(12), align="center", font=("Courier", 14, "bold"))
            elif i == 30:
                Skip(25)
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))
                Skip(-25)
            elif (i == 25 or i == 35):
                Skip(20)
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))
                Skip(-20)
            else:
                turtle.write(int(i/5), align="center", font=("Courier", 14, "bold"))
            Skip(-radius - 20)
        else:
            turtle.dot(5)
            Skip(-radius)
        turtle.right(6)
         
def Week(t):  
    week = ["星期一", "星期二", "星期三",
            "星期四", "星期五", "星期六", "星期日"]
    return week[t.weekday()]
  
def Date(t):
    y = t.year
    m = t.month
    d = t.day
    return "%s %d%d" % (y, m, d)
  
def Tick():
    # 绘制表针的动态显示
    t = datetime.today()
    second = t.second + t.microsecond * 0.000001
    minute = t.minute + second / 60.0
    hour = t.hour + minute / 60.0
    secHand.setheading(6 * second)
    minHand.setheading(6 * minute)
    hurHand.setheading(30 * hour)
     
    turtle.tracer(False)
    printer.forward(65)
    printer.write(Week(t), align="center",
                  font=("Courier", 14, "bold"))
    printer.back(130)
    printer.write(Date(t), align="center",
                  font=("Courier", 14, "bold"))
    printer.home()
    turtle.tracer(True)
  
    # 100ms后继续调用tick
    turtle.ontimer(Tick, 100)
  
def main():
    # 打开/关闭龟动画，并为更新图纸设置延迟。
    turtle.tracer(False)
    Init()
    SetupClock(160)
    turtle.tracer(True)
    Tick()
    turtle.mainloop()
  
if __name__ == "__main__":
    main()

6.正方形绘制

#正方形绘制
import turtle as t
t.setup(600,400)#turtle.setup(width=800,height=800, startx=100, starty=100)
t.penup()
t.fd(-100)
t.pendown()
t.pensize(5)
t.pencolor("black")
for i in range(4):
    #t.seth(360-i*90)
    t.left(90)
    t.fd(100)
t.done()

7.正方形绘制

#六边形形绘制
import turtle as t
t.setup(600,400)#turtle.setup(width=800,height=800, startx=100, starty=100)
t.penup()
#t.fd(-100)
t.pendown()
t.pensize(5)
t.pencolor("black")
for i in range(6):
    t.left(360/6)
    t.fd(100)
t.done()

8.风轮绘制

#风轮绘制
import turtle as t
t.setup()
t.pensize(5)
for i in range(4):
    t.fd(150)#直线150
    t.right(90)#转90度
    t.circle(-150,360/8)#顺时针以-150为半径，角度360/8画弧度
    t.right(90)#画完弧度后右转
    t.fd(150)#行进150回到原点
    t.right(45)
t.done()

9.天天向上的力量

#天天向上的力量
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=dayfactor+0.001
print("工作日的努力参数是:{:.3f}".format(dayfactor))

10.圆面积计算

#圆面积计算
r=int(input("请输入半径:"))
s=3.1415*pow(r,2)
print("{:.2f}".format(s))

11.绘制五角星

#绘制五角星
from turtle import *
color('red','red')
begin_fill()
for i in range(5):
    fd(200)
    rt(144)#箭头方向向右旋转x度。
end_fill()

12.转换星期几

#转换星期几
s=int(input())
ss="一二三四五六日"
print(ss[s-1])

13.文本进度条

#文本进度条
import time
scale=50
start=time.perf_counter()
for i in range(scale+1):
    a='*'*i#复制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=''))
    #\r输出一行后换行
    
#{:^3.0f}--->:引导符 ^居中 3宽度 .代表精度 0f为不取小数位,2f为取2位小数位
#
#

#
#
    
time.sleep(0.2)

14.format格式化方法控制

#format格式化方法控制
a="{:=^20}".format("PYTHON")
#输出20个=，PYTHON在中间对齐
print(a)

a="{0:*>20}".format("BIT")
#右对齐输出20个*+BIT

print(a)
a="{:10}".format("BIT")

print(a)

15.时间格式化

#时间格式化
import time
#t=time.gmtime()#获取当前时间，表示为计算机可处理的时间格式--格林时间不适合
t=time.localtime(time.time())#格式化时间戳time.time()为本地的时间
t1=time.strftime("%Y-%m-%d %H:%M:%S %p %A",t)#格式化时间
print(t1)


timeStr='2020-08-31 15:15:22 PM Monday'
print(time.strptime(timeStr,"%Y-%m-%d %H:%M:%S %p %A"))#表示为计算机可处理的时间格式


start=time.perf_counter()#返回一个CPU级别精确时间计数值,一般用于计算时间差
print(start)
time.sleep(1)#延时单位1秒
#计算时间差
end=time.perf_counter()
print("时间差/耗时:"+str(end-start))

16.随机数练习

import random
#random.seed(100)#产生种子10对应的序列
print(random.random())#生成0.0~1.0之间的随机小数 ,第一次都生成0.5714025946899135
print(random.random())#第二次都生成0.4288890546751146
print(random.randrange(1,10,2))#生成一个[1,10]之间的随机数奇数
print(random.randrange(2,10,2))#生成一个[1,10]之间的随机数偶数
print(random.uniform(10,100))#生成10~100之间的随机小数

print(
random.choice([1,2,3,4,5,6,7,8,9]))#从序列中随机选择一个元素

#将序列打乱后输出
s=[1,2,3,4,5,6,7,8,9]
random.shuffle(s)
print(s)

17.函数参数传递

#函数参数传递

def fact(n,*b):
    s=1
    for i in range(1,n+1):
        s*=i
    for item in b:
     s*=item
     return s
print(fact(10,3))
print(fact(10,3,5,8))

def fact1(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m
print(fact1(10))#默认m=1
print(fact1(10,5))#指定m=5

18.七段数码管

#七段数码管的绘制
import turtle as t
import time
def drawgap():
    t.pu()
    t.fd(5)
def drawline(draw):#绘制单段数码管
    t.pendown() if draw else t.penup()
    t.fd(40)
    drawgap()
    t.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)
    t.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)
    t.left(180)
    t.pu()#为绘制后续数字确定位置
    t.fd(20)#为绘制后续数字确定位置
def drawdate(date):#获取日期
    t.pencolor("green")
    for i in date:
        if i == '年':
            t.write('年',font = ("Arial",18,"normal"))
            t.pencolor("blue")
            t.fd(40)
        elif i == "月":
            t.write('月',font = ("Arial",18,"normal"))
            t.pencolor("yellow")
            t.fd(40)
        elif i == "日":
            t.write('日',font = ("Arial",18,"normal"))
            t.pencolor("red")
        else:
            drawdigit(eval(i))#通过eval()将数字变成整数
def main(date):
    t.setup(1500,650,20,20)
    t.pu()
    t.fd(-600)
    t.pensize(5)
    drawdate(time.strftime("%Y年%m月%d日",time.gmtime()))
    t.fd(40)
    t.color("red")
    drawdate(date)
    t.hideturtle()
    t.done()
main(input("请输入一个年月日，例：2019年01月22日:\n"))

19.函数的递归

#函数的递归
#链条:计算过程存在的递归链条
#基例：存在一个或多个不需要再次递归的基例
#计算n！
def fact(n):
    if n==0:
        return 1
    else:
        return n*fact(n-1)
print(fact(3))

#将字符反转后输出
def rvs(s):
    if s=="":
        return s
    else:
        return rvs(s[1:])+s[0]#每次将第一个字符放到最后
print(rvs("123456789"))

20.集合类型

#集合类型
A={"python",123,("python",123)}
print(A)

B=set("python123")#使用set()建立集合

print(B)#输出是不按顺序的

C={"python",123,"python"}
print(C)#集合具有唯一性，重复的将被去重


#知识列子1
A=set("py1")
B=set("thon1")
print(A|B)#{'1', 'y', 'n', 'h', 'o', 'p', 't'}-->并：包括A和B中的所有元素
print(A-B)#{'p', 'y'}差-->在A中但不在B中的元素
print(A&B)#{'1'}交-->同时在A中也在B中的元素
print(A^B)#{'o', 'p', 't', 'n', 'h', 'y'}补-->A和B中非相同元素

#知识列子2
A=set("py")
B=set("python")

print(A<=B)#判断A是否在B中-->True

print(B>=A)#判断B是否包含A-->True

#知识列子3

A=set("py")
B=set("thon")

A|=B#A=A|B 并,更新集合A,包括A和B中的所有元素

A-=B#A=A-B

A&=B#A=A&B

A^=B#A=A^B

#知识列子4 ->方法
A=set("python")

A.add(123)#如果123不在集合A中，则将123加到集合A中，不限类型
print(A)#-->{'t', 'n', 'h', 'p', 'o', 123, 'y'}

print(
A.pop())#随机取出A集合中的一个元素并更新集合A,A为空产生KeyError
print(A)

A.discard(123)#移除A集合汇总的元素123，如果123不在集合A中也不报错

print(A)
#A.remove(123)#移除A集合中的123,123不在集合A中，报错-->KeyError: 123

print(A)
A.clear()#清楚A集合中的所有元素


print(A)#-->输出set()

A=set("python")
B=A.copy()#返回集合A的一个副本
print(B)
print(len(A))#返回A集合中元素的个数=6
print("p" in A)#判断p在集合A中则返回True
print("p" not in A)#判断p不在集合A中则返回True


#知识列子5

ls=['p','y','p','y','123']#定义列表
s=set(ls)#将列表转换为集合类型
print(s)#{'y', '123', 'p'} 利用集合无重复元素的特点去重复

21.序列类型知识点

#序列类型（文本串可以看做是一个序列）
x="py"
s="python"
t=" is very good"
print(x in s)#如果x是序列s的元素，返回True
print(x not in s)#如果x不是序列s的元素，返回True
print(s+t)#连接连个序列
print(s*5,5*s)#将序列S复制N次
print(s[0])#返回s的第0个元素
print(s[0:3])#切片,返回序列s第0~3-1个元素
print(s[0:3:2])#切片,返回序列s第0~3-1个元素，每次个2位
print(s[::-1])#将字符反转
print(len(s))#返回序列s的长度，即元素的个数
print(min(s))#返回序列中最小的元素(前提是可比较，字母数字都是可以比较)
print(max(s))#返回序列中最大的元素(前提是可比较，字母数字都是可以比较)
print(s.index('o'))#返回序列s中第一次出现字符‘o’的索引位置
print(t.count('o'))#返回序列S中出现的‘o’总次数

ls=["python",123,".io"]
print(len(ls))#len(ls)=3

22.元组和列表类型

#元组和列表类型
#1.元组是一种序列类型，一但创建就不能被修改
#2.使用小括号()或tuple()创建，元素间用逗号,分隔
#3.可以使用或不使用小括号
i=0

j=1
k=1
n=5
creature="cat","dog","tiger","human"
print(creature)#打印输出元组
color=(0x001100,"blue",creature)#元组里面的元素也可以是元组
print(color)#(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
#元组继承了序列类型的全部通用操作

#元组因为创建后不能修改，因此没有特殊操作
print(creature[::-1])#将元组顺序反向——>('human', 'tiger', 'dog', 'cat')
print(color[-1][2])#通过下标取出元组内子元组内的元素->tiger

#4.列表是序列类型的一种扩展，十分常用
#5，使用方括号或list()创建，元素间用逗号分隔
#6.列表中各个元素类型可以不同，无长度限制

ls=["cat","dog","tiger",1024]
print(ls)#['cat', 'dog', 'tiger', 1024]
ls[0]='girl'#替换列表ls第0元素为'girl'
print(ls)

lt=[1,2,3,4]
ls[i:j:k]=lt#用列表it替换ls切片后所对应元素子列表(还没理解透彻)
print(ls)

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

print(ls)
ls+=lt#ls=ls+lt 更新ls列表，将列表lt元素增加到ls
ls*=n#ls=ls*n  将元素重复n次



ls=["cat","dog","tiger",1024]
ls[1:2]=[1,2,3,4]#将列表ls中的第1个元素替换为元素[1,2,3,4]
print(ls)#['cat', 1, 2, 3, 4, 'tiger', 1024]
del ls[::3]#[::3]表示删除从头到尾，步长为3
print(ls)#-->[1, 2, 4, 'tiger']
ls.append('gril')#在列表最后增加一个元素gril
print(ls)#-->[1, 2, 4, 'tiger', 'gril']
lt=ls.copy()#复制ls中所有元素赋值给lt
print(lt)#-->[1, 2, 4, 'tiger', 'gril']
ls.clear()#删除列表ls中所有元素
ls.insert(0,'gril')#在列表第0位置增加元素'gril'
ls.pop(0)#将列表中第0索引位置取出并删除该位置元素,如索引大于元素数量，提示IndexError
print(ls)
ls=["cat","dog","tiger",1024,"dog"]
ls.remove('dog')#将列表ls中出现的第一个dog元素删除
print(ls)#['cat', 'tiger', 1024, 'dog']
ls.reverse()
print(ls)#['dog', 1024, 'tiger', 'cat']

23.字典类型知识与练习

#字典类型知识与练习
#映射是一种键(索引)和值(数据)的对应
#键值对:键是数据索引的扩展
#字典是键值对的集合,键值对之间无序
#采用大括号{}或dict()创建,键值对用冒号:表示
#在字典变量中，通过键获得值
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)#{'中国': '北京', '法国': '巴黎', '美国': '华盛顿'}
print(d["中国"])#-->北京
del d["中国"]#删除字典d中键'中国'对应的数据值
print(d)#{'美国': '华盛顿', '法国': '巴黎'}
print("美国" in d,"华盛顿" in d)#判断键(不是键值)是否在字典中
print(d.keys())#返回字典d中所有的键信息-->dict_keys(['法国', '美国'])
print(d.values())#返回字典d中所有的值信息-->dict_values(['华盛顿', '巴黎'])
print(d.items())#返回字典中所有的键值对信息-->dict_items([('美国', '华盛顿'), ('法国', '巴黎')])

##字典类型操作函数和方法
print(d.get("中国","没有中国"))#建存在则返回相应值，否则返回default值-->没有中国
print(d.get("法国","没有中国"))#-->巴黎
print(d.pop("美国","没有美国"))#-->取出键(美国)的值(华盛顿)并从字典中删除
print(d)#{'法国': '巴黎'}

d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d.popitem())#随机从字典中取出一个键值对并从字典中删除，以元组形式返回
print(d)
print(len(d))#字典中元素(键值对)的个数
d.clear()#删除所有的键值对
d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
for k in d:
    print(k)#遍历键
for key,value in d.items():
    print("key:"+key+" value:"+value)#遍历键和键值

24.文件的使用

#文件的使用
#文本形式打开文件
tf=open("1.txt","rt")
print(tf.readline())#readline读取第一行-->中国是一个伟大的国家！
tf.close()

#二进制形式打开文件
bf=open("1.txt","rb")
print(bf.readline())#readline读取第一行-->b'\xd6\xd0\xb9\xfa\xca\xc7\xd2\xbb\xb8\xf6\xce\xb0\xb4\xf3\xb5\xc4\xb9\xfa\xbc\xd2\xa3\xa1'
bf.close()

#文件处理的步骤:打开-操作-关闭
#打开模式
'''
'r':只读模式，如果文件不存在，返回FileNotFoundError
'w':覆盖写模式，文件不存在则创建，存在则完全覆盖
'x':创建写模式,文件不存在则创建，存在则返回
'a':追加写模式，文件不存在则创建，存在则在文件最后追加内容
'b':二进制文件模式
't':文本文件模式，默认值
'+':与/r/w/x/a配合使用，在原功能基础上增加同时读写功能
'''
tf=open("1.txt","rt")
size=-1
print(tf.read(size))#读取指定内容长度的内容，如果不给size参数或size=-1则读入全部内容
print(tf.read(size))#注意，不能连续读2次，因为文件被占用了
tf.close()#先关闭后面才能读取
tf=open("1.txt","rt")
print("readline方法")
print(tf.readline(0))#size=-1或不给size参数，读入一行内容,size>=0读入该行size长度
tf.close()#先关闭后面才能读取

tf=open("1.txt","rt")
print(tf.readlines(size))#读入文件所有行，以每行为元素形成列表,如给出size参数，则读取前size行
tf.close()#先关闭后面才能读取

#遍历全文本之方法1
#一次读入，统一处理
print("遍历全文本之方法1：一次读入，统一处理")
fo=open("1.txt",'r')
txt=fo.read()
print(txt)
fo.close()

#遍历全文本之方法2
#按数量读入，逐步处理
print("遍历全文本之方法2：按数量读入，逐步处理")
fo=open("1.txt",'r')
txt=fo.read(2)#读入2个长度的文本
while txt!="":
    print(txt)
    txt=fo.read(2)
fo.close()

#遍历全文本之方法3
#逐行遍历文件
print("遍历全文本之方法3：逐行遍历文件")
fo=open("1.txt",'r')
txt=fo.readline()#读入一行
while txt!="":
    print(txt)
    txt=fo.readline()
fo.close()

#遍历全文本之方法4
#逐行遍历文件
print("遍历全文本之方法4：逐行遍历文件")
fo=open("1.txt",'r')
for line in fo:
    print(line)
fo.close()

#遍历全文本之方法5
#逐行遍历文件
print("遍历全文本之方法5：逐行遍历文件")
fo=open("1.txt",'r')
for line in fo.readlines():
    print(line)
fo.close()


#数据的文件写入
fo=open("1.txt","w+")
fo.write("\n此致敬礼")
print(fo.read())
fo.close()

fo=open("1.txt","w+")
ls=["中国","法国","美国"]
fo.writelines(ls)
print(fo.read())
fo.close()

#fo.seek(offset) 改变当前文件操作指针的位置
'''
offset定义：
0--文件开通
1--当前位置
2--文件结尾
'''
print("练习")
fo=open("1.txt","w+")
ls=["中国","法国","美国"]
fo.writelines(ls)
fo.seek(0)#移动到文件头或文件尾
for line in fo:
    print(line)#移动到文件头或文件尾才有输出
fo.close()

25.一维数据、二维数据与文件处理

#一维数据和二维数据
#一维数据是由对等关系的有序或无序数据构成，采用线性方式组织
#二维数据是由多个一维数据构成，是一维数据的组合形成(表格是典型的二维数据，其中，表头也是二维数据的一部分)
#多维数据是由一维或二维数据在新维度上扩展形成
#数据的操作周期 ：存储<->表示<->操作

#一维数据的表示：如果数据间有序，使用列表类型,列表类型可以表达一维有序数据
ls=[3.1398,3.1349,3.1376]
#如果数据间无序:使用集合类型，集合类型可以表达一维无序数据
ls={3.1398,3.1349,3.1376}

#一维数据的存储，方式一:空格分隔
#1）使用一个或多个空格分隔进行存储，不换行，缺点：数据中不能存在空格

#一维数据的存储，方式二:逗号分隔
#1）使用英文半角逗号分隔数据，不换行 缺点：数据中不能有英文逗号

#一维数据的存储，方式三:其他特殊符号方式
#1）使用其他符号或符号组合分隔数据，建议采用特殊符号 缺点：需要根据数据特点定义，通用性较差

#从特殊符号分割的文件中读入数据(一维数据)
txt=open("shuju.txt").read()
ls=txt.split(" ")
print(ls)

#采用空格分隔方式将数据写入文件
ls=['中国', '美国', '日本', '德国', '法国', '英国']
f=open("shuju.txt",'w')
f.write(' '.join(ls))#在ls变量除最后元素外，每个元素后增加一个空格
print(' '.join(ls))#中国 美国 日本 德国 法国 英国
f.close()

#二维数据的格式化和处理
#列表类型可以表达二维数据
print("二维数列表据遍历")
ls=[[3.1398,3.1349,3.1376],[3.1313,3.1404,3.1401]]
for i in range(len(ls)):
    for j in range(len(ls[i])):
        print(ls[i][j])

#从csv文件读入数据
print("从csv文件读入数据")
fo=open("1.csv")#打开一个文件，创建一个 fo 对象
ls=[]
print(fo)
for line in fo:# 直接遍历对象每行赋值给line
    line=line.replace("\n","")#将每行末尾的换行替换为空
    ls.append(line.split(","))#分割文本插入到ls列表
    print(line)#输出CSV每行
print(ls)
fo.close()

#将数据写入到csv文件(遍历方式)
print("将数据写入到csv文件")
ls=[["姓名","年龄","性别"],["张三","李四","王五"],["23","24","25"]]#二维列表
#w:打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑
#即原有内容会被删除。如果该文件不存在，创建新文件。
f=open("2.csv",'w')
for item in ls:
    print(",".join(item)+"\n")
    f.write(",".join(item)+"\n")
f.close()

#将数据写入到csv文件(csv库方式)
import csv
#创建文件对象
#f = open('3.csv','w',encoding='utf-8')#加encoding='utf-8'会乱码
f = open('3.csv','w',newline='')#加newline=''是为了写入时有空行问题
#基于文件对象构建 csv写入对象
csv_writer = csv.writer(f)
#构建列表头
csv_writer.writerow(["姓名","年龄","性别"])
#写入csv文件内容
csv_writer.writerow(["张三",'18','男'])
csv_writer.writerow(["李四",'20','男'])
csv_writer.writerow(["王五",'22','女'])
# 5. 关闭文件
f.close()