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个字符所在的行，每一行的内容包括换行符作为一个列表的元素，最终返回该列表。
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 True
def 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
'%(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 True
def 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('
{0}${1}'.format(username,passwd))
return True
def 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 False
def 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 False
def 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()