Python 快速入门: 学习Python的基础操作

你的名字 2023-09-24 15:39 40阅读 0赞

#### 文章目录 ####

*  变量赋值
 *   *  单变量赋值
     *  多变量赋值
 *  数据类型
 *   *  Number类型
     *   *  定义
         *  数字类型转换
         *  运算
         *  相关函数
     *  String类型
     *   *  定义
         *  字符串格式化
         *  多行字符串
         *  \`str.format()\`
         *  \`f-string\`
         *  相关函数
     *  List类型
     *   *  定义
         *  常用操作
         *  相关函数
     *  元组类型
     *   *  定义
         *  常用操作
         *  相关函数
     *  字典类型
     *   *  定义
         *  常用操作
         *  相关函数
     *  集合类型
     *   *  定义
         *  常用操作
     *  强制转换
 *  推导式
 *   *  定义
     *  列表推导式
     *  字典推导式
     *  集合推导式
     *  元组推导式
 *  迭代器与生成器
 *   *  迭代器
     *   *  定义
         *  常用操作
     *  生成器
     *   *  定义
         *  常用操作
 *  函数
 *   *  参数
     *   *  1.必须参数
         *  2.关键字参数
         *  3.默认参数
         *  4.不定长参数
     *  匿名函数
     *   *  定义
         *  使用实例
 *  读写文件
 *   *  文件模式
     *  file对象函数
     *  文件操作常用函数
     *   *  \`file.read()\`
         *  \`file.readline()\`
         *  \`file.readlines()\`
         *  \`file.close\`
         *  \`file.seek(offset,\[whence\])\`
         *  \`file.write(str)\`
         *  \`file.writelines(seq)\`
 *  命名空间和作用域
 *   *  命名空间
     *   *  分类
         *  生命周期
     *  作用域
     *   *  分类
         *  global和nonlocal
 *  异常处理
 *   *  异常捕捉
     *  自定义异常
     *  断言

## 变量赋值 ##

### 单变量赋值 ###

python中的变量赋值不需要声明类型, 但是变量使用前必须要先赋值, 用等号`=`来给变量赋值

counter = 100

### 多变量赋值 ###

在 Python 中，多变量赋值是指同时给多个变量赋值。这是通过将多个变量名列在左侧，并将它们与右侧的值列表一一对应来实现的

a = b = c = 1

a,b,c = 1,2,"test"

a, b, c = [1, 2, 3]

## 数据类型 ##

**python3中有6个标准的数据类型:**

*  `Number`：数字
 *  `String`：字符串
 *  `List`：列表
 *  `Tuple`：元组
 *  `Set`：集合
 *  `Dictionary`：字典

### Number类型 ###

#### 定义 ####

Python3 支持 `int`、`float`、`bool`、`complex`(复数)

a, b, c, d = 20, 5.5, True, 4+3j
    print(type(a), type(b), type(c), type(d)) #输出:<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
    
    print(isinstance(a, int)) #输出True

#### 数字类型转换 ####

a = 1.0
    b = 3
    print(int(a)) #输出1
    print(float(b)) #输出3.0

#### 运算 ####

print(17//3)   #输出5
    print(17%3)    #求余,输出2
    print(5**2)    #求平方,输出25
    print(25**0.5) #开根号，输出5.0

#### 相关函数 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">Number类型函数</th> 
   <th align="left">返回值 ( 描述 )</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>abs(x)</code></td> 
   <td align="left">返回数字的绝对值，如<code>abs(-10)</code> 返回 10</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.ceil(x)</code></td> 
   <td align="left">返回数字的上入整数，如<code>math.ceil(4.1)</code> 返回 5</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.floor(x)</code></td> 
   <td align="left">返回数字的下舍整数，如<code>math.floor(4.9)</code>返回 4</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.exp(x)</code></td> 
   <td align="left">返回e的x次幂,如<code>math.exp(1)</code> 返回2.718281828459045</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.log10(x)]</code></td> 
   <td align="left">返回以10为基数的x的对数，如<code>math.log10(100)</code>返回2.0</td> 
  </tr> 
  <tr> 
   <td align="left"><code>max(x1, x2,...)</code></td> 
   <td align="left">返回给定参数的最大值，参数可以为序列。例如max([1,2,3,4]), 返回4</td> 
  </tr> 
  <tr> 
   <td align="left"><code>min(x1, x2,...)</code></td> 
   <td align="left">返回给定参数的最小值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.pow(x, y)</code></td> 
   <td align="left">返回<code>x**y</code>运算后的值。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>round(x,n)</code></td> 
   <td align="left">返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>math.sqrt(x)</code></td> 
   <td align="left">返回数字x的平方根。如<code>math.sqrt(100)</code>返回10</td> 
  </tr> 
 </tbody> 
</table>

### String类型 ###

#### 定义 ####

可对字符串进行切片操作

str = 'HelloWorld'
    print(str)          # 输出字符串: HelloWorld
    print(str[0:-1])    # 输出第一个到倒数第二个的所有字符: HelloWorl
    print(str[0])       # 输出字符串第一个字符: H
    print(str[2:5])     # 输出从第三个开始到第五个的字符: llo
    print(str[2:])      # 输出从第三个开始的后的所有字符: lloWorld
    print(str * 2)      # 输出字符串两次: HelloWorldHelloWorld
    print(str + "TEST") # 连接字符串: HelloWorldTEST

#### 字符串格式化 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">字符串格式符号</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>%c</code></td> 
   <td align="left">格式化字符及其ASCII码</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%s</code></td> 
   <td align="left">格式化字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%d</code></td> 
   <td align="left">格式化整数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%u</code></td> 
   <td align="left">格式化无符号整型</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%o</code></td> 
   <td align="left">格式化无符号八进制数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%x</code></td> 
   <td align="left">格式化无符号十六进制数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%X</code></td> 
   <td align="left">格式化无符号十六进制数(大写)</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%f</code></td> 
   <td align="left">格式化浮点数字，可指定小数点后的精度</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%e</code></td> 
   <td align="left">用科学计数法格式化浮点数, 默认保留6位小数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%E</code></td> 
   <td align="left">作用同%e，用科学计数法格式化浮点数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%g</code></td> 
   <td align="left">根据数值的大小采用%f和%e</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%G</code></td> 
   <td align="left">作用同<code>%g</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>%p</code></td> 
   <td align="left">用十六进制数格式化变量的地址</td> 
  </tr> 
 </tbody> 
</table>

print("%.2f"%(10.556)) #输出10.56
    print ("我叫%s今年%d岁" % ('henry', 20))  #输出:我叫henry今年20岁
    print("%x" % 16) #输出16的十六进制数: 10
    print("%e" % 10000) #输出: 1.000000e+04,
    print("%.3e" % 0.001) #输出: 1.000e-03
    print("%g" % 1000) #输出: 1000
    print("%g" % 1000000000) #输出: 1e+09

#### 多行字符串 ####

python可以使用三引号`"""`包裹多行字符串

para_str = """这是一个多行字符串的实例
    多行字符串可以使用制表符
    """
    print(para_str)

#### `str.format()` ####

`str.format`的常用语法:

print("MY NAME IS {},AGE is {}".format('herry','15'))
    #输出MY NAME IS herry,AGE is 15

可在`format()`使用位置参数

>>> print('{0} 和 {1}'.format('Henry', 'Tom'))
    Henry 和 Tom
    >>> print('{1} 和 {0}'.format('Henry', 'Tom'))
    Tom 和 Henry

可在`format()`使用关键字参数, 它们的值会指向使用该名字的参数

print("MY NAME IS {name},AGE is {age}".format(name='herry',age='15'))
    #输出MY NAME IS herry,AGE is 15

也可以位置参数和关键字参数混合

print('名字列表 {0}, {1}, 和 {other}。'.format('Henry', 'Tom', other='Lee'))
    #输出:名字列表 Henry, Tom, 和 Lee。

通过`:`和格式符号可以对值更好的格式化, 例如保留小数点后几位

import math
    print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi)) #输出:常量 PI 的值近似为 3.142。

在 `:` 后传入一个整数, 可以保证该域至少有这么多的宽度。

table = {
        'Google': 1, 'Runoob': 2, 'Taobao': 3}
    for name, number in table.items():
        print('{0:10} ==> {1:10d}'.format(name, number))
    
    #输出内容如下:        
    #Google     ==>          1
    #Runoob     ==>          2
    #Taobao     ==>          3

#### `f-string` ####

`f-string`是 python3.6之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

格式化字符串以 **`f`** 开头, 后面接着字符串, 字符串中的表达式用大括号\*\*`{}`\*\*包起来，它会将变量或表达式计算后的值替换进去

name = 'Herry'
    print(f'Hello {
          name}') #输出Hello Herry
    print(f'{
          1+2}') #输出3

a = {
        'id':1,'name':'faker'}
    print(f'我叫{
          a["name"]},排名第{
          a["id"]}') #我叫faker,排名第1

#### 相关函数 ####

<table> 
 <thead> 
  <tr> 
   <th>python函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>len(str)</code></td> 
   <td>返回字符串str的长度</td> 
  </tr> 
  <tr> 
   <td><code>max(str)</code></td> 
   <td>返回字符串 str 中最大的字母。</td> 
  </tr> 
  <tr> 
   <td><code>min(str)</code></td> 
   <td>返回字符串 str 中最小的字母。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th align="left">String内置函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>str.capitalize()</code></td> 
   <td align="left">将字符串的第一个字符转换为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.center(width,fillchar)</code></td> 
   <td align="left">返回一个宽度为width, str居中的字符串，fillchar为填充的字符, 默认为空格。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.count(sub, beg= 0,end=len(string))</code></td> 
   <td align="left">返回sub在 str 里面出现的次数，如果 beg 或者 end 指定了, 则返回指定范围内 str 出现的次数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>bytes.decode(encoding="utf-8")</code></td> 
   <td align="left">Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来对bytes对象进行解码，这个bytes对象可以由 <code>str.encode()</code> 来编码返回。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.encode(encoding='UTF-8')</code></td> 
   <td align="left">对字符串str进行encoding 指定的编码格式编码, 返回bytes对象</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.endswith(suffix, beg=0, end=len(string))</code></td> 
   <td align="left">检查str是否以suffix结束，如果beg 或者 end 指定, 则检查指定的范围内是否以suffix结束，如果是，返回 True,否则返回 False.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.expandtabs(tabsize=8)</code></td> 
   <td align="left">把字符串str中的 tab 符号转为空格，tab 符号默认的空格数是 8 。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.find(sub, beg=0, end=len(str))</code></td> 
   <td align="left">检测 sub 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.index(sub, beg=0, end=len(string))</code></td> 
   <td align="left">跟find()方法一样，只不过如果sub不在字符串中会报一个异常。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isalnum()</code></td> 
   <td align="left">如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isalpha()</code></td> 
   <td align="left">如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isdigit()</code></td> 
   <td align="left">如果字符串只包含数字则返回 True 否则返回 False…`</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.islower()</code></td> 
   <td align="left">`如果字符串的字符全是小写字母则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isnumberic()</code></td> 
   <td align="left">如果字符串中只包含数字字符，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isspace()</code></td> 
   <td align="left">如果字符串中只包含空白，则返回 True，否则返回 False.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.istitle()</code></td> 
   <td align="left">如果字符串是标题化的(见 title())则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isupper()</code></td> 
   <td align="left">如果字符串中的字符全是大写，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.join(seq)</code></td> 
   <td align="left">以指定字符串str作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.ljust(width,fillchar)</code></td> 
   <td align="left">返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.lower()</code></td> 
   <td align="left">转换字符串中所有大写字符为小写.</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.lstrip(chars)</code></td> 
   <td align="left">截掉字符串左边的空格或指定字符chars。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.replace(old,new)</code></td> 
   <td align="left">把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.rjust(width,fillchar)</code></td> 
   <td align="left">返回一个原字符串右对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.rstrip(chars)</code></td> 
   <td align="left">删除字符串末尾的空格或指定字符chars。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.split(chars="")</code></td> 
   <td align="left">以 chars为分隔符对字符串str进行切片来返回列表</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.splitlines(keepends)</code></td> 
   <td align="left">按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.startswith(substr, beg=0,end=len(string))</code></td> 
   <td align="left">检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.strip(chars)</code></td> 
   <td align="left">在字符串上执行 lstrip()和 rstrip()</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.swapcase()</code></td> 
   <td align="left">将字符串中大写转换为小写，小写转换为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.title()</code></td> 
   <td align="left">返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.upper()</code></td> 
   <td align="left">转换字符串中的小写字母为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str.isdecimal</code></td> 
   <td align="left">检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。</td> 
  </tr> 
 </tbody> 
</table>

### List类型 ###

#### 定义 ####

列表可以使用方括号 `[]` 来定义，元素之间使用逗号 `,` 分隔

# 定义一个空列表
    lst = []
    
    # 定义一个包含整数的列表
    lst = [1, 2, 3, 4, 5]
    
    # 定义一个包含字符串的列表
    lst = ['apple', 'banana', 'cherry']
    
    # 定义一个包含多种类型元素的列表
    lst = [1, 'apple', 3.14, [1, 2, 3]]

#### 常用操作 ####

读取列表元素和列表的切片与拼接

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
    tinylist = [123, 'runoob']
    
    print(list)            # 输出完整列表:['abcd', 786, 2.23, 'runoob', 70.2]
    print(list[0])         # 输出列表第一个元素:abcd
    
    print(list[1:3])       # 从第二个开始输出到第三个元素:[786, 2.23]
    print(list[2:])        # 输出从第三个元素开始的所有元素:[2.23, 'runoob', 70.2]
    print(list[-1])        # 输出最后一个元素70.2
    print(list[0:-2])      # 输出第一个至倒数第三个元素:['abcd', 786, 2.23]
    
    print(list[1:])        # 输出[786, 2.23, 'runoob', 70.2]
    print(list[1::2])      # 输出[786, 'runoob']
    print(list[::-1])      # 逆序输出[70.2, 'runoob', 2.23, 786, 'abcd']
    
    print(tinylist * 2)    # 输出两次列表:[123, 'runoob', 123, 'runoob']
    print(list + tinylist) # 拼接列表,输出['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

列表与字符串不一样的是, 列表的元素是可以改变的

a = [1,2,3,4,5,6]
    a[0] = 9
    a[2:5] = [13,14,15]
    print(a) #输出[9, 2, 13, 14, 15, 6]
    
    a[2:5] = [] #设置对应的元素为空
    print(a) #输出[9, 2, 6]

更新列表元素

list = ['Google', 'Runoob', 1997, 2000]
     
    print ("第三个元素为 : ", list[2])
    list[2] = 2001
    print ("更新后的第三个元素为 : ", list[2])
     
    list1 = ['Google', 'Runoob', 'Taobao']
    list1.append('Baidu')
    print ("更新后的列表 : ", list1)

删除列表元素

list = ['Google', 'Runoob', 1997, 2000]
    print("原始列表 : ", list) #输出: ['Google', 'Runoob', 1997, 2000]
    del list[2]
    print("删除后的列表: ", list) #输出: ['Google', 'Runoob', 2000]

#### 相关函数 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">python内置函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>len(list)</code></td> 
   <td>返回列表元素个数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>max(list)</code></td> 
   <td>返回列表元素最大值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>min(list)</code></td> 
   <td>返回列表元素最小值</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>list函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>list(seq)</code></td> 
   <td>将元组(序列)转换为列表</td> 
  </tr> 
  <tr> 
   <td><code>list.append(obj)</code></td> 
   <td>在列表末尾添加新的对象</td> 
  </tr> 
  <tr> 
   <td><code>list.count(obj)</code></td> 
   <td>返回某个元素在列表中出现的次数</td> 
  </tr> 
  <tr> 
   <td><code>list.extend(seq)</code></td> 
   <td>在列表末尾一次性追加另一个序列中的多个值, 此序列可以是列表,元组,集合</td> 
  </tr> 
  <tr> 
   <td><code>list.index(obj,start)</code></td> 
   <td>返回obj元素在列表匹配的第一个索引位置, start表示查找的起始位置</td> 
  </tr> 
  <tr> 
   <td><code>list.insert(index,obj)</code></td> 
   <td>在列表的指定索引插入元素</td> 
  </tr> 
  <tr> 
   <td><code>list.pop(index)</code></td> 
   <td>移除列表的指定索引元素, 若index为空则默认移除最后一个元素</td> 
  </tr> 
  <tr> 
   <td><code>list.remove(obj)</code></td> 
   <td>移除列表中某个值的第一个匹配项</td> 
  </tr> 
  <tr> 
   <td><code>list.reverse()</code></td> 
   <td>逆转列表元素的索引位置</td> 
  </tr> 
 </tbody> 
</table>

**`list.sort(key=None,reverse=False)`**

> key: 将key作标准来进行排序, 可以是表达式或者函数
> 
> reverse: False表示升序, True表示降序

如下代码所示, 将列表元素按字符串长度进行排序输出, 以下有两种解决思路:

fruits = ['grape','pear','apple','water melon']
    
    #lambda声明匿名函数,使用格式为lambda arguments : expression,执行表达式并返回结果
    fruits.sort(key=lambda x:len(x))  
    print(fruits)

fruits = ['grape','pear','apple','water melon']
    fruits.sort(key=len)
    print(fruits)

### 元组类型 ###

#### 定义 ####

元组与列表类似，但是元组的元素不能修改。

元组使用小括号 **`( )`**，列表使用方括号 **`[ ]`**。

tup1 = ('Google', 'Runoob', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5 )
    tup3 = "a", "b", "c", "d"
    print(type(tup3))  #tup1,tup2,tup3均为元组类型

若元组中只包含一个元素，则需要在元素后面添加逗号, 否则`()`会被识别成运算符

tup1 = (60)
    print(type(tup1))  #输出<class 'int'>
    
    tup2 = (60,)
    print(type(tup2))  #输出<class 'tuple'>

#### 常用操作 ####

使用下标索引来访问元组中的值, 也可以对元组进行切片操作

tup1 = ('Google', 'Runoob', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5, 6, 7)
    
    print(tup1[0])   #输出Google
    print(tup2[1:5]) #输出(2, 3, 4, 5)

虽然元组中的元素值是不允许修改的，但可以对元组进行拼接组合

tup1 = (12, 34.56)
    tup2 = ('abc', 'xyz')
    tup3 = tup1 + tup2
    print (tup3)  #输出(12, 34.56, 'abc', 'xyz')

元组中的元素值是不允许删除的，但我们可以使用`del`语句来删除整个元组

tup = ('Google', 'Runoob', 1997, 2000) 
    del tup
    print (tup) #输出直接报错,因为元组已被删除

#### 相关函数 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">python内置函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>len(tuple)</code></td> 
   <td align="left">计算元组元素个数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>max(tuple)</code></td> 
   <td align="left">返回元组中元素最大值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>min(tuple)</code></td> 
   <td align="left">返回元组中元素最小值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>tuple(iterable)</code></td> 
   <td align="left">将可迭代系列转换为元组。</td> 
  </tr> 
 </tbody> 
</table>

### 字典类型 ###

#### 定义 ####

字典用大括号\*\*`{}`\*\*来定义。

键必须是唯一的, 值是可变的。

mydict = {
        'name': 'runoob', 'likes': 123, 1: 'www.runoob.com'}
    
    print(mydict[1])      #输出www.runoob.com
    print(mydict['name']) #输出runoob

#### 常用操作 ####

使用`dict()`函数创建字典

emptyDict = dict()
    
    print(emptyDict) #输出空字典:{}
    
    print(len(emptyDict)) #输出字典的长度:0

访问字典的值

tinydict = {
        'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
     
    print (tinydict['Name']) #输出
    print (tinydict['Age'])

修改和更新字典的值

tinydict = {
        'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
     
    tinydict['Age'] = 8               # 更新 Age
    tinydict['School'] = "北京大学"    # 添加信息
     
     
    print (tinydict['Age'])     #输出8
    print (tinydict['School'])  #输出'北京大学'

删除字典元素

tinydict = {
        'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
     
    del tinydict['Name'] # 删除键 'Name'
    tinydict.clear()     # 清空字典
    del tinydict         # 删除字典
     
    print (tinydict['Age'])  #输出直接报错,因为字典已被删除

#### 相关函数 ####

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>len(dict)</code></td> 
   <td>计算字典元素个数, 即键的总数。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str(dict)</code></td> 
   <td>用字符串的形式输出字典, 例如输出:<code>"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.clear()</code></td> 
   <td>删除字典内所有元素</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.copy()</code></td> 
   <td>返回一个字典的浅复制</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.fromkeys(seq,values)</code></td> 
   <td>用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.get(key,[value])</code></td> 
   <td>返回指定键的值，如果键不在字典中返回默认值 None 或者设置的默认值。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>key in dict</code></td> 
   <td>如果键在字典dict里返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.items()</code></td> 
   <td>Python 字典 items() 方法以列表返回视图对象，是一个可遍历的<code>key</code>/<code>value</code> 对</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.keys()</code><br><code>dict.values()</code></td> 
   <td>返回一个视图对象</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.pop(key)</code></td> 
   <td>删除字典key键所对应的值，返回被删除的值</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict.popitem()</code></td> 
   <td>返回并删除字典中最后一对键和值</td> 
  </tr> 
 </tbody> 
</table>

**`dict.fromkeys(seq,values)`**

country = ['China','England','America','France']
    dict = {
        }
    dict = dict.fromkeys(country,'')
    print(dict)

使用`dict.items()`同时遍历字典的键与值, 使用`dict.keys()`和`dict.values()`分别遍历字典的键与值

dict = {
        'China':1,'England':2,'America':3,'France':4}
    
    for key,value in dict.items():
        print(key+"  ===>  "+str(value))
        '''输出如下:
            China  ===>  1
            England  ===>  2
            America  ===>  3
            France  ===>  4
        '''
    for key in dict.keys():
        print(key)
        '''输出如下:
            China
            England
            America
            France
        '''
    
    for value in dict.values():
        print(value)
        '''输出如下:
             1
             2
             3
             4   
        '''

### 集合类型 ###

#### 定义 ####

集合是一个无序的不重复元素序列, 使用大括号\*\*`{ }`**或**`set()`\*\*函数来创建

#### 常用操作 ####

以下是两个集合之间的运算

a = set('abacha')
    print(a) #输出{'c', 'a', 'h', 'b'}
    
    b = set('jabka')
    print(b) #输出{'k', 'a', 'j', 'b'}
    
    print(a|b) #输出a与b的并集:{'a', 'k', 'b', 'h', 'j', 'c'},
    print(a&b) #输出a与b的交集:{'b', 'a'}
    print(a^b) #输出不同时包含于a和b的元素:{'c', 'j', 'h', 'k'}

集合添加元素: `set.add()`、`set.update()`

thisset = set(("Google", "Runoob", "Taobao"))
    thisset.add("Facebook")
    print(thisset) #输出{'Taobao', 'Runoob', 'Facebook', 'Google'}
    
    thisset.update([1,2])
    print(thisset) #输出{1, 2, 'Taobao', 'Runoob', 'Facebook', 'Google'}

集合移除元素: `set.remove(element)`、`set.discard(element)`、`set.pop()`

thisset = set(("Google", "Runoob", "Taobao"))
    thisset.remove("Taobao") #若元素不存在则会报错
    print(thisset) #输出{'Google', 'Runoob'}

thisset = set(("Google", "Runoob", "Taobao"))
    thisset.discard("Taobao") #若元素不存在不会报错
    print(thisset) #输出{'Google', 'Runoob'}

thisset = set(("Google", "Runoob", "Taobao"))
    x = thisset.pop() #随机删除一个元素

求集合元素的个数: `len(set)`

thisset = set(("Google", "Runoob", "Taobao"))
    print(len(thisset)) #输出3

清空集合元素: `set.clear()`

thisset = set(("Google", "Runoob", "Taobao"))
    thisset.clear()
    print(thisset) #输出set()

### 强制转换 ###

在 Python 中，可以使用一些内置的函数来强制转换数据类型

<table> 
 <thead> 
  <tr> 
   <th align="left">强制转换函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>int(x)</code></td> 
   <td align="left">将x转换为一个整数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>float(x)</code></td> 
   <td align="left">将x转换到一个浮点数</td> 
  </tr> 
  <tr> 
   <td align="left"><code>str(x)</code></td> 
   <td align="left">将对象 x 转换为字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>repr(x)</code></td> 
   <td align="left">将对象 x 转换为表达式字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>eval(str)</code></td> 
   <td align="left">用来计算在字符串中的有效Python表达式,并返回一个对象</td> 
  </tr> 
  <tr> 
   <td align="left"><code>tuple(s)</code></td> 
   <td align="left">将序列 s 转换为一个元组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>list(s)</code></td> 
   <td align="left">将序列 s 转换为一个列表</td> 
  </tr> 
  <tr> 
   <td align="left"><code>set(s)</code></td> 
   <td align="left">转换为可变集合</td> 
  </tr> 
  <tr> 
   <td align="left"><code>dict(d)</code></td> 
   <td align="left">创建一个字典。d 必须是一个 (key, value)元组序列。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>frozenset(s)</code></td> 
   <td align="left">转换为不可变集合</td> 
  </tr> 
  <tr> 
   <td align="left"><code>chr(x)</code></td> 
   <td align="left">将一个整数转换为一个字符</td> 
  </tr> 
  <tr> 
   <td align="left"><code>ord(x)</code></td> 
   <td align="left">将一个字符转换为ASCII码</td> 
  </tr> 
  <tr> 
   <td align="left"><code>hex(x)</code></td> 
   <td align="left">将一个整数转换为一个十六进制字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>oct(x)</code></td> 
   <td align="left">将一个整数转换为一个八进制字符串</td> 
  </tr> 
 </tbody> 
</table>

## 推导式 ##

### 定义 ###

Python 推导式可实现从一个数据序列构建另一个新的数据序列

Python 支持各种数据结构的推导式

*  列表推导式
 *  字典推导式
 *  集合推导式
 *  元组推导式

### 列表推导式 ###

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
    new_names = [name.upper() for name in names if len(name)>3]
    print(new_names) #输出:['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数

multiples = [i for i in range(30) if i % 3 == 0]
    print(multiples) #输出:[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

### 字典推导式 ###

将列表转换成字典, 其中键为字符串值, 值为字符串长度

listdemo = ['Google','Runoob', 'Taobao']
    newdict = {
        key:len(key) for key in listdemo}
    print(newdict)  #输出{'Google': 6, 'Runoob': 6, 'Taobao': 6}

### 集合推导式 ###

判断不是abc的字母并输出

a = {
        x for x in 'abracadabra' if x not in 'abc'}
    print(a) #输出{'d', 'r'}

### 元组推导式 ###

生成一个包含1~9的元组

a = (x for x in range(1,10))
    print(a) #输出生成器对象:<generator object <genexpr> at 0x000001DB1C5EF270>
    print(tuple(a))  #(1, 2, 3, 4, 5, 6, 7, 8, 9)

## 迭代器与生成器 ##

### 迭代器 ###

#### 定义 ####

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退

迭代器主要涉及两个函数: `iter()`和`next()`

*  `iter()`: 将可迭代对象转换为迭代器
 *  `next()`: 依次访问迭代器里面的函数

#### 常用操作 ####

创建迭代器对象

list=[1,2,3,4]
    it = iter(list) #创建迭代器对象
    print(next(it))  #输出1
    print(next(it))  #输出2

for语句遍历迭代器对象

list=[1,2,3,4]
    it = iter(list)    # 创建迭代器对象
    for x in it:
        print (x, end=" ") #输出1 2 3 4

### 生成器 ###

#### 定义 ####

在 Python 中，有一种特殊的函数叫做生成器，它使用 `yield` 关键字返回值。生成器能够在循环的过程中不断推算出后续的值，而不必创建完整的列表，从而节省空间。

列表生成式是一种快速创建列表的方式，但当列表中的元素数量很多时，会占用大量的存储空间。使用生成器能够在循环的过程中推算出后续的元素，而不必一次性创建完整的列表。这样就能节省大量的空间

#### 常用操作 ####

著名的斐波拉契数列（`Fibonacci`），除第一个和第二个数外，任意一个数都可由前两个数相加得到, 例如:1, 1, 2, 3, 5, 8, 13, 21, 34, …

def fib(sum):
        a, b, c = 0, 1, 0
        while c < sum:
            yield b        # 代码执行到这里，会跳出这个函数，并将b的值返回到使用next的代码处
            a, b = b, a + b
            c += 1
    
    p = fib(6)
    print(next(p)) #输出1
    print(next(p)) #输出1
    print(next(p)) #输出2
    print(next(p)) #输出3
    print(next(p)) #输出5
    print(next(p)) #输出8

在 Python 中，生成器函数使用 `yield` 语句返回值，而不是使用 `return` 语句。如果想要在生成器中使用 `return` 语句, 可通过捕获生成器的 `StopIteration` 异常。当生成器的 `return` 语句被执行时，会抛出 `StopIteration` 异常，并结束生成器的执行, `return`语句的返回值包含在`StopIteration`的`value`中

def fib(sum):
        a, b, c = 0, 1, 0
        while c < sum:
            yield b
            a, b = b, a + b
            c += 1
        return "返回值只能传递给异常"
    
    g = fib(3)
    while True:
        try:
            x = next(g)
            print('g:', x)
        except StopIteration as e:
             print('Generator return value:', e.value)
             break
     def fib(sum):
        a, b, c = 0, 1, 0
        while c < sum:
            yield b
            a, b = b, a + b
            c += 1
        return "返回值只能传递给异常"
    
    g = fib(3)
    while True:
        try:
            x = next(g)
            print('g:', x)
        except StopIteration as e:
             print('Generator return value:', e.value)
             break
    """
    输出如下所示：
    g: 1
    g: 1
    g: 2
    Generator return value: 返回值只能传递给异常
    """

## 函数 ##

### 参数 ###

#### 1.必须参数 ####

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样，调用 `printme()` 函数，你必须传入一个参数，不然会出现语法错误

def printme(str):
       "打印任何传入的字符串"
       print (str)
       return
     
    # 调用printme 函数，不加参数会报错
    printme()

#### 2.关键字参数 ####

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值

def printme(str):
       "打印任何传入的字符串"
       print (str)
       return
     
    #调用printme函数
    printme(str="HelloWorld") #输出"HelloWorld"

#### 3.默认参数 ####

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值

# 可写函数说明
    def printinfo(name, age=35):
        "打印任何传入的字符串"
        print("名字: ", name)
        print("年龄: ", age)
        return
    
    
    # 调用printinfo函数
    printinfo(name="Henry", age=22)  #输出:"名字:Henry 年龄:22"
    printinfo(name="Tom")            #输出:"名字:Tom   年龄:35"

#### 4.不定长参数 ####

不定长参数是指函数的参数个数是不确定的。不定长参数可以接受任意数量的参数，并将它们作为一个元组返回

可以使用 `*` 操作符定义不定长参数。例如，下面是一个函数，它使用不定长参数计算传入的所有数字的平均值

def avg(*args):
        total = 0
        for arg in args:
            total += arg
        return total / len(args)
    
    print(avg(1, 2, 3))  # 2.0
    print(avg(1, 2, 3, 4, 5))  # 3.0
    print(avg())  # 0.0

不定长关键字参数可以接受任意数量的关键字参数，并将它们作为一个字典返回

在 Python 中，可以使用 `**` 操作符定义不定长关键字参数。例如下面是一个函数，它使用不定长关键字参数打印传入的所有关键字参数

def my_func(**kwargs):
        for key, value in kwargs.items():
            print(f"{
          key}: {
          value}")
    
    my_func(a=1,b=2,c=3)
    
    '''
    Output:
    a: 1
    b: 2
    c: 3
    '''

### 匿名函数 ###

#### 定义 ####

Python 使用 `lambda` 来创建匿名函数。所谓匿名，意即不再使用 `def` 语句这样标准的形式定义一个函数

虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

lambda 函数的使用语法如下：

lambda [arg1 [,arg2,.....argn]]:expression

#### 使用实例 ####

定义一个返回两个参数相加后的结果的匿名函数

sum = lambda arg1, arg2: arg1 + arg2
     
    # 调用sum函数
    print ("相加后的值为 : ", sum( 10, 20 ))
    print ("相加后的值为 : ", sum( 20, 20 ))
    
    #输出结果如下：
    #相加后的值为 :  30
    #相加后的值为 :  40

## 读写文件 ##

### 文件模式 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">模式</th> 
   <th align="left">描述</th> 
   <th>若文件不存在</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>r</code></td> 
   <td align="left">以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td align="left"><code>rb</code></td> 
   <td align="left">以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td align="left"><code>r+</code></td> 
   <td align="left">打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td align="left"><code>rb+</code></td> 
   <td align="left">以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
   <td>出错</td> 
  </tr> 
  <tr> 
   <td align="left"><code>w</code></td> 
   <td align="left">打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>wb</code></td> 
   <td align="left">以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>w+</code></td> 
   <td align="left">打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>wb+</code></td> 
   <td align="left">以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a</code></td> 
   <td align="left">打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件进行写入。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>ab</code></td> 
   <td align="left">以而二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件进行写入。</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>a+</code></td> 
   <td align="left">打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写</td> 
   <td>建立</td> 
  </tr> 
  <tr> 
   <td align="left"><code>ab+</code></td> 
   <td align="left">以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写</td> 
   <td>建立</td> 
  </tr> 
 </tbody> 
</table>

### file对象函数 ###

<table> 
 <thead> 
  <tr> 
   <th>file对象函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>file.close()</code></td> 
   <td>关闭文件。</td> 
  </tr> 
  <tr> 
   <td><code>file.flush()</code></td> 
   <td>刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入</td> 
  </tr> 
  <tr> 
   <td><code>file.fileno()</code></td> 
   <td>返回一个整型的文件描述符, 可以用在如os模块的read方法等一些底层操作上</td> 
  </tr> 
  <tr> 
   <td><code>file.isatty()</code></td> 
   <td>如果文件连接到一个终端设备返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td><code>file.read([size])</code></td> 
   <td>从文件读取指定的字节数，如果未给定或为负则读取所有</td> 
  </tr> 
  <tr> 
   <td><code>file.readline([size])</code></td> 
   <td>读取整行，包括 “\n” 字符。</td> 
  </tr> 
  <tr> 
   <td><code>file.readlines([sizenint])</code></td> 
   <td>读取所有行并返回列表</td> 
  </tr> 
  <tr> 
   <td><code>file.seek(offset,[whence])</code></td> 
   <td>移动文件读取指针到指定位置</td> 
  </tr> 
  <tr> 
   <td><code>file.tell()</code></td> 
   <td>返回文件当前位置</td> 
  </tr> 
  <tr> 
   <td><code>file.truncate([size])</code></td> 
   <td>从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除</td> 
  </tr> 
  <tr> 
   <td><code>file.write(str)</code></td> 
   <td>将字符串写入文件, 并返回写入字符的长度</td> 
  </tr> 
  <tr> 
   <td><code>file.writelines(sequence)</code></td> 
   <td>向文件写入一个字符串列表，如果需要换行则要自己加入每行的换行符</td> 
  </tr> 
 </tbody> 
</table>

### 文件操作常用函数 ###

#### `file.read()` ####

file = open('text.txt','r+')
    
    print(file.read())
    # 输出文件所有内容:
    # www.taobao.com
    # www.jd.com
    # www.baidu.com
    
    file.close()

file = open('text.txt','r+')
    
    print(file.read(10))
    #输出10个字节的文件内容:www.taobao
    
    file.close()

#### `file.readline()` ####

file = open('text.txt','r+')
    
    print(file.readline())
    # 输出文件一行内容:
    # www.taobao.com

#### `file.readlines()` ####

file = open('text.txt','r+')
    
    print(file.readlines())
    #输出含有文件所有内容的列表(包含换行符):
    ['www.taobao.com\n', 'www.jd.com\n', 'www.baidu.com\n', '\n']

#### `file.close` ####

当你处理完一个文件后, 调用 `f.close()` 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()
    >>> f.read()
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    ValueError: I/O operation on closed file

当处理一个文件对象时, 使用 **`with`** 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件

with open('result.txt','w+') as f:
        f.write("this is testing")
    
    print(f.closed) #判断文件是否关闭，输出True

#### `file.seek(offset,[whence])` ####

*  offset: 移动偏移的字节数
 *  whence: 默认值为0; 0表示从文件开头开始, 1表示从当前位置开始, 2表示从文件末尾开始

f = open('workfile', 'rb+')
    f.write("0123456789abcdef")
    f.seek(5) #移动至第六个字节
    print(f.read(1)) #输出5
    
    f.seek(-3,2) #移动到文件倒数第三个字节
    print(f.read(1)) #输出'd'

#### `file.write(str)` ####

*  str: 要写入的字符串

# 打开文件
    fo = open("test.txt", "r+")
    print ("文件名: ", fo.name)
    
    str = "6:www.test.com"
    # 在文件末尾写入一行
    fo.seek(0,2)  #移动至文件内容末尾
    line = fo.write(str )
    
    # 读取文件所有内容
    fo.seek(0,0) #移动至文件内容开头
    for index in range(6):
        line = next(fo) 
        print ("文件行号 %d - %s" % (index, line))
    
    # 关闭文件
    fo.close()

#### `file.writelines(seq)` ####

*  seq: 要写入文件的字符串序列

fo = open("test.txt", "w")
    print ("文件名为: ", fo.name)
    seq = ["Henry", "Tom"]
    fo.writelines( seq )
    
    # 关闭文件
    fo.close()

## 命名空间和作用域 ##

### 命名空间 ###

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python字典来实现的

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响

#### 分类 ####

一般有三种命名空间, 其查找顺序为: **局部名称 -> 全局名称 -> 内置名称**

*  **内置名称**(built-in names): Python 语言内置的名称，比如函数名 `abs`、`char` 和异常名称 `BaseException`、`Exception` 等等。
 *  **全局名称**(global names): 模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
 *  **局部名称**(local names): 函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量,类中定义的也是

![请添加图片描述][e701960d38234ef0849bcda7d8d101c5.png]

#### 生命周期 ####

命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。因此, 我们无法从外部命名空间访问内部命名空间的对象

### 作用域 ###

作用域就是一个 Python 程序可以直接访问命名空间的正文区域

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

#### 分类 ####

Python 的作用域一共有4种, 其搜索顺序为:**L –> E –> G –> B**

*  **L(Local)**：最内层, 包含局部变量，例如一个函数/方法内部。
 *  **E(Enclosing)**：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数(或类) A 里面又包含了一个函数 B ，那么对于B中的名称来说 A 中的作用域就为非局部(nonlocal)。
 *  **G(Global)**：当前脚本的最外层，比如当前模块的全局变量。
 *  **B(Built-in)**： 包含了内建的变量/关键字等，最后被搜索。

#### global和nonlocal ####

当内部作用域想修改外部作用域的变量时，就要用到 `global` 和 `nonlocal` 关键字了

num = 1
    def fun1():
        global num  # 需要使用 global 关键字声明
        print(num) #输出1
        num = 123
        print(num) #输出123
    fun1()
    print(num) #输出123

如果要修改嵌套作用域(enclosing 作用域)中的变量则需要`nonlocal`关键字了

def outer():
        num = 10
        def inner():
            nonlocal num   # nonlocal关键字声明
            num = 100
            print(num)
        inner()
        print(num)
    outer()

> 上述代码中使用关键字`nonlocal`声明了num变量, 表示此变量非局部变量, 其作用域为`outer`函数

## 异常处理 ##

### 异常捕捉 ###

Python中使用`try`、`except`、`finally`组合来捕捉异常，except中的`Exception`是所有异常的父类

try:
        int("12a")  # 抛出可能出现异常的代码
    except IndexError as e:  # 捕捉索引异常的子异常
        print("IndexError:",e) #输出:ValueError: invalid literal for int() with base 10: '12a'
    
    except ValueError as e:  # 捕捉value错误的子异常
        print("ValueError:",e)
    
    except Exception as e:  # 使用Exception捕获，Exception能够捕获所有的异常
        print("Exception:",e)
    
    else:  # 如果都没有异常发生，执行else中的代码块
        print("true")
    
    finally:  # 不管是否发生异常，在最后都会执行finally中的代码，假如try里面的代码正常执行，先执行else中的代码，再执行finally中的代码
        print("finally")
    
    #输出内容如下:
    # ValueError: invalid literal for int() with base 10: '12a'
    # finally

### 自定义异常 ###

因为Exception是所有异常的父类，所以可以自定义Exception的子类，实现自定义异常处理

class TypeErrorException(Exception):
        def __init__(self, message):
            self.message = message
    
        def __str__(self):  # 打印异常的时候会调用对象里面的__str__方法返回一个字符串
            return self.message
    
    
    if __name__ == "__main__":
        try:
            raise TypeErrorException("Type error")  #抛出TypeErrorException异常
        except TypeErrorException as e:
            print("TypeErrorException:", e)  #输出异常:TypeErrorException: Type error
        except Exception as e:
            print("Exception:", e)
        else:
            print("true")
        finally:
            print("finally")

### 断言 ###

断言assert一般用在判断执行环境上, 只要断言的条件不满足, 就会抛出异常且后续代码不会被执行

如下所示为断言条件不满足:

print("开始执行代码")
    a,b=1,2
    assert a == b
    print("结束执行代码")

![请添加图片描述][b5f1cb9e27b049baba3a0ddfea8e4602.png]

如下所示为断言条件满足:

print("开始执行代码")
    a,b=1,1
    assert a == b
    print("结束执行代码")

![请添加图片描述][1489dc7e09654b2580455dd849291644.png]

[e701960d38234ef0849bcda7d8d101c5.png]: https://img-blog.csdnimg.cn/e701960d38234ef0849bcda7d8d101c5.png
[b5f1cb9e27b049baba3a0ddfea8e4602.png]: https://img-blog.csdnimg.cn/b5f1cb9e27b049baba3a0ddfea8e4602.png
[1489dc7e09654b2580455dd849291644.png]: https://img-blog.csdnimg.cn/1489dc7e09654b2580455dd849291644.png