接着上篇接着讲，如需要看上篇的朋友下方了解更多，跳转
列表(list)
- 列表是一种无序的、可重复的数据序列，可以随时添加、删除其中的元素。
- 列表页的每个元素都分配一个数字索引，从 0 开始
- 列表使用方括号创建，使用逗号分隔元素
- 列表元素值可以是任意类型，包括变量
- 使用方括号对列表进行元素访问、切片、修改、删除等操作，开闭合区间为[)形式
- 列表的元素访问可以嵌套
- 方括号内可以是任意表达式
创建列表
hello = (1, 2, 3)
li = [1, "2", [3, 'a'], (1, 3), hello]
访问元素
li = [1, "2", [3, 'a'], (1, 3)]
print(li[3]) # (1, 3)
print(li[-2]) # [3, 'a']
切片访问
格式: list_name[begin:end:step] begin 表示起始位置(默认为0)，end 表示结束位置(默认为最后一个元素)，step 表示步长(默认为1)
hello = (1, 2, 3)
li = [1, "2", [3, 'a'], (1, 3), hello]
print(li) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:2]) # ['2']
print(li[:2]) # [1, '2']
print(li[:]) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[2:]) # [[3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:-1:2]) # ['2', (1, 3)]
访问内嵌 list 的元素：
li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ['a', 'b', 'c']]
- 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）
- 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
- 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。最后执行 try 语句之后的代码。
- 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
- 一个 try 语句可能包含多个 except 子句，分别来处理不同的特定的异常。
- 最多只有一个 except 子句会被执行。
- 处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
- 一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。
- 最后一个 except 子句可以忽略异常的名称，它将被当作通配符使用。可以使用这种方法打印一个错误信息，然后再次把异常抛出。
- try except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。这个子句将在 try 子句没有发生任何异常的时候执行。
- 异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。
- 不管 try 子句里面有没有发生异常，finally 子句都会执行。
- 如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。
抛出异常
使用 raise 语句抛出一个指定的异常。
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
自定义异常
可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承。
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类。
大多数的异常的名字都以”Error”结尾，就跟标准的异常命名一样。
实例
import sys
class Error(Exception):
"""Base class for exceptions in this module."""
pass
# 自定义异常
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
try:
print('code start running...')
raise InputError('input()', 'input error')
# ValueError
int('a')
# TypeError
s = 1 'a'
dit = {'name': 'john'}
# KeyError
print(dit['1'])
except InputError as ex:
print("InputError:", ex.message)
except TypeError as ex:
print('TypeError:', ex.args)
pass
except (KeyError, IndexError) as ex:
"""支持同时处理多个异常, 用括号放到元组里"""
print(sys.exc_info())
except:
"""捕获其他未指定的异常"""
print("Unexpected error:", sys.exc_info()[0])
# raise 用于抛出异常
raise RuntimeError('RuntimeError')
else:
"""当无任何异常时, 会执行 else 子句"""
print('"else" 子句...')
finally:
"""无论有无异常, 均会执行 finally"""
print('finally, ending')
文件操作
打开文件
open() 函数用于打开/创建一个文件，并返回一个 file 对象：
open(filename, mode)
- filename：包含了你要访问的文件名称的字符串值
- mode：决定了打开文件的模式：只读，写入，追加等
文件打开模式：
文件对象方法
- fileObject.close()
- close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作，否则会触发 ValueError 错误。 close() 方法允许调用多次。
- 当 file 对象，被引用到操作另外一个文件时，Python 会自动关闭之前的 file 对象。 使用 close() 方法关闭文件是一个好的习惯。
- fileObject.flush()
- flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
- 一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
- fileObject.fileno()
- fileno() 方法返回一个整型的文件描述符(file descriptor FD 整型)，可用于底层操作系统的 I/O 操作。
- fileObject.isatty()
- isatty() 方法检测文件是否连接到一个终端设备，如果是返回 True，否则返回 False。
- next(iterator[,default])
- Python 3 中的 File 对象不支持 next() 方法。 Python 3 的内置函数 next() 通过迭代器调用 __next__() 方法返回下一项。在循环中，next() 函数会在每次循环中调用，该方法返回文件的下一行，如果到达结尾(EOF)，则触发 StopIteration。
- fileObject.read()
- read() 方法用于从文件读取指定的字节数，如果未给定或为负则读取所有。
- fileObject.readline()
- readline() 方法用于从文件读取整行，包括 “\n” 字符。如果指定了一个非负数的参数，则返回指定大小的字节数，包括 “\n” 字符。
- fileObject.readlines()
- readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 Python 的 for... in ... 结构进行处理。如果碰到结束符 EOF，则返回空字符串。
- fileObject.seek(offset[, whence])
- seek() 方法用于移动文件读取指针到指定位置。
- whence 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾。whence 值为默认为0，即文件开头。例如：
- seek(x, 0)：从起始位置即文件首行首字符开始移动 x 个字符
- seek(x, 1)：表示从当前位置往后移动 x 个字符
- seek(-x, 2)：表示从文件的结尾往前移动 x 个字符
- fileObject.tell(offset[, whence])
- tell() 方法返回文件的当前位置，即文件指针当前位置。
- fileObject.truncate([size])
- truncate() 方法用于从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后 V 后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
- fileObject.write([str])
- write() 方法用于向文件中写入指定字符串。
- 在文件关闭前或缓冲区刷新前，字符串内容存储在缓冲区中，这时你在文件中是看不到写入的内容的。
- 如果文件打开模式带 b，那写入文件内容时，str (参数)要用 encode 方法转为 bytes 形式，否则报错：TypeError: a bytes-like object is required, not 'str'。
- fileObject.writelines([str])
- writelines() 方法用于向文件中写入一序列的字符串。这一序列字符串可以是由迭代对象产生的，如一个字符串列表。换行需要指定换行符 \n。
实例
filename = 'data.log'
# 打开文件(a 追加读写模式)
# 用 with 关键字的方式打开文件，会自动关闭文件资源
with open(filename, 'w ', encoding='utf-8') as file:
print('文件名称: {}'.format(file.name))
print('文件编码: {}'.format(file.encoding))
print('文件打开模式: {}'.format(file.mode))
print('文件是否可读: {}'.format(file.readable()))
print('文件是否可写: {}'.format(file.writable()))
print('此时文件指针位置为: {}'.format(file.tell()))
# 写入内容
num = file.write("第一行内容\n")
print('写入文件 {} 个字符'.format(num))
# 文件指针在文件尾部，故无内容
print(file.readline(), file.tell())
# 改变文件指针到文件头部
file.seek(0)
# 改变文件指针后，读取到第一行内容
print(file.readline(), file.tell())
# 但文件指针的改变，却不会影响到写入的位置
file.write('第二次写入的内容\n')
# 文件指针又回到了文件尾
print(file.readline(), file.tell())
# file.read() 从当前文件指针位置读取指定长度的字符
file.seek(0)
print(file.read(9))
# 按行分割文件，返回字符串列表
file.seek(0)
print(file.readlines())
# 迭代文件对象，一行一个元素
file.seek(0)
for line in file:
print(line, end='')
# 关闭文件资源
if not file.closed:
file.close()
输出：
文件名称: data.log
文件编码: utf-8
文件打开模式: w
文件是否可读: True
文件是否可写: True
此时文件指针位置为: 0
写入文件 6 个字符
16
第一行内容
16
41
第一行内容
第二次
['第一行内容\n', '第二次写入的内容\n']
第一行内容
第二次写入的内容
序列化
在 Python 中 pickle 模块实现对数据的序列化和反序列化。pickle 支持任何数据类型，包括内置数据类型、函数、类、对象等。
方法
dump
将数据对象序列化后写入文件
pickle.dump(obj, file, protocol=None, fix_imports=True)
必填参数 obj 表示将要封装的对象。 必填参数 file 表示 obj 要写入的文件对象，file 必须以二进制可写模式打开，即wb。 可选参数 protocol 表示告知 pickle 使用的协议，支持的协议有 0,1,2,3，默认的协议是添加在 Python 3 中的协议3。
load
从文件中读取内容并反序列化
pickle.load(file, fix_imports=True, encoding='ASCII', errors='strict')
必填参数 file 必须以二进制可读模式打开，即rb，其他都为可选参数。
dumps
以字节对象形式返回封装的对象，不需要写入文件中
pickle.dumps(obj, protocol=None, fix_imports=True)
loads
从字节对象中读取被封装的对象，并返回
pickle.loads(bytes_object, fix_imports=True, encoding='ASCII', errors='strict')
实例
import pickle
data = [1, 2, 3]
# 序列化数据并以字节对象返回
dumps_obj = pickle.dumps(data)
print('pickle.dumps():', dumps_obj)
# 从字节对象中反序列化数据
loads_data = pickle.loads(dumps_obj)
print('pickle.loads():', loads_data)
filename = 'data.log'
# 序列化数据到文件中
with open(filename, 'wb') as file:
pickle.dump(data, file)
# 从文件中加载并反序列化
with open(filename, 'rb') as file:
load_data = pickle.load(file)
print('pickle.load():', load_data)
输出：
pickle.dumps(): b'\x80\x03]q\x00(K\x01K\x02K\x03e.'
pickle.loads(): [1, 2, 3]
pickle.load(): [1, 2, 3]
命名规范
Python 之父 Guido 推荐的规范
要是有小伙伴看不懂的话可以找老师领取视频教学资料，联系我即可,
