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

python day 5

2019/10/08

学习资料来自老男孩教育

目录

• python day 5
  • 1. 匿名函数lambda
  • 2. python的内置函数
  • 3. python文件操作
  • 4. 递归函数
  • 5. 冒泡排序
  • 6. 装饰器

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