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
  1. 进入安装包所在目录，我的放在/opt/​目录下了。
cd /opt/
  1. 解压安装包，解压后会多一个Python-3.8.6文件夹。
tar -xvf Python-3.8.6.tgz
  1. 进入Python-3.8.6文件夹。
cd Python-3.8.6
  1. 配置及编译安装。
# prefix参数用于指定安装路径，默认路径是/usr/local/
# enable-optimizations参数用于启用Profile引导优化(PGO)和链路时间优化(LTO)，以减缓构建过程为代价，提升10%左右性能
./configure --prefix=/usr/local/python38 --enable-optimizations
# 编译及安装
make && make install
  1. 配置环境变量
# 编辑文件
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
  1. 环境测试
# 查看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源有：

永久换源后，就可以直接安装依赖，不需要使用-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))
  1. ​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)
  1. ​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)
  1. 追加内容
counter.update(['c', 'b', 'c', 'd'])
print(counter)
  1. 返回最高频率前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)
  1. 继承类型方法
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))