zoukankan      html  css  js  c++  java
  • python_基础数据类型

    前言

    本篇博客整合了以下知识点

    本篇博客以理论加实际 ,为我全方面解读。

    知识点已经列出来了就开干吧

    计算机的基础知识

    计算机由以下几个主要部分组成

    cpu:人类的大脑

    内存 临时此处一些数据 解决硬盘和cpu 速度差

    硬盘 永久存储数据

    操作系统 一个特殊的程序 调度硬件和软件之间的数据交互

    python入门的基础知识

    python的种类(解释器)

    Cpython:官方推荐解释器。可以转化成C语言能识别的字节码。(c)
    Jpython: 可以转化成Java语言能识别的字节码。(java)
    Ironpython:可以转化成.net语言能识别的字节码( c#)
    pypy:转换成 动态编译。(python)两块 开发快运行快
    ipython 和cpython在终端上有一点区别
    

    编程语言的种类

    编译型:c,c++
    
           将代码一次性全部编译成二进制,然后再执行**。
           优点:执行效率高。
           缺点:开发效率低,不能跨平台。
           代表语言:C
    解释型:python,强累定义语言
           逐行解释成二进制,**逐行运行**。
           优点:开发效率高,可以跨平台。
           缺点:执行效率低。不能加密
           代表语言:python。
    混合型
           java
    

    变量

    简介

    变量是一个便利贴

    变量的命名规范

    1. 变量全部由数字,字母 下划线任意组合。(不行有,。;’【】等)
      不能以数字开头。
    2. 不能是python的关键字。
      ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
    3. 要具有描述性。

    常量

    一般约定俗成不能改变 一般大写表示
    python中没有真正的常量,为了应和其他语言的口味,全部大写的变量称之为常量。
    将变量全部大写,放在文件的最上面。
    设置一些不变的量 :身份证号,id,
    BIRTH_OF_CHINA = 1949
    

    注释(重点

     文言文中对一些晦涩难懂的成语或者经典的出处 解释说明。便于你理解。
     便于你理解对方的代码,自己的代码。
     单行(单行)注释:  #    **注释的代码不执行**
     
     多行注释: '''被注释内容'''  """被注释内容"""#变成了字符串并没有引用
     难以理解的代码后面,加注释。
     
     函数,类,文件都需要注释,解释说明。 好理解
    

    初识int str bool数据类型

    int(整型):

    普通的数字
    	1 ,2, 123, ....
    可以基本运算
    	+ - * /   
    

    str(字符串)

    凡是用 引号 引起来的数据就称之为字符串。
    '', "", ''' ''',  """ """
    
    # 单双引号可以配合使用
    # 三引号:换行的字符串
    # str + str  *** 字符串的拼接 (都是字符串才可以)
    # str * int 字符串的相乘(字符串与数子)
    

    bool

    就是True False
    

    type查看数据的类型

    type() 查看属于什么类  
    

    input 与print 的注意事项

    python3 input 获取的都是字符串
    
    print()的几个参数
    print(*objects, sep=' ', end='
    ', file=sys.stdout)
        objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
        sep -- 用来间隔多个对象,默认值是一个空格。
        end -- 用来设定以什么结尾。默认值是换行符 
    ,我们可以换成其他字符串。
        file -- 要写入的文件对象。
        	代表tab键
        
    代表换行
    
    

    python的基本语法

    if流程语法的基本结构

    if 条件:   #判断
    缩进  结果   #条件成立后执行的(4个空格)
    # if{条件}{结果}
    
    

    单分支

    if 条件:
        满足条件后要执行的代码
    
    

    实列

    if 2 < 1:
        print(666)
    print(222)
    
    

    双分支

    if 条件:
        满足条件执行代码
    else:
        if条件不满足就走这段
    
    

    实列

    age = input('请输入年龄:')
    if int(age) > 18:
        print('恭喜你,成年了')
    else:
        print('小屁孩儿')
    
    

    多分支

    if 条件:
        满足条件执行代码
    elif 条件:
        上面的条件不满足就走这个
    elif 条件:
        上面的条件不满足就走这个
    else:
        上面所有的条件不满足就走这段
    
    

    实列

    num = int(input('猜点数:'))
    if num == 1:
        print('晚上请你吃饭')
    elif num == 3:
        print('一起溜达')
    elif num == 2:
        print('请你大宝剑')
    else:#以上都不符合条件
        print('太笨了....')
    print('组合')
    
    

    多选 纯if

    if 条件:
        满足条件执行代码
    if 条件:
        上面的条件不满足就走这个
    
    

    实列

    if 5>2:
        print(666)
    if 5>3:
        print(666)
    
    

    嵌套的if

    if 条件:
        if 条件:
            满足条件执行代码
    
    

    实列

    username = input('请输入用户名:')
    password = input('请输入密码:')
    code = 'qwer'
    your_code = input('请输入验证码:')
    
    if your_code == code:
        if username == 'taibai' and password == '123':
            print('登录成功')
        else:
            print('账号或者密码错误')
    else:
        print('验证码错误')
    
    

    在Python语言中,也有三元运算符。不过Python的三元运算符和java以及C#有所区别,语法格式为:
    表达式1 if 条件表达式 else 表达式2
    当表达式返回True时,返回结果表达式1,否则返回结果表达式2。示例:
    c = a if a < b else b

    for else

    结果
    for i in [1,2]:
        if i==2:
            break
        else:
            print(i)
    else:
        for i in range(6):
            print(i)
    结果      
    for i in [1,2]:
        if i==2:
            break
        else:
            print(i)
    for i in range(6):
    `print(i)
    
    

    while循环语句的基本语法结构

    while 条件:
        循环体
    
    

    while循环语句终止运行的两种条件

    1. while 旁边的条件改变成为false
    2. 运行途中遇到continue break
    改变条件实列
    flag = True
    while flag:
        print('狼的诱惑')
        print('我们不一样')
        print('月亮之上')
        flag = False
      print('庐州月')
        print('人间')
    
    
    遇到continue break实列
    while else: while 循环如果被break打断,则不执行else语句。
         count = 1
         
    while count < 5:
             print(count)
          if count == 2:
                 break
          count = count + 1
         else:
             print(666)
             
             
             
    在补充
    
    

    3元运算符

    # 三元与运算符: 简单的if else
    # c = a if a > b else b
    # def complie(a,b):
    #     c = a if a > b else b
    #     return c
    
    

    格式化输出的3种方式

    当你遇到这样的需求:字符串中想让某些位置变成动态可传入的,首先要考虑到格式化输出。

    %s占位符方式

    %s 字符串 %d int整型   %%(转义)        字符串格式化 不能多 不能少且要一一对应
    name=input('>>>')  #第一种
    print('我的名字是%s'%(name))
    
    

    {} 3.7后的方式

    name=input('>>>') 
    print(f'我的名字是{name}')
    f扩起来{}包占位的
    
    

    format 方式

    # name = "alex{}wusir{}"
    # name1 = name.format('结婚了',"要结婚了")  # 按照位置顺序去填充的
    # name = "alex{1}wusir{0}"
    # name1 = name.format('结婚了',"要结婚了")    # 按照索引位置去填充
    # name = "alex{a}wusir{b}"
    # name1 = name.format(a="结婚了",b="马上结婚")  # 指名道姓 填充
    # print(name1)
    
    

    其他重要知识

    运算符 与and运算

    算数运算 +, - ,* ,/ ,%, **幂,//取整   %取余
    比较运算符 == , !=  , >  ,<  , >=  , <=
    赋值运算符 = ,+= ,-= ,*= ,/= ,**= ,%= ,//=
    逻辑运算符 and(与 -- 和) or (或) not (非 -- 不是)
    成员运算符 in 在   not in 不在
    身份运算 is是 is not 不是
    
    
    # 在没有()的情况下,优先级:not > and > or,同一优先级从左至右依次计算
    # and 运算 2都为真 and的后面***
    # and 运算 2都为假 and的前面
    # or 运算 2都为真 or的前面***
    # or 运算 2都为假 or的后面
    # and 运算 一真一假 取假
    # or 运算 一真一假 取 真
    
    
    一个等号代表的含义是赋值,将某一数值赋给某个变量,比如a=3,将3这个数值赋予给a。
    两个等号是判断是否相等,返回True或False,比如1==1。他们是相等的,那么就返回true。1==2,他们是不相等的,那么就返回false。
    is 判断id相同
    
    

    数据类型之间的转换

    # str ---> int  : 只能是纯数字组成的字符串
    s1 = '00100'
    print(int(s1))
    # int ----> str
    i1 = 100
    print(str(i1),type(str(i1)))
    
    # int  ---> bool  : 非零即True ,0为False。
    i = 0
    print(bool(i))
    # bool ---> int
    print(int(True))  # 1
    print(int(False))  # 0
    
    

    编码的初识

    计算机存储文件,存储数据,以及将一些数据信息通过网络发送出去,存储发送数据什么内容?底层都是01010101.

    密码本:01010110 二进制与 文字之间的对应关系。

    最早起的密码本:

    英文1 欧洲2 亚洲3

    ASCII码 只支持英文**   1字节
    gbk 英1中2
    Unicode  英2 中4
    Utf-8 英文1 欧洲2 亚洲3
    
    

    编码转化

    bit是字位,也就是计算机存储数据的“0”、“1”,每个“0”、“1”都是一个字位。Byte是字节,是文件存储的最小单位,一个字节由八个字位组成,前七位是文件的名称,最后一位是校验位。1Byte=8bit,1KB=1024Byte,1MB=1024KB,1GB=1024MB,1TB=1024GB。
    
    8bit = 1Byte****B
    1024byte = 1KB
    1024KB = 1MB
    1024MB = 1GB
    1024GB = 1TB
    
    
    1024TB = 1PB
    1024TB = 1EB
    1024EB = 1ZB
    1024ZB = 1YB
    1024YB = 1NB
    1024NB = 1DB    
    
    7.6MB  ----> 7.6 * 1024 * 1024 * 8
    
    

    for 循环语句

    fro循环
    
    

    len 内置函数

    len()#获取长度
    
    

    range内置函数

    range #默认从0开始 可以步长 类似列表 顾头不顾尾
    
    s = range(1,10)  # 大坑  python2 和 python3
    print(s)  # 范围 range(1, 10)
    
    

    python的基本数据类型以及方法

    6大数据类型

    1. str
    2. bool
    3. int
    4. dict
    5. list
    6. tuple
    7. set

    str数据类型

    # 字符串 -- 用于存储数据的 -- 比较少
    # python 中只要是用引号 引起来的就是字符串
    # 支持索引(引取值的时候超出了索引的范围会报错),切片(切片如果终止位置超出了不报错),步长
    注意事项
    list('1234')#['1', '2', '3', '4']
    
    

    str的方法

    字符串方法 其实就是调用类的方法 字符串是数字不会报错
    b='  aBdsfdfhgjkc6'
    # print(b.upper())# 全部大写
    # print(b.lower())# 全部小写
    
    # print(b.startswith('a'))  # 以什么开头
    # print(b.endswith("c"))# 以什么结尾
    # print(b.count("zhu"))   # 查询某个内容出现的次数
    # b1 = b.replace('n','s',2)  # 替换  2是替换的次数 第一个参数旧的 第2个新的
    # b2 = b.strip('6')  #返回移除字符串头尾指定的字符生成的新字符串 (只要头尾包含有指定字符序列中的字符就删除:) 默认去空格
    # str.split(第1个参数,第2个参数) 返回列表
    # 第1个参数 必需。字符串或正则表达式,从该参数指定的地方分割 stringObject。
    # 第2个参数 可选。该参数可指定返回的数组的最大长度。如果设置了该参数,返回的子串不会多于这个参数指定的数组。如果没有设置该参数,整个字符串都会被分割,不考虑它的长度。
    
    # is 系列  -- 判断
    # print(name.isdecimal()) # 判断是不是十进制  -- 用它来判断是不是数字
    # print(name.isalpha())    # 判断的是中文和字母
    # print(name.isalnum())     # 判断的是不是字母,中文和阿拉伯数字
    
    补充
    str
    首字母大写 capitalize()
    s1 = object.capitalize()
    每个单词首字母大写 title()
    s = "alex wusir"
    s1 = s.title()
    统计出现的次数count()
    print(s.count("a"))
    大小写转换 swapcase()
    print(s.swapcase())
    利用元素找索引 find()
    print(s.find("c"))     # find 查找不到的时候返回 -1
    print(s.index("C"))    # index 查找不到就报错
    
    

    切片小列题

    # 从左向右数 0,1,2,3
    # 从右向左数 -1,-2,-3,-4
    # a='123456789'
    # print(a[::3])
    # print(a[1:5])
    # print(a[0],a[-1])
    
    

    bool数据类型

    # bool # 布尔值 -- 用于条件使用
    # True  真
    # False 假
    
    # print(bool(0))
    # True 转化成数字 1   False 转换成数字 0
    # 非0 非空(空字符串,空列表,空元祖,空集合,空字典) 就是True
    # print(type(str(True))) 布尔值可以转换成字符串
    
    

    int数据类型

    int可以运算
    # print(num.bit_length())  # 求十进制数转换成二进制时所占用的位数
    # 10进制转2进制 8421
    
    

    list数据类型

    # 什么是列表? 就是一个容器,任意类型都可以放到容器中
    # list  []  多个元素 每个元素中间用,逗号隔开
    # 有序的?  按照咱们写的顺序输出  支持切片,步长
    # 可变的 -- 可以在本身上进行修改  可以增加 - 删除 - 修改
    # 列表不能用insert
        #效率低了一个变后面都会变 补位
    # 列表不能用pop(n)
        ##效率低了一个变后面都会变 补位
    
    

    创建列表

    # 创建列表3种方式 (列表推导式,自己创建)
    # 第一种
    # l1 = [1,2,3,'123',True,[1,2,5]]
    # 第2种
    # l1=[i for i in range(9)]
    
    

    list增删改查

    # 方法
    l1 = [1,2,3,'alex',3,[1,2,3]]
    l1.append('sq') #追加  添加在末尾  添加的操作
    l1.insert(0,"mcsq") #插入 第一个参数(索引),第二参数要插入的内容
    l1.extend("abc")                # 扩展 -- 迭代添加  -- for
    l2 = ["a","b","c"]+[1,2,3]# 列表合并["a","b","c",1,2,3]
    l3=[[]]*3#[[], [], []]列表相乘
    
    # 删
    # l1.remove(1)   # 删除   按照元素名进行删除
    # print(li.pop(索引))
    # 弹 pop有返回值  返回的是被删除的内容# 默认删除的是最后一个# 可以通过索引指定删除
    
    del l2#将整个容器都删掉了
    # del l2[2]   #del 支持索引删除
    # del l2[0:3]   #del 支持切片删除
    # del l2[::2]    # del 支持步长删除
    # 清空
    # li.clear()  # 清空里面元素 列表还在
    
    # 索引改
    # li = [0,1,2,3,4,5]
    # # li[0:2] = []  # [2, 3, 4, 5]  # 没有步长迭代进去的 可以多,可以少
    # li[::2]=[1,2,3]#有步长,不可以多,不可以少 否则报错
    # print(li)
    
    

    列表的嵌套:

    # 抽丝剥茧
    补充方法
    list
    l1=[1,2,3,4,5,6,6,5,4,3,2,1]
    list:
    计数count()
    print(li.count("1"))
    利用元素找索引 find()
    print(li.index("C"))    # index 查找不到就报错
    反转 reverse()原列表反转
    l1.reverse()
    排序 原列表升序或降序
    li.sort()  # 升序
    li.sort(reverse=True)
    
    

    tuple数据类型

    # 元组
    # 元组本身不可变,如果元组中还包含其他可变元素,这些可变元素可以改变
    # 只有当元组内的所有元素都为不可变类型的时候,才能成为字典的key
    # 小括号中一个元素的时候没有逗号就括号中元素的本身
    # 小括号中一个元素的时候有个逗号就是元组
    # 空的小括号就是元组
    
    # 元组有序:
    # 索引,切片,步长
    # 元组不可变数据类型
    
    元祖不可以增删改 可以 索引 切片
    # 元组的嵌套:
    
    为什么要有元祖?
    保护数据安全
    方法补充
    tuple
    tu=(1,2,3)
    tuple:
    计数
    print(tu.count("3"))
    利用元素找索引 index()
    print(tu.index("1"))
    
    

    拆包

    # 拆包
    # a = 1
    # b = 2
    # a,b = b,a
    # print(a,b)
    
    

    dict数据类型

    # 字典是什么?
    # dict
    # {} "键":"值"   一个键对应一个值 
    # dic = {"key":"value",1:2,2:3}
    # 键:必须是可哈希(不可变的数据类型),并且是唯一的
    # 值: 任意
    
    # 字典的无序的,python3.6版本以上 默认了咱们定义顺序,python3.5以下是随机显示
    # 字典比较消耗内存  最常用的数据 : 字符串,列表,字典
    # 有明确的对应关系时,推荐使用字典   字典一定要用明白  -- json
    
    

    dict增删改查

    # dic = {"a":"b","b":"c"}
    # 增:
    # dic.setdefault("key","values")#存在就不添加,不存在就添加
    # dic["s"] = "ssss"   # dic[键] = 值
    # 删:
    # print(dic.pop("a"))   #通过键删除  pop具有返回值,返回的被删除的值
    # del dic["b"]   #删除指定的键值对
    # del dic   #  删除整个字典
    # dic.clear()    # 清空字典元素
    # 改:
    # dic["b"] = "这是值"   # 键在字典中存在就是修改,键在字典中不存在就是增加
    # dic.update({6:6})   # update括号里的字典级别高有更新覆盖 无则添加
    
    # 查:
    # 字典的查询只能通过键获取值,不能通过值获取键
    # print(dic["c"])  键不存在的时候不报错
    # print(dic.get("c","不存在"))# 键存在返回值,键不存在设定第2参数的时候不报错
    
    # dic = {1:2,"a":"a1"}
    # for i in dic:   # for循环字典的时候打印的是字典的键
    #     print(i,dic[i])
    # for k,v in dic.items():
    #     print(i)
    
    补充方法
    dict
    dict:
    dic = dict(k=1,k1=123,k2="aa",k3=222,k4=1123123)   # 定义方式
    批量创建字典
    dic = {}
    dic1 = dict.fromkeys("abcdef",[4,5,6])
    第一个参数可迭代对象
    第二个参数是每个键对应的值 -- 用的都是同一个内存地址
    dic.popitem()   #随机删除
    python3.6版本 默认删除最后个键值对
    python3.5版本以前 随机删除
    批量创建字典
    dic = {}
    dic1 = dict.fromkeys("abcdef",[4,5,6])
    第一个参数可迭代对象
    第二个参数是每个键对应的值 -- 用的都是同一个内存地址
    
    

    字典的嵌套

    # 字典的嵌套:
    
    

    枚举

    # 枚举 默认从0开始
    # enumerate()
    list = ['a','b', 3, 4, 5, 6]
    for i, j in enumerate(list):
        print(i+1,j)
    
    

    set数据类型

    # 集合就是一个没有值的字典,遵循:唯一,无序,元素要求可哈希(不可变)
    # 集合是无序的
    # 集合是可变的
    # 集合里面有元祖,只有当元组内的所有元素都为不可变类型的时候才可以做集合元素
    # 创建set
    # s = set("1234")   # 定义方式
    s={1,2,3,"123",False,(1,2,3,4,)}
    print(s,type(s))
    
    # 增:
    # s.update("3456")  # 迭代添加
    # s.add("怼怼")
    #删:
    # s.pop()   #随机删除
    # s.clear()    # 清空
    # del s        #删除整个集合
    # 改:
    # 删了,在加
    # 查:
    # for
    
    # 天然去重   --  唯一  列表去重
    
    # print(s1 - s2)  #差集
    # print(s1 | s2)  #并集   (合集)
    # print(s1 & s2)  #交集
    # print(s1 ^ s2)  #对称差集  -- 反交集
    # print(s1 > s2)  # 超集   -- 父集
    # print(s1 < s2)  # 子集
    
    # 冻结集合(可变 转换成 不可变)  -- 更不常用
    # f_s = frozenset({1,2,3,4,5})
    # dic = {f_s:"1"}
    # print(dic)
    
    

    深浅copy与小数据池(理论)

    先理解is == id 用法

    # is # 判断两个内存地址是否相同     # 必须记住
    # == # 判断等号两边的值是否相同     # 必须记住
    # = 代表赋值 改变指向
    
    

    代码块

    同一代码块

    # 在python中一个模块,一个函数,一个类,一个文件等都是一个代码块。
    # 机制内容:Python在执行同一个代码块的初始化对象的命令时,会检查是否其值是否已经存在,如果存在,会将其重用。换句话说:执行同一个代码块时,遇到初始化对象的命令时,他会将初始化的这个变量与值存储在一个字典中,在遇到新的变量时,会先在字典中查询记录,如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中,文件执行时(同一个代码块)会把i1、i2两个变量指向同一个对象,满足缓存机制则他们在内存中只存在一个,即:id相同。
    # 适用对象: int(float),str,bool。
    
    

    不同代码块(小数据池)

    # 先执行代码块,不符合代码块才会执行小数据
    # 代码块:  一个文件,一个模块,一个函数,一个类,终端中每一行都一个代码块
    # 小数据池就是Python中一种提高效率的方式,固定数据类型使用同一个内存地址
    # 小数据池 不同代码块的
    # -5 ~ 256  *记住
    # 字符串:
    # 1.字符串在做乘法的时候总长度不能超过20,进行驻留   # 记住
    # 2.自己定义的字符串 长度不限制 字符串必须(字母,数字.下划线)组成,进行驻留
    # 3.特殊字符(中文除外)定义1个时候,进行驻留
    # 4.字符串*1 其实就是赋值
    # bool值就是True,False
    
    # 怎么能自己驻留?
    #需要使用python的内置模块
    # from sys import intern
    # a = intern("@@@@@@"*20)
    # b = intern("@@@@@@"*20)
    # print(a is b)        # 自己进行驻留
    
    

    小数据池的适用场景

    深浅copy

    # 浅copy: list dict: 嵌套的可变的数据类型是同一个。
    浅拷贝:拷贝目标可变对象(list, dict, set)时,仅为 **整体** 第一层**可变对象分配新的内存地址**,**第二层(元素)**及以上的可变对象沿用之前对象的内存地址,此外**所有层的不可变对象**(int, str, bool, tuple)均沿用之前对象的内存地址。
    
    # 深copy: list dict: 嵌套的可变的数据类型不是同一个 。
    深拷贝:拷贝目标可变对象(list, dict, set)时,**为所有层的可变对象分配新的内存地址**,此外**所有层**的**不可变对象**(int, str, bool, tuple)均**沿用之前对象的内存地址。
    
    深浅拷贝的规律:
    赋值: 两个变量使用的是同一个空间
    浅拷贝:修改不可变数据类型,不变动,修改可变数据类型,变动
    深拷贝:修改就不变动
    赋值运算 =  不是copy 只是改变指向  ID相同
    
    

    python文件操作

    文件操作是什么?

    # 操作文件:
    # f = open("文件路径",mode="模式",encoding="编码")
    # open()  # 调用操作系统打开文件
    # mode    # 对文件的操作方式
    # encoding # 文件的编码  -- 存储编码要统一
               # win -- gbk
               # linux -- utf-8
               # mac   -- utf-8  最常用的就是utf-8
    # f 文件句柄  -- 操作文件的相当于锅把
    # 文件操作怎么用?
    
    # 读 r
    # 写 w清空写 ,a追加写
    # 读 rb
    # 写 wb   ab
    
    

    补充的知识点 编码的详细学习

    # ascii     不支持中文
    # gbk       国标   中文2 英文1
    # unicode   万国码 英文2 中文4
    # utf-8     英文1  欧洲2 亚洲3
    
    # 硬盘中存储的是     字节 8位1字节
    
    # 1. 在计算机内存中,统一使用Unicode编码,当需要将数据保存到硬盘或者需要网络传输的时候,
    # 就转换为非Unicode编码比如:UTF-8编码。
    # 2. 不同编码之间,不能直接互相识别。
    # 文件内容传输 先编码 在解码  用什么编码就用什么解码
    # 编码 成bytes类型
    # s = "abc"
    # print(s.encode("gbk"))
    # print(s1.decode("gbk"))  #字节转换成字符串 -- 解码
    
    

    文件操作的几种方式

    注意:不管是读取文本内容还是非文本内容都是以下几种操作方式

      • 全部读取
      • 一行行读
      • 清空写入
      • 追加写入
    • 操作光标

      • 查看光标
      • 移动光标
    • 文件的+模式

      • 边读边写
    • 文件的修改

      • 文件内容的替换

    文件的读

    # f.read()    # 全部读取
    # f.read(3)        # 字符读取
    # readline(3)  # 读取一行内容中多个字符
    # f.readlines()) # 一行一行读取,存储到列表中   
    是换行
    with open('cs.txt',encoding='utf-8',mode='r') as f1:
        # print(f1.read())#全部读取 注意 一般不这么读 耗内存
        print(f1.read(1))# 字符读取 注意不是读取字节 符号也是一个字符
        # print(f1.readline())#读一行 注意会记录光标 
    是换行
    # with open('cs.txt', encoding='utf-8', mode='r') as f1:
        # for i in f:  # 迭代读取 一行一行读取 -- 防止内存溢出
        #     print(i)
    
    # 路径
    # F:a111.txt  绝对路径 从磁盘的根处查找
    # 相对路径      相对于当前文件进行查找的
    
    # repr() #函数将对象转化为供解释器读取的形式。
    dict = {'runoob': 'runoob.com', 'google': 'google.com'}
    print(repr(dict),type(repr(dict)))
    # import os
    # print(os.getcwd())  # 查看当前工作路径
    
    # 另一种打开文件的方式.
    # with open("day8",mode="r",encoding="utf-8") as f,
    #     open("a",mode="w",encoding="gbk") as f1:
    #     print(f.read())
    #     f1.write("真饿!")
    
    

    文件的写

    # 写 w 清空写  a 追加写
    # f = open("cs.txt",mode="w",encoding="utf-8")
    # f.write("123")
    # f.close()  # 关闭文件
    
    # a 追加写 追加到末尾
    # with open('cs.txt',encoding='utf-8',mode='a') as f1:
    # #     f1.write('你最棒')
    
    

    文件读写非文本wb

    # rb ,wb,ab 不能指定编码
    # print(f.read())  # read()  全部读取
    
    # with open('cs.jpg',mode='rb') as f1:
    #     print(f1.read())
    #     print(f1.read(3))  # 读取的是字节
    
    import requests
    import os
    ret = requests.get("http://www.521609.com/uploads/allimg/151124/1-1511241G251317.png")
    a=os.path.dirname(os.path.dirname(__file__))
    b=os.path.join(a,'1.jpg')
    with open(b,mode='wb') as f1:
        f1.write(ret.content)
    
    

    文件操作+模式

    # r 读  r+ 读写  注意,要先读后写 如果写写在读 光标会在最后就读不出内容了
    # w 写  w+ 写读 真的废物
    # a 写  a+ 写读
    # r+
    #正确示范   -- 后期开发中使用频率比较低
    # f = open("day8",mode="r+",encoding="utf-8")
    # print(f.read())
    # f.write("脑瓜疼啊脑瓜疼")
    
    

    调整文件光标

    # 在a 模式 读完后关标在最后 所以我们要注意这些小问题
    # 查看光标: tell()  返回值 返回的就是当前光标的位置
    # 移动光标:
    #   seek(0,0) 文件开始位置
    #   seek(0,1) 光标的当前位置
    #   seek(0,2) 文件末尾位置
    #   seek(3)   按照字节调节  使用utf-8是3 gbk是2
    
    

    文件的修改

    原理就是边读边写
    # 不好用 好耗内存
    # with open("day8",mode="r+",encoding="utf-8")as f:
    #     content = f.read()
    #     content = content.replace("您","你")
    #     f.seek(0,0)
    #     f.write(content)
    
    # 利用for循环 边读边写 与os模块
    # with open("cs.txt",mode="r",encoding="utf-8")as f,
    # open("cs_bak.txt",mode="a",encoding="utf-8")as f1:
    #     for i in f:
    #         content = i.replace("你","我")
    #         f1.write(content)
    #
    # import os
    # os.remove("cs.txt")  # 原数据可以使用rename来做备份
    # os.rename("cs_bak.txt","cs.txt")
    
    
    yuan=r'C:Users86131Desktop程序员之路笔记系统测试学习测试方法.md'
    gai=r'C:Users86131Desktop程序员之路笔记系统测试学习测试方法.md.bak'
    with open(yuan,mode="r",encoding="utf-8")as f,
    open(gai,mode="a",encoding="utf-8")as f1:
        for i in f:
            content = i.replace("回到顶部","")
            f1.write(content)
    
    import os
    os.remove(yuan)  # 原数据可以使用rename来做备份
    os.rename(gai,yuan)
    
    
  • 相关阅读:
    python内置的魔术命令(builtin magic commands)
    绘制ROC曲线
    python with语句中的变量有作用域吗?
    Visual Studio上编译ncnn
    loss函数学习笔记
    Install zeal on ubuntu16.04
    cmake方式使用vlfeat
    整理读研期间用过、改进过、写过的代码
    ubuntu下使用matplotlib绘图无法显示中文label
    error: each element of 'ext_modules' option must be an Extension instance or 2-tuple
  • 原文地址:https://www.cnblogs.com/saoqiang/p/12176764.html
Copyright © 2011-2022 走看看