周总结——weekfour

1|0周总结——weekfour

1|1异常常见类型

'''
SyntaxError  
NameError
IndexError
KeyError
IndentationError
......
'''

1|01、SyntaxError

三种SyntaxError：
    invalid syntax（无效语法）invalid character in identifier（标识符中有无效字符）EOL while scanning string literal（检查到不完整的字符串）

（1）SyntaxError: invalid syntax（无效语法），这是语法错误中最常见的一种，通常是由下面几种情况引起的。

    遗漏了标点符号，比如漏了冒号，混用中英文符号等；关键字拼写错误或遗漏，比如while写成了whlie，for…in…中的关键字in忘写了等；变量名或函数名使用了关键字

（2）SyntaxError: invalid character in identifier（标识符中有无效字符）；

在运行代码的时候出现这个错误有可能是你在写代码时频繁地切换中英文输入法所造成的，修改为对应的英文符号即可。

（3）SyntaxError: EOL while scanning string literal（检查到不完整的字符串）；

这种情况通常是因为遗漏了字符串两边的引号，或者混用了引号（即字符串两边的引号不统一）。

1|02、NameError

NameError

	NameError是最普通也是最常会遇到的内建报错类名，其代表问题出现在python 变量命名上，找不到变量名会引发NameError。
    

1|03、IndexError

IndexError
引用超过list最大索引

导致“IndexError: list index out of range”

该错误发生在如下代码中：

spam = [‘cat’, ‘dog’, ‘mouse’]
print(spam[6])

1|04、KeyError

KeyError

使用不存在的字典键值

导致“KeyError：‘spam’”

该错误发生在如下代码中：

    spam = {‘cat’: ‘Zophie’, ‘dog’: ‘Basil’, ‘mouse’: ‘Whiskers’}
    print(‘The name of my pet zebra is ‘ + spam[‘zebra’])

1|05、IndentationError

Python是一种对缩进非常敏感的语言，最常见的情况是tab和空格的混用会导致错误，或者缩进不对

1|2异常处理语法结构

1|01、基本语法结构

'''
语法结构：
	try：
		待检测的代码（自己无法控制，且有可能出现的错误的代码）
	except 错误类型:
		针对上述错误类型所指定的方案
'''
try:
    name = 'jason'
    print(nama)
except NameError:
    print('名字未定义')  # 名字未定义

1|02、查看错误信息

'''
语法结构：
	try：
		待检测的代码（自己无法控制，且有可能出现的错误的代码）
	except 错误类型 as e:
		针对上述错误类型所指定的方案
		
这里面的e打印出来是系统报的错误信息
e（error）只是一个变量名
'''
try:
    name = 'jason'
    print(nama)
except NameError as e:
    print('名字未定义')  # 名字未定义
    print(e)    # name 'nama' is not defined

1|03、针对不同的错误类型制订不同的解决方案

'''
语法结构：
	try：
		待检测的代码（自己无法控制，且有可能出现的错误的代码）
	except 错误类型 as e:
		针对上述错误类型所指定的方案
	except 错误类型 as e:
		针对上述错误类型所指定的方案
	except 错误类型 as e:
		针对上述错误类型所指定的方案
		
只有except的错误类型符合才会执行，反之不会执行，如果都不符合，则会报错
'''
try:
    name = 'jason'
    print(nama)
except IndexError as e:
    print('索引错误')  
    print(e)    

except TypeError as e:
    print('类型错误')  
    print(e)    

except NameError as e:
    print('名字未定义')  # 名字未定义
    print(e)    # name 'nama' is not defined

1|04、万能异常

'''
使用Exception/BaseException
语法结构：
	try:
		待检测的代码 （自己无法控制，且有可能出现的错误的代码）
	except Exception as e:
		print(e)
'''
try:
    name = 'jason'
    print(nama)
except Exception as e:
    print(e)    # name 'nama' is not defined

1|05、结合else使用

'''
语法结构：
	try:
		待检测的代码 （自己无法控制，且有可能出现的错误的代码）
	except Exception as e:
		print(e)
	else:
		try的子代码正常运行结束，没有任何的报错后，执行else子代码
'''
try:
    name = 'jason'
    print(name)         #jason
except Exception as e:
    print(e)    
else:
    print('No problem')     # No problem

1|06、结合finally使用

'''
语法结构：
	try:
		待检测的代码 （自己无法控制，且有可能出现的错误的代码）
	except Exception as e:
		print(e)
	else:
		try的子代码正常运行结束，没有任何的报错后，执行else子代码
	finally：
		无论try的子代码是否报错，最后都要执行finally的子代码
'''

try:
    name = 'jason'
    print(nama)
except Exception as e:
    print(e)                # name 'nama' is not defined
else:
    print('No problem')     
finally:
    print('it\'s cool')     # it's cool

1|3异常处理补充

1|01、断言

'''
assert  (断言)
isinstance() 内置函数，用来判断一个对象的变量类型
语法结构：
	assert 需要断言的代码
'''
name = 'jason'
assert isinstance(name, str)
print('是字符串类型的话，就执行我吧') # 是字符串类型的话，就执行我吧

1|02、主动抛异常

'''
raise Exception('抛出的异常错误类型')
'''
name = 'jason'
if name == 'jason':
    raise Exception('抛出异常') # Exception: 抛出异常
else:
    print('正常执行')

1|4异常处理实战应用

1|01、异常处理使用场景

'''
1、异常处理能尽量少用就少用
2、被try监测的代码能少，就尽量少
3、当代码中可能会出现一些无法控制的情况下，才应该考虑使用
'''

1|02、使用异常处理的示例

'''
使用while循环+异常处理+迭代器对象，完成for循环迭代取值的功能
'''
list_one = [11, 22, 33, 44, 55, 66]
def next():
    res = list_one.__iter__()
    while True:
     print(res.__next__())
try:
    while True:
        next()
except StopIteration as e:
    print(e)

1|5生成器对象

1|01、本质

'''
	还是内置有__iter__和__next__的迭代器对象
'''

1|02、区别

'''
迭代器对象是解释器自动提供的
	数据类型/文件对象>>>:迭代器对象（生成器）
'''

1|03、创建生成器的基本语法

'''
函数体代码中填写yield关键字
注意事项：
	1、函数体代码中如果有yield关键字，那么函数名()就不会执行函数体代码，而是会生成一个生成器对象（迭代器对象）
	2、使用加括号之后的结果调用__next__才会执行函数体代码
	3、每次执行完__next__代码都会停留在yield位置，下次基于该位置继续前往找第二个yield
	4、yield还有点类似于return，可以返回返回值
'''
def print_some():
    print('1')
    yield
    print('2')
    yield
    print('3')
    yield
    print('4')
    yield
    print('5')
    yield
    print('6')
    yield
res = print_some()
a = res.__next__()  # 1
print(a)    # a接收返回值11
res.__next__()  # 2
res.__next__()  # 3
res.__next__()  # 4
res.__next__()  # 5
res.__next__()  # 6

1|6生成器示例

'''
自定义生成器对标range功能(一个参数 两个参数 三个参数 迭代器对象)
1.先写两个参数的
2.再写一个参数的
3.最后写三个参数
'''
def my_range(start_number, end_number=None, step=1):
    if not end_number:
        end_number = start_number
        start_number = 0
    while start_number < end_number:
        yield start_number
        start_number += step

for i in my_range(1, 10, 2):
    print(i)

1|7yield冷门用法

def eat(name, food=None):
    print(f'{name}准备用餐')
    while True:
        food = yield
        print(f'{name}正在吃{food}')


res = eat('jason')
res.__next__()
res.send('奥力给')  # 1.将括号内的数据传给yield前面的变量名 2.再自动调用__next__
res.send('力奥给')
res.send('给奥力')

1|8生成器表达式

'''
生成器的简化写法
'''
# list_one = [i ** 2 for i in range(100)]
# print(list_one)


list_one = (i ** 2 for i in range(100))  # 生成器对象
print(list_one)  # <generator object <genexpr> at 0x000002B31A7B6570>
for i in list_one:
    print(i)

示例：

 
"""
(有难度)
	大致知道流程即可
"""
def add(n, i):  # 普通函数 返回两个数的和  求和函数
    return n + i
def test():  # 生成器
    for i in range(4):
        yield i
g = test()  # 激活生成器
for n in [1, 10]:
    g = (add(n, i) for i in g)
    """
    第一次for循环
        g = (add(n, i) for i in g)
    第二次for循环
        g = (add(10, i) for i in (add(10, i) for i in g))
    """
res = list(g)
print(res)

#A. res=[10,11,12,13]
#B. res=[11,12,13,14]
#C. res=[20,21,22,23]
#D. res=[21,22,23,24]
'''不用深入研究 大致知道起始数即可'''

1|9索引取值与迭代器的差异

'''
1、索引取值：
	可以在任意位置，任意次数的取值，不支持无序类型的数据取值

2、迭代取值：
	只能从前往后的依次取值，一旦开始取值无法后退，并且支持所有的类型取值（无序、有序）

两者的使用场景，需要结合实际的应用
'''

1|10模块简介

1|01、模块的本质

'''
模块是指内部具有一定功能代码的py文件
'''

1|02、python模块的表现形式

'''
1、py文件，也可称为模块文件
2、含有多个py文件的文佳夹
3、已经被编译为共享库或者DLL的c、c++扩展
4、使用c编写并链接到python的内置模块
'''

1|11模块的分类

'''
1、自定义模块：
	我们自己所编写的模块文件

2、内置模块
	python解释器提供的模块

3、第三方模块
	别人写的py模块文件
'''

1|12导入模块的两种句式

1|01、导入前要知道的事情

'''
强调：
	1、一定要知道，谁是执行文件，谁知被导入文件
	
	2、项目里面py文件的名称一般要用纯英文（最好不要用中文和空格）
	
	3、导入模块文件不需要填写后缀名
'''

1|02、import句式

'''
底层原理
1、先产生执行文件的名称空间
2、执行被导入文件的代码，将产生的名字放入被导入文件的空间名称中
3、在执行文件的名称空间中产生一个模块的名字
4、在执行文件中使用该模块名加点的方式，使用名称空间中所有的名字

语法格式：
	import 被导入的模块的文件名
'''
import user

1|03、from...import...句式

'''
1、先产生执行文件的名称空间
2、执行被导入文件的代码，将产生的名字放入被导入文件的空间名称中
3、在执行文件的名称空间中产生对应的名字绑定模块名称空间中对应的名字
4、在执行文件中直接使用名字就可以访问名称空间中对应的名字

语法格式：
	from 需要导入的模块的文件名  import 需要使用的被导入模块内的名字
	
	from 需要导入的模块的文件名  import * （*默认是将模块名空间中所有的名字都导入）
	__all__ = ['名字1'， ’名字2] （此方法可以限制*可以拿到名字）
'''
from user import name

1|13导入模块补充说明

1|01、重复导入模块

'''
	解释器只会导入一次，后续重复导入的语句并不会执行
'''

1|02、起别名

'''
语法格式：
	import 被导入的模块的文件名 as 需要的名字
	
	from 需要导入的模块的文件名  import 需要使用的被导入模块内的名字 as 需要的名字
'''

1|03、涉及到多个模块的导入

'''
	可以将多个模块的文件名写在同一个import后面，中间用,号隔开
	如果两个模块的功能相似，可以使用上述方法，功能相似度不高建议还是分开导入
'''
import user, manager

1|14循环导入问题

1、循环导入
	两个文件之间彼此导入，彼此相互使用各自名称空间中的名字
2、循环导入时的问题
	如果我们所需要使用的名字在使用之前并没有准备好，那么就会出现无法找到名字的情况，就会报错
	解决方法：在使用之前，确保使用的名字准备完毕
3、在我们日常编码的过程中，应该尽量的避免使用循环导入

1|15判断文件类型

'''
__name__
	所有的py文件都可以直接打印__name__的对应的值
	eg：
		当py文件时执行文件的时候，__name__所对应的值时__main__
		
		当py文件是被导入文件的时候__name__对应的值是模块名

可以区分py文件是执行文件还是被导入文件的语法：
	if__name__ ==  '__main__'
		子代码
上述代码在py文件为执行文件的时候会运行子代码

使用场景：
	1、模块的开发阶段
	2、项目启动文件
'''

1|16模块的查找顺序

'''
1、先从内存中找 

2、再从内置模块中找

3、最后从sys.path中找（环境变量）一定要分清楚谁是执行文件谁是被导入文件

sys返回的是一个列表，里面放了一些文件的路径，但是第一个路径永远是文件所在的文件夹

注意：py文件的文件名不应该与模块名(内置的、第三方的)冲突
'''

1|17绝对导入和相对导入

1|0绝对导入

'''
绝对导入：
	类似于绝对路径，把所需要导入的模块的地址一层层的写进去：
	语法格式：
		from 路径 import 模块名
	书写的流程就是按照项目根目录一层层的点下去
'''

1|0相对导入

'''
相对导入：
	.	在路径中表示当前目录
	..	表示上一层目录
	..\..	表示上上一层目录
	不在一句执行文件所在的sys.path（系统环境变量）而是以模块自身的路径为准
	语法格式：
		from . import user
相对导入只能使用于模块文件中，不能再执行文件中使用
相对导入使用的频率较低，一般使用绝对导入即可，结构更加清晰
'''

1|18包

'''
可以理解为多个py文件的集合，即文件夹

	内部含有__init__.py文件的文件夹（python2必须要求、python3中无所谓）
'''                 

1|19包的具体使用

'''
	虽然在python3中对包的要求低了，不需要__init__.py文件也可以识别，但是为了兼容性考虑，我们最好还是要加上__init__.py
	1、如果只想用包中的某几个模块，还可以按照之前的导入方式导入
	2、直接导入包名
		导入包名其实是导入了包下面的__init__.py文件，我们点的方式只能使用该文件内的名字，如果要使用其他模块，需要在__init__.py中导入相应的模块
'''

1|20软件开发目录规范

'''
1、文件以及目录的名字是可以变换的，但是思想时不变的，分类管理
2、目录规范主要规定开发过程中针对不同的文件功能需要做不同的分类

目录规范格式：
	MyProject项目文件夹
		1、bin文件夹	主要存放项目启动文件
			 start.py （启动文件可以放在bin目录下，也可以直接在项目的根目录下）
		2、conf文件夹	主要存放项目的配置文件
       		settings.py （里面存放新项目的默认配置，一般都是大写）
       
       3、core文件夹	主要存放项目核心文件
       		src.py 		（里面存放项目核心功能）
       4、interface文件夹	主要存放项目接口文件
       		goods.py、user.py、account.py （根据具体业务逻辑划分相应的文件）
       5、db文件夹	主要存放项目相关数据
       		userinfo.txt
       		db_handler.py 	存放数据库操作相关的代码
       6、log文件夹		主要存放项目日志文件
       7、lib文件夹		主要存放项目公共功能
       8、readme文件	 主要存放项目相关说明
       9、requirements.txt文件		主要存放项目所需模板及版本
'''

1|21常用内置模块

1|0collections模块

1|01、具名元组：namedtuple

'''
具名元组：namedtuple
	导入语法结构:
		from collections import namedtuple
'''
from collections import namedtuple
card = namedtuple('扑克牌', ['number', 'type'])
user_one = card('Q', '黑桃')
user_two = card('K', '红心')
print(user_one, user_two)
print(user_one.number, user_two.number)
print(user_one.type, user_two.type)

1|02、队列和堆栈

'''
队列：先进先出
堆栈：先进后出

队列和堆栈都是只有一边只能进，一边只能出
'''

1|03、双端队列deque

from collections import deque
a = deque()
a.append(11)
a.append(22)
a.appendleft(999)
print(a)         # deque([999, 11, 22])

1|04、有序字典OrderedDict

from collections import OrderedDict
dict_one = dict([('a',1),('b',2),('c',3)])
print(dict_one)                     # {'a': 1, 'b': 2, 'c': 3}
o_dict = OrderedDict([('a',1),('b',2),('c',3)])
print(o_dict)                    # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

1|05、计数Counter

from collections import Counter
res = '2131236jhjjad'
res1 = Counter(res)
print(res1)  # Counter({'j': 3, '2': 2, '1': 2, '3': 2, '6': 1, 'h': 1, 'a': 1, 'd': 1})

1|0时间模块

'''
时间的三种表现形式
	1、时间戳
	2、结构化时间 （主要是给计算机使用）
	3、格式化时间 （主要是给人看的）
'''
import time
# .time 时间戳
print(time.time())  # 1666169340.9480226
# .localtime 结构化时间
print(time.localtime()) # time.struct_time
# (tm_year=2022, tm_mon=10, tm_mday=19, tm_hour=16, tm_min=49, tm_sec=0,
# tm_wday=2, tm_yday=292, tm_isdst=0)


print(time.strftime('%Y-%m-%d'))        # 2022-10-19
print(time.strftime('%Y-%m-%d %H:%M:%S'))   # 2022-10-19 17:56:10
print(time.strftime('%Y-%m-%d %X'))     # 2022-10-19 17:56:10

'''
# strptime 按照特定时间格式将字符串转换为时间类型
'''
from datetime import datetime
Time = datetime.strptime('1314/5/20', '%Y/%m/%d')
print(Time)  # 1314-05-20 00:00:00
Time1 = datetime.strptime('1314年5月20日星期六', '%Y年%m月%d日星期六')
print(Time1)    # 1314-05-20 00:00:00
Time2 = datetime.strptime('1314年5月20日星期六8时8分8秒', '%Y年%m月%d日星期六%H时%M分%S秒')
print(Time2)    # 1314-05-20 00:00:00

1|0随机数模块

1|0random

'''
random随机数模块常用方法：
'''
import random
print(random.random())  # 0.09466450124602899 随机产生0到1之间的小数
print(random.randint(0, 8))  # 0  随机产生0到8之间的整数
print(random.randrange(0, 88, 2))   # 随机产生指定的整数
print(random.choice(['100W', '200W', '1000W', '0']))    # 1000W 随机抽取一个样本
print(random.choices(['999w', '888w', '666w']))  # ['999w'] 随机抽取一个样本
print(random.sample(['Maria', 'Tank', 'Tony', 'Tom', 'Sandy'], 3))  # ['Maria', 'Tony', 'Tank'] 随机抽指定样本数
card = ['A', '2', '3', '4', '5', '6', '7', '8', '9', 'J', 'Q', 'K', 'Queen', 'King']
random.shuffle(card)   # 随机打乱数据集
print(card)  # ['8', 'Q', '2', '4', 'Queen', 'J', 'A', '3', '6', '5', '7', '9', 'King', 'K']

1|0图片验证码

'''
产生图片验证码：每一位都可以是大写字母、小写字母、数字、4位
'''
import random
def get_code(n):
    code = ''
    for i in range(n):
        number = str(random.randint(0, 9))
        upper_number = chr(random.randint(97, 122))
        lower_number = chr(random.randint(65, 90))
        temp = random.choice([number, upper_number, lower_number])
        code += temp
    return code

res = get_code(26)
print(res)  # 72mlgC8eRimd1j51Kef4xVpyt2

res = get_code(4)
print(res)  # iisb

1|22os模块

1|01、os.mkdir() 创建目录(文件夹)

'''
语法结构：
	import os
	os.mkdir()
	os.makedirs() 
r的作用是让\起作用
'''
import os
os.mkdir(r'练习1020')  # 在同一级中创建一个目录，该方法不可创建多级目录
os.makedirs(r'作业1020\作业')  # 在同一级中创建一个多级目录，也可以创建单级目录

1|02、os.rmdir() 删除目录(文件夹)

'''
语法结构：
	import os
	os.rmdir()
	os.removedirs() 
r的作用是让\起作用
'''
import os
os.rmdir(r'练习1020')     # 在同一级中删除一个目录，该方法不可删除多级目录
os.removedirs(r'作业1020\作业')     #   在同一级中删除一个多级目录，也可以删除单级目录

1|03、os.listdir() 列举指定路径下内容名称

'''
语法结构：
	import os
	os.listdir()
'''
import os
res = os.listdir(r'D:\\')   # 显示指定路径下所有的文件夹（目录）
print(res)

1|04、os.rename() 重命名文件

'''
语法结构：
	import os
	os.rename()
'''
import os
os.rename(r'a.txt', r'aaa.txt')   # 重命名文件名，将a.txt重命名为aaa.txt

1|05、os.remove() 删除文件

'''
语法结构：
	import os
	os.remove()
'''
import os
os.remove(r'a')  #  删除文件 

1|06、os.getcwd() 获取当前工作目录

'''
语法结构：
	import os
	os.getcwd()
'''
import os
res = os.getcwd()
print(res)  # D:\pycharm\demo\chap5 获取当前代码运行所在的目录

1|07、 os.chdir() 切换当前工作目录

'''
语法结构：
	import os
	os.chdir()
'''
import os
os.chdir('..')
print(os.getcwd())  # D:\pycharm\demo 返回到当前代码运行所在的目录的上一级目录

1|08、动态获取项目根路径(It's importent)

'''
语法结构：
	import os
	os.path.dirname(__file__)	# 获取执行文件的所在目录
	os.path.abspath(__file__)	# 获取执行文件的绝对路径
'''
res = os.path.dirname(__file__)	 # D:\pycharm\demo\chap5
print(res)
res = os.path.abspath(__file__)  # D:\pycharm\demo\chap5\模块1020.py
print(res)

1|09、判断路径是否存在（文件、目录）

'''
语法结构：
	import os
	os.path.exists()	#  判断文件路径是否存在  True
	os.path.isfile()	#  判断路径是否是文件
'''
import os
res = os.path.exists(r'aaa.txt')
print(res)  # True
res = os.path.isfile(r'aaa.txt')
print(res)  # True
print(os.path.isdir(r'aaa.txt'))    # False 

1|010、路径拼接(It's importent)

'''
涉及到路径的拼接，一定不要自己做，因为不同的操作系统路径分隔符不一样
语法结构：
	impor os
	os.path.join( , )
'''
import os
string_one = os.path.dirname(__file__)
print(string_one)   # D:\pycharm\demo\chap5
string_two = 'aaa.txt'
print(string_two)   # aaa.txt
string_three = os.path.join(string_one, string_two)
print(string_three)  # D:\pycharm\demo\chap5\aaa.txt

1|011、获取文件大小（字节）

'''
语法结构：
	impor os
	os.path.getsize()
'''
print(os.path.getsize(r'aaa.txt'))  # 1415

1|23sys模块

1|01、获取执行文件的sys.path

'''
语法结构：
	import sys
	sys.path # 获取执行文件的sys.path
'''
import sys

print(sys.path)

1|02、获取python解释器最大递归深度

'''
语法结构：
	import sys
	sys.gettrecursionlimit()
'''
import sys

print(sys.getrecursionlimit())  # 1000

1|03、修改python解释器默认最大递归深度

'''
语法结构：
	import sys
	sys.setrecursionlimit()
'''
import sys

sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())  # 2000

1|04、查看平台信息（了解即可）

'''
语法结构：
	sys.platform
'''
import sys
print(sys.platform)  # win32

1|24json模块

'''
	json模块也称为序列化模块，序列化可以打破语言限制，实现不同编程语言之间的数据交互
	
	json格式数据的形式：
		1、都是字符串类型
		2、引号都是双引号
	
	json相关操作：
		针对数据
		json.dumps()
		
		针对文件
		json.dump()
		json.load()
		
	json.dumps()和json.loads()是json格式处理函数（可以这么理解，json是字符串）
　　(1)json.dumps()函数是将一个Python数据类型列表进行json格式的编码（可以这么理解，json.dumps()函数是将字典转化为字符串）
　　(2)json.loads()函数是将json格式数据转换为字典（可以这么理解，json.loads()函数是将字符串转化为字典）
	json.dump()和json.load()主要用来读写json文件函数
	
总结:
    res=json.loads(var) var为变量
    res=json.load(file) file为文件路径
    res都为字典类型
'''

__EOF__

本文作者：少年奇妙游
本文链接：https://www.cnblogs.com/HaiMan/p/16819655.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！