Python基础——Python语言家族

绝地灬酷狼 2022-12-09 11:52 277阅读 0赞

在这里插入图片描述

# 一、Python语言家族 #

## 1 Introduction ##

### 1.1 Python 简介 ###

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

简单来说，Python是一门编程语言，帮助我们更好的与计算机沟通，功能全面、易学易用、可拓展语言，所以说，人生苦短，我学Python。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

*  `Python 是一种解释型高级语言:` 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
 *  `Python 是交互式语言:` 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
 *  `Python 是面向对象语言:` 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
 *  `Python 是初学者的语言:` Python 对初级程序员而言，是一种伟大的语言，开发代码量少，模块扩展库种类繁多，所以它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

##### 扩展：编译型与解释型的原理 #####

*  编译型：编译器将源代码逐条编译成机器代码，任何一条语句 有错，都不能通过编译，最终形成目标代码，以后每次执行只执 行目标代码即可，因此执行速度快。
 *  解释型：解释器逐条解释源代码，成功一条就执行一 条，每次执行时都需要解释，所以速度稍慢

### 1.2 Python发展历史 ###

*  Python的作者是荷兰人Guido von Rossum（龟叔）
 *  1982年，Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，尽管拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的活儿。
 *  1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python’s Flying Circus (BBC1960-1970年代播放的室内情景幽默剧，以当时的英国生活为素材)。他希望这个新的叫做Python的语言，能实现他的理念(一种C和shell之间，功能全面，易学易用，可拓展的语言)。Guido作为一个语言设计爱好者，已经有过设计语言的(不很成功)的尝试。这一次，也不过是一次纯粹的hacking行为。
 *  Python正式诞生于1991年
 *  Python目前有两个版本，Python2和Python3，代码不完全兼容
 *  源文件.py文件猴后缀名
 *  Python的解释器如今有多个语言实现，通常用的是Cpython或者IPython（官方版本的C语言实现），其他还有Jpython（Java平台）、IronPython（NET和Mono平台）、PyPy（Python实现）

##### 扩展：Python2还是Python3 #####

*  py2.7是2.x系列的最后一个版本，已经停止开发，不再增加新功能。2020年终止支持。所有的最新的标准库的更新改进，只会在3.x的版本里出现。Guido决定清理Python2.x ，并且不再兼容旧版本。
 *  最大的一个改变就是使用Unicode作为默认编码。Pyhton2.x中直接写中文会报错，Python3中可以直接写中文了。从开源项目看，支持py3的比例已经大大提高，知名的项目一般都支持py2.7和py3+。
 *  py3比py2更规范统一、去掉了没必要的关键字Python3.x还在持续改进。
 *  所以我们还是推荐大家使用Python3.x。

## 2 Python的安装与使用 ##

### 2.1 Python环境搭建 ###

*  Python可应用于多平台包括Windows、 Linux/Unix 和 Mac OS。
 *  Python有不同的搭建环境包括Python解释器(CPython)、编辑器(（)IDLE，PyCharm，Sublime Text)、Python软件包管理系统(pip)

#### 2.1.1 环境下载 ####

*  Python最新源码，解释器环境等最新下载
    
    Python官网:[http://www.python.org/][http_www.python.org]
 *  Python 权威使用技术文档等最新下载
    
    Python文档下载地址:[http://www.python.org/doc/][http_www.python.org_doc]

#### 2.1.2 Python编辑器 ####

*  Ipython IDLE
 *  Vim和macVim（linux，unix，macOSX）
 *  Eclipse+pyDEV
 *  Xcode（macOSX）
 *  Notepad++（win）
 *  Sublime Text（win，macOSX，linux，unix）
 *  PyCharm（全平台）

#### 2.1.3 Unix & Linux 平台安装 Python:(源码式安装) ####

*  以下为在Unix & Linux 平台上安装 Python 的简单步骤：
    
     *  打开WEB浏览器访问[http://www.python.org/download/][http_www.python.org_download]
     *  选择适用于Unix/Linux的源码压缩包。
     *  下载及解压压缩包。
     *  如果你需要自定义一些选项修改Modules/Setup
     *  执行 ./configure 脚本
     *  make
     *  make install
 *  执行以上操作后，Python会安装在 /usr/local/bin 目录中，Python库安装在/usr/local/lib/pythonXX，XX为你使用的Python的版本号。

#### 2.1.4 通过ubuntu官方的apt工具包安装 ####

$ sudo apt-get install python  
       $ sudo apt-get install python2.7  
       $ sudo apt-get install python3.7

#### 2.1.5 Mac安装Python3 ####

$ brew sreach python
       $ brew install python3
       //在/usr/local/Cellar/这个目录下

#### 2.1.6 windows下直接安装 ####

##### ① 首先访问[http://www.python.org/download/][http_www.python.org_download] 下载最新环境 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70][]

##### ② 然后选择最新版本，并适用于自己系统的环境 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 1][]

##### ③ 下载后，双击安装,选择“Install Now”默认安装，但一定勾选“Add Python 3.7 toPATH” #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 2][]

##### ④ 如果没有添加环境，在安装之后，配置环境 #####

## 3 Python的运行 ##

##### 运行Python的三种方式 #####

1.  交互式解释器
2.  命令行运行Python源代码
3.  使用编辑器或集成开发环境（IDE）例如：pycharm

### 3.1 交互式解释器 ###

*  你可以通过命令行窗口进入python并开在交互式解释器中开始编写Python代码。
 *  你可以在Unix，DOS或任何其他提供了命令行或者shell的系统进行python编码工作。

$ python # Unix/Linux 
    或者 
    C:>python # Windows/DOS

*  以下为Python命令行参数：

<table> 
 <thead> 
  <tr> 
   <th>选项</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>-d</td> 
   <td>在解析时显示调试信息</td> 
  </tr> 
  <tr> 
   <td>-O</td> 
   <td>生成优化代码 ( .pyo 文件 )</td> 
  </tr> 
  <tr> 
   <td>-S</td> 
   <td>启动时不引入查找Python路径的位置</td> 
  </tr> 
  <tr> 
   <td>-V</td> 
   <td>输出Python版本号</td> 
  </tr> 
  <tr> 
   <td>-X</td> 
   <td>从 1.6版本之后基于内建的异常（仅仅用于字符串）已过时。</td> 
  </tr> 
  <tr> 
   <td>-c cmd</td> 
   <td>执行 Python 脚本，并将运行结果作为 cmd 字符串。</td> 
  </tr> 
  <tr> 
   <td>file</td> 
   <td>在给定的python文件执行python脚本。</td> 
  </tr> 
 </tbody> 
</table>

### 3.2 命令行脚本 ###

*  在记事本中输入下列代码，另存为test.py文件

import requests
    response=requests.get(https://img-bss.csdnimg.cn/201906261028104896.png)
    pic = open('photo.jpg','wb')
    pic.write(response.content)

*  在你的应用程序中通过引入解释器可以在命令行中执行Python脚本，如下所示：

$ python test.py # Unix/Linux 
    或者 
    C:>python test.py # Windows/DOS

### 3.3 集成开发环境 ###

*  PyCharm 是由 JetBrains 打造的一款 Python IDE，支持 macOS、 Windows、 Linux 系统。
 *  PyCharm 功能 : 调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制……
 *  PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/
 *

#### 3.3.1 Pycharm的基本使用 ####

##### 下载安装后，新建一个项目 #####

![20191104181153705.jpg][]

##### 选择Python解释器，并确定项目名称 #####

![20191104181322274.jpg][]

##### 新建一个Python源代码文件 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 3][]

##### 给源文件起名字 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 4][]

##### 运行源文件 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 5][]

##### 得到运行结果 #####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 6][]

## 4 Python基础语法 ##

### 4.1 Python注释 ###

#### Python中的注释有单行注释和多行注释： ####

*  python中单行注释采用 \# 开头。

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 文件名：test.py
    
    # 第一个注释
    print("Hello, Python!")  # 第二个注释

输出结果：

Hello, Python!

注释可以在语句或表达式行末：

name = "Madisetti" # 这是一个注释

*  python 中多行注释使用三个单引号(’’’)或三个双引号(""")。

#!/usr/bin/python
    # -*- coding: UTF-8 -*-
    # 文件名：test.py
    
    ''' 这是多行注释，使用单引号。 这是多行注释，使用单引号。 这是多行注释，使用单引号。 '''
    
    """ 这是多行注释，使用双引号。 这是多行注释，使用双引号。 这是多行注释，使用双引号。 """

![20191104181435700.jpg][]

### 4.2 Python语法格式-缩进 ###

*  python最具特色的就是使用缩进来表示代码块，不需要使用大括号(\{\})。
 *  缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
 *  缩进强迫大家写出格式化的代码
 *  当语句以’:’结尾时，缩进的语句视为代码块
 *  约定俗成管理，4个空格为一个缩进
 *  Python大小写敏感

实例如下：

if True:
        print ("True")
    else:
        print ("False")

*  以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

if True:
        print ("Answer")
        print ("True")
    else:
        print ("Answer")
      print ("False")    # 缩进不一致，会导致运行错误

*  以上程序由于缩进不一致，执行后会出现类似以下错误：

File "test.py", line 6
        print ("False")    # 缩进不一致，会导致运行错误
                                          ^
    IndentationError: unindent does not match any outer indentation level

##### 多行语句 #####

*  Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
            item_two + \
            item_three

*  在 \[\], \{\}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
            'item_four', 'item_five']

##### 空行 #####

*  函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
 *  空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
 *  记住：空行也是程序代码的一部分。

### 4.3 输入和输出： ###

#### input()输入： ####

*  input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
 *  input()在从键盘获取了数据以后，会存放到等号右边的变量中
 *  input()会把用户输入的任何值都作为字符串来对待
 *  注意：在python2中还有一个raw\_input()输入，但到python3中没有了

#!/usr/bin/python3
    
    str = input("请输入：");
    print ("你输入的内容是: ", str)

*  这会产生如下的对应着输入的结果：

请输入：Hello Python!
    你输入的内容是:  Hello Python!

#### Print()输出： ####

*  print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

#!/usr/bin/python3
    
    x="a"
    y="b"
    # 换行输出
    print( x )
    print( y )
    
    print('---------')
    # 不换行输出
    print( x, end=" " )
    print( y, end=" " )
    print()
    
    # 同时输出多个变量
    print(x,y)

#### format的格式化函数（了解） ####

*  格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
 *  基本语法是通过 \{\} 和 : 来代替以前的 % 。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
    'hello world'
    
    >>> "{0} {1}".format("hello", "world")  # 设置指定位置
    'hello world'
    
    >>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
    'world hello world'
    
    >>> print("网站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com")) #指定参数名
    '网站名：百度, 地址 www.baidu.com'
    
    
    >>>site = { "name": "百度", "url": "www.baidu.com"}
    >>>print("网站名：{name}, 地址 {url}".format(**site)) # 通过字典设置参数
    '网站名：百度, 地址 www.baidu.com' 
    
    >>>my_list = ['百度', 'www.baidu.com']
    >>>print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的 通过列表索引设置参数
    '网站名：百度, 地址 www.baidu.com'
    
    >>> print("{:.2f}".format(3.1415926)); #数字格式化
    3.14

<table> 
 <thead> 
  <tr> 
   <th>数字</th> 
   <th>格式</th> 
   <th>输出</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>3.1415926</td> 
   <td>{:.2f}</td> 
   <td>3.14</td> 
   <td>保留小数点后两位</td> 
  </tr> 
  <tr> 
   <td>3.1415926</td> 
   <td>{:+.2f}</td> 
   <td>+3.14</td> 
   <td>带符号保留小数点后两位</td> 
  </tr> 
  <tr> 
   <td>-1</td> 
   <td>{:+.2f}</td> 
   <td>-1.00</td> 
   <td>带符号保留小数点后两位</td> 
  </tr> 
  <tr> 
   <td>2.71828</td> 
   <td>{:.0f}</td> 
   <td>3</td> 
   <td>不带小数</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>{:0&gt;2d}</td> 
   <td>05</td> 
   <td>数字补零 (填充左边, 宽度为2)</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>{:x&lt;4d}</td> 
   <td>5xxx</td> 
   <td>数字补x (填充右边, 宽度为4)</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>{:x&lt;4d}</td> 
   <td>10xx</td> 
   <td>数字补x (填充右边, 宽度为4)</td> 
  </tr> 
  <tr> 
   <td>1000000</td> 
   <td>{:,}</td> 
   <td>1,000,000</td> 
   <td>以逗号分隔的数字格式</td> 
  </tr> 
  <tr> 
   <td>0.25</td> 
   <td>{:.2%}</td> 
   <td>25.00%</td> 
   <td>百分比格式</td> 
  </tr> 
  <tr> 
   <td>1000000000</td> 
   <td>{:.2e}</td> 
   <td>1.00e+09</td> 
   <td>指数记法</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>{:10d}</td> 
   <td>13</td> 
   <td>右对齐 (默认, 宽度为10)</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>{:&lt;10d}</td> 
   <td>13</td> 
   <td>左对齐 (宽度为10)</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>{:^10d}</td> 
   <td>13</td> 
   <td>中间对齐 (宽度为10)</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>‘{:b}’.format(11) ‘{:d}’.format(11) ‘{: o}’.format(11) ‘{:x}’.format(11) ‘{:#x}’.format(11) ‘{:#X}’.format(11)</td> 
   <td>1011 11 13 b 0xb 0XB</td> 
   <td>进制</td> 
  </tr> 
 </tbody> 
</table>

#### Python中的变量 ####

*  Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
 *  在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
 *  等号（=）用来给变量赋值。
 *  等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
 *  实例(Python 3.0+)

#!/usr/bin/python3
    
    counter = 100          # 整型变量
    miles   = 1000.0       # 浮点型变量
    name    = "demo"     # 字符串
    
    print (counter)
    print (miles)
    print (name)

*  执行以上程序会输出如下结果：

100
      1000.0
      demo

#### 多个变量赋值 ####

*  Python允许你同时为多个变量赋值。例如：

a = b = c = 1

*  以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
 *  您也可以为多个对象指定多个变量。例如：

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

*  以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 “demo” 分配给变量 c。

#### 变量的命名 ####

*  在一个代码段内，尽量不要重名
 *  变量名由字母、数字、下划线组成,但不能以数字开头
 *  Python 中的标识符是区分大小写
 *  Python保留字: 保留字即关键字，我们不能把它们用作任何变量名称
 *  变量命名要符合PEP8规范，驼峰命名法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 7][]

例如：
    teacherName = 'yh'
    stu_self = MiddleStudent( 'yh',20)

#### 标识符 ####

*  在`Python`里，**标识符: 由字母、数字、下划线组成,但不能以数字开头**。
 *  Python 中的标识符是区分大小写的。
 *  特殊标识符：
    
     *  以下划线开头的标识符是有特殊意义的。以单下划线开头 `_foo` 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 `from xxx import *` 而导入；
     *  以双下划线开头的 `__foo` 代表类的私有成员；以双下划线开头和结尾的 `__foo__` 代表 Python 里特殊方法专用的标识，如 `__init__()` 代表类的构造函数。
 *  python保留字： 保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
      >>> keyword.kwlist
      ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 
      'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 
      'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'if',
      'return','try', 'while', 'with', 'yield']

## 5 数据类型 ##

### 5.1 内置的基本数据类型 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 8][]

*  Python3中，只有一种整型类型int
 *  内置的type()函数可以查询变量所指的对象类型
 *  也可以使用内置的isinstance()函数来判断
 *  Python3中True的值是1，False的值是0
 *  浮点只有单精度float，没有double双精度

### 5.2 Number 数字 ###

*  Python3 支持 int、float、bool、complex（复数）。
 *  在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
 *  像大多数语言一样，数值类型的赋值和计算都是很直观的。
 *  内置的 type() 函数可以用来查询变量所指的对象类型。

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

*  此外还可以用 isinstance 来判断：

>>>a = 111
    >>> isinstance(a, int)
    True
    >>>

*  isinstance 和 type 的区别在于：

class A:
        pass
    
    class B(A):
        pass
    
    isinstance(A(), A)  # returns True
    type(A()) == A      # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False

*  区别就是:
    
     *  type()不会认为子类是一种父类类型。
     *  isinstance()会认为子类是一种父类类型。

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
    到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

*  当你指定一个值时，Number 对象就会被创建：

var1 = 1
    var2 = 10

*  您也可以使用del语句删除一些对象引用。
    
     *  del语句的语法是：
     *  del var1\[,var2\[,var3\[…,varN\]\]\]\]
 *  您可以通过使用del语句删除单个或多个对象。例如

del var
    del var_a, var_b

##### 整数的进制: #####

# 输出其他进制数值
    
    >>> bin(255) #255的二进制
    '0b11111111'
    >>> oct(255) #255的八进制
    '0o377'
    >>> hex(255) #255的十六进制
    '0xff'
    
    >>> a=0b10   #赋值二进制数值
    >>> a
    2
    >>> a=0o10   #赋值八进制数值
    >>> a
    8
    >>> a=0x10   #赋值十六进制数值
    >>> a
    16

### 5.2 字符串 ###

*  Python中字符串三种标示
    
     *  使用单引号(’) str=‘this is string’
     *  使用双引号(") str=“this is string”
     *  使用三引号(’’’) str=’’‘this is string’’’
 *  字符串切片截取语法如下：
 *  变量\[起始下标：结束下标：步进\]
 *  反斜杠可以转义特殊字符
 *  常用字符串操作函数 len(),replace(),index(),find(),split()等
 *  加号 (+) 是字符串的连接符， 星号 (\*) 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：

#!/usr/bin/python3
    
    str = 'zhangsan'
    
    print (str)          # 输出字符串
    print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
    print (str[0])       # 输出字符串第一个字符
    print (str[2:5])     # 输出从第三个开始到第五个的字符
    print (str[2:])      # 输出从第三个开始的后的所有字符
    print (str * 2)      # 输出字符串两次
    print (str + "TEST") # 连接字符串

*  Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个`r`，表示原始字符串：

>>> print('Ru\noob')
    Ru
    oob
    >>> print(r'Ru\noob')
    Ru\noob
    >>>

*  另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。
 *  注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>>word = 'Python'
    >>> print(word[0], word[5])
    P n
    >>> print(word[-1], word[-6])
    n P

*  与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word\[0\] = 'm’会导致错误。
 *  注意：
    
     *  反斜杠可以用来转义，使用`r`可以让反斜杠不发生转义。
     *  字符串可以用+运算符连接在一起，用`*`运算符重复。
     *  Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
     *  Python中的字符串不能改变。

### 5.3 列表 ###

*  List（列表）是一种有序集合，可以随时添加和删除其中元素
 *  列表的元素可以不同
 *  列表同样支持切片截取语法如下：
    
     *  变量\[起始下标：结束下标：步进\]
 *  列表格式\[“yh”,“micheal”,“jack”\]，\[\]之间，元素逗号隔开
 *  索引值从0开始，-1代表末尾
 *  使用(+)可以连接两个列表，(\*)是重复操作

#!/usr/bin/python3
      
      list = [ 'abcd', 786 , 2.23, 'demo', 70.2 ]
      tinylist = [123, 'demo']
      
      print (list)            # 输出完整列表
      print (list[0])         # 输出列表第一个元素
      print (list[1:3])       # 从第二个开始输出到第三个元素
      print (list[2:])        # 输出从第三个元素开始的所有元素
      print (tinylist * 2)    # 输出两次列表
      print (list + tinylist) # 连接列表

*  以上实例输出结果：
    
        ['abcd', 786, 2.23, 'demo', 70.2]
        abcd
        [786, 2.23]
        [2.23, 'demo', 70.2]
        [123, 'demo', 123, 'demo']
        ['abcd', 786, 2.23, 'demo', 70.2, 123, 'demo']
 *  与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]
      >>> a[0] = 9
      >>> a[2:5] = [13, 14, 15]
      >>> a
      [9, 2, 13, 14, 15, 6]
      >>> a[2:5] = []   # 将对应的元素值设置为 [] 
      >>> a
      [9, 2, 6]

*  List内置了有很多方法，例如append()、pop()等
 *  注意
    
     *  List写在方括号之间，元素用逗号隔开。
     *  和字符串一样，list可以被索引和切片。
     *  List可以使用+操作符进行拼接。
     *  List中的元素是可以改变的。

### 5.4 元组 ###

*  Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
 *  元组写在小括号()里，元素之 间用逗号隔开
 *  元组中元素类型也可以不同
 *  列表同样支持切片
 *  索引值从0开始，-1代表末尾
 *  如果元组中的元素只有一个，那么写成(1,)，不要写成(1)

#!/usr/bin/python3
    
    tuple = ( 'abcd', 786 , 2.23, 'demo', 70.2  )
    tinytuple = (123, 'demo')
    
    print (tuple)             # 输出完整元组
    print (tuple[0])          # 输出元组的第一个元素
    print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
    print (tuple[2:])         # 输出从第三个元素开始的所有元素
    print (tinytuple * 2)     # 输出两次元组
    print (tuple + tinytuple) # 连接元组

*  以上实例输出结果：

('abcd', 786, 2.23, 'demo', 70.2)
      abcd
      (786, 2.23)
      (2.23, 'demo', 70.2)
      (123, 'demo', 123, 'demo')
      ('abcd', 786, 2.23, 'demo', 70.2, 123, 'demo')

*  元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。
 *  也可以进行截取（看上面，这里不再赘述）。
 *  其实，可以把字符串看作一种特殊的元组。

>>>tup = (1, 2, 3, 4, 5, 6)
    >>> print(tup[0])
    1
    >>> print(tup[1:5])
    (2, 3, 4, 5)
    >>> tup[0] = 11  # 修改元组元素的操作是非法的
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment
    >>>

*  虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
 *  构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
    tup2 = (20,) # 一个元素，需要在元素后添加逗号
    string、list和tuple都属于sequence（序列）。

*  注意：
    
     *  与字符串一样，元组的元素不能修改。
     *  元组也可以被索引和切片，方法一样。
     *  注意构造包含0或1个元素的元组的特殊语法规则。
     *  元组也可以使用+操作符进行拼接。

### 5.5 集合 ###

*  Set（集合），是一个无序不重复元素的序列
 *  可以使用大括号 \{ \} 或者set()函数创建集合
    
     *  注意:创建一个空集合必须用set()而不是 \{ \}，因为 \{ \} 是用来创建一个空字典
 *  创建格式：
    
     *  \{value1, value2, value3, value4,….\} 或者 set（value）
 *  集合之间可以进行:-差集 &交集 |并集 ^反交集

# set可以进行集合运算
      a = set('abracadabra')
      b = set('alacazam')
      print(a)
      
      print(a - b)     # a和b的差集
      print(a | b)     # a和b的并集
      print(a & b)     # a和b的交集
      print(a ^ b)     # a和b中不同时存在的元素

*  以上实例输出结果：

{ 'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
      Rose 在集合中
      { 'b', 'a', 'c', 'r', 'd'}
      { 'b', 'd', 'r'}
      { 'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
      { 'a', 'c'}
      { 'l', 'r', 'z', 'm', 'b', 'd'}

### 5.6 字典 ###

*  字典（dictionary）是无序集合对象，元素是通过key-value键值对来存取的
 *  字典是一种映射类型，字典用"\{ \}"标识，它是一个无序的键(key) : 值(value) 对集合
 *  键(key)必须使用不可变类型、在同一个字典中，键(key)必须是唯一的
 *  另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
 *  字典方便我们使用查找和搜索功能

#!/usr/bin/python3
    
    dict = { }
    dict['one'] = "1 - Python教程"
    dict[2] = "2 - Python工具"
    
    tinydict = { 'name': 'demo','code':1, 'site': 'www.demo.com'}
    
    
    print (dict['one'])       # 输出键为 'one' 的值
    print (dict[2])           # 输出键为 2 的值
    print (tinydict)          # 输出完整的字典
    print (tinydict.keys())   # 输出所有键
    print (tinydict.values()) # 输出所有值

以上实例输出结果：

1 - Python教程
    2 - Python工具
    { 'name': 'demo', 'site': 'www.demo.com', 'code': 1}
    dict_keys(['name', 'site', 'code'])
    dict_values(['demo', 'www.demo.com', 1])

*  构造函数 dict() 可以直接从键值对序列中构建字典如下：
 *  实例

>>>dict([('demo', 1), ('Google', 2), ('Taobao', 3)])
    { 'Taobao': 3, 'demo': 1, 'Google': 2}
    
    >>> { x: x**2 for x in (2, 4, 6)}
    { 2: 4, 4: 16, 6: 36}
    
    >>> dict(demo=1, Google=2, Taobao=3)
    { 'Taobao': 3, 'demo': 1, 'Google': 2}

*  另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
 *  注意：
    
     *  1、字典是一种映射类型，它的元素是键值对。
     *  2、字典的关键字必须为不可变类型，且不能重复。
     *  3、创建空字典使用 \{ \}。

### 5.7 数据类型转换【扩展内容】 ###

*  有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
 *  以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值

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

##### 数据类型转换分类： #####

*  数据类型转换一共分为2类：自动数据类型转换(隐式转换)和强制数据类型转换(显示转换)

##### 自动数据类型转换/隐式转换 #####

*  自动类型转换是程序根据运算要求进行的转换，不需要人工干预 1.自动类型转换不需要人工干预 2.自动类型转换多发生在运算或者判断过程中 3.转化时向着更加精确的类型转换

##### 强制类型转换/显示转换 #####

*  根据程序需要，由编写程序人员人为改变数据类型的方式就是强制数据类型转换。
 *  int() 将其他类型转化为整型

1.数字整型转化之后，还是原来的味道
    2.浮点类型转化之后，舍去小数部分
    3.布尔值转化之后 True -> 1 False->0
    4.字符串转换，仅纯整型字符串可以转化（浮点型或者带有其他字符都不可以转化）
    5.复数不可以转换

*  float() 将其他类型转化为浮点型

1.整型转换之后变为浮点型，后面+.0
    2.浮点数不需要转化，转化也不会变化
    3.布尔值转化 True->1.0  False ->0.0
    4.字符串，纯整型字符串和纯浮点型字符串可以转换，其他都不可以

*  complex() 将其他数据转化为复数

1.整型转换之后变为 （整型+0j）
    2.浮点型转换之后变为(浮点型 + 0j)
    3.布尔值转化之后 True->（1+0j） False(0j)
    4.字符串，纯整型和浮点型字符串可以转化，其他都不行
    5.复数，无需转换

*  bool() 将其他类型转化为布尔值

#下面转化为布尔值false的情况
        1.整型   0
        2.浮点型  0.0
        3.复数  0+0j
        4.布尔  False
        5.字符串  '' 空字符串
        6.列表   [] 空列表
        7.元组   ()空元组
        8.字典   { } 空字典
        9.集合   set() 空集合

*  str() 将其他类型转化为字符串
    
     *  所有转换均改变类型为字符串，表示方式依旧不变
 *  list() 将其他类型转化为列表类型
    
     *  在python中有5中可迭代序列，可以互相转换，他们分别是：
     *  字符串，列表，元组，字典，集合

var = ('张三','李四','王老五')
    
    newvar = list(var)
    
    newvar的值为 ['张三','李四','王老五']

*  注意：
    
     *  1.字符串转换时每个字符变成列表中的一个值
     *  2.字典类型转换时，仅将字典的键部分转换成列表，忽略值部分
 *  tuple() 将其他类型转化为元组类型

var = { '张三','李四','王老五'}
    
    newvar = tuple(var)
    
    newvar的值为 ('张三','李四','王老五')

*  注意：
    
     *  1.字符串转换时每个字符变成元组中的一个值
     *  2.字典类型转换时，仅将字典的键部分转换成元组，忽略值部分
 *  set（） 将其他类型转化为集合类型

var = ['张三','李四','王老五']
    newvar = set(var)
    newvar的值为 { '张三','李四','王老五'}  #值的顺序不定

*  注意：
    
     *  1.字符串转换时每个字符变成集合中的一个值
     *  2.字典类型转换时，仅将字典的键部分转换集合，忽略值部分
 *  dict() 将其他类型转换为字典类型
 *  其他类型转化为字典时需要按照指定的格式才可以转化：（列表和元组的组合可以）

[['cat', '黑猫警长'], ['mouse', '一只耳'], ['next', '请看夏季']]
    [('cat', '黑猫警长'), （'mouse', '一只耳'）, （'next', '请看夏季'）]

## 6 分支结构 ##

*  流程: 计算机执行代码的顺序就是流程
 *  流程控制: 对计算机代码执行顺序的管理就是流程控制 流程分类:
 *  流程控制一共分为三类:
    
     *  顺序结构
     *  分支结构/选择结构
     *  循环结构
 *  分支结构一共分为4类：
    
     *  单项分支
     *  双项分支
     *  多项分支
     *  巢状分支

### 6.1 单项分支 ###

''' if <条件判断1>: <执行1> '''
    # 例子
    age = 30
    if age >= 18:
    	print('your age is', age) 
    	print('adult')

*  特征：
    
     *  if条件表达式结果为真，则执行if之后所控制代码组，如果为假，则不执行后面的代码组（`:`后面的N行中有相同缩进的代码）
     *  `:`之后下一行的内容必须缩进，否则语法错误！
     *  if之后的代码中如果缩进不一致，则不会if条件表达式是的控制，也不是单项分支的内容，是顺序结构的一部分
     *  if`:`后面的代码是在条件表达式结果为真的情况下执行，所以称之为真区间或者if区间、

### 6.2 双项分支 ###

''' if <条件判断1>: <执行1> else: <执行2> '''
    # 例子
    age = 13
    if age >= 16:
    	print('your age is', age)
    	print('adult')
    else:
    	print('your age is', age)
    	print('teenager')

*  特征:
    
     *  1.双项分支有2个区间:分别是True控制的if区间和False控制的else区间（假区间）
     *  2.if区间的内容在双项分支中必须都缩进，否则语法错误！

### 6.3 多项分支 ###

''' if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: <执行3> else: <执行4> '''
    # 例子
    age = 20
    if age >= 6:
    	print('teenager')
    elif age >= 18:
    	print('adult')
    else:
    	print('kid')

*  特征：
    
     *  1.多项分支可以添加无限个elif分支，无论如何只会执行一个分支
     *  2.执行完一个分支后，分支结构就会结束，后面的分支都不会判断也不会执行
     *  3.多项分支的判断顺序是自上而下逐个分支进行判断
     *  4.在Python中没有switch – case语句。
 *  实例-演示了狗的年龄计算判断：

#!/usr/bin/python3
    
    age = int(input("请输入你家狗狗的年龄: "))
    print("")
    if age < 0:
        print("你是在逗我吧!")
    elif age == 1:
        print("相当于 14 岁的人。")
    elif age == 2:
        print("相当于 22 岁的人。")
    elif age > 2:
        human = 22 + (age -2)*5
        print("对应人类年龄: ", human)
    ### 退出提示
    input("点击 enter 键退出")

### 6.4 巢状分支【\*扩展内容】 ###

*  巢状分支是其他分支结构的嵌套结构，无论哪个分支都可以嵌套

# !/usr/bin/python3
    
    num=int(input("输入一个数字："))
    if num%2==0:
        if num%3==0:
            print ("你输入的数字可以整除 2 和 3")
        else:
            print ("你输入的数字可以整除 2，但不能整除 3")
    else:
        if num%3==0:
            print ("你输入的数字可以整除 3，但不能整除 2")
        else:
            print  ("你输入的数字不能整除 2 和 3")

*  上述程序，执行后输出结果为：

输入一个数字：6
    你输入的数字可以整除 2 和 3

## 7 循环结构 ##

*  循环是让计算机做重复任务的有效方法
 *  循环结构分为2类：`while`循环 和 `for..in`循环

### 7.1 break语句与continue语句 ###

*  break作用:在循环中break的作用是终止当前循环结构的后续操作，一旦程序运行了break，循环也就终止了！
 *  break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下
 *  continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

### 7.2 while循环和break ###

# 1到100求和
    n = 1
    while n <= 100:
    	if n > 10: # 当n = 11时，条件满足，执行break语句
    		break # break语句会结束当前循环
    	print(n)
    	n = n + 1
    print('END')

*  while循环，只要条件满足，就不断循环，条件不满足时退出循环
 *  在循环中，break语句可以提前退出循环

##### 注意：死循环就是循环不会终止的循环类型 #####

### 7.3 while循环和continue ###

n = 0
    while n < 10:
    	n = n + 1
    	if n % 2 == 0: # 如果n是偶数，执行continue语句
    		continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    	print(n)

*  在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环
 *  执行上面的代码可以看到，打印的不再是1～10，而是1，3，5，7，9

### 7.4 for…in循环 ###

# 1到10求和
    sum = 0
    for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    	sum = sum + x
    print(sum)
    
    # 遍历list
    names = [’小红‘, ’小军‘, ’小明']
    for name in names:
    	print(name)
    
    在for…in 循环用

在for…in 循环用于遍历容器类的数据(字符串，列表，元组，字典，集合)

### 7.5 range()函数 ###

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

for i in range(5): # 遍历出0~4的值
    	print(i)
    for i in range(5,9): # 遍历出5~8的值
    	print(i)
    for i in range(0,10,3): # 遍历出0,3,6,9的值
    	print(i)
    for i in range(5-10,-100,-30): # 遍历出-10,-40,-70的值
    	print(i) 
    a = ['Google', 'Baidu', 'Sina', 'Taobao', 'QQ']
    for i in range(len(a)): #遍历列表
    	print(i, a[i])

### 7.6 pass 语句 【扩展内容】 ###

*  Python pass是空语句，是为了保持程序结构的完整性。
 *  pass 不做任何事情，一般用做占位语句，如下实例

## 8 函数 ##

*  函数的本质就是功能的封装。使用函数可以大大提高编程效率与程序的可读性。
 *  函数是能够实现特定功能的计算机代码而已，他是一种特定的代码组结构。
 *  函数的作用
    
     *  1.提升代码的重复利用率，避免重复开发相同代码
     *  2.提高程序开发效率
     *  3.便于程序维护

### 8.1 函数的定制 ###

*  函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
 *  任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
 *  函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
 *  函数内容以冒号起始，并且缩进。
 *  return \[表达式\] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

### 8.2 函数的命名 ###

函数名的命名规则:和变量基本一样

*  1.推荐使用英文或者拼音,禁止使用中文
 *  2.可以使用数字，但是不能用数字开头
 *  3.不可以使用特殊字符，除了\_
 *  4.函数名严格区分大小写
 *  5.函数名必须要有意义。
 *  6.不能和系统已经存在的保留关键字冲突!
 *  7.禁止使用和系统提供函数相同的函数名

### 8.3 带有参数的函数格式 ###

def 函数名(参数,参数….): 
    	函数功能代码...
    	函数功能代码... 
    	return（没有return 默认返回None）
    调用函数: 函数名(参数,参数….)

*  形参: 形式上的参数,声明函数时()中的参数是形参
 *  实参: 实际上的参数,调用函数时()中的参数是实参
 *  注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
 *  参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

形参: 形式上的参数,声明函数时()中的参数是形参  
实参: 实际上的参数,调用函数时()中的参数是实参  
注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已  
参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

#### 8.3.1 函数参数格式 ####

1.  默认值的参数：可选择性输入的参数
2.  可变参数 ：可以输入0到任意个参数，函数内组装成tuple
3.  关键字参数：可以输入0到任意个含参数名参数，函数内组装成一个dict
4.  命名关键字参数
5.  多种参数混合：顺序是必选，默认，可变，命名关键字，关键字

### 8.4 函数返回值 ###

*  调函数根据执行完毕是否可以得到一个结果，将函数分为2个类型:
    
     *  执行过程函数: print()
     *  具有返回值的函数:id(),type()
 *  return的特征:
    
     *  具有return语句的函数称为具有返回值的函数
     *  return可以为当前函数执行完毕返回一个结果，这样的函数调用可以被接受
     *  return执行之后，函数则会终止，所有return之后的语句不会被执行
     *  一个函数可以书写多个return语句，但是一般会放入分支结构当中
     *  一个函数若要返回多个数据，可借助复合数据类型(list，tuple，set，dict) 来操作即可!
     *  不带参数值的return语句返回None

### 8.5 函数文档 ###

*  函数文档就是用来查看当前函数相关信息介绍的一个特定格式而已
 *  查看函数文档的方法:
    
     *  help(函数名称) \# 直接输出显示函数文档的内容字符串
     *  函数名.doc \# 直接输出显示函数文档的内容元字符串(转义字符不转义)
     *  官方文档 http://docs.python.org/3/library/functions.html

def 函数名(参数...): 
    	''' 在此处声明函数文档 ''' 
    	函数功能代码...

*  注意:函数文档的作用是对函数进行说明，便于阅读和快速掌握函数的使用，通常函数文档需要具有以下信息:
    
     *  函数的作用
     *  函数的参数介绍(个数，数据类型)
     *  函数的返回值(数据和类型)

### 8.6 局部变量和全局变量 ###

*  定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
 *  局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python3
    
    total = 0; # 这是一个全局变量
    # 可写函数说明
    def sum( arg1, arg2 ):
        #返回2个参数的和."
        total = arg1 + arg2; # total在这里是局部变量.
        print ("函数内是局部变量 : ", total)
        return total;
    
    #调用sum函数
    sum( 10, 20 );
    print ("函数外是全局变量 : ", total)

*  以上实例输出结果：

函数内是局部变量 :  30
    函数外是全局变量 :  0

### 8.7 匿名函数【扩展内容】 ###

*  python 使用 lambda 来创建匿名函数。
 *  所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
 *  lambda 只是一个表达式，函数体比 def 简单很多。
 *  lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
 *  lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
 *  虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
 *  语法:
 *  lambda 函数的语法只包含一个语句，如下：

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

*  如下实例：

#!/usr/bin/python3
    
    # 可写函数说明
    sum = lambda arg1, arg2: arg1 + arg2;
    
    # 调用sum函数
    print ("相加后的值为 : ", sum( 10, 20 ))
    print ("相加后的值为 : ", sum( 20, 20 ))

*  以上实例输出结果：

相加后的值为 :  30
    相加后的值为 :  40

## 9 文件读写 ##

### 9.1 Python 内置的文件读写操作 ###

*  open（） 打开或者创建一个文件

格式：open('文件路径','打开模式')
        返回值：文件io对象
        打开模式一共N种：
            w模式 写模式write  文件不存在时会创建文件，如果文件已存在则会清空文件
            r模式  读模式read  文件不存在就报错，存在则准备读取文件
            a模式 追加模式 append 文件不存在则新建，文件存在则在文件末尾追加内容
            x模式 抑或模式 xor 文件存在则报错，文件 不存在则新建文件
            b模式 二进制模式 binary 辅助模式不能单独使用
            +模式 增强模式plus  也是辅助模式不能单独使用

*  以上模式可以互相组合：wrax不可以互相组合:

<table> 
 <thead> 
  <tr> 
   <th>模式</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>r</td> 
   <td>以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。</td> 
  </tr> 
  <tr> 
   <td>w</td> 
   <td>打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td>rb</td> 
   <td>以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。</td> 
  </tr> 
  <tr> 
   <td>wb</td> 
   <td>以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>ab</td> 
   <td>以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td> 
  </tr> 
  <tr> 
   <td>r+</td> 
   <td>打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td>w+</td> 
   <td>打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>a+</td> 
   <td>打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。</td> 
  </tr> 
  <tr> 
   <td>rb+</td> 
   <td>以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。</td> 
  </tr> 
  <tr> 
   <td>wb+</td> 
   <td>以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。</td> 
  </tr> 
  <tr> 
   <td>ab+</td> 
   <td>以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写</td> 
  </tr> 
 </tbody> 
</table>

*  close() 关闭文件

### 9.2 读写函数： ###

*  read() 读取文件

''' 格式：文件io对象.read() 返回值：整个文件的字符 格式：文件io对象.read(字符长度) 返回值：指定长度的字符 '''
    f = open('test.txt', 'r')
    content = f.read(5)
    print(content)
    print("-"*30)
    content = f.read()
    print(content)
    f.close()

*  readline() 读取一行文件

''' 格式:文件io对象.readline() 返回值：一行内容的字符串 格式：文件io对象.readline（字符长度） 返回值：一行内容的字符串 注意：字符长度<当前行内内容，则读取指定长度的字符串，并且下次再读取还是在 这个一行中获取没有读取的内容。字符长度>=当前行内容，直接读取当前行 '''
    #coding=utf-8
    
    f = open('test.txt', 'r')
    content = f.readline()
    print("1:%s"%content)
    content = f.readline()
    print("2:%s"%content)
    f.close()

*  readlines() 将文件中的内容读取到序列当中。

''' 格式：文件io对象.readlines() 返回值：列表 格式：文件io对象.readlines(字符长度) 返回值：列表 注意：读取的行数由字符长度决定，如果字符长度读取了N行后，还有指定长度的字符 没有读取，则直接读取下一行进来 '''
    #coding=utf-8
    
    f = open('test.txt', 'r')
    content = f.readlines()
    print(type(content))
    i=1
    for temp in content:
        print("%d:%s"%(i, temp))
        i+=1
    f.close()

*  write() 写入文件

格式：文件io对象.write(字符串)
    返回值：写入字符串的长度

*  writelines() 将序列写入文件中

格式：文件io对象.writelines(序列)
    返回值：None

*  truncate() 字符串截取操作

格式：文件io对象.truncate(字节长度)
    返回值：截取的字节长度

### 9.3 OS模块 ###

*  OS – 操作系统的简称
 *  os模块就是对操作系统进行操作
 *  使用该模块必须先导入模块：

import os

##### os模块中的函数: #####

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>描述</th> 
   <th>格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>getcwd()</td> 
   <td>获取当前的工作目录</td> 
   <td>格式：os.getcwd() 返回值：路径字符串</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>chdir()</td> 
   <td>修改当前工作目录</td> 
   <td>格式:os.chdir() 返回值:None</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>listdir()</td> 
   <td>获取指定文件夹中的 所有文件和文件夹组成的列表</td> 
   <td>格式:os.listdir(目录路径) 返回值：目录中内容名称的列表</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>mkdir()</td> 
   <td>创建一个目录/文件夹</td> 
   <td>格式：os.mkdir(目录路径) 返回值：None</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>makedirs()</td> 
   <td>递归创建文件夹</td> 
   <td>格式:os.makedirs(路径)</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>rmdir()</td> 
   <td>移除一个目录（必须是空目录）</td> 
   <td>格式：os.rmdir(目录路径) 返回值:None</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>removedirs()</td> 
   <td>递归删除文件夹</td> 
   <td>格式：os.removedirs(目录路径) 返回值：None 注意最底层目录必须为空</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>rename()</td> 
   <td>修改文件和文件夹的名称</td> 
   <td>格式：os.rename(源文件或文件夹，目标文件或文件夹) 返回值：None</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>stat()</td> 
   <td>获取文件的相关 信息</td> 
   <td>格式：os.stat(文件路径) 返回值：包含文件信息的元组</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>system()</td> 
   <td>执行系统命令</td> 
   <td>格式:os.system() 返回值：整型 慎用！ 玩意来个rm -rf 你就爽了！</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>getenv()</td> 
   <td>获取系统环境变量</td> 
   <td>格式：os.getenv(获取的环境变量名称) 返回值：字符串</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>putenv()</td> 
   <td>设置系统环境变量</td> 
   <td>格式：os.putenv(‘环境变量名称’,值) 返回值：无 注意：无法正常的getenv检测到。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>exit()</td> 
   <td>推出当前执行命令，直接关闭当前操作</td> 
   <td>格式:exit() 返回值：无</td> 
  </tr> 
 </tbody> 
</table>

#### 当前os模块的值: ####

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>curdir</td> 
   <td>os.curdir 获取当前路径 都是.</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>pardir</td> 
   <td>os.pardir 获取上层目录路径 都是…</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>path</td> 
   <td>os.path os中的一个子模块，操作非常多</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>name</td> 
   <td>os.name 当前系统的内核名称 win-&gt;nt linux/unix-&gt;posix</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>sep</td> 
   <td>os.sep 获取当前系统的路径分割符号 window -&gt; \ linux/unix -&gt; /</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>extsep</td> 
   <td>os.extsep 获取当前系统中文件名和后缀之间的分割符号，所有系统都是.</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>linesep</td> 
   <td>os.linesep 获取当前系统的换行符号 window -&gt; \r\n linux/unix -&gt; \n</td> 
  </tr> 
 </tbody> 
</table>

##### os.environ模块 #####

*  os.environ 可以直接获取所有环境变量的信息组成的字典，如果希望更改环境变量，并且可以查询得到，就需要对os.environ进行操作
 *  该模块的所有方法均是字典的方法，可以通过字典的os.environ的结果进行操作。
 *  注意：无论使用os.getenv，putenv 还是使用os.environ进行环境变量的操作，都是只对当前脚本，临时设置而已，无法直接更新或者操作系统的环境变量设置。

##### os.path模块 #####

*  os.path是os模块中的子模块，包含很多和路径相关的操作
 *  函数部分:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>描述</th> 
   <th>格式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>abspath()</td> 
   <td>将一个相对路径转化为绝对路径</td> 
   <td>格式：os.path.abspath(相对路径) 返回值：绝对路径字符串</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>basename()</td> 
   <td>获取路径中的文件夹或者文件名称 （只要路径的最后一部分）</td> 
   <td>格式：os.path.basename(路径) 返回值：路径的最后一部分(可能是文件名也可能是文件夹名)</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>dirname()</td> 
   <td>获取路径中的路径部分(出去最后一部分)</td> 
   <td>格式:os.path.dirname(路径) 返回值：路径中除了最后一部分的内容字符串</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>join()</td> 
   <td>将2个路径合成一个路径</td> 
   <td>格式：os.path.join(路径1,路径2) 返回值：合并之后的路径</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>split（）</td> 
   <td>将一个路径切割成文件夹和文件名部分</td> 
   <td>格式：os.path.split(路径) 返回值：元组</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>splitext()</td> 
   <td>将一个文件名切成名字和后缀两个部分</td> 
   <td>格式：os.path.splitext(文件名称) 返回值：元组 （名称,后缀）</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>getsize()</td> 
   <td>获取一个文件的大小</td> 
   <td>格式:os.path.getsize(路径) 返回值：整数</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>isfile()</td> 
   <td>检测一个路径是否是一个文件</td> 
   <td>格式：os.path.isfile(路径) 返回值：布尔值</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>isdir()</td> 
   <td>检测一个路径是否是一个文件夹</td> 
   <td>格式：os.path.isdir(路径) 返回值：布尔值</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>getctime()</td> 
   <td>获取文件的创建时间！ get create time</td> 
   <td>格式：os.path.getctime(文件路径) 返回值：时间戳浮点数</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>getmtime()</td> 
   <td>获取文件的修改时间！ get modify time</td> 
   <td>格式：os.path.getmtime(文件路径) 返回值：时间戳浮点数</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>getatime()</td> 
   <td>获取文件的访问时间！ get active time</td> 
   <td>格式：os.path.getatime(文件路径) 返回值：时间戳浮点数</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>exists()</td> 
   <td>检测指定的路径是否存在</td> 
   <td>格式：os.path.exists(路径) 返回值：布尔值</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>isabs()</td> 
   <td>检测一个路径是否是绝对路径</td> 
   <td>格式:os.path.isabs(路径) 返回值：布尔值</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>islink()</td> 
   <td>检测一个路径是否是链接</td> 
   <td>格式:os.path.islink(路径) 返回值:布尔值</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>samefile()</td> 
   <td>检测2个路径是否指向同一个文件</td> 
   <td>格式:os.path.samefile(路径1,路径2) 返回值：布尔值</td> 
  </tr> 
 </tbody> 
</table>

## 10 Python运算符【扩展内容】 ##

*  本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，"+" 称为运算符。
 *  Python语言支持以下类型的运算符:
    
    1.  算术运算符
    2.  比较（关系）运算符
    3.  赋值运算符
    4.  逻辑运算符
    5.  位运算符
    6.  成员运算符
    7.  身份运算符
    8.  运算符优先级

#### 10.1 Python算术运算符: ####

*  以下假设变量a为10，变量b为21：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加 - 两个对象相加</td> 
   <td>a + b 输出结果 31</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减 - 得到负数或是一个数减去另一个数</td> 
   <td>a - b 输出结果 -11</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘 - 两个数相乘或是返回一个被重复若干次字串</td> 
   <td>a * b 输出结果 210</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除 - x 除以 y</td> 
   <td>b / a 输出结果 2.1</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取模 - 返回除法的余数</td> 
   <td>b % a 输出结果 1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂 - 返回x的y次幂</td> 
   <td>a**b 为10的21次方</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>取整除 - 返回商的整数部分</td> 
   <td>9//2 输出结果 4 , 9.0//2.0 输出结果 4.0</td> 
  </tr> 
 </tbody> 
</table>

#### 10.2 Python比较运算符: ####

*  以下假设变量a为10，变量b为20：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>等于 - 比较对象是否相等</td> 
   <td>(a == b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于 - 比较两个对象是否不相等</td> 
   <td>(a != b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>大于 - 返回x是否大于y</td> 
   <td>(a &gt; b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于 - 返回x是否小于y。返回1表示真，返回0表示假。 这分别与特殊的变量True和False等价。注意，这些变量名的大写。</td> 
   <td>(a &lt; b) 返回 True。</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于 - 返回x是否大于等于y。</td> 
   <td>(a &gt;= b) 返回 False。</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于 - 返回x是否小于等于y。</td> 
   <td>(a &lt;= b) 返回 True。</td> 
  </tr> 
 </tbody> 
</table>

#### 10.3 Python赋值运算符: ####

*  以下假设变量a为10，变量b为20：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>简单的赋值运算符</td> 
   <td>c = a + b 将 a + b 的运算结果赋值为 c</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等效于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等效于 c = c - a</td> 
  </tr> 
  <tr> 
   <td><code>*=</code></td> 
   <td>乘法赋值运算符</td> 
   <td><code>c *= a</code> 等效于 <code>c = c * a</code></td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等效于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模赋值运算符</td> 
   <td>c %= a 等效于 c = c % a</td> 
  </tr> 
  <tr> 
   <td><code>**=</code></td> 
   <td>幂赋值运算符</td> 
   <td><code>c **= a</code> 等效于 <code>c = c ** a</code></td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整除赋值运算符</td> 
   <td>c //= a 等效于 c = c // a</td> 
  </tr> 
 </tbody> 
</table>

#### 10.4 Python位运算符： ####

*  按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
 *  下表中变量 a 为 60，b 为 13二进制格式如下：

>>> a=18        
    >>> bin(a)      # 将变量a的数值转成二进制数值输出
    '0b10010'
    
    >>> b = 0b10010  #将二进制的数值赋给变量b
    >>> b
    18
    
    # 下面是二进制运算
    a = 0011 1100
    b = 0000 1101
    -----------------
    a&b = 0000 1100
    a|b = 0011 1101
    a^b = 0011 0001
    ~a  = 1100 0011

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;</td> 
   <td>按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0</td> 
   <td>(a &amp; b) 输出结果 12 ，二进制解释： 0000 1100</td> 
  </tr> 
  <tr> 
   <td>l</td> 
   <td>按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。</td> 
   <td>(a l b) 输出结果 61 ，二进制解释： 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>按位异或运算符：当两对应的二进位相异时，结果为1</td> 
   <td>(a ^ b) 输出结果 49 ，二进制解释： 0011 0001</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1</td> 
   <td>(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移动运算符：运算数的各二进位全部左移若干位，由"&lt;&lt;"右边的数指定移动的位数，高位丢弃，低位补0。</td> 
   <td>a &lt;&lt; 2 输出结果 240 ，二进制解释： 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移动运算符：把"&gt;&gt;“左边的运算数的各二进位全部右移若干位，”&gt;&gt;"右边的数指定移动的位数</td> 
   <td>a &gt;&gt; 2 输出结果 15 ，二进制解释： 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

#### (5). Python逻辑运算符: ####

*  Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>逻辑表达式</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。</td> 
   <td>(a and b) 返回 20。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。</td> 
   <td>(a or b) 返回 10。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not(a and b) 返回 False</td> 
  </tr> 
 </tbody> 
</table>

#### 10.5 Python成员运算符: ####

*  除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>in</td> 
   <td>如果在指定的序列中找到值返回 True，否则返回 False。</td> 
   <td>x 在 y 序列中 , 如果 x 在 y 序列中返回 True。</td> 
  </tr> 
  <tr> 
   <td>not in</td> 
   <td>如果在指定的序列中没有找到值返回 True，否则返回 False。</td> 
   <td>x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。</td> 
  </tr> 
 </tbody> 
</table>

#!/usr/bin/python3
    
    a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ];
    
    if ( a in list ):
       print ("1 - 变量 a 在给定的列表中 list 中")
    else:
       print ("1 - 变量 a 不在给定的列表中 list 中")
    
    if ( b not in list ):
       print ("2 - 变量 b 不在给定的列表中 list 中")
    else:
       print ("2 - 变量 b 在给定的列表中 list 中")
    
    # 修改变量 a 的值
    a = 2
    if ( a in list ):
       print ("3 - 变量 a 在给定的列表中 list 中")
    else:
       print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中
    2 - 变量 b 不在给定的列表中 list 中
    3 - 变量 a 在给定的列表中 list 中

#### 10.6 Python身份运算符 ####

*  身份运算符用于比较两个对象的存储单元

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>is</td> 
   <td>is是判断两个标识符是不是引用自一个对象</td> 
   <td>x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>is not 是判断两个标识符是不是引用自不同对象</td> 
   <td>x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

*  注： `id()` 函数用于获取对象内存地址。

#!/usr/bin/python3
    
    a = 20
    b = 20
    
    if ( a is b ):
       print ("1 - a 和 b 有相同的标识")
    else:
       print ("1 - a 和 b 没有相同的标识")
    
    if ( id(a) == id(b) ):
       print ("2 - a 和 b 有相同的标识")
    else:
       print ("2 - a 和 b 没有相同的标识")
    
    # 修改变量 b 的值
    b = 30
    if ( a is b ):
       print ("3 - a 和 b 有相同的标识")
    else:
       print ("3 - a 和 b 没有相同的标识")
    
    if ( a is not b ):
       print ("4 - a 和 b 没有相同的标识")
    else:
       print ("4 - a 和 b 有相同的标识")

*  以上实例输出结果：

1 - a 和 b 有相同的标识
    2 - a 和 b 有相同的标识
    3 - a 和 b 没有相同的标识
    4 - a 和 b 没有相同的标识

##### is 与 == 区别： #####

# is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
    >>>a = [1, 2, 3]
    >>> b = a
    >>> b is a 
    True
    >>> b == a
    True
    >>> b = a[:]   # 其中[:]表示复制传值
    >>> b is a
    False
    >>> b == a
    True

#### 10.7 Python运算符优先级: ####

*  以下表格列出了从最高到最低优先级的所有运算符：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>**</td> 
   <td>指数 (最高优先级)</td> 
  </tr> 
  <tr> 
   <td>~ + -</td> 
   <td>按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)</td> 
  </tr> 
  <tr> 
   <td>* / % //</td> 
   <td>乘，除，取模和取整除</td> 
  </tr> 
  <tr> 
   <td>+ -</td> 
   <td>加法减法</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt; &lt;&lt;</td> 
   <td>右移，左移运算符</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>位 ‘AND’</td> 
  </tr> 
  <tr> 
   <td>^ l</td> 
   <td>位运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;= &lt; &gt; &gt;=</td> 
   <td>比较运算符</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt; == !=</td> 
   <td>等于运算符</td> 
  </tr> 
  <tr> 
   <td>= %= /= //= -= += *= **=</td> 
   <td>赋值运算符</td> 
  </tr> 
  <tr> 
   <td>is is not</td> 
   <td>身份运算符</td> 
  </tr> 
  <tr> 
   <td>in not in</td> 
   <td>成员运算符</td> 
  </tr> 
  <tr> 
   <td>not or and</td> 
   <td>逻辑运算符</td> 
  </tr> 
 </tbody> 
</table>

## 11 Python数据类型的操作【扩展内容】 ##

### 11.1 Number数字 ###

#### 11.1.1 数学函数 ####

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>返回值 ( 描述 )</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>abs(x)</td> 
   <td>返回数字的绝对值，如abs(-10) 返回 10</td> 
  </tr> 
  <tr> 
   <td>ceil(x)</td> 
   <td>返回数字的上入整数，如math.ceil(4.1) 返回 5</td> 
  </tr> 
  <tr> 
   <td>cmp(x, y)</td> 
   <td>如果 x &lt; y 返回 -1, 如果 x == y 返回 0, 如果 x &gt; y 返回 1。 Python 3 已废弃 。使用 使用 (x&gt;y)-(x&lt;y) 替换。</td> 
  </tr> 
  <tr> 
   <td>exp(x)</td> 
   <td>返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045</td> 
  </tr> 
  <tr> 
   <td>fabs(x)</td> 
   <td>返回数字的绝对值，如math.fabs(-10) 返回10.0</td> 
  </tr> 
  <tr> 
   <td>floor(x)</td> 
   <td>返回数字的下舍整数，如math.floor(4.9)返回 4</td> 
  </tr> 
  <tr> 
   <td>log(x)</td> 
   <td>如math.log(math.e)返回1.0,math.log(100,10)返回2.0</td> 
  </tr> 
  <tr> 
   <td>log10(x)</td> 
   <td>返回以10为基数的x的对数，如math.log10(100)返回 2.0</td> 
  </tr> 
  <tr> 
   <td>max(x1, x2,…)</td> 
   <td>返回给定参数的最大值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td>min(x1, x2,…)</td> 
   <td>返回给定参数的最小值，参数可以为序列。</td> 
  </tr> 
  <tr> 
   <td>modf(x)</td> 
   <td>返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。</td> 
  </tr> 
  <tr> 
   <td>pow(x, y)</td> 
   <td><code>x**y</code> 运算后的值。</td> 
  </tr> 
  <tr> 
   <td>round(x [,n])</td> 
   <td>返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。</td> 
  </tr> 
  <tr> 
   <td>sqrt(x)</td> 
   <td>返回数字x的平方根。</td> 
  </tr> 
 </tbody> 
</table>

#### 11.1.2 随机数函数 ####

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>choice(seq)</td> 
   <td>从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。</td> 
  </tr> 
  <tr> 
   <td>randrange ([start,] stop [,step])</td> 
   <td>从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1</td> 
  </tr> 
  <tr> 
   <td>random()</td> 
   <td>随机生成下一个实数，它在[0,1)范围内。</td> 
  </tr> 
  <tr> 
   <td>seed([x])</td> 
   <td>改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。</td> 
  </tr> 
  <tr> 
   <td>shuffle(lst)</td> 
   <td>将序列的所有元素随机排序</td> 
  </tr> 
  <tr> 
   <td>uniform(x, y)</td> 
   <td>随机生成下一个实数，它在[x,y]范围内。</td> 
  </tr> 
 </tbody> 
</table>

#### 11.1.3 三角函数 ####

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>acos(x)</td> 
   <td>返回x的反余弦弧度值。</td> 
  </tr> 
  <tr> 
   <td>asin(x)</td> 
   <td>返回x的反正弦弧度值。</td> 
  </tr> 
  <tr> 
   <td>atan(x)</td> 
   <td>返回x的反正切弧度值。</td> 
  </tr> 
  <tr> 
   <td>atan2(y, x)</td> 
   <td>返回给定的 X 及 Y 坐标值的反正切值。</td> 
  </tr> 
  <tr> 
   <td>cos(x)</td> 
   <td>返回x的弧度的余弦值。</td> 
  </tr> 
  <tr> 
   <td>hypot(x, y)</td> 
   <td>返回欧几里德范数 sqrt(x<em>x + y</em>y)。</td> 
  </tr> 
  <tr> 
   <td>sin(x)</td> 
   <td>返回的x弧度的正弦值。</td> 
  </tr> 
  <tr> 
   <td>tan(x)</td> 
   <td>返回x弧度的正切值。</td> 
  </tr> 
  <tr> 
   <td>degrees(x)</td> 
   <td>将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0</td> 
  </tr> 
  <tr> 
   <td>radians(x)</td> 
   <td>将角度转换为弧度</td> 
  </tr> 
 </tbody> 
</table>

#### 11.1.4 数学常量 ####

<table> 
 <thead> 
  <tr> 
   <th>常量</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>pi</td> 
   <td>数学常量 pi（圆周率，一般以π来表示）</td> 
  </tr> 
  <tr> 
   <td>e</td> 
   <td>数学常量 e，e即自然常数（自然常数）。</td> 
  </tr> 
 </tbody> 
</table>

## 11.2 String字符串 ##

#### 11.2.1 Python转义字符 ####

<table> 
 <thead> 
  <tr> 
   <th>转义字符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>(在行尾时)</td> 
   <td>续行符</td> 
  </tr> 
  <tr> 
   <td>\</td> 
   <td>反斜杠符号</td> 
  </tr> 
  <tr> 
   <td>’</td> 
   <td>单引号</td> 
  </tr> 
  <tr> 
   <td>"</td> 
   <td>双引号</td> 
  </tr> 
  <tr> 
   <td>\a</td> 
   <td>响铃</td> 
  </tr> 
  <tr> 
   <td>\b</td> 
   <td>退格(Backspace)</td> 
  </tr> 
  <tr> 
   <td>\e</td> 
   <td>转义</td> 
  </tr> 
  <tr> 
   <td>\000</td> 
   <td>空</td> 
  </tr> 
  <tr> 
   <td>\n</td> 
   <td>换行</td> 
  </tr> 
  <tr> 
   <td>\v</td> 
   <td>纵向制表符</td> 
  </tr> 
  <tr> 
   <td>\t</td> 
   <td>横向制表符</td> 
  </tr> 
  <tr> 
   <td>\r</td> 
   <td>回车</td> 
  </tr> 
  <tr> 
   <td>\f</td> 
   <td>换页</td> 
  </tr> 
  <tr> 
   <td>\oyy</td> 
   <td>八进制数，yy代表的字符，例如：\o12代表换行</td> 
  </tr> 
  <tr> 
   <td>\xyy</td> 
   <td>十六进制数，yy代表的字符，例如：\x0a代表换行</td> 
  </tr> 
  <tr> 
   <td>\other</td> 
   <td>其它的字符以普通格式输出</td> 
  </tr> 
 </tbody> 
</table>

#### 11.2.2 Python字符串运算符 ####

*  下表实例变量a值为字符串 “Hello”，b变量值为 “Python”：

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>字符串连接</td> 
   <td>a + b 输出结果： HelloPython</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>重复输出字符串</td> 
   <td>a*2 输出结果：HelloHello</td> 
  </tr> 
  <tr> 
   <td>[]</td> 
   <td>通过索引获取字符串中字符</td> 
   <td>a[1] 输出结果 e</td> 
  </tr> 
  <tr> 
   <td>[ : ]</td> 
   <td>截取字符串中的一部分</td> 
   <td>a[1:4] 输出结果 ell</td> 
  </tr> 
  <tr> 
   <td>in</td> 
   <td>成员运算符 - 如果字符串中包含给定的字符返回 True</td> 
   <td>H in a 输出结果 1</td> 
  </tr> 
  <tr> 
   <td>not in</td> 
   <td>成员运算符 - 如果字符串中不包含给定的字符返回 True</td> 
   <td>M not in a 输出结果 1</td> 
  </tr> 
  <tr> 
   <td>r/R</td> 
   <td>原始字符串 - 原始字符串：所有的字符串都是直接按照字面 的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大 小写）以外，与普通字符串有着几乎完全相同的语法。</td> 
   <td>print r’\n’ prints \n 和 print R’\n’ prints \n</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>格式字符串</td> 
   <td>请看下一节内容。</td> 
  </tr> 
 </tbody> 
</table>

#!/usr/bin/python3
    
    a = "Hello"
    b = "Python"
    
    print("a + b 输出结果：", a + b)
    print("a * 2 输出结果：", a * 2)
    print("a[1] 输出结果：", a[1])
    print("a[1:4] 输出结果：", a[1:4])
    
    if( "H" in a) :
        print("H 在变量 a 中")
    else :
        print("H 不在变量 a 中")
    
    if( "M" not in a) :
        print("M 不在变量 a 中")
    else :
        print("M 在变量 a 中")
    
    print (r'\n')
    print (R'\n')

*  以上实例输出结果为：

a + b 输出结果： HelloPython
    a * 2 输出结果： HelloHello
    a[1] 输出结果： e
    a[1:4] 输出结果： ell
    H 在变量 a 中
    M 不在变量 a 中
    \n
    \n

#### 11.2.3 Python字符串格式化: ####

*  Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
 *  在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python3
    
    print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
    
    # 以上实例输出结果：
    # 我叫 小明 今年 10 岁!

\*python字符串格式化符号:

<table> 
 <thead> 
  <tr> 
   <th>符 号</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>%c</td> 
   <td>格式化字符及其ASCII码</td> 
  </tr> 
  <tr> 
   <td>%s</td> 
   <td>格式化字符串</td> 
  </tr> 
  <tr> 
   <td>%d</td> 
   <td>格式化整数</td> 
  </tr> 
  <tr> 
   <td>%u</td> 
   <td>格式化无符号整型</td> 
  </tr> 
  <tr> 
   <td>%o</td> 
   <td>格式化无符号八进制数</td> 
  </tr> 
  <tr> 
   <td>%x</td> 
   <td>格式化无符号十六进制数</td> 
  </tr> 
  <tr> 
   <td>%X</td> 
   <td>格式化无符号十六进制数（大写）</td> 
  </tr> 
  <tr> 
   <td>%f</td> 
   <td>格式化浮点数字，可指定小数点后的精度</td> 
  </tr> 
  <tr> 
   <td>%e</td> 
   <td>用科学计数法格式化浮点数</td> 
  </tr> 
  <tr> 
   <td>%E</td> 
   <td>作用同%e，用科学计数法格式化浮点数</td> 
  </tr> 
  <tr> 
   <td>%g</td> 
   <td>%f和%e的简写</td> 
  </tr> 
  <tr> 
   <td>%G</td> 
   <td>%f 和 %E 的简写</td> 
  </tr> 
  <tr> 
   <td>%p</td> 
   <td>用十六进制数格式化变量的地址</td> 
  </tr> 
 </tbody> 
</table>

*  格式化操作符辅助指令:

<table> 
 <thead> 
  <tr> 
   <th>符号</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>*</td> 
   <td>定义宽度或者小数点精度</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>用做左对齐</td> 
  </tr> 
  <tr> 
   <td>+</td> 
   <td>在正数前面显示加号( + )</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>在正数前面显示空格</td> 
  </tr> 
  <tr> 
   <td>#</td> 
   <td>在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)</td> 
  </tr> 
  <tr> 
   <td>0</td> 
   <td>显示的数字前面填充’0’而不是默认的空格</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>‘%%‘输出一个单一的’%’</td> 
  </tr> 
  <tr> 
   <td>(var)</td> 
   <td>映射变量(字典参数)</td> 
  </tr> 
  <tr> 
   <td>m.n.</td> 
   <td>m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)</td> 
  </tr> 
 </tbody> 
</table>

*  Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

#### 11.2.4 Python 的字符串内建函数: ####

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>capitalize()</td> 
   <td>将字符串的第一个字符转换为大写</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>center(width, fillchar)</td> 
   <td>返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>count(str, beg= 0,end=len(string))</td> 
   <td>返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>bytes.decode(encoding=“utf-8”, errors=“strict”)</td> 
   <td>Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>encode(encoding=‘UTF-8’,errors=‘strict’)</td> 
   <td>以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>endswith(suffix, beg=0, end=len(string))</td> 
   <td>检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>expandtabs(tabsize=8)</td> 
   <td>把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>find(str, beg=0 end=len(string))</td> 
   <td>检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>index(str, beg=0, end=len(string))</td> 
   <td>跟find()方法一样，只不过如果str不在字符串中会报一个异常.</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>isalnum()</td> 
   <td>如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>isalpha()</td> 
   <td>如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>isdigit()</td> 
   <td>如果字符串只包含数字则返回 True 否则返回 False…</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>islower()</td> 
   <td>如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>isnumeric()</td> 
   <td>如果字符串中只包含数字字符，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>isspace()</td> 
   <td>如果字符串中只包含空白，则返回 True，否则返回 False.</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>istitle()</td> 
   <td>如果字符串是标题化的(见 title())则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td>isupper()</td> 
   <td>如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td>join(seq)</td> 
   <td>以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td>len(string)</td> 
   <td>返回字符串长度</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td>ljust(width[, fillchar])</td> 
   <td>返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。</td> 
  </tr> 
  <tr> 
   <td>21</td> 
   <td>lower()</td> 
   <td>转换字符串中所有大写字符为小写.</td> 
  </tr> 
  <tr> 
   <td>22</td> 
   <td>lstrip()</td> 
   <td>截掉字符串左边的空格或指定字符。</td> 
  </tr> 
  <tr> 
   <td>23</td> 
   <td>maketrans()</td> 
   <td>创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。</td> 
  </tr> 
  <tr> 
   <td>24</td> 
   <td>max(str)</td> 
   <td>返回字符串 str 中最大的字母。</td> 
  </tr> 
  <tr> 
   <td>25</td> 
   <td>min(str)</td> 
   <td>返回字符串 str 中最小的字母。</td> 
  </tr> 
  <tr> 
   <td>26</td> 
   <td>replace(old, new [, max])</td> 
   <td>把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。</td> 
  </tr> 
  <tr> 
   <td>27</td> 
   <td>rfind(str, beg=0,end=len(string))</td> 
   <td>类似于 find()函数，不过是从右边开始查找.</td> 
  </tr> 
  <tr> 
   <td>28</td> 
   <td>rindex( str, beg=0, end=len(string))</td> 
   <td>类似于 index()，不过是从右边开始.</td> 
  </tr> 
  <tr> 
   <td>29</td> 
   <td>rjust(width,[, fillchar])</td> 
   <td>返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串</td> 
  </tr> 
  <tr> 
   <td>30</td> 
   <td>rstrip()</td> 
   <td>删除字符串字符串末尾的空格.</td> 
  </tr> 
  <tr> 
   <td>31</td> 
   <td>split(str="", num=string.count(str))</td> 
   <td>num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串</td> 
  </tr> 
  <tr> 
   <td>32</td> 
   <td>splitlines([keepends])</td> 
   <td>按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。</td> 
  </tr> 
  <tr> 
   <td>33</td> 
   <td>startswith(str, beg=0,end=len(string))</td> 
   <td>检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。</td> 
  </tr> 
  <tr> 
   <td>34</td> 
   <td>strip([chars])</td> 
   <td>在字符串上执行 lstrip()和 rstrip()</td> 
  </tr> 
  <tr> 
   <td>35</td> 
   <td>swapcase()</td> 
   <td>将字符串中大写转换为小写，小写转换为大写</td> 
  </tr> 
  <tr> 
   <td>36</td> 
   <td>title()</td> 
   <td>返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())</td> 
  </tr> 
  <tr> 
   <td>37</td> 
   <td>translate(table, deletechars="")</td> 
   <td>根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中</td> 
  </tr> 
  <tr> 
   <td>38</td> 
   <td>upper()</td> 
   <td>转换字符串中的小写字母为大写</td> 
  </tr> 
  <tr> 
   <td>39</td> 
   <td>zfill (width)</td> 
   <td>返回长度为 width 的字符串，原字符串右对齐，前面填充0</td> 
  </tr> 
  <tr> 
   <td>40</td> 
   <td>isdecimal()</td> 
   <td>检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。</td> 
  </tr> 
 </tbody> 
</table>

## 11.3 List列表 ##

*  序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
 *  列表操作实例：

#!/usr/bin/python3
    
    # 定义 
    list0 = [] # 创建一个空列表 或者 变量 = list()
    list1 = ['Google', 'Python', 1997, 2000];
    list2 = [1, 2, 3, 4, 5, 6, 7 ];
    
    #输出
    print ("list1[0]: ", list1[0])  # Google
    print ("list2[1:5]: ", list2[1:5]) # [2, 3, 4, 5]
    
    #更新其中的值
    print ("第三个元素为 : ", list[2])    # 2000
    list[2] = 2001
    print ("更新后的第三个元素为 : ", list[2])  # 2001
    
    #删除其中一个元素
    del list[2]
    print ("删除第三个元素 : ", list)  # ['Google', 'Python', 2000]

#### 11.3.1 列表的遍历操作: ####

1.使用for...in 遍历列表
    
        for 变量 in 列表：
            使用变量
    
    2.使用while循环遍历列表
    
        i = 0
        while i<len(列表):
            使用列表中的元素(列表[i])
            i += 1
    
    3.同等长度二级列表的遍历
    
        列表 = [[值1,值2],[值1,值2],....]
    
        for 变量1,变量2 in 列表:
            使用变量1和变量2
    
        注意：变量1取二级列表中的第一个值，变量2取第二个值
    4.非同等长度的二级列表的遍历
    
        列表 = [[值1，值2]，[值1，值2,值3],[值]...]
    
        for 变量1 in 列表：
            for 变量2 in 变量1：
                使用变量2(变量2是二级列表中的每个值)

#### 11.3.2 Python列表脚本操作符： ####

*  列表对 + 和 *的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

<table> 
 <thead> 
  <tr> 
   <th>Python 表达式</th> 
   <th>结果</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len([1, 2, 3])</td> 
   <td>3</td> 
   <td>长度</td> 
  </tr> 
  <tr> 
   <td>[1, 2, 3] + [4, 5, 6]</td> 
   <td>[1, 2, 3, 4, 5, 6]</td> 
   <td>组合</td> 
  </tr> 
  <tr> 
   <td>[‘Hi!’] * 4</td> 
   <td>[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]</td> 
   <td>重复</td> 
  </tr> 
  <tr> 
   <td>3 in [1, 2, 3]</td> 
   <td>True</td> 
   <td>元素是否存在于列表中</td> 
  </tr> 
  <tr> 
   <td>for x in [1, 2, 3]: print(x, end=" ")</td> 
   <td>1 2 3</td> 
   <td>迭代</td> 
  </tr> 
 </tbody> 
</table>

#### 11.3.3 Python列表截取与拼接： ####

*  Python的列表截取与字符串操作类型，如下所示：L=\[‘Google’, ‘Python’, ‘Taobao’\]

<table> 
 <thead> 
  <tr> 
   <th>Python</th> 
   <th>表达式 结果</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>L[2]</td> 
   <td>‘Taobao’</td> 
   <td>读取第三个元素</td> 
  </tr> 
  <tr> 
   <td>L[-2]</td> 
   <td>‘Python’</td> 
   <td>从右侧开始读取倒数第二个元素: count from the right</td> 
  </tr> 
  <tr> 
   <td>L[1:]</td> 
   <td>[‘Python’, ‘Taobao’]</td> 
   <td>输出从第二个元素开始后的所有元素</td> 
  </tr> 
 </tbody> 
</table>

*  使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'

#### 11.3.4 Python列表函数&方法: ####

*  Python包含以下函数:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>len(list)</td> 
   <td>列表元素个数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>max(list)</td> 
   <td>返回列表元素最大值</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>min(list)</td> 
   <td>返回列表元素最小值</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>list(seq)</td> 
   <td>将元组转换为列表</td> 
  </tr> 
 </tbody> 
</table>

*  Python包含以下方法:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>list.append(obj)</td> 
   <td>在列表末尾添加新的对象</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>list.count(obj)</td> 
   <td>统计某个元素在列表中出现的次数</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>list.extend(seq)</td> 
   <td>在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>list.index(obj)</td> 
   <td>从列表中找出某个值第一个匹配项的索引位置</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>list.insert(index, obj)</td> 
   <td>将对象插入列表</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>list.pop(obj=list[-1])</td> 
   <td>移除列表中的一个元素（默认最后一个元素），并且返回该元素的值</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>list.remove(obj)</td> 
   <td>移除列表中某个值的第一个匹配项</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>list.reverse()</td> 
   <td>反向列表中元素</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>list.sort([func])</td> 
   <td>对原列表进行排序</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>list.clear()</td> 
   <td>清空列表</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>list.copy()</td> 
   <td>复制列表</td> 
  </tr> 
 </tbody> 
</table>

## 11.4 Tuple元组 ##

*  Python 的元组与列表类似，不同之处在于元组的元素不能修改。
 *  元组使用小括号，列表使用方括号。
 *  元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

# 定义元组的方式：
    tup0 = ()  #定义一个空元组 或者 变量 = tuple()
    tup1 = ('Google', 'Python', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5 )
    tup3 = "a", "b", "c", "d"
    
    # 输出元组：
    print ("tup1[0]: ", tup1[0])       # tup1[0]: Google
    print ("tup2[1:5]: ", tup2[1:5])   # tup2[1:5]: (2, 3, 4, 5)
    
    # 注意下面这种定义不加逗号，类型为整型
    tup4 = (50)
    print(type(tup4))  # <class 'int'>
    
    # 正确定义方式加上逗号，类型为元组
    tup5 = (50,)
    print(type(tup5))  # <class 'tuple'>
    
    # 以下修改元组元素操作是非法的。
    # tup1[0] = 100
    
    #元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
    del tup0;

#### 11.4.1 元组运算符： ####

*  与字符串一样，元组之间可以使用 + 号和 \* 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

<table> 
 <thead> 
  <tr> 
   <th>Python 表达式</th> 
   <th>结果</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>len((1, 2, 3))</td> 
   <td>3</td> 
   <td>长度</td> 
  </tr> 
  <tr> 
   <td>(1, 2, 3) + (4, 5, 6)</td> 
   <td>(1, 2, 3, 4, 5, 6)</td> 
   <td>组合</td> 
  </tr> 
  <tr> 
   <td>(‘Hi!’) * 4</td> 
   <td>(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)</td> 
   <td>重复</td> 
  </tr> 
  <tr> 
   <td>3 in (1, 2, 3)</td> 
   <td>True</td> 
   <td>元素是否存在于元组中</td> 
  </tr> 
  <tr> 
   <td>for x in (1, 2, 3): print(x, end=" ")</td> 
   <td>1 2 3</td> 
   <td>迭代</td> 
  </tr> 
 </tbody> 
</table>

#### 11.4.2 元组索引，截取： ####

*  因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
 *  如下所示：L=(‘Google’, ‘Python’, ‘Taobao’)

<table> 
 <thead> 
  <tr> 
   <th>Python</th> 
   <th>表达式 结果</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>L[2]</td> 
   <td>‘Taobao’</td> 
   <td>读取第三个元素</td> 
  </tr> 
  <tr> 
   <td>L[-2]</td> 
   <td>‘Python’</td> 
   <td>从右侧开始读取倒数第二个元素: count from the right</td> 
  </tr> 
  <tr> 
   <td>L[1:]</td> 
   <td>(‘Python’, ‘Taobao’)</td> 
   <td>输出从第二个元素开始后的所有元素</td> 
  </tr> 
 </tbody> 
</table>

#### 11.4.3元组内置函数: ####

*  Python元组包含了以下内置函数:

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>len(tuple)</td> 
   <td>元组元素个数</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>max(tuple)</td> 
   <td>返回元组元素最大值</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>min(tuple)</td> 
   <td>返回元组元素最小值</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>tuple(seq)</td> 
   <td>将元组转换为元组</td> 
  </tr> 
 </tbody> 
</table>

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
    
    tuple1=tuple(list1)
    
    print(tuple1)
    
    #('Google', 'Taobao', 'Runoob', 'Baidu')

## 11.5 set集合 ##

*  集合（set）是一个无序不重复元素的序列。
 *  基本功能是进行成员关系测试和删除重复元素。
 *  可以使用大括号 \{ \} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 \{ \}，因为 \{ \} 是用来创建一个空字典。

# 集合的定义
    set1 = set()  #定义一个空的集合
    set2 = { 1,2,3}
    
    # 增加一个元素
    set1.add(5)  
    
    #增加多个：
    set1.update([5,6,7,8])
    
    #删除某个值
    set1.remove(1)
    
    #查：无法通过下标索引
    
    #改：不可变类型无法修改元素
    
    a={ 10,20,30}
    b={ 20,50}
    print(a - b)     # a和b的差集 
    
    print(a | b)     # a和b的并集
    
    print(a & b)     # a和b的交集
    
    print(a ^ b)     # a和b中不同时存在的元素

#### 11.5.1 集合的遍历: ####

1.普通序列的遍历
    
        for 变量 in 集合：
            使用变量
    
    2.多级集合
    
        集合 = { （值,值..）,（值，值..）。。。}
    
        for 变量1，变量2 in 集合：
    
            使用变量1和变量2

#### 11.5.2 集合的序列函数： ####

*  len() 计算集合的长度
 *  max() 获取集合中的最大值
 *  min() 获取集合中的最小值
 *  set() 创建空集合或者将其他数据转换为集合

#### 11.5.3 集合中的方法： ####

*  add – 增加集合元素

name = {'d', 's'}
    name.add('d')
    name
    返回结果：{'d', 's'}
    name.add('sd')
    name
    返回结果：{'sd', 'd', 's'}

*  update–更新已有集合

name = {'sd', 'd', 's'}
    name.update('df')
    name
    返回结果：{'sd', 'd', 'f', 's'}

*  remove–移除指定集合元素

name = {'sd','d','s'}
    name.remove('s')
    返回结果：name
    {'sd', 'd'}

*  discard–移除元素

name = {'sd', 'd', 's'}
    name.discard('s')
    
    返回结果：name 
            {'sd', 'd'}
    
    # remove移除非成员值会报错，discard移除非成员值，啥也不错！

*  clear–清空集合元素

name = {'d', 's'}
    name.clear()
    name
    
    返回结果：{}

*  copy–浅拷贝

name = {'sd', 'd', 's'}
    li = name.copy()
    
    返回结果：li
            {'sd', 'd', 's'}

*  difference – 求差集

name.difference(li)
    set()
    >>> name.difference()
    {'sd', 'd', 's'}

*  union–并集，创建新的对象

name = {'sd', 'd', 's'}
    li = {'s', 'd','h'}
    name.union(li)
    返回结果：{'h', 's', 'd', 'sd'}

*  difference\_update—删除当前set中的所有包含在 new set 里的元素

li = ('s', 'd')
    name = {'sd', 'd', 's'}
    name.difference_update(li)
    name
    返回结果：{'sd'}

*  intersection–取交集,建立新的set集合

li = ('s', 'd')
    name = {'sd', 'd', 's'}
    name.intersection(li)
    返回结果：{'d', 's'}

*  intersection\_update–取交集,更新原来的set集合

li = ('s', 'd')
    name = {'sd', 'd', 's'}
    name.intersection_update(li)
    返回结果：{'d', 's'}

*  isdisjoint–判断没有交集，返回True,否则,返回False

li = {'s', 'd'}
    name = {'sd', 'd', 's'}
    name.isdisjoint(li)

*  issubset–判断是否是子集

li = {'s', 'd'}
    name = {'sd', 'd', 's'}
    name.issubset(li)  #判断name是不是li的子集
    返回结果：False
    
    li.issubset(name)  #判断li是不是name的子集
    返回结果：True

*  issuperset–判断是否是父集

li = {'s', 'd'}
    name = {'sd', 'd', 's'}
    name.issuperset(li)  #判断name是不是li的父集
    返回结果：True
    
    li.issuperset(name)  #判断li是不是name的父集
    返回结果：False

*  pop–移除集合元素

name = {'sd', 'd', 's'}
    name.pop()
    返回结果：'sd' #同一个集合，删除集合元素的顺序固定
    
    se1 = {'a','s','sb'}
    se1.pop()
    返回结果：'sb'

*  symmetric\_difference–去两个集合的差集，建立新的set集合对象

name = {'sd', 'd', 's'}
    li = {'s', 'd'}
    name.symmetric_difference(li)
    返回结果：{'sd'}

*  symmetric\_difference\_update–去两个集合的差集，更新原来的集合对象

name = {'sd', 'd', 's'}
    li = {'s', 'd'}
    name.symmetric_difference_update(li)
    返回结果：{'sd'}

## 11.6 Dictionary字典 ##

*  字典是另一种可变容器模型，且可存储任意类型对象。
 *  字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号(\{\})中 ,格式如下所示：

d = { key1 : value1, key2 : value2 }

*  键必须是唯一的，但值则不必。

#### 11.6.1 创建字典: ####

1.创建空字典
        变量 = {} 或者 变量 = dict()
    
    2.创建多个元素的字典：
        方法1：
            变量 = {键:值,键:值....}
    
        方法2：
            变量 = dict({键:值,键:值....})
    
        方法3：
            变量 = dict(键=值,键=值...)
            注意：该方式键作为形参名使用不可以添加引号，必须符合变量规则
    
        方法4：
            变量 = dict([(键,值),(键,值)...])
            变量 = dict([[键,值],[键,值]...])
            变量 = dict(((键,值),(键,值)...))
    
        方法5：
            变量 = dict(zip((键，键...),(值,值...)))

#### 11.6.2 字典的基本操作: ####

访问字典的元素：
        变量[键]
    
    添加字典的元素
        变量[新键] = 值
    
    修改字典元素
        变量[键] = 新值
    
    删除字典元素
        del 变量[键]

*  案例：

#!/usr/bin/python3
    
    # 定义一个字典
    dict = { 'Name': 'Python', 'Age': 17, 'Class': 'First'}
    
    # 输出子典中的信息
    print ("dict['Name']: ", dict['Name']) #Python
    print ("dict['Age']: ", dict['Age'])   #17
    
    # 输出错误信息：KeyError: 'Alice'
    #print ("dict['Alice']: ", dict['Alice'])
    
    
    # 修改和添加内容
    dict['Age'] = 18;              # 更新 Age
    dict['School'] = "云课堂"      # 添加信息
    
    # 删除信息
    del dict['Name'] # 删除键 'Name'一个元素值
    dict.clear()     # 清空字典
    del dict         # 删除字典

#### 11.6.3 字典的遍历: ####

1.键的遍历
        for 变量i in 字典：
            使用i遍历所有的键，有键就可以通过变量访问其值
    
    2.键值遍历
        for 变量i，变量j in 字典.items()：
            使用变量i遍历所有键，通过变量j遍历所有值

#### 11.6.4 字典内涵/字典推导式: ####

1.普通的字典内涵
        变量= {key:value for key,value in 字典.items()}
    
    2.带有判断条件的字典内涵
        变量= {key:value for key,value in 字典.items() if 条件表达式}
    
    3，多个循环的字典内涵
        变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}
    
    4.带有判断条件的多个循环的字典内涵
        变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式}

#### 11.6.5 字典内置函数&方法： ####

*  Python字典包含了以下内置函数：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>函数名称</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>len(dict)</td> 
   <td>计算字典元素个数， 即键的总数。</td> 
   <td>&gt;&gt;&gt; dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} &gt;&gt;&gt; len(dict) 3</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>str(dict)</td> 
   <td>输出字典， 以可打印的字符串表示。</td> 
   <td>&gt;&gt;&gt; dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} &gt;&gt;&gt; str(dict) “{‘Name’: ‘py’, ‘Class’: ‘First’, ‘Age’: 7}”</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>type(variable)</td> 
   <td>返回输入的变量类型， 如果变量是字典 就返回字典类型。</td> 
   <td>&gt;&gt;&gt; dict = {‘Name’: ‘py’, ‘Age’: 7, ‘Class’: ‘First’} &gt;&gt;&gt; type(dict) &lt;class ‘dict’&gt;</td> 
  </tr> 
 </tbody> 
</table>

*  Python字典包含了以下内置方法：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法名称</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>radiansdict.clear()</td> 
   <td>删除字典内所有元素</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>radiansdict.copy()</td> 
   <td>返回一个字典的浅复制</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>radiansdict.fromkeys()</td> 
   <td>创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>radiansdict.get(key, default=None)</td> 
   <td>返回指定键的值，如果值不在字典中返回default值</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>key in dict</td> 
   <td>如果键在字典dict里返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>radiansdict.items()</td> 
   <td>以列表返回可遍历的(键, 值) 元组数组</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>radiansdict.keys()</td> 
   <td>以列表返回一个字典所有的键</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>radiansdict.setdefault(key, default=None)</td> 
   <td>和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>radiansdict.update(dict2)</td> 
   <td>把字典dict2的键/值对更新到dict里</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>radiansdict.values()</td> 
   <td>以列表返回字典中的所有值</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>pop(key[,default])</td> 
   <td>删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>popitem()</td> 
   <td>随机返回并删除字典中的一对键和值(一般删除末尾对)。</td> 
  </tr> 
 </tbody> 
</table>

\{key:value for key,value in 字典.items()\}

2.带有判断条件的字典内涵  
变量= \{key:value for key,value in 字典.items() if 条件表达式\}

3，多个循环的字典内涵  
变量 = \{i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()\}

4.带有判断条件的多个循环的字典内涵  
变量 = \{i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式\}

#### 11.6.5 字典内置函数&方法：
    
    - Python字典包含了以下内置函数：
    
    | 序号 | 函数名称       | 描述                                                 | 实例                                                         |
    | ---- | -------------- | ---------------------------------------------------- | ------------------------------------------------------------ |
    | 1    | len(dict)      | 计算字典元素个数， 即键的总数。                      | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}  >>> len(dict)   3 |
    | 2    | str(dict)      | 输出字典， 以可打印的字符串表示。                    | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}   >>> str(dict)   "{'Name': 'py', 'Class': 'First', 'Age': 7}" |
    | 3    | type(variable) | 返回输入的变量类型， 如果变量是字典 就返回字典类型。 | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}   >>> type(dict)   <class 'dict'> |
    
    - Python字典包含了以下内置方法：
    
    | 序号 | 方法名称                                  | 描述                                                         |
    | ---- | ----------------------------------------- | ------------------------------------------------------------ |
    | 1    | radiansdict.clear()                       | 删除字典内所有元素                                           |
    | 2    | radiansdict.copy()                        | 返回一个字典的浅复制                                         |
    | 3    | radiansdict.fromkeys()                    | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 |
    | 4    | radiansdict.get(key, default=None)        | 返回指定键的值，如果值不在字典中返回default值                |
    | 5    | key in dict                               | 如果键在字典dict里返回true，否则返回false                    |
    | 6    | radiansdict.items()                       | 以列表返回可遍历的(键, 值) 元组数组                          |
    | 7    | radiansdict.keys()                        | 以列表返回一个字典所有的键                                   |
    | 8    | radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
    | 9    | radiansdict.update(dict2)                 | 把字典dict2的键/值对更新到dict里                             |
    | 10   | radiansdict.values()                      | 以列表返回字典中的所有值                                     |
    | 11   | pop(key[,default])                        | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
    | 12   | popitem()                                 | 随机返回并删除字典中的一对键和值(一般删除末尾对)。           |

[http_www.python.org]: http://www.python.org/
[http_www.python.org_doc]: http://www.python.org/doc/
[http_www.python.org_download]: http://www.python.org/download/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70]: /images/20221123/f501f2dd2d5249eabe7d9ef3a55fe025.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 1]: /images/20221123/bef1a5cc69ec4b4aa43911bd24daf433.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 2]: /images/20221123/0c39a0fa1431474fa0dfb6e78cddd37c.png
[20191104181153705.jpg]: /images/20221123/b8577fe8e86d4f32b0cf98bafee29619.png
[20191104181322274.jpg]: /images/20221123/5916812d1c1d43d8b3bd2880331701fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 3]: /images/20221123/236e90d168fe4899a8edc3a25d3b39dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 4]: /images/20221123/2e886745eee24bacba56c3a19a4fbc61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 5]: /images/20221123/77d646371a484a669696f6f5c30d41c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 6]: /images/20221123/7bab040cde354647910a20714e0ae515.png
[20191104181435700.jpg]: /images/20221123/d0cb0343a2564c1ea5143fc67fd99e1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 7]: /images/20221123/b04c59ac2aeb4093824c671a790a7057.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDg4ODQ4Ng_size_16_color_FFFFFF_t_70 8]: /images/20221123/8f02939894cc4b74b55d600dc6fb3263.png