python day5 lambda,内置函数，文件操作,冒泡排序以及装饰器

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

python day 5

2019/10/08

学习资料来自老男孩教育

1. 匿名函数lambda

函数名就是变量，使用lambda表达来创建一些简单功能的函数。

lambda定义简单函数时，比用def定义要简洁，会用在map,reduce,filter等函数中。

return x+y
ret = f1(1,2)
print(ret)`lambda 参数: 函数执行体`，与上面def定义的函数f1功能是一样的。f2 = lambda x,y : x+y
ret2 = f2(1,2)
print(ret2)


user = input('请输入用户名:>>>')
passwd = input('请输入密码:>>>')
def login(username,passwd):
'''
用于用户名与密码验证
:param username: 用户名
:param passwd: 密码
:return: True，用户名验证成功；False，用户验证失败。
'''
with open('db','r',encoding='utf-8') as f1:
for line in f1:
#strip默认无参数时，移除空格，换行符，有参数时，移除两侧指定的值
line = line.strip()
line_list = line.split('$')
#print(line_list)
if username == line_list[0] and passwd== line_list[1]:
return True
return False
is_login = login(user,passwd)
if is_login:
print('登录成功')


2. python的内置函数

0，None，以及空值都是假的。

abs(),返回绝对值。

all()，遍历可迭代对象的每一个元素，如果全部为真，则返回真。

any(),遍历可迭代对象的每一个元素，只要有一个为真，则返回真。

ascii()，去参数对应的类中找__rep__，并返回__rep__的返回值。

bin() ,将十进制转换成二进制。

oct(),将十进制转换成八进制。

int(),将十进制转换成十进制。

hex()，将十进制转换成十六进制。

boll(),将一个对象转换成boll值。

bytes('xxxx',encoding='utf-8') #将字符串转换成以utf-8编码的字节，一个字节是8位bit。

chr(), 将十进制数字转换成为ascii码表对应的字符。(65,90)是ASCII表中字母数字区间。

ord()，将ascii码表中的字符转换成对应的十进制数字。

callable(),判断一个对象是否可执行，即该对象是否是一个函数名。

compile()，将字符串编译成可执行的函数，当然，该字符串是函数语句。

dict(map)，创建字典。

list(iterable),创建列表。

dir()，输出对象的所有方法与属性。

divmod(x,y),返回元素为x除以y的商与余数的元组。

enumerate()，给可迭代对象增加序列号。

ret = eval('a+60',{'a':9}),可以执行一个字符串形式的表达式,简单的加减乘除运算。

exec('for i in range(5):print(i)')，执行字符串形式的代码,没有返回值。

filter(func,iterable), 筛选：可迭代对象的每一个元素都作为实参传递到函数中去，函数返回值为真的元素留下，为假的元素不留，并返回一个迭代器。

iter1 = filter(lambda x: x>22, [11,22,33,44])
for i in iter1:
print(i)


map(func,iterable)，映射：可迭代对象的每一个元素都作为实参传递到函数中去，函数返回值作为新的迭代器元素返回,最终返回的是一个迭代器。

format()，字符串格式化的方法。

s1 = '{0} is working hard , so is {1}'.format('lanxing', 'his wife')

s2 = '{name} is working hard, so is { name2} '.format(name='lanxing',name2='his wife')

globals()，获取当前程序的所有全局变量。

locals(),获取当前程序的所有局部变量。

hash()，计算哈希值，

isinstance(1,int)，判断第一个参数(对象)是否是第二个参数(类)的实例对象，是就返回真。

issubclass(int,object)，判断第一个参数(类),是否是第二个参数(类)的子类，是就返回真。

iter(iterable)，将可迭代对象转换为迭代器。

len()，计算序列字符的长度。

max()，得出序列中的最大值，

min(),得出序列中的最小值

next(),输出迭代器的下一个值。

open()，打开文件，需要重点掌握。

pow(2,4)，计算2的4次方

reversed(iterable),返回一个逆序排列的迭代器。

round(),四舍五入。

sorted(iterable,/,*,key=None, reverse = False)，排序，默认返回一个升序排列的新列表，如果reverse为True，则降序排列。key接收一个排序的函数。数字完全按照大小进行排序，字符串分三类顺序：数字字符串，字母字符串，中文字符串，前两类按照ASCII码排序，后一类按照Unicode码排序。

str()，将对象转换为字符串

sum()，将序列求和

super(),返回父类。

tuple(),将可迭代对象转换为元组。

type()，返回对象所属的类。

vars()，返回程序有多少个变量。

zip(iterable1,iterable2)，将两个可迭代对象的元素一一对应成为元组，元组作为元素并返回一个迭代器。

r = import(random) ，将引入的random模块赋予变量r。

3. python文件操作

使用内置函数open来操作文件。操作文件有三步：打开文件，操作文件，关闭文件。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

3.1. file如果只写文件名，比如'file1.txt'，则默认是当前路径，如果当前路径没有这个名字的文件，则报错，如果是其他目录的文件，则需要加上文件路径。

3.2. mode有4种模式：'r'表示只读模式，'w'代表只写入模式(如果文件存在，则覆盖掉，不存在则创建)，'x'表示新创建一个文件，并进入写入模式(如果文件存在，则报错)，'a'表示追加写入模式，所有写入内容都在文件末尾。打开file有三种模式，'b'代表二进制模式，'t'代表文本模式，'+'表示读写模式。默认文件打开是'rt'模式。

3.3. encoding如果没传入，则默认是平台当前的编码方式。只在文本模式中需要编码。二进制模式不需要encoding。

3.4. buttering,指缓冲，默认是-1，代表

读时是按照指针的顺序，从前往后读，写时，都是写到最后,指针也到了最后。

help(open)
f1 = open('hello.txt', 'w', encoding='utf-8')
f1.write('hello,lanxing') #将字符串写入文件。
f1.close() #关闭文件f2 = open('hello.txt', 'rb')
data = f2.read() #read表示读取多少个字符，如果不加参数，则默认读取全部内容。
print(data)
data2 = str(data,encoding='utf-8')
print(data2)
f2.close()f3 = open('test1.txt', 'wb')
# 以二进制模式进行写入操作，write的参数必须是字节形式，所以用bytes将字符串转换成字节。
f3.write(bytes('中国人', encoding='utf-8'))
f3.close()f4 = open('test1.txt', 'rb+')
data4 = f4.read(3) #只读取3个字节
print(data4)
str_data4 = str(data4,encoding='utf-8')
print(str_data4)
f4.close()# 一,以下是读写模式，先读再写。
f5 = open('test1.txt', 'r+', encoding='utf-8')
# tell告诉当前指针(或叫光标)在哪个位置，一个字节就是一个指针位
print(f5.tell()) # tell
data5 = f5.read(1) # 读取1个字符，utf-8编码中，一个中文字符是3个字节。
print(f5.tell()) # 所以现在是3个指针位
print(data5)
data6 = f5.read(1) # 再读1个字符位。
print(data6)
print(f5.tell()) # 现在指针在第6个字节位处了
f5.seek(0) # 将指针重新调整到起始位置。
f5.write('日本人') # 写入操作，会在末尾追加，指针调整到最后。
f5.close()# 二，以下是写读模式，先写再读，即先清空再读。写入的同时，指针就在最后了。
f6 = open('test1.txt', 'w+', encoding='utf-8')
data6 = f6.read()
print(data6) #空值，因为先写，已经清空整个文件了。
f6.write('中国人')
print(f6.tell()) #是9，因为3个汉字是9个字节。
data7 = f6.read() #还是空值，因为现在指针在9，9后面没有数据了。
f6.seek(0) #将指针调到到开始。
data8 = f6.read()
print(data8)
f6.close()# 三，a+模式，打开时，指针已经在最后了。


打开文件一定要记得关闭文件，最好使用with来打开文件，with打开文件会自动关闭文件。

with open('test1.txt','w+',encoding='utf-8') as f:
f.write('中国人')
with open('test1.txt','r+',encoding='utf-8') as f1, open('test2.txt','w+',encoding='utf-8') as f2:
#with可以同时打开多个文件。
for line in f1:
#将f1的每一行都写入到f2文件中去。
f2.write(line)

文件的基本操作还有：

flush(), 即时刷新，可以在文件未关闭之前看到文件更新内容，不接参数。

readline()，读取当前指针处的一行内容。

readlines(n)，读取当前指针处的n个字符，如果n不写，则默认全读完，如果n小于当前行的字符长度，则读取当前行内容，包括换行符\n，如果n大于当前行的字符长度，则一直到第从当前指针处的第n个字符所在的行，每一行的内容包括换行符作为一个列表的元素，最终返回该列表。

close(),关闭文件

seek(n),调整指针位置

tell()，返回当前指针位置。

truncate(),截取当前指针处之前的字节内容。文件关闭时，就只有截取的内容了。

read(n),读取从当前指针处的多少个字符。返回的是字符串。

write()，写入字符串或字节。

def del_user(username):
'''
delete the specified user and the password referenced.
:param username: username
:return: True
'''
with open('db.txt','r',encoding='utf-8') as f1,open('db2.txt','w',encoding='utf-8') as f2 :
for line in f1:
if username not in line:
f2.write(line)
with open('db.txt', 'w', encoding='utf-8') as f1, open('db2.txt', 'r', encoding='utf-8') as f2:
for line in f2:
f1.write(line)
return Truedef ch_passwd(username):
'''
change the password for the user specified.
:param username: username
:param password: password
:return: True
'''
with open('db.txt','r',encoding='utf-8') as f1,open('db2.txt','w',encoding='utf-8') as f2 :
for line in f1:
if username in line:
password = input('请输入修改的密码:>>>')
line= line.strip()
line_list = line.split('$')
line_list[1] = password
line = '%s$%s\n'%(line_list[0],line_list[1])
f2.write(line)
else:
f2.write(line)
with open('db.txt', 'w', encoding='utf-8') as f1, open('db2.txt', 'r', encoding='utf-8') as f2:
for line in f2:
f1.write(line) return Truedef register(username,passwd):
'''
用于注册新用户
:param username: user's name
:param passwd: user's password
:return: True when registerd.
'''
with open('db.txt','a+',encoding='utf-8') as f1:
f1.write('\n{0}${1}'.format(username,passwd))
return Truedef user_exist(username):
'''
check if user exists in the file 'DB'
:param username: username
:return: True if username exists, False if not exists.
'''
with open('db.txt','r',encoding='utf-8') as f1:
for line in f1:
line = line.strip()
line_list = line.split('$')
if username == line_list[0]:
return True
return Falsedef login(username,passwd):
'''
用于用户名与密码验证
:param username: 用户名
:param passwd: 密码
:return: True，用户名验证成功；False，用户验证失败。
'''
with open('db.txt','r',encoding='utf-8') as f1:
for line in f1:
#strip默认无参数时，移除空格，换行符，有参数时，移除两侧指定的值
line = line.strip()
line_list = line.split('$')
#print(line_list)
if username == line_list[0] and passwd== line_list[1]:
return True
return Falsedef main():
user_choice = input('输入1注册，输入2登录,输入3注销用户，输入4修改密码:>>>')
user = input('请输入用户名:>>>')
passwd = input('请输入密码:>>>')
if user_choice =='1':
if user_exist(user):
print('该用户已存在，请直接登录')
else:
register(user,passwd)
print('注册成功')
elif user_choice=='2':
is_login = login(user, passwd)
if is_login:
print('登录成功')
else:
print('用户名与密码不符，请重新输入')
if user_choice == '3':
#先判断是否登录成功，登录成功之后方可注销用户
if login(user,passwd):
del_user(user)
elif user_choice == '4':
# 先判断是否登录成功，登录成功之后方可修改密码
if login(user, passwd):
ch_passwd(user)if __name__=='__main__':
main()


4. 递归函数

def f1():
return 'f1'def f2(args):
a = args()
return a


f1,f2也是变量，其是函数对象地址的引用，所以函数名也可以作为实参传入另外一个函数中。

f2(f1) #f1作为实参传入形参args。

数学意义上的阶乘：5！ = 5* 4！, 4!= 43!, 3!= 32!, 2!= 2*1!, 1!=1

可以使用递归函数解决，递归函数指在函数内部调用自己的函数。

def factoria(n):
if n==1:
return 1
return n*factoria(n-1)


5. 冒泡排序

li = [33,2,10,1]
#使用冒泡排序按照由小到大的顺序进行排列
for i in range(len(li)-1):
if li[i]>=li[i+1]:
temp = li[i]
li[i]=li[i+1]
li[i+1]=temp
for i in range(len(li)-2):
if li[i] >= li[i + 1]:
temp = li[i]
li[i] = li[i + 1]
li[i + 1] = temp
for i in range(len(li)-3):
if li[i] >= li[i + 1]:
temp = li[i]
li[i] = li[i + 1]
li[i + 1] = temp
print(li)
#总共循环了3次，可以优化下，实际自己做的时候，就写到上面这一步。
#可以简化成下面
def maopao(li):
'''
按照冒泡排序算法对列表进行处理
:param list1: a list
:return: list sorted in ascending
'''
for j in range(1, len(li)): # 1,2,3
for i in range(len(li) - j):
if li[i] > li[i+ 1]:
temp = li[i]
li[i] = li[i + 1]
li[i + 1] = temp
return li
print(maopao(li))

6. 装饰器

开放封闭原则：对于函数内部是封闭的，即不可修改；函数外部是开放的，可以修改。

装饰器用来装饰函数，使得函数在执行之前或执行之后进行某个功能。

def outter(func):
def inner():
print('inner')
#原hello函数
ret = func()
print('inner2')
return ret
return inner
# 解释器看到@符号会自动做两件事
# 1,执行 outter函数，将下面的函数名hello作为实参传递给func
# 2，再将outter函数的返回值重新赋值给hello。
# 就是执行了hello = outter(hello)=inner
@outter
def hello():
print('hello')hello()