Python学习日记（六）——内置函数和文件操作（lambda）

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)
  
  print(f.tell())     #获取指针位置
  f.write("意大利")
  print(f.tell())     #获取指针位置
  
  data = f.read()     #写后，第二次读
  print(type(data),data)
  
  f.seek(0)            #调整指针位置,到最前面
  data = f.read()     #第三次读
  print(type(data),data)
  f.close()
  
  输出结果：
      <class 'str'> ciri
      4
      13
      <class 'str'>
      <class 'str'> ciri意大利
  #从此一次获取指针位置的结果可以看出,在进行读的操作后，指针移动到了，读取的数据的后面
  
  #从第二次获取指针位置的结果可以看出，在进行写的操作后，指针移动到了最后面（"ciri"--四个字节，"意大利"--9个字节）
  
  #所以第二次的读操作没有内容　  
  
  #因为在第三次读之前,把指针位置调整到了最前面,所以第三次可以读出文件的所有内容  

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

  #w+
  f = open("ha.log",'w+',encoding="utf-8")
  
  data = f.read()     #读第一次
  print(type(data),data)
  
  print(f.tell())     #获取指针位置
  f.write("意大利")
  print(f.tell())     #获取指针位置
  
  data = f.read()     #写后，第二次读
  print(type(data),data)
  
  f.seek(0)            #调整指针位置,到最前面
  
  data = f.read()     #第三次读
  print(type(data),data)
  f.close()
  
  输出结果:
      <class 'str'>
      0
      9
      <class 'str'>
      <class 'str'> 意大利
  
  #第一次读操作,没有读取到文件内容,说明  文件在执行w+操作的时候就把文件内容删除了

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

  #x+
  f = open("ha2.log",'a+',encoding="utf-8")
  
  data = f.read()     #读第一次
  print(type(data),data)
  
  print(f.tell())     #获取指针位置
  f.write("意大利")
  print(f.tell())     #获取指针位置
  
  data = f.read()     #写后，第二次读
  print(type(data),data)
  
  f.seek(0)            #调整指针位置,到最前面
  
  data = f.read()     #第三次读
  print(type(data),data)
  f.close()
  
  输出结果:
      <class 'str'>
      0
      9
      <class 'str'>
      <class 'str'> 意大利
  
  #因为x+创建了新文件,所以没什么变化

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

  #a+
  f = open("ha.log",'a+',encoding="utf-8")
  
  data = f.read()     #读第一次
  print(type(data),data)
  
  print(f.tell())     #获取指针位置
  f.write("意大利")
  print(f.tell())     #获取指针位置
  
  data = f.read()     #写后，第二次读
  print(type(data),data)
  
  f.seek(0)            #调整指针位置,到最前面
  
  data = f.read()     #第三次读
  print(type(data),data)
  f.close()
  
  输出结果：
      <class 'str'>
      4
      13
      <class 'str'>
      <class 'str'> 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 -- 读取指定字节数据
    f1.read()#不加参数读取所有的内容
    f1.read(1)#以b的形式打开（读一个字节），以字符形式打开（读一个字符）

#readable -- 是否可读
#readline -- 仅读取一行数据
f = open("ha.log",'r+',encoding="utf-8")
for line in f:
    print(line)    #一行一行的读取文件

#seek -- 指定文件中指针位置
#seekable -- 指针是否可操作
#tell -- 获取指针位置

#truncate -- 截断数据，仅保留指定之前数据
    f1.truncate()   #指针在哪就截取前面的几个

#write -- 写内容
#writeable -- 是否可写

三、关闭文件

自动close的操作——with

with open('','r') as f:
    f.read()
    。。。

用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)

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