数据类型分类，深浅拷贝

数据类型分类，深浅拷贝
一、按存值个数区分

存值个数数据类型

单个值数字，字符串

多个值(容器) 列表，元组，字典，集合

二、按可变不可变区分

可变or不可变数据类型

可变列表，字典，集合

不可变数字，字符串，元组

三、有序无序区分

有序or无序数据类型

有序(可按索引取值) 字符串，列表，元组

不可变字典，集合

四、按访问类型区分

访问类型数据类型

直接访问数字

顺序访问(序列类型) 字符串，列表，元组

key值访问(映射类型) 字典

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

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

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

1.1、可变or不可变

id不变值可变，即在原值的基础上修改，则为可变数据类型；值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。
```
 age = 19
 print(f'first:{id(age)}')
 age = 20
 print(f'second:{id(age)}')
 first:4384901776
 second:4384901808
```
二、拷贝

如果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']
```
三、浅拷贝

如果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']]
```
四、深拷贝

如果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']]
```
一、什么是异常
- 异常就是程序运行时发生错误的信号（在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止），在python中，错误触发的异常如下
1.1 语法错误

语法错误，根本过不了python解释器的语法检测，必须在程序执行前就改正。
```
 # 语法错误示范一
 if
 
 # 语法错误示范二
 def test:
     pass
 
 # 语法错误示范三
 class Foo
     pass
 
 # 语法错误示范四
 print(haha
```
1.2 逻辑错误
```
 # TypeError:int类型不可迭代
 for i in 3:
     pass
 
 # ValueError
 num=input(">>: ") #输入hello
 int(num)
 
 # NameError
 aaa
 
 # IndexError
 l=['egon','aa']
 l[3]
 
 # KeyError
 dic={'name':'egon'}
 dic['age']
 
 # AttributeError
 class Foo:pass
 Foo.x
 
 # ZeroDivisionError:无法完成计算
 res1=1/0
 res2=1+'str'
```
二、异常的种类

在python中不同的异常可以用不同的类型（python中统一了类与类型，类型即类）去标识，一个异常标识一种错误。

2.1 常用异常
- AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
- IOError 输入/输出异常；基本上是无法打开文件
- ImportError 无法引入模块或包；基本上是路径问题或名称错误
- IndentationError 语法错误（的子类）；代码没有正确对齐
- IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
- KeyError 试图访问字典里不存在的键
- KeyboardInterrupt Ctrl+C被按下
- NameError 使用一个还未被赋予对象的变量
- SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
- TypeError 传入对象类型与要求的不符合
- UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
- ValueError 传入一个调用者不期望的值，即使值的类型是正确的
2.2 其他异常
- ArithmeticError
- AssertionError
- AttributeError
- BaseException
- BufferError
- BytesWarning
- DeprecationWarning
- EnvironmentError
- EOFError
- Exception
- FloatingPointError
- FutureWarning
- GeneratorExit
- ImportError
- ImportWarning
- IndentationError
- IndexError
- IOError
- KeyboardInterrupt
- KeyError
- LookupError
- MemoryError
- NameError
- NotImplementedError
- OSError
- OverflowError
- PendingDeprecationWarning
- ReferenceError
- RuntimeError
- RuntimeWarning
- StandardError
- StopIteration
- SyntaxError
- SyntaxWarning
- SystemError
- SystemExit
- TabError
- TypeError
- UnboundLocalError
- UnicodeDecodeError
- UnicodeEncodeError
- UnicodeError
- UnicodeTranslateError
- UnicodeWarning
- UserWarning
- ValueError
- Warning
- ZeroDivisionError
三、异常处理

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

3.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
```
3.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('无论异常与否，都会执行该模块，通常是进行清理工作')
```
四、try...except总结
1. 把错误处理和真正的工作分开来
2. 代码更易组织，更清晰，复杂的工作任务更容易实现；
3. 毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；
五、抛出异常raise
```
 try:
     raise TypeError('抛出异常，类型错误')
 except Exception as e:
     print(e)
```
5.1 自定义异常
```
 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)
```
六、断言assert
```
 assert 1 == 1
 try: 
     assert 1 == 2
 except Exception as e:
     print(e)
```
虽然视频、音频和图片在硬盘中也是用二进制存储的，但是上一章节讲的字符编码只和文本文件有关，因为‘utf-8’格式的编码并不使用视频，视频有其本身的编码格式，如MP4、avi、mkv等。

一、什么是文件？

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

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

二、为什么要有文件？

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

三、如何用文件？

现在我们有一个需求需要把用户输入的账号密码存储到硬盘中，我们使用Python该如何操作呢？
```
 name = 'nick'
 pwd = '123'
```
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.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'
```
四、总结

打开文件总而言之分为三步：
1. 打开文件
2. 读写
3. 关闭
一、绝对路径
- Windows系统绝对路径从盘符（C:、D:）开始写一个完整的路径。
- macos系统从根目录(/Users)开始写一个完整的路径。
二、相对路径

相对于当前执行文件所在的文件夹开始找。
```
 f = open('32.txt')  # 32.txt与该.md文档同路径位置
```
相关阅读:
微信运营
 1.数据库&SQL语言
 16.线程
 15.IO流
 14.异常
 13.集合
 12.常用类
 11.String类-StringBuffer类、StringBuilder类
 10.Object类-包装类-内部类
 9.接口
原文地址：https://www.cnblogs.com/TMesh/p/11315487.html

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

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

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

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