Python 基础

介绍 ¶

Python 是一门解释型、面向对象的高级编程语言。编程语言按程序执行方式大致分为以下两种：

• 解释型：使用特定的解释器对源码逐行解释成特定平台的机器码，然后机器会立即对机器码进行执行 (解释一行，执行一行，无中间文件产生，运行速度较慢)。
• 编译型：使用特定的编译器对源码一次性编译成特定平台的机器码文件，然后由机器统一对机器码文件进行解释执行 (编译一次，可多次执行，有中间文件产生，运行速度较快)。

编程语言按软件开发思想大致分为以下两种：

• 面向过程：将解决问题的步骤分析出来，用函数把步骤一步一步实现，然后再依次调用 (注重功能的实现流程)。
• 面向对象：将解决的问题分解为若干对象，建立对象的行为属性，通过对象在问题中的行为描述来分别处理问题 (注重描述行为的对象)。

发展史 ¶

Python 于 1989 年圣诞节晚上，由 “龟叔” Guido van Rossum 在荷兰的数学和计算机科学研究所设计而来。

• 1991 年 2 月第一个 Python 编译器诞生，由 C 语言实现。
• 1994 年 1 月发布 Python1.0 版本。
• 2000 年 10 月发布 Python2.0 版本。
• 2008 年 12 月发布 Python3.0 版本。
• 2020 年 1 月发布停止 Python2.x 版本的更新。

目前最新稳定版本是 Python3.11.0，但是我们并不推荐直接使用最新版本，因为可能会存在兼容性和一些小问题。这里推荐小伙伴们使用 Python3.8 版本。

优缺点 ¶

每门语言都会有优点和缺点，Python 也不例外。

优点 ¶

1. 易入门：较大多数高级语言，Python 简洁的语法和结构，可以让初学者快速入门并掌握，同时也是许多高校作为入门编程语言的首选。
2. 免费开源：免费开源意味着所有人都可以学习和使用，这使得 Python 拥有一个强大的社区来维护，标准库和第三方库十分丰富。
3. 移植性好：Python 基于开源的特性，已被众多平台收录，使用对应平台的解释器就可以在不同平台进行移植。
4. 扩展性好：Python 也被称为 “胶水语言”，原因之一是它有许多第三方库，可以让 Python 与许多其他编程语言的程序混合使用。

缺点 ¶

1. 运行速度慢：解释型语言的通病。
2. 源码不能加密：发布的 Python 程序，实则也是发布源码，不同于编译型语言，只需要发布编译好的机器码文件即可，别人是很难反编译为源码的，但是现在也是有相关对策的，有兴趣的小伙伴可以自行了解。
3. 国内门槛高：随着近几年的发展，Python 在越来越多的领域中被使用，这使得 Python 在国内编程语言热度排行榜已经多年位居第一，但在大多数领域对学历和能力要求高，大部分公司只招收研究生 Python 工程师，只有小部分公司招收后端 Python 工程师。
4. 多并发限制：Python 存在一个 GIL (Global Interpreter Lock) 全局解解释器锁，当解释器执行字节码时，需要申请 GIL，这将导致只能有一个被线程执行，因此，Python 的多线程并不是真正意义上的多线程，而是一个单线程。

使用领域 ¶

Python 的使用领域很广，主要包含但不限于以下领域：

1. 云计算。
2. Web 开发。
3. 人工智能和深度学习。
4. 系统运维。
5. 数据分析。
6. 网络爬虫。
7. 游戏图形 GUI。

解释器 ¶

Python 解释器作用：运行文件

Python 解释器种类 ：

• CPython，C 语言开发的解释器 [官方]，应用广泛的解释器。
• IPython，基于 CPython 的⼀种交互式解释器。
• PyPy，基于 Python 语言开发的解释器。
• Jython，运行在 Java 平台的解释器，直接把 Python 代码编译成 Java 字节码执行。
• IronPython，运行在微软.Net 平台上的 Python 解释器，可以直接把 Python 代码编译成.Net 的字节码。

Windows 平台 ¶

Python 官网 Windows 安装包下载地址。

下载 ¶

说明：左侧 Stable Releases 一列为稳定版本，右侧 Pre-releases 一列为尝鲜版本。

在浏览器中按下 [Ctrl] + [F] 搜索 Python3.8.6 (注意区分版本后是否带有 rcl​，我们选择不带 rcl​的版本)。

找到对应的版本后，会看到有 7 条下载地址 (后续的版本中仅有 5 条) 供我们选择。

• ​help file​：该版本的帮助文档，一般安装程序中会自带帮助文档，无需我们下载。
• ​x86-64 XXX​和 x86 XXX​：64 位和 32 位的安装程序，根据个人电脑操作系统的配置信息进行对应选择即可 (查看方法：左下角 Win 标 -> 设置 -> 系统 -> 关于 -> 系统类型)
• ​embeddable zip file​：绿色便携版 zip 压缩包，解压即安装，包含 Python 解释器，但不包含 pip (包管理工具)，后续的版本中统一命名为 embeddable package (xx-bit)​，不推荐。
• ​executable installer​：离线安装包可执行文件，包含了帮助文档和 pip，一键式操作，适合所有人群安装，后续的版本中统一命名为 installer (xx-bit)​。
• ​web-based installer​：在线安装程序可执行文件，运行程序后自动开始下载安装文件，需要两次下载，后续的版本中已经不再使用该方法安装，不推荐。

对于 ARM 架构的操作系统，请选择支持 ARM 的版本。

这里我们选择 Windows x86-64 executable installer 进行下载。

安装 ¶

1. 双击可执行文件，运行安装包。
2. 勾选环境变量，我们推荐选择默认安装。
3. 等待安装。
4. 安装完成，关闭程序。
5. 环境测试。

快捷键 [Win] + [R] 打开运行，输入 cmd​回车，在命令提示符窗口输入 python --version​，出现安装版本即安装成功。

问题 ¶

1. 环境测试时，没有出现版本号或者提示不是命令、程序、文件。

原因：在安装时没有勾选 Add Python 3.8 to PATH​，添加到环境变量。

关于：环境变量类似于一个软连接、快捷方式，可以在其他路径下使用。有用户变量和系统变量两类，用户变量只能在该用户下才能使用，系统变量可以在所有用户下使用。

解决：Win 开始 -> 设置 -> 系统 -> 关于 -> 高级系统设置 -> 环境变量 -> 用户变量里找到 Path​双击 -> 新建以下两个路径 -> 添加好后将这两个路径通过上移置顶 -> 最后一路点击确定

C:\Users\xxx\AppData\Local\Programs\Python\Python38\Scripts\

C:\Users\xxx\AppData\Local\Programs\Python\Python38\

卸载 ¶

Win 开始 -> Windows 系统 -> 控制面板 -> 程序 -> 程序和功能 -> 找到 Python -> 双击卸载 / 右键卸载

MacOS 平台 ¶

Python 官网 MacOS 安装包下载地址。

下载 ¶

说明：左侧 Stable Releases 一列为稳定版本，右侧 Pre-releases 一列为尝鲜版本。

在浏览器中按下 [Command] + [F] 搜索 Python3.8.6 (注意区分版本后是否带有 rcl​，我们选择不带 rcl​的版本)。

这里我们选择 macOS 64-bit installer 进行下载。

另外，安装了 Homebrew 的小伙伴可以直接通过终端命令进行下载安装。

# 查询python版本
brew search python
# 安装需要的python版本
brew install python3.8.6

安装 ¶

根据提示一直点击继续即可。

卸载 ¶

# 卸载Python
brew uninstall --ignore-dependencies python
# 查看pip框架目录
pip3 -V
# 删除pip框架
sudo rm -rf /Library/Frameworks/Python.framework

Linux 平台 ¶

Python 官网 Linux 安装包下载地址。

下载 ¶

说明：左侧 Stable Releases 一列为稳定版本，右侧 Pre-releases 一列为尝鲜版本。

在浏览器中按下 [Ctrl] + [F] 搜索 Python3.8.6 (注意区分版本后是否带有 rcl​，我们选择不带 rcl​的版本)。

• ​Gzipped source tarball​：tgz 压缩包程序。
• ​XZ compressed source tarball​：tar.xz 压缩包程序。

任选择一种下载即可，这里我们选择 Gzipped source tarball 进行下载。

也可以使用 wget​工具进行下载，可自行更改版本号

wget https://www.python.org/ftp/python/3.8.6/Python-3.8.6.tgz

安装 ¶

1. 安装相关依赖

yum -y install wget gcc zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel libffi-devel

2. 进入安装包所在目录，我的放在 /opt/​目录下了。

cd /opt/

3. 解压安装包，解压后会多一个 Python-3.8.6 文件夹。

tar -xvf Python-3.8.6.tgz

4. 进入 Python-3.8.6 文件夹。

cd Python-3.8.6

5. 配置及编译安装。

# prefix参数用于指定安装路径，默认路径是/usr/local/
# enable-optimizations参数用于启用Profile引导优化(PGO)和链路时间优化(LTO)，以减缓构建过程为代价，提升10%左右性能
./configure --prefix=/usr/local/python38 --enable-optimizations
# 编译及安装
make && make install

6. 配置环境变量

# 编辑文件
vim ~/.bash_profile
# 设置环境变量
export PATH=$PATH:/usr/local/python38/bin
# 更新环境变量
source ~/.bash_profile

如果嫌以上方式麻烦，可以直接使用以下命令一键安装

# Ubuntu
sudo apt-get install python3
sudo apt-get install python3-pip

# CentOS
yum -y install python3
yum -y install python3-pip

7. 环境测试

# 查看Python版本
python3 -V

问题 ¶

1. 编译安装过程中，报错 can't decompress data; zlib not available​。

原因：缺少 zlib​依赖包。

关于：zlib​是一类解压缩库。

解决：通过软件包工具进行下载安装，再次编译安装即可。

Ubuntu 安装如下：

sudo apt install zlib*

CentOS 安装如下：

yum -y install zlib*

卸载 ¶

该方法会将 Python 环境彻底移除，可能会导致其他功能无法使用，请谨慎使用。

# Ubuntu
sudo apt-get remove python3.6/3.8
sudo apt-get remove --auto-remove python3.6/3.8
sudo apt-get purge python3.6/3.8

# CentOS
rpm -qa |grep python3|xargs rpm -ev --allmatches --nodeps
whereis python3 |xargs rm -frv
whereis python

pip 换源 ¶

pip 是 Python 的包管理工具，用于安装和管理 Python 包。

临时换源 ¶

pip3 install 安装包==版本 -i 换源地址

永久换源 ¶

# 升级到最新pip
python -m pip install -U pip

# 查看配置
pip3 config list

# 全局换源
pip3 config set global.index-url 换源地址

常用的国内 PyPi 源有：

• 清华大学：https://pypi.tuna.tsinghua.edu.cn/simple
• 阿里云：https://mirrors.aliyun.com/pypi/simple
• 豆瓣：https://pypi.douban.com/simple
• 中国科大 https://pypi.mirrors.ustc.edu.cn/simple/

永久换源后，就可以直接安装依赖，不需要使用 -i​参数指定安装源啦。

创建虚拟环境 ¶

通过 pycharm 创建需要注意的是，可能会因为依赖源下载慢导致报错，提前换源即可。

• 创建并激活虚拟环境

python3 -m venv ./venv && source ./venv/bin/activate

• 退出虚拟环境

deactivate

或使用 mkvirtualenv​创建

# 安装virtualenv
sudo apt install virtualenv

# 安装virtualenvwrapper，安装完后重启终端
sudo apt install virtualenvwrapper

# 创建并激活虚拟环境
mkvirtualenv -p /usr/bin/python3 envName

# 切换虚拟环境
workon envName

# 删除虚拟环境
rmvirtualenv envName

成功激活虚拟环境后，会在终端行首展示 (venv)​。后续操作将在虚拟环境中进行。

依赖管理 ¶

requirements.txt 可以帮助我们将项目的所有依赖进行导出，在移植到其他环境时可以快速安装依赖。

导出依赖 ¶

会将当前环境的所有依赖打包到 requirements.txt 文件。

pip3 freeze > requirements.txt

安装依赖 ¶

会将 requirements.txt 文件的所有依赖都安装到此工作环境。

pip3 install -r requirements.txt

基础语法 ¶

注释 ¶

作用：对所写的代码进行标注说明（解释代码），提高代码的可读性。

• 编码及解释器

# -*- coding: utf-8 -*-
#!/usr/bin/python3

• 单行注释

# 注释内容

• 多行注释

"""
多行注释第一种写法
第二行注释
"""

'''
多行注释第二种写法
第二行注释
'''

标识符 ¶

标识符是编程中用于标识变量、函数、类、模块或其他实体的名称。Python 中自定义的名字都需要满足标识符命名规则。

标识符命名规则：

• 由数字、字母、下划线组成。
• 不能由数字开头。
• 不能使用内置关键字。
• 区分大小写。

命名习惯：

• 见名知义。
• 大驼峰：每个单词首字母都大写。
• 小驼峰：除第一个单词，后面的单词首字母都大写。
• 下划线：使用下划线连接单词。

关键字 ¶

Python 中已经使用的单词，具备自己的作用。

import keyword

print(keyword.kwlist)

['False', 'None', 'True', '__peg_parser__', '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']

进制 ¶

• 二进制：由 0 和 1 组成，代码中以 0b​开头。
• 十进制：由 0-9 组成，代码默认进制。
• 八进制：由 0-7 组成，代码中以 0o​开头。
• 十六进制：由 0-9 和 a-f 组成，代码中以 0x​开头。

代码块 ¶

Python 最具特色的就是使用 缩进 来表示代码块，不需要使用大括号 {}​ 。同一个代码块的代码，应有相同的缩进单位。缩进混乱会导致程序出错，这是小白最容易出现问题的地方。

多行语句 ¶

通常情况下一行就包含一条语句，但有的时候语句会很长，需要使用 \​来换行。

result = number1 + \
         number2 + \
         number3 + \
         number4 + \
         number5

命名空间 ¶

Python 中，变量、函数、类等实体，都存储在命名空间中。

一般有三种命名空间：

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

命名空间搜索规则：

• 局部名称 -> 全局名称 -> 内置名称

命名空间的生命周期：

• 创建：模块第一次导入时，创建全局名称；调用函数时，创建局部名称。
• 销毁：模块卸载时，销毁全局名称；函数调用结束，销毁局部名称。

作用域 ¶

作用域指的是变量生效的范围。

四种作用域：

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

全局变量和局部变量 ¶

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

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

global 和 nonlocal 关键字 ¶

global 关键字：

• 声明全局变量，让变量变成全局变量。
• 局部变量可以覆盖全局变量。

nonlocal 关键字：

• 声明嵌套作用域的变量，让变量变成嵌套作用域的变量。
• 局部变量可以覆盖嵌套作用域的变量。

作用域链 ¶

嵌套作用域中，内部作用域可以访问外部作用域，反之则不行。

Python 是一种动态类型的编程语言，支持多种内置数据类型，这些数据类型用于存储和操作不同种类的数据。

数值类型 (number)¶

Python 的数据类型根据其特性可分为序列类型和散列类型。

int、float、bool、complex 都是数值类型。

• 不可变
• 不可迭代

简单用法 ¶

# int 整型
int_example = 1
# float 浮点型
fload_example = 1.1
# bool类型，只有两种值，True和False，表示真和假，值分别为1和0。
bool_example = True
# complex类型
complex_example = 1 + 2j

print(type(int_example))
print(type(fload_example))
print(type(bool_example))
print(type(complex_example))

数学方法 ¶

​math​ 标准库：

方法	说明
ceil(x)	向上取整
floor(x)	向下取整
fabs(x)	返回绝对值
factorial(x)	返回 x 的阶乘
fmod(x, y)	返回 x % y 的浮点数
sqrt(x)	返回 x 的平方根的浮点数
pow(x, y)	返回 x 的 y 次方的浮点数
exp(x)	返回 e^x 的浮点数
log(x, base)	返回 base^x 的浮点数
log10(x)	返回 10^x 的浮点数
log2(x)	返回 2^x 的浮点数
sin(x)	返回 x 的正弦值
cos(x)	返回 x 的余弦值
tan(x)	返回 x 的正切值
asin(x)、acos(x)、atan(x)	返回反正弦、反余弦、反余切
degrees(x)	返回弧度转为角度
radians(x)	返回角度转为弧度
pi	返回圆周率 Π
e	返回自然对数

‍

字符串类型 (str)¶

• 不可变
• 可迭代

简单用法 ¶

# 字符串引号的内容可以是任意字符
str_example = "Hello everyone."

# 输出str类型
print(type(str_example))

常用方法 ¶

# 子串查找，返回索引，否则返回-1
字符串.find(子串, 起始索引, 结束索引)
# 子串查找，返回索引，否者报错
字符串.index(子串, 起始索引, 结束索引)
# 返回子串出现的次数
字符串.count(子串, 起始索引, 结束索引)

# 子串替换，产生新的字符串
字符串.replace(旧串, 新串, 次数)
# 子串切割，返回一个列表
字符串.split(分割标识, 切割次数)
# 子串拼接
字符串.join(字符串的序列)
# 字符串开头转大写
字符串.capitalize()
# 首字母转大写
字符串.title()
# 字符串转小写
字符串.lower()
# 字符串转大写
字符串.upper()
# 字符串去空白
字符串.strip()
# 字符串对齐
字符串.center(长度, 填充字符)
字符串.rjust(长度, 填充字符)
字符串.ljust(长度, 填充字符)

# 判断是否以子串开始
字符串.startswith(子串, 起始索引, 结束索引)
# 判断是否以子串结束
字符串.endswith(子串, 起始索引, 结束索引)
# 判断是否都是字母
字符串.isalpha()
# 判断是否都是数字
字符串.isdigit()
# 判断是否都是字母或数字
字符串.isalnum()
# 判断是否都是空白
字符串.isspace()

格式化 ¶

name = "Python小白"
age = 20
studend_id = 10
height = 1.70

# %s格式化字符串
print("我是%s" % name)

# %d格式化有符号整型，%04d即使用4位数，不足以0补全，超出4位则原样输出
print("今年%d岁" % age)
print("学号是%04d" % studend_id)

# %f格式化浮点型，%.2f即保留两位小数
print("身高%.2f米" % height)

# 多格式化使用，使用小括号按顺序包裹即可
print("我是%s，明年都%d岁了，身高才%.2f米" %(name, age + 1, height))

# format函数的使用，{索引值}即第几个的数据
print("我是{0}，明年都{1}岁了，身高才{2}米".format(name, age + 1, height))

# f'{表达式}'的使用
print(f"我是{name}，明年都{age + 1}岁了，身高才{height}米")

• 格式化符号

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

• 格式化操作符辅助指令

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

转义字符 ¶

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

使用案例：

# \n换行转义字符
print("I'm Python novice\n I'm 20 years old")

# \t制表符转义字符
print("I'm Python novice\t I'm 20 years old")

列表 (list)¶

• 可变
• 可迭代

简单用法 ¶

# 列表里面的每一项可以是任意的数据类型
list_example = [0, 1, 2, "零", "壹", "贰"]

# 输出list类型
print(type(list_example))

常用方法 ¶

# 获取列表长度
len(列表)
# 获取列表元素出现次数
列表.count(元素)
# 获取列表元素索引，否者报错
列表.index(元素, 起始索引, 结束索引)

# 追加元素到列表
列表.append(元素)
# 追加序列到列表
列表.extend(序列)
# 插入元素到列表
列表.insert(索引, 元素)

# 删除列表
del 列表
# 根据索引删除元素
del 列表[索引]
# 删除一个元素并返回该元素，默认最后一个
列表.pop(下标)
# 删除相同元素
列表.remove(元素)
# 清空列表
列表.clear()

# 根据索引修改
列表[索引] = 值
# 列表元素反转
列表.reverse()
# 列表元素排序
列表.sort(key=None, reverse=False)
# 列表拷贝
列表.copy()

元组 (tuple)¶

元组是不可变的列表，因此列表的一部分特性也适用。

• 不可变
• 可迭代

简单用法 ¶

tuple_example = (0, 1, 2, "零", "壹", "贰")

# 输出tuple类型
print(type(tuple_example))

常用方法 ¶

# 查找元素，返回索引，否则报错
元组.index(元素)
# 返回元素个数
元组.count(元素)
# 返回元素长度
len(元组)

由于元组的不可变，因此没有修改和删除的方法。

列表 / 元组推导式 ¶

作用：使用一句表达式，创建有规律的某种集合。

# 无条件生成，0-9
list_example = [i for i in range(10)]

# 含条件生成10以内的偶数
list_example = [i for i in range(10) if i % 2 == 0]

# 多重推导式
list_example = [(i,j) for i in range(10) for j in range(10)]

序列语法糖 ¶

序列类型具有相同的性质，如有序，有索引。其他类型统称散列类型。

索引 ¶

# 通过索引下标获取第一个字符
序列[0]
# 通过索引下标获取倒数第一个字符
序列[-1]

索引是从 0 开始，倒数使用负号获取。

切片 ¶

# 通过切片获取某部分字符，[索引起始值:索引结束值:步长]
序列[s:e:t]

拆包 ¶

# 将一个序列的元素拆分为多个数据，*代表不定长，接收剩下的所有元素
list_example = [1, 2, 3, 4]
a, b, *c = list_example
print(a, b, c)

公共方法 ¶

函数	描述
len()	计算容器中元素个数
del 或 del ()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start, end, step)	⽣成从 start 到 end 的数字，步⻓为 step，供 for 循环使用
enumerate()	函数用于将⼀个可遍历的数据对象 (如列表、元组或字符串) 组合为一个索引序列，同时列出数据和索引，⼀般用在 for 循环当中。

字典 (dict)¶

• 可变
• 可迭代

简单用法 ¶

# 与新华字典一样，具备一对关键字和值（键值对，key:value）
dict_example = {
    "name":"苦艾酒", "age":22
}

# 输出dict类型
print(type(dict_example))

常用方法 ¶

# 获取属性
字典[key]
# 获取属性值
字典.get(key, 默认值)
# 获取字典所有key的列表
字典.keys()
# 获取字典所有value的列表
字典.values()
# 获取字典所有键值对元祖的列表
字典.items()

# 新增或修改属性
字典[key] = value
字典.update(z)
# 删除字典
del 字典
# 删除字典属性
del 字典[key]
# 清空字典
字典.clear()

字典推导式 ¶

# 生成10以内的平方
dict_example = {i: i**2 for i in range(10)}

# 条件筛选到5以内的平方
dict_example = {key: value for key, value in dict_example.items() if key < 5}

集合 (set)¶

• 不可变
• 可迭代

简单用法 ¶

# 与数学中的集合一样，自带去重效果，空集合使用 set()创建
set_example = {0, 1, 2}

# 输出set类型
print(type(set_example))

常用方法 ¶

# 添加单个元素
集合.add(数据)
# 批量添加序列元素
集合.update(序列)

# 删除元素，不存在则报错
集合.remove(元素)
# 删除元素，不存在不报错
集合.discard(元素)
# 删除随机元素并返回该元素
集合.pop()

# 判断数据是否在集合内
数据 in 集合
# 判断数据是否不在集合内
数据 not in 集合

集合推导式 ¶

# 生成10以内的集合
set_example = {i for i in range(10)}

类型转换 ¶

作用：将一种数据类型转换为另外一种数据类型。

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

常用运算符 ¶

算术运算符 ¶

运算符	描述
+	加 - 两个对象相加或拼接两个序列对象
-	减 - 得到负数或是一个数减去另一个数
*	乘 - 两个数相乘或是返回一个被重复若干次的序列元素
/	除 - x 除以 y
%	取模 - 返回除法的余数
**	幂 - 返回 x 的 y 次幂
//	取整除 - 往小的方向取整数

比较运算符 ¶

运算符	描述
==	等于 - 比较对象是否相等
!=	不等于 - 比较两个对象是否不相等
>	大于 - 返回 x 是否大于 y
<	小于 - 返回 x 是否小于 y。所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意，这些变量名的大写。
>=	大于等于 - 返回 x 是否大于等于 y。
<=	小于等于 - 返回 x 是否小于等于 y。

复合运算符 ¶

运算符	描述
=	简单的赋值运算符
+=	加法赋值运算符
-=	减法赋值运算符
*=	乘法赋值运算符
/=	除法赋值运算符
%=	取模赋值运算符
**=	幂赋值运算符
//=	取整除赋值运算符
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。

位运算符 ¶

运算符	描述
&	按位与运算符：参与运算的两个值，如果两个相应位都为 1, 则该位的结果为 1, 否则为 0
|	按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为 1。
^	按位异或运算符：当两对应的二进位相异时，结果为 1
~	按位取反运算符：对数据的每个二进制位取反，即把 1 变为 0, 把 0 变为 1。~x 类似于 -x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由 "<<" 右边的数指定移动的位数，高位丢弃，低位补 0。
>>	右移动运算符：把 ">>“左边的运算数的各二进位全部右移若干位，”>>" 右边的数指定移动的位数

逻辑运算符 ¶

运算符	逻辑表达式	描述
and	x and y	布尔 "与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
or	x or y	布尔 "或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not	not x	布尔 "非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

and 运算符，只要有一个值为 0，则结果为 0，否则结果为最后⼀一个⾮非 0 数字。

or 运算符，只有所有值为 0 结果才为 0，否则结果为第⼀个⾮非 0 数字。

not 运算符，即取反运算符。

成员运算符 ¶

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

条件语句 ¶

if 语句 ¶

作用：如果 if 语句的条件成立则执行缩进内的代码。

if 条件:
  条件成立执行的代码
  注意代码的缩进

使用案例：

# 修改True => False使条件不成立
flag = True

if flag:
  print("我是缩进的代码")
  print("只有条件成立才执行")

print("我不是缩进的代码，条件是否成立与我无关。")

else 语句 ¶

作用：与 if 语句配合使用，如果条件不成立时执行缩进内的代码。

if 条件:
  条件成立所执行的代码
else:
  条件不成立所执行的代码

使用案例：

age = 20

if age >= 18:
  print("已成年")
  print("终于可以去网吧了！")
else:
  print("未成年")
  print("还不能去网吧哦！")

elif 语句 ¶

作用：用于多重条件判断，else if 的缩写，即 if 语句的条件不成立，并且本语句条件成立时执行缩进内的代码。

if 条件1:
  条件1成立执行的代码
elif 条件2:
  条件2成立执行的代码
elif 条件3:
  条件3成立执行的代码
else:
  以上条件都不成立执行的代码

else 需要在语句的最后使用。

使用案例：

level = int(input("请输入您的等级："))

if 0 < level <= 10:
    print("您是魂士")
elif 10 <= level <= 20:
    print("您是魂师")
elif 20 <= level <= 30:
    print("您是大魂师")
elif 30 <= level <= 40:
    print("您是魂尊")
elif 40 <= level <= 50:
    print("您是魂宗")
elif 50 <= level <= 60:
    print("您是魂王")
elif 60 <= level <= 70:
    print("您是魂帝")
elif 70 <= level <= 80:
    print("您是魂圣")
elif 80 <= level <= 90:
    print("您是魂斗罗")
elif 90 <= level < 100:
    print("您是封号斗罗")
elif level == 100:
    print("恭喜，您已成神！")
else:
    print("你是个什么玩意！")

三目运算符 ¶

作用：简化 if-else 语句。

条件成立执行的代码 if 条件 else 条件不成立执行的代码

该运算结果可以用于赋值。

循环语句 ¶

while 循环 ¶

作用：在条件成立时，循环执行缩进内的代码。

while 条件:
  条件成立时循环执行的代码
  每次循环时都会判断条件
else:
  循环正常结束时执行的代码

使用案例：

# 输出100遍
num = 100
while num > 0:
  print("媳妇，我错了！")
  num -= 1
else:
  print("我真的知道错了")
print("原谅你了")

for 循环 ¶

作用：循环遍历序列。

for 临时变量 in 序列:
  循环执行的代码
else:
  循环正常结束执行的代码

使用案例：

# 输出10以内的奇数
for i in range(10):
  if i % 2 == 0:
    continue
  print(i)

continue：结束本次循环，开始下次循环。

break：强行跳出循环，else 语句不会执行。

函数 ¶

作用：将一段有独立功能的代码块整合到一起并命名（封装），在需要的位置进行调用这个名称即可实现该部分的功能，从而实现代码的复用。

简单使用 ¶

该区域的变量为全局变量
# 定义函数
def 函数名(形参):
  """ 函数的说明，可使用help(函数名)进行查看。 """
  代码
  该区域的变量为局部变量，使用global关键字即可声明为全局变量
  ...
  return 返回值
  
# 调用函数
函数名(实参)

形参与实参统称为参数，用于函数接收数据，在实际开发过程中根据需要给出，其中形参可以是 *args​（元组不定长）、**kwargs​（字典不定长），用于接收不确定长度的实参。

返回值用于将一个结果返回给调用者，以获取某个数据，在实际开发过程中根据需要给出。

使用案例：

# 求平方和
def my_sum(*args):
    result = 0
    for i in args:
        result += i**2
    return result


list_example = [1, 2, 3]
# * 可以直接理解为拆包
result = my_sum(*list_example)
print(result)

闭包 ¶

作用：将一个函数作为返回值的函数，可以用于创建回调函数及二次封装。

def 外层函数(形参):
    代码
    ...
    def 内层函数(形参):
        代码
        可以使用外层函数的变量，使用nonlocal关键字声明为局部变量才能修改。
        ...
    # 外函数的返回值是内函数的引用
    return 内层函数

lambda 表达式 ¶

作用：简化版函数。

lambda 参数: 表达式

lambda 表达式只能返回一个表达式的值，且参数可有可无。

使用案例

func = lambda a: a**2
print((lambda a: a**2)(5))
print(func)
print(func(5))

递归 ¶

一种函数的使用技巧，通过调用自身并在达到某一临界值后进行累积返回值。

def my_sum(num):
  if num == 1:
    return 1
  # 函数自调用
  result = num + my_sum(num-1)
  return result

内置函数 ¶

是 Python 中自带的一些函数，可以全局直接调用。

更多内置函数参考 Python3 内置函数。

map、reduce、filter 函数 ¶

1. ​map(function, iterable, ...)​：将序列的每一个元素应用一个函数，并返回一个迭代器对象。

nums = [1, 2, 3, 4]
result = map(lambda x: x**2, nums)
print(list(result))

2. ​reduce(function, iterable)​：将序列的每一个元素通过 function (x, y) 逐一操作归纳为一个值。

from functools import reduce

nums = [1, 2, 3, 4]
result = reduce(lambda x,y: x+y, nums)
print(result)

3. ​filter(function, iterable)​：将序列的每一个元素通过函数返回值的 True 和 False，过滤为一个过滤器对象。

nums = [1, 2, 3, 4]
result = filter(lambda x:x<3, nums)
print(list(result))

enumerate 函数 ¶

​enumerate(sequence, [start=0])​可以将可迭代对象组合为一个索引字典，即索引：值。

fruits = ['apple', 'banana', 'cherry']  
for index, fruit in enumerate(fruits):  
    print(index, fruit)

sorted 排序 ¶

​sorted(iterable, key=None, reverse=False)​可以将序列按照一定的规则进行排序，并返回一个新的序列。

nums = [2, 3, 5, 1, 8, 6]
# 从大到小排序
sorted(nums, lambda x: -x)

zip 打包 ¶

​zip([iterable, ...])​可以将多个可迭代对象中相同索引的元素打包为一个个的元组 / 字典，并返回一个 zip 对象，可使用 *​对 zip 对象进行解压为多个可迭代对象。

a = [1, 2, 3]
b = [4, 5, 6]

c = zip(a, b)
# [(1, 4), (2, 5), (3, 6)]
print(list(c))

c = zip(a, b)
# {1: 4, 2: 5, 3: 6}
print(dict(c))

c = zip(a, b)
d,e = zip(*c)
print(d,e)

注意：zip 对象是特殊的生成器，因此只能使用一次数据。

ord、chr 函数 ¶

​ord(char)​函数将一个字符返回其对应的 ASCII 数值，或者 Unicode 数值。

​chr(int)​函数将一个整数返回其对应的字符。

# 97
print(ord('a'))

# A
print(chr(65))

Counter 计数器 ¶

用于追踪值的出现次数，Counter 类继承 dict 类，可以使用其方法。

1. 对 iterable 进行计数

import collections

counter = collections.Counter(['a', 'b', 'c', 'a', 'b', 'a'])
print(counter)

2. 追加内容

counter.update(['c', 'b', 'c', 'd'])
print(counter)

3. 返回最高频率前 n 的数据

counter.most_common(n)

defaultdict 默认字典 ¶

Python 的字典中，访问不存在的 key 会报错，一般需要初始化。defaultdict 可以传入 value 的类型完成初始化。

1. 自动初始化

import collections

dict_int = collections.defaultdict(int)
dict_int['num'] += 10
print(dict_int)

2. 继承类型方法

dict_list = collections.defaultdict(list)
dict_list['nums'].append(10)
print(dict_list)

groupby 函数 ¶

​groupby(iterable, key=None)​可以将相邻相同元素进行聚合，配合 sorted 可以完成根据 key 的相同值进行分组。

from itertools import groupby

students = [
  {'id': 1, 'name': 't1', 'gender': 'male'},
  {'id': 2, 'name': 't2', 'gender': 'male'},
  {'id': 3, 'name': 't3', 'gender': 'female'},
  {'id': 4, 'name': 't4', 'gender': 'male'},
  {'id': 5, 'name': 't5', 'gender': 'female'},
]
students_copy = sorted(students, key=lambda x: x['gender'])
result = groupby(students, lambda x: x['gender'])
for k,v in result:
  print(k, list(v))