优效学院,大数据,人工智能,Java,架构,在线教育

接着上篇接着讲,如需要看上篇的朋友下方了解更多,跳转

列表(list)

创建列表

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:决定了打开文件的模式:只读,写入,追加等

文件打开模式:

python3.8.5零基础入门教程(Python3入门)(1)

文件对象方法

  • 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 推荐的规范

python3.8.5零基础入门教程(Python3入门)(2)

要是有小伙伴看不懂的话可以找老师领取视频教学资料,联系我即可

,