笔记
一.基本序列类型
0.声明空变量
li=[] #声明一个空列表
lis={} #声明一个空字典 因为字典比集合用的多
lst='' #声明一个空字符串
mo=() #声明一个空元组
me=set() #声明一个空集合
1.列表（list）(可变序列)
增（append、insert、extend）
a=['sdsd','sdddd',321]
append——a.append('sda')
末尾追加——末尾 增加sda
insert
指定追加——a.insert(0,'sda')
extend
打散型末尾追加，用法同append，将所有内容打散（内容不能是单个数字）
删（pop、remove、clear、del）
pop：下标指定删除 remove：选择一个元素进行删除，默认从左开始，只删一个 clear：清空列表所有数据（结果返回空列表） del：可以进行下标删除 也可以del 列表名，直接删除列表
改（下标、切片）
单个修改，直接利用下标 多个修改：可以通过切片方式实现，但是切多少个数据，右边就要写多少个数据
查（index、count）
index：根据数据，获取数据下标（也可以设置起点值）
语法格式:列表名.index(数据)
列表名.index(数据,起点值)
count：求和，统计数据出现次数 列表名.count(数据)
列表的排序（sort）
升序 列表名.sort() 升序 列表名.sort(reverse=Ture) 降序
2.元组（tuple）（不可变序列）
查（同列表）
元组 为不可变序列，无法修改
3.字符串（不可变序列）（使用时候先print再输入格式）
增（加号连接）
print('sd'+'dsa')
删(repalce)
repalce：（删除或者替换）
字符串.repalce('替换值','')#删除
字符串.repalce('替换值','新值')#替换
字符串.replace('替换值','新值',修改次数)(从左开始)
使用时候要直接print 再加格式
改（大小写，切割，去空格）
upper：字母全大写
lower：字母全小写
title：单词首字母大写
strip：去除字符串左右空格
split：切割字符串
语法格式: 字符名.split('分割对象')
4.集合（set）（无序）
认识
集合的特性:唯一性,无序性 主要是用来进行去重和逻辑判断
增（add）
add:
语法格式: 集合名.add(数据)
因为是无序的，所以随机增加
删（pop、remove）
pop:删除一个数据(根据版本不同有些是从头开始删除或者随机或者从末尾开始删除) 语法格式:集合名.pop()
remove:删除指定数据 语法格式:集合名.remove(数据)
ps:选择性删除
5.字典（dict）（无序）
键值对
增（setdefault、update）
setdefault
语法格式: 字典名.setdefault(键,值)
一次只能增加一个键值对
键存在时,不会对其进行修改
当没有写值的时候,会默认为None
update
语法格式: 字典名.update({键:值,键:值})
可以多次增加或者修改
删（pop、popitem、clear）
pop: 通过键名删除指定的数据#键名删除
语法格式: 字典名.pop(键名)
popitem:根据版本不同随机删除键值对#删一对
语法格式: 字典名.popitem()
clear:全部清除
语法格式: 字典名.clear()
改（通过键名去修改）
查（key、value、items）
key：通过key可以寻找值
语法格式: 字典名[key]
get通过键(key)获取值
语法格式: 字典名.get(key)
字典名.keys() # 获取字典中所有的键 字典名.values() # 获取字典中所有的值 字典名.items() # 获取字典中所有的键值对(键值对是以元组的形式输出)
defaultdict
dict.setdefault()方法：有两个参数，第一个是参数，第二个是默认值。
二.格式化输出
1.f-str输出（format string）
print(f'dsada{dsds}dsd')
2.占位符
print('我最喜欢的美食是%s,需要%d元'(数据1，数据2))
3.format
print('xxx{}xxx{}'.fomat(数据1，数据2))
4.保留小数
>>> x = 3.1415926
>>> print("%.2f" % x)
3.14
例子：
a,b = input().split(',')
print("{:.2f} {:.2f}".format(abs(eval(a)),abs(eval(b))))
三.绝对路径和相对路径
绝对路径: 完整的具体位置
相对路径: 简单位置,有一个参考的坐标(如果在同一个文件里就可以使用)
四.字符编码
utf-8(内容最多最主流)
Unicode（超过14w字符）
ASCII
查找ASCII（ord）
查找字符（chr）
五.流程控制
1.if类
if 表达式：
代码块
if 表达式：
代码块
else：
代码块
if-elif
if 表达式： 代码块 elif 表达式： 代码块 else： 代码块
2.缩进
tab（四个空格） 缩进会调整代码之间的作用域的关系
3.循环结构
1）while循环
语法格式:
while 循环条件:
执行语句 #当满足循环条件就执行 否则不执行
循环条件的更新
while 1: #最简单的死循环
执行语句
2）for循环
语法格式:
for 变量名 in 可迭代对象(字符串 列表 元组 字典 集合):
执行语句
语法格式2:
for 变量名 in range(数值):
执行语句
range(起点值,终点值)
4.嵌套
1）分支嵌套
if 表达式：
代码块
if 表达式：
代码块
else：
代码块
else：
代码块
2）循环嵌套
1>for循环嵌套
例如
打印99乘法表
for i in range(1,10):
for j in range(1,10):
print(f'i*j={i*j}',end='\t') # 每个式子后面增加间距
print('') # 满十个换行
斜三角99乘法表
for i in range(1,10):
for j in range(1,i+1):
print(f'i*j={i*j}',end='\t') # 每个式子后面增加间距
print('') # 满十个换行
2>while循环嵌套
例如：登录操作
while count<3:
name=input("请输入用户名")
password=input("请输入密码")
if name=="huxiaohui" and password=="123456":
print("你答对啦")
break
else:
print("错啦 再来一次")
5.break、continue、pass
break--->结束循环
但是你跑了十圈体力不支就偷懒了选择摆烂 -- break 结束循环
for i in range(1,101):
print(f'我跑了第{i}圈')
if i == 10: # 在我满足第十圈的时候就结束执行
print('我不跑了')
break
continue--->跳过这一圈继续运行
抄书 但是不精 找到一些页面我就跳过不写 耍滑头 --> continue 跳过
for i in range(1, 21):
if i == 10 or i == 15 or i == 20:
continue
print(F'这是我抄书的第{i}遍')
pass--->占位符
当我们流程控制里面,有语句没有想好的话,可以使用pass占位 防止一些不必要的报错
六.函数
1.函数的定义
def 函数名（）：
代码块
代码块
函数名（）#最后用带括号函数名来调用函数
2.函数的参数
1）必备参数
参数分为：
形参：没有具体数据 -- 定义时候
实参：有具体数据 -- 调用时候
def woman(name):
print(f'{name}恭喜入选')
woman('罗志祥')# 实参会把值反代入进形参，再进入到函数去
2）默认参数
形参在定义的时候可以直接对形参赋值
def food (food1,food2='烤鸡'):
print(f'今晚表现很好奖励自己一个{food1}顺便打包{food2}回家')
food('炸鸡')
food('炸鸡','可乐') #烤鸡被覆盖
# 但是赋值的形参会被新加入的实参覆盖
3）不定长参数（*args、**kwargs）
*args：长度不限 可以一次性接受多个参数
ps：该参数接收到多余的参数值之后 会将值保存到元组中
def 函数名(*args):
代码
调用时
函数名(值1,值2....)
**kwargs：一次性可以接收多个数据 但是接收的数据类型是为键值对 得到的参数变量为字典类型的数据
ps：该参数将多余的参数值以字典的方式保存 其中参数名作为字典的键(key) ,参数值作为字典里的值(value)
def 函数名(**kwargs)：
调用时
函数名(参数名=值,参数名1=值1)
3.返回值（return）
return：将定义的函数的值返回给调用的变量
def 函数名:
代码
return 返回值
print(函数名()) #得到函数返回值
七.函数作用域和名称空间
1.函数功能（*重点：闭包函数）
1.把函数赋值给变量
def fun_1():
return '婷婷是个靓女'
b=fun_1() #把函数fun_1的返回值赋值给了变量b
a(b)
print(b)
2.函数可以作为元素放在列表、元组、字典、集合中使用
def fun_3(a, b):
return a + b
ll1 = (66, 88, 99, fun_3, 77)
print(ll1[3](5, 6))
3.函数可以作为参数被传递给另一个函数
def name():
my_name = '婷婷'
return my_name
def name1(a):
print(f'我是个靓女{a}')
name1(name())
4.函数可以作为返回值（闭包函数）
def boss(a, b): #老板收到两个任务(参数)
def boss1(c, d): # 我在任务加了两个创意(参数)
return c + d # 做好东西
return boss1(a, b) # 老板拿做好的东西 邀功
print(boss(66, 88)) # 成果是老板的 跟我没半毛钱关系
2.名称空间
名称空间: 就是存放名字的地方 即存放变量名,函数名
名称空间 -- 存储变量名 函数名 模块名
内存数据 -- 变量值 函数代码 模块里的代码
一共有三层结构
1.内建名称空间(存放内置函数)
生命周期:随着python程序启动而生成,在程序关闭时回收,清除所有的数据
加载顺序:最先被加载出来的
存放对象:内置函数 print input type len sum
2.全局名称空间(python定义在外层的名字)
生命周期:随着python文件执行之前产生,运行完后销毁
加载顺序:第二个被加载出来的
存放对象:在python外层写的代码,定义的变量名 函数名
3.局部名称空间(存在函数内定义的名字)
生命周期:随着函数的调用而生成, 在结束调用时销毁
加载顺序:在调用时才会被加载
存放对象:在函数里定义的变量名,函数名,形参
3.作用域
作用域: 一个数据能够使用的范围
作用域分为:全局作用域 局部作用域
1）global（提权）
提权:让一个数据从局部变成全局，大家都可以用
def 函数名():
global 变量名
操作变量
函数名()
print(变量)
2）nonlocal（降权）
降权: 将局部变量再度局部化
a=888
def fun1():
a=1 #这个里a 在函数里是公共的 函数里都可以使用
def fun2():
nonlocal a
a=0 #把变量a 进行修改 霸道的抢过来 私有化
fun2()
print(a)
fun1()
## 结果为0
4.匿名函数（lambda）
语法格式: lambda 变量:操作
因为他匿名，所以他单独使用的时候是需要给他赋上一个名字的。
lambda 参数列表:运算表达式 f = lambda x:x*x print(f(5))
5.高阶内置函数
print(abs(-1)) # 绝对值 print(sum([1, 2, 3, 4])) # 求和 print(round(4.3)) # 四舍五入
任意两个数字，对这2个数字求绝对值后进行求和
def ab_sum(a,b,f):
return f(a) + f(b)
res = ab_sum(-1,-4,abs)
res1 = ab_sum(1.1,-4.8,round)
print(res)
6.map（）
语法： map(func,seq)第一个参数是给一个函数，第二个参数是给一个序列类型 map可以直接操作序列中每个元素 map可以改变序列中所有的元素，改变规则由我们传入的函数决定
例如：
list1 = [1,2,3,4,5]
def add1(x): # x就代表列表中的每个元素
return x+1
print(list(map(add1,list1)))
# [2, 3, 4, 5, 6]
7.filter（）
语法： filter(func,seq)第一个是给一个函数，第二个给一个序列类型 用于过滤序列，过滤掉不符合条件的元素
list1 = [1,2,3,4,5,6,7,8,9,10]
def o2s(x):
return x%2==0
print(list(filter(o2s,list1)))
# 结果保留偶数
8.*递归函数
一个函数内部调用了自己，那么就叫做递归函数
# 打印1-500
def func(x):
if x ==501:
return
print(x)
return func(x+1) # f(1) = f(2) = f(3)...f(501 结束)
func(1)
9.生成器(生成器名 = （x for x in range（数字））)
r = (x for x in range(1,6)) print(next(r)) print(next(r)) print(next(r)) print(next(r)) print(next(r)) print(next(r)) # 报错 next数量不可以超过总共生成的量
生成器的创建方式：
1.(i for i in range(1,10))
2.yield 关键字
def f():
print('hello world')
yield 1
g = f()
print(next(g))
hello world
1
迭代是遍历的方法
遍历是迭代的目的
从现象来看，只要是可以for循环的都是可迭代对象
从本质来看，是内置有iter方法的是可迭代对象
记住本质：能循环是因为内部有一个iter方法
可迭代对象：拥有iter方法的
yield 和 return的区别： return：在函数中给返回某个值，然后函数结束运行，一般没有返回值类型，就不用写return yield：带 yield 的函数是一个生成器，在函数内部碰到 yield 的时候，函数会返回某个值，并且停留在这个位置，当下次执行函数后，会在上次停留的位置继续运行
10.迭代器
生成器都是迭代器
iterable --可迭代对象
什么是迭代器： 1.有iter方法 2.有next方法 l = [1,2,3,4] d = iter(l) print(next(d)) print(next(d)) print(next(d)) print(next(d))
for循环内部本质就是3个事情： 1.调用可迭代对象的iter方法返回一个迭代器 2.不断地调用迭代器的next方法 3.处理异常
小结
迭代：每一次对过程的重复称为一次迭代，而每一次迭代得到的结果会作为下一次迭代的初始值 可迭代对象：从语法形式上讲，内置有iter方法的对象都是可迭代对象 调用 iter方法返回的结果就是一个迭代器对象 迭代器对象是内置有iter和next方法的对象
11.装饰器
在不修改源代码的基础上给函数增加新的功能
@ 语法糖
def show_time(func): # 这个函数的功能就是帮忙计算时间的
def inner(*args,**kwargs):
start = time.time()
func(*args,**kwargs) # print('foo..')
time.sleep(1) # sleep()可以休眠程序，括号里面时休眠几秒
end = time.time()
print(f'运行了{end - start}秒')
return inner
@ show_time
def add(*args,**kwargs):
sum1 = 0
for i in args:
sum1+=i
print(sum1)
add(1,2,3,4,5)
八.模块
模块使用分两步:
1.导入模块
import 模块名
2.使用模块
print(模块名.变量名) # 调用模块里的变量
模块名.函数名() #调用模块里的函数
如果模块名过长可以通过as关键字 给他取小名
import win32process as pro
当你只需要导入模块里的当个变量/函数时, 可以单独导入
from 模块名 import 函数名
from 模块名 import 变量名
模块分为三类:
内置模块 -- python 自带的工具
第三方模块 -- 别人写好的需要另外下载的工具
自定义模块 -- 用户自己写的工具
下载第三方模块 -->
cmd中输入 pip install 模块名
Python文件分为两种情况:
1.该文件是以模块身份运行,模块是作为工具,他的内置变量__name__的值为模块名
2.该文件是以程序的身份执行作为启动程序,他的内置变量__name__的值为__main__
如果需要测试/调试文件,可以写上main判断 把一些测试代码放在main判断中(
Python的main跟其他语言的面不一样)
if __name__ == '__main__':
代码
包:一个文件夹,里面有对应的功能模块,里面有个名为__init__.py文件
__init__.py:随着包的创建自动生成,当导入包里的模块时,会运行__init__的代码,所以可以把一些配置信息,使用说明放在此文件中
跨文件夹导入模块
from 文件夹 import 模块名
1.常用模块***
1）time
tm_year=2022,代表当前年份 tm_mon=12,代表当前月份 tm_mday=9,代表当前日期 tm_hour=20,当前小时 tm_min=20,当前分钟 tm_sec=27,当前秒数 tm_wday=4,代表当前的星期(范围从0-6) tm_yday=343,代表今年的第几天 tm_isdst=0,冬令时 夏令时
2）random
a = random.random() ——# 生成一个大于0并且小于1 随机数 b=random.randint(1,10) ——# 获取指定范围之间的随机整数 c=random.uniform(10,2.2) ——# 获取指定范围之间的随机小数 ll=(2,3,5,6,7,89,7) d=random.choice(ll) ——# 在列表内随机抽取 列表元组 ll1=[2,3,5,6,7,89,7] random .shuffle(ll1) ——# 打乱列表顺便 洗牌 列表可变
3）os
主要是运行在操作系统上的相关信息(文件)
1.os.system 运行cmd命令 关机 打开计算器 画图工具
# os.system('start cmd') 打开cmd
# os.system('start calc') 打开计算器
# os.system('start osk') 打开屏幕键盘
2.获取当前文件所在路径目录
# print(os.getcwd())
3.在当前路径新建文件夹 已经存在再次创建就会报错
# print(os.mkdir('text'))
4.删除文件夹 只能删除空白的文件夹
# print(os.rmdir('text'))
5.对文件进行重命名
# print(os.rename('demo1.py','demo2.py'))
6.判断当前路径文件是否存在
# print(os.path.exists('demo.py'))
...
# 将散列部分组成一个完整的路径
# 别人给你几个路径或者文件名字
print(os.path.join('Python_78', 'day9', 'os模块.py'))
# 组成路径 并不是真实的路径后期你们可以组成自己真实的路径 只是说可以组成路径
# 这里的斜划线都是一样
# 对路径去掉文件名
print(os.path.dirname('Python_78\day9\os模块.py'))
# 对原有的路径进行重新组成
print(os.path.join(os.path.dirname('Python_78\day9\os模块.py'), 'os22.py'))
# 去掉路径获得文件名
print(os.path.basename('Python_78\day9\os模块.py'))
4）json
-
-
json模块
-
json是一种文件的存储格式 主要作用就是保留原来类型的情况下,保存数据
-
一个数据json保存可以确保 存之前是列表 取出来还是列表
-
json就是一种让你的文件可以保留原来类型的文件格式类型
-
json模块提供了四个功能 # 序列化 dumps: 把数据类型转换为字符串 --无文件关联时候 dump: 把数据类型转换为字符串并且存储到文件中 --有文件关联时候 # 反序列化 loads: 把字符串转变成数据类型 load: 把文件打开从字符串转变为数据类型
5）re（*正则表达式）
正则表达式:检查字符串是否包含指定字符,获得从字符中提取某个字符内容比较多 爬虫用的多
-
元字符
'.':匹配任意一个字符 \n是个例外 '+':匹配前一个元字符多次 '\W':匹配非字母数据以及下划线 '\w':匹配字母数据以及下划线
-
方法
match() 从头开始匹配 group() 只获取匹配到的字符 findall(): 查询所有满足条件的 split():根据指定字符进行切割 sub():替换指定字符
示例：
# res_1='婷婷是\t个超级无敌大美女'
# msg_1=re.match('.',res_1)
# print(msg_1) #并没有很直观的输出一个字符 对象 位置 字符
# print(msg_1.group())
# msg_2=re.match('.........................',res_1) #超过就报错 因为没有那么多
# print(msg_2.group())
# msg3=re.match('.+',res_1) #几乎是整个字符串 匹配出来
# print(msg3.group())
# msg4=re.match('......',res_1)
# print(msg4.group())
# res2='IN 2022 ,& tt_tt1'
# print(re.findall('\w',res2))
# print(re.findall('\W',res2))
正则表达式补充
context = '<title>asjokdaono</title>' import re print(re.match(r'<(\w+)>([\w\W]*)</(\w+)>', '<title>asjokdaono</title>').group(1)) \1 代表第一个分组的内容 \2 代表第二个分组的内容 ?P<别名> print(re.match(r'<(?P<tag>\w+)>([\w\W]*)</(?P=tag)>', '<title>asjokdaono</title>').group())
-
hashlib**
哈希模块
哈希是一种规则可以接收一个数据来生成一个哈希数据 作用用来数据加密
就像算命一样 你给算命先生说过的事 他会给你一些回复
特点:
传入的内容是一样的 hash值也是一样的
你和别人算命 如果说的东西一样 返回的结果也是一样
hash值正常情况下 破解难度比较大
算命过程比较玄学 难以破解
不管传的数据/文件多大多长 最后得到的哈希值长度都是为32位
不管你跟算命先生说了多少 他就只回你32个字
说白了就是我给你个数据你返回我一个基于这个数据生成的32位的哈希数据(看不出规律的32位字符)
WiFi破解-->笨蛋方法 找一个密码字典(记录了很多常用的密码本)
拿里面的密码一个个尝试 --> 密码简单 常见
带了符号 中文 --> 破解不了
加盐
相当于密码123456 你可能误打误撞就蒙对了
我觉得这个密码有风险我现在给他加了东西 123456+'螺丝粉'
生成哈希值是基于123456螺蛳粉 生成的 而不是123456
如果单纯123456来破解 是破解不了
主要是在后续我们开发网站的时候 后台处理数据的时候会用到
2.模块的下载
pip -- python自带的下载器
install -- 下载
uninstall -- 卸载
pip 没有设置python的环境变量的话,那么这个配置就找不到 所以下载python的时候要记得配置环境变量
python默认下载库就是使用pip 如果python环境没有设置好,pip就使用不了-->修复/重装
#下载模块
pip install 模块名
pip install pywin32
#pycharm下载模块(首先选择cmd下载 其次在是pycharm)
file -- settings -- projoct -- + -- install
(有时候pycharm下载是在虚拟环境中,不会在电脑python环境里,当你重新创建项目的话可能访问不到)
在cmd里下载就是全部下载到自己的python环境里面 这样不管如何创建项目都能访问到
#卸载模块
pip uninstall 模块名
#查看模块
pip list
#更新pip 有时候pip的版本太低 新的库升级不了
python -m pip install --upgrade pip -i
#通过(cdn)代理加速,下载第三方模块:
pip install 库名 --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install requests --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple
3.模块的使用
第一种： import 模块名 将某模块的整体导入到当前模块中 第二种： from 模块名 import 成员名 将指定的成员导入到当前模块作用域中 第三种： from 模块名 import * 将指定模块的所有成员导入到当前模块作用域中 注意：导入进来的成员不要与当前模块成员名称相同 如果相同会遵循就近原则 as 取别名 from module01 import f as f1 from module02 import f as f2 from module03 import f as f3
-
隐藏成员
-
模块中以
_开头的属性，不会被导入隐藏成员只对 * 有作用
-
九.文件操作
操作文件步骤：
1.打开文件
2.对文件进行操作(读，写)，保存
3.关闭文件
1.打开
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 绝对路径：ctrl+shift+c 绝对路径通常是指从盘符开始的完整路径 相对路径通常使用“.”或者“..”开头 “./”表示当前文件所在的目录，可以省略不写 “../”表示当前目录的上一级目录 “../../”表示上上级目录 “/”开头代表根目录 在python中一般表示路径可以使用两个\\ 或者 / 最好的办法是在路径前面写一个r r的作用可以规避反斜杠
例： fileName = r'../day14/demo.txt' demo = open(fileName) print(demo)
2.关闭
close（）
fileName = r'../day14/demo.txt' demo = open(fileName) content = demo.read() print(content) print(type(content)) # <class 'str'> demo.close()
读取之后自动关闭
with open...as 语句
fileName = r'../day14/demo.txt'
with open(fileName) as f:
print(f.read()) # 可以读取出来
print(f.read()) # 文件已经自动关闭，报错
3.读取
open打开文件默认以文本文件的形式打开
fileName = 'demo2.txt'
with open(fileName,encoding='utf-8') as f:
content = f.read()
print(content)
你好
世界
保存
关闭
read()读取全部
read(参数) 参数为要指定读取的字符的数量
读取文件方式1
# 读取大文件的方式
with open(fileName,encoding='utf-8')as f:
# 定义变量，指定每次读取的大小
c = 2
# 创建循环读取文件内容
while 1:
# 读取指定大小的内容
content = f.read(c)
# 检测内容是否为空
if content == '':
# 读取完毕，退出循环
break
# 输出读取出来的内容
print(content,end='')
读取文件方式2
# 读取大文件的方式
with open(fileName,encoding='utf-8')as f:
all_content = ''
# 定义变量，指定每次读取的大小
c = 2
# 创建循环读取文件内容
while 1:
# 读取指定大小的内容
content = f.read(c)
# 检测内容是否为空
if content == '':
# 读取完毕，退出循环
break
# 输出读取出来的内容
all_content+=content
print(all_content)
只读一行
readline() 读取一行内容
with open(fileName,encoding='utf-8')as f:
print(f.readline(),end='')
print(f.readline(),end='')
print(f.readline(),end='')
print(f.readline())
readlines() 一行一行的读取内容，一次性读完存到列表里面
with open(fileName,encoding='utf-8')as f:
print(f.readlines())
#结果为：['你好\n', '世界\n', '保存\n', '关闭']
with open(fileName,encoding='utf-8')as f:
l = f.readlines()
print(l[1:3]) # ['世界\n', '保存\n']
4.写入***
write() # 括号里面的值必须是字符串类型
write也有返回值，返回值就是你写入的字符串的长度
r：只读
w：可写，会覆盖文件，如果文件不存在时，会创建文件
a：追加，如果文件不存在时，会创建文件
fileName = 'demo3.txt'
with open(fileName,'w',encoding='utf-8')as f:
a = f.write('python')
print(a)
fileName = 'demo3.txt'
with open(fileName,'a',encoding='utf-8')as f:
f.write('你好世界')
f.write('你好世界')
5.二进制文件
t 读取文本文件
b 读取二进制文件
fileName = r'C:\Users\EDY\Desktop\陈奕迅 - 不要说话.mp3'
with open(fileName,'rb')as f:
# 新的文件名
new_path = 'qq.mp3'
with open(new_path,'wb')as new_f:
# 每次读取的大小
c =1024
# 循环读取写入
while 1:
# 从旧的对象中读取数据
content = f.read(c)
# 读取的这个数据还有就继续读，没有就break退出
if not content:
break
# 将读取出来的数据写入到新的对象文件中
new_f.write(content)
fileName = r'C:\Users\EDY\Desktop\陈奕迅 - 不要说话.mp3'
with open(fileName,'rb')as f:
# 新的文件名
new_path = 'qq.mp3'
with open(new_path,'ab')as new_f:
# 每次读取的大小
c =1024
# 循环读取写入
while 1:
# 从旧的对象中读取数据
content = f.read(c)
# 读取的这个数据还有就继续读，没有就break退出
if not content:
break
# 将读取出来的数据写入到新的对象文件中
new_f.write(content)
***写入的文字规范
| 打开模式 | 效果 |
|---|---|
| r | 以读方式打开，文件必须存在 |
| w | 以写方式打开，文件不存在则创建，存在清空原有内容 |
| a | 以追加模式打开，文件不存在则创建，存在则继续进行写操作 |
| r+ | 以读写模式打开 文件必须存在 |
| w+ | 以读写模式打开文件，不存在则创建，存在清空原有内容 |
| a+ | 追加并可读模式，文件不存在则创建，存在则继续进行写操作 |
| rb | 以二进制读模式打开 同r |
| wb | 以二进制写模式打开 同w |
| ab | 以二进制追加模式打开 同a |
| rb+ | 以二进制读写模式打开 同r+ |
| wb+ | 以二进制读写模式打开 同w+ |
| ab+ | 以二进制读写模式打开 同a+ |
856
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
