Python基础三

changxin7

发布于 2019-09-10 16:15:20

1.3K0

发布于 2019-09-10 16:15:20

文章被收录于专栏：changxin7changxin7

1.字典 -- dict

字典是无序,可变的
键:使用不可变数据类型(可哈希),键是唯一的
值:可以任意

增加

     dic["键"] = "值"  # 暴力添加
     dic.setdefault("键","值")  # 存在不添加

删除

     del dic["键"]
     dic.pop("键")
     dic.clear()

改

     dic["键"] = "值"
     dic.update("要更新的字典")

查

     for 循环查询的是字典的键
     get("键")  #存在返回字典中键对应的值,不存在返回None
     dic["键"]    # 存在返回字典中键对应的值,不存在报错

其他操作

     keys  --  获取字典中所有的键      存放在一个高仿列表中
     values  --  获取字典中所有的值    存放在一个高仿列表中
     items  --  获取字典中所有的键和值 存放在一个高仿列表里的元组(元组第一个元素:键,第二元素:值)

解构

    a = 10
    b = 20
    a,b = b,a

字典的嵌套

   dic = {1001:["周杰伦","林俊杰"],
           1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
           1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
           1004:{"韦小宝":[{"教主夫人":["教主"]},
                        {"阿珂":"刺客"},
                        {"双儿":"天地会"},
                        {"爱心觉罗建宁":"公主"},
                        {"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[
                               "唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]
                                 }},
                        {"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
           1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
           }
    
 print(dic)
 print(dic[1004]["韦小宝"][0]["教主夫人"][0])
 print(dic[1005]["常鑫"][-1])
 print(dic[1002]["汪峰"]["前妻2"][-1])
 print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
 print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])

    # 查找的时候一层一层的通过键进行查找
    # 键

小数据池--缓存机制(驻留机制)

== 判断两边内容是否相等

a=10
b=10
print(a==b)
Ture

is 是

a=10
b=10
print(a is b) # is 判断基于内存地址进行判断

#查ID
print(id(a))
print(id(b))

小数据池的数字范围:-5~256

a = -2.5 * 2
b = -2.5 * 2
print(id(a))
print(id(b))

a = "alex你好" *2
b = "alex你好" *2
print(id(a))
print(id(b))

代码块:一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块

支持:

数字:
  在同一代码块下 只要内容相同就采用相同的内存地址(-5以后就不是)
# 数字在做乘法的时候范围 -5 ~ 256  ****
  数字在做乘法的时候不能使用浮点数
字符串:
  在同一代码块下 只要内容相同就采用相同的内存地址
# 乘法的时候总长度不能超过20   ****
  乘法的时候中文,特殊符号乘以1或0
布尔值:
  在同一代码块下 只要内容相同就采用相同的内存地址

小数据池

# 数字:  -5 ~ 256   ****
字符串:
      在同一代码块下 只要内容相同就采用相同的内存地址
    # 乘法的时候总长度不能超过20   ****
      乘法的时候中文,特殊符号乘以0
布尔值:
      在同一代码块下 只要内容相同就采用相同的内存地址
小数据池的验证方法,必须脱离代码块才能进行验证
先执行代码块的规则,在执行小数据的规则 --(驻留机制)

必会:

#重点重点

# ==  判断等号两边的值是否相等   ****
# is  判断两边的内存地址是否相等  ****

总结

    1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
       1.1.1 数字: -5 ~ 256
       1.1.2 字符串: 乘法时总长度不能超过20
       1.1.3 布尔值: 内容相同内存地址相同
    1.2 小数据池:
       1.2.1 数字: -5 ~ 256
       1.2.2 字符串: 乘法时总长度不能超过20
       1.2.3 布尔值: 内容相同内存地址相同
    1.3 先执行代码块后执行小数据池
    1.4 == is
        1.4.1 == 判断等号两边值是否相等
        1.4.2 is 判断两边的值内存地址是否相等

深浅拷贝--复制

# 面试必问:赋值,浅拷贝,深拷贝

# 浅拷贝=修改第一层元素不改变,其它改变.
# 深拷贝=修改任何位置,另外一个不改变.

lst = [1,2,3,[5,6,7]]
lst1 = lst
print(lst1)
print(lst)

lst[-1].append(8)
print(lst1)
print(lst)

lst1 = lst.copy()  # 新开辟一个空间给lst1

print(lst[-1])
print(lst1[-1])

print(id(lst1[-1]))
print(id(lst[-1]))

浅拷贝的时候

只会开辟一个新的容器列表,其他元素使用的都是源列表中的元素

# 浅拷贝=修改第一层元素不改变,其它改变.

lst = [1,2,3,[5,6,7]]
lst1 = lst.copy()     # lst1 = lst.copy()
lst1[-1].append(8)
print(lst)
print(lst1)

深拷贝

不可变的数据类型公用,可变的数据类型重新开辟一个空间,对源数据进行修改,深拷贝的内容不进行改变

# 深拷贝=修改任何位置,另外一个不改变.

 import copy  #导入
 lst = [1,2,3,[5,6,7]]
 lst1 = copy.deepcopy(lst)  # 深拷贝 lst1 = copy.deepcopy(lst)
 lst[-1].append(8)
 print(lst)
 print(lst1)

总结

# 浅拷贝的时候只拷贝第一层元素
# 浅拷贝在修改第一层元素(不可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在替换第一层元素(可变数据类型)的时候,拷贝出来的新列表不进行改变
# 浅拷贝在修改第一层元素中的元素(第二层)的时候,拷贝出来的新列表进行改变

# 深拷贝开辟一个容器空间(列表),不可变数据公用,可变数据数据类型(再次开辟一个新的空间)
# ,空间里的值是不可变的数据进行共用的,可变的数据类型再次开辟空间

测试代码

#浅拷贝
        s = [1, 2, 3, [4, 5, 6]]
        s1 = s.copy()
        s[-1] = 11111
        print(s)
        print(s1)
#深拷贝
        s=[1,2,3,[4,5,6]]
        import copy
        s1=copy.deepcopy(s)
        s[-1][1]=11111
        print(s)
        print(s1)

集合--set

没有值的字典无序--不支持索引

**** 天然去重

定义集合

 s = {1,"alex",False,(1,2,3),12,1,12,4,6,32,2,4}
 print(s)

面试题:

lst = [1,2,1,2,4,2,45,3,2,45,2345,]
print(list(set(lst)))

s = {1,2,3,4}

增:
s.add("67")  #只能添加一个
print(s)
s.update("今天")  # 迭代添加
print(s)

删:
print(s.pop())  # pop有返回值
print(s)
s.remove(3)     # 指定元素删除
print(s)
s.clear()         # 清空   -- set() 空集合
print(s)

改:
先删在加

 查:
 for i in {1,2,3}:
     print(i)

其他操作:

s1 = {1,2,3,4,5,6,7}
s2 = {5,6,7,1}
print(s1 & s2)  # 交集
print(s1 | s2)  # 并集
print(s1 - s2)  # 差集
print(s1 ^ s2)  # 反交集
print(s1 > s2)  # 父集(超集)
print(s1 < s2)  # 子集

 print(frozenset(s1))  # 冻结集合 更不常用
 dic = {frozenset(s1):1}
 print(dic)

基础类型补充

str:不可变

1.首字母大写

name = "alex"
name1 = name.capitalize()
print(name1)

2.每个单词首字母大写

name = "alex wusir"
print(name.title())

3.大小写反转

 name = "Alex"
 print(name.swapcase())

4.居中--填充

 name = "alex"
 print(name.center(20,"-"))

5.查找从左向右只查找一个

 name = "alelx"
 print(name.find("b"))  #find查找不存在的返回-1
 print(name.index("b"))   #index查找不存在的就报错

6.拼接

 name = "al3x"
# print("_".join(name))  ***

7.格式化

 1.%s
 2.f
 3.name.format()
 name = "alex{},{},{}"
 print(name.format(1,2,3)) # 按照顺序位置进行填充
 name = "alex{2},{0},{1}"
 print(name.format("a","b","c")) # 按照索引值进行填充
 name = "alex{a},{b},{c}"
 print(name.format(a=1,c=11,b=67)) # 按照关键字进行填充

8.+ * 开辟新的空间

name = "alex"
name1 = "wusir"
print(id(name))
print(id(name1))
print(id(name + name1))

list:

定义方法

list("123")

其他方法

lst = [1,2,23,234,435,36,23,213421,421,4231,534,65]
lst.sort()  # 排序 (升序)
print(lst)

lst = ["你好","我好"]
lst.sort()  # 排序 (默认升序)
print(lst)

lst.sort(reverse=True) # 降序
print(lst)

lst = [1,2,3,4453,5,6,7]
print(lst[::-1])
lst.reverse()  # 反转
print(lst)

lst = [1,2,3,4,5123,21345,231123,4,1235,234,123]
lst.sort()
lst.reverse()
print(lst)

面试题

lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)

lst = [1,[]]
new_lst = lst * 5
new_lst[0] = 10
print(new_lst)

lst = [1,[]]
new_lst = lst * 5
new_lst[1] = 10
print(new_lst)

方式一:
lst.extend(lst1)
print(lst)
方式二:
print(lst+lst1)
new_lst = lst * 5
print(id(new_lst[0]), id(new_lst[0]))

lst = [[]]
new_lst = lst * 5
new_lst[0].append(10)
print(new_lst)

tuple

 tu = ("12")  # 数据类型是()中数据本身
 print(type(tu))

 tu = (1,)   # (1,)是元组
 print(type(tu))

 元组 + * 不可变共用,可变也共用

dict

定义一个字典

print(dict(k=1,k1=2))

随机删除:popitem

dic = {"key":1,"key2":2,"key3":56}
print(dic.popitem())  # 返回的是被删除的键值对(键,值)
print(dic)
python36 默认删除最后一个

dic = {}
dic.fromkeys("123",[23]) # 批量添加键值对{"1":[23],"2":[23],"3":[23]}
print(dic)

dic = dict.fromkeys("123456789",1) # 批量添加键值对"键是可迭代对象",值 -- 会被共用
dic["1"] = 18
print(dic)

set

    # set() -- 空集合
    # {} -- 空字典
    # 定义集合:
    # set("alex")  # 迭代添加的

bool: False
数字: 0
字符串: ""
列表:[]
元组:()
字典:{}
集合: set()
其他: None

数据类型之间转换

list  tuple
tuple list
str list
name = "alex"  print(name.split())
list str
lst = ["1","2","3"] # print(''.join(lst))

dict -- str
dic = {"1":2}
print(str(dic),type(str(dic)))
print(dict("{1:1}"))

set - list
list - set

# python数据类型:
# 可变:
# list ,dict ,set
# 不可变:
# int bool str tuple
# 有序:
# list,tuple,str,int,bool
# 无序:
# dict,set
# 取值方式:
# 索引: str list tuple
# 直接: set ,int ,bool
#   键: dict

二次编码

密码本

 ascii  -- 没有中文
 gbk    -- 英文 8b(位) 1B(字节) 中文 16b 2B
 unicode -- 英文16b 2B  中文32b 4B
 utf-8 --   英文8b 1B  欧洲16b 2B  亚洲24b 3B

 name = "你好啊"
 s1 = name.encode("utf-8") # 编码  9
 s2 = name.encode("gbk") # 编码  6
 s2 = s1.decode("utf-8") # 解码
 print(s2.encode("gbk"))
# 以什么编码集(密码本)进行编码就要用什么编码集(密码本)解码

以后会遇见的坑坑坑

循环

lst = [1,2]
for i in lst:
    lst.append(3)
print(lst)  # 死循环

删除列表的坑

lst = [1,2,3,4]
for i in lst:
    lst.pop()
print(lst)

lst = [1,2,3,4]
for i in lst:
    lst.pop(0)
print(lst)

lst = [1,2,3,4]
for i in lst:
    lst.remove(i)
print(lst)

成功删除的方式

lst = [1,2,3,4,6]
for i in range(len(lst)):
    lst.pop()
print(lst)

lst = [1,2,3,4,6]
for i in range(len(lst)-1,-1,-1):
    del lst[i]
print(lst)

lst = [1,2,3,4,6]
for i in range(len(lst)):
    del lst[-1]
print(lst)

lst = [1,2,3,4,5,6]
lst1 = lst.copy()
for i in lst1:
    lst.remove(i)
print(lst)

删除字典的坑

dic = dict.fromkeys("12345",1)  # 字典的迭代的时候改变了原来的大小(不能加不能删)
for i in dic:
    dic[i] = "123"
print(dic)

dic = dict.fromkeys("12345",1)
dic1 = dic.copy()
for i in dic1:
    dic.pop(i)
print(dic)

# 集合和字典都是迭代的时候不能改变原来的大小

文件操作

理论性知识

"萝莉小姐姐电话号.txt"
open()  # 打开
file  # 文件的位置(路径)
mode  # 操作文件的模式
encoding # 文件编码方式
f  # 文件句柄

f = open("萝莉小姐姐电话号",mode="r",encoding="utf-8")
print(f.read())
f.close()

操作文件:
    1. 打开文件
    2. 操作文件
    3. 关闭文件

文件操作的模式:
r,w,a (重要)
rb,wb,ab (次要)
r+,w+,a+ (没啥用)

f = open("文件的路径(文件放的位置)",mode="操作文件的模式",encoding="文件的编码") # 内置函数
f(文件句柄)

重要知识:r读,w写,a加 (重要) 内容

R操作读

f = open("萝莉小姐姐电话号",mode="r",encoding="utf-8")
print(f.read())    #全部读取
print(f.read(5))   #按照字符进行读取
print(f.read())

print(f.readline())  # 读取一行内容,自动换行
print(f.readline())  # "常鑫你就是大帅比\n"
print(f.readline().strip()) #去除换行符

print(f.readlines())  # 一行一行的读取,存放在列表中

解决大文件:
for i in f:
    print(i)  # 本质就是一行一行进行读取

print(f.readline())
print(f.readline())
print(f.readline())

W操作写

w分为两步:
    1.先清空文件
    2.写入文件

f = open("萝莉小姐姐电话号","w",encoding="utf-8")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")
f.write("123456789\n")

路径

1.绝对路径 -- C:\user\meet\python24\萝莉小姐姐电话号
2.相对路径

绝对路径方式打开文件
f = open("F:\s24\day08\萝莉小姐姐电话号","r",encoding="utf-8")
print(f.read())

相对路径方式打开文件
f = open("../day03/萝莉小姐姐电话号","r",encoding="utf-8")
print(f.read())
../ 返回上一层

f = open(r"C:\user\net\s24\day03\萝莉小姐姐电话号","r",encoding="utf-8")

路径转义:
    1."\\"
    2.r"C:\user\net"
推荐使用相对路径 (*****)

s = "[1,'2',3,4]"
print(s)
print(repr(s))  # repr -- 显示数据原生态

A操作:追加写加

在源文件的基础上进行添加
f = open("../day03/萝莉小姐姐电话号","a",encoding="utf-8")
f.write("138383848\n")
f.write("138383850\n")

次要知识:rb,wb,ab (次要) 字节

rb 读字节

f1 = open("1.jpg","rb")
print(f1.read())   # 全部读取
print(f1.read(3))  # 按照字节读取

wb 写字节

f = open("3.jpg","wb")
f.write(f1.read())

ab 加字节

f = open("2.jpg","ab")
f.write("你好啊".encode("utf-8"))

f = open("2.jpg","rb")
print(f.read())

不重要: +操作

R+ 读写-先读后写

错误的操作 (坑)
f = open("萝莉小姐姐电话号","r+",encoding="utf-8")
f.write("常鑫你太美")
print(f.read())


正确的操作:
f = open("萝莉小姐姐电话号","r+",encoding="utf-8")
print(f.read())
f.write("常鑫你太美")

w+ 清空写读

f = open("萝莉小姐姐电话号","w+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell())
f.seek(15)         
print(f.tell())
print(f.read())

a+ 追加写读

f = open("萝莉小姐姐电话号","a+",encoding="utf-8")
f.write("常鑫你太美")
print(f.tell())   # 字节数
print(f.seek(0,0))  # 0将光标移动到文件的头部
print(f.read())

其他操作:

tell 查看光标    --- 返回的是字节数
seek 移动光标
    1.seek(0,0)  -- 移动到文件的头部
    2.seek(0,1)  -- 当前位置
    3.seek(0,2)  -- 移动到文件的末尾
    4.seek(3)    -- 按照字节进行移动(按照编码集,自己进行计算)

f = open("萝莉小姐姐电话号","r",encoding="gbk")
print(f.read(3)) # 字符

f = open("萝莉小姐姐电话号","rb")
print(f.read(3))   # 字节

f = open("萝莉小姐姐电话号","r",encoding="gbk")
print(f.read(3))     # 字符

错误操作

f = open("萝莉小姐姐电话号","r",encoding="gbk")
f.seek(-1)
print(f.read())

文件修改

f = open("萝莉小姐姐电话号","r",encoding="gbk")
s = f.read()
s1 = s.replace("你太美","吃煎饼")

f1 = open("萝莉小姐姐电话号","w",encoding="gbk")
f1.write(s1)

with 关键字 open("萝莉小姐姐电话号","r",encoding="gbk") as f:
  文件操作的具体内容

w,a 检测有文件就操作,没文件就创建

with open("萝莉小姐姐电话号","r",encoding="gbk")as f,\
        open("萝莉小姐姐电话号.txt","w",encoding="gbk")as f1:
    for i in f:
        s1 = i.replace("大烧饼","井盖")
        f1.write(s1)

import os
os.rename("萝莉小姐姐电话号","萝莉小姐姐电话号.bak")
os.rename("萝莉小姐姐电话号.txt","萝莉小姐姐电话号")

with open("萝莉小姐姐电话号","r",encoding="gbk")as f:
    pass # 缩进里操作文件
print(f.read())  # 文件及已经关闭了

总结

1.字典 -- dict

字典是无序,可变的
键:使用不可变数据类型(可哈希),键是唯一的
值:可以任意

增加

     dic["键"] = "值"  # 暴力添加
     dic.setdefault("键","值")  # 存在不添加

删除

     del dic["键"]
     dic.pop("键")
     dic.clear()

改

     dic["键"] = "值"
     dic.update("要更新的字典")

查

     for 循环查询的是字典的键
     get("键")  #存在返回字典中键对应的值,不存在返回None
     dic["键"]    # 存在返回字典中键对应的值,不存在报错

其他操作

     keys  --  获取字典中所有的键      存放在一个高仿列表中
     values  --  获取字典中所有的值    存放在一个高仿列表中
     items  --  获取字典中所有的键和值 存放在一个高仿列表里的元组(元组第一个元素:键,第二元素:值)

解构

    a = 10
    b = 20
    a,b = b,a

字典的嵌套

   dic = {1001:["周杰伦","林俊杰"],
           1002:{"汪峰":{"前妻1":["大烧饼"],"前妻2":["熊大","熊二"],"国际章":"肉丝"}},
           1003:{"陈冠希":["阿娇","阿萨","张柏芝"]},
           1004:{"韦小宝":[{"教主夫人":["教主"]},
                        {"阿珂":"刺客"},
                        {"双儿":"天地会"},
                        {"爱心觉罗建宁":"公主"},
                        {"独臂神尼":{"韦小宝师父":{"兰陵王":"隐身"},"花木兰":[
                               "唧唧复唧唧","木兰是战士",{"爸爸":["花和尚"]}]
                                 }},
                        {"陈圆圆":"丈母娘"},{"穆建平":"小郡主"}]},
           1005:{"常鑫":["大黑哥","大烧饼","吃大煎饼","肉夹馍","自行车","井盖",]}
           }
    
 print(dic)
 print(dic[1004]["韦小宝"][0]["教主夫人"][0])
 print(dic[1005]["常鑫"][-1])
 print(dic[1002]["汪峰"]["前妻2"][-1])
 print(dic[1004]["韦小宝"][4]["独臂神尼"]["韦小宝师父"]["兰陵王"])
 print(dic[1004]["韦小宝"][4]["独臂神尼"]["花木兰"][2]["爸爸"][0])

    # 查找的时候一层一层的通过键进行查找
    # 键

1.小数据池

    1.1代码块: 一个文件,一个函数,一个类,一个模块,终端中每一行
       1.1.1 数字: -5 ~ 256
       1.1.2 字符串: 乘法时总长度不能超过20
       1.1.3 布尔值: 内容相同内存地址相同
    1.2 小数据池:
       1.2.1 数字: -5 ~ 256
       1.2.2 字符串: 乘法时总长度不能超过20
       1.2.3 布尔值: 内容相同内存地址相同
    1.3 先执行代码块后执行小数据池
    1.4 == is
        1.4.1 == 判断等号两边值是否相等
        1.4.2 is 判断两边的值内存地址是否相等

2.深浅拷贝

    2.1 赋值:
        多个变量名指向同一个内存地址
        一个变量对其进行操作,其他变量查看时都变动
    2.2 浅拷贝:
        lst[1:10] -- 是浅拷贝
        浅拷贝只拷贝第一层元素
        修改第一层元素时,新开辟的不进行改变
    2.3 深拷贝:
        不可变的数据类型共用,可变的数据类型重新开辟一个空间
        对源数据进行修改,深拷贝的内容不进行改变
        
# 浅拷贝=修改第一层元素不改变,其它改变.
# 深拷贝=修改任何位置,另外一个不改变.

3.集合

3. 集合
    3.1 集合是没用值得字典
    3.2 集合是无序,可变的
    3.3 集合天然去重
    3.4
        增:add ,update
        删:pop remove clear
        改:先删后加
        查: for循环
    3.5 其他操作:
        & 交集
        | 并集
        - 差集
        ^ 反交集
        > 超集
        < 子集
        frozenset()  冻结集合
    3.6 面试题:
        list(set(要去去重的数据))

1.编码解码

# 编码:将文字转换成字节形式  encode
# 解码:将字节转换成文字形式  decode

2.基础数据类型

str:
    首字母大写
    每个单词首字母大写
    大小写反转
    居中 -- 填充
    查找:find index
    拼接
    格式化: name.format

list:
    排序(默认是升序) 降序sort(reverse=True)
    反转
    查找 index
    统计 count
    + * 元素都是共用的

    面试题:

tuple:
    (1,)# 元组
    (1) # 括号里数据本身
    + *

dict:
    popitem
    fromkeys("可迭代的键",共用的值)   -- 坑
    dict(key = 1,key2 =2)

set:
    set() -- 空集合
    set("alex") # 迭代添加

3.坑

    列表删除  -- 从后向前删除
    创建一个新的列表,删除旧的列表

    字典删除  -- 循环的时候不能改变源数据的大小 (可以改变值)
    创建一个新的字典,删除旧的字典

    集合删除  -- 循环的时候不能改变源数据的大小

类型转换

     list -- str  join
     str -- list  split

文件操作

open  -- 打开文件
file  -- 文件路径
mode  -- 操作文件的模式
encoding -- 文件的编码集

打开文件
操作文件
关闭文件

r,w,a (******)

     r: 读文本
        read()  全部读取
        read(3) 看文件的操作方式 r/w/a 字符
        readline 读取一行(自带换行符)
        readlines() 一行一行读取存放在列表中

     w:清空,写
        open("xxx","w",encoding="utf-8")  # 进行清空
        write()  只能写字符串

     a:追加
        在文本的末尾进行写入
        write()

rb,wb,ab(****)

    rb:读字节
        read()  全部读取
        read(3) 看文件的操作方式  rb/wb/ab 字节
        readline 读取一行(自带换行符)
        readlines() 一行一行读取存放在列表中

    wb:清空,写
        open("xxx","wb")  # 进行清空
            write()  只能写字节

    ab:追加
        open("xxx","ab")
            write()  只能写字节

r+,w+,a+ (r+)

    r+:读写
        错误的方式是写读
        先读后写

    w+:清空写,读
        1.清空文件
        2.读取内容(默认读取的是空)
        3.移动光标

    a+:追加写,读
        1.先写后读
        2.读取内容(默认读取的是空)
        3.移动光标
# 注意点: (a,ab,a+)将光标移动到某个位置进行,写入的时候还是在文件的末尾

其他操作:

    tell()  查看光标返回的是字节
    seek() 移动光标
        seek(0,0) 移动文件头部
        seek(0,1) 当前位置
        seek(0,2) 移动文件末尾

        seek(3)  # 按照字节进行计算 (计算方式根据编码计算)

    with open("文件路径","操作模式",编码")as f:
        操作文件

    with open的好处:
        1.可以同时打开多个文件
        2.能够自动关闭文件

    修改文件内容:
        1.创建一个新的文件
        2.将文件中的内容进行替换
        3.替换后的内容写入新文件中
        4.改变文件名

重点

    路径:
        绝对路径: 从磁盘根部进行查找
        相对路径: ../返回上一级  --推荐使用
        转义:
            1."C:\\user\\ner"
            2. r"C:\user\ner"  -- 推荐使用

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2019-07-05 ，如有侵权请联系 cloudcommunity@tencent.com 删除

javascript

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

javascript

其他

Python基础三

Python基础三

1.字典 -- dict

增加

删除

改

其他操作

解构

字典的嵌套

小数据池--缓存机制(驻留机制)

== 判断两边内容是否相等

is 是

小数据池的数字范围:-5~256

代码块:一个文件,一个函数,一个类,一个模块,终端中每一个行是一个代码块

小数据池

必会:

总结

深浅拷贝--复制

浅拷贝的时候

深拷贝

总结

测试代码

集合--set

定义集合

面试题:

其他操作:

基础类型补充

str:不可变

1.首字母大写

2.每个单词首字母大写

3.大小写反转

4.居中--填充

5.查找 从左向右 只查找一个

6.拼接

7.格式化

8.+ * 开辟新的空间

list:

定义方法

其他方法

面试题

tuple

dict

定义一个字典

随机删除:popitem

set

数据类型之间转换

二次编码

密码本

以后会遇见的坑坑坑

循环

删除列表的坑

成功删除的方式

删除字典的坑

文件操作

理论性知识

重要知识:r读,w写,a加 (重要) 内容

R操作 读

W操作 写

路径

A操作:追加写 加

次要知识:rb,wb,ab (次要) 字节

rb 读 字节

wb 写 字节

ab 加 字节

不重要: +操作

R+ 读写-先读后写

w+ 清空写 读

a+ 追加写 读

其他操作:

错误操作

文件修改

w,a 检测有文件就操作,没文件就创建

总结

1.字典 -- dict

增加

删除

改

其他操作

解构

字典的嵌套

5.查找从左向右只查找一个

R操作读

W操作写

A操作:追加写加

rb 读字节

wb 写字节

ab 加字节

w+ 清空写读

a+ 追加写读