day 09总结（数据类型分类、Python深浅拷贝、异常处理、基本文件处理、绝对路径和相对路径）...

叁歲伎倆 2021-11-01 03:08 205阅读 0赞

# 一、数据类型分类 #

## 1.按存值个数区分 ##

## 2.按可变不可变区分 ##

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;">可变or不可变</th> 
   <th style="text-align:left;">数据类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">可变</td> 
   <td style="text-align:left;">列表，字典，集合</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">不可变</td> 
   <td style="text-align:left;">数字，字符串，元组</td> 
  </tr> 
 </tbody> 
</table>

## 3.有序无序区分 ##

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;">有序or无序</th> 
   <th style="text-align:left;">数据类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">有序（可按索引取值）</td> 
   <td style="text-align:left;">字符串，列表，元组</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">无序</td> 
   <td style="text-align:left;">字典，集合</td> 
  </tr> 
 </tbody> 
</table>

## 4.按访问类型区分 ##

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;">访问类型</th> 
   <th style="text-align:left;">数据类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="text-align:center;">直接访问</td> 
   <td style="text-align:left;">数字</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">顺序访问（序列类型）</td> 
   <td style="text-align:left;">列表，元组，字符串</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;">key值访问（映射类型）</td> 
   <td style="text-align:left;">字典</td> 
  </tr> 
 </tbody> 
</table>

## 6.六大数据类型内置方法 ##

1.  数字类型内置方法
2.  字符串类型内置方法
3.  列表类型内置方法
4.  元组类型内置方法
5.  字典类型内置方法
6.  集合类型内置方法

# 二、Python深浅拷贝 #

当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用针对该列表`l1=['a'，'b'，'c'，['d'，'e'，'f']]`一般有三种方法，分别为：拷贝（赋值）、浅拷贝、深拷贝

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

## 1.拷贝 ##

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

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

['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    ['a', 'b', 'c', ['d', 'e', 'f'], 'g']

## 2.浅拷贝 ##

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

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

['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    ['a', 'b', 'c', ['d', 'e', 'f']]
    ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
    ['a', 'b', 'c', ['d', 'e', 'f', 'g']]

## 3.深拷贝 ##

如果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)
    
    print(l2)
    
    l1[3].append('g')
    
    print(l1)
    
    print(l2)

['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    ['a', 'b', 'c', ['d', 'e', 'f']]
    ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
    ['a', 'b', 'c', ['d', 'e', 'f']]

# 三、异常处理 #

## 1.什么是异常？ ##

异常就是程序运行时发生错误的信号（在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止）

### 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'

## 2.异常的种类 ##

### 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.异常处理 ##

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

### 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之后预防 ###

*  万能异常Exception
    
        s1 = 'hello'
        try:
            int(s1)
        except Exception as e:
            print(e)

## 4.try...except总结 ##

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

## 5.抛出异常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)

## 6.断言assert ##

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

# 四、基本文件处理 #

## 1.什么是文件？ ##

文件是操作系统为用户或应用程序提供的一个读写硬盘的虚拟单位。文件的操作是基于文件，即文件的操作核心就是：读和写。也就是只要我们想要操作文件就是对操作系统发起请求，然后由操作系统将用户或应用程序对文件的读写操作转换成集体的硬盘指令（比如控制盘片转动，控制机械手臂移动，以此来读取数据)。

## 2.为什么要有文件？ ##

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

## 3.如何使用文件？ ##

### 3.1从硬盘中读取数据 ###

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

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

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

# 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 = 'tbb'
    pwd = '111'

### 3.2写入数据 ###

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

name = 'tbb'
    pwd = '666'

## 4.总结 ##

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

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

# 五、绝对路径和相对路径 #

## 1.绝对路径 ##

*  Windows系统绝对路径从盘符（C:、D:）开始写一个完整的路径。
 *  macos系统从根目录(/Users)开始写一个完整的路径。
    
    `F:\Python学习\python11期\day 09`

## 2.相对路径 ##

相对于当前执行文件所在的文件夹开始找。

`f = open('32.txt') # 32.txt与该.md文档同路径位置`

转载于:https://www.cnblogs.com/mgytz/p/11315913.html