标签：打开 提醒 不可变 rom one cal 导致 聚合 line
格式：f = open("文件路径"，mode = "r",encoding = "utf-8")
f : 代表文件句柄
文件路径：
绝对路径：从根文件夹下查找
相对路径： 相对于某个文件进行查找
f = open("D:\Python_s25\day08\小姐姐电话号",mode="r",encoding="utf-8")# print(f.read()) # 全部读取
(1)print(f.read(3)) # 按照字符读取
(2)print(f.readline()) # 默认尾部有一个\n# (3)print(f.readline().strip()) # 读取一行# (4)print(f.readline().strip()) # 将\n去除# (5)print(f.readlines()) #一行一行读取,全部存储在列表中读字节：rb
读取图像，视频时使用的的操作
字节操作，不能执行encoding
f = open("timg.jpg",mode="rb")# print(f.read()) # 全部读取
(1) print(f.read(3)) # 按照字节读取
(2)(f.readline()) # 按照行进行读取
(3)print(f.readlines())r 和 rb 的区别：
r 需要指定encoding，rb 不需要
r模式中的read（数字）代表按照字符读取
rb模式中的read（数字）代表按照字节读取
read 和 readlines 如果文件较大时，会出现内存溢出
面试题 ****
当文件较大时，会出现内存溢出现象
解决办法：
使用for循环进行读取? 只写，写字符：w
特性：写操作--清空写
当文件模式为w 和 a 模式时，有文件就使用当前文件，没有文件那就创建一个新的文件
写入的内容必须是字符串
ff = open("a1",mode="w",encoding="utf-8")# ff.write("[1,2,3,4]\n") # 写的内容必须是字符串
ff.write('1111\n') # 写的内容必须是字符串 ff.write('2222\n') # 写的内容必须是字符串只写，写字节：wb
清空写，写的是字节
ff = open("a1",mode="w",encoding="utf-8")
ff.write("[1,2,3,4]\n") # 写的内容必须是字符串# ff.write('1111\n') # 写的内容必须是字符串# ff.write('2222\n') # 写的内容必须是字符串追加操作
追加写，写文本（a）
f = open("b1",mode="a",encoding="utf-8")
f.write("你好啊\n")
f.write("我好啊\n")
f.write("他好啊\n")
f.write("大家好啊\n")追加写，写字节（ab）
其他操作：
读写：r+
# 坑 -- 使用方式是错误
# f = open("b1",mode="r+",encoding="utf-8")
# f.write("今天是周一")
# print(f.read())
# 正确的操作:
# f = open("b1",mode="r+",encoding="utf-8")
# print(f.read())
# f.write("今天是周一")写读：w+
# w+ 写读 (有点用)
# f = open("b1",mode="w+",encoding="utf-8")
# f.write("今天是周一")
# f.seek(0) # 移动光标
# print(f.read())追加读：a +
# a+ 追加读 # 坑
f = open("b1",mode="a+",encoding="utf-8")
f.write("今天是周一")
f.seek(0) # 移动光标
f.write("啊啊啊啊")
print(f.read())其他操作：
# seek() 移动光标
# f.seek(0,0) # 移动光标到文件的头部
# f.seek(0,1) # 移动光标到当前位置
# f.seek(0,2) # 移动光标到文件末尾
# f.seek(6) # 光标是按照字节移动# 查看光标:
# tell 查光标
# f = open("c1","r",encoding="gbk")
# print(f.read(3))
# print(f.tell()) # 按照字节进行计算修改文件：
import os 操作系统交互的接口
# f = open('a2',"r",encoding="utf-8")
# f1 = open("a1","w",encoding="utf-8")
# for i in f:
# i = i.replace("日","天")
# f1.write(i)
#
# f.close()
# f1.close()
# os.remove("a2") # 删除不能找回
# os.rename("a1","a2") 考点:
# import os # 操作系统交互的接口
# f = open('a2',"r",encoding="utf-8")
# f1 = open("a1","w",encoding="utf-8")
# i = f1.read().replace("天","日") # 将文件中全部内容读取 容易导致内存溢出
# f1.write(i)
#
# f.close()
# f1.close()
# os.rename("a2","a3")
# os.rename("a1","a2")with open：
自动关闭文件
同一时间操作多个文件
# with open("a3","r",encoding="utf-8")as f,# open('a2',"r",encoding="utf-8")as f1:
# print(f.read())
# print(f1.read())? 持久化，永久储存
lst = [1,2,3,4,5] #列表，元祖，字典，字符串都可以求长度
n = 0
for i in list:
n += 1
print(list)def ():
函数体
# def-python 关键字，len-函数名--变量名一样，（）必须要写的，格式规定，：代表语句结束def yue():
print("掏出手机")
print("打开微信")
print("聊天")
print("约会")
yue()#面向函数编程：
def yue():
print("掏出手机")
print("打开微信")
print("聊天")
print("约会")
yue()
print("上班")
yue()
print("吃饭")def yue():
print("掏出手机")
print("打开微信")
print("聊天")
print("约会")
print("......")
return"女朋友" #函数中遇到return，此函数结束，不再继续执行
girl = yue()
print(girl)参数分类：
位置参数：一 一对应
默认参数：参数定义时括号中写好的就是默认参数
关键字参数（默认参数）：按照名字进行传参
位置参数必须放在默认参数之前
混合·参数：未知参数和关键字参数一起传参
def yue(a,app1="微信"):
print("掏出手机")
print(f"打开{a}{app1}")
print("聊天")
print("约会")
yue("探探")形参：函数定义阶段括号中的参数叫做形参
实参：函数调用阶段括号中的参数叫做实参
传参：将实参传递给形参的过程叫传参
#例：
def yue(app): #形参
print("掏出手机")
print("打开"+app)
print("聊天")
print("约会")
yue("app名字")# 实参 输出结果是yue（）里面的内容，一个萝卜一个坑，括号里面的内容必须和前面def yue（）数量一一对应
传参：将实参传递给形参的过程叫传参def func(a,b):
return a if a > b else b
print(func(6,9))def eat(*args): #函数的定义阶段 *聚合（打包）
print(args) #元祖
print(*args)#函数体中的*，打散（解包）def eat(a,b,*c): #a，b为位置参数>带*号的为动态位置参数
print(a)
print(b)
print(c) #元祖、
eat("面条"，"米饭","馒头","大饼")
#输出结果：面条，米饭，('馒头', '大饼')确定思想：位置参数永远大于默认参数，动态参数也是一样
# def eat(a,b,*args,d=2,**c): # 位置参数 > 动态位置参数 > 默认参数 > **c是动态默认参数
# print(a)
# print(b)
# print(d)
# print(args) # tuple
# print(c) # dict
# eat("面条","米饭","大烧饼","大煎饼",a1=1,b1=2)
输出结果：
# 输出结果：
# 面条
# 米饭
# 2
# ('大烧饼', '大煎饼')
# {'a1': 1, 'b1': 2}XRO86F52%7BC.png)
# def eat(*args,**kwargs): # (万能传参)
# print(args) # tulpe
# print(kwargs) #dic
# lst = [1,23,4,6,7]
# dic = {"key1":1,"key2":3}
# eat(*lst,**dic)
输出结果：
(1, 23, 4, 6, 7)
{'key1': 1, 'key2': 3}XL3L.png)
*args：大家伙都用的名字，可以进行修改但是不建议
**kwargs(聚合关键字参数)大家伙都用的名字，可以进行修改但是不建议
位置参数 > 动态位置参数 > 默认参数 > 动态默认参数
函数体中的 * ：
第一个代表：聚合
第二个代表：打散
def eat(a,b,*args):
print(a) #面条
print(b) #米饭
print(*c) #元祖，(馒头，大饼)
eat("面条","米饭","馒头","大饼")形参：
实参和函数体：
在函数的定义阶段*和**都是聚合
函数体中的 * 就是打散，* args将元祖中的元素进行打散，**kwargs将字典的键获取
def eat(a,b,*args,**kwargs):
print(a) #面条
print(b) #米饭
print(*args) #元祖，(馒头，大饼)
print(**kwargs) #字典{'a1':1,'a2':4}
eat("面条","米饭","馒头","大饼",a1=1,a2 = 4)
形参：
? 位置参数：
? 动态位置参数：先执行位置参数，未知参数接收完后额外的参数动态位置参数进行接收，获取到的是一个元祖
? 默认参数
? 动态关键字参数：先执行默认参数，默认参数接收后额外的默认参数动态默认参数进行接收，获取的是一个字典
实参和函数体：
? *打散
? **实参时能够使用
查看函数名注释：._doc_
# def a(a:int,b:int):
# """
# “声明注释内容，例如此函数的意思就是进行加运算”
# :param a: int
# :param b: int
# :return: int
# """
# return a + b查看函数的名字：._name_
内置空间：python解释器自带的一块空间
全局空间：py文件中顶格写的就是全局空间
局部空间：函数体中就是局部空间
加载顺序：
内置空间
全局空间
局部空间
# def func():
# a = 1
# print(a)
# func()
取值顺序：
局部空间
全局空间
内置空间
a = 10
def func()
print(a)
func()
作用域：
? 不管在什么位置，只要是函数名（）就是在调用一个函数。
# 混合嵌套:
# def f1():
# print(11)
#
# def f2():
# print(22)
# f1()
#
# def f3():
# print(33)
# f1()
#
# def run():
# f3()
# f2()
# f1()
# run()
例2：
# def func(a):
# print(a)
# return f1(foo(a))
#
# def foo(b):
# print(b)
# return b + 5
#
# def f1(args):
# return args + 10
#
# print(func(5))
输出结果：5，5，20
# def foo(a):
# a = 10
# def f1(b):
# c = b
# def foo(c):
# print(c)
# print(foo.__doc__)
# foo(c)
# print(b)
# f1(a)
# print(a)
# foo(25)
输出结果：10，10，10
global，只修改全局
nonlocal：修改局部，修改离他最近的一层，上一层没有继续向上层查找，只限局部
# a = 10
# def func():
# global a
# a = a - 6
# print(a)
# fun ()
# a = 100
# def func():
# b = 10
# def foo():
# b = a
# def f1():
# nonlocal b
# b = b + 5
# print(b) # 105
# f1()
# print(b) # 105
# foo()
# print(b) # 10
# func()
# print(a) # 100
函数名的第一类对象（概述）：
使用方式：
函数名可以当做值赋值给变量
def func():
print(1)
print (func) #查看函数的内存地址
a = func
print (a) #
函数名可以当做容器中的元素
dic = {"1":login,"2":register,"3":index}
msg = """
1 登录
2 注册
3 主页
"""
choose = input(msg) # 1
if choose.isdecimal():
if dic.get(choose):
dic[choose]()
else:
print("请正确输入!")
函数名可以当做函数的参数
def fuc(a):
a()
print(111)
def foo():
print(222)
def f1()
print(333)
fun(f1)
foo()函数名可以当函数的返回值
def func():
def foo():
print(111)
return foo
a = func()
a()
func()() #foo()
输出结果：111
111进阶题：
def foo(a):
def func(a):
def f1(a):
print(a)
return "aelx"
return f1(a)
return func(a)
print(foo(5))
输出结果： 5 ，alex def func(a):
a()
def foo(b):
return b()
def f1(c):
def a():
def f3():
print(3333)
return [f3,a,f1]
print(11)
return f3()
return c(a())
def aa(b):
print(111)
return b
print(f1(aa))
输出结果：
11
3333
111
[<function f1.<locals>.a.<locals>.f3 at 0x00000187D0649C80>, <function f1.<locals>.a at 0x00000187D0649BF8>, <function f1 at 0x00000187D0649AE8>]def f1(c):
def a():
def f3():
print(3333)
return [f3,a,f1]
print(11)
return f3()
ret = a()
return c(ret)
def aa(b):
print(111)
return b
print(f1(aa))? f"{变量名}"
? F"{变量名}"
? f"""{变量名}"""
print(F"姓名:{input('name:')} 年龄:{input('age:')}")def foo():
print("is foo")
lst = [1,2,3,4]
dic = {"key1":23,"key2":56}
print(f"""{dic['key1']}""")
print(f"{3+5}")
print(f"{3 if 3>2 else 2}")
print(f"""{':'}""")
msg = f"""{{{{'alex'}}}}""" #必须是偶数
print(msg)
name = "alex"
print(f"{name.upper()}")
print(f"{':'}")
可迭代对象：
list，tuple，str，set，dict取值方式只能直接看、
只要具有__ iter __()方法就是一个可迭代对象
lst = [1,23,4,5]
for i in lst:
print(i)
lst = [1,2,3,4]
lst.__iter__()
dict.__iter__()
迭代器：工具
具有__ iter __ () 和 __ next __ () 两个方法才是迭代器
lst = [1,2,3,4,5]
l = lst.__iter__() # 将可迭代对象转换成迭代器
l.__iter__() # 迭代器指定__iter__()还是原来的迭代器
print(l.__next__()) # 1
print(l.__next__()) # 2
for循环的本质（重点）：
while True:
try: #异常处理机制
print(l.__next__())
except StopIteration: #接收到异常提醒就终止
break
lst = []
for i in range(10000):
lst.append(i)
l = lst.__iter__()
for i in range(16):
print(l.__next__())
print(''.center(50,"*"))
for i in range(16):
print(l.__next__())
print(''.center(50,"*"))
for i in range(16):
print(l.__next__())
优点：
缺点：
空间换时间：容器存储大量的数据，取值快，占用空间大
时间换空间：迭代器就是一个节省了空间，但是取值慢
可迭代对象：具有 iter() 方法的就是一个可迭代对象
迭代器：具有 iter（）和next（）方法就是一个迭代器
python2和python3中的区别：
def func ():
print("这是一个函数")
return“函数”
func()def func():
print("这是一个生成器")
yield"生成器"
#func() 生成一个生成器
print(func().__next__) #启动生成器
输出结果：获取到的是一个生成器的.png)
# 获取到的是一个生成器的内存地址
# <generator object func at 0x00000087C2A10CA8># def func():
# msg = input("请输入内容")
# yield msg
# print("这是第二次启动")
# yield "生成器2"
# yield "生成器3"
# yield "生成器4"
#
# g = func()
# print(next(g))
# print(next(g))
# print(next(g))
# print(next(g))
# 执行结果：
# 请输入内容>>>>你好
# 你好
# 这是第二次启动
# 生成器2
# 生成器3
# 生成器4一个yield 必须对应一个next
# def func():
# lst =[]
# for i in range(100000):
# lst.append(i)
# return lst
# print(func())
# 输出结果：[0~100000]用途：节省空间，例题：吃包子问题
使用场景：
可迭代对象：（python 3 ）
迭代器：
生成器：
yield 和 return 区别：
区别：通过send区别什么是迭代器，什么是生成器
迭代器的地址
生成器的地址
# 数据类型 (pyhton3: range() | python2 :xrange()) 都是可迭代对象 __iter__()
# 文件句柄是迭代器 __iter__() __next__()没有send方法就是一个迭代器，具有send方法就是一个生成器
# def func():
# lst = [1,2,3,45,6]
# lst1 = ["alex","wusir","taibi","baoyuan"]
# yield from lst
# yield from lst1
# g = func()
# print(g)
# 输出结果：<generator object func at 0x0000010DA038CF68>yield from将可迭代对象逐个返回
yield 将可迭代对象一次性返回
tu = （i for i in range（10）if i > 5）
for i in tu :
print(i)eval：执行字符串类型的代码
exac：执行字符串社类型的代码
eval与exac 禁止使用
hash（）作用就是区分可变数据类型与不可变数据类型
# print(hash("123"))
# print(hash(12))
# print(hash(-1))
# print(hash(-10))
# print(hash((2,1)))
# dic = {[1,2,3]:2}
# print(hash([1,2,3]))
help（）：查看帮助信息
callable（）：查看对象是否可以调用，
# def func():
# print(1)
# lst = [1,23,4,]
# print(callable(lst)) # 查看对象是否可调用
int（）：将字符串或数字转换成整型
float（）：转换成浮点数
complex（）：复数
bin（）：十进制转二进制
oct（）：十进制转八进制
hex（）：十进制转十六进制
divmod（）：计算除数与被除数结果，包含一个商和余数的元祖
round（）：保留浮点数的小数位数，可以设定保留位数，默认保留整数
pow（）：求x ** y次幂（三个参数的时候为x ** y的结果对第三个参数取余）
bytes（）：用于不同编码之间的转换，建议使用encode
ord（）：通过元素获取当前表位编码位置
chr（）：通过表位序号查找对应的元素
repr（）：查看数据的原生态（给程序员使用的）
all（）：判断容器汇总的元素是否都为真，返回true
any（）：判断容器中的元素有一个为真，就是True
标签：打开 提醒 不可变 rom one cal 导致 聚合 line
原文地址：https://www.cnblogs.com/heyulong1214/p/11396604.html
