python金牌班第五周周末总结

常见内置函数

1.abs  # 求绝对值,将负数变为整数，并且得出的值只有正数print（abs(-999))  # 999
2.all  # 当在经历条件判断时所有的返回值为True时那么判定为True，反之则为False，和and类似。print（all（0, 1, 2, 3, 4, 5））  # False
3.any  # 当经历条件判断时任意一个返回值为True那么返回值就是True，和or类似print（any（0，1, 2，3，4，5））  # True
4.basestring  # 用来判断一个对象是否是str或者是unicode的实例isinstance（'holle world',basestring）  # True
5.bin  # 将十进制转为二进制模式print（bin（10））  # 0b1010
6.oct  # 将十进制转为八进制模式print（oct（10））  # 0o12
7.hex  # 将十进制转为十六进制模式print（hex（10））  # 0xa
8.bool  # 老熟人  布尔值True  False
9.bytearray  # 可变的字节序列，相当于bytes的可变版本如果 source 为整数，则返回一个长度为 source 的初始化数组；如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。bytearray()  # bytearray(b'')bytearray([1,2,3])  # bytearray(b'/x01/x02/x03')bytearray('runoob', 'utf-8')  # bytearray(b'runoob')res = bytes('我生君未生，君生我已老','utf-8')print(res)  # b'/xe6/x88/x91/xe7/x94/x9f/xe5/x90/x9b/xe6/x9c/xaa/xe7/x94/x9f/xef/xbc/x8c/xe5/x90/x9b/xe7/x94/x9f/xe6/x88/x91/xe5/xb7/xb2/xe8/x80/x81'res1 = str(res, 'utf8')print(res1)  # 我生君未生，君生我已老
10.callable  # call在it专业名词中是调用的意思，需要加括号才能使用  able是否的意思，那么就是指这个内容是否可以被调用name = 'joseph'def func():    print('from func')print(callable(name))  # Falseprint(callable(func))  # True
11.chr  # 一句ascii码表实现数字与字符之间的转换print(chr(90))  # Zprint(chr(65))  # A
12.classmethod  # 指定一个类的方法也叫类方法class C:  # 这个是cv过来的我也看不懂    @classmethod    def f(cls, arg1, arg2, ...): ...
13.cmp  # 用于比较两个对象（x， y）如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
14.compile  # 将一个字符串编译成字符代码compile(source, filename, mode[, flags[, dont_inherit]])'''ource -- 字符串或者AST（Abstract Syntax Trees）对象filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值mode -- 指定编译代码的种类。可以指定为 exec, eval, singleflags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象flags和dont_inherit是用来控制编译源码时的标志'''
15.cpmplex  #用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数class complex([real[, imag]])
16.delattr  # 删除属性delattr(object, name)  # 删除目标变量名
17.dict  # 老朋友了 我们的字典
18.dir  # 获取对象内部可以使用的内置方法print(dir(str))  
19.divmod  # 获取除法之后的整数和余数，我们在定制页面有多少野的时候经常用到这个，确定这一页展示多少数据，不够就填够了就这样"""手上有很多数据 每页展示10条 需要多少页    通过代码自动计算 总数据         每页展示            需要多少页 100            10                  10 99             10                  10 101            10                  11 898            10                  ???"""real_num, more = divmod(99999, 25)if more:    real_num += 1print('总页数是：%s' % real_num)  # 4000
20.enumerate  # 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中l1 = ['joseph', 'trump', 'joe', 'jones']for i , k in enumerate(l1, 25):    print(i, k)# 25 joseph		26 trump	 27 joe	   28 jones
21.eval  # 能够识别字符串中简单的的python代码并执行res = 'print（321）'eval（res）  # 321 
22.exec  # 能够识别略微复杂的代码并执行res1 = for i in range（5）:print(i)exec(res1)  # 0, 1, 2, 3, 423.file  # 也是老朋友了  通过这个创建一个文件file(name[, mode[, buffering]])24.filter  # 过滤我们不需要的元素25.float  # 这个同样也是老朋友了浮点数26.format  # 额格式化输出和%S类似27.frozenset  # 返回一个冻结的集合，该集合不能在被增加或减少任何元素class frozenset([iterable])
28.getattr  # 返回一个对象的属性值getattr(object, name[, default])
29.globals  # 会以字典类型返回当前位置的全部全局变量globals()
30.hash  # 获取取一个对象（字符串或者数值等）的哈希值hash(object)
31.help  # 查看帮助信息help（）
34.id  # 也算是老朋友了吧地址
35.input  # 额输入老朋友
36.int  # 整型额可以将底层是整数类型的进制数的对象改为整型
37.isinstance  # 判断某个数据是否属于某个类型
38.issubclass  # 用于判断参数 class 是否是类型参数 classinfo 的子类issubclass(class, classinfo)
39.iter  # 生成迭代器iter(object[, sentinel])
40.len  # 老朋友判断xx的长度
41.list  # 额列表
42.locals  # 函数会以字典类型返回当前位置的全部局部变量
43.long  # 将数字或字符串转换为一个长整型  # 貌似py3已经将这个删除了
44.map  # 映射说新也新说不新也能说
45.max  # 取最大值，老朋友
46.min  # 取最小值和上面那个是兄弟俩也是老朋友
47.memoryview  #返回给定参数的内存查看对象，看不懂memoryview(obj)  
48.next  # 返回迭代器的下一个项目
49.object  # 嵌入到主调函数中的函数称为内置函数，又称内嵌函数object（）
50.oct  # 函数将一个整数转换成 8 进制字符串
51.open  # 打开老朋友
52.ord  # 返回十进制print(ord(Z))  # 90print(ord(A))  # 65
53.pow  # 幂指数print（pow（2， 4））  # 16
54.print  # 打印认识最久没有之一
55.property  # 是在新式类中返回属性值
56.range  # 范围老冤种好久不见
57.raw_input  #  将所有输入作为字符串看待，返回字符串类型raw_input([prompt])
58.reduce  # 求和
59.repr  # 将对象转化为供解释器读取的形式
60.reversed  # 返回一个反转的迭代器颠倒
61.round  #四舍五入在py中由于数字不敏感其实被默认为五舍六入
62.set  # 集合
63.setattr  # 对应函数 getattr()，用于设置属性值，该属性不一定是存在的
64.slice  # 实现切片对象，主要用在切片操作函数里的参数传递
65.sorted  # 对所有可迭代的对象进行排序操作
66.staticmethod  # 返回函数的静态方法
67.str  #字符串
68.sum  # 方法对序列进行求和计算
69.super  # 解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题
70tuple  # 元组
71.type  # 类型
72.unichr  # 数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符  # python3也不支持
73.unicode  # 编码
74.vars  # 返回对象object的属性和属性值的字典对象
75.xrange  # 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器
76.zip  # 拉链，缝合
77.__import__  # 如果一个模块经常变化就可以使用 __import__() 来动态载入 

可迭代对象

1.可跌代对象其实就是可以被分割依次读取的元素了， 例如列表，字符串，字典等。
2.迭代器类型
	while True:
        print('我是自己一个人循环重复的')
	像这种的循环结构不能叫做迭代，只能叫做循环自己因为他没有在上一个值的基础上进行变化只是不断往复的
	循环一个数值
    count = 0
    while c <10：
    	print（c）
      c += 1  # 0	1	2	3	4	5	6	7	8

迭代器对象

1.迭代器对象其实就是可迭代对象使用__iter__方法转变为迭代器对象然后使用__next__方法将内部数值循环出来的元素。
2.迭代器对象迭代取值
	res = 'joseph'.__intr__()	# 将这个字符串有可迭代对象转为迭代器对象并赋值给res变量名
    print(res.__next__())  #j
    print(res.__next__())  # o
    print(res.__next__())  # s
    print(res.__next__())  # e
    print(res.__next__())  # p
    print(res.__next__())  # h
    print(res.__next__())  # 如果多出一个的话就会直接报错
    
    dic1 = {'name':'joseph','age':21}  # 新建一个字典
    res = d1ic.__iter__()  # 将可迭代对象转迭代器对象
    print(res.__next__())  # name
    print(res.__next__())	# age

for循环的本质

1.for i in 可迭代对象：  # （in后面自动增加__iter__）
	 可迭代对象__next__  # 取出
2.在for循环中in会直接将后面的值变成可迭代对象也就是自动在后方加一个__intr__
3.后面开始循环的时候也会直接在前面附加一个(__next__)让他在迭代器中迭代
4.由于我们在实验的时候再继续往下写的时候会直接报错，我们的for循环就自动帮我们修复了这个bug让他循环完成不
会报错或者说修复报错

异常捕获

1.异常捕获其实就是我们如果遇到感觉可能会出错的代码，我们就可以使用异常捕捉判断是否为这个类型加如果出错后的更正方式，来进行捕获并求改。
2.常见异常类型
	TypeError:类型错误，对象用来表示值的类型非预期类型时发生错误
	AttributeError:属性错误，特性引用和复制失败时会引发的错误
	NameError：试图访问的变量名不存在
	SyntaxError：语法错误，代码形式错误
	KeyError:在读取字典中k值不存在就会出发这个错误
	IndexError:索引错误，使用的索引不存在或超出可索引范围
	IndentationError:缩进错误
	TabError:tab和空格混合使用产生的错误
3.try:  # 尝试关键字
		可能会出现错误的代码  
	except 上方可能会报错的代码的报错类型 as e：  # except尝试预测报错方法如果真的错误了就是用这个后面的例外方案，跟上报错类型如果预测失败的话那么就会直接报错而不会运行运行之后的代码，except可进行连	环使用，跟上as后面跟上一个报错提示，可以不需要这一步这一步只是为了方便我们查询报错，跟上默认一般e来接收报错
    print（如果判断成功打印出这个错误看一下）
    解决这个报错的plan B直接解决
    try：
    	可能会出错误代码
    except TypeError as e：
    	对应解决方案
4.可以与捕获联系的内置方法
	4.1	else否则老朋友了，哪里都有它吐了，不过这次只有在上方尝试没有报错的情况下他才会执行，如果报错他也不执行，看到这个还是蛮爽的
		try：
			可能会出错误代码
		except TypeError as e：
			对应解决方案
		else：
        只有在上方执行美哟报错的情况下才会执行else  
	4.2	finally最后，这个就比较豪横了，无论上方代码有没有错误都会执行这大哥和这大哥后方的东西
				try：
			可能会出错误代码
		except TypeError as e：
			对应解决方案
		else：
        只有在上方执行美哟报错的情况下才会执行else 
		finally：
        无论怎么报错我都执行就是这么的豪横
	4.3	isinstance可以使用这个预测上方是什么数据类型不对的话就会直接报错，而对的话才会继续往下执行代码
		name = 'jsoeph'
		isinstance(name, bool)如果预测正确继续往下运行，不正确来吧直接进入主题报错根据上方预测成功的类型继续操作
	4.4	raise主动报错，堪称无敌自己和自己玩，唉就是报错
		name = input（'请输入您的姓名>>>:'）
		if name == 'Alice':
			raise Exception(‘只要是输入了Alice，进了我这道门那么你就死都别想出去，嘿嘿嘿’)
		else：
        我只要Alice别人绕道走就行 

异常捕获实践

1. for循环的内部结构
	l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99]  # 首先自建一个列表
	res = l1.__iter__()  # 将列表的可迭代对象转为迭代器对象，在for循环中会将in后面的可迭代对象直接转为迭代器对象
    while True:  # 额最普通的循环    
        try:  # 尝试，监控下方代码        
            print(res.__next__())  # 打印这个已经被转为迭代器对象的结果使用__next__依次取出通过while    
            except Exception as e:  # 报错就截胡，管他什么先截胡再说     
                print(e)  # 自己加的没想到打印不出来        
                break  # 上方循环完报错完被截胡后强制中止while循环

取值差异

1.迭代取值l1 = [11, 22, 33, 44, 55, 66]
res =l1.__iter__()print(res.__next__())  # 11
print(res.__next__())  # 22
print(res.__next__())  # 33
print(res.__next__())  # 44
print(res.__next__())  # 55
print(res.__next__())  # 66
"""迭代取值是我们经常使用的一种取值方式，通过while或者for循环的方式将列表字典元组等地方的值一次取出，但是他每次取值都是在上次取值的基础上再次取值，取完就没了，再也取不了之前取过的值这就是他的弊病"""
2.索引取值l1 = [11, 22, 33, 44, 55, 66]print(l1[0])  # 11
print(l1[1])  # 22
print(l1[2])  # 33
print(l1[0])  # 11
"""我们在索引取值的时候是可以根据他的所在位置将他里面的值索引出来，可以将里面的值重复取出但是必须知道这个地方的内部是什么或者有多少取多少，如果数据过多的话那么就不太建议使用索引取值"""

模块的本质

1.模块其实就是已经编号的代码，我们只需要去调用这个代码那么我们就可以获取，这个模块里面蕴含的功能
2.模块的种类
2.1内置模块
    	内置模块其实就是我们python自带的一些模块，我们直接在py文件中调用就可以使用模块中的内容和功能，例
	如：import time,import sys等的一些自带模块
	2.2自定义模块
    	自定义模块其实就是我们自己写的一些功能模块，如果在相同文件夹内那么我们其实就可以直接调用我们自己
	写的一些模块功能就不需要去重复书写例如我们之前学的一些请输入您的姓名什么的都可以当作模块使用
	2.3第三方模块
    	第三方模块其实就是我们可以去网上寻找别人写的模块下载下来，然后将他放到文件夹中调用即可使用，例如一些早已经被写出来并分享到网上的一些大佬模块：图片翻译，小爱同学，图形可视化等
3.模块的导入方式
	方式一：import xxx  # 导入整个模块
	方式二：from xxx import xxx  # 导入模块中的某一个功能

模块的使用

1.起别名	
	1.1当我们调用多个模块时容易出现多个模块名相同的情况，所以我们就出现了起别名，为了我们方便区分他们，	那个是哪个以防调用失败以及场面混乱    
    import time as aaa    
    import time as bbb    
    import time as ccc    
    print(aaa.xxx)    
    print(bbb.xxx)    
    print(ccc.xxx)	
    1.2第二种就是我们调用的文件名过于复杂的话那么我们最好也帮他起一个别名：dog egg， dog left	the son，rhubarb，Pig boy等简单方便我们记忆即可    
    import experimenta as aaa    
    import dog left the son as sb    
    print(aaa.xxx)    
    print(sb.xxx)
2.导入多个名字	
	2.1导入多个模块		
    import time,sys,os		虽然这样也能一次性导入多个文件但是经常容易出现错误，只有在上方多个模块功能相近的时候才可以采用上方那种导入模式		
    import time		
    import sys		
    import os		
    在python中如果导入多个模块建议这样一次一个的往里导入。	
   2.2方式二：		
    from experimenta as name, func1, func2		
    当在导入同一个模块中的不同变量或函数的时候我们就可以采用一次性导入多个因为他本来就是同一个模块中的
3.全导入	
	当我们在使用同一个模块中的功能并且只能使用from xxx import的时候我们就可以采用全导入的方式导入	
    from xxx import *	
    就可以将那个模块中的所有功能导入本文件我们直接调用即可2.私密的程序不想被全导入的话我们可以直接给她限定可以导入些什么也就是针对*号来导入使用__all__ = [字符串名字]就可以只给他调用你这个里面所包含的变量与函数

判断文件类型与顺序查找

1.判断文件类型	
	在我们之后要用的代码中可能就会需要在多个文件中来回的去倒那么我们就需要判断py文件是作为模块文件还是执行文件，那么这时我们就能使用__name__	__name__当文件是执行文件的时候会返回__main__如果文件是被当做模块导入则返回文件名(模块名)			 print(__name__)  # __main__	
		if __name__ == '__main__':	
			print(True)	
         if __name__ == '__main__':  		
            read1()
	"""在pycharm中可以直接敲 main按tab键即可自动补全if判断"""
2.查找顺序	
首先从内存空间中寻找→→然后去内置名称空间中寻找→→最后要是还找不到的话就调用sys模块使用内部的sys.path来寻找他的环境变量
2.实际操作	
    import experimenta	
    import time 	
    time.sleep(8)	
    print(experimenta.name)
"""
首先我们先调用了两个模块，然后使用sleep睡眠调用下方模块，并将上方模块文件删除然后还是执行了出来，就证明他是在执行的一瞬间就将所调用的模块输入到这个文件中，然后删除也不会影响调用，但是一旦运行结束再运行的话那就没有这个模块也就不能执行了
"""	
    import sys	sys.path.append(r'D:/pythonProject/day22/xxx')	
    import experimenta	
    print(experimenta.name)
"""
如果不是同一个地址那么就需要添加执行文件的地址才能调用该模块
"""

绝对导入与相对导入

1.绝对导入其实就是我们通过各种手段获取到的执行文件地址，并将这个地址输入到我们调用的内部，并使用内部的功能，类似于环境变量
    from aaa import new1
    print(new1.name)

    import sys
    sys.path.append(r'D:/pythonProject/day23/aaa')
    import new1
    print(new1.name)
2.相对导入其实就是我们在调用的时候给她一个模糊的路径，他就可以帮我们在这个模糊路径中调取到我们所需要的信息
拓展
    .在路径中意思是当前路径
    ..在路径中意思是上一层路径
    ../..在路径中意思是上上一层路径

    from . import new1模块文件

    from aaa.bbb.ccc import new1  # pycharm自动修改文件
    print(new1.name)  # 打印

包的概念

1.包本质上其实就是一个文件夹，我们可以通过调用的手段去拿到这个文件夹中的所有内容，这个文件夹内的内容根据分类我们在调用的时候就可以方便一些，知道哪个里面是什么。
3.对包的定义一共有两种	
	一种是在python2.x中文件夹内部必须带有__init__.py文件的才会被认为是包，调用的时候擦可以被调用，如果没有的话那么就不认识,我们不熟	
    第二种则是在python3.x中只要是个文件夹并且不管内部带不带__init__文件我们都认为他是一个包，但是我们在使用的时候还是比较建议给调用的文件夹中添加一个__init__的py文件，比较符合规范	
    最后包呢其实就是多个py文件放到同一个文件夹中，为了方便管理和调用创造出了一个名词叫做包
4.1.包的规范
	首先我们要先应该现在包的内部找到__init__文件，然后在内部定义好这个文件同级别调用的模块以供别的执行文件调用更方便一些例如form . improt xxx, xxx, xxx,然后再经过别的执行文件调用这个包的名字并且调用__init__文件就可以了

软件开发目录

1.我们可以根据这个目录进行存储文件，也可以不按照这个来存储文件，只要见名知意那么他就可以存储文件。

collections模块

1.除内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型、Counter、deque、defaultdict、namedtuple和OrderedDict等。
2.namedtuple: 生成可以使用名字来访问元素内容的tuple,可以用来表示坐标轴等
	from collections import namedtuple
	point = namedtuple('point', ['X', 'Y', 'Z'])
	p = point(5, 2, 1)
	print(p)  # point(X=5, Y=2, Z=1)
	print(p.x, p.y, p.z)  # 5 2 1
3.deque: 双端队列，可以快速的从另外一侧追加和推出对象
	from collections import deque
	q = deque (['joseph', 'trump', 'alice' 'jon' 'lili'])
	q.append('zoey')
	q.appendleft('annabelle')
	q.append('kayla')
	print(q)  # deque(['annabelle', 'joseph', 'trump', 'alice', 'jon', 'lili', 'zoey', 'kayla'])
	q.pop()  # deque(['annabelle', 'joseph', 'trump', 'alice', 'jon', 'lili', 'zoey'])
	q.popleft()  # deque(['joseph', 'trump', 'alice', 'jon', 'lili', 'zoey'])
4.Counter: 计数器，主要用来计数，直接帮我们看出可迭代对象中一共出现了，多少次某个相同的元素并使用字典的方式返回	
    from collections import Counter	
    c = Counter(['joseph', 'trump', 'alice', 'jon', 'lili', 'joseph', 'lili','trump','joseph'])	
    print(c)  # Counter({'joseph': 3, 'trump': 2, 'lili': 2, 'alice': 1, 'jon': 1})
5.OrderedDict: 有序字典，将无序字典变为有序字典
	from collections import OrderedDict
	d = dict([('name', 'joseph'), ('age', '21'), ('gender','male'), ('hobby', 'read')])
	print(d)  # {'name': 'joseph', 'age': '21', 'gender': 'male', 'hobby': 'read'} 
  	# 其实应该是乱的但是pycharm太只能了帮我们理清了
	od = OrderedDict([('name', 'joseph'), ('age', '21'), ('gender','male'), ('hobby', 'read')])
	print(od)  # OrderedDict([('name', 'joseph'), ('age', '21'), ('gender', 'male'),
  	('hobby', 'read')])
	print('hobby')  # hobby
6.defaultdict: 带有默认值的字典
	from collections import defaultdict
	l1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 520, 521]
	dic1 = defaultdict(list)
	for i in l1:
    	if i < 66:
        	dic1['k1'].append(i)
    	else:
        	dic1['k2'].append(i)
	print(dic1)

time模块

1.时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型	import time	print(time.time())  # 1657797052.588196
2.格式化时间
	我们通过这些就可以直接打印出当前时间
	import time
 
	print(time.strftime("%Y-%m-%d %X"))  # 2022-07-14 19:19:58
	print(time.strftime("%Y-%m-%d %H-%M-%S"))  #2022-07-14 19-19-58
	print(time.strftime("%Y-%m-%d %H:%M:%S %p"))  #2022-07-14 19:19:58 PM
3.结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第  几周，一年中第几天，夏令时),打印时能够打印我们所在时区的时间  	import time  	print(time.localtime())  # time.struct_time(tm_year=2022, tm_mon=7,		tm_mday=14, tm_hour=19, tm_min=16, tm_sec=33, tm_wday=3, tm_yday=195, 			tm_isdst=0)

datetime模块

import datetime  # 导入import模块 

res = datetime.datetime.today()  
print(res)  # 2022-07-15 14:43:23.238107  

res = datetime.datetime.utcnow()
print(res)  # 2022-07-15 06:44:50.539694 

res = datetime.date.today()
print(res)  # 2022-07-15 
print(res.year)  # 2022
print(res.weekday())  # 4

print(res.timetuple())  # time.struct_time(tm_year=2022, tm_mon=7, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=196, tm_isdst=-1)  

res1 = datetime.timedelta(days=2190)
print(res + res1)  # 2028-07-13
print(res-res1)  # 2016-07-16  

res = datetime.datetime.utcnow()
print(res)  # 2022-07-15 07:07:45.423954 

c = datetime.datetime(2020, 5, 20, 00, 43, 22)
print('梦开始的时间：', c)  # 梦开始的时间： 2020-05-20 00:43:22

m = datetime.datetime(2021, 7, 28, 19, 56, 44)
print('心碎的时间：', m)  # 心碎的时间： 2021-07-28 19:56:44

os模块

import osres = os.cpu_count()print(res)1.增加文件夹os.mkdir(r'a.txt')  # 新增一个啊.txt文件
os.mkdir(r'aaa/bbb/ccc')  # 新增一个递增的文件夹，使用mkdir并不能增加
os.makedirs(r'bbb/ccc/ddd/eee')  # 使用makedirs才能增加多个递增文件夹
os.makedirs(r'fff')  # 使用makedirs也可以单独增加一个文件夹
2.删除文件夹
os.rmdir(r'a.txt')  # 删除一个单独的文件夹
os.rmdir(r'bbb')  # 删除整个文件夹，并不能删除因为这个文件夹中
os.removedirs(r'bbb/ccc/ddd/eee')  # 使用removedirs可以将空文件夹删除，并且是从底部删除，底部删完的话就会判断他的上一层及是否也是空文件夹，如果是# 空文件夹的话那么也会将这个空文件夹删除，依次递推
os.removedirs(r'fff')  # 使用removerdirs也可以删除一个单独的空文件夹
3.查看目录下的所有文件名print(os.listdir())  # ['.idea', 'blog write.py']
print(os.listdir(r'D://'))  # 查看该目录下的所有文件print(os.listdir(r'C://'))  查看该路径下的所有文件
4.删除文件
os.rename('a.txt', 'b.txt')  # 修改文件名
os.remove('b.txt')  # 删除该文件
5.获取文件地址print(os.getcwd())  # D:/pythonProject/day24获取本层的地址
os.chdir(r'D:/pythonProject/day24/bbb/ccc/ddd/eee')  # 进入指定地址所处的文件夹
os.mkdir(r'西八儿')  # 创建一个文件夹目录
print(os.getcwd())  # 再次获取现在所在的地址，D:/pythonProject/day24/bbb/ccc/ddd/eee6.获取文件的路径
print(os.path.abspath(__file__))  # D:/pythonProject/day24/blog write.py，查找执行文件的绝对路径
print(os.path.dirname(__file__))  # D:/pythonProject/day24， 查找执行文件所在文件的路径
7.判断某某某是否在本执行文件层级print(os.path.exists(r'b.txt'))  # True  # 判断路径是否在文件中
print(os.path.exists(r'a.txt'))  # False  # 判断路径是否在文件中
print(os.path.exists(r'bbb'))  # True  # 判断路径是否在文件中
print(os.path.exists(r'eee'))  # False  # 判断路径是否在文件中
print(os.path.exists(r'fff'))  # True  # 判断路径是否在文件中
print(os.path.lexists(r'b.txt'))  # True  # 判断路径是否在目录中
print(os.path.lexists(r'a.txt'))  # False  # 判断路径是否在目录中
print(os.path.lexists(r'bbb'))  # True  # 判断路径是否在目录中
print(os.path.lexists(r'eee'))  # False  # 判断路径是否在目录中
print(os.path.lexists(r'fff'))  # True  # 判断路径是否在目录中8.文件的拼接
real_path = 'b.txt'  res_path = 'D:/pythonProject/day24/ccc/ddd/eee'
print(os.path.join(res_path,real_path))
9.查看文件内部一共有多少字节print(os.path.getsize('blog write.py'))  #4029
print(os.path.getsize(r'D:/pythonProject/day24/bbb/ccc/ddd/eee/new1.py'))  # 31

sys模块

1.sys的功能import sys print(sys.path)  # ['D://pythonProject//day24', 'D://pythonProject//day24', 'D://PyCharm 2021.1.3//plugins//python//helpers//pycharm_display', 'D://python38//python38.zip', 'D://python38//DLLs', 'D://python38//lib', 'D://python38', 'D://python38//lib//site-packages', 'D://PyCharm 2021.1.3//plugins//python//helpers//pycharm_matplotlib_backend']
print(sys.version)  # 3.8.6 (tags/v3.8.6:db45529, Sep 23 2020, 15:52:53) [MSC v.1927 64 bit (AMD64)]
print(sys.platform)  # win32 
2.cmd执行的命令，差点没把我搞疯
	D:/pythonProject/day24 python38 'blog write.py' joseph 123
    import sys
    res = sys.argv
    if len(res) == 3:    
        username = res[1]    
        password = res[2]    
        if username == 'joseph' and password == '123':        
            print('您可以正在执行该文件')    
            else:        
                print('用户名或密码错误')
                else:    
                    print('难搞')

json模块

1.json模块也叫做序列化模块，在各个编程软件之间进行相互配合使用的时候就需要json模块来帮我们转换，也可以说是必备的模块，由于我们在进行数据转换时肯定要转换成二进制那种计算机能够听懂的语言，那么因为各个语言都是不同的类型，所以转换成二进制语言也都不一样，就需要我们的json模块来进行转变，保留数据转换的完整的对方的可读性。只要是json转的数据都会变成字符串的形式，无论什么东西都是，他呢在转换的时候都是使用双引号做标记，证明他这个文件时一个就是json文件。
2.反序列化
import jsondic = {'name':'joseph', 'pwd':'123'}
res = json.dumps(dic)
print(type(res))  # <class 'str'>
dic1 = {'name':'joseph', 'pwd':'123'}print(dic1)  # {'name': 'joseph', 'pwd': '123'}
res1 = json.loads(res)
print(res1, type(res1))  # {'name': 'joseph', 'pwd': '123'} <class 'dict'>
3.写入字典并转换
import jsondic = {'name':'joseph', 'pwd':'123'}
with open(r'a.txt', 'w', encoding='utf8')as f:    
    json.dumps(dic, f)
    with open(r'a.txt', 'r', encoding='utf8')as f:    
        res = json.load(f)    
        print(res)  # {'name': 'joseph', 'pwd': '123'}    
        print(type(res))  # <class 'dict'>