【笔记】Python入门基础指南

1 Python基础概念及环境搭建

1.1 python简介及发展史

之父Guido van Rossum。ABC语言的替代品。Python提供了高效的数据结构，还能简单有效地面向对象编程。Python语法和动态类型，以及解释性语言的本质，使之成为多数平台上写脚本和快速开发应用的语言。

Python解释器易于扩展，可以使用C或C++（或者其他可以通过C调用的语言）扩展新的功能和数据类型。Python也可用于可定制化软件中的扩展程序语言。Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码。

Python2.7停更。Python3系列不兼容Python2.

1.2 Python定义及其理解

标准定义：Python是一门面向对象、解释型的计算机程序设计语言。

面向对象：指Python编程语言采用的思想。

解释型：指Python编程语言采用的程序编译方式。

1.3 Python对比其他同类编程语言的优劣势

优势：1、语法简单，易上手；高度语言话，摒弃传统语言的大部分标识语义，可读性好；2、可扩展性强；面向其他编程语言友好；3、开发效率极高；第三方库、组建丰富；Python生态完整；4、跨平台性好

劣势：1、太“高级”，过于趋近应用层，造成编译与执行效率较低（对比之下，比如对比C或C++）；2、大部分面向底层的开发，不太建议使用Python，通常会选择性能更好的编程语言，比如C++；

1.4 Python的其他维度定义

Python是一门胶水语言。Python可以开发一个功能模块的公共接口，将其他编程语言实现的功能进行整合。

Python是数据科学领域首选的编程语言。数据科学注重模型的建立（数学建模）。

1.5 Python基础概念相关名词解释

解释型语言：程序不需要编译，程序在运行时才翻译成机器语言，每执行一次都要翻译一次。因此效率较低。如Python语言，专门有一个解释器能够直接执行Python程序，每个语句都是执行的时候才翻译，。（效率较低，依赖解释器，跨平台性好）。

编译型语言：程序在执行之前需要有一个专门编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。如C、C++、Delphi等。

解释器：又译为直译器，是一种电脑程序，能够把高级编程语言一行一行直接转译运行。解释器不会一次把整个程序转义出来，只像一位“中间人”，每次运行程序时都要先转成另一种语言再作运行，因此解释器的程序运行速度比较缓慢。每转译一行程序叙述就立刻运行，然后再转译下一行，再运行，如此不停地进行下去。

解释器工作原理：解释器的工作原理及流程：1、执行xxx.py文件：开始运行一个Python程序；2、此时就会调用提前安装好的Python解释器对代码进行逐行解析；3、解析的过程中，解析一行，运行一行，如果出错，则终止解释运行，并返回错误信息；

1.6 Python环境搭建：解释器环境搭建、开发工具搭建

1.6.1 使用CPython解释器搭建Python环境

gzipped source tarball:用于Linux系统下通过编译源码的方式安装Python环境的Python源码包；

windows install(65-bit):用于Windows通过安装程序直接安装的安装包；

1.61.3 华为云服务器购买及配置选购参考

共建智能世界云底座-华为云

先看近期打折活动。

性能配置：CPU核心数、内存容量、带宽、是否有数据盘、云服务器使用时长。1核2G带宽1MB带一个40GB的系统盘大致可满足学习。

1.6.2 使用Anaconda3安装Python环境

1.6.2.1 Anaconda简介

Anaconda是凯源的python发行版本。包含了conda、python等180多个科学包及其以来项。如果只需要某些包或者节省带宽或存储空间，可使用Miniconda这个较小的发行版（仅包含conda和python）。

conda是一个开源包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换。

Anaconda将程序员日常开发中可能会用到的库、插件、扩展等，全部放在一起打包，然后封装为一个可执行文件用于安装。

Index of /anaconda/archive/ | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror

1.6.2.3 Linux&mac下安装Anaconda3开发环境

我是macbook m2。

打开终端，输入source ~/.bash_profile。让环境生效

参考：【Mac安装anaconda最新实用教程】_mac安装conda-CSDN博客

Linux测试环境：HUAWEI云耀服务器，操作系统：Centos 8

（学一下命令）

SSH远程连接云服务器，进入后开始安装：

wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.11-Linux-x86_64.sh #版本就选择tsinghua查到的较新的linux-86版本

执行wget后等待下载完毕即可。

下载完毕后，进入Anaconda3文件所在目录，执行bash命令进行安装：

bash Anaconda3-2020.11-Linux-x86_64.sh

安装过程会多次提示相关操作，按照提示进行操作即可，等待安装完毕，Anaconda的安装即完成。

配置Anaconda3的环境变量：

vim /etc/profile

使用vim编辑器打开profile文件，点击键盘"i"进入编辑模式，添加如下内容：

export ANACONDA_HOME_PATH=/root/anaconda3

export PATH=$ANACONDA_HOME_PATH/bin:$PATH

添加完毕后，ESC退出编辑，输入“:wq”退出vim编辑；

最后再source一下生效即可：

source /etc/profile

1.6.3 编程工具IDE介绍：Pycharm的安装、配置及使用详解

Pycharm、Microsoft Visual Studio Code、subline Text3…集成其他的功能配合代码的高效编写与调试。

集成开发环境（IDE，Integrated Development Environment）用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务等。所有具备这一特性的软件或软件套（组）都可以叫集成开发环境。如微软的Visual Studio系列，Borland的C++ Builder、Delphi系列等。该程序可以独立运行，也可以和其他程序并用。

即：IDE其实就是一个应用程序（软件），这个程序把程序员写代码所需要的一切功能，包括编辑、调试、运行代码等全部集成在这个软件内，让程序员最大限度的，方便的进行成产开发。

1.6.3.1 Pycharm简介

jetbrains系列产品。

Pycharm Community 社区版，免费且开源

Pycharm Professional 专业版，付费且非开源

社区版不支持第三方库和组件

tb教育激活授权

1.6.3.2 Pycharm下载

PyCharm: the Python IDE for data science and web development

1.6.3.3 Pycharm安装

1.6.3.3 Pycharm初次使用及基本配置

设置Location，项目的存储路径

选择依赖的python库，会新建一个venv虚拟环境

也可以关联本地的python解释器

1.6.3.5 Pycharm常见配置1:如何更改界面主题

file->settings->editor->color scheme

1.6.3.6 Pycharm常见配置2:如何打开一个已有的项目或Python文件

file->open

如果项目或Python文件放在桌面，/users/username/Desktop

1.6.3.7 Pycharm常见配置3:如果突然配置好的Python解释器路径失效，重新配置

file-settings->Projects:项目名称->Python Interpreter

1.6.4 Conda虚拟环境

Pychon的环境搭建最简单的方式：直接使用CPython解释器安装环境并在Pycharm中直接配置本地Python环境即可。

并不是每一个项目所采用的Python版本都是一致的。Python多个版本无法高效的在同一台PC的本地环境下管理。

采用虚拟环境进行Python环境搭建，为每一个虚拟环境指定特定的Python版本，通过虚拟环境隔离本机物理环境，进行Python多版本共存管理，提升便捷性。

主流的有virtualenvwrapper虚拟环境和Conda虚拟环境。

virtualenvwrapper面向python开发。

Python的包管理工具pip。

1.6.4.1 pip包管理工具

Python的标准库是官方内置好的。第三方开发者（非官方技术人员）开发所需的额外的技术、工具、插件，封装为模块或包。

先在本机Python环境下安装好第三方库，然后在本机的python环境下使用第三方库。

pip包管理工具，是专门用来安装python的第三方库、包、组建及插件。该工具在安装python解释器的时候，已经自动安装好了，可以直接使用。

1.6.4.2 pip包管理工具基本使用

pip管理工具通过shell命令使用。打开终端。

使用pip安装一个库：

pip install 库名

使用pip卸载一个库：

pip uninstall 库名

查看当前环境下已经安装了哪些库：

pip list

查看当前pip包管理工具版本信息：

pip –version

pip无论是否在本机物理环境下，还是虚拟环境下，都可以使用。但是，对于linux系统，如果是直接在本机物理环境下使用，需要使用pip3命令，如：

pip3 install xxx

pip3 uninstall xxx

pip3 list

如果在虚拟环境下使用，因为创建虚拟环境时已经自动建立好了pip3的软连接，则使用pip或pip3都行。

1.6.4.3 下载第三方库时的国内镜像源

有些第三方库、包、组件及插件，并不是国人开发或没有上传至境内的网站进行托管，而是在国外的网站托管，下载就会很慢或无网络连接无法下载。即出现国内的景象地址，可以更快的下载到本地。国内镜像源地址：

清华大学开源软件镜像站：https://mirrors.tuna.tsinghua.edu.cn/

腾讯源：https://mirrors.cloud.tencent.com/

阿里源：https://developer.aliyun.com/special/mirrors/notice

华为源：https://mirrors.huaweicloud.com/

中科大源：http://mirrors.ustc.edu.cn/

北京外国语大学源：https://mirrors.bfsu.edu.cn/

网易源：http://mirrors.163.com/

豆瓣Python PYPI镜像：http://pypi.doubanio.com/simple/

python主要使用的是：清华大学开源软件镜像站、中科大源、豆瓣Python PYP镜像。

在使用pip安装第三方库时，pip install xxx（需要安装的库名）。发现该库下载很慢时，可以选择添加某一个国内镜像源。一般情况下，使用pip进行第三方库安装时，一般选择豆瓣的镜像源下载，会很快。

pip install xxx（需要安装的库名） -i https://pypi.douban.com/simple

1.6.4.4 Conda虚拟环境的使用

在成功安装Anaconda3后且已经完成环境变量配置时，Conda虚拟环境就已经安装完毕了。验证如下，以下三个命令任意一个都可验证：

anaconda -V

conda -V

conda –version

只要能够顺利看到conda对应的版本号，说明conda已经配置生效了。

conda虚拟环境的几个常用命令：

查看conda版本号：

conda –version

conda -V

查看当前已有的conda虚拟环境：

conda env list

创建一个conda虚拟环境：

conda create -n [envs_name] python=版本号

# e.g.

conda create -n myFirstCondaEnvs python=3.6.5

激活（进入）一个conda虚拟环境：

# linux

source activate envs_name

# e.g.

source activate myFirestCondaEnvs

退出一个conda虚拟环境

# linux

source deactivate

conda虚拟环境下安装第三方依赖：

先添加Anaconda的TUNA镜像：

conda config –add channels https://mirrors.tuna.tsinghua.cn/ananoda/pkgs/free/

设置搜索时显示通道地址：

conda config –set show_channel_urls yes

安装某依赖包：

conda install [包名]

conda虚拟环境下也是可以通过pip进行第三方依赖安装的。

查看当前虚拟环境下已安装的依赖：

conda list

conda其他常用命令

删除一个已有的conda虚拟环境：

conda remove –name envs_name –all

删除环境中的指定包：

conda remove –name envs_name [包名]

克隆环境：

conda create –name envs_name –clone another_envs_name

查找软件包：

conda search [包名]

1.6.4.5 Conda虚拟环境在Pycharm中的配置

第一步：点击Pycharm主界面右下角

第二步：点击Interpreter Settings

第三步：弹出中点击Add

第四步：interpreter找到python.exe

第五步：勾选make available to all projects，点击ok。配置完成。

1.7 第一个Python程序：Hello Nudt!

1.7.1 交互式编码

交互式编码是指在操作系统的命令行中运行代码。

1.7.2 Pycharm主界面主要功能介绍

1、Pycharm的标题栏/工具栏：常用的功能、配置等。

file：文件相关操作及系统配置等操作

view：主界面的相关配置

run：运行/debugger一个程序的相关配置

2、Pycharm的项目目录结构。点击后即显示目录结构。该功能方便实时查看项目结构，点击可选择展开或关闭。

3、代码编辑区域

4、程序运行/debugger界面区域选项

termical：Pycharm集成好的终端shell，可在此像系统的终端一样通过shell运行一个程序。

5、当前项目配置好的Python解释器在右下角显示。如果Pycharm配置了多个解释器，点击可以随意切换。

1.7.3 Pycharm中新建一个Python文件

在左侧项目结构区域，选择一个Python文件创建目录

选择Python file后会提示给文件命名。命名时不用携带.py后缀名，只需要输入文件名称，回车后自动补齐后缀。

1.7.4 文件式编码：编写第一个程序Hello Nudt!

在新建的Python文件中输入代码：

print('Hello Nudt')

文件空白区域任意处右键单击，选择run

程序于控制台运行后返回结果。第一个Python程序完成。

1.7.5 Jupyter Notebook

Jupyter Notebook是基于网页的用于交互计算的应用程序。可被应用于全过程计算：开发、文档编写、运行代码和展示结果。

Jupyter Notebook是以网页的形式打开，可以在网页页面中直接编写代码和代码，代码的运行结果也会直接在代码块下显示。Jupyter Notebook是一种“在线形式”的交互式编程环境。

在Python编程应用场景中，Jupyter Notebook是需要单独安装的：

pip install jupyter

之前已经安装好了Anaconda3，此时Jupyter Notebook已经安装好了，可以直接使用了。

1.7.5.1 Windows下本地开放Jupyter Notebook服务

终端输入命令：

jupyter notebook

等服务开启即可，且会自动打开浏览器进入到notebook界面

1.7.5.2 CentOS云服务器下远程开放Jupyter Notebook服务

第一步：云服务器开放8888（或任意其他数字）端口：

进入云服务器控制台，点击对应的名称/ID，点击安全组，点击“更改安全规则”，选择“如方向规则”后，点击添加规则，优先级（1）、策略（允许）、协议端口（TCP、端口号自定义，jupyter默认8888自定义端口号不要与其他端口号冲突）、源地址、描述、确定。

第二步：创建jupyter notebook配置文件：

jupyter notebook –generate-config

# 注意：终端中会显示文件所在路径: /root/.jupyter/jupyter_notebook_config.py

第三步：输入ipython，并在ipython中输入如下代码，完成密码设置：

# 注意：会生成一个密钥，从终端中将该密钥拷贝出来以备后续使用。

第四步：打开配置文件，输入如下配置信息后保存退出：

vim /root/.jupyter/jupyter_notebook_config.py

# 注意不要配置为localhost，‘*’代表任何ip均可访问

c.NotebookApp.password='*'

=u 'xxxx'

# 服务器本地不打开浏览器

c.NotebookApp.open_broswer=False

# 端口号默认为8888.想用其他端口号可在这里修改

c.NotebookApp.port=8888

# 指定Jupyter Notebook文件路径，也可以不设置

c.NotebookApp.notebook_dir='/root/DataMining_codes'

# 是否允许root用户登录

在云服务器下开启Jupyter notebook：

jupyter notebook –allow-root

打开浏览器，地址栏输入：

http://[云服务器主机ip]:[端口号]

即可进入jupyter notebook

1.7.5.3 Jupyter Notebook插件安装

Jupyter Notebook关联Conda环境：

conda install nb_conda

在实际使用时，为确保在Jupyter中能够关联（即使用）指定的Conda虚拟环境，一般的，最简单的方式是：

先终端下进入指定Conda虚拟环境：

conda activate xxx

再开启远程Jupyter服务：

jupyter notebook –allow-root

此时Jupyter中默认即使用该虚拟环境了；直接进入，在jupyter中再切换虚拟环境也是可以的。

Jupyter Notebook安装代码补全插件：在终端中依次执行命令：

pip install jupyter_contrib_nbextensions -i https://pypj.douban.com/simple

jupyter contrib nbextension install –user

pip install jupyter_nbextenssions_configurator -i https://pypi.douban.com/simple

jupyter nbextenssions_configurator enable –user

1.7.5.4 Jupyter Notebook插件安装

新建一个目录

目录重命名：先勾选目录，点击remove即可

新建一个Python文件

新文件的重命名

程序编写：在页面中每一个in之后编写代码

程序运行：每写一部分程序后可直接点击运行

虚拟环境切换：点击Kernel –Change Kernel，选择所需的虚拟环境即可

将代码保存至本地

1.7.6 补充知识：Pycharm建立SFTP协议共享Linux主机文件&实现SSH远程连接服务器Python环境

该需求主要面向生产环境下，该功能可实现：1、在Windows下远程连接Linux云主机共享文件，实现在Windows下Pycharm对Linux主机内文件进行编码；2、可实现Windows下对Linux主机文件编码后远程通过SSH连接服务器Python环境并执行Linux主机下脚本。基于此，Pycharm已提供相应的文件共享协议SFTP以及SSH远程登录功能。

Tools->Deployment->Configuration,+号，选择SFTP，新服务命名，…新增SSH远程连接配置，完成相关配置Host\User name\Password Test Connection.选择刚添加的ssh配置，点击mapping，Local path\Deployment path(选择本地路径) Web path(在linux里指定一个同步的路径)。全部操作完毕点击ok，SFTP文件共享服务配置完成。

Tools->Deployment->Broswe Remote Host.开启右侧服务器文件路径结构，方便直接查看，双击编辑。

Tools-Deployment->Upload here(手动)/Automatic Uploar(Always)（自动）

设置Windows下Pycharm可通过SSH远程连接云主机下的Pyhton环境并使用该环境运行Linux下python程序：

点击解释器配置，Settings->Project ..python Interpreter->add选择添加->SSH Interpreter-> Host\Username->Password->Interpreter选择路径->finish.配置完成。

2 变量及数据类型

2.1 计算机基本组成原理与编程基础预备知识

编译运行和解释运行。

编译与解释的过程中关注的不是程序如何检错，而是如何“编译（或解释）”

2.1.1 冯·诺依曼体系

1946年ta提出存储程序原理，把程序本身当作数据来对待，程序和该程序处理的数据用同样的方式储存。

冯诺依曼体系结构、冯诺依曼理论的要点是：计算机的数制采用二进制，计算机应该按照程序顺序执行。人们把冯诺依曼这个理论成为冯诺依曼体系结构。冯诺依曼体系主要由5大部分组成：1、输入数据和程序的输入设备 2、记忆程序和数据的存储器 3、完成数据加工处理的运算器 4、控制程序执行的控制器 4、输出处理结果的输出设备。

现代计算机包括几十年前出来的计算机，仍然在沿用这样的体系进行设计。控制器控制执行的程序，就是现代计算机中软件开发所研究的方向。

计算机系统的组成结构

一台计算机首先要有硬件组成部分，在硬件上安装操作系统，在操作系统上安装使用各种应用程序。

操作系统，为用户提供一个可视化的GUI界面，用户可以依赖输入输出设备使用计算机的各种功能，为应用与硬件之间的交互提供了一个媒介。

高级程序语言（人看懂）-》编译器/解释器-〉机器码（01机器认识）-》硬件执行指令。

C++：编译型语言，编译流程：先一次性编译完毕，再直接执行机器码

JavaScript：解释型脚本语言，解释流程：运行时逐行解释为机器码，逐行执行机器码

2.1.2 Python解释器执行流程

1、开始执行xxx.py文件

2、系统调度python解释器

3、python解释器逐行读取xxx.py源文件，将其编辑成PyCodeObject字节码对象，写入同名的.pyc文件，存放于内存中；Python结束器的虚拟机从内存中读取.pyc文件的字节码对象，逐行读取、解释为机器码，逐行运行机器码。

4、Python解释器将PyCodeObject字节码对象写回pyc文件中。Python程序需多次运行时，每次运行前，先在存储中检索对应的pyc文件，若有则跳过第一步直接开始逐行解释，若无则重复。

Python先编译成字节码的好处：

跨平台特性。将Python程序先编译成字节码，不同的机器机器指令是不一样的，将代码编译成解释器能识别的机器码，运行时解释器就可以根据不同机器指令执行相应的操作。如此即可实现Python的跨平台特性。

提升运行性能。解释器的效率其实比编译器高很多，因为没有预编译的过程。Python源代码只需执行一次编译为字节码且持久化存储，后期解释器解释为机器码的过程可以反复使用该字节码，无需再预编译成字节码，弥补了Python执行效率低的缺点。

2.1.3 PEP-8编码规范

Python Enhancement Proposal #8（第八号Python增强提案），建成PEP-8，用于规范全球开发者所需遵循的统一Python编码风格。

缩进：代表代码的嵌套，包含与被包含的关系。用4个空格表示一次缩紧，可在settings->Editor->Code Style->Python->Tab size中设置tab键。

所有行限制的最大字数为79；

顶层函数和类的定义，前后用两个换行隔开；

源文件编码统一采用UTE-8；

模块或包导入语句单独一行。。。

先导入标准库，再导入三方库，工程内脚本，中间都最好有一个换行

属性和方法的声明中间最好有换行

方法内核心逻辑的实现和方法的定义最好有换行

循环体稍复杂第一行和循环语句最好有换行

方法和方法间最好有换行

方法的最后一行return和方法体的实现最好有换行

import scrapy

from scrapy import Request

2.1.4 注释及其使用

及注解，Python中只有单行注释。

# 我是一条注释

Pycharm中快捷键command+/

'''、"""在Python中是文档字符串，是字符串对象

2.1.5 Pycharm常用快捷键

将光标移动到本行开头：command+《

将光标移动到本行末尾：command+》

快速注释/快速取消注释：command+/

复制光标所在行：command+d

删除光标所在行：command+Delete

移动光标所在行：shift+command+⬆️或⬇️

选中代码的格式化：command+option+L

2.1.6 基本常用函数

函数即一个具体的功能。

input()：用于输出一定的内容，语法：

print(data) # data:要输出的数据

print(data1,date2,…) # 多条内容间使用“，”号隔开

常用参数：end，每条输出内容以何字符结束，语法：

print(data,end='结束符') # 输出一条内容，以xxx内容作为结尾

print默认结束符：

\n # 转义字符，代表以换行结束，即输出一条后换行，后续如果还有输出内容，则自动换到下一行。

# 输出一句Hello NUDT
print('Hello NUDT!')

# 输出一句Hello NUDT
# 输出一句2026 NUDT xukeda
print('Hello,NUDT!')
print('2026 NUDT xukeda')

# 输出一句“hello，nudt！”，同一行继续输出一句“hello，2026 nudt xcukeda”
print('hello,nudt!','hello 2026 nudt xukeda')

# 输出一句hello，nudt
# 输出一句hello，xukeda
# 两行输出一行提示
print('hello,nudt',end=' ')
print('hello,xukeda')

常用参数：sep，将多个同时输出的内容之间添加一个连接（/间隔）符号，语法：

print(data1,data2,…sep="连接/间隔符") # 以连接/间隔符隔开每一条输出内容

# 输出一句“hello，nudt”，同一行间隔一个&符号继续输出一句“hello，xukeda”

print('hello,nudt','hello,xukeda',sep='&')

input()，接收键盘输入的内容，语法：

data=input(输入提示) # 按照input内的提示，一句提示输入所需数据

# 提示：一段文本，提示这里可以输入什么数据

# 输入你的年龄
age = input('输入你的年龄')
# 输入你的性别
sex = input('输入你的性别')
# 输入你的手机号
phone = input('输入你的手机号')
# 输入你的身份证号码
id = input(''输入你的身份证号码)
# 一行输出：你的姓名，性别，手机号，身份证号码
print(age,sex,phone,id)
print(age,sex,phone,id,sep=',')

2.2 变量

2.2.1 定义

变量是一种使用方便的占位符，用于引用计算机内存地址，改地址可以存储数据对象。

2.2.2 变量定义的理解

变量是一个存储空间，为了存储一个具体的对象，这个具体对象所在的空间用一个名字命名，即变量。

2.2.3 变量的声明赋值语句

语法：

变量名 = 数据对象 # 声明单个变量，绑定耽搁对象

变量名1 = 变量名2 = 变量名3 = 。。。 = 变量名n = 数据对象 # 声明多个变量，绑定同一个对象

变量名1，变量名2，变量名3，。。。，变量名n = 数据对象1，数据对象2，数据对象3，。。。，数据对象n # 声明多个变量，绑定多个哦对象

声明一个变量，命名为xx，赋值为xx。

a = 1

b = 2

c = 1.5

d = 'hello nudt'

student = 'xukeda'

创建一个变量的时候，称这个过程为声明一个变量。

=表示为赋值，创建对象与变量之间的引用关系

==表示等于、相等，数学中的=

先声明（创建一个变量，包含该变量的存储地址及命名的名称），后赋值（将该变量与对象之间创建引用关系）。

2.2.4 有关“=”赋值操作的理解

赋值的含义：创建变量与对象间的引用关系，并且一定是变量引用对象

teacher='老师'

1、解释器先向计算机内存申请一块存储空间，该存储空间的地址为0x901；2、为该存储空间命名；3、将读取到内存的对象“老师”与该存储空间之间创建引用关系，该引用关系为变量引用对象，所以箭头指向为：变量=》对象。

变量的声明赋值本质上是在创建于对象之间的引用关系。先声明再赋值。

2.2.5 变量的命名规则

变量名可以使用英文大小写、中文、阿拉伯数字、“-”，可随意组合，但不能以数组开头命名。

变量命名尽量采用驼峰命名法、匈牙利命名法。

驼峰命名法是指一个变量的名称可能会有多个英文单词组成，这种情况下每个单词的首字母就需要大些以区分整个变量命名含义的组成。

驼峰命名法又分为：1、大驼峰：即变量的命名无论包含几个单词，每个单词的首字母统统都需要大写；小驼峰：即变量的命名无论包含几个单词，第一个单词首字母不大写，从第二个单词开始首字母才需要大写。

匈牙利命名法：一个变量的命名要根据其所引用的对象的含义进行命名，即变量的命名尽可能的见名知义。

a = 1

a2 = 3 # 数组和字母随意组合

ab_1 # 数字、字母、“-”随意组合

_abc = 'abc' # 下划线也可以做命名开头

studentInfo = '学生信息' # 小驼峰，匈牙利命名法

SchoolName = '国防科大' # 大驼峰，匈牙利命名法

错误的命名方式

1a = 1 # 数字不能作为变量命名的开头

2.2.6 难点讲解：多变量赋值与变量交换

一次性将同一个数据对象赋值给多个不同的变量。

n1 = n2 = n3 = 2026

一次性将不同的数据对象绑定于不同的变量，且会按照变量声明的先后顺序依次进行赋值。

name,sex,age = 'xukeda','not matter',18

变量重新赋值

二次赋值，多次赋值，也成重新赋值，变量被重新绑定到一个新的数据对象。

变量和对象之间仅仅只是引用与被引用的关系。变量和数据对象间的引用关系在发生变化。

num = 3.14

num = 3.1415926

number = num

print(number)  # 3.1415926

print(num) # 3.1415926

2.2.7 del语句

作用：del语句用于删除变量

语法：del 变量1,变量2,…,变量n

注意：1、del删除的不是数据对象，删除的是变量及变量与对象之间的引用关系；2、因为del只是删除变量（以及变量与对象间的引用关系），所以从宏观上看，del能删除已绑定对象的一切变量，包括删除一个函数（引用了函数对象的变量）、删除一个类（引用了类对象的变量）。

num1 = 123 # 声明变量num，赋值为数字123
num2 = num1 # 做变量引用关系拷贝，声明一个变量num2，将其也赋值为数字123；此时数字123有两个变量同时引用
num3 = num2 # 做变量引用关系拷贝，声明一个变量num3，将其也赋值为数字123；此时数字123有三个变量同时引用
num1 = 234 # num1变量做重新赋值，所以num1变量的引用关系要由原本的指向123，改为234
print(num2) # num2变量引用的对象仍然为123
del num3 # 删除num3变量，此时该变量直接删除，连带其指向数字123的引用关系也删除，数字123直邮num2在引用
num4 = num2 = 555 # 声明变量num4，并与num2变量一起，对于num4来说变量声明后赋值为数字555，对num2是做了变量重新赋值，赋值后引用新数字555
print(num2) # 555
print(num3) # 

2.2.8 变量的类型

Python中是没有所谓的变量的类型的概念的，因为Python的变量类型是动态的。

变量类型的静态是指：变量在声明时就需要规定好能够存储的数据类型。比如java、c++，在声明变量的时候必须规定数据类型，int num = 123; // 正确 age = '十八岁'; // 错误，因为必须规定age变量数据类型为字符串

对于Python来说，因为声明变量时无需规定数据类型，变量声明后可绑定任意类型的对象，所以Python中变量的类型是动态的。

2.3 数据类型

Python一切皆对象，所有对象的引用及调用都是通过变量进行。

2.3.1 数据及数据类型定义

数据：是指客观事件进行记录并可以鉴别的符号，是对客观事物的性质、状态及相互关系等进行记载的物理符号或这些物理符号的组合。是可识别的、抽象的符号。

在计算机科学中，数据是所有能输入到计算机并被计算机程序处理的符号的介质的总称，是用于输入电子计算机进行处理，具有一定意义的数字、字母、符号和模拟量等的通称。在计算机编程语言中，数据就是指一切能存入变量的对象。

数据类型：因为一切都可以称作为数据，但数据的个体与个体之间是存在差异的，但同时又具备诸多相似性，所以，把一类相似的数据放在一起集中管理，就形成了数据类型。也就是说，数据类型是用来划分数据的。而分类标准可以有很多种，所以数据的划分也可以有很多标准，但具体的，数据类型的种类是固定的。

2.3.2 Python中支持的数据类型

Python因为是一门高级编程语言，在数据类型的支持上相对其他编程语言会比较简化、多样。

Python目前支持的数据类型如下：

整型：int

浮点型：float

复数：complex

布尔类型：bool

空值：None

字符串：str

列表：list

元组：tuple

字典：dict

集合与固定集合：set&frozenset

字节串：bytes

2.3.3 Python基本数据类型的划分

类型查看函数：type()

语法：

type(object) # param：需要查看类型的对象

作用：返回一个对象的类型

示例代码：

a = 123

b = '123'

print(type(a)) # <class 'int'>

print(type(b)) # <class 'str'>

按照是否为数字类型进行划分，可将数据类型划分为：

数字类型：整型、浮点型、复数、布尔类型；

其他类型：Node、序列、容器

按照是否为序列和容器进行划分，对于除数字类型之外的其他类型，按照是否为序列或容器，可将数据类型分为：

序列类型：字符串、列表、元组、字节串

容器类型：字典、集合与固定集合

目前公认的数据类型划分标准为：

数字类型：整型、浮点型、复数类型、布尔类型

序列类型：字符串、列表、元组、字节串

容器类型：字典、集合与固定集合

其他类型：None

按照Python中对象的可变性与不可变性，也可划分为：

可变类型：列表、字典、集合

不可变类型：数字类型、字符串、元组、固定集合、字节串

2.3.4 计算机基础知识：原码、反码与补码&进制及其进制转换

2.3.4.1 计算机中数的表示形式

机器数：一个数在计算机中的二进制表示形式

机器数是带符号的，在计算机中用一个数的最高位存放符号表示，正数为0，负数为1

真值：因为机器数的第一位知识符号位，所以机器数的形式值不等于其真实的数值

0000 0001真值：+000 0001 = +1

1000 0001真值：-000 0001 = -1

将带符号位的机器数对应的真实数值成为机器数的真值

2.3.4.2 原码

计算机存储一个数字的具体编码方式之一

原码的表示方法：符号位+真值的绝对值。即最高位表示符号位，即正负数，其余位表示真值。

+1的原码：0000 0001

-1的原码：1000 0001

2.3.4.3 反码

计算机存储一个数字的具体编码方式之一

反码的表示方法：正数，正数的反码是原码本身；负数，负数的反码是在原码的基础上，符号位不变，其余各位按位取反。

+1的原码：0000 0001，反码：0000 0001

-1的原码：1000 0001，反码：1111 1110

2.3.4.4 补码

计算机存储一个数字的具体编码方式之一

补码的表示方法：正数，正数的补码是原码本身；负数，负数的补码是在原码的基础上，符号位不变，其余各位按位取反后再+1，即反码+1.

+1的原码：0000 0001，补码：0000 0001

-1的原码：1000 0001，补码：1111 1111

2.3.4.5 计算机中数字的进制表示

二进制：逢二进一，也就是只有0和1来表示一个二进制

进制前缀：0b

表示法：xxx(2)

二进制首位含义：首位0，代表正数；首位1，代表负数。

二进制表示举例：

0100(2)

1011(2)

0b010

0b10001

二进制应用场景：主要用于表示机器码、字节及字节流

八进制：逢八进一，也就是只有0-7这8个数字来表示一个八进制。

进制前缀：0o

表示法：0xxx(8)

八进制首位：0，含义：表示八进制

八进制表示举例：

023(8)

0a01(8)

八进制应用场景：部分情况下用于替代十六进制的使用场景

十进制

逢十进一，也就是只哟0-9这10个数字来表示一个十进制

进制前缀：0d

表示法：xx(10)，一般不加进制位数显示的数字默认都是十进制

十六进制

逢十六进一，也就是只有0-9、A-F（或a-f）这16个数字来表示一个十六进制

进制前缀：0x

表示法：xxx(16)

十六进制表示举例：

0xE43993C

十六进制应用场景：变量申请的内存空间地址，RGB颜色的十六进制表示

2.3.4.6 各进制间转换

二进制与十进制

二进制转换十进制

正整数二进制转十进制

先对二进制数进行补位至8位二进制，首位为代表为二进制正整数

然后从二进制数最后一位开始，最后一位对应的2的指数为0，向前一位则对应2的指数+1（最高位为符号位，不参与计算），将每一位的数值（0或1）*2的n次方（n为每一位对应的指数值），最后将所有位计算结果加载一起，即为十进制。

负正数二进制转十进制

二进制数位负数，一定是满足8位的

对该负正数二进制进行按位取反，得该负整数二进制的反码

再针对负整数二进制的反码的真值（最高位，负整数的反码最高位为1，不参与计算），按照相同的算法计算其余位数对应的十进制值，最后给十进制结果添加负号即可。

浮点数（小数）二进制转十进制

以小数点作为临界点，整数部分（如果整数部分不为0）向高位进行补位至8位；小数部分向低位进行补位至8位。

二进制整数部分最小位对应的2的指数为0，高位方向指数+1，低位方向指数-1，各位数乘以2的指数次方，最后整数位做求和，小数位做求和，结果即为十进制小数。

十进制转换二进制

正整数十进制转二进制

先对整数进行除二取余，直至结果为1

将最后得到的结果为1，与之前短除后得到的余数，按照“由结果自下而上”的顺序将最终结果1与前余数做排列，记得到十进制数的二进制

最后将得到的二进制结果进行补位（只补位到真值位，最高位根据十进制数的正负给0或1）

负整数十进制转二进制

先对负数的整数部分呢进行除二取余，直至结果为1

将最后得到的结果1，与之前短除后得到的余数，按照“由结果自下而上”的顺序将最终结果1与前位余数做排列，即得该十进制数的二进制

将得到的二进制结果进行补位（只补位到真值位，最高位为符号位，因为是负整数，所以最高位为1）

将真值按位取反

将结果+1拿到真值的补码

补上符号位(1)，结果即为负整十进制对应的二进制

浮点数（小数）十进制转二进制

将整数部分和小数部分先分离

整数部分按照整数转二进制的方法进行转换后补位

小数部分乘以2，每次的结果取其整数位（整数位必定是0或1），直至结果的小数位为0

将整数位按结果顺序排列，即为整数位的二进制结果

将小数位按乘积顺序排列，即为小数位的二进制结果

最后整数位二进制结果与小数位二进制结果之间添加上小数点，即为小数十进制转二进制

二进制与八进制

二进制转换八进制

取三合一法

先将三位二进制从000开始，每次+1，得到的结果对应八进制数的0-7

再将二进制数（如果为负数，要先取反）以小数点为临界点，向高位与低位方向同时每三位取成一组，位数不够的向高位低位方向进行补位，直至满足3位一组即可

每组三位二进制对照如上获得八进制数

最后各组八进制数按权相加（拼成一个整数，不做数学计算），得到的就是最终的八进制结果

八进制转换二进制

以一分三法，即逆向取三合一

二进制与十六进制

二进制转换十六进制

十六位数表示方法：

先将四位二进制从0000开始，每次+1，得到的结果对应十六进制数的0-9、A-F

将二进制数（如为负数先取反）以小数点为临界点），向高位低位方向每四位取一组，位数不足的按位补齐

每组四位二进制对照上数表获得其十六进制数

各组十六进制数按权相加，得到最终的十六进制数

十六进制转换二进制

以一分四法，即逆向取四合一

2.3.4.7 计算机数据存储单位

2.3.4.8 位

计算机中的最小存储单位，符号为bit，一个位存储一个二进制编码（即0或1）

2.3.4.9 字节

符号为byte，其由八个位组成一个字节单元，也就是8个bit组成一个byte；字节通常用作各类数据类型表示占据内存大小的最小单位。

2.3.4.10 计算机数据存储单位换算

1byte = 8bit

1KB = 1024byte

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

2.3.5 整数类型：int

2.3.5.1 定义

整型用于表示整数值对象，包含正整数，0以及负整数

2.3.5.2 整型字面值表示

整型对象采用相关的进制表示，比如二进制、八进制、十进制、十六进制等。

2.3.5.3 Python整型的取值范围

关于整型对象的取值范围，大部分编程语言都是直接跟机器的位数有关系的。

32位机器，整型对象的取值范围为：-2^31-2^31(-2147483648-2147483647)

64位机器，整型对象的取值范围为：-2^63-2^63

大部分编程语言的取值范围如此，如java、c++

在java、c++中，一个int类型的整型数值会占据至多4个字节（4*8bit=32bit），因为整型还区分byte类型与短整型short类型。byte类型整数只占据1字节，即8个bit，short类型整型只占据2个字节，即16个bit。而他们的int类型的整数会占有4个字节，最大取值范围只能达到2147483647

如果要表示一个比2147483647（2的32次方）更大的整数，还有一种长整型类型，即long类型，规定取值范围可以达到2的64次方

java、c++中，整型数值的最大取值范围只能达到2的64次方，与机器能够支持的最大位数（目前的计算机支持的最大位数就是64位）相关。

但，Python中int整型的取值范围与机器位数是无关的

在Python中，如果要查看一个对象所占用的内存大小，可以使用标准库模块：sys中封装好的一个方法：getsizeof()进行查看

Python中整型对象的取值范围是根据内存所能支持的范围来决定的

Python中整数占用的字节数随整数的增大而增大，且每次数字值的增量达到2的30次方，占据字节会继续+4字节。所以Python中整型数值占用字节没有固定的值，Python中整型对象的取值范围是变长的。Python中整数对象的取值范围是根据机器内存所能支持的范围来决定的。

2.3.5.4 整型数值对象构造操作

语法：number = int(param)

参数：任意合法的类型

作用：构造一个整型数值对象，将合法的其他类型对象转换为整型对象

返回值类型：int类型

2.3.5.5 基本输入语句的整型结果接收及使用

data = input('提示语句')

接收用户从键盘输入到的数据，input所接受到的数据属于字符类型：str

但Python规定：字符类型的对象无法直接参与算术运算

int()

基于输入语句常用固定套路：当程序需要接受从键盘输入的数字时，一般按照如下方式使用：

num = int(input('提示语句'))

2.3.5.6 小整数对象池

变量必须先先声明再引用，对象也必须先创建才能被变量所引用。意味着解释器因为整型使用非常频繁的原因，也需要频繁的向内存申请空间，于是引入了小整数对象池的概念。

Python为了提升整体的运行效率，解决性能问题，引入了小整数对象池的概念。

小整数对象池中整型对象的取值范围为[-5,256]，Python认为再-5到256这个范围区间的整型对象使用概率是非常高的。

该区间内的整型对象是提前创建好的，也就是说这些对象在变量引用的时候无需先创建对象，直接引用即可，且小整数对象池中的整型对象不会被垃圾回收。

is是运算符，这里的含义是判断变量引用的对象是否为同一个对象

1这个整数在小整数对象池的取值范围内部，所以1直接被两个变量同时引用，且整数对象1已经存在

整型对象-6已不再小整数对象池的取值范围之内，所以-6这个整型对象需要先创建好，再由变量申请内存空间，最后变量引用整型对象-6。两个变量，创建了两个整型对象-6，e、f引用的是两个独立的对象，所以返回false

2.3.5.7 数字类型常用函数详解

type()

语法：obj_type = type(object)

作用：返回一个对象的数据类型

参数：需要查看类型的对象

返回值：该对象所属的数据类型名称

abs()

语法：abs_num = abs(num_object)

作用：返回任意一个数字绝对值

参数：需要求绝对值的数字

返回值：该数字的绝对值结果

pow()

语法：num = pow(x,y[,z])

参数：x：底数；y：指数；z：可选参数，如果存在，代表将x次方的结果做取余

返回值：一个数x的y次方的幂运算后的结果

round()

语法：num = round(float_num,保留位数)

作用：对一个小数进行四舍五入

参数：float_num：需要进行四舍五入的小数，保留位数：四舍五入后保留几位小数

2.3.6 浮点数：float

2.3.6.1 定义

浮点型用于表示小数，包含正数、0.0、负数。

2.3.6.2 浮点型字面值表示

浮点型对象在Python中有两种表示方法：1、各进制表示法下的小数表示；2、科学计数法

浮点数*

2.3.6.3 Python浮点型的取值范围

虽然浮点型与整型在计算机内存中的存储方式不同，但Python的浮点型同整数取值范围具有一样的逻辑，Python的浮点型可以表示一个很大的浮点数，具体以极机器内存所支持的空间大小相关。

2.3.6.4 关于Python的浮点型的特殊说明

其他编程语言，如java、C++中，关于浮点型对象其实有更加精确的类型划分。如java浮点型包括单精度浮点型float以及双精度浮点型double。

Python中，对于浮点型对象没有如此明确的划分，如果要拿Python中的浮点型与java浮点型做一个相当的比较，Python的浮点型有点像java中的double，即双精度浮点型。

2.3.6.5 浮点型的算术运算问题

精度问题

浮点数和整型数在计算机内部的存储方式是不同的。正数运算永远是精确的，但浮点数的运算则可能出现一定的误差。

浮点型与整数的算术运算

Python中规定：整型与浮点型做算术运算，结果自动转为浮点型：

2.3.6.6 浮点型数值对象构造操作

语法：data = float(params)

作用：1、构造一个浮点型数值；2、将其他合法类型数值对象转为浮点型对象

参数：需要转换类型的对象

参数类型：对象object

返回值类型：float数值对象

Python为任何一个内置类型都准备了类型转换函数，函数名称与类型名称一致。

2.3.7 复数类型：complex

2.3.7.1 定义

由一个实数和一个虚数构成的对象。

2.3.7.2 负数对象的字面值表示

复数使用如下方式表示：

其中a成为实部，b成为虚部

2.3.7.3 复数对象构造操作

语法：data = complex(object)

参数：任意合法类型的对象

作用：构造一个复数对象

返回值：构造出来的复数对象

2.3.8 空值None

2.3.8.1 定义

表示控、空变量、空对象，通常用于对象占位使用。

2.3.8.2 空值对象字面值表示

空值对象使用None进行字面值表示，使用时只需将其赋值给任意变量即可，起到变量的临时占位功能。部分类型的对象，比如：字符串、列表、元组、字典、集合与固定集合、字节串。当该对象内部为空时，也会用None表示。

2.3.9 布尔类型：bool

2.3.9.1 定义

布尔类型对象用于表示真和假，通常用于逻辑运算。

2.3.9.2 布尔类型数值对象字面值表示

布尔类型对象只有两个值：True和False。True：表示真，表示条件满足or成立，对应数字1；False：表示假，表示条件不满足or不成立，对应数字0.

2.3.9.3 布尔类型数值对象构造操作

语法：data = bool(params)

参数：任意合法的类型对象

作用：将传入的参数转为布尔类型

返回值类型：布尔类型，即True or False

2.3.9.4 有关布尔类型数值对象的细节

从Python标准库原码角度简单分析。

如果想看某个语法、某个对象、某个类的标准库源码实现，只需要将鼠标放到这个语法内容上，按住command，同时鼠标左键点击该语法内容，即可直接跳转到标准源码并自动定位到目标源码区域。

Python基本数据类型中有一个大类，叫数字类型。其中包含：整型int、浮点型float、复数类型complex、布尔类型bool。

bool类型标准库源码。

每种类型的源码的第一行代码是在创建一个类，并且制定该类默认集成的基类。

class int(object)

class float(object)

class complex(object)

class bool(int)

前三种类型默认都是集成父类object。bool类型则不是，其继承了int类。bool是int的子类。

某一种类型的某个数据对象直接对应另外一种类型的某个数据对象的值。某类型的某值对应着另外某类型的某值。

上面只是判断数值层面相等。本质并非如此。三种类型具备object这个公共基类且是同一级别的，父类是object。

True==1，对象本质层面是一致的，因为bool继承了int，所以True对应了数值对象1，故而才会相等判断成立

True这个布尔类型的值，其类型bool的父类不是object而是int

False这个布尔类型的值，其类型bool的父类不是object而是int

True对应整型数值对象1，False对应整型数值对象0。

布尔类型大量应用于各种条件判断、逻辑判断、循环判断等场景。直接使用True or false进行的判断，执行效率比不上直接使用1or0.

bool类型要继承int类型是为了提升Python执行效率。

2.3.9.5 布尔类型值与空对象的关系

Python中规定：一切为空的对象类型、整型对象的0以及None空值对应的转为布尔类型的值的结果为False。

2.3.9.6 布尔类型算术运算特性

布尔类型集成自int类型，故而布尔类型数值可直接进行直接算术运算。

2.3.10 字符类型：str

2.3.10.1 定义

由一系列字符组成的不可变序列，存储的是字符的编码值。

2.3.10.2 字符编码

字符是各种文字和符号的总称，包括各自国家的文字、标点符号、图形符号、数字等。

字符在计算机中的存取即表示方式不一致。

字符集（码表）：字符集是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集有：ASCII字符集、ISO 8859字符集、GB2312字符集、GB18030字符集、Unicode字符集等。

国际标准兼容所有计算机系统。每一种字符集还需要设计不同的字符编码方式以将某字符集中的字符编码为机器能看懂的二进制。

字符编码就是以二进制的数字来对应字符集的字符。对字符进行编码，是信息交流的技术基础。

编码：将某字符集的某字符转换为对应的二进制序列的过程。

解码：将二进制序列转换为对应的某字符集的某字符的过程。

某一种语言的文字、标点符号、图形符号等，叫字符。

为一组通类型的字符设计一种表示方法，将这些字符全部包含在一起的集合，叫字符集。

字符集中的字符为了能够在计算机中存储及表示，需转化为二进制机器码的方式，叫字符编码。

某字符集的字符转换为二进制的过程，叫编码。

某二进制转换为某字符的过程，叫解码。

各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”一般都是同时制定的。因此，平常所说的“字符集”，比如：GB2312,GBK,JIS等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。

常见的字符集及其字符编码方式：

ASCII

GB2312

GB2312是对ASCII的中文扩展，兼容ASCII。

GBK

GBK兼容ASCII、兼容GB2312，是GB2312的扩展，主要用于中文表示。

Unicode

Unicode是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案。

UTF-8

UTF-8以字节为单位对Unicode进行编码。

编码方式：

ASCII编码：包含英文、数字等字符，每个字符1个字节。

GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉子2个字节

UTF-8编码：Unicode的存储与存储方式，英文1字节，中文3字节。

2.3.10.3 字符串编解码相关基本函数

ord()

语法：unicode_num = ord(字符对象)

作用：返回某字符的Unicode

参数：合法的字符类型对象

返回值：该字符对应的Unicode码

chr()

语法：str = chr(Unicode)

作用：返回该Unicode码对应的字符对象

参数：Unicode编码值，整型int

返回值：字符对象

2.3.10.4 字符串的字面值表示

单引号表示：

str = '我是一个字符串'

双引号表示：

str = "我是一个字符串"

单引号、双引号的区别

单引号内的双引号不算结束符

双引号内的单引号不算结束符

转义字符：

转义字符 描述

（在行尾时） 续行符

\ 反斜杠符号

' 单引号

" 双引号

\a 响铃

\b 退格（Backspace）

\e 转义

\000 空

\n 换行

\v 纵向制表符

\t 横向制表符

\r 回车

\f 换页

\oyy 八进制数，yy代表的字符，如：\012代表换行

\xyy 十六进制数，yy代表的字符，如：\x0a代表换行

\other 其他的字符以普通格式输出

原始字符串表示

str = r'这里是一个原始字符串'

作用：原始字符串内的转义字符不会进行转译

三引号表示：

三单引号表示

str = '''

这里是一个字符串

'''

三双引号表示

str = """

这里是一个字符串

"""

三引号字符串的特点：1、三引号可以包含单引号和双引号；2、作为对象的文档字符串，存储于对象内部的doc内置属性。

2.3.10.5 字符串格式化占位符

定义：生成一定格式的字符串

语法：'字符串%[长度][占位符类型]'%数据对象

例：name = 'xukeda'

age = 18

print('i am %2s years old,my name is %d'%(name,age))

我这里的占位符好像没有生效

占位符只有一个时，传参时无需括号。

占位符包含多个时，传参时进行标识。

多个占位符传参时，要按照占位符先后顺序依次进行传参。

Python支持的字符串格式化占位符类型：

符号 描述

%c 格式化字符及其ASCII码

%s 格式化字符串

%d 格式化整数

%u 格式化无符号整型

%o 格式化无符号八进制数

%x 格式化无符号十六进制数

%X 格式化无符号十六进制数（大写）

%f 格式化浮点数字，可指定小数点后的精度

%e 用科学计数法格式化浮点数

%E 作用同%e，用科学计数法格式化浮点数

%g %f和%E的简写

%G %F和%E的简写

%p 用十六进制数格式化变量的地址

2.3.10.6 字符串格式化方法：format()

语法：'这里是一个字符串{占位}'.format(数据对象)

作用：进行字符串格式化

参数：需要构造字符串的数据对象

返回值：构造完成的字符串对象

例：s = '这里是一个字符串，后面需要构造上一个{}'.format('姓名')

使用注意事项：

字符串的格式化方法不会想格式化占位符那样规定传入的数据类型限制

当具备多个占位符，按照占位顺序依次传值即可，值不做类型限制，也就是任何类型的对象都可以直接拼接进占位

当具备多个占位符，可给占位进行编号

str = '这里是一个字符串，占位1号{}，占位2号{}'.formate(1,2)

我这里不行，不知道为啥

2.3.11 Python常见其他序列及容器类型简介

2.3.11.1 字符串str

有一些列字符组成的不可变序列。用来记录文本信息，即表示一段文本内容。字面值通常采用''或""表示，也有''''''或""""""的表示方法。

2.3.11.2 列表list

由一些列数组组成的可变序列。列表为常见数据结构中的逻辑结构——线性表的物理实现。

2.3.11.3 元组tuple

由一系列数据组成的不可变序列。列表为常见数据结构中的逻辑结构——线性表的物理实现，一般对应受限线性表。

2.3.11.4 字典dict

由一系列键值对组成的可变散列容器。散列即对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。同时键必须唯一且必须为不可变类型数据对象。

2.3.11.5 集合set

由一系列不重复的不可变类型变量组成的可变散列容器，相当于只有键没有值的字典。

2.3.11.6 固定集合frozenset

由一系列不重复的不可变类型变量组成的不可变散列容器，即不可变的集合。

2.3.11.7 字节串bytes

由一系列字节组成的不可变字节序列。存储以字节为单位的数据，通常在文件读写中大量应用。

3 运算符及表达式

3.1 基础概念

3.1.1 运算符定义

运算符用于执行程序代码运算，会针对一个以上操作数对象来进行运算。

3.1.2 表达式定义

多个运算符及参与运算的各个类型对象即构成一个表达式，表达式是一段可以执行的语句，其执行后往往返回一个确定的结果对象。

3.1.3 Python支持的运算符分类

Python相对其他编程语言，运算符分类标准有所区别，主要分为以下类型：算术运算符、符合算数运算符、比较运算符、逻辑运算符、位运算符、is is not运算符、in not in运算符。

3.2 算术运算符

运算符  含义  对应重载方法

+  加法运算；应用于序列类型时含义为拼接  __add__

–  减法运算  其他任意类型：__sub__;集合类型：__isub__

*  乘法运算；应用于序列类型时含义为成倍拼接；  __mul__

/  除法运算；  __truediv__

//  地板除运算；  __floordiv__

**  幂运算；  __pow__

%  取余运算；  __mod__

3.2.1 Python特有运算符详解：地板除

Python中的地板运算符含义为：先做除法，随后向下取整。

取整

如果使用/

变量num1与num2进行普通除法运算，因为无法整除，所以结果自动升级为浮点型数值对象。

但是使用//

变量num1与num2进行地板除运算，地板除运算：先进行两个值的除法，得到其浮点型结果，随后对浮点型结果做向下取整。

将浮点型结果进行一次强转为整型对象值，并且对于小数点部分采取向下取整的方式，即：去掉小数位，保留整数位。

如果面临如下运算场景：多个值之间参与除法运算的结果期望获得其整型结果时，可以直接使用地板除运算符实现。

向上取整：去掉小数位，整数位进1

向下取整：去掉小数位，保留整数位

3.2.2 运算符优先级

当加法、减法运算与乘法、除法运算共存于同一个表达式内，则会面临运算符优先级的问题，如果不做处理，很有可能导致运算结果出现异常情况。

这对吗？？？

切换成python了，上面好像是ipython进的

Python中支持如下运算符优先级顺序：

优先级最高：()

优先级次之：**

第三优先级：* / % //

最低优先级：+ –

3.2.3 算术运算符参与的表达式返回值

通常情况下，对于只有算术运算符参与运算的表达式，其执行后会返回一个确定的结果对象，该对象类型可能为任意类型的对象。

3.3 复合算数运算符（赋值运算符）

运算符 含义 等同效果 对应重载方法

+= 数值自增 y+=y y=y+1 不可变类型：__add__;可变类型list：__iadd__

-= 数值自减 y-=x y = y-x __sub__

*= 数值自乘 y*=x y = y*x 不可变类型：__mul__;可变类型list：__imul__

/= 数值自除 y/=x y = y/x __truediv__

//= 数值自地板除 y//=x y = y//x __floordiv__

%= 数值自取余 y%=x __mod__

**= 数值自幂运算 y**=x-y=y**x __pow__

3.3.1 算数运算符参与的表达式返回值

通常情况下，对于只有复合算数运算符与运算的表达式，其执行后会返回一个确定的结果对象，该对象类型可能为任意类型的对象。

3.4 比较运算符

运算符 含义 对应重载方法

> 大于 __gt__

< 小于 __lt__

>= 大于等于 __ge__

<= 小于等于 __ le__

== 等于 __eq__

!= 不等于 __ne__

3.4.1 比较运算符参与的表达式返回值

通常情况下，对于只有比较运算符参与运算的表达式，其执行后会返回一个布尔类型的结果对象，即True或False。

3.5 逻辑运算符

运算符 含义 对应重载方法

and 逻辑与，表示若干个条件都成立整体才会成立 __and__，但无法重载

or 逻辑或，表示若干条件中只要有一个成立，其余整体都成立 __or__，但无法重载

not 逻辑非，对于True，逻辑非为False，反之亦然 无

逻辑与：与操作，对于多个表达式，必须同时满足条件or成立，整体的表达式才会成立

逻辑或：或操作，对于多个表达式，只要其中一个条件满足or成立，整体的表达式就会成立

逻辑非：不是、非也、相反的、取反值

3.5.1 逻辑运算符使用细节

对于参与逻辑运算符的条件表达式，其执行后的运算结果一定为一个布尔类型的数值对象

逻辑与，只有参与运算的所有条件全部成立（即每个条件表达式完毕后的返回值为True，整体条件才会成立

逻辑与，只要有一个条件不成立（即条件表达式执行完毕后的返回值为False），整体条件就不成立

逻辑或，只要参与运算的所有条件表达式中有任意一个条件成立，则整体条件成立

逻辑或，只有当所有的条件都不成立时，整体条件才不成立

逻辑非，不是真，非真即假，不是假，非假即真

表示一个变量是否为空

表示一个对象内部是否为空

3.5.2 短路逻辑

对于逻辑与：多个条件表达式参与逻辑与运算时，一个为假整体都为假，即一假全假

对于逻辑或：多个条件表达式参与逻辑或运算时，一个为真整体都为真，即一真全真

3.5.3 逻辑运算符优先级

当and or not 同时处于一个表达式内部时，其具备一个默认的优先级顺序

优先运算not，再运算and，最后运算or。即优先级not>and>or

3.5.4 逻辑运算符参与的表达式返回值

逻辑运算符参与的表达式返回值通常情况下为布尔类型值对象。

3.6 位运算符

运算符 含义 对应重载方法

$ 按位与：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0 __and__

| 按位或：只要对应的二个而进位有一个1时，结果位就为1 __or__

^ 按位异或：当两个对应位的二进制位不同时（同为1或哦），结果为1 __xor__

~ 按位取反：对数据的每个二进制位取反，即把1变为0，把0变为1 __invert__

<< 按位左移动：运算数的各二进位全部左移若干位，由<<右边的数字指定移动的位数，高位丢弃，低位补0 __lshift__

>> 按位右移动：把>>左边的运算数的各二进位全部右移若干位，>>右边的数字指定了移动的位

3.6.1 位运算符详解

计算机中所有的对象都是通过二进制机器码来表示和存储。

对于二进制表示的对象，包含以下几种操作

1、按位与：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0。

a = 0010 1011

b = 0101 1010

按位与：a & b = 0000 1010

2、按位或：只要对应的二个二进位有一个为1时，结果位就为1。

a = 0010 1011

b = 0101 1010

按位或：a | b = 0111 1011

3、按位异或：当两个对应的二进位不同时位（同为1或0），结果为1。如果两个二进制数对应位数的值相同，则取结果0，如果两个二进制位数对应位数的值不相同，则取结果1.

a = 0010 1011

b = 0101 1010

按位异或： a ^ b = 0111 0001

4、按位取反：对数据的每个二进制位取反，即把1变为0，把0变为1.

a = 0010 1011

b = 0101 1010

按位取反：

~a = 0101 0100 # 注意，最高位位符号位

~b = 0010 0101

5、按位左移动：运算数的各二进位全部左移若干位，由<<右边的数字指定移动的位势，高位丢弃，低位补0.

a = 0010 1011

b = 0101 1010

按位左移动：

a << 2 = 0010 1100

b << 2 = 0110 1000

6、按位右移动：运算数的各二进位全部右移若干位，由>>右边的数组指定移动的位数，低位丢弃，高位补0.

a = 0010 1011

b = 0101 1010

按位右移动：

a >> 2 = 0000 1010

b >> 2 = 0001 0110

3.6.2 位运算符参与的表达式返回值

位运算符参与的表达式返回值通常情况下位具体的二进制表示形式的数据对象。

3.7 is、is not 运算符（也称作身份运算符）

运算符 定义 对应重载方法

is is是判断两个表示符是不是引用自一个对象 无

is not is not 是判断两个表示符是不是引用自不同对象 无

3.7.1 身份运算符使用细节

is运算符主要用于以下两种场景的判断：

1、对于变量来说，判断多个变量引用的是否为同一个对象

这里其实主要判断变量所引用对象的内存地址，通过地址判断是否为同一个对象。

2、对于对象来说，可用于判断某对象的类型是否为某一具体类型。

is运算符与比较运算符：==的区别

==：仅仅比较两个对象间字面值的大小结果是否相等

is运算符：比较的是两个对象的内存地址是否相等，用于判断是否为同一对象

3.7.2 身份运算符参与的表达式返回值

身份运算符参与的表达式执行完毕后的返回结果通常为布尔类型数值对象。

3.8 in、not is运算符（也称成员运算符）

运算符 定义 对象重载方法

in 如果在指定的序列中找到值返回True，否则返回False。 __contains__

not in 如果在指定的序列中没有找到值返回True，否则返回False。 __contains__

3.8.1 in、not in 运算符使用细节

该运算符主要应用于序列或容器类型对象，主要用于判断某一个对象是否存在于该对象内部，如果存在返回True，不存在返回False。​​​​​​​

3.8.2 成员运算符参与的表达式返回值

成员运算符参与的表达式执行完毕返回的结果通常为布尔类型数值对象。

3.9 Python运算符重难点知识讲解

3.9.1 重难点讲解：Python运算符的本质

对应重载方法

每一种类型都有自己的类型对象构造操作。

int() float() complex() bool()

序列类型包括的字符串、列表、元组、字符串，容器类型包含的字典、集合与固定集合等这些数据类型，也有自身的类型对象构造操作。

这些都是类型对象的构造操作，而非函数。是对象构造操作。Python中的数据类型，本质上是一个解释器提前封装好的内置标准类。

Python的每一种数据类型对标一个封装好的类。

class int(object)

class float(object)

class complec(object)

class bool(int)

类名() 是在创建一个类的实例(对象)

得到类型对象的过程，不是一个函数调用的过程。

整型数值对象可以做加法运算、减法运算

浮点型数值对象可以做比较运算

字符对象可以做is身份运算

Python中的对象可以做这些运算符对应的一种运算操作。

__xxx__ 有自己对应的功能

def __add__(self,*args,**kwargs): # real signature unknown

    """ Return self+value. """ # 返回一个值加另一个值的结果

    pass

这个__add__文档解释翻译过来：返回一个值加上另一个值的结果

    def __add__(self, *args, **kwargs): # real signature unknown
        """ Return self+value. """
        pass

Python中的任意数据类型能够具备各种各样的运算符，是因为这些数据类型中都定义了实现特定运算符操作的方法。比如加法运算是通过__add__方法来实现的。

def __sub__(self,*args,**kwargs): # real signature unknown
    """ Return self-value. """
    pass

这个__sub__的文档解释：返回一个值减去另一个值的结果

Python运算符本质总结：

因为Python中的一切皆对象

所以Python中的每一个对象都对应着一种类型

在这种对象的类型里，已经为对象提前添加好了各种运算符所需要的运算操作

当使用某一种运算符对表达式涉及到的多个对象进行相应的运算时，会触发该中运算符对应的形如__xxx__方法，来实现该运算功能

当前接触到的各种运算符，只是某种运算功能方法对应的语法糖

由运算符符号语法糖可直接出发该运算符对应的运算功能

Python运算符的本质：表现形式上是语法糖，功能实现上是某一类型中已经实现好了的某个运算功能

3.9.2 重难点讲解：pow()与**运算符是同一种操作？

pow()的源码

def pow(*args,**kwargs):
    """
    Equivalent to bse**exp with 2 arguments or base**exp % mod with 3 arguments
    
    Some types,such as ints,are able to use a more effecient algorithm when
    invoked using the three argument from.
    """
    pass

pow()是一个函数

**运算符，对应一个运算功能，__pow__

def __pow__(self,*args,**kwargs): # real signature unknown
    """ Return pow(self,value,mod)."""
    pass

**对应的__pow__是类的一个方法

Return pow(self,value,mod)

**运算符的本质是用pow()函数做幂预算

pow()与**运算本质上不是同一种操作

pow()是一个函数

**运算符对应的方法：__pow__是任意对象的一个方法

这两种操作的表达形式和载体是不一样的。且**运算符的__pow__方法实现幂运算的原理也还是通过pow()函数实现的。

3.9.3 重难点讲解：y=y+x和y+=x是同一种操作？

算术运算符与复合算数运算符

对于不可变类型对象来说，y=y+x与y+=x本质上没区别

但对于可变类型对象list、列表，是两组不同的操作：

列表的+运算：拼接两个独立的列表对象为一个新的列表对象，+运算符对应__add_

但其+=运算：虽然看上去还是拼接一个列表，但其本质是在原列表对象上做追加操作，本质上没有创建出新的对象，+=运算符云顶__iadd__.

3.9.4 重难点讲解：a运算符b与b运算符a是相同的操作吗？

对于a+b：运算符左边是对象a，则会触发对象a的+运算方法__add__

对于b+a：运算符左边是对象b，则会触发对象b的+运算方法__add__

如果：运算符左右的对象类型是一致的；或运算符左右的对象均为标准库中的内建类型对象，则a运算符b与b运算符a两种运算就有区别，涉及到反响运算符的概念。

字符串也是可以做乘法运算的，字符串的惩罚运算就是按照乘积的倍数将字符串拼接多少次。

报错的原因是：是一个整型对象在自定义字符型对象s2做乘法运算；而整型对象中没有定义字符串的乘法拼接方法；在自定义字符型对象中也没有反向乘法算数运算符。

只需给自定义类型定义反向乘法算数运算符即可。

class MyInt(object):
    def __init__(self,value):
        self.data = value

    def __str__(self):
        return '{}'.format(self.data)

    def __add__(self,other):
        print('use function __add__')
        return MyInt(self.data + other.data)

class MyStr(object):
    def __init__(self,value):
        self.data = value

    def __str__(self):
        return self.date

    def __mul___(self,rhs):  # rhs代表运算符右边的参数
        print('__mul__触发')
        return MyInt(self.data * rhs)

    def __rmul__(self,lhs): # lhs代表哦运算符左边的参数
        print('__rmul__触发')
        return MyInt(self.data * lhs)

if __name__ ==  "__main__":
    s1 = MyStr('abc')
    s2 = MyStr('def')

    print(2 * s1)
    # print(s1 * 2)

触发了__rmul__，代表这种情况下触发了反向运算符。

反向运算符的概念：

正向运算符：针对当前参与运算的对象来说，运算符处于右侧的，叫正向运算符。

反向运算符：针对当前参与运算的对象来说，运算符处于左侧的，叫反正运算符。

Python中规定：

常见算术运算符、复合运算符、逻辑运算符等具有对应的反向运算符。

反向运算符在运算方法的命名上，相对于正向运算符名称，在其前面添加字幕r表示对应的反向运算符。

算术运算符*：

正向运算符：__add__；

反向运算符：__radd__

4 流程控制语句及循环语句

4.1 基础概念

4.1.1 行

物理行：程序员编写代码的行。

逻辑行：Python解释器需要执行的指令。

Python编码注意事项：建议一个逻辑行在一个物理行上。如果一个物理行中使用多个逻辑行，需要使用分号;隔开。如果逻辑行过长，可以使用隐式换行或显式换行。

print(12);print(23)

隐式换行：所有括号里的内容换行，称为隐式换行。包括() [] {}三种

显示换行：通过拆行符\（反斜杠）换行，且必须放在一行的末尾，目的是告诉解释器，下一行也是本行的语句。

4.1.2 pass语句

作用：通常用来填充语法空白。

Python的PEP8规范较严谨，如果某些语法处规定必须有代码但是实际应用中此处无需代码，则可以使用pass进行填充。

语法：

# 代码的任意位置处
pass

例：

if True:
    # 此处理逻辑为：如果条件成立，不做任何操作，那么此时这里就必须要有代码，但因为逻辑层面这里无需代码，故直接pass即可
    pass

4.2 流程控制语句：if语句

4.2.1 if语句

if语句用于程序的条件判断。

4.2.2 if语句

语法：

if 条件表达式:
    条件成立时执行的语句逻辑

含义：如果条件表达式成立，即：该表达式执行完毕后返回的结果为True，则执行对应条件成立的语句逻辑。

例：

Teacher_Xu = 'bellin'
if Teacher_Xu == 'bellin':
    print('teacher xu is {}'.format(Teacher_Xu))

if后必须跟表达式，且时执行后能返回一个布尔类型数值对象的条件表达式

条件表达式后必须跟:，这是Phthon的语法规定

if条件成立后需要执行的语句逻辑需编写在下一行，且需缩进表示逻辑嵌套，即：这部分语句逻辑是条件表达式成立的前提下才会执行

一个基本的if语句必须最少包含一个if子句

4.2.3 if…else语句

语法：

if 条件表达式:
    逻辑1:条件表达式成立时执行的语句逻辑
else:
    逻辑2:条件表达式不成立时执行的语句逻辑

含义：如果条件表达式成立，即：该表达式执行完毕后返回的结果为True，则执行逻辑1:条件表达式成立时执行的语句逻辑。如果条件表达式不成立，即：该表达式执行完毕后返回的结果为False，则执行else之内的逻辑2:条件表达式不成立时执行的语句逻辑。

注意：if后必须跟表达式，并且是执行后能返回一个布尔类型数值对象的条件表达式。条件表达式后及else子句后必须跟:，这是Python的语法规定。if条件成立后需要执行的语句逻辑需写在 if语句的下一行，且需要打一个缩进表示逻辑嵌套，即：这部分语句逻辑是条件表达式成立的前提下才会执行。if条件不成立后需执行的语句逻辑需写在else子句的下一行，且需要打一个缩进表示逻辑嵌套，即：这部分语句逻辑是条件表达式不成立的前提下才会执行。一个if…else…结构语句中最多只能包含一个else子句。

4.2.4 if…elif…else语句

语法：

if 条件表达式1:
    逻辑1: 条件表达式1成立时执行的语句逻辑
elif 条件表达式2:
    逻辑2: 条件表达式2成立时执行的语句逻辑
elif 条件表达式3:
    逻辑3: 条件表达式3成立时执行的语句逻辑
... # elif可以有很多个
else: # 当所有的条件表达式都不成立时
    逻辑4: 当所有的条件表达式都不成立时执行的语句逻辑

含义：如果条件表达式1成立，则执行逻辑1；否则如果条件表达式2成立，则执行逻辑2；否则如果条件表达式3成立，则执行逻辑3.。。如果所有的条件表达式都不成立，则执行逻辑4.

注意：if即else后必须跟表达式，并且是执行后能返回一个布尔类型数值对象条件表达式。if即elif子句后必须跟：，这是Python的语法规定。一个完整的if…elif…else结构可以包含任意多个elif子句，但至少包含一个if子句，之多包含一个else子句。

4.2.5 if语句的嵌套

if条件判断语句支持任意模式的嵌套。

weather = input('how about weather today?\n')
status = input('how about status today?\n')
if weather == 'sunny':
    if status == 'happy':
        print('{},{},go to play\n'.format(weather, status))
    if status == 'good':
        print('{},{},study in library\n'.format(weather, status))
if weather == 'rainy':
    if status == 'happy':
        print('{},{},study at home\n'.format(weather,status))
    if status == 'good':
        print('{},{},watch TV'.format(weather,status))

注意：if语句虽然可以随意嵌套，但一定是一句程序的逻辑进行嵌套。语句嵌套全程注意Python语法规定。

4.2.6 if条件表达式

if条件表达式是一种采用表达式结构的、简化后的if语句结构。

语法：result = 逻辑1: 如果条件表达式成立时执行的语句路基 if 条件表达式 else 逻辑2: 如果条件表达式不成立时执行的语句逻辑

含义：在if条件表达式中if子句的前面执行条件表达式成立时的语句逻辑。在if条件表达式中else子句的后面执行条件表达式不成立时的语句逻辑。

weather = input('how about today weather\n')
is_goodday = print('today weather is sunny ? {}\n'.format(weather)) if weather == 'sunny' else print('today weather is rainy ? {}'.format(weather))

注意：如果一个条件判断逻辑没有确定的返回结果，则最好不要使用if条件表达式。

这里的变量is_goodday其实没有接收到任何对象，因为该if条件表达式全程的执行逻辑并没有返回一个结果对象，那么这个is_goodday会接收一个Node空值。

if条件表达式也支持嵌套：如果条件表达式成立时进行嵌套，在if子句前进行嵌套逻辑，且嵌套逻辑使用()分割逻辑。如果条件表达式不成立时进行嵌套，在else子句后进行嵌套逻辑，且嵌套逻辑使用()分割逻辑。

a = input('input a value\n')
b = input('input b value\n')
c = input('input c value\n')

(print('mix a = {}'.format(a)) if a <= c else print('mix c = {}'.format(c))) if a <= b else(print('mix b = {}'.format(b)) if b <= c else print('mix c = {}'.format(c)))

4.3 循环语句

4.3.1 while循环语句

定义：while语句可以让某功能的代逻辑在满足某一条件的情况下反复的、重复的执行。

语法：

while 条件表达式:
    循环体: 如果条件表达式成立时执行的循环语句逻辑
else:
    如果条件表达式不成立时执行的循环语句逻辑

含义：while后的条件表达式一般含义为：循环能够持续执行的条件。while条件表达式可以解读为：当循环一直满足该条件的情况下。当循环的条件表达式成立时执行的循环逻辑哪必须要有控制循环逐渐结束的逻辑。else子句的逻辑为：当循环终止时需要执行的语句逻辑。

while循环使用技巧：程序的整个循环逻辑中最好存在一个逻辑变量，该循环变量可以起到控制循环结束的作用。在程序的循环体语句中一定要控制循环变量“逐渐向不满足循环条件成立的方向”改变。

4.3.1.1 死循环loop

死循环（loop）是指程序一旦进入循环状态，其循环条件永远不会达到“不满足循环继续执行“的”不成立“状态，进而程序的循环体结构因循环条件永远无法达到”不成立“”状态而一直循环执行下去。

死循环注意事项：1、死循环结构存在较大的安全隐患，尤其面向大规模的CPU密集型程序，其危害非常大；一个性能非常好、CPU计算规模非常大的程序一旦进入死循环状态，轻则会导致计算机的CPU占用率瞬间飙升至接近100%（用户体验上的感受就是电脑瞬间卡死不动了，机器的风扇突然开始大功率工作，可以听到明显的风扇呼呼声），重则会导致CPU硬件损伤甚至连带内存、硬件等其他硬件也会收到影响。2、死循环结构也有一定的应用情况，比如给予UDP协议的面相无连接的数据报嵌套接字构造的网络传输协议，其服务端一般情况下需时刻保持可以连接的状态，那么在代码层面实现这个需求就是让服务端的等待连接功能进入一个死循环状态，保证服务端时刻开启，客服端可随时进行连接。

避免程序进入死循环的方式：1、给循环体一个循环变量，当循环体执行的过程中口感女孩子循环便变量逐渐向着不满足循环条件成立的方向改变，最终当程序执行有限次循环后循环条件不再成立时，循环会自动的结束执行。2、通过“暴力”的方式结束执行：break语句。

4.3.1.2 break语句

作用：终止当前程序的循环体执行。

语法：在循环体的任意位置处执行break语句即可。

break语句的使用技巧：一般情况下，break语句可以配合着if语句使用，即：如果程序循环执行到某一时刻，某条件表达式不再成立，循环无需再继续执行，则break。

4.3.1.3 continue语句

作用：跳出当前本次循环，进入下一次循环。

语法：在循环体的任意位置处执行continue语句即可。

while循环使用技巧：一般地，如果实在无法编写while循环的条件表达式，或就是为了图省事，可以如此使用while循环：先，条件表达式直接给True让循环直接开始执行。再，循环内通过if语句结合break语句暴力终止循环即可。

4.3.1.4 while循环语句嵌套

语法：

while 条件表达式：
    循环体语句逻辑
    。。。
    此时这层循环称作“外层循环逻辑”
    如果此时需要嵌套：
    while 条件表达式：
        此时这层循环称作“内层循环逻辑”
        。。。
        如果此时还需要继续嵌套：
        while 条件表达式：
        循环语句逻辑
        此时这层循环操作“第三层循环逻辑”
        后续的嵌套一次类推。。。

循环嵌套使用注意：1、何时构成何种循环嵌套结构，与代码逻辑无关，与实际解决问题的逻辑有关。2、循环嵌套谨慎使用，即：需要构造嵌套关系了，再使用。3、循环嵌套结构逻辑相对复杂，构造时注意缩进问题，即：缩进代表：某循环对应的自身的循环体逻辑。

4.3.2 for循环语句

定义：for循环语句常用于可迭代对象的遍历操作，即：可从可迭代对象中迭代（不断的获取下一个）的存取对应的数据元素。一般情况下，可迭代对象都是有长度限制的，所以其元素对象的个数（即长度）是固定的。当for循环从该固定长度的可迭代对象中迭代的存取某一个数据对象时，其过程类似一个循环操作，故而称作for循环语句。

可迭代对象：可以用于for循环遍历的对象。

语法：

for 循环变量 in 可迭代对象:
    循环语句逻辑
else:
    当循环不满足只系ing条件时的语句逻辑

含义：可迭代对象的长度一定是固定的，所以：for循环迭代的从第一个元素拿到最后一个元素对象，这个循环迭代的次数就是固定的，即：循环的次数一定是固定的。

每迭代的拿到一个可迭代对象中的元素对象时，会执行一遍循环体中的循环语句逻辑。

for语句之所以能实现循环效果是因为：1、其将迭代的获取下一个元素对象的效果等效为循环的不断执行。2、并且因为可迭代对象的长度一定是有限的，顺带也实现了限制循环执行的次数。

for语句遍历可迭代对象能构成一个循环：因为可迭代对象的长度固定，导致for语句遍历可迭代对象产生的循环效果是有限次的，即：循环的齿数是可控的。在可遍历可迭代对象时迭代的拿到下一个元素对象后，去执行一个重复的、固定的逻辑，看上去就是循环的在重复执行一件事情，即：每一次循环都要执行一次重复的循环体逻辑。

for语句遍历一个可迭代对象，循环变量不断的拿到可迭代对象中的某一个元素对象，并且在每次拿到某元素对象时执行一次循环体语句逻辑。

for循环对比while循环：

while循环：当while后的条件表达式的执行结果为True时才会触发while循环体。

for循环：没有触发条件，只要其遍历的是一个可迭代对象且该对象具有长度（即元素个数补位0）则循环自动开始执行（即自动开始迭代的获取下一个元素对象）。

循环执行次数的控制方式区别：

while循环：控制循环结束有两种方式：1、“优雅的结束循环”：在循环结构中构造一个关键的循环变量，在循环体中控制循环变量“逐渐向不满足循环条件成立的方向”改变。2、“暴力的结束循环”“直接使用break语句在任意时刻任意逻辑下强制终止循环。

for循环：因为for循环遍历的可迭代对象的长度是已知的、固定的（即元素对象的个数是固定的、有限的），所以for循环既可以自动开始，也可以自动结束，即：当for循环遍历到可迭代对象的最后一个元素时，循环自动终止。

break语句也可用于for循环结构。

在与for循环遍历可迭代对象的应用场景无关的前提下，while循环及for循环的主要应用场景的区别也显而易见了：如果希望一个循环的执行次数是可以充分可控的，并且在逻辑中存在一个明确的”循环变量”，那么可以考虑使用while循环。如果循环体的执行次数本身就是固定的，且无需考虑循环开始执行之后是否充分可控（即只要循环开始执行就一定会正常结束），则可以选择更简单的for循环。

如果是对于一个可迭代对象的遍历操作时，没有选择，只能for循环。

4.3.2.1 可迭代对象简介

Python中的序列类型及容器类型都属于可迭代对象。

说明：可迭代对象的概念较为深入。

for循环其实就是为了Python中的可迭代对象而生的。

但是，一些与可迭代对象遍历无关的应用场景下，也需要使用for循环，那么这个for循环，该遍历一个何样的可迭代对象？

Python中的序列类型：字符串、列表、元组、字节串以及容器类型：字典、集合与固定集合是可迭代对象，初次以外的其他类型没有在这里说明，代表其他类型就不是可迭代对象。

4.3.2.2 range()

定义：range()用于创建一个包含一些列整数对象的可迭代对象，通常也称为整数序列生成器。

各版本下range()不一样：

对于python3.+版本，range()返回的只是一个可迭代对象，不是任何序列或容器类型。

对于Python2.x版本，range()直接返回一个列表对象，对象类型属于list类型。

其实在Python2.x版本中，xrange()的作用与现存Python3.x版本的作用是类似的，但其也不是直接返回一个可迭代对象，而是返回一个生成器对象。

如果需要一个可迭代对象来辅助做“与for循环遍历可迭代对象”无关的其他for循环应用的话，则可以通过range()来创建一个包含了一系列整数对象的可迭代对象来辅助循环功能实现。

语法：iterable = range()start,end,step)

参数：start：整数对象范围的起点。end：整数对象范围的重点。step：整数对象的取值间隔，也称作步长。

返回值：返回一个包含一些列整数对象的可迭代对象，用于for循环遍历操作。

range()使用注意：

range()内的参数可以给一个，也可以给两个，也可以给三个，

如果range()只给一个参数，则该参数的含义为“终点”，即：

iterable = range(end)

默认的起点为0，即整数取值默认从0开始，每次取值默认的取值间隔（即步长）为1，且只会取到终点值的前一位，例如：

如果range()给两个参数，则参数的含义为“从起点值，取到终点值的前一位”，即：

iterable = range(start,end)

此时，已规定起点和终点，并且每次取值默认的取值间隔（即步长）为1，并且只会取到终点值的前一位，例如：

如果range()给三个参数，则参数的含义为：从起点值，取到终点值的前一位，且按照指定的取值间隔进行取值。即：

iterable = range(start,end,step)

取值间隔（即步长）：

含义：在规定的取值范围内每隔多少值取一个。

但，range()内不能不给任何参数，也就是：最少要给1个参数作为取值范围的终点。

虽然range()是用于构造一个包含一系列整数对象的可迭代对象，该对象也可以使用变量进行引用，但日常开发中不会单独把range()所创建的可迭代对象绑定一个变量，而是直接应用于for循环语法中，即：

for 循环变量 in range([start],end,[,step]):
    循环体语句逻辑

循环变量的命名通常是有讲究的：

如果该for循环主要应用于具备独立程序逻辑的场景下，则循环变量命名以i j k或x y z 或 m n为主。

对于容器类型：字典遍历时，则循环变量以key命名。

对于for循环参与程序上下逻辑时，循环变量的命名尽量见名知义，即：见到这个循环变量名就知道遍历的这个可迭代对象含义是什么，拿到的是该可迭代对象中的什么样的对象。

4.3.2.3 for循环语句嵌套

语法：

for 循环变量1 in 可迭代对象1:
    循环体语句
    此时这里的循环体语句称为“外层循环”:
    此时如果需要嵌套:
    for 循环变量2 in 可迭代对象2:
        此时这里的循环体语句称为“内层循环”:
        此时如果需要继续嵌套:
        for 循环变量3 in 可迭代对象3:
            循环体语句
            此时这里的循环体语句称为“第三层循环”:
            以此类推，，，

循环嵌套使用注意：

何时构成何种循环嵌套结构，与代码逻辑无关，与实际解决问题的逻辑有关。

循环嵌套谨慎使用，即：需要构建嵌套关系了，再使用。

循环嵌套结构逻辑相对复杂，狗仔时注意缩进问题，即：缩进代表“某循环对应的自身的循环体逻辑”

4.3.2.4 for循环与while循环总结

其实for循环实现一个循环逻辑往往比while循环实现的简单、高效、方便。

一般应用场景下，如果一个循环需求使用while循环能够实现，使用for循环也能够方便的实现的话，一般情况都会选择直接使用for循环。

4.4 算法练习

# 算法1：输出1-100内所有的偶数
# 问题描述：给定1-100的所有正整数，输出所有的偶数对象
# 测试用例
#
# 输入：
# 整数范围的最大值：100
# 输出：
# 100以内的偶数有：0，2，4，6，8，10，...

max = int(input('input int\n'))  # 1-100以内的正整数

for i in range(1+1,max+1,2):
    print(i,end=',')

# 算法2：输出1-100内所有的奇数
# 问题描述：给定1-100的所有正整数，输出所有的奇数对象
# 测试用例：
#
# 输入：
# 整数范围的最大值：100
# 输出：
# 100以内的奇数有：1，3，5，7，9，...

for i in range(1,101,2):
    print(i,end=',')

【TODO】

5 序列类型

5.1 基础概念铺垫：什么是序列

数据结构与算法

在数据结构与算法理论中，其规定：数据是具有一些特定的组织结构的。

常见的：线性结构、树形结构、图形结构等。抽象层面的概念。

对于任意一个计算机的应用程序，无论其采用何种模式（B/S架构模式或C/S结构模式）设计，本质上都是：针对某一类特定的数据组织形式的数据做相应的自动化处理。

数据如何定义、数据如何传输、数据如何可视化。数据如何高效组织以方便程序设计和实现。而数据结构与算法只是数据如何组织的理论层面的抽象概念。具体这种理论该如何应用在程序设计中，需要依靠编程语言对其理论进行实现才能够应用。

大部分编程语言，比如Python、Java、C++、Go等等，其实都是基于一个固定的编程理论进行设计。数据接哦股中“线性结构”的数据组织形式：C++、Java实现的“线性结构”叫数组。Python实现的“线性结构”叫序列。

线性结构的数据组织形式：n个具有相同特性的数据元素的有限序列，称之为线性结构。

Python中的序列类型的对象的组织结构：由多个相同特定的对象构成的一个有限集合，就是序列。

序列是一个对象。

n个具有相同特性的数据对象就可以放在一起，共同管理，就会构成一个序列对象。

序列这样的线性的数据组织结构可以实现方便的、高效的管理通类型的数据对象。

类似序列对象这样的线性的数据组织结构，本质是针对不同对象，为其构造一种固定的对象间逻辑关系（即一种对象可以由多种同类型的其他对象所构成），以达到“方便的、高效的”对同类型的数据对象的统一管理。

5.2 序列类型：字符串str

5.2.1 字符串定义

由一系列字符组成的不可变序列，存储的是字符的编码值；Python的字符串类型为一种可迭代对象。

Python中的对象，主要分为：可变类型对象、不可变类型对象。

可变类型对象：其对象在内存中创建完毕后，允许程序等其他操作对其对象的内部结构进行修改，这个过程不会产生新的对象，原对象所赋值的变量的地址空间不变。

不可变类型对象：因其不可变，所以其对象在内存中创建完毕后，不允许各种操作对原对象的内部结构做任何操作，如果非要进行相应操作，则会产生新的对象，且与原对象所赋值的变量的地址空间不一致。

5.2.2 字符串相关运算符

5.2.2.1 字符串拼接运算符

运算符 定义 对应重载方法

+ 字符串拼接 __add__

* 重复拼接对应次数的字符串 __mul__

注意：字符串+运算与数字类型对象的+运算不一样

对于数字类型来说，+运算是算术运算符，即对两个数值对象做算术加法运算，其值会进行相加。

对于字符串类型来说，+运算是做字符串拼接，即：将若干个字符串对象拼接为一个新的字符串对象。

对于字符串+运算，拼接之后打印拼接的结果字符串的id值发现：id值不相同，代表将原字符串进行拼接后生成了一个新的字符串对象。

正因为字符串属于不可变类型对象。

同理，对于*运算符，也不是算术运算中的*含义，对多个数子对象的数值进行乘积，而是在当前字符串对象基础上拼接若干次该字符串。

5.2.2.2 字符串成员运算符

运算符 含义 对应重载方法

in 判断某字符是否存在于该字符串，存在，返回True __contains__

not in 判断某字符是否存在于该字符串，不存在，返回True __contains__

5.2.3 字符串对象构造操作

语法：字符串对象 = str(object)

作用：将传入的任意合法类型的对象构造为一个字符串对象。

参数：任意合法类型对象

返回值：字符串对象

5.2.4 字符串的索引

5.2.4.1 序列的长度

序列的长度是指该序列类型对象中数据元素对象的个数。

5.2.4.2 索引的概念

索引是序列类型对象中每一个存在的数据元素的唯一标识符。

一个序列的数据元素的索引值总是从0开始计算，每个数据元素的索引值+1.

序列类型对象的每一个数据元素都对应一个唯一的索引值，通过该索引值可直接访问序列对象中的某一个具体的数据元素。

一个序列类型对象的第一个数据元素其索引值一定为0，最后一个数据元素的索引值一定为序列的长度（即序列中数据元素的个数）-1.

通过索引对一个序列类型对象中的每一个数据元素进行编号。每个数据元素有了编号，就可以方便的去管理该序列类型对象中任意一个数据元素了。

5.2.4.3 字符串的索引取值

语法：

字符串对象[索引值]

作用：根据某一索引位，获取该索引位对应的字符对象。

返回值：新的字符对象

5.2.4.4 字符串的索引切片

语法：

字符串[start:end:step]

作用：从字符串中截取指定长度的字符串片段。

参数：start：截取的起始位置索引值。end：截取的终止位置索引值。step：步长，即：每隔几个字符截取一次。

返回值：新的字符串对象。

参数传递细节：字符串做索引切片时，其参数传递是比较灵活的：可以选择传递两个参数，且如果是这样传递：字符串[start:end]代表只能传递起始位置索引值和终止位置索引值，不传递步长，此时默认步长为1，例如：

如果这样传递：字符串[:end:step]代表值传递结束位置索引值和步长，起始位置默认从0开始，例如：

如果这样传递：字符串[start::step]代表只传递起始位置索引值和步长，终止位置默认为最后一个字符。例如：

可以选择参数全部传递，即标准的传参方式。例如：

也可选择传递一个参数，

字符串[start::]代表只传递起始位置的索引值，默认结束位置为最后一个字符，默认步长为1，例：

字符串[:end:]代表只传递终止位置索引值，默认起始位置为0，默认步长为1，例：

字符串[::step]代表只传递步长，默认起始位置为0，终止位置为最后一个字符，例：

字符串索引切片的特殊用法：

字符串[::-1]代表没有其实位置（默认0），没有终止位置（默认最后一个字符），步长负值代表反向切片。

作用（效果）：对一个字符串做反序。例：

字符串[:]代表没有起始位置（默认为0），没有终止位置（默认最后一个字符），步长也没用。

作用（效果）：对当前字符串做拷贝，得到一个新的字符串对象。例：

5.2.5 字符串对象常用函数

len():

语法：results = len(str)

作用：获取一个字符串的长度，即字符串对象中字符的个数

参数：任意字符串对象

返回值：字符串的长度，int类型

max():

语法：results = max(str)

作用：获取该字符串中最大的字符。如果是中文、英文、符号字符串，则依据unicode编码获取编码值最大的字符。如果是数值型字符串，则依据字符对应的整型数值对象字面值大小获取最大的字符。

参数：任意字符串对象

返回值：最大值的字符，str类型

main():

语法：results = min(str)

作用：获取该字符串中值最小的字符。如果是中文、英文、符号字符串，则依据unicode编码获取编码值最小的字符。如果是数值型字符串，则依据字符对应的整型数值对象字面值大小获得最小的字符。

参数：任意字符串对象

返回值：最小值的字符，str类型

5.2.6 字符串的遍历

字符串是Python内置的一种可迭代对象。

因为可以通过遍历操作为可迭代对象中的每一个元素添加相同的功能逻辑，所以要对一个可迭代对象进行遍历操作。对一个可迭代对象进行遍历操作实现了简化一类相同特性的数据对象的共通的、同一的操作实现。

5.2.6.1 遍历一个字符串的两种方式

方式一：直接遍历该字符串（可迭代对象）的字符对象：

for 循环变量 in 字符串对象:
    同一操作
    通过print(i)获取每一个字符

此种遍历方式下，for循环的循环变量拿到的就是该字符串的每一个具体的字符对象。例：

方式二：遍历该字符串（可迭代对象）索引值：

for 循环变量 in range(len(字符串对象)):
    同一操作
    通过print(字符串对象[i])获取某一个字符

此种遍历方式下，先通过len()函数获取该字符串的长度，随后以长度值作为rang()函数的一个参，用其构造一个整数序列，该整数序列即对应字符串的索引值，随后通过遍历起索引值，即可实现遍历该字符串对象。取值时，通过循环变量获取到的索引值对字符串做索引取值操作，即可获取某字符。

5.2.7 字符串对象常用方法

【TODO】

str.count(son_str,beg=0,end=len(str)):

作用：返回一个指定的字符串在原字符串中出现的次数，如果指定beg及end参数，代表返回在原字符串中指定的范围内子字符串的出现次数

参数：son_str：检索的目标字符串。beg：检索的起始范围。end：检索的终止范围，默认参数值为原字符串的长度，即默认终止范围是最后一个字符串

返回值：目标字符串的出现次数，int类型。

str.join(seq):

作用：以字符串str作为拼接符，将seq列表中所有的字符串元素对象拼接为一个完整字符串

参数：列表，list类型

返回值：拼接后的字符串，str类型

str.split(分隔符):

作用：以一个字符串作为分隔符，将原字符串对象分割为包含多个字符串元素的列表。

参数：分隔符，str类型

返回值：列表，list类型

join与split方法为一组互逆方法

str.lstrip():

作用：去除字符串左边的空格

参数：无

返回值：去除左边空格后的新字符串对象，str类型

str.rstrip():

作用：去除字符串右边的空格

参数：无

返回值：去除右边空格后的新字符串对象，str类型

str.strip():

作用：去除字符串左右两边的空格

参数：无

返回值：去除左右两边空格后的新字符串对象，str类型

5.3 序列类型：列表list

5.3.1 定义

由一系列数据对象组成的可变序列，存储的是任意类型的对象。Python的列表类型为一种可迭代对象。

5.3.2 列表的创建语法

创建一个空列表：

list = []

创建列表时初始化列表数据元素对象：

list = [n1,n2,n3,…]

5.3.3 列表对象构造操作

语法：列表对象 = list(object)

作用：将传入的任意合法类型的对象构造为一个列表对象

参数：任意合法类型对象

返回值：列表对象

5.3.4 列表的可变类型对象与字符串的不可变类型对象的使用区别

字符串：字符串对象为不可变对象，代表：对象一旦创建则无论对其做拼接、切片等操作时，结果均返回一个新的字符串对象。

即：结果对象所赋值的变量的id值与原字符串变量的id值不同，

列表：因为列表对象为可变对象，代表：对象创建完毕后允许对其内部结构做修改，且这个过程不会产生一个新的列表对象。即：对象所赋值的变量的id值不发生改变。

5.3.5 列表相关运算符

5.3.5.1 列表拼接运算符

运算符 定义 对应重载方法

+ 列表拼接 __add__

* 重复拼接对应次数的列表 __mul__

注意：列表的+运算与数字类型对象的+运算不一样

对于数字类型来说：+运算是算术运算符，即对两个数值做算术加法运算，其值会进行相加。

对于列表类型来说：+运算符是做列表拼接，即若干个新列表对象拼接为一个新的列表对象。

5.3.5.2 列表成员运算符

运算符 含义 对应重载方法

in 判断某数据对象是否存在于该列表，存在，返回True  __contains__

not in 判断某数据对象是否不存在该列表，不存在，返回True  __contains__

5.3.6 列表的索引

5.3.6.1 序列的长度

序列的长度是指该序列类型对象中数据元素对象的个数。

list1 = [1,2,3,4,5]

列表list1的长度为：5，因为其包含了5个整数对象。

5.3.6.2 索引的概念

索引是序列类型对象中每一个存在的数据元素的唯一标识符

一个序列的数据元素的索引值总是从0开始计算，每个数据元素的索引值+1

序列类型对象的每一个数据元素都对应一个唯一的索引值，通过该索引值可直接访问序列类型对象中的某一个具体的数据元素。

一个序列类型的对象的第一个数据元素其索引值一定为0.最后一个数据元素的索引值一定为序列的长度（即序列中数据元素的个数）-1

5.3.6.3 列表的索引取值

语法：列表对象[索引值]

作用：根据某一索引位，获取该索引对应的数据对象

返回值：数据对象

5.3.6.4 列表的索引赋值

语法：列表对象[索引值] = 数据对象

作用：根据某一索引位，为该索引位赋值一个新的数据对象

5.3.6.5 列表的索引切片

语法：列表[start:end:step]

作用：从列表对象中截取指定长度的列表片段

参数：start：截取的起始位置索引值。end：截取的终止位置索引值。step：步长。即：每隔几个数据对象截取一次

返回值：新的列表对象

参数传递细节：列表做索引切片时，其参数传递是比较灵活的：

可以是选择传递两个参数：

列表[start:end:]

代表：只传递起始位置索引值和终止位置索引值，不传递步长。此时默认步长为1。

列表[:end:step]

代表：只传递结束位置索引值和步长，起始位置默认从0开始。

列表[start::step]

代表：只传递起始位置索引值和步长，终止位置默认为最后一个字符。

可以选择参数全部传递，即标准的传参方式。

也可以选择传递一个参数。

列表[start::]

代表：只传递起始位置的索引值，默认结束位置为最后一个字符，默认步长为1.

列表[:end:]

代表：只传递终止位置索引值，默认起始位置为0，默认步长为1.

列表[::step]

代表：只传递步长。默认起始位置为0，终止位置为最后一个字符。

列表索引切片的特殊用法。

列表[::-1]

代表：没有起始位置（默认0），没有终止位置（默认最后一个字符），步长负值代表反向切片

作用（效果）：对一个列表做反序

列表[:]

代表：没有起始位置（默认0），没有终止位置（默认最后一个字符），步长也没有

作用（效果）：对当前列表做拷贝，得到一个新的列表对象

5.3.7 列表对象常用函数

len()

语法：results = len(list)

作用：获取一个列表的长度，即列表对象中数据对象的个数

参数：任意列表对象

返回值：列表的长度，int类型

max()

语法：results = max(list)

作用：获取该列表中值最大的数据对象。如果是中文、英文、符号列表，则依据unicode编码获取编码值最大的对象。如果是数值型列表，则依据列表中的数值对应的字面值大小获得最大的对象。

参数：任意列表对象

返回值：最大值的对象，任意类型

min()

语法：results = min(list)

作用：获取该列表中值最小的数据对象。如果是中文、英文、符号列表，则依据unicode编码获取编码值最小的对象。如果是数值型列表，则依据列表中数值对象对应的字面值大小获得最小的对象。

参数：任意列表对象

返回值：最小值的对象，任意类型

5.3.8 列表的遍历

方式一：直接遍历该列表（可迭代对象）的数据对象

for 循环变量 in 列表对象:
    同一操作
    如何获取每一个数据对象:print(i)

解读：此种遍历方式下，for循环的循环变量拿到的就是该列表的每一个具体的数据对象，如：

方式二：遍历该列表（可迭代对象）的索引值：

for 循环变量 in range(len(列表对象)):
    统一操作
    如何获取某一个数据对象:print(列表[i])

解读：此种遍历方式下，先通过len()函数获取该列表的长度，随后以长度值作为range()函数的一个参数，用其构造一个整数序列，该整数序列即对应列表中数据对象的索引值，随后通过遍历其索引值，即可实现遍历该列表对象，取值时，通过循环变量获取到的索引值对列表做索引取值操作，即可获取某数据对象，如：

5.3.9 列表对象常用方法

list.append(obj)

作用：向列表的末尾添加一个新的数据对象

参数：任意合法类型对象

返回值：无

list.count(obj)

作用：统计某个元素在列表中出现的次数

参数：任意合法类型对象

返回值：某元素的出现次数，int类型

list.index(obj)

作用：返回某个数据对象的第一个匹配结果的索引值

参数：任意合法类型对象

返回值：该数据对象的第一个匹配结果的索引值，int类型

list.insert(index,obj)

作用：向指定索引为插入一个数据对象，后续数据对象的索引位后移一位

参数：index：向指定索引位插入一个数据对象，后续数据对象的索引位后移一位。obj：需要插入的数据对象，任意合法类型对象。

返回值：无

list.pop([index=-1])

作用：移除列表中某个数据对象，默认移除最后一位，在数据结构与算法的概念中，该方法对应：栈结构的末尾出栈操作

参数：可选，索引位，默认为-1，int类型

返回值：返回被移除的数据对象，任意合法类型对象

list.remove(obj)

作用：移除列表中某个数据对象的第一个匹配结果

参数：任意合法类型对象

返回值：无

list.reverse():

作用：将列表中的数据对象进行反序

参数：无

返回值：无

list.sort([reverse=False])

作用：将列表中的数值对象进行排序，默认为升序排序

参数：可选，是否降序排序，默认为False，代表升序排序

返回值：无

list.copy()

作用：将list列表通过浅拷贝得到一个新的拷贝的列表对象

参数：无

返回值：新的列表对象

5.3.10 列表推导式

语法：lists = [关于 循环变量 的表达式 for 循环变量 in 可迭代对象 [if 过滤条件]]

作用：简化列表对象的构造过程

列表推导式的嵌套

语法：lists = [关于 循环变量1&循环变量2 的表达式 for 循环变量1 in 可迭代对象1 for 循环变量2 in 可迭代对象2]

5.4 列表list类型重点知识讲解

5.4.1 重点讲解：可变类型对象与不可变类型对象

字符串类型是不可变类型对象。序列类型是可变类型对象。

要追溯到这两类对象的构造原理。几乎所有的编程语言所采用的程序设计理论基础都是数据结构与算法。在数据结构与算法的概念中，对象叫：实例。类型叫：抽象数据类型。

要从计算机程序设计与开发的角度说起。。。

5.4.1.1 抽象数据类型基本概念理解

仅凭基本数据类型无法完成开发需求。

数据是否够用

数据如何保证安全性。数据是否可以随意访问，数据内部是否可以随意修改

数据之间是否有共性。如何以数据为中心，如何围绕数据进行思考和设计

抽象数据类型的概念

全称：抽象数据类型

英文简称：ADT

定义：抽象数据类型（ADT）是指一个数学模型以及定义在此数学模型上的一组操作。抽象数据类型需要通过固有数据类型（高级编程语言中已实现的数据类型）来实现。抽象数据类型是与表示无关的数据类型，是一个数据模型及定义在该模型上的一组运算。对一个抽象数据类型进行定义时，必须给出他的名字及各运算的运算符名，即函数名，并且规定这些函数的参数性质。一旦定义了一个抽象数据类型及具体实现，程序设计中就可以像使用基本数据类型那样，十分方便地使用抽象数据类型。

【TODO】

————————————

仅用于本人学习

来源：网络

作者：许科大