Python基础总结思维导图模板_ProcessOn思维导图、流程图

基础入门

计算机的组成

硬件

cpu

存储器

内存储器

内存条

外存储器

硬盘

u盘

输出设备

打印机、投影仪等

输入设备

鼠标、键盘等

软件

系统软件

windows、Linux、ios等

应用软件

qq、微信等

python简介

创始人：吉多·范罗苏姆（Guido van Rossum）

是一门高级的、动态的、强类型的、解释型的语言（面向对象）

特点：

优点

简单、免费、开源、丰富的库、扩展性强等

缺点

运行速度较慢

应用场景

web开发、运维、网络爬虫、数据分析、人工智能等

变量

数据在内存中存储后的定义的名称叫变量

变量的作用：在计算机内存中存储数据

格式

变量名 = 值

命名规则（也就是标识符的命名规则关键词名是标识符，变量名也是标识符，函数名、方法名也是标识符）

只能由字母、数字、下划线_组成

开头不能是数字

不能是关键字

严格区分字母大小写

命名习惯

大驼峰命名法（MyName）

小驼峰命名法（myName）

下划线命名法（my_name)

数据类型

整型（int）

10

浮点型（float）

10.1

字符串（str）

“abc"、"10"

布尔型（bool）

True 为真 False为假

列表（list)

[10,20]

元组（tuple）

(10,20)

集合（set）

{10,20}

字典（dict）

{"name":"python","age":18}

注释

是通过自己熟悉的语言对程序进行说明，可以大大提高代码的可读性

类型

单行注释

# 注释内容（快捷键：ctrl+/）

多行注释

''' 注释内容'''

转换数据类型

转换数据类型的函数

int(x [,base ]) 将x转换为⼀个整数

float(x ) 将x转换为⼀个浮点数

注意:浮点型无法转换成型

complex(real [,imag ]) 创建⼀个复数，real为实部，imag为虚部

str(x ) 将对象x 转换为字符串

repr(x ) 将对象x 转换为表达式字符串

eval(str ) ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象

tuple(s ) 将序列s 转换为⼀个元组

list(s ) 将序列s 转换为⼀个列表

chr(x ) 将⼀个整数转换为⼀个Unicode字符

ord(x ) 将⼀个字符转换为它的ASCII整数值

hex(x ) 将⼀个整数转换为⼀个⼗六进制字符串

oct(x ) 将⼀个整数转换为⼀个⼋进制字符串

bin(x ) 将⼀个整数转换为⼀个⼆进制字符串

格式化输出

格式化是指将数据按照预先定义好的格式处理数据的结构(字符串中含有变量)

格式化输出作用：让开发者很好的处理数据，组装数据，然后将其输出

格式化符号

%s 字符串

3.6以上版本可以用f'{}"表示

%d 有符号的⼗进制整数

%06d 表示输出的整数位数，不足前面补零

%f 浮点数

%.2f 表示保留两位小数

%c 字符

%u ⽆符号⼗进制整数

%o ⼋进制整数

%x ⼗六进制整数（⼩写ox）

%X ⼗六进制整数（⼤写OX）

%e 科学计数法（⼩写'e'）

%E 科学计数法（⼤写'E'）

%g %f和%e的简写

%G %f和%E的简写

转义字符

\n:换行

\t：制表符，一个tab键（空4格）

结束符

print("输出内容",end = "\n") print()，默认⾃带end="\n"这个换⾏结束符，所以导致每两个print直接会换⾏展示，⽤户可以按需求更改结束符。

运算符

算数运算符

+ 加 1 + 1 输出结果为2

- 减 1-1 输出结果为0

* 乘 2 * 2 输出结果为4

/ 除 10 / 2 输出结果为5

// 整除 9 // 4 输出结果为2

% 取余 9 % 4 输出结果为1

** 指数 2 ** 4 输出结果为16，即2 * 2 * 2 * 2

() 小括号小括号⽤来提⾼运算优先级，即(1 + 2) * 3 输出结果为9

赋值运算符

= 赋值将=右侧的结果赋值给等号左侧的变量

复合赋值运算符

+= 加法赋值运算符 c += a 等价于c = c + a

-= 减法赋值运算符 c -= a 等价于c = c- a

*= 乘法赋值运算符 c *= a 等价于c = c * a

/= 除法赋值运算符 c /= a 等价于c = c / a

//= 整除赋值运算符 c //= a 等价于c = c // a

%= 取余赋值运算符 c %= a 等价于c = c % a

**= 幂赋值运算符 c ** = a 等价于c = c ** a

比较运算符

== 判断相等

如a=3,b=3，则（a == b) 为True

!= 不等于

如a=3,b=3，则（a == b) 为True如

a=1,b=3，则(a != b) 为True

> 大于

如a=7,b=3，则(a > b) 为True

< 小于

如a=7,b=3，则(a < b) 为False

>= 大于等于

如a=7,b=3，则(a < b) 为False如

a=3,b=3，则(a >= b) 为True

<= 小于等于

如a=3,b=3，则(a <= b) 为True

逻辑运算符

and 与

True and False，返回False

or 或

False or True，返回True

not 反

not True 返回False, not False 返回True

分支与循环

if语法

分支主题

if...else 语法

分支主题

if嵌套

分支主题

while 循环

基本语法

while 条件: 条件成⽴重复执⾏的代码1 条件成⽴重复执⾏的代码2 ......

循环嵌套

while 条件1: 条件1成⽴执⾏的代码 ...... while 条件2: 条件2成⽴执⾏的代码 ......

while...else

while 条件: 条件成⽴重复执⾏的代码 else: 循环正常结束之后要执⾏的代码

for 循环

基本语法

for 临时变量 in 序列: 重复执⾏的代码1 重复执⾏的代码2 ......

循环嵌套

for 临时变量 in 序列1: 重复执⾏的代码1 重复执⾏的代码2 ...... for 临时变量 in 序列: 重复执⾏的代码1 重复执⾏的代码2 ......

for...else

for 临时变量 in 序列: 重复执⾏的代码 ... else: 循环正常结束之后要执⾏的代码

退出循环

continue

退出本次循环，继续执⾏下⼀次循环

break

退出整个循环

三目运算

条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

分支主题

数据结构

字符串(不可变类型)

定义

单个或多个字符组成(一般用引号来创建字符串)

格式

⼀对引号字符串

一对双引号字符

三引号字符串

三引号形式的字符串⽀持换⾏。

输入

使⽤ input() 接收⽤户输⼊

下标

“下标” ⼜叫 “索引” ，就是编号注意：下标从0开始。

例子

分支主题

切片

序列[开始位置下标:结束位置下标:步⻓]

1. 不包含结束位置下标对应的数据，正负整数均可； 2. 步⻓是选取间隔，正负整数均可，默认步⻓为1

例子

分支主题

操作方法

查找

find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1

字符串序列.find(⼦串, 开始位置下标, 结束位置下标)

index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则报异常。

字符串序列.index(⼦串, 开始位置下标, 结束位置下标)

rfind()：和find()功能相同，但查找⽅向为右侧开始。 rindex()：和index()功能相同，但查找⽅向为右侧开始。

count()：返回某个⼦串在字符串中出现的次数

字符串序列.count(⼦串, 开始位置下标, 结束位置下标

修改

replace()：替换

字符串序列.replace(旧⼦串, 新⼦串, 替换次数)

split()：按照指定字符分割字符串

字符串序列.split(分割字符, num)

join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

字符或⼦串.join(多字符串组成的序列)

capitalize()：将字符串第⼀个字符转换成⼤写 title()：将字符串每个单词⾸字⺟转换成⼤写 lower()：将字符串中⼤写转⼩写。 islower():判断是否为小写 upper()：将字符串中⼩写转⼤写。 isupper():判断是否为大写

判断

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开 始和结束位置下标，则在指定范围内检查。

endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开 始和结束位置下标，则在指定范围内检查

isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

列表(可变类型)

格式

[数据1, 数据2, 数据3, 数据4......]

下标

同字符串

切片

同字符串

操作方法

查找

通过下标

index()：返回指定数据所在位置的下标

count()：统计指定数据在当前列表中出现的次数

判断

in：判断指定数据在某个列表序列，如果在返回True，否则返回False

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

增加

append()：列表结尾追加数据

列表序列.append(数据)

extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表。

列表序列.extend(数据)

insert()：指定位置新增数据。

列表序列.insert(位置下标, 数据)

删除

del (全部删除或删除指定数据)

pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据。

列表序列.pop(下标

clear()：清空列表

修改

根据下标

逆置： reverse()

排序： sort()

复制 copy()

循环遍历

for 变量 in 列表

综合应用

随机分配办公室

分支主题

元组(不可变类型)

格式

(数据1, 数据2, 数据3, 数据4......)

特点

⼀个元组可以存储多个数据，元组内的数据是不能修改的。

操作方法

查找

按下标查找数据

index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。

count()：统计某个数据在当前元组出现的次数

字典(可变类型)

格式

{"key":"value"}

特点

字典⾥⾯的数据是以键值对形式出现，字典数据和数据顺序没有关系，即字典不⽀持下标，后期⽆论数据如何变化，只需要按照对应的键的名字查找数据即可

操作方法

增加

字典序列[key] = 值

删除

del() / del：删除字典或删除字典中指定键值对。

clear()：清空字典

修改

字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

查找

key值查找

如果当前查找的key存在，则返回对应的值；否则则报错

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。

keys() 查出所有键

values()查所有键对应的值

items() 查找所有键值对

循环遍历

字典序列.keys

字典序列.value

字典序列.items

分支主题

集合(可变类型)

格式

{数据1, 数据2, 数据3, 数据4......}

特点

:1.集合可以去掉重复数据； 2. 集合数据是⽆序的，故不⽀持下标

操作方法

增加

add()

因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作。

update(), 追加的数据是序列

删除

remove()，删除集合中的指定数据，如果数据不存在则报错。

discard()，删除集合中的指定数据，如果数据不存在也不会报错。

pop()，随机删除集合中的某个数据，并返回这个数据。

查找

in：判断数据在集合序列 not in：判断数据不在集合序列

公共操作

运算符

分支主题

公共方法

分支主题

range()

注意： range()⽣成的序列不包含end数字

enumerate(可遍历对象, start=0)

start参数⽤来设置遍历数据的下标的起始值，默认为0。

分支主题

容器类型转换

tuple() 转元组

list() 转列表

set() 转集合

推导式

作⽤

⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。

带if的列表推导式

分支主题

字典推导式

分支主题

集合推导式

分支主题

多个for循环实现列表推导式

函数

使用步骤

定义

def 函数名(参数): 代码1 代码2 . .....

函数就是将⼀段具有独⽴功能的代码块整合到⼀个整体并命名，在需要的位置调⽤这个名称即可完成对应的需求。

更⾼效的实现代码重⽤

调用

函数名(参数)

函数的参数

定义

函数调⽤时候指定的数字(实参)和定义函数时候接收的数字(形参)即是函数的参数。

类型

位置参数

调⽤函数时根据函数定义的参数位置来传递参数。

传递和定义参数的顺序及个数必须⼀致。

分支主题

关键字参数

函数调⽤，通过“键=值”形式加以指定。

注意：函数调⽤时，如果有位置参数时，位置参数必须在关键字参数的前⾯，但关键字参数之间不存在先后顺序。

分支主题

缺省参数

缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值

注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤

分支主题

不定长参数

不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)

包裹位置传递

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)

分支主题

包裹关键字传递

进的所有参数都会被kwargs变量收集，它会根据传进参数的位置合并为⼀个字典(dict)

分支主题

函数的返回值

return

作用:1.返回函数的数据 2.函数体内,遇到return后所有代码不执行

return a, b 返回多个数据的时候，默认是元组类型(a, b)。 2. return后⾯可以连接列表、元组或字典，以返回多个值。

变量作用域

全局变量

是在函数体内、外都能⽣效的变量。

局部变量

在函数体内部的变量，即只在函数体内部⽣效。

局部变量转全局变量: global 局部变量

拆包和交换变量值

拆包:元组

分支主题

拆包:字典

分支主题

交换变量值

c=a a= b b = c

python 的方式: a, b = b, a

引用(传递)

可变类型

在其原内存操作

分支主题

不可变类型

操作需从开内存

分支主题

说明文档

help(函数名):查看函数说明文档

def 函数名(参数): """ 说明⽂档的位置 """ 代码 ......

函数的应用

分支主题

递归

函数内部⾃⼰调⽤⾃⼰ 必须有出⼝

分支主题

lambda表达式

语法: lambda 参数列表：表达式

print((lambda a, b: a if a > b else b)(1000, 500))

列表数据按字典key的值排序

分支主题

高阶函数

把函数作为参数传⼊

abs() 将数字绝对值

round() 四舍五入

map(func, lst): 将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

分支主题

reduce(func(x,y)， lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算。

分支主题

filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 filter 对象,。如果要转换为列表,可以使⽤ list() 来转换。

分支主题

文件操作

作用

把⼀些内容(数据)存储存放起来，可以让程序下⼀次执⾏的时候直接使⽤，⽽不必重新制作⼀份，省时省⼒

基本操作

打开

open(name, mode)

name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。 mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等

分支主题

写

文件对象.write('内容')

读

⽂件对象.read(num)

readlines()

按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。

readline()

readline()⼀次读取⼀⾏内容。

关闭

⽂件对象.close()

seek()

⽂件对象.seek(偏移量, 起始位置)

⽤来移动⽂件指针

案例

分支主题

文件备份

分支主题

文件和文件夹的操作

⽂件重命名

os.rename(⽬标⽂件名, 新⽂件名)

删除⽂件

os.remove(⽬标⽂件名)

创建⽂件夹

os.mkdir(⽂件夹名字)

删除⽂件夹

os.rmdir(⽂件夹名字)

获取当前⽬录

os.getcwd()

改变默认⽬录

os.chdir(⽬录)

获取⽬录列表

os.listdir(⽬录)

应用:批量修改文件名

分支主题

面向对象

类

类 :是对⼀系列具有相同特征和⾏为的事物的统称，是⼀个抽象的概念，不是真实存在的事物。类是⽤来创建对象

定义类

class 类名: 代码 ......

类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯

组成

属性(特征)

实例属性

修改

类外面

实例对象名.属性名 = 值

类里面

self.属性名 = 值

获取

类外面

对象名.属性名

类里面

self.属性名

类属性

归属于类对象的属性，所有对象共有的属性

类属性只能通过类对象修改，不能通过实例对象修改， 如果通过实例对象修改类属性，实际上是创建了⼀个实例属性

方法(行为)

实例方法

def xx(self): 代码块

魔法方法(__xx__)

__init__()

初始化对象。在创建⼀个对象时默认被调⽤

_init__(self) 中的self参数, python解释器会⾃动把当前的对象引⽤传递过去

带参数

分支主题

__str__()

打印时解释器会,自动调用这个⽅法,返回 return 的数据

__del__()

当删除对象时， python解释器会默认调⽤

类方法

@classmethod def xx(cls): 代码块

当⽅法中需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法类⽅法⼀般和类属性配合使⽤

静态方法

@staticmethod def xx(): 代码块

1.当⽅法中既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅法、创建实例等)时，定义静态⽅法 2.取消不需要的参数传递，有利于减少不必要的内存占⽤和性能消

三大特性

封装

将属性和⽅法书写到类的⾥⾯的操作即为封装

继承

class B(A): 代码块

在Python中，所有类默认继承object类， object类是顶级类或基类；其他⼦类叫做派⽣类

继承特点

⼦类默认拥有⽗类的所有属性和⽅法

重写

⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法

super()

调⽤⽗类⽅法

私有权限

class 类名(): # 私有属性 __属性名 = 值  # 私有⽅法 def __函数名(self): 代码块

多态

⼀类事物有多种形态，（⼀个抽象类有多个⼦类，因⽽多态的概念依赖于继承）

子类重写父类方法, 调用子类该方法时, 实际上执行的是子类重写后的内容, 相同的方法名, 不同子类重写的功能不同, 那么执行的结果也不同, 即为多态

异常

基本格式

try: 可能发⽣错误的代码 except: 如果出现异常执⾏的代码

捕获异常

指定异常

try: 可能发⽣错误的代码 except 异常类型: 如果捕获到该异常类型执⾏的代码

指定多个异常

try: 可能发⽣错误的代码 except 异常类型:1,异常类型:2....: 如果捕获到该异常类型执⾏的代码

所有异常

try: 可能发⽣错误的代码 except Exception as 变量: 如果捕获到该异常类型执⾏的代码

else

如果没有异常要执⾏的代码。

finally

⽆论是否异常都要执⾏的代码，例如关闭⽂件。

异常的传递

分支主题

自定义异常

语法为 raise 异常类对象。

分支主题

模块和包

制作模块

⾃定义模块名必须要符合标识符命名规则。

__name__

直接执行当前文件, __name__的值是"__main__", 被其他代码调用, __name__的值是py文件名

模块定位顺序

1. 当前⽬录

2. 如果不在当前⽬录， Python则搜索在shell变量PYTHONPATH下的每个⽬录。

3. 如果都找不到， Python会察看默认路径。 UNIX下，默认路径⼀般为/usr/local/lib/python/

注意事项

模块搜索路径存储在system模块的sys.path变量中。变量⾥包含当前⽬录， PYTHONPATH和由安装过程决定的默认⽬录

⾃⼰的⽂件名不要和已有模块名重复，否则导致模块功能⽆法使⽤

使⽤from 模块名 import 功能的时候，如果功能名字重复，调⽤到的是最后定义或导⼊的功能

导入模块的时候, 模块里的代码都会执行一次

导入模块

import 模块名

调用模块名.功能名()

from 模块名 import 功能名

调用功能名()

from 模块名 import *(不推荐)

调用功能名()

如果⼀个模块⽂件中有 __all__ 变量，当使⽤ from xxx import * 导⼊时，只能导⼊这个列表中的元素。

import 模块名 as 别名

调用别名.功能名()

from 模块名 import 功能名 as 别名

调用功能名()

制作包

如果⽂件夹内有⼀个名字为 __init__.py ⽂件，那么这个⽂件夹就称之为包

步骤: [New] — [Python Package] — 输⼊包名 — [OK] — 新建功能模块(有联系的模块)。

导包

import 包名.模块名

from 包名 import 模块名

from 包名 import * (不推荐)

__all__ = [] ：允许导⼊的模块或功能列表

import 包名.模块名 as 别名

from 包名 import 模块名 as 别名