第一阶段：Python开发基础 day09 Python基础语法入门--数据类型分类深浅拷贝文件的使用

目录

• 上节课内容回顾
  • 列表类型的内置方法
  • 元组类型的内置方法
  • 字典类型的内置方法
  • 集合类型的内置方法
• 一、深浅拷贝
  • 1.1、引言
  • 1.2、可变or 不可变
  • 1.3、拷贝
  • 1.4、浅拷贝
  • 1.5、深拷贝
• 二、数据类型分类
  • 2.1、 按存值个数区分
  • 2.2、按可变不可变区分
  • 2.3、有序无序区分
  • 2.4、按访问类型区分
  • 2.5、各种数据类型的内置方法
• 三、基本的文件操作
  • 3.1、什么是文件？
  • 3.2、为什么要有文件？
  • 3.3、如何用文件？
  • 3.4、总结
• 四、异常处理
  • 4.1 提前预防
  • 4.2 之后预防
  • 4.3、try...except总结
  • 4.4、抛出异常raise
  • 4.5、 自定义异常
  • 4.6、断言assert
• 阶段性小结程序
• 今日小结

上节课内容回顾

列表类型的内置方法

• 优先掌握
  • 按索引取值（正向取值+反向取值），即可存也可以取
  • 切片
  • 长度len
  • 成员运算in 和 not in
  • 追加 append
  • 删除 del
  • for 循环
• 需要掌握
  • insert
  • pop
  • remove
  • count
  • index
  • clear
  • copy
  • extend
  • reverse
  • sort 排序

元组类型的内置方法

• 优先掌握

  • 索引取值
  • 切片（顾头不顾尾，步长）
  • 长度 len
  • 成员运算 in 和 not in
  • 循环
  • count
  • index

• 元组和列表的区别

  列表可变的原因是：索引所对应的值的内存地址是可以改变的

  元组不可变得原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的。

字典类型的内置方法

• 优先掌握
  • 按key存取值：可存可取
  • 长度len
  • 成员运算 in 和 not in
  • 删除 del
  • 键 keys()、值values()、键值对 items()
  • 循环
• 需要掌握
  • get
  • update
  • fromkeys
  • setdefault

集合类型的内置方法

• 优先掌握

  • 长度len
  • 成员运算 in 和 not in
  • | 并集、union
  • & 交集、intersection
  • -差集、difference
  • ^ 对称差集、symmetric_difference
  • ==
  • 父集：>、>=、issuperset
  • 子集：<、<=、issubset

• 需要掌握

  • add
  • remove
  • difference_update
  • discard
  • isdisjoint

一、深浅拷贝

1.1、引言

在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。

针对该列表lt = ['a'.'b','c',['d','e','f']] 一般有三种方法，分别为：拷贝（赋值）、浅拷贝、深拷贝

注意：拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的

1.2、可变or 不可变

id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。

age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')
first:4384901776
second:4384901808

1.3、拷贝

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1

l1.append('g')

print(l1)
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)
['a', 'b', 'c', ['d', 'e', 'f'], 'g']

1.4、浅拷贝

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)
['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('g')

print(l1)
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
print(l2)
['a', 'b', 'c', ['d', 'e', 'f', 'g']]

1.5、深拷贝

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
print(l2)
['a', 'b', 'c', ['d', 'e', 'f']]
l1[3].append('g')

print(l1)
['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
print(l2)
['a', 'b', 'c', ['d', 'e', 'f']]

二、数据类型分类

2.1、 按存值个数区分

存值个数	数据类型
单个值	数字，字符串
多个值(容器)	列表，元组，字典，集合

2.2、按可变不可变区分

可变or不可变	数据类型
可变	列表，字典，集合
不可变	数字，字符串，元组

2.3、有序无序区分

有序or无序	数据类型
有序(可按索引取值)	字符串，列表，元组
不可变	字典，集合

2.4、按访问类型区分

访问类型	数据类型
直接访问	数字
顺序访问(序列类型)	字符串，列表，元组
key值访问(映射类型)	字典

2.5、各种数据类型的内置方法

数值类型和字符串类型的内置方法

列表元组字典集合类型的内置方法

三、基本的文件操作

虽然视频、音频和图片在硬盘中也是用二进制存储的，但是上一章节讲的字符编码只和文本文件有关，因为‘utf-8’格式的编码并不使用视频，视频有其本身的编码格式，如MP4、avi、mkv等。

3.1、什么是文件？

文件是操作系统为用户或应用程序提供的一个读写硬盘的虚拟单位。文件的操作是基于文件，即文件的操作核心就是：读和写。也

就是只要我们想要操作文件就是对操作系统发起请求，然后由操作系统将用户或应用程序对文件的读写操作转换成集体的硬盘指令（比如控制盘片转动，控制机械手臂移动，以此来读取数据)。

3.2、为什么要有文件？

内存无法永久保存数据，但凡我们想要永久保存数据都需要把文件保存到硬盘中，而操作文件就可以实现对硬件的操作。

3.3、如何用文件？

现在我们有一个需求需要把用户输入的账号密码存储到硬盘中，我们使用Python该如何操作呢？

name = 'nick'
pwd = '123'

3.3.1 从硬盘中读取数据

如果我们需要打开一个文件，需要向操作系统发起请求，要求操作系统打开文件，占用操作系统资源。Python中使用open()方法可以打开某个具体的文件，open()方法内写入文件路径。

open(r'/Users/mac/desktop/jupyter/pythonCourseware/32.txt')

如果给列表增加值，我们需要给列表赋值后才能给对应的列表增加值。文件也是如此。

lis = [1,2,3]
lis.append(4)
lis.append(5)
# 打开文件
f = open(r'/Users/mac/desktop/jupyter/pythonCourseware/32.txt')
print(f)
<_io.TextIOWrapper name='/Users/mac/desktop/jupyter/pythonCourseware/32.txt' mode='r' encoding='UTF-8'>

打开文件之后，文件不仅占用了内存，他还对应了操作系统打开的以文件，相当于使用文本编辑器打开了一个文件。并且我们说了我们操控文件只是为了读和写，因此打开文件并不是目的，读和写才是目的，接下来我们尝试如何读写文件。

# read模式打开文件
f = open(r'/Users/mac/desktop/jupyter/pythonCourseware/32.txt', mode='r')
# 读取文件内容，向操作系统发起读请求，会被操作系统转成具体的硬盘操作，将内容由硬盘读入内存
data = f.read()
print(data)
# 由于Python的垃圾回收机制只回收引用计数为0的变量，但是打开文件还占用操作系统的资源，所以我们需要回收操作系统的资源资源
# del f 只是回收变量f
f.close()
name = 'nick'
pwd = '123'

3.3.2 写入数据

# write模式打开文件
f = open(r'/Users/mac/desktop/jupyter/pythonCourseware/32.txt', mode='w')
f.write("""name = 'nick'
pwd = '123'""")
f.close()
f = open(r'/Users/mac/desktop/jupyter/pythonCourseware/32.txt', mode='r')
data = f.read()
print(data)
name = 'nick'
pwd = '123'

3.4、总结

打开文件总而言之分为三步：

1. 打开文件
2. 读写
3. 关闭

四、异常处理

为了保证程序的健壮性与容错性，即在遇到错误时程序不会崩溃，我们需要对异常进行处理

4.1 提前预防

如果错误发生的条件是可预知的，我们需要用if进行处理：在错误发生之前进行预防

AGE = 10
while True:
    age = input('>>: ').strip()
    if age.isdigit():  # 只有在age为字符串形式的整数时，下列代码才不会出错，该条件是可预知的
        age = int(age)
        if age == AGE:
            print('you got it')
            break
>>: nick
>>: sdkf
>>: 2
>>: 10
you got it

4.2 之后预防

如果错误发生的条件是不可预知的，则需要用到try...except：在错误发生之后进行处理

#基本语法为
try:
    被检测的代码块
except 异常类型：
    try中一旦检测到异常，就执行这个位置的逻辑
#  举例
try:
    f = [
        'a',
        'a',
        'a',
        'a',
        'a',
        'a',
        'a',
    ]
    g = (line.strip() for line in f)
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
except StopIteration:
    f.close()
a
a
a
a
a

1.异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

s1 = 'hello'
try:
    int(s1)
except IndexError as e:  # 未捕获到异常，程序直接报错
    print(e)

2.多分支

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
invalid literal for int() with base 10: 'hello'

3.万能异常Exception

s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print(e)

4.多分支异常与万能异常

* 如果你想要的效果是，无论出现什么异常，我们统一丢弃，或者使用同一段代码逻辑去处理他们，那么骚年，大胆的去做吧，只有一个Exception就足够了。

* 如果你想要的效果是，对于不同的异常我们需要定制不同的处理逻辑，那就需要用到多分支了。

5.也可以在多分支后来一个Exception

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
except Exception as e:
    print(e)

6.异常的最终执行

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
#except Exception as e:
#    print(e)
else:
    print('try内代码块没有异常则执行我')
finally:
    print('无论异常与否，都会执行该模块，通常是进行清理工作')

4.3、try...except总结

1. 把错误处理和真正的工作分开来
2. 代码更易组织，更清晰，复杂的工作任务更容易实现；
3. 毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；

4.4、抛出异常raise

pythtry:
    raise TypeError('抛出异常，类型错误')
except Exception as e:
    print(e)

4.5、 自定义异常

class EgonException(BaseException):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return self.msg


try:
    raise EgonException('抛出异常，类型错误')
except EgonException as e:
    print(e)

4.6、断言assert

assert 1 == 1
try:
    assert 1 == 2
except Exception as e:
    print(e)

阶段性小结程序

猜年龄升级版

今日小结

今天我们讲了深浅拷贝和数据类型的分类以及基本文件的操作，学会了如何对文件进行打开、读、写操作以及关闭文件。这个对文件的操作对我们今后很多事情都有很大帮助，是一个比较重要的点。而且今天又重新讲解了一次异常判断，加深了对异常判断的理解和学习，在编程中能够更好地使用异常处理。