经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Python » 查看文章
python day5 lambda,内置函数，文件操作,冒泡排序以及装饰器
来源：cnblogs　　作者：bluestarpin　　时间：2019/10/9 8:56:12　　对本文有异议

目录

python day 5

2019/10/08

学习资料来自老男孩教育

1. 匿名函数lambda

函数名就是变量，使用lambda表达来创建一些简单功能的函数。
lambda定义简单函数时，比用def定义要简洁，会用在map,reduce,filter等函数中。

```def f1(x,y):
return x+y
ret = f1(1,2)
print(ret)

lambda 参数: 函数执行体，与上面def定义的函数f1功能是一样的。

f2 = lambda x,y : x+y
ret2 = f2(1,2)
print(ret2)
```

  1. user = input('请输入用户名:>>>')
  2. passwd = input('请输入密码:>>>')
  3. def login(username,passwd):
  4.     '''
  5.     用于用户名与密码验证
  6.     :param username: 用户名
  7.     :param passwd: 密码
  8.     :return: True，用户名验证成功；False，用户验证失败。
  9.     '''
  10.     with open('db','r',encoding='utf-8') as f1:
  11.         for line in f1:
  12.             #strip默认无参数时，移除空格，换行符，有参数时，移除两侧指定的值
  13.             line = line.strip()
  14.             line_list = line.split('$')
  15.             #print(line_list)
  16.             if username == line_list[0] and passwd== line_list[1]:
  17.                 return True
  18.         return False
  19. is_login = login(user,passwd)
  20. if is_login:
  21.     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), 筛选：可迭代对象的每一个元素都作为实参传递到函数中去，函数返回值为真的元素留下，为假的元素不留，并返回一个迭代器。

  1. iter1 = filter(lambda x: x>22, [11,22,33,44])
  2. for i in iter1:
  3.     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，代表

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

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

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

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

文件的基本操作还有：
flush(), 即时刷新，可以在文件未关闭之前看到文件更新内容，不接参数。
readline()，读取当前指针处的一行内容。
readlines(n)，读取当前指针处的n个字符，如果n不写，则默认全读完，如果n小于当前行的字符长度，则读取当前行内容，包括换行符\n，如果n大于当前行的字符长度，则一直到第从当前指针处的第n个字符所在的行，每一行的内容包括换行符作为一个列表的元素，最终返回该列表。
close(),关闭文件
seek(n),调整指针位置
tell()，返回当前指针位置。
truncate(),截取当前指针处之前的字节内容。文件关闭时，就只有截取的内容了。
read(n),读取从当前指针处的多少个字符。返回的是字符串。
write()，写入字符串或字节。

  1. def del_user(username):
  2.     '''
  3.     delete the specified user and the password referenced.
  4.     :param username: username
  5.     :return: True
  6.     '''
  7.     with open('db.txt','r',encoding='utf-8') as f1,open('db2.txt','w',encoding='utf-8') as f2  :
  8.         for line in f1:
  9.             if username not in line:
  10.                 f2.write(line)
  11.     with open('db.txt', 'w', encoding='utf-8') as f1, open('db2.txt', 'r', encoding='utf-8') as f2:
  12.         for line in f2:
  13.             f1.write(line)
  14.     return True
  19. def ch_passwd(username):
  20.     '''
  21.     change the password for the user specified.
  22.     :param username: username
  23.     :param password: password
  24.     :return: True
  25.     '''
  26.     with open('db.txt','r',encoding='utf-8') as f1,open('db2.txt','w',encoding='utf-8') as f2  :
  27.         for line in f1:
  28.             if username in line:
  29.                 password = input('请输入修改的密码:>>>')
  30.                 line= line.strip()
  31.                 line_list = line.split('$')
  32.                 line_list[1] = password
  33.                 line = '%s$%s\n'%(line_list[0],line_list[1])
  34.                 f2.write(line)
  35.             else:
  36.                 f2.write(line)
  37.     with open('db.txt', 'w', encoding='utf-8') as f1, open('db2.txt', 'r', encoding='utf-8') as f2:
  38.         for line in f2:
  39.             f1.write(line)
  41.     return True
  44. def register(username,passwd):
  45.     '''
  46.     用于注册新用户
  47.     :param username: user's name
  48.     :param passwd: user's password
  49.     :return: True when registerd.
  50.     '''
  51.     with open('db.txt','a+',encoding='utf-8') as f1:
  52.         f1.write('\n{0}${1}'.format(username,passwd))
  53.     return True
  56. def user_exist(username):
  57.     '''
  58.     check if user exists in the file 'DB'
  59.     :param username: username
  60.     :return: True if username exists, False if not exists.
  61.     '''
  62.     with open('db.txt','r',encoding='utf-8') as f1:
  63.         for line in f1:
  64.             line = line.strip()
  65.             line_list = line.split('$')
  66.             if username == line_list[0]:
  67.                 return True
  68.     return False
  71. def login(username,passwd):
  72.     '''
  73.     用于用户名与密码验证
  74.     :param username: 用户名
  75.     :param passwd: 密码
  76.     :return: True，用户名验证成功；False，用户验证失败。
  77.     '''
  78.     with open('db.txt','r',encoding='utf-8') as f1:
  79.         for line in f1:
  80.             #strip默认无参数时，移除空格，换行符，有参数时，移除两侧指定的值
  81.             line = line.strip()
  82.             line_list = line.split('$')
  83.             #print(line_list)
  84.             if username == line_list[0] and passwd== line_list[1]:
  85.                 return True
  86.         return False
  90. def main():
  91.     user_choice = input('输入1注册，输入2登录,输入3注销用户，输入4修改密码:>>>')
  92.     user = input('请输入用户名:>>>')
  93.     passwd = input('请输入密码:>>>')
  94.     if user_choice =='1':
  95.         if user_exist(user):
  96.             print('该用户已存在，请直接登录')
  97.         else:
  98.             register(user,passwd)
  99.             print('注册成功')
  100.     elif user_choice=='2':
  101.         is_login = login(user, passwd)
  102.         if is_login:
  103.             print('登录成功')
  104.         else:
  105.             print('用户名与密码不符，请重新输入')
  106.     if user_choice == '3':
  107.         #先判断是否登录成功，登录成功之后方可注销用户
  108.         if login(user,passwd):
  109.             del_user(user)
  110.     elif user_choice == '4':
  111.         # 先判断是否登录成功，登录成功之后方可修改密码
  112.         if login(user, passwd):
  113.             ch_passwd(user)
  117. if __name__=='__main__':
  118.     main()

4. 递归函数

  1. def f1():
  2.     return 'f1'
  4. def f2(args):
  5.     a = args()
  6.     return a

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

数学意义上的阶乘：5！ = 5* 4！, 4!= 43!, 3!= 32!, 2!= 2*1!, 1!=1
可以使用递归函数解决，递归函数指在函数内部调用自己的函数。

  1. def factoria(n):
  2.     if n==1:
  3.         return 1
  4.     return n*factoria(n-1)

5. 冒泡排序

  1. li = [33,2,10,1]
  2. #使用冒泡排序按照由小到大的顺序进行排列
  3. for i in range(len(li)-1):
  4.     if li[i]>=li[i+1]:
  5.         temp = li[i]
  6.         li[i]=li[i+1]
  7.         li[i+1]=temp
  8. for i in range(len(li)-2):
  9.     if li[i] >= li[i + 1]:
  10.         temp = li[i]
  11.         li[i] = li[i + 1]
  12.         li[i + 1] = temp
  13. for i in range(len(li)-3):
  14.     if li[i] >= li[i + 1]:
  15.         temp = li[i]
  16.         li[i] = li[i + 1]
  17.         li[i + 1] = temp
  18. print(li)
  19. #总共循环了3次，可以优化下，实际自己做的时候，就写到上面这一步。
  20. #可以简化成下面
  21. def maopao(li):
  22.     '''
  23.     按照冒泡排序算法对列表进行处理
  24.     :param list1: a list
  25.     :return: list sorted in ascending
  26.     '''
  27.     for j in range(1, len(li)):  # 1,2,3
  28.         for i in range(len(li) - j):
  29.             if li[i] > li[i+ 1]:
  30.                 temp = li[i]
  31.                 li[i] = li[i + 1]
  32.                 li[i + 1] = temp
  33.     return li
  34. print(maopao(li))
  35.

6. 装饰器

开放封闭原则：对于函数内部是封闭的，即不可修改；函数外部是开放的，可以修改。
装饰器用来装饰函数，使得函数在执行之前或执行之后进行某个功能。

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

原文链接：http://www.cnblogs.com/lanxing0422/p/pythonday5.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Python热门文章

  • Python | 新冠肺炎疫情数据的爬取与可视化分析
  • Python爬小草1024图片，盖达尔的诱惑（urllib.request）
  • pytorch如何获得模型的计算量和参数量
  • 计算曲线与坐标轴的面积
  • 基于Python实现语音合成小工具
  • PyQt5笔记之弹出窗口大全
  • python反编译学习之字节码详解
  • Python爬虫基础讲解（二十）：多进程——multiprocessing模块的使用
  • python?OpenCV计算图片相似度的5种算法
  • matplotlib 设置图形大小时 figsize 与 dpi 的关系

    • Python推荐文章

  • python 音频处理（2)——提取PPG特征之whisper库的使用（2.1）
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-60 - 判断元素是否显示 - 下篇 - 北京-宏哥
  • [python] 启发式算法库scikit-opt使用指北
  • 《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇 - 北京-宏哥
  • 界面自动化测试录制工具，让python selenium自动化测试脚本开发更加方便
  • 《最新出炉》系列入门篇-Python+Playwright自动化测试-56- 多文件上传 - 下篇 - 北京-宏哥
  • 音频文件降噪及python示例
  • 全网最适合入门的面向对象编程教程：20 类和对象的 Python 实现-组合关系的实现与 CSV 文件保存
  • 张高兴的 MicroPython 入门指南：（一）环境配置、Blink、部署
  • Python——比 Seaborn 更好的相关性热力图：Biokit Corrplot

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号