Python（二）ProMax
from collections import OrderedDict data=OrderedDict() data['name']='ghj' data['age']=18 data['sex']='girl'print(dict(data))
#分解出多个元素信息 list1=['Python','Google','阿里','腾讯','百度','网易'] print(list1[1:]) language,*company=list1 print(language) print(company)
下⾯主要结合集合的知识，也就是交集和并集，来获取字典相同的键和相同的值，具体实现的代码如下：
dictX={'x':1,'y':2,'z':3}
dictY={'w':10,'x':11,'y':2}
print('获取相同的键值对:{0}'.format(
dictX.keys() & dictY.keys()
))
print(set(dictX.keys())&set(dictY.keys()))
print('dictX的键值对不dictY⾥⾯:{0}'.format(
dictX.keys() - dictY.keys()
))
print(set(dictX.keys())-set(dictY.keys()))
print('获取两个相同的键值对:{0}'.format(
dictX.items() & dictY.items()
))
Python函数式编程
Python函数的概述
所谓函数，就是把重复的代码单独的分离出来，放在⼀个公共的地⽅，以后可以⼀直的进⾏调⽤，这样就可以解决 多次重复来编写。
函数中参数详解
函数参数
''' 函数的定义： def func(): 函数体 定义函数的时候，（）里面的叫形式参数，比如函数sum(a,b),那么可以说sum函数的形式参数是a和b，他的价值函数在函数体内编写函数的 实现部分，那么形式参数就是实现部分的一部分 实际参数：当一个函数调用的时候，给形式参数赋予的实际的值叫实际参数 ''' def sum(a,b): print(a+b) sum(a=1,b=2) sum(3,4) sum('a','b') sum(1.0,2.0) sum(-9,10)
形式参数：形式参数只有在函数在进⾏被调⽤的时候才会在内存中分配内存单元，在调⽤结束后，即刻释放所分配 的内存单元。所以说，形式参数只有在函数内部是有效的。
实际参数：实际参数就是函数在被调⽤的时候，赋予形式参数具体的值，也就是实际参数
默认参数
在函数中，也可以在定义函数的时候，指定形式参数具体的值，这样的参数叫默认参数，如下所示：
''' 形式参数没赋予值，就使用了默认参数，如果赋予了新的值，新使用的值 ''' def login(username='ghj',password='admin'): ''' :param username: 登陆账户信息 :param password: 登陆账户密码 :return: ''' if username=='ghj' and password=='admin': print('login success') else: print('login fail') login()
在使⽤默认参数中，⼀定需要特别注意的是，形式参数没有值的不能放在默认参数的后⾯，否则程序就会报具体的 错误信息。在我们调⽤具体函数的时候，如果我们赋予默认参数对应的形式参数具体的值，它就会在内存中分配新的单元信息，指向赋予的具体实际参数的具体的值，如果没有，那么它在内存的分配单元依然是定义函数的时候的具体的值。默认参数是Python语⾔⾮常有⽤的⼀个功能特性，因为使⽤它，我们就可以在编写函数的时候，依据被定义函数的功能性，来定义默认参数。
动态参数
在⼀个函数中，由于我们在调⽤函数中，实际参数可能是列表的数据类型，也可能是字典的数据类型，还有可能是 元组的数据类型，这样我们在定义函数的时候就⽆法指定具体的形式参数，这个时候我们可以使⽤动态参数来解决 这个问题，在动态参数中，*args指的是元组的数据类型，**kwarks指的是字典的数据类型。
''' 动态参数：当一个函数形式参数个数不确定，数据类型不确定的时候，使用动态参数 *：代表的是元组 **：字典 可以加*来准确添加，当然列表不论怎么加*，都会添加到元组中 ''' def func(*args,**kwargs): print(args,kwargs) print(type(args),type(kwargs)) func(1,2,3) func([1,2,3]) func(a='1',b='2') func([1,2,3],('a','b','c'),**{'name':'ghj'})
''' 函数的返回值： 在单个函数而言，有没有返回值其实没有多大意义，函数的返回值核心思想是通过函数的返回值 可以把函数与函数关联起来，比如登录成功返回token，带上token可以访问个人主页。 关于返回值的几点： 1、函数的返回值是在函数的表达式中，return关键字后面， return关键字后面就是函数的返回值 2、一个函数可以有多个返回值 3、单一个函数没有写return的时候，不代表函数没有返回值，其实它的返回值是None ''' def login(username='ghj',password='admin'): if username=='ghj' and password=='admin': return 'dasfdsag' else: return '账户登录有错误' print(login()) str1=login() print(str1)
def profile(token): if token=='dasfdsag': print('欢迎访问个人主页') else: print('重定向到登录页面') profile(token=login())
def sum(a,b): print(a+b) print(sum(1,2))
''' 全局变量： 在一个python文件里面定义的变量叫全局变量 局部变量： 在一个函数内部定义的变量叫局部变量 优先级： 1、在python文件中，当全局变量与局部变量一致的时候，全局变量的优先级是高于全局变量的 2、在函数内部，局部变量的优先级是高于全局变量 把全局变量引用到局部变量的关键字是global ''' name='str1' def func(): name='str2' print(name) func()
name = 'str1' def func(): global name print(name) func()
#匿名函数 a=lambda a,b:a+b print(a(3,4))
chr
数字转字母
s=109 chr(s) 'm'
ord
字母转数字
str1='g' ord(str1) 103
获取随机字符串验证码
import random list1=[] for item in range(10): r=random.randrange(9,99) list1.append(chr(r)) print(''.join(list1))
#range范围，含首不含尾 如果是range(10)就是从0开始到9结束 for item in range(2,10): print(item) #强制转为列表 print(list(range(5)))
''' filter:过滤函数 ''' #列表推导式 lists=[x for x in range(10) if x>=2] print(lists) list1=[] for item in lists: if item>2: list1.append(item) print(list1) print(filter(lambda x:x>2,lists)) print(list(filter(lambda x:x>2,lists)))
''' map:所有的元素做同样的操作 ''' lists=[x for x in range(10) ] list1=[] for item in lists: list1.append(item+10) print(list1) print(list(map(lambda x:x+10,lists)))
eval
str1='4+9' print(eval(str1))
Python常用库与IO操作
模块与包
在Python⾥⾯，每⼀个Python⽂件都是都可以成为⼀个模块，在⼀个包中可以包含多个Python⽂件，也就是多个 Python的⽂件。
package:针对代码结构的组织，一个包里面可以拥有很多的python文件
module：一个python文件就是一个模块。
''' 一个模块想引用另外一个魔魁啊里面的代码，怎么实现？ from package。module import 变量，函数 如果无法调用已存在的包，则找到根目录设置源包‘make dictionary as’ ''' from index import name,login(或者替换成*) print(name) login()
Python常用库
''' 库： 1、标准库 安装Python环境后自带的 OS sys 2、第三方的库 第三方的个人以及公司发布 selenium：WEB自动化测试框架 requests：API测试框架 flask：轻量级WEB开发框架 django：全栈WEB开发框架 fastapi：异步WEB框架 putest：单元测试框架 3、自定义的库 '''
os实战
os模块主要是对路径的处理
import os os.system('ping www.baidu.com') ///pingbaidu # os.mkdir('aaa',mode=777) ///创建文件夹 #获取当前文件目录 print(os.getcwd()) print(os.path.dirname(__file__)) #查看目录下所有的文件 # for item in os.listdir(os.getcwd()): # print(item) #获取当前操作系统 print(os.name) #返回绝对路径 print(os.path.abspath('/usr/local')) #针对文件目录进行分隔 分割出来是元组 print(os.path.split('/usr/local'))
#目录是否存在 import time print(os.path.exists('/usr/local')) #判断是否是文件夹 print(os.path.isfile('/usr/local')) #文件最后存取时间 print(os.path.getatime('D:\85425')) #文件最后修改时间 print(os.path.getmtime('D:\85425')) print(time.localtime(os.path.getmtime('D:\85425')).tm_year)
#获取当前路径 print(os.path.dirname(__file__)) #获取当前路径的上一层路径 print(os.path.dirname(os.path.dirname(__file__))) #路径拼接 base_dir=os.path.dirname(os.path.dirname(__file__)) print(os.path.join(base_dir,'data','log')) with open(os.path.join(base_dir,'data','log')) as f: print(f.read())
序列化：把内存⾥的数据类型转为字符串的数据类型，使能够存储到硬盘或通过⽹络传输到远程，因为硬盘或者⽹络传输时只接受bytes的数据类型。简单的说就是把Python的数据类型(字典，元组，列表)转为str的数据 类型过程。
⽽反序列化，就是str的数据类型转为Python对象的过程
''' 序列化：把Python对象(list&tuple&dict)转为字符串的过程 dumps() 反序列化：字符串转为python对象的过程 loads() ''' import json '''字典的序列化与反序列化''' dict1={'name':'ghj','age':22} dict_str=json.dumps(dict1) print(dict_str,type(dict_str)) str_dict=json.loads(dict_str) print(str_dict,type(str_dict))
'''列表的序列化与反序列化''' lists={'name':'ghj','age':22} list_str=json.dumps(lists) print(list_str,type(list_str)) str_list=json.loads(list_str) print(str_list,type(str_list))
'''元组的序列化与反序列化''' tuple1=(1,2,3) tuple_str=json.dumps(tuple1) ///把元组序列化与反序列化之后就会变成列表 print(tuple_str,type(tuple_str)) str_tuple=json.loads(tuple_str) print(str_tuple,type(str_tuple))
'''文件的序列化与反序列化''' dict1={"token":"eyJ0eXAi","user":{"uid":"adGw32EcTpNmbYrN2mXCkA","telephone":"13484545195","username":"无涯","email":None,"avator":"","date_joined":"2022-01-08T15:07:01.003115+08:00","is_active":True}} json.dump(dict1,open('login.json','w',encoding='utf-8')) print(json.load(open('login.json','r',encoding='utf-8')))
''' time学习 ''' import time #休眠时间 # time.sleep(5) #获取当前时间的时间戳，如何去百度搜索转换 # print(time.time()) #时间戳转为当前时间 t=time.localtime(time.time()) print(t.tm_year,t.tm_mon,t.tm_mday,t.tm_hour,t.tm_min,t.tm_sec)
#获取较为好看的当前时间 print(time.strftime('%y-%m-%d %H-%M-%S',time.localtime()))
#简单方法获取当前时间 print(datetime.datetime.now()) #在当前的时间基础上加（减）时间 print(datetime.datetime.now()+datetime.timedelta(hours=2)) ///=是加，=-是减，一般用的是hours或者years
hashlib实战
hashlib⾥⾯主要会涉及到md5的加密算法的
''' open api :开放平台接口 1、针对请求参数进行ascil码排序 2、把请求参数处理成key1=value&key2=value2 3、进行md5的加密 ''' import hashlib from urllib import parse import time def sign(): dict1={"name":'ghj','age':18,'sex':'boy','time':time.time()} dict1=dict(sorted(dict1.items(),key=lambda item:item[0])) print(dict1) data=parse.urlencode(dict1) print(data) m=hashlib.md5() m.update(data.encode('utf-8')) print(m.hexdigest()) sign()
sys提供对解释器使⽤或维护的⼀些变量以及与解释器强烈交互的函数的访问。
import sys #获取Python解释器的持续版本信息 print(sys.version) #返回模块的搜索路径 for item in sys.path: print(item) #获取操作系统平台名称 print(sys.platform)
当要从其他包引用方法时报ModuleNotFoundError: No module named，这时可以用sys
import os base_dir=os.path.dirname(os.path.dirname(__file__)) sys.path.append(os.path.join(base_dir,'data')) ///将所要引用的文件路径添加到解释器的搜索路径中 from login import * print(name) func()
文件读取和操作
我们对⽂件的操作，⼀般情况下，分为三种情况，分别是：打开⽂件，操作⽂件（读写等），关闭⽂件。在Python 的语⾔了，提供了对⽂件的操作⽅法，默认open()是打开⽂件并且是只读模式，事实上打开和关闭⽂件⽐较很好的 理解，操作⽂件，那么操作⽂件的前提打开⽂件，打开⽂件就涉及到以什么样的模式来打开⽂件，⽐如读，写，只 读，只写，⼆进制等等模式，具体总结的⻅如下：
r:只读模式
w:只写模式【不可读，不存在就创建，存在就清空内容】
x:只写模式【不可读，不存在就创建，存在就报错】
a:增加模式【可读，不存在就创建，存在只增加内容】
"+"表示可以同时读写某个⽂件，具体为：
r+：读写
w+：写读
x+：写读
a+：写读
下⾯还是通过具体的案例来演示⽂件操作的这部分
''' 文件操作： 1、写 2、读 操作文件三个步骤： 1、打开文件 2、读/写 3、关闭文件 文件操作的模式： a ：追加 w ：写（假设文件里面有内容，先清空再写） r ：读 ''' ''' open函数写文件逻辑： 1、如果操作的文件不存在，它会自动创建文件 2、如果文件存在，并且里面有内容，模式是w，先清空再写 open函数读文件逻辑： 1、前提是必须读取的文件存在，如果不存在，出错：FileNotFoundError ''' f=open('log.txt','w') f.write('Hello jiliguala!') f.close() f=open('log.txt','a') f.write('\nHello Python!') f.close() #批量写入文件 lists=[x for x in range(10)] f=open('log.txt','w') for item in lists: f.write('\n'+str(item)) f.close()
f=open('log.md','r') #read()读取文件里面所有的内容，不管多少 print(f.read()) f.close()
f=open('log.txt','r',encoding='utf-8')#read()读取文件里面所有的内容，不管多少 print(f.read()) #默认读取第一行 print(f.readline())
#按行读取 for item in f.readlines(): print(item.strip())
for item in f.readlines(): if '好' in item: print(item) f.close()
'''with上下文：它内部会自动关闭文件''' with open('log.txt','r',encoding='utf-8') as f: #f.write('aert') for item in f.readlines(): print(item.strip())
Python异常操作
在编写程序的时候，某些时候需要处理异常，⽐如写⼀个除法的函数或者⽅法，分⺟是0，那么这样的程序肯定是要处理异常的，我们来看看如果不异常处理
Python的异常类具体如下：
| 描述 | |
|---|---|
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| KeyboardInterrupt | 用户中断执行（通常是输入^c） |
| Exception | 常规错误的基类 |
| StopIteration | 迭代器没有更多的值 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| FloatingPointError | 浮点计算错误 |
| OverflowError | 数值运算超出最大限制 |
| ZeroDivisionError | 除(或取模)零(所有数据类型) |
| AssertionError | 断言语句失败 |
| AttributeError | 对象没有这个属性 |
| EOFError | 没有内建输入，达到EOF标记 |
| EnvironmentError | 操作系统错误的基类 |
| IOError | 输入\输出操作失败 |
| OSError | 操作系统错误 |
| WindowsError | 系统调用失败 |
| ImportError | 导入模块/对象失败 |
| LookupError | 无效数据查询的基类 |
| IndexError | 序列中没有此索引(index) |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python解释器不是致命的) |
| NameError | 未声明/初始化对象(没有属性) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用（weak reference）试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError | Python语法错误 |
| IndentationError | 缩进错误 |
| TabError | Tab和空格混用 |
| SystemError | 一般的解释器系统错误 |
| TypeError | 对类型无效的操作 |
| ValueError | 传入无效的参数 |
| UnicodeError | Unicode相关的错误 |
| UnicodeDecodeError | Unicode解码时的错误 |
| UnicodeEncodeError | Unicode编码时的错误 |
| UnicodeTranslateError | Unicode转换时的错误 |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning |
''' 异常逻辑的处理： try: pass expect: pass 当try里面的代码执行正确的情况下，expec的代码不会执行 当try里面的代码执行错误，expect就来获取错误信息，不要让程序出错 Exception：能够处理所有的异常信息 BaseException：所有异常的祖先 ''' def div(a,b): try: print(a/b) #获取异常信息Exception：能够处理所有异常 except Exception as e: print(e.args[0]) else: print('try执行正常，会执行else代码') finally: print('不管是否执行正确，都会被执行') div(1,0)
下图是正确执行的结果，把div里面的值改成1，1
def div(a,b): try: print(a/b) except IndexError as e: print('索引异常') except ZeroDivisionError as e: print('分母不能为0') div(1,0)
''' Exception：能够处理所有的异常信息 BaseException：所有异常的祖先 ''' def div(a,b): try: print(a/b) except Exception as e: print(e.args) div(1,'1')
综合练习
isinstance判断类型
a=1 if isinstance(a,int): print('a是int') else: print('a不是int')
下⾯编写⼀个登录注册的函数功能，来实现代码的分离和优化的过程
import json def register(): username=input('请输入账户:\n') password=input('请输入密码:\n') temp=username+'|'+password json.dump(temp,open('user.md','w')) register()
def login(): username=input('请输入账户:\n') password=input('请输入密码:\n') lists=str(json.load(open('user.md','r'))).split('|') if username==lists[0] and password==lists[1]: return True else: return False print(login())
def profile(): lists=str(json.load(open('user.md','r'))).split('|') if login(): print('{nick}登陆成功'.format(nick=lists[0])) else: print('账户或者密码错误') profile()
def main(): while True: try: f=int(input('1、注册 2、个人主页 3、退出\n')) if f==1: register() elif f==2: profile() elif f==3: break except: continue if __name__ == '__main__': main()
浙公网安备 33010602011771号