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"  -- 推荐使用

学习2：内容# 1.while # 2.字符串格式化 # 3.运算符 # 4.编码初始的更多相关文章

  1. 学习2：总结# 1.while # 2.字符串格式化 # 3.运算符 # 4.编码初始

    目录 1.while循环 -- 死循环 2.字符串格式化: 3.运算符 4.编码 1.while循环 -- 死循环 while 条件: 循环体 打断死循环: break -- 终止当前循环 改变条件 ...

  2. day02——while、字符串格式化、运算符、编码初识

    day02 while--关键字(死循环) 格式:while 条件: ​ 循环体 print(1) while True: print("痒") print("鸡你太美& ...

  3. python27期day02：while循环、break、格式化、运算符、编码初始、作业题。

    1.while循环:不断的重复着某件事就是循环 2.while循环图解: 3.break:终止当前循环. 4.continue就是跳出本次循环.继续下次循环. 下方代码都不会执行. 改变循环条件来终止 ...

  4. python学习6—数据类型之集合与字符串格式化

    python学习6—数据类型之集合与字符串格式化 1. 使用id()可以查看一个变量的内存地址: name = 'alex' id(name) 2. 进制转换 十进制转换为二进制等: a = 10 # ...

  5. 小白之入口即化——十分钟看懂while循环，字符串格式化，运算符

    while循环 while循环-死循环 while空格+条件+冒号 缩进+循环体 3.打断死循环 break--终止当前循环 while True: print(123) print(234) bre ...

  6. python全栈 流程控制;while 循环 格式化输出 运算符 及编码

    python全栈开发 1循环 2break和continue的区别 3格式化输出 4运算符 5编码 一.流程控制while循环 while条件: 代码块(循环体) 1.死循环; while True; ...

  7. while循环,格式化输出,运算符及编码初识

    一.while循环 1.基本循环(死循环) while 条件: 循环体 2.使用while计数 count = 0 # 数字里面非零的都为True while True: count = count ...

  8. python学习（二十四） 字符串格式化

    1: Test 1 a = 'city' b = 'country' print(" aaa %s bbb %s " % (a, b)) result: aaa city bbb ...

  9. 总结day2 ---- while循环的简单使用, 格式化输出.运算符.以及编码的应用

    内容提要 一 : while 循环 while 的基本语句操作 如何终止循环 二 :格式化输出 三 :运算符号 四 :编码初识别 一 : while 循环 1  >>>>whi ...

随机推荐

  1. SqlServer 复制中将大事务分成小事务分发

    原文:SqlServer 复制中将大事务分成小事务分发 在sql server 复制中,当在发布数据库执行1个大事务时,如一次性操作 十万或百万以上的数据.当操作数据在发布数据库执行完成后 ,日志读取 ...

  2. DEPLOYING NATIVE UWP (UNIVERSAL WINDOWS PLATFORM) APPS FOR JAVA DEVELOPERS & PUBLISHING THEM TO THE MICROSOFT STORE

    原文: DEPLOYING NATIVE UWP (UNIVERSAL WINDOWS PLATFORM) APPS FOR JAVA DEVELOPERS & PUBLISHING THEM ...

  3. AStyle 2.02版本 AStyle（全称Artistic Style）是一个C、C++、C#和Java源代码缩进、格式化和美化工具

    http://download.csdn.net/detail/akof1314/3323725

  4. Android CTS Test failed to run to conmpletion 测试超时问题

    引用“Android cts all pass 全攻略”里面的一段话: ❀ testcase timeout 测试某个testcase的时候一直出现 “........”,迟迟没有pass或者fail ...

  5. 预处理器#include 指令

    预处理器发现 #include 指令后,就会寻找后跟的文件名并把这个文件的内容包含到当前文件中.被包含文件中的文本将替换源代码文件中的#include指令,就像你把被包含文件中的全部内容键入到源文件中 ...

  6. Silverlight消散，WinRT登台

    2011年,Silverlight刚开始有蓬勃发展的起色,不利的传言就开始大量流传.不安的Silverlight开发者们要求微软澄清,但得到的只是沉默.终于随着微软在BUILD上亮相Window 8以 ...

  7. LOG4NET图文教程

    LOG4NET教程 一:简介 从操作系统到大多数的大型软件,都会有自己的程序运行时的日志跟踪API.因为一旦程序被部署以后,就不太可能再利用专门的调试工具了.然而软件开发人员需要一套强大的日志系统来记 ...

  8. 解释一下，知乎上关于C语言奇技淫巧最火的回答。

    前几天逛知乎,碰巧发现一个很火的问题. “C 语言有什么奇技淫巧?”虽然问题本身没有什么特殊的地方,但是网友的回答却是非常幽默. 下面就让我们一起来分析一下,被赞最多的答案“C 语言运算符 趋向于‘- ...

  9. java集合框架collection(6)继承结构图

    根据<java编程思想>里面的说法,java集合又叫容器,按照单槽和双槽分为两类,Collection和Map,这两个都是接口. 一.Collection Collection下面又分了三 ...

  10. webpack 编译ES6

    虽然js的es6是大势之趋,但很多浏览器还没有完全支持ES6语法,webpack可以进行对es6打包编译 需要安装的包有 npm init // 初始化 npm install babel-loade ...