python内置函数打开创建文件

python内置函数打开创建文件

lambda表达式

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

# 普通条件语句

if 1 == 1:

name = 'prime'

else:

name = 'ciri'

# 三元运算

name = 'prime' if 1 == 1 else 'ciri'

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

#普通函数

# 定义函数(普通方式)

def func(arg):

return arg + 1

# 执行函数

result = func(123)

# lambda表达式

# 定义函数(lambda表达式)

my_lambda = lambda arg : arg + 1

# 执行函数

result = my_lambda(123)

内置函数

函数功能

all() -- 每个元素为真就为真

any() -- 只要有一个真就是真

bin()十进制转二进制

hex()十进制转十六进制

int()所有的通过它转成十进制

oct()十进制转八进制

bool() -- 判断真假

bytes() -- 字符串转换成字节

str() -- 字节转成字符串串

chr() -- 数字转字母

ord() -- 字母转数字

dir() --帮助

help() --详细功能

enumerate() -- 对于一个可迭代的(iterable)，enumerate将其组成一个索引序列，利用它可以同时获得索引和值

eval() -- 执行表达式,返回结果

exec() -- 执行表达式,没有返回结果

filter() -- 过滤,接收两个参数(函数,迭代的东西)

map() -- 让序列里的每一个元素,都做一个加工(例如:让每一个值都+100)

globals() -- 查看所有的全局变量

locals() -- 查看所有的局部变量

id() -- 查看内存地址

input() -- 获取输入

isinstance() -- 对象是不是指定类型

lens() -- 查看长度

max() -- 取最大值

min() -- 取最小值

sum() -- 取和

pow() -- 指数

range() -- 范围

round() -- 四舍五入

sorted() -- 排序

type() -- 查看对象的类型

zip() -- 把两个列表的同一个位置元素,拿出来

open() -- 操作文件

#abs()--绝对值

i = abs(123)

print(i)

i = abs(-123)

print(i)

#all()--循环参数,如果每个元素都为真,那么all的返回值为真

r = all([True,True])

print(r)

#什么是假的?

print(bool(0))#只有0是假的

print(bool(None))#False

print(bool(''))#空字符串是假的

print(bool([]))#空列表是假的

print(bool(()))#空元组是假的

print(bool({}))#空字典也是假的

#any()--循环参数,只要一个元素为真,那么any的返回值为真

#i = any(None,"",[],{},(),1)

#print(i)

# bin()二进制

# oct()八进制

# int()十进制

# hex()十六进制

r = bin(11)

r = oct(11)

r = hex(11)

#bool()--判断真假,把一个对象转换成布尔值

#bytes()--表示字节

#bytearray()--表示字节列表[asd]

#chr(65)#找到这个数字对应的ascii码对应的符号

#ord(a)#找到字符对应的ascii码

#callable()--是否能够被执行

#def f1():

# return 123

f1 = 123 #不能加括号,给了你一个东西后面能加括号表示是可执行的

r = callable(f1)

print(r)

#dir()--看函数提供了哪些功能

#help()--查看函数的详细功能

#divmod--取商和余数

a = 10/3

print(a)

r = divmod(10,3)

print(r)

#输出结果:(3, 1),商和余数

#eval()--可进行字符串形式的数值运算

#exec()--可移执行,字符串形式的表达式

a = "1 + 3"

print(a)

ret = eval("1 + 3")

print(ret)

ret = exec("for i in range(10):print(i)")

print(ret)

#compel--编译代码

#eval--表达式,返回值

#exec--执行py代码

#range--创建范围内指定的数

n = range(10)

print(n)#输出的是一个range类,不创建

for i in n:

print(i) #默认不创建,循环时创建

#filter()--过滤,循环可迭代的对象,获取每一个参数,函数参数

#map()--map(函数,可迭代的对象)

def f1(x):

if x > 22:

return True

else:

return False

ret = filter(f1,[11,22,33,44])

#print(ret)会输出一个filter对象,类似range默认不会在内存中创建,使用时才会创建

for i in ret:

print(i)

#filter接收两个参数,一个是函数,一个是可以迭代的对象

#迭代每一次都执行函数,返回True表示符合条件,符合条件就放到ret里

li = [1,2,3,4,5]

def f1(x):

return x+100

ret = map(f1,[1,2,3,4,5])

print(ret)

for i in ret:

print(i)

#map接收两个参数,一个是函数,一个是可以迭代的对象

#迭代每一次都执行函数,把所有的返回值都放到ret中

#globals()获取所有的全局变量

#locals()获取所有的局部变量

#hash()算哈希值

# max()--取最大值

# min()--取最小值

#pow()--求指数

i = pow(2,100) #2的100次方

print(i)

#round()四舍五入

#zip--在两个列表或元组中,把同一个元素结合起来,形成新的元组

li1 = [11,22,33,44]

li2 = ["a","BB","C","E"]

r = zip(li1,li2)

print(r)

for i in r:

print(i)

#输出结果:

# (11, 'a')

# (22, 'BB')

# (33, 'C')

# (44, 'E')

filte和map函数,功能内部实现

#filter内部实现

def MyFilter(func,seq): #func代表函数,seq代表列表

result = []

for i in seq:

ret = func(i)

if ret:

result.append(i)

return result

def f1(x):

if x > 22:

return True

else:

return False

r = MyFilter(f1,[11,22,33,44])

print(r)

#map的内部实现

def MyMap(fun,arg): #fun代表函数,arg代表列表

result = []

for i in arg:

ret = fun(i)

result.append(ret)

return result

def x(arg):

return arg + 100

r = MyMap(x,[11,22,33,44])

print(r)

函数使用实例——随机验证码

import random

#思路

#生成一个随机数:65-90,导入random模块

#数字转换成字母:chr(数字)

#ASCII：A-Z:65-90

#生成纯字符验证码

temp =""

for i in range(4):

i = random.randrange(65,91)

c = chr(i)

temp += c

print(temp)

#生成数字和字符混合的验证码

temp = ""

for i in range(6):

num = random.randrange(0,4)

if num == 3 or num ==1:#等于3和1的时候生成一个数字,等于0,2生成一个一个字母

rad2 = random.randrange(0,10)

temp += str(rad2)

else:

rad1 = random.randrange(65,91)

c1 = chr(rad1)

temp += c1

print(temp)

python中的排序

li = [1,22,31231,4215,324,12]

print(li)

li.sort()

print(li)

new_li = sorted(li) #sorted就是调用list里面的sort()

print(new_li)

char = ["z","123","1","23","45","asb","abd","c","我","爱","你"]

new_chat = sorted(char)

print(new_chat)

#for i in new_chat: #查看字节

# print(bytes(i,encoding='utf-8'))

#输出结果：['1', '123', '23', '45', 'abd', 'asb', 'c', 'z', '你', '我', '爱']

#字符串和数字不能混在一起排序，在一起会报错

#数字排序就是按照大小来

# 字符串排序--数字优先,然后是字母,最后是中文

#排列顺序按照元素一个一个的比较

注：进制之间的转换

#进制之间的转换

int(10)#加一个参数就是把十进制的数转换成十进制的数

i = int('0b11',base=2) #二进制是0b，把二进制转成十进制，0b可省略

print(i)

i = int('11',base=8) #八进制是0o，把8进制转成十进制，0o可省略

print(i)

i = int('0x11',base=16) #十六进制是0h，把16进制转成十进制，0x可省略

print(i)

文件处理

Open函数，该函数用于文件处理

操作文件时，一般需要经历如下下步骤

打开文件

操作文件

关闭文件

一、打开文件

文件句柄 = open('文件路径', '模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r，只读模式【默认】

w，只写模式【不可读；不存在则创建；存在则清空内容】

x，只写模式【不可读；不存在则创建，存在则报错】

a，追加模式【不可读；不存在则创建；存在则只追加内容】

现有一个文件

文件名：ha.log     文件内容：ciri

#r--只读模式

f = open("ha.log","r")

data = f.read()

#f.write()会报错

f.close()

print(type(data))

print(data)

#w--只写模式

f = open("ha.log","w")

f.write("456") #把文件内容改成456

f.close()

#x--只写模式

f = open("ha2.log","x") #创新一个新文件ha2.log

f.write("456")

f.close()

#a--追加模式

f = open("ha.log","a")

f.write("456") #在文件内容最后面添加456

f.close()

"+" 表示可以同时读写某个文件

现有一个文件

文件一：文件名：ha.log     文件内容：ciri

r+，读写【可读，可写】

#r+

f = open("ha.log",'r+',encoding="utf-8")

data = f.read() #读第一次

print(type(data),data)

ll()) #获取指针位置

f.write("意大利")

ll()) #获取指针位置

data = f.read() #写后，第二次读

print(type(data),data)

f.seek(0) #调整指针位置,到最前面

data = f.read() #第三次读

print(type(data),data)

f.close()

输出结果：

ciri

4

13

ciri意大利

#从此一次获取指针位置的结果可以看出,在进行读的操作后，指针移动到了，读取的数据的后面

#从第二次获取指针位置的结果可以看出，在进行写的操作后，指针移动到了最后面("ciri"--四个字节，"意大利"--9个字节)

#所以第二次的读操作没有内容

#因为在第三次读之前,把指针位置调整到了最前面,所以第三次可以读出文件的所有内容

w+，写读【可读，可写】

#w+

f = open("ha.log",'w+',encoding="utf-8")

data = f.read() #读第一次

print(type(data),data)

ll()) #获取指针位置

f.write("意大利")

ll()) #获取指针位置

data = f.read() #写后，第二次读

print(type(data),data)

f.seek(0) #调整指针位置,到最前面

data = f.read() #第三次读

print(type(data),data)

f.close()

输出结果:

0

9

意大利

#第一次读操作,没有读取到文件内容,说明 文件在执行w+操作的时候就把文件内容删除了

x+，写读【可读，可写】

#x+

f = open("ha2.log",'a+',encoding="utf-8")

data = f.read() #读第一次

print(type(data),data)

ll()) #获取指针位置

f.write("意大利")

ll()) #获取指针位置

data = f.read() #写后，第二次读

print(type(data),data)

f.seek(0) #调整指针位置,到最前面

data = f.read() #第三次读

print(type(data),data)

f.close()

输出结果:

0

9

意大利

#因为x+创建了新文件,所以没什么变化

a+，写读【可读，可写】

#a+

f = open("ha.log",'a+',encoding="utf-8")

data = f.read() #读第一次

print(type(data),data)

ll()) #获取指针位置

f.write("意大利")

ll()) #获取指针位置

data = f.read() #写后，第二次读

print(type(data),data)

f.seek(0) #调整指针位置,到最前面

data = f.read() #第三次读

print(type(data),data)

f.close()

输出结果：

4

13

ciri意大利

#因为第一次没有读到内容，说明打开文件时，指针调整到了最后面(ciri是四个字节)

总结

# r+ -- 不进行写操作,不删除文件的内容

# W+ -- 在打开文件的时候,就清楚了文件内容

# a+ -- 在打开时指针调整到了最后面

# x+ -- 创建新文件

"b"表示以字节的方式操作

rb 或 r+b

wb 或 w+b

xb 或 x+b

ab 或 a+b

现有一个文件

文件名：ha.log     文件内容：ciri

#rb--只读

f = open("ha.log","rb")

data = f.read()

f.close()

print(data)

print(type(data))

str_data = str(data,encoding="utf-8") #把字节转换成字符串

print(str_data)

#wb--只写

f = open("ha.log","wb")

f.write(bytes("中国",encoding="utf-8")) #把字节转换成字符串,然后写入

f.close()

#xb--只写

f = open("ha2.log","wb")

f.write(bytes("中国",encoding="utf-8")) #把字节转换成字符串,然后写入

f.close()

#ab--追加

f = open("ha1.log","ab")

f.write(bytes("中国",encoding="utf-8")) #把字节转换成字符串,然后写入

f.close()

注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型

二、操作文件

#close -- 关闭文件

#fileno -- 文件描述符，I/O操作时会用

#flush -- 刷新文件内部缓冲区，刷到硬盘

f1 = open("ha.log",'r+',encoding="utf-8")

f1.write("I don't bite")

i = input(">>>")

#此时程序没有执行完，文件的内容不会变。当进程中止时，才会从内存刷到硬盘里

#此时是读取不到新的文件内容的

f1 = open("ha.log",'r+',encoding="utf-8")

f1.write("I don't bite")

f1.flush() #主动把内存里的东西刷到硬盘上，别的程序会读取到新的文件内容

i = input(">>>")

#read -- 读取指定字节数据

#readable -- 是否可读

#readline -- 仅读取一行数据

f = open("ha.log",'r+',encoding="utf-8")

for line in f:

print(line) #一行一行的读取文件

#seek -- 指定文件中指针位置

#seekable -- 指针是否可操作

#tell -- 获取指针位置

#truncate -- 截断数据，仅保留指定之前数据

#write -- 写内容

#writeable -- 是否可写

三、关闭文件

自动close的操作——with

with open('','r') as f:

。。。

用with同时打开两个文件

with open('log1','r') as obj1 ,open('log2','r') as obj2:

#例：

with open('ha.log','r') as f1 ,open('ha12','r') as f2:

with open('源文件','r') as obj1, open('新文件','w') as obj2:

for line in '源文件':

'新文件'.write(line)

#一行一行的读取 源文件 ,然后复制到 新文件 里