万字长文爆肝呕血整理Python入门到精通,【巨详细，一学就会】

目录

前言

课程介绍

你将获得

适合人群

Python自学疑惑解答

30天从新手到大师

第1~20天 - Python语言基础

第20~30天 - Python语言进阶

Python语言基础

Python 简介

Python 下载安装

Python 语法

Python 注释

Python 变量

Python 数据类型

Python 运算符

Python 数字

Python 字符串

Python 布尔值

Python 列表

Python 元组

Python 数组

Python 集合

Python 字典

Python 分支

Python 循环

Python 面向对象

Python 继承

Python 多态

Python 内置函数

Python JSON

Python File

Python 实例

MySQL 日期/时间函数

---

 

前言

作为一名技术人员，经常有人问我一个问题————Python自学行吗？

问题这个问题的人，因为都是小白，对Python了解非常少，担心自己学不会或是坚持不下来。最终学习半途而废。其实学习一直是一件对意志力要求很高的事情。和学习的对象关联又关系，但并不会非常大。Python作为编程入门语言，可以说是很简单的，对于新人来讲完全可以借助网上的资料进行自学。而不需要交付高额的培训费用。下面我讲讲一些学习的节奏和方法，帮助新人快速学好Python。

Python学习中，新人非常关键的就是前20天，20天里学习的基础知识内容对新人来讲是比较困难的，这20天里面要弄清楚很多概念，才能进入学习的角色，所以建议，课程学习中配套视频进行学习，这样效果会更佳。下面列一个大概的学习框架，可供新人学习参考。

本文介绍

本篇文章内容简明易懂，不仅适合没有编程经验的小白从零开始学习，也适合有其他编程语言基础的同学学习。

贴合工作：即学即用，学完后1小时能完成别人手工一整天才能完成的工作。

系统学习：系统的帮你整理Python的知识要点，让你知其然，更知其所以然。

代码演示：教会你如何实战应用，快速入门，提升代码理解能力。

你将获得

系统掌握Python语言的技术点，高效的完成工作。

培养完整的编程思维，提升编程效率。

掌握Python的编程技巧，帮你升职加薪

适合人群

刚刚毕业的你： 期待个人成长，想学一门有技术含量的技术。

跨行转业的你： 想要转行，需要一块敲门砖。

做技术的你： 想要提升技能水平，期待进入IT核心领域。

想要提升效率的你： 摆脱天天加班做表的苦恼。

工作汇报的你： 通过Python学习获得领导的肯定和认可。

做数据分析的你： 面对大量数据，快速得到自己想要的结论。

面试的你： 面试前跟着文章系统的回顾一遍知识点。

Python自学疑惑解答

1、要不要学：Python发展太快了，随处可以见到Python广告，Python真的是被大家玩坏了～，Python真的像广告说的那么强大吗？
点击进入 >>> python值得学吗？ 普通人学python有意义吗？

2、难不难学：下定决心要学Python，你一定会关心Python学起来难吗？能学会吗？
点击进入 >>> 零基础学python难吗？ 毫无基础的人如何入门Python?

3、要学多久：Python如果能学会，那么新手自学Python需要多久？如果时间太长，通过培训结构需要多少钱？
点击进入 >>> python自学要多久？ 学python多少钱？

4、学习资料推荐：通过培训机构学习Python，培训结构会有系统的课程和资料帮助初学者学好Python，但如果自学的话，有没有什么好的平台或资料呢？
点击下方链接查看详情
python自学书籍推荐
自学Python有必要买课程吗?
python自学网站免费推荐?
免费python全套教程推荐?
python自学免费教程推荐?
10个免费自学的Python课程?
python官方文档中文版在哪下载?
python参考手册第五版下载?

5、优势和劣势：Python语言和其它语言有什么区别和联系呢？学习Python的方法能否借鉴其它编程语言，或是把学习Python方法应用到其他编程语言呢？
点击下方链接查看详情
Python和PHP有什么不同？各有什么特点？
Python2和Python3有什么不同？版本差别在哪？
Python和Javascript有什么不同？各自区别优势、劣势是什么？
Python和GO有什么不同？各自区别优势、劣势是什么？
Python，JAVA，PHP，PERL，Ruby，JavaScript，C++，TCL之间差别？
Python和C++有什么不同？各自区别优势、劣势是什么？
Python和Ruby有什么不同？各自区别优势、劣势是什么？

30天从新手到大师

前20天基础部分内容对新手来说是比较困难的，建议反复学习和练习并有配套视频进行学习，效果会更佳。

第1~20天 - Python语言基础

第 1 天 - 初识Python

制定学习计划 - 了解Python的系统知识 / 制定合理的学习计划
Python简介 - Python的历史 / Python特点 / Python的应用领域
搭建编程环境 - Windows环境 / Linux环境 / MacOS环境
从终端查看Python版本 - python -V / 了解安装错误的常见问题
Python IDE工具安装 - IntelliJ IDEA安装Python插件 / 新建python程序

第 2 天 - 基本语法

编程规范 - 关键字 / 缩进与空行 / 命名规则 / 数据类型
基本程序操作 - 输入和输出 / 模块导入 / 异常 / 空值 / 运算符
条件控制 - 分支机构 / while循环 / for循环
Python 注释 - 注释的介绍和作用 / 注释的用法 / 特殊写法
Python 变量 - 变量的命名规范 / 变量的用法 / 变量使用的常见问题

第 3 天 - 数据类型与运算

了解数据类型 - 文字类型 / 数值类型 / 序列类型 / 映射类型 / 集合类型 / 布尔类型 / 二进制类型
Python 解释器 - 交互式编程 / 脚本式编程
Python 运算符 - 算术运算符 / 赋值运算符 / 比较运算符 / 逻辑运算符 / 身份运算符 / 成员运算符 / 位运算符

第 4 天 - 数字、布尔和字符串详解

数字运算 - 数字运算 / 数学函数 / 随机数函数 / 三角函数 / 数学常量
布尔值 - 值比较 / if条件判断 / bool()函数
字符串操作 - 访问 / 更新 / 转译 / 运算符 / 格式化 / 换行 / 内置函数

第 5 天 - 列表、元组、数组、集合和字典详解

列表操作 - 访问列表 / 访问元组 / 修改元组 / 删除元组 / 元组运算符 / 元组索引和截取 / 元组内置函数
元组操作 - 创建元组 / if条件判断 / bool()函数
数组操作 - 数组与列表的区别 / 元素访问与修改 / 数组长度 / 数组遍历 / 添加和删除 / 操作方法
集合操作 - 创建与访问集合 / 添加元与删除元素 / 清空集合与判断元素 / 集合之间运算 / frozenset 集合 / 内置方法
字典操作 - 字典的特点 / 创建与访问字典 / 修改与删除字典 / 字典健判断 / 使用字典格式化字符串 / 内置函数 / 内置方法

第 6 天 - 分支结构

分支结构的应用场景 - 条件 / 动图演示过程 / 代码块 / 流程图
if语句 - 简单的if / if-else结构 / if-elif-else结构 / 嵌套的if
案例练习 - 操作符 / 根据年龄值判断后打印内容

第 7 天 - 循环结构

循环结构的应用场景 - 条件 / 动图演示过程 / 代码块 / 流程图
while循环 - 基本结构 / break语句 / continue语句
for循环 - 基本结构 / break语句 / continue语句 / pass 语句 / range()函数 / 循环嵌套
应用案例 - 冒泡排序 / 插入排序 / 选择排序

第 8 天 - 实战运用巩固知识

经典案例 - 水仙花数 / 百钱百鸡 / 两数之和 / 数组合并 / 不重复字符串 / 全排列
练习题目 - 斐波那契数列 / 完美数 / 素数

第 9 天 - 函数的调用

定义函数 - def语句 / 函数名 / 参数列表 / return语句 / 调用自定义函数
调用函数 - 如何调用 / 函数封装功能模块
函数的参数 - 必需参数 / 关键字参数 / 默认参数 / 不定长参数
函数的返回值 - 没有返回值 / 返回单个值 / 返回多个值

第 10 天 - 模块和作用域

模块定义 - 后缀名 / sys模块 / argv模块 / path模块
模块引用 - import 语句 / from … import 语句
模块常用方法 - __name__属性 / dir() 函数
包的操作 - 包的创建 / import导入模块 / from...import导入模块
作用域问题 - 局部作用域 / 嵌套作用域 / 全局作用域 / 内置作用域 / 和作用域相关的关键字

第 11-13 天 - 面向对象编程

类和对象 - 什么是类 / 什么是对象 / 属性 / 方法 / 封装 / 继承 / 多态
定义类 - 基本结构 / 属性和方法 / 构造器 / 析构器 / __init__方法
使用对象 - 创建对象 / 调用方法 / 访问权限

第 14-17 天 - 面向对象进阶

属性 - 类属性 / 实例属性 / 属性访问器 / 属性修改器 / 属性删除器 / 使用__slots__
类中的方法 - 实例方法 / 类方法 / 静态方法
继承用法 - 什么是继承 / 继承的语法 / 调用父类方法 / super()函数 / 添加方法 / 添加属性
多态用法 - 什么是继承 / 多态的用法 / 鸭子类型 / 运算符重载
迭代器 - 遍历集合 / 创建一个迭代器 / StopIteration / 生成器

第 18 天 - 时间与内置函数

时间元组 - 9组数字 / struct_time元组 / 时间戳
时间操作 - 获取当前时间 / 格式化时间 / 格式化日期 / 获取日历
Time 模块 - time.time() / time.sleep(secs) / time.gmtime([secs]) / time.clock()
内置函数 - dict() / input() / len() / min() / max() / iter() / list() / next()

第 19 天 - Json和XML的应用

JSON函数 - json.dumps / json.loads / 格式化 / 分隔符 / 结果排序
什么是 XML - XML格式 / XML 的解析 / SAX / DOM
XML解析 - ContentHandler类 / make_parser方法 / parser方法 / parseString方法

第 20 天 - 文件和异常

读文件 - 读取整个文件 / 逐行读取 / 文件路径
写文件 - 覆盖写入 / 追加写入 / 文本文件 / 二进制文件
异常处理 - 异常机制的重要性 / try-except代码块 / else代码块 / finally代码块 / 内置异常类型 / 异常栈 / raise语句
数据持久化 - CSV文件读取 / csv文件写入 /

第20~30天 - Python语言进阶

第 21 天 - 正则表达式

正则表达式入门 - 正则表达式的作用 / 元字符 / 转义 / 量词 / 分组 / 零宽断言 /贪婪匹配与惰性匹配懒惰
正则表达式搜索 - 使用re模块实现正则表达式操作（匹配、搜索、替换、捕获）
使用正则表达式 - compile函数 / group、groups、 match、 search、findall、finditer、sub、subn和split方法

第 22 天 - 进程和线程

进程和线程的概念 - 什么是进程 / 什么是线程 / 多线程的应用场景
使用进程 - _thread / threading / 线程池 / 进程间通信
使用线程 - thread模块 / threading模块 / Thread类 / Lock类 / 队列

第 23 天 - 网络应用开发

计算机网络基础 - 计算机网络发展史 / “TCP-IP”模型 / IP地址 / 端口 / 协议 / 其他相关概念
网络应用模式 - “客户端-服务器”模式 / “浏览器-服务器”模式
使基于HTTP协议访问网络资源 - 网络API概述 / 访问URL / requests模块 / 解析JSON格式数据
Python网络编程 - socket模块 / socket函数 / 创建TCP服务器 / 创建TCP客户端 / 创建UDP服务器 / 创建UDP客户端
电子邮件 - SMTP协议 / POP3协议 / IMAP协议 / smtplib模块 / poplib模块 / imaplib模块
短信服务 - 调用短信服务网关

第 24 天 - 图像和文档处理

用Pillow处理图片 - 图片读写 / 图片合成 / 几何变换 / 色彩转换 / 滤镜效果
读写Word文档 - 文本内容的处理 / 段落 / 页眉和页脚 / 样式的处理
读写Excel文件 - xlrd模块 / xlwt模块
生成PDF文件 - pypdf2模块 / reportlab模块

第25天 - 图形界面和游戏开发

使用tkinter开发GUI程序 - 创建顶层窗口 / 添加GUI组件 / GUI组件功能组织
使用pygame三方库开发游戏应用 - 图像处理 / 声音处理 / 视频处理 / 事件处理 / 碰撞处理
“大球吃小球”游戏 - 制作窗口 / 绘图 / 加载图像 / 动画效果 / 碰撞检测 / 事件处理

第 26 天 - Python CGI编程

什么是CGI - 了解CGI / Web服务器支持及配置 / HTTP头部 / CGI环境变量
请求方式 - GET方法 / POST方法 / CGI程序实例
CGI中使用Cookie - cookie的语法 / Cookie设置 / 检索Cookie信息

第 27 天 - Python 数据结构和算法

算法定义 - 什么是算法 / 重要的特征 / 算法好坏的评价维度
排序和查找算法 - 选择 / 冒泡 / 归并 / 顺序 / 折半
常用算法 - 穷举法 / 贪婪法 / 分治法 / 回溯法 / 动态规划

第 28 天 - Python PyMySQL

PyMySQL准备 - 了解PyMySQL / pip3 install PyMySQL / curl 命令来安装 / 常见错误
数据库操作 - 数据库连接 / 创建数据库表 / 插入 / 查询 / 更新 / 删除 / 执行事务 / 错误处理
安装 - python -m pip install mysql-connector / import mysql.connector
数据库操作 - 数据库连接 / 创建数据库表 / 插入 / 查询 / 更新 / 删除 / 执行事务 / 错误处理

第 29 天 - Python Mongodb和Redis

PyMongo 准备 - 了解PyMongo / pip3 install PyMongo / easy_install 安装 / 测试 PyMongo
数据库操作 - 创建数据库 / 创建集合 / 插入文档 / 查询文档 / 修改文档 / 删除 / 排序
Redis连接 - 连接池 / redis 连接基本参数 / 应用场景
redis 基本命令 - 增加键值 / 取值 / 删除元素 / set操作 / List操作 / 排序 / 管道

第 30 天 - Python 爬虫和Lambda表达式

何谓爬虫 - 了解爬虫 / 抓取 / 分析 / 存储
常见的反爬处理 - user-agent控制访问 / IP来限制 / 请求间隔 / 参数加密 / robots.txt限制
认识lambda - lambda是什么 / lambda结构 / lambda例子 / 匿名函数
lambda用法详解 - lambda + map / lambda + filter / lambda + reduce / lambda应用场景

Python语言基础

Python 简介

Python语言诞生在20世纪90年代初，创始人为荷兰人吉多·范罗苏姆 （Guido van Rossum）。为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，取名“Python”（蟒蛇），名称是源至电视喜剧《蒙提.派森的飞行马戏团》（Monty Python's Flying Circus）。
目前Python已经成为最受欢迎的编程语言之一。2004年以后，Python的使用率呈线性增长。由于Python语言的诸多优点，目前的研究机构和培训课程日益增多，使得Python的学习越来越容易。

简单易学：Python简单易学，通过本教程的学习你就能体会到。

运行速度快：Python 的底层是用 C 语言写的，运行速度非常快。

开源免费：使用者可以自由地阅读和改动源代码。

可移植性：Python可以被移植在多平台上，包括Linux、Windows、Symbian、android平台等等。

面向对象：Python既支持面向过程也支持面向对象编程。

可扩展性：可以部分程序用其它语言编写，集成到Python程序中。

丰富的库：Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、数据库、电子邮件、XML等等。

Python 应用

YouTube - 视频分享网站，在某些功能上使用到Python。

Reddit - 社交分享网站，最早用Lisp开发，在2005年转为Python。

Dropbox - 文件分享服务。

豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站。

Django - 鼓励快速开发的Web应用框架。

Fabric - 用于管理成百上千台Linux主机的程序库。

EVE - 网络游戏EVE大量使用Python进行开发。

Blender - 以C与Python开发的开源3D绘图软件。

BitTorrent - BT下载软件客户端。

Yahoo! Groups - 雅虎推出的群组交流平台。

Python 下载安装

Mac Python安装包下载及安装过程详细介绍

Linux Python安装包下载及安装过程详细介绍

Python IDE工具下载及安装过程详细介绍

Python 安装包下载

开始Python编程之前，首先需要安装Python环境，下面详细讲解如何在不同的操作系统上安装Python环境.

Python最新安装包在Python的官网：https://www.python.org可以下载，Python可以在多平台上运行，你可以根据自己的需要，下载对应的安装包。具体如下图所示。

Windows下安装Python环境

点击上图中的“windows”，下载对应的Python安装包

查看python下载的安装包存放位置

打开本机所在的目录

选择下载的安装文件  双击进行安装，具体步骤如下：

默认安装会勾选所有组件，并安装在 C 盘，勾选上Add Python 3.8 to PATH，可以将 Python 命令工具添加到系统 Path 环境变量中，后期使用 Python 命令会很方便。
这里建立选择自定义安装，将 Python 安装到其他磁盘，点击“Customize installation”进行入下一步。

 

 

安装成功后，打开 Windows 的命令行程序（命令提示符），输入命令：python -V（注意字母p是小写，V是大写），如下图所示。

Python 语法

编码

Python 2.x默认的字符和文件编码都是ASCII，Python 3.x默认的字符编码是unicode，默认的文件编码是UTF-8。在工作中遇到不同编码的问题，需要对编码进行转换，在Python中UTF-8或者是GBK编码的转换要经过Unicode。

关键字

Python 中的关键字不能用作任何变量的名称，Python 3.8.3中有33个关键字分别是，在终端输入命令语句，如下图所示。

>>> import keyword
>>> keyword.kwlist

执行结果如下：

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

注释

1、单行注释：在行首加 “#”，比如：

# 你好，我是单行注释
print ("Hello, World!")

print ("Hello, World!") # 你好，我是行末注释

2、多行注释：可以在多行的行首前加“#”或是在整段需要注释的内容首尾加'''或"""三重引号。

方法一：逐行注释

#单行注释1
#单行注释2
#单行注释3
print ("Hello, World!")

方法二：三个单引号进行注释

'''
单行注释2
单行注释2
单行注释3
'''
print ("Hello, World!")

方法三：三个双引号进行注释

"""
单行注释2
单行注释2
单行注释3
"""
print ("Hello, World!")

命名

模块名：使用下划线连接多个小写字母，例如：cat_action。包名：使用“.”符号连接多个小写字母，例如：com.lidihuo.cat。类名：首字母需大写，其它字母小写的单词，例如：Cat。变量命名：变量名由字母、数字和下划线构成，数字不能开头，不要跟关键字和系统保留字冲突，建议名称采用小写字母单词。函数和属性名：应全部使用小写字母，多个单词之间用“_”下划线分割。常量命名：应全部使用大写字母，多个单词之间用“_”下划线分割。模块内部的类名：采用 "下划线+首字母大写" 的形式，如 _Cat。

运算符

Python的运算符包括：算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符。

算术运算符：主要用于加减乘除等运算，运算符有：“+、-、 *、/、%、**、//”。比较运算符：用于对象之间的比较，运算符有：“==、!=、<>、>、<、>=、<=”。赋值运算符：用于对象的赋值，运算符有：“=、+=、-=、*=、/=、%=、**=、//=”。逻辑运算符：用于逻辑运算，运算符有：“and、or、not”。位运算符： 把数字看作二进制计算。运算符有：“&、|、^、~、<<、>>”。成员运算符：判断一个对象是否包含另一个对象，运算符有：“in、not in”。身份运算符：判断是不是引用自一个对象，运算符有：“is、is not”。

数据类型

Python中数据类型可以分为2大类，值类型和组类型。

组类型：组类型的成员类型有：序列（字符串、列表、元组）、集合和字典。

空值

在 Python 中空值不表示 0，也不表示空字符串，而表示没有值，空值也不代表空对象，与 []、“”也不同。空值用None表示，属于NoneType类型。
None 常用于判断函数有无返回值，在没有 return 语句的函数，都会在末尾加上 return None，使用不带值的 return 语句，函数就会返回 None。

缩进与空行

缩进：Python不同于其它的编程语言，Python没有用“{}”包裹代码块，而是用缩进来表示，所以代码的缩进成为了程序的重要组成部分，同一层级的代码块中缩进的空格数必须相同。

if 1==1:
 print ("success")
else:
 print ("fail") #同一层级缩进空格数不同，引发异常

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

多行连接

在Python中一行写不完的语句可以用“\”符号来连接，比如：

print (''Hello Python,\
I am \
lidehuo')

需要注意的是在(),{},[] 中无需用“\”连接，可以直接换行，比如：

animal = ['cat','dog','tiger',
'cow','horse'，'pig'
'bat','cock','bear']

输入和输出

输入：使用input([prompt])读取一行，将其转换为string类型并返回，input的参数可有可无，通常在控制台输入一些数据，然后敲击回车，就完成了本次输入。比如：

animal = input("请输入动物名称: ")
print(animal)

需要注意的是input返回的是string类型，想要得到其它数据类型，还需要进行类型转换。

输出：一般使用print进行输出，比较简单，比如：print ('Hello World')，当输出的内容包含变量时，可以用“，”连接，比如：print '数组为：',list。

模块导入

Python代码中进行模块导入非常高频。Python模块导入机制其实非常灵活。具体包括：常规导入、from语句导入、相对导入、可选导入和本地导入。

常规导入：使用“import”，导入多个包或模块时用“，”分隔，比如：import time,os。from语句导入：这个场景时候导入一个模块或库的部分功能，格式为：from xxx import xxx。比如：from datetime import datetime。相对导入：python中使用句点来决定如何相对导入其他包或模块，比如：from . import xxxx可选导入：主要用于优先或备选使用某个模块或包，语句操作结构为：

try:
 from xxx import xxx
except ImportError:
 from xxx import xxx

局部导入：在Python脚本的顶部导入一个模块，那么将该模块是全局作用域，如果想要局部作用域，导入语句都应该位于模块的顶部即可。

异常

Python 完整的异常处理结构如下：

try:
 #业务实现代码
except Exception1 as e:
 #异常处理块1
 ...
except Exception2 as e:
 #异常处理块2
 ...
#可以有多个 except
 ...
else:
 #正常处理块
finally :
 #资源回收块
 ...

整个异常处理结构中try块是必需的，但是也不能只使用 try 块，要么使用 try except结构，或是 try finally 结构；可以有多个 except 块，多个 except 块必须位于 try 块之后，finally 块必须位于所有的 except 块之后。

分支结构

Python代码是按照顺序单行执行的，执行中会出现分支情况，在Python中使用if、elif和else关键字来创建分支结构，具体如下：

If cond1:
 #业务代码块1
elif cond2:
 #业务代码块2
elif cond3:
 #业务代码块3
else:
 #业务代码块4

循环结构

Python循环有2种做法，一种是for-in循环，一种是while循环。

for-in循环：明确循环次数或者对一个容器进行迭代用for-in，具体格式如下：

for x in y:
 循环体

while循环：不知道循环次数时，我们使用while循环，while是否终止通过bool只判断。具体格式如下：

while cond:
 #业务代码块

内置函数

Python 解释器内置了很多函数具体如下：

函数	描述
abs()	返回数的绝对值
acos(x)	返回x的反余弦弧度值。
all()	如果可迭代对象中的所有项均为 true，则返回 True。
any()	如果可迭代对象中的任何项为 true，则返回 True。
ascii()	返回对象的可读版本。用转义字符替换 none-ascii 字符。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
bin()	返回数的二进制版本。
bool()	返回指定对象的布尔值。
bytearray()	返回字节数组。
bytes()	返回字节对象。
callable()	如果指定的对象是可调用的，则返回 True，否则返回 False。
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cos(x)	返回x的弧度的余弦值。
chr()	返回指定 Unicode 代码中的字符。
choice(seq)	从序列的元素中随机挑选一个元素。
classmethod()	把方法转换为类方法。
compile()	把指定的源作为对象返回，准备执行。
complex()	返回复数。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
delattr()	从指定的对象中删除指定的属性（属性或方法）。
dict()	返回字典（数组）。
dir()	返回指定对象的属性和方法的列表。
divmod()	当参数1除以参数2时，返回商和余数。
enumerate()	获取集合（例如元组）并将其作为枚举对象返回。
eval()	评估并执行表达式。
exec()	执行指定的代码（或对象）。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
filter()	使用过滤器函数排除可迭代对象中的项目。
float()	返回浮点数。
format()	格式化指定值。
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
frozenset()	返回 frozenset 对象。
getattr()	返回指定属性的值（属性或方法）。
globals()	以字典返回当前全局符号表。
hasattr()	如果指定的对象拥有指定的属性（属性/方法），则返回 True。
hash()	返回指定对象的哈希值。
help()	执行内建的帮助系统。
hex()	把数字转换为十六进制值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
id()	返回对象的 id。
input()	允许用户输入。
int()	返回整数。
isinstance()	如果指定的对象是指定对象的实例，则返回 True。
issubclass()	如果指定的类是指定对象的子类，则返回 True。
iter()	返回迭代器对象。
len()	返回对象的长度。
list()	返回列表。
locals()	返回当前本地符号表的更新字典。
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
map()	返回指定的迭代器，其中指定的函数应用于每个项目。
max()	返回可迭代对象中的最大项目。
memoryview()	返回内存视图（memory view）对象。
min()	返回可迭代对象中的最小项目。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
next()	返回可迭代对象中的下一项。
object()	返回新对象。
oct()	把数转换为八进制。
open()	打开文件并返回文件对象。
ord()	转换表示指定字符的 Unicode 的整数。
pow()	返回 x 的 y 次幂的值。
print()	打印标准输出设备。
property()	获取、设置、删除属性。
range()	返回数字序列，从 0 开始且以 1 为增量（默认地）。
radians(x)	将角度转换为弧度
repr()	返回对象的可读版本。
reversed()	返回反转的迭代器。
round()	对数进行舍入。
randrange([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
set()	返回新的集合对象。
sin(x)	返回的x弧度的正弦值。
setattr()	设置对象的属性（属性/方法）。
slice()	返回 slice 对象。
sorted()	返回排序列表。
@staticmethod()	把方法转换为静态方法。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
str()	返回字符串对象。
sum()	对迭代器的项目进行求和。
super()	返回表示父类的对象。
sqrt(x)	返回数字x的平方根。
tan(x)	返回x弧度的正切值。
tuple()	返回元组。
type()	返回对象的类型。
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。
vars()	返回对象的 __dict__ 属性。
zip()	从两个或多个迭代器返回一个迭代器。
__import__()	用于动态加载类和函数。

Python 注释

注释的介绍和作用

注释用于解释代码的逻辑和作用，增强代码的可读性。注释掉的代码和文字不会参与代码的编译和执行。注释分为单行注释和多行注释，当然多行注释也可通过多个单行注释实现。

注释的用法

1、单行注释：在行首加 “#”，比如：

# 你好，我是单行注释
print ("Hello, World!")

print ("Hello, World!") # 你好，我是行末注释

2、多行注释：可以在多行的行首前加“#”或是在整段需要注释的内容首尾加'''或"""三重引号。

方法一：逐行注释

#单行注释1
#单行注释2
#单行注释3
print ("Hello, World!")

方法二：三个单引号进行注释

'''
单行注释2
单行注释2
单行注释3
'''
print ("Hello, World!")

方法三：三个双引号进行注释

"""
单行注释2
单行注释2
单行注释3
"""
print ("Hello, World!")

特殊写法

当在字符串中使用三个单/双引号时是一种特殊的写法，比如：

str = '''I
like
lidihuo'''
print str

执行结果是

I
like
lidihuo

Python 变量

变量是一种载体，主要用于存储数据。变量的值可以被读取和修改。变量不需要单独声明，首次赋值时就会被创建.

变量的命名规范

变量可以使用短名称（如 a 和 b）或用更直观的名称（cat、animal、username）。变量命名规则包括：

变量名必须以字母或下划线字符开头，不能以数字开头。变量名称由字母、数字、字符和下划线（A-z、0-9 和 _）组成变量名称区分大小写（a、A是2个不同的变量）。

注意：变量名称区分大小写。

变量的用法

1、输出变量: 变量输出通过”print”关键字实现。

a = 1
print(a)

执行结果：

1

2、赋值创建变量

a = 1
b = "Hello World！"
print(a)
print(b)

执行结果：

1
Hello World！

注意：变量不需要使用类型声明。

3、变量值覆盖

a = "Hello"
a = "World"
print(a)

执行结果：

World

4、多个变量赋不同值

a, b, c = "cat", "dog", "cow"
print(a)
print(b)
print(c)

执行结果：

cat
dog
cow

注意：多个变量赋值等号前后变量和值顺序要一致，变量和值用“,”逗号分隔。

5、多个变量赋相同值

a = b = c = "cat"
print(a) print(b)
print(c)

执行结果：

cat
cat
cat

注意：多个变量用“=”连接而不是“,”。

Python 数据类型

• 不同的数据类型存储不同的数据，可以执行不同的操作。
• Python中的变量没有类型，这里的数据类型是指的内存中对象的类型。
• Python中常用的数据类型包括：文字类型、数值类型、序列类型、映射类型、集合类型、布尔类型和二进制类型。

标准数据类型

• 文字类型： str，比如“Hello World”。
• 数值类型： int ，float，complex，比如：1、1.2、1.2+1.3j。
• 序列类型： list，tuple， range。比如：[a,b,c]、(a,b,c)。
• 映射类型： dict，比如：{“a”:1,”b”:2}。
• 集合类型： set，frozenset，比如：{‘a’,’b’}。
• 布尔类型： bool，比如，True、False。
• 二进制类型： bytes，bytearray， memoryview。
• 注意：其中文字类型、数值类型、元组是不可变数据类型，列表、字典、集合是可变数据类型。

Python 运算符

运算符用于对变量和值执行操作。比如： 1 +2 = 3 中，1 和 2 被称为操作数，"+" 称为运算符。

Python支持运算符的类型如下:

算术运算符赋值运算符比较运算符逻辑运算符身份运算符成员运算符位运算符

下面我们一起来看看。

算术运算符

运算符	描述	实例	结果
+	加（两个数相加）	1 + 2	3
-	减（两个数相减）	2 - 1	1
*	乘（两个数相乘）	1 * 2	2
/	除（两个数相除）	6 / 3	2
//	取整除（向下取接近商的整数）	7//2	3
%	取模（返回除法的余数）	5 % 3	2
**	幂（返回x的y次幂）	2**4	16

赋值运算符

赋值运算符用来把右侧的值传递给左侧的变量，赋值运算符是等号=，结合其它运算符还能扩展出更强大的赋值运算符。

运算符	说 明	用法举例	等价形式
=	简单的赋值运算符	x = y	x = y
+=	加法赋值运算符	x += y	x = x + y
-=	减法赋值运算符	x -= y	x = x - y
*=	乘法赋值运算符	x *= y	x = x * y
/=	除法赋值运算符	x /= y	x = x / y
%=	取余数赋值运算符	x %= y	x = x % y
**=	幂赋值运算符	x **= y	x = x ** y
//=	取整数赋值运算符	x //= y	x = x // y
&=	按位与赋值运算符	x &= y	x = x & y
|=	按位或赋值	x |= y	x = x | y
^=	按位异或赋值运算符	x ^= y	x = x ^ y
<<=	左移赋值运算符	x <<= y	x = x << y，这里的 y 指的是左移的位数
>>=	右移赋值运算符	x >>= y	x = x >> y，这里的 y 指的是右移的位数

比较运算符

比较运算符也称关系运算符，用于对常量、变量或表达式的结果进行大小比较，比较的结果只有True（真）或False（假）两种状态。

运算符	描述	实例	结果
==	等于（比较对象是否相等）	1 == 2	False
!=	不等于（比较两个对象是否不相等）	1 != 2	True
>	大于（返回x是否大于y）	1 > 2	False
<	小于（返回x是否小于y）	1 < 2	True
>=	大于等于（返回x是否大于等于y）	1 >= 2	False
<=	小于等于（返回x是否小于等于y）	1 <= 2	True

逻辑运算符

逻辑运算符用于组合条件语句：

运算符	表达式	描述	实例	结果
and	x and y	且，两个值都为真返回真	True and True	True
or	x or y	或，有一个值为真返回真	True or False	True
not	not x	非，相反，值为真返回假	not True	False

身份运算符

身份运算符用于比较对象是否为同一个对象。

运算符	描述	实例	结果
is	引用自一个对象返回True	1 is ‘1’	False
is not	不是同一个对象返回True 1	is not ‘1’	True

成员运算符

成员资格运算符用于测试序列是否在对象中出现

运算符	描述	实例
in	如果对象中存在具有指定值的序列，则返回 True。	x in y
not in	如果对象中不存在具有指定值的序列，则返回 True。	x not in y

位运算符

位运算符用于比较（二进制）数字

运算符	描述	实例
&	AND,参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	OR,只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	XOR,当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	NOT,对数据的每个二进制位取反,即把1变为0,把0变为1。	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位。	a >> 2 输出结果 15 ，二进制解释： 0000 1111

运算符优先级

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

Python 数字

Python 数字数据类型用于存储数值，类型是不允许改变的,改变类型的值，将重新分配内存空间。数字类型如下表。

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3e+18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

随机数函数

Python中常用随机数函数：

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

三角函数

Python中常用的三角函数

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

数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

Python 字符串

字符串必须由双引号" "或者单引号' '包围，例如：

str1 = 'Hello'
str2 = "World"

字符串的内容可以包含字母、数字、标点、符号、中文和外文。

访问字符串的值

Python 访问子字符串，可以使用方括号来截取字符串，例如:

str1 = 'Hello'
str2 = "lidehuo"
print("var1[0]: ", str1[0])
print("var2[1:5]: ", str2 [1:5])

执行结果：

var1[0]: , H
var2[1:5]: , ideh

字符串拼接

字符串之间可以进行拼接，例如：

str = 'Hello World'
print(str[:2] + 'lidehuo')

执行结果：

Helidehuo

字符串转译

当字符中出现特殊字符时，需要用反斜杠(\)转义字符。如下表：

字符串运算符

下表为字符串的运算：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行。
\other	其它的字符以普通格式输出。

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
%	格式字符串

字符串格式化

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

格式化操作符辅助指令:

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

字符串内置函数

Python 的字符串常用内建函数如下：

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

Python 布尔值

布尔值有两种：True 或 False。

比较两个值时，将对表达式求值，Python 返回布尔值答案

print(2 > 1)
print(2 == 1)
print(2 < 1)

执行结果：

True
False
False

当在 if 语句中运行条件时，返回 True 或 False：

a = 2
b = 1
if ( b > a ):
 print("b 大于 a")
else:
 print("b 小于等于 a")

执行结果：

b 小于等于 a

评估值和变量

bool() 函数可评估值并返回 True 或 False。

a = “Hello”
print(bool("Hello"))
print(bool(["1", "2", "3"]))
print(bool(a))

执行结果：

True
True
True

注意：实际上，除空值（例如 ()、[]、{}、""、数字 0 和值 None、False ）外，没有多少值会被评估为 False。

print(bool(False))
print(bool(None))
print(bool(0))
print(bool(""))
print(bool(()))
print(bool([]))
print(bool({}))

执行结果：

False
False
False
False
False
False

Python 列表

• 列表第一个索引是0，第二个索引是1，依此类推。
• 序列都可以进行索引，切片，加，乘，检查成员等操作。
• 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
• 列表用方括号[]包裹元素，元素并用逗号分隔。
• 列表的数据项可以是不同的数据类型

列表格式如下：

list1 = ['cat', 'dog', 1, 2]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

访问列表的值

使用下标索引来访问列表中的值，或是使用方括号的形式获取，例如：

list1 = ['cat', 'dog', 1, 2]
list2 = [1, 2, 3, 4, 5 ]
print("list1[0]: ", list1[0])
print("list2[1:3]: ", list2[1:3])

执行结果：

list1[0]: , cat
list2[1:3]: , [2, 3]

列表更新

列表的数据项可以进行修改或更新，例如：

list = ['cat', 'dog']
x = ('cow', 'pig')
list[0] = 'lion' #修改第一个元素
print(修改第一个元素: ",list)
list.append(x); #使用append()追加，追加的元素会被当成一个整体
print("元素不被当成一个整体: ",list)
list = ['cat', 'dog']
list.extend(x); #使用extend()追加，追加的元素不会被当成一个整体
print("元素不被当成一个整体: ",list)
list[0: 4] = [1.2, 3, 4] # 修改从头第1～4个元素
print("修改从头第1～4个元素: ",list)
list[5: 5] = [5, 6, 7] # 在第5个元素位置后插入元素
print("在第5个元素位置后插入元素: ",list)

执行结果：

修改第一个元素: ['lion', 'dog']
元素被当成一个整体: ['lion', 'dog', ('cow', 'pig')]
元素不被当成一个整体: ['cat', 'dog', 'cow', 'pig']
修改从头第1～4个元素: [1.2, 3, 4]
在第5个元素位置后插入元素: [1.2, 3, 4, 5, 6, 7]

删除列表元素

可以使用 del 语句来删除列表的的元素，例如：

list = ['cow', 'dog', 1, 2, 3]
print("原始列表 : ", list)
dellist[4] # 删除第5个元素
print("删除第5个元素 : ", list)
list = ['cow', 'dog', 1, 2, 3]
delpop(3) # 删除1～3之间的元素
print("删除1～3之间的元素个元素 : ", list)
list = ['cow', 'dog', 1, 2, 3]
list.pop(3) # 删除第4个元素
print("删除第4个元素 : ", list)
list = ['cow', 'dog', 1, 2, 3]
list.remove('dog') # 删除dog元素
print("删除dog 元素: ", list)

执行结果：

原始列表 : ['cow', 'dog', 1, 2, 3]
删除第5个元素 : ['cow', 'dog', 1, 2]
删除第1～3个元素 : [1, 2, 3]
删除第4个元素 : ['cow', 'dog', 1, 3]
删除dog 元素: ['cow', 1, 2, 3]

列表操作符

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

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

列表拼接和嵌套

列表还支持拼接和嵌套操作，如下：

list1 = [1, 2, 3, 4, 5]
list2 = [6,7,8,9]
x = list1+list2
y = [list1, list2]
print(x)
print(y)

执行结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[[1, 2, 3, 4, 5], [6, 7, 8, 9]]

Python列表函数&方法

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

Python包含以下方法:

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

Python 元组

元组与列表类似，不同之处有2点：

元组的元素不能修改，包括修改元素值，删除和插入元素;元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号()中用逗号隔开元素即可，格式为：(item1, item2, ... , itemn)

存储的元素包括整数、实数、字符串、列表、元组等数据类型，且同一个元组中数据类型可以不同，例如：(1, '2', [2,'a'], ("abc",3.0))

创建元组

元组可以使用下标索引来访问元组中的值，如下实例:

tuple1 = () # 创建一个空元组
print("空元组数据类型为%s,元组数据：%s。" % (type(tuple1),tuple1))
tuple1 = 10
print("不加逗号，数据类型为%s,元组数据：%s。" % (type(tuple1),tuple1))
animal = "cat", "dog"
print("不加括号，数据类型为%s,元组数据：%s。" % (type(animal),animal))
tuple1 = (10,)
print("加上逗号，数据类型为%s,元组数据：%s。" % (type(tuple1),tuple1))
#将列表转换成元组
list = ['cat', 'dog', 'pig', 'lion']
tuple1 = tuple(list)
print("使用tuple和list创建元组数据：{value}。".format(value=tuple1))
# 将区间转换成元组
range = range(1, 6)
tuple1 = tuple(range)
print("使用tuple和range创建元组数据：{value}。".format(value=tuple1))

执行结果：

空元组数据类型为,元组数据：()。
不加逗号，数据类型为,元组数据：10。
不加括号，数据类型为,元组数据：('cat', 'dog')。
加上逗号，数据类型为,元组数据：(10,)。
使用tuple和list创建元组数据：('cat', 'dog', 'pig', 'lion')。
使用tuple和range创建元组数据：(1, 2, 3, 4, 5)。

访问元组

和列表一样，我们可以使用2种方式访问元组。

使用索引（Index）访问元组中的某个元素，格式为：tuplename[i]使用切片访问元组元素，格式为：tuplename[start : end : step]

具体例子如下：

animal = ('dog', 'cat', 'lion', 'pig')
print("animal[0]: ", animal[0])
print("animal[-2]: ", animal[-2])
print("animal[1:3]: ", animal[1:3])
print("animal[-3: -1]",animal[-3: -1])

执行结果：

('animal [0]: ', 'dog')
('animal [-2]: ', 'lion')
('animal [1:3]: ', ('cat', 'lion'))
('animal [-3: -1]', ('cat', 'lion'))

修改元组

元组中的元素不能被修改，这里说的修改是创建一个新的元组去替代旧的元组。具体如下：

tuple1 = (1, 2, 3, 4)
print("原始元组的值{value}".format(value=tuple1))
tuple1 = (5,6,7,8)
print("对元组进行重新赋值{value}".format(value=tuple1))
tuple2 = (1,2,3,4)
print("输出两个累加元组的值{value}".format(value=(tuple1+tuple2)))
print("tuple1元组的值{value}".format(value=tuple1))
print("tuple2元组的值{value}".format(value=tuple2))

执行结果：

原始元组的值(1, 2, 3, 4)
对元组进行重新赋值(5, 6, 7, 8)
输出两个累加元组的值(5, 6, 7, 8, 1, 2, 3, 4)
tuple1元组的值(5, 6, 7, 8)
tuple2元组的值(1, 2, 3, 4)

删除元组

当创建的元组不再使用时，可以通过 del 关键字将其删除，例如：

animal = ('dog', 'cat', 'lion', 'pig')
print(animal)
del animal
print("删除后的元组 tup :{vlaue} ".format(vaule=animal))

执行结果：

('dog', 'cat', 'lion', 'pig')
Traceback (most recent call last):
File "/Users/yf/workspace/firstpython/class/course.py", line 100, in 
print ("删除后的元组 tup :{vlaue} ".format(vaule=animal))
NameError: name 'animal' is not defined

输出变量会有异常信息，说明元组animal已被删除。

元组运算符

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

Python表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

元组索引和截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：tuple = ('dog', 'cat', 'lion')

Python 表达式	结果	描述
tuple[2]	'lion'	读取第三个元素
tuple[-2]	'cat'	反向读取，读取倒数第二个元素
tuple[1:]	'cat', 'lion'	截取元素，从第二个开始后的所有元素。

元组内置函数

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

方法及描述	实例	结果
len(tuple) 计算元组元素个数。	tuple = ('dog', 'cat', 'lion') print(len(tuple))	3
max(tuple) 返回元组中元素最大值。	tuple = (1, 2, 7) print(max(tuple))	7
min(tuple) 返回元组中元素最小值。	tuple = (1, 2, 7) print(min(tuple))	1

Python 数组

数组（array）与列表（list）的区别

数组也是序列类型和列表非常类似，除了数组存储对象的类型是受约束的外，其它和列表类似。

数组只能够保存相同类型的元素,而列表存放的元素类型不受限制，可以是任何类型。数组和列表提供的操作方法基本一致,都有append,insert,pop extend,index等操作方法。对全是数字类型的元素操作中,数组的操作效率比列表要快很多。

Python数组的结构和列表一样是用方括号[], 并用逗号分割元素，例如:

animal = ['cat', 'dog', 'pig', 'cow']
print(animal)

执行结果：

['cat', 'dog', 'pig', 'cow']

数组长度

获取数组的长度可以使用 len()方法，即获取数组中的元素数量。例如：

animal = ['cat', 'dog', 'pig', 'cow']
x = len(animal)
print(x)

执行结果：

4

数组遍历

数组的遍历可以使用for in进行循环，按照元素排列顺序进行遍历。例如：

animal = ['cat', 'dog', 'pig', 'cow']
for x in animal:
  print(x)

执行结果：

cat
dog
pig
cow

元素添加和删除

数组的添加可以使用 append()和insert()方法，删除可以使用remove()和pop()方法。例如：

animal = ['cat', 'dog', 'pig', 'cow']
animal.append('wolf') # 追加元素，添加到末尾
print(animal)
animal.pop(1) # 删除第2个元素
print(animal)
animal.remove('cat') # 根据元素值进行删除
print(animal)
animal.insert(0, 'cat') # 在第一个元素后插入cat
print(animal)

执行结果：

cat, dog, pig, cow , wolf
cat, pig, cow , wolf
pig, cow , wolf
cat, pig, cow , wolf

数组操作方法

Python提供一组可以在列表或数组上使用的操作方法:

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

Python 集合

• 集合和字典类似也是无序的，用来保存不重复的元素。
• Python中的集合将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，格式为：{item1,item2,...,itemn}。
• 集合只能存储不可变的数据类型，包括整型、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型。

>>> animal = {'cat', 'dog', 'pig', 'cow'}
>>> print(animal) # 这里演示的是去重功能
{'cat', 'dog', 'pig', 'cow'}
>>> 'dog' in animal # 快速判断元素是否在集合内
True
>>> a = set('abcdefghijklmn')
>>> b = set('dehkmn')
>>> a
{'m', 'i', 'n', 'b', 'a', 'f', 'k', 'e', 'l', 'c', 'h', 'j', 'd', 'g'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'i', 'b', 'a', 'f', 'l', 'c', 'j', 'g'}
>>> a | b # 集合a或b中包含的所有元素
{'m', 'i', 'n', 'b', 'a', 'k', 'e', 'h', 'f', 'l', 'c', 'j', 'd', 'g'}
>>> a & b # 集合a和b中都包含了的元素
{'m', 'n', 'k', 'e', 'h', 'd'}
>>> a ^ b # 不同时包含于a和b的元素
{'i', 'b', 'a', 'f', 'l', 'c', 'j', 'g'}

创建set集合

a = {1,'a',(1,2,3),'b',1.2} 用{}方式创建
b = set((1,2,3,4,5)) set方式创建
print(a)
print(b)

执行结果：

{1, 1.2, (1, 2, 3), 'b', 'a'}
{1, 2, 3, 4, 5}

注意：创建空集合只能使用 set() 函数实现，使用一对 {}，会将视为一个空字典。

访问set集合

访问集合元素常用的方法是使用循环结构将集合中的数据逐一读取出来。

a = {'cat', 'dog', 'cow', 'pig'}
print(a)
for item in a:
 print(item)

执行结果：

{'cow', 'cat', 'pig', 'dog'}
cow
cat
pig
dog

set集合添加元素

set集合添加元素的方法是add()或updte()，将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

animal = {'cat', 'dog', 'cow', 'pig'}
animal.add("wolf")
print(animal)
animal.update({'tiger','zebra'})
print(animal)

执行结果：

{'dog', 'cat', 'wolf', 'pig', 'cow'}
{'dog', 'zebra', 'cat', 'wolf', 'tiger', 'pig', 'cow'}

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除集合中在另一个指定集合相同的元素，并将另一个集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

Python 字典

字典是无序可变的序列，元素以“键值对（key-value）”的形式存储。字典相对于列表（list）和元组（tuple）是有序的序列。字典中的元素是通过键来存取的，列表是通过下标索引存取的。字典用 { } 标识，是一个键(key) : 值(value) 的集合，key值必须保障唯一。字典格式为{'key':'value1', 'key2':'value2', ..., 'keyn':valuen}字典键必须是唯一的，但值不需要，值可以取任何数据类型。

创建字典

dict = {}
dict['name'] = "lidihuo"
dict[1] = "Hello World"
dict1 = {'name': 'lidihuo','course':'python', 'site': 'www.lidihuo.com'}
dict2 = {(1,2,3): 'great', 30: [1,2,3]} # 使用元组和列表作为key和value
print(dict['name']) # 输出键为 'name' 的值
print(dict[1]) # 输出键为1的值
print(dict1) # 输出完整的字典
print(dict1.keys()) # 输出所有键
print(dict1.values()) # 输出所有值
print(dict2) # 输出完整的字典

执行结果：

lidihuo
Hello World
{'name': 'lidihuo', 'course': 'python', 'site': 'www.lidihuo.com'}
dict_keys(['name', 'course', 'site'])
dict_values(['lidihuo', 'python', 'www.lidihuo.com'])
{(1, 2, 3): 'great', 30: [1, 2, 3]}

字典内置函数

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> dict = {'name': 'lidihuo','course':'python', 'site': 'www.lidihuo.com'} >>> len(dict) 3
2	str(dict) 输出字典，以可打印的字符串表示。	>>> dict = {'name': 'lidihuo','course':'python', 'site': 'www.lidihuo.com'} >>> str(dict) "{'name': 'lidihuo','course':'python', 'site': 'www.lidihuo.com'}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> dict = {'name': 'lidihuo','course':'python', 'site': 'www.lidihuo.com'} >>> type(dict)

字典内置方法

序号	函数及描述
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() 返回一个迭代器，可以使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 返回一个迭代器，可以使用 list() 来转换为列表
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 随机返回并删除字典中的最后一对键和值。

Python 分支

Python程序执行顺序是从头到尾的顺序依次执行，所以执行过程中需要通过条件控制执行的代码块。使用 if、if else或if elif else 语句对条件进行判断，可根据不同的条件执行不同的代码，它们的语法和执行流程如下图所示。

代码执行过程：

结构

Python中if语句的一般形式如下所示：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

若 condition_1 条件成立（True），将执行 statement_block_1 业务代码块若 condition_1 条件不成立（False），将跳过 statement_block_1 业务代码块，进入下一个条件判断若 condition_2 条件成立（True），将执行 statement_block_2 业务代码块若 condition_2 条件不成立（False），将 statement_block_2 业务代码块，进入下一个条件判断

Python 中用 elif是else if的简写，所以if语句的关键字格式为：if – elif – else。

注意：每个条件后面要使用冒号(:)，使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

实例

以下是一个简单的 if 实例：

age = 20
if age >= 18:
    print("恭喜你，你已经成年啦～")
elif age < 18 and age >12:
    print("恭喜你，你已经成年啦～")
elif age < 13 and age >7:
    print("你是为少儿～")
else:
    print("你是为婴幼儿～")

执行结果：

恭喜你，你已经成年啦～

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

if 嵌套

Python中if语句的一般形式如下所示：

if condition_1:
    statement_block_1
    if condition_2:
        statement_block_3
    elif condition_3:
        statement_block_3
    else:
        statement_block_4
elif condition_5:
    statement_block_6
else:
    statement_block_6

以下是一个简单的实例：

age = 50
if age >= 18:
    print("恭喜你，你已经成年啦～")
    if age == 50:
        print("你的年龄是50岁")
    elif age == 40:
        print("你的年龄是40岁")
    else:
        print("你的年龄不是30岁也不是40岁")
elif age < 18 and age >12:
    print("你的年龄在12岁到18岁之间")
else:
    print("你的年龄小于12岁")

执行结果：

恭喜你，你已经成年啦～
你的年龄是50岁

Python 循环

Python中的循环语句有 for 和 while。

Python for循环的用法

Python 循环语句的控制结构图如下所示：

while 循环

Python 中 while 语句的一般形式：

while condition:
    statement_block

程序执行过程如下所示：

和if一样，需要注意冒号(:)和缩进。另外，和java不同的是，Python中并没有 do while 的循环结构。

以下实例用while循环实现1～50的正整数求和：

number = 50
sum = 0
while number > 0:
    sum = sum + number;
    number = number - 1;
print("1 到 50 之和为: %d" % (sum))

执行结果：

1 到 50 之和为: 1275

while 循环使用 else 语句

在 while … else 在条件语句为 false 时执行 else 的语句块。语法格式如下：

while condition:
    statement_block else: condition:
    statement_block

循环输出数字，并判断大小：

number = 3
while number > 0:
    print(number)
    number = number - 1;
else:
    print("number小于等于0")

执行结果：

3
2
1
number小于等于0

一行简写

如果你的while循环体中只有一条语句，可以将该语句与while写在同一行中， 如下所示：

number = 50
while number > 0:  

  print("number 大于 50。")

注意：注意：以上的无限循环你可以使用 CTRL+C 来中断循环。

执行结果：

number 大于 50。
number 大于 50。
number 大于 50。
number 大于 50。
number 大于 50。
number 大于 50。
......

break 语句

如果使用 break 语句，即使 while 条件为真，也可以停止循环：

number = 50
while number > 0:
    print("number 大于 50。")
    break;

执行结果：

number 大于 50。

continue 语句

如果使用 continue 语句，就可以停止当前的迭代，并继续下一个，通过以下实例可以看出如果 i 等于 3，则继续下一个迭代：

number = 5
while number > 0:
    number = number - 1;
    if number == 3:
        continue;
    print(number)

执行结果：

4
2
0
1

Python 面向对象

面向对象技术简介

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭，很多初学者会因无法理解面向对象而放弃学习编程。本章节我们将详细介绍Python的面向对象编程。

面向对象编程（Object-oriented Programming，简称 OOP），如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基本特征。

类：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

属性：类中的所有变量称为属性。方法：类中定义的函数。不过，和函数所有不同的是，类方法至少要包含一个 self 参数。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

局部变量：定义在方法中的变量，只作用于当前实例的类。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

方法重载：类中支持多个同名函数，但参数的个数或类型要不同，在调用的时候，解释器会根据参数的个数或者类型，调用相应的函数。

封装：将类的某些部分（属性、方法）隐藏起来，具有一定的保护作用，隐藏对象的属性和方法实现细节，仅对外提供公共的访问方式。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

多态：多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

实例化：创建一个类的实例，类的具体对象。

定义类

语法格式如下：

class 类名:
    执行语句
    类变量
    类方法

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。类最重要的两部分就是类变量和类方法，类成员之间的可以相互调用。

在Python中可以使用class关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。

class Animal():
    # __init__用于在创建对象时进行初始化操作,通过这个方法可以绑定name和color两个属性
    def __init__( self, name, color):
        self.name = name
        self.color = color

    def play( self, action):
        print('%s正在玩%s.' % (self.name, action))

animal = Animal("dog","black")
animal.play("篮球")

执行结果：

dog正在玩篮球.

写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。当我们定义好一个类之后，可以通过上面的方式来创建对象并调用。

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self):
    self.data = []

类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 Animal，对应的 __init__() 方法就会被调用:

animal = Animal("dog","black")

当然， __init__() 方法可以没有参数。

self代表类的实例，而非类，类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Animal:
    def show( self):
        print(self)
        print(self.__class__)
animal = Animal()
animal.show()

执行结果：

<__main__.Animal instance at 0x10ad9d638>
__main__.Animal

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 lidihuo 也是可以正常执行的:

class Animal():
    def show( lidihuo):
        print(lidihuo)
        print(lidihuo.__class__)
animal = Animal()
animal.show()

执行结果：

<__main__.Animal instance at 0x10ad9d638>
__main__.Animal

访问权限

对于C++、Java、C#等编程语言的属性有4种访问权限，而在在Python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头，下面看个列子。

class Animal:
    # __init__用于在创建对象时进行初始化操作,通过这个方法可以绑定name和color两个属性
    def __init__( self, name, color):
        self.name = name
        self.color = color

    def __play( self, action):
        print('%s正在玩%s.' % (self.name, action))

def main():
    animal = Animal("dog","black")
    animal.__play("篮球")
if __name__ == "__main__":
    main()

执行结果：

Traceback (most recent call last):
File "script.py", line 14, in
main()
File "script.py", line 12, in main
animal.__play("篮球")
AttributeError: 'Animal' object has no attribute '__play'

在实际开发中，我们并不建议将属性设置为私有的，因为这会导致子类无法访问。但让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。

@property装饰器

上面我们讲到python中属性和方法访问权限，我们不建议将属性设置为私有的，但是有时直接将属性暴露给外界也是有问题的，前面我们建议将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。通过@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。

class Animal:
    def __init__( self, name, color):
        self.name = name
        self.color = color

    # 访问器 - getter方法
    @property
    def name( self):
        return self._name

    # 访问器 - getter方法
    @property
    def color( self):
        return self._color

    # 修改器 - setter方法
    @name.setter
    def name( self, name):
        self._name = name

    # 修改器 - setter方法
    @color.setter
    def color( self, color):
        self._color = color

    def play( self, action):
        print('%s正在玩%s.' % (self.name, action))

def main():
    animal = Animal("dog","black")
    animal.play("篮球")

if __name__ == "__main__":
    main()

执行结果：

dog正在玩篮球.

__slots__魔法

Python是一门动态语言，允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。限定对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。

class Animal:
    # 限定Person对象只能绑定_name, _color和_age属性
    __slots__ = ('_name', '_color', '_age')
    def __init__( self, name, color):
        self.name = name
        self.color = color

    # 访问器 - getter方法
    @property
    def name( self):
        return self._name

    # 访问器 - getter方法
    @property
    def color( self):
        return self._color

    # 修改器 - setter方法
    @name.setter
    def name( self, name):
        self._name = name

    # 修改器 - setter方法
    @color.setter
    def color( self, color):
        self._color = color

    def play( self, action):
        print('%s正在玩%s.' % (self.name, action))

def main():
    animal = Animal("dog","black")
    animal.play("篮球")
    animal._age = (5)
    animal._weight = (50)

if __name__ == "__main__":
    main()

执行结果：

animal._weight = (50)
AttributeError: 'Animal' object has no attribute '_weight'

静态方法和类方法

@staticmethod，静态方法，通过类直接调用，不需要创建对象，不会隐式传递self@classmethod，类方法，方法中的self是类本身，调用方法时传的值也必须是类的公有属性，就是说类方法只能操作类本身的公有字段。

class Animal:
    name = "Dog"
    color = "Black"

    @classmethod
    def play( self, action):
        print('%s正在玩%s.' % (self.name, action))

    @staticmethod
    def show():
        print('%s是%s的.' % (Animal.name,Animal.color))

def main():
    animal = Animal()
    animal.play("篮球")
    Animal.show()
if __name__ == "__main__":
    main()

执行结果：

Dog正在玩篮球.
Dog是Black的.

Python 继承

继承允许定义继承另一个类的所有方法和属性的类。父类是继承的类，也称为基类。子类是从另一个类继承的类，也称为派生类。

创建父类

创建一个名为 Person 的类，其中包含 firstname 和 lastname 属性以及 printname 方法：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

# 实现特定功能的多行代码使用 Animal 来创建对象，然后执行 printinfo 方法：

x = Animal("dog", 6)
x.printinfo()

执行结果：

name is dog , age is 6

创建子类

创建一个名为 Cat 的类，它将从 Animal 类继承属性和方法：

class Cat(Animal):
    pass

注意：如果您不想向该类添加任何其他属性或方法，请使用 pass 关键字。

现在，Cat 类拥有与 Animal 类相同的属性和方法。

使用 Cat 类创建一个对象，然后执行 printinfo 方法：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    pass # 实现特定功能的多行代码使用 Animal 来创建对象，然后执行 printinfo 方法：
x = Cat("cat", 8)
x.printinfo()

执行结果：

name is cat , age is 8

__init__() 函数

到目前为止，我们已经创建了一个子类，它继承了父类的属性和方法。

我们想要把 __init__() 函数添加到子类（而不是 pass 关键字）。需要注意的是每次使用类创建新对象时，都会自动调用 __init__() 函数。

为 Cat 类添加 __init__() 函数

class Cat(Animal):
    def __init__(self, name, age):

注意：当您添加__init__()函数时，子类将不再继承父的__init__()函数。子的 __init__() 函数会覆盖对父的 __init__() 函数的继承

如需保持父的 __init__() 函数的继承，请添加对父的 __init__() 函数的调用：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    def __init__(self, name, age):
        Animal.__init__(self, name, age)
x = Cat("cat", 10)
x.printinfo()

执行结果：

name is cat , age is 10

super() 函数

Python 还有一个super() 函数，它会使子类从其父继承所有方法和属性：

通过使用 super() 函数，您不必使用父元素的名称，它将自动从其父元素继承方法和属性。

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)
x = Cat("cat", 12)
x.printinfo()

执行结果：

name is cat , age is 12

添加属性

比如把属性color添加到 Cat 类中：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)
        self.color = "block"
x = Cat("cat", 12)
print("name is %s , age is %d , color is %s" %(x.name,x.age,x.color))

执行结果：

name is cat , age is 12 , color is block

在这例子中，block 年应该是一个变量，并在创建 Cat 对象时传递到 Cat 类。为此，请在 __init__() 函数中添加另一个参数：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    def __init__(self, name, age,color):
        super().__init__(name, age)
        self.color = color
x = Cat("cat", 12,"block")
print("name is %s , age is %d , color is %s" %(x.name,x.age,x.color))

执行结果：

name is cat , age is 12 , color is block

添加方法

把名为 say 的方法添加到 Cat 类：

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def printinfo(self):
        print("name is %s , age is %d " %(self.name,self.age))

class Cat(Animal):
    def __init__(self, name, age,color):
        super().__init__(name, age)
        self.color = "block"
    def say(self):
        print("name is %s , age is %d , color is %s" %(self.name,self.age,self.color))
x = Cat("cat", 12,"block")
x.say()

执行结果：

name is cat , age is 12 , color is block

Python 多态

Python中多态是指对象有多种形态。比如动物有多种形态，狗，猫，牛，马等等。

什么是多态性？

多态性是指在不考虑实例类型的情况下使用实例，多态性分为静态多态性和动态多态性

静态多态性：如任何类型都可以用运算符+进行运算

动态多态性：如下

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def color(self):
        pass

class Dog(Animal):
    def color(self):
        print("Dog is black")

class Cat(Animal):
    def color(self):
        print("Cat is blue")

dog = Dog()
cat = Cat()
dog.color()
cat.color()

# 定义一个统一的接口来访问
def func(object):
    object.color()

func(dog)

执行结果：

Dog is black
Cat is blue
Dog is black

为什么要用多态性？

增加了程序的灵活性：以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)增加了程序额可扩展性：通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def color(self):
        pass

class Dog(Animal):
    def color(self):
        print("Dog is black")

class Cat(Animal):
    def color(self):
        print("Cat is blue")

class Pig(Animal): # 属于动物的另外一种形态：猪
    def color(self):
        print("Pig is white")

dog = Dog()
cat = Cat()
pig = Pig()

# 统一接口，对于使用者来说，自己的代码根本无需改动
def func(object):
    object.color()

# 甚至连调用方式都无需改变，就能调用出pig的talk功能
func(pig)

执行结果：

Pig is white

鸭子类型

在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。

例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为"鸭子"的对象，并调用它的"走"和"叫"方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的"走"和"叫"方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的"走"和"叫"方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

鸭子类型通常得益于不测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。

class Duck():
    def speak(self):
        print("Duck speaking like a duck")

    def swim(self):
        print("Duck swim like a duck")

class Person():
    def speak(self):
        print("this people speaking like a duck")

    def swim(self):
        print("this people swim like a duck")

可以很明显的看出，Person类拥有跟Duck类一样的方法，当有一个函数调用Duck类，并利用到了两个方法speak()和swim()。我们传入Person类也一样可以运行，函数并不会检查对象的类型是不是Duck，只要他拥有speak()和swim()方法，就可以正确的被调用。

和其它面向对象语言相比，Python不支持方法重载，主要原因是函数功能相同，但是参数类型不同，Python不需要处理，因为 python可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在 python中很可能是相同的代码，没有必要做成两个不同函数。而函数功能相同，但参数个数不同，python就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。

运算符重载

运算符重载是让自定义的类生成的对象(实例)能够使用运算符进行操作

1、算术运算符的重载:                                                                

方法名	运算符和表达式	说明
__add__(self,rhs)	self + rhs	加法
__sub__(self,rhs)	self - rhs	减法
__mul__(self,rhs)	self * rhs	乘法
__truediv__(self,rhs)	self / rhs	除法
__floordiv__(self,rhs)	self //rhs	地板除
__mod__(self,rhs)	self % rhs	取模(求余)
__pow__(self,rhs)	self **rhs	幂运算

具体事例如下：

class Number():
    def __init__(self,v):
        self.data = v

    def __repr__(self):
        return "Number(%d)"%self.data

    def __add__(self,other):
        v = self.data + other.data
        return Number(v)

    def __sub__(self,other):
        v = self.data - other.data
        return Number(v)

n1 = Number(100)
n2 = Number(200)
n3 = n1 + n2
print(n3)
n4 = n2 - n1
print(n4)
print(n1.__add__(n2))
print(n2.__sub__(n1))

执行结果：

Number(300)
Number(100)
Number(300)
Number(100)

2、反向算术运算符的重载                                                    

方法名	运算符和表达式	说明
__radd__(self,lhs)	lhs + self	加法
__rsub__(self,lhs)	lhs - self	减法
__rmul__(self,lhs)	lhs * self	乘法
__rtruediv__(self,lhs)	lhs / self	法
__rfloordiv__(self,lhs)	lhs // self	地板除
__rmod__(self,lhs)	lhs % self	取模(求余)
__rpow__(self,lhs)	lhs ** self	幂运算

3、复合赋值算术运算符的重载                   

方法名	运算符和表达式	说明
__iadd__(self,rhs)	self += rhs	加法
__isub__(self,rhs)	self -= rhs	减法
__imul__(self,rhs)	self *= rhs	乘法
__itruediv__(self,rhs)	self /= rhs	除法
__ifloordiv__(self,rhs)	self //=rhs	地板除
__imod__(self,rhs)	self %= rhs	取模(求余)
__ipow__(self,rhs)	self **=rhs	幂运算

4、比较算术运算符的重载                                       

方法名	运算符和表达式	说明
__lt__(self,rhs)	self < rhs	小于
__le__(self,rhs)	self <= rhs	小于等于
__gt__(self,rhs)	self > rhs	大于
__ge__(self,rhs)	self >= rhs	大于等于
__eq__(self,rhs)	self == rhs	等于
__ne__(self,rhs)	self != rhs	不等于

5、位运算符重载       

方法名	运算符和表达式	说明
__and__(self,rhs)	self & rhs	位与
__or__(self,rhs)	self | rhs	位或
__xor__(self,rhs)	self ^ rhs	位异或
__lshift__(self,rhs)	self <	左移
__rshift__(self,rhs)	self >>rhs	右移

6、反向位运算符重载                

方法名	运算符和表达式	说明
__and__(self,lhs)	lhs & rhs	位与
__or__(self,lhs)	lhs | rhs	位或
__xor__(self,lhs)	lhs ^ rhs	位异或
__lshift__(self,lhs)	lhs <	左移
__rshift__(self,lhs)	lhs >>rhs

7、复合赋值位相关运算符重载                                    

方法名	运算符和表达式	说明
__iand__(self,rhs)	self & rhs	位与
__ior__(self,rhs)	self | rhs	位或
__ixor__(self,rhs)	self ^ rhs	位异或
__ilshift__(self,rhs)	self <	左移
__irshift__(self,rhs)	self >>rhs

8、一元运算符的重载

方法名	运算符和表达式	说明
__neg__(self)	- self	负号
__pos__(self)	+ self	正号
__invert__(self)	~ self	取反

9、索引和切片运算符重载方法

方法名	运算符和表达式	说明
__getitem__(self,i)	x = self(i)	索引/切片取值
__setitem__(self,i,v)	self[i] = v	索引/切片赋值
__delitem__(self,i)	del self[i]	del语句删除索引/切片

Python 内置函数

Python 有一组内建函数，具体如下：

函数	描述
abs()	返回数的绝对值
acos(x)	返回x的反余弦弧度值。
all()	如果可迭代对象中的所有项均为 true，则返回 True。
any()	如果可迭代对象中的任何项为 true，则返回 True。
ascii()	返回对象的可读版本。用转义字符替换 none-ascii 字符。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
bin()	返回数的二进制版本。
bool()	返回指定对象的布尔值。
bytearray()	返回字节数组。
bytes()	返回字节对象。
callable()	如果指定的对象是可调用的，则返回 True，否则返回 False。
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cos(x)	返回x的弧度的余弦值。
chr()	返回指定 Unicode 代码中的字符。
choice(seq)	从序列的元素中随机挑选一个元素。
classmethod()	把方法转换为类方法。
compile()	把指定的源作为对象返回，准备执行。
complex()	返回复数。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
delattr()	从指定的对象中删除指定的属性（属性或方法）。
dict()	返回字典（数组）。
dir()	返回指定对象的属性和方法的列表。
divmod()	当参数1除以参数2时，返回商和余数。
enumerate()	获取集合（例如元组）并将其作为枚举对象返回。
eval()	评估并执行表达式。
exec()	执行指定的代码（或对象）。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
filter()	使用过滤器函数排除可迭代对象中的项目。
float()	返回浮点数。
format()	格式化指定值。
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
frozenset()	返回 frozenset 对象。
getattr()	返回指定属性的值（属性或方法）。
globals()	以字典返回当前全局符号表。
hasattr()	如果指定的对象拥有指定的属性（属性/方法），则返回 True。
hash()	返回指定对象的哈希值。
help()	执行内建的帮助系统。
hex()	把数字转换为十六进制值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
id()	返回对象的 id。
input()	允许用户输入。
int()	返回整数。
isinstance()	如果指定的对象是指定对象的实例，则返回 True。
issubclass()	如果指定的类是指定对象的子类，则返回 True。
iter()	返回迭代器对象。
len()	返回对象的长度。
list()	返回列表。
locals()	返回当前本地符号表的更新字典。
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
map()	返回指定的迭代器，其中指定的函数应用于每个项目。
max()	返回可迭代对象中的最大项目。
memoryview()	返回内存视图（memory view）对象。
min()	返回可迭代对象中的最小项目。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
next()	返回可迭代对象中的下一项。
object()	返回新对象。
oct()	把数转换为八进制。
open()	打开文件并返回文件对象。
ord()	转换表示指定字符的 Unicode 的整数。
pow()	返回 x 的 y 次幂的值。
print()	打印标准输出设备。
property()	获取、设置、删除属性。
range()	返回数字序列，从 0 开始且以 1 为增量（默认地）。
radians(x)	将角度转换为弧度
repr()	返回对象的可读版本。
reversed()	返回反转的迭代器。
round()	对数进行舍入。
randrange([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
set()	返回新的集合对象。
sin(x)	返回的x弧度的正弦值。
setattr()	设置对象的属性（属性/方法）。
slice()	返回 slice 对象。
sorted()	返回排序列表。
@staticmethod()	把方法转换为静态方法。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
str()	返回字符串对象。
sum()	对迭代器的项目进行求和。
super()	返回表示父类的对象。
sqrt(x)	返回数字x的平方根。
tan(x)	返回x弧度的正切值。
tuple()	返回元组。
type()	返回对象的类型。
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。
vars()	返回对象的 __dict__ 属性。
zip()	从两个或多个迭代器返回一个迭代器。
__import__()	用于动态加载类和函数。

Python JSON

若有 Python 对象，则可以使用 json.dumps() 方法将其转换为 JSON 字符串。

实例：把 Python 转换为 JSON：

# 导入 json 模块
import json
x = { "name":"Jack", "age":26, "sex":"woman"}

# 转换为 JSON：
y = json.dumps(x)

# 结果是 JSON 字符串：
print(y)

执行结果：

{"name": "Jack", "age": 26, "sex": "woman"}

还可以把以下类型的 Python 对象转换为 JSON 字符串：

dictlisttuplestringintfloatTrueFalseNone

实例：将 Python 对象转换为 JSON 字符串，并打印值：

# 导入 json 模块

import json
print(json.dumps({"name": "Jack", "age": 18}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))

执行结果：

{"age": 18, "name": "Jack"}
["apple", "bananas"]
["apple", "bananas"]
"hello"
42
31.76
true
false
null

格式化结果

上面的实例打印一个 JSON 字符串，但它不是很容易阅读，没有缩进和换行。

json.dumps() 方法提供了令结果更易读的参数：

实例:使用 indent 参数定义缩进数：

# 导入 json 模块
import json
x = { "name":"Jack", "age":26, "sex":"woman"}

# 格式化JSON字符串
print(json.dumps(x, indent=4))

执行结果：

{
    "age": 26,
    "name": "Jack",
    "sex": "woman"
}

Python File

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

方法	描述
file.close()	关闭文件。关闭后文件不能再进行读写操作。
file.flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()	返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()	如果文件连接到一个终端设备返回 True，否则返回 False。
file.next()	Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])	读取整行，包括 "\n" 字符。
file.readlines([sizeint])	读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.seek(offset[, whence])	移动文件读取指针到指定位置。
file.tell()	返回文件当前位置。
file.truncate([size])	从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
file.write(str)	将字符串写入文件，返回的是写入的字符长度。
file.writelines(sequence)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

Python 实例

Python 各种例子，在Python 3.8版本测试通过，具体例子如下：

函数	描述
Python Hello World 实例	学习Python的第一个实例，即如何输出"Hello World!"
Python 数字求和	过用户输入两个数字，并计算两个数字之和
Python 平方根	通过用户输入一个数字，并计算这个数字的平方根
Python 二次方程	通过用户输入数字，并计算二次方程
Python 计算三角形的面积	通过用户输入三角形三边长度，并计算三角形的面积
Python 计算圆的面积	通过公式求圆的面积
Python 随机数生成	演示如何生成一个随机数
Python 摄氏温度转华氏温度	演示了如何将摄氏温度转华氏温度
Python 交换变量	通过用户输入两个变量，并相互交换
Python if 语句	通过使用 if...elif...else 语句判断数字是正数、负数或零
Python 判断字符串是否为数字	通过创建自定义函数 is_number() 方法来判断字符串是否为数字
Python 判断奇数偶数	判断一个数字是否为奇数或偶数
Python 判断闰年	判断用户输入的年份是否为闰年
Python 获取最大值函数	使用max()方法求最大值
Python 质数判断	质数判断
Python 输出指定范围内的素数	输出指定范围内的素数
Python 阶乘实例	整数的阶乘是所有小于及等于该数的正整数的积，0的阶乘为1。
Python 九九乘法表	实例演示了如何实现九九乘法表
Python 斐波那契数列	斐波那契数列
Python 阿姆斯特朗数	检测用户输入的数字是否为阿姆斯特朗数
Python 进制转换	实现十进制转二进制、八进制、十六进制
Python ASCII码与字符相互转换	实现ASCII码与字符相互转换
Python 最大公约数算法	实现最大公约数算法
Python 最小公倍数算法	实现最小公倍数算法
Python 简单计算器实现	实现简单计算器，包括两个数基本的加减乘除运算
Python 生成日历	用于生成指定日期的日历
Python 使用递归斐波那契数列	使用递归的方式来生成斐波那契数列
Python 返回对象的内存地址	门牌号-返回对象的内存地址
Python 计算字符串型表达式的值	计算字符串型表达式的值
Python 真假判断	Python True和False的真假判断
Python 返回对象哈希值	返回对象哈希值
Python 字符串格式化	格式化字符串常见用法
Python 两种创建属性方法	返回 property 属性和使用@property装饰器
Python 一键查看对象所有方法	不带参数和带参数时返回不同的内容。
Python 绘制柱状图和折线图	用 4 种常见的绘图库绘制柱状图和折线图，快速入门这些库
Python 文件 IO	Python基本的文件操作，包括 open，read，write
Python 字符串判断	演示Python字符串的判断
Python 字符串大小写转换	演示如何将字符串转换为大写字母，或者将字符串转为小写字母等
Python 计算每个月天数	通过导入 calendar 模块来计算每个月的天数
Python 获取昨天日期	通过导入 datetime 模块来获取昨天的日期
Python list 常用操作	list 常用操作
Python 约瑟夫生者死者小游戏	约瑟夫生者死者小游戏代码实现
Python 五人分鱼	五人分鱼代码实现
Python 实现秒表功能	使用 time 模块来实现秒表功能
Python 计算 n 个自然数的立方和	计算 n 个自然数的立方和
Python 计算数组元素之和	定义一个整型数组，并计算元素之和
Python 数组翻转指定个数的元素	定义一个整型数组，并将指定个数的元素翻转到数组的尾部
Python 将列表中的头尾两个元素对调	定义一个列表，并将列表中的头尾两个元素对调
Python 将列表中指定的两个元素对调	定义一个列表，并将列表中的指定位置的两个元素对调
Python 翻转列表	定义一个列表，并将它翻转
Python 判断元素是否在列表中存在	定义一个列表，并判断元素是否在列表中
Python 清空列表	定义一个列表，并清空列表，可以使用 clear() 方法实现
Python 复制列表	定义一个列表，并将该列表元素复制到另外一个列表上。
Python 计算元素在列表中出现的次数	定义一个列表，并计算某个元素在列表中出现的次数。
Python 计算列表元素之和	定义一个数字列表，并计算列表元素之和。
Python 计算列表元素之积	定义一个数字列表，并计算列表元素之积。
Python 查找列表中最小元素	定义一个数字列表，并查找列表中的最小元素。
Python 查找列表中最大元素	定义一个数字列表，并查找列表中的最大元素。
Python 移除字符串中的指定位置字符	给定一个字符串，然后移除制定位置的字符：
Python 判断字符串是否存在子字符串	给定一个字符串，然后判断指定的子字符串是否存在于改字符串中。
Python 判断字符串长度	给定一个字符串，然后判断改字符串的长度。
Python 使用正则表达式提取字符串中的 URL	给定一个字符串，里面包含 URL 地址，需要我们使用正则表达式来获取字符串的 URL。
Python 将字符串作为代码执行	给定一个字符串代码，然后使用 exec() 来执行字符串代码。
Python 字符串翻转	给定一个字符串，然后将其翻转，逆序输出。
Python 对字符串切片及翻转	给定一个字符串，从头部或尾部截取指定数量的字符串，然后将其翻转拼接。
Python 按键或值对字典进行排序	给定一个字典，然后按键(key)或值(value)对字典进行排序
Python 计算字典值之和	给定一个字典，然后计算它们所有数字值的和
Python 移除字典点键值(key/value)对	给定一个字典，然后计算它们所有数字值的和
Python 合并字典	给定一个字典，然后计算它们所有数字值的和
Python 将字符串的时间转换为时间戳	给定一个字符串的时间，将其转换为时间戳
Python 获取几天前的时间	计算几天前并转换为指定格式
Python 将时间戳转换为指定格式日期	将时间戳转换为指定格式日期
Python 打印自己设计的字体	通过对 26 个字母的设定，设置自己要输出的字体。
Python 二分查找	二分搜索是一种在有序数组中查找某一特定元素的搜索算法
Python 线性查找	线性查找指按一定的顺序检查数组中每一个元素，直到找到所要寻找的特定值为止
Python 插入排序	插入排序（英语：Insertion Sort）是一种简单直观的排序算法。
Python 快速排序	快速排序使用分治法策略来把一个序列分为子序列，然后递归地排序
Python 选择排序	选择排序（Selection sort）是一种简单直观的排序算法
Python 冒泡排序	冒泡排序（Bubble Sort）也是一种简单直观的排序算法
Python 归并排序	归并排序，是创建在归并操作上的一种有效的排序算法
Python 堆排序	堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法
Python 计数排序	计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中
Python 希尔排序	希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本
Python 拓扑排序	对一个有向无环图G进行拓扑排序

MySQL 日期/时间函数

MySQL日期/时间函数用于处理时间值。下表简要说明了每个功能:

功能	说明
date()	date()函数用于从给定的日期/日期时间获取日期。
adddata()	adddata()函数用于获取添加一些时间/日期间隔的日期。
curdate()	curdate()函数用于获取当前日期。
current_date()	current_date()函数用于获取当前日期。
date_add()	date_add()函数用于获取添加某些日期/日期时间间隔的日期。
date_format()	date_format()函数用于获取指定格式的日期。
datediff()	datediff()函数用于获取两个指定日期值之间的差。
day()	day()函数用于从给定日期获取日期。
dayname()	dayname()函数用于从给定日期获取日期名称。
dayofmonth()	dayofmonth()函数用于获取指定日期的日期。
dayofweek()	dayofweek()函数用于获取数字中的星期几。
dayofyear()	dayofyear()函数用于获取一年中的天数。
from_days()	from_days()函数用于获取给定天数的日期。
hour()	hour()函数用于从给定的日期时间获取小时。
addtime()	addtime()函数用于获取添加了一些时间间隔的时间/日期时间值。
current_time()	current_time()函数用于获取当前时间。
current_timestamp()	current_timestamp()函数用于获取当前日期和时间。
curtime()	curtime()函数用于获取当前时间。
last_day()	last_day()函数用于获取日期中给定月份的最后日期。
localtime()	localtime()函数用于获取当前日期和时间。
localtimestamp()	localtimestamp()函数用于获取当前日期和时间。
makedate()	makedate()函数用于根据给定的年份和天数来确定日期。
maketime()	maketime()函数用于从给定的小时，分​​钟和秒开始计时。
microsecond()	microsecond()函数用于从给定的日期时间或时间获取微秒的值。
minute()	minute()函数用于获取指定日期时间或时间的月份值。
month()	month()函数用于从给定的日期时间或时间获取month的值。
monthname()	monthname()函数用于获取完整的月份名称。
now()	函数用于获取当前日期和时间。
period_add()	period_add()函数以YYMM或YYYYMM格式添加给定时间段内给定的月数。
period_diff()	period_diff()函数用于获取给定两个周期之间的差。
quater()	quarter()函数用于获取指定日期/日期时间的四分之一部分。
sec_to_time()	sec_to_time()函数用于将指定的秒转换为时间。
second()	second()函数用于从指定的日期/日期时间获取第二部分。
str_to_date()	str_to_date()函数用于将字符串转换为给定的format_mask。
subdate()	subdate()函数用于获取减去给定间隔的日期。
subtime()	subtime()函数用于获取被某些时间间隔减去的时间/日期时间。
sysdate()	sysdate()函数用于获取系统日期。
time()	time()函数用于获取给定时间/日期时间的时间。
time_format()	time_format()函数用于以指定的format_mask格式化时间。
time_to_sec()	time_to_sec()函数用于将时间转换为秒。
timediff()	timediff()函数用于获取给定的两个时间/日期时间之间的时差。
timestamp()	timestamp()函数用于将表达式转换为日期时间。
to_day()	to_day()函数用于将日期转换为数字天数。
weekday()	weekday()函数用于获取日期的索引
week()	week()函数用于获取指定日期的星期部分。
weekofyear()	weekofyear()函数用于获取给定日期的星期。