python入门教程思维导图模板_ProcessOn思维导图、流程图

dict字典

定义

使用 { key : value } 定义字典

每对值之间用逗号(,)分割

数据结构和json类似

d = {'woodman': 98, 2.5: 'PM', 'Bobo': [89, 34],'Mydict': {'Alan': 99}}

特点

Key 必须唯一

Python <3.6 版本无序存储，
>=3.6版本有序存储

查找速度快，数量无论多少，查询速度一样

访问

dict[key]

key 不存在会抛出异常

dict.get(key)

key不存在返回None

新增与修改值

dict[key] = value

key不存则新增，key存在则为修改

dict.update(otherdict)

批量新增或修改

删除值

dict.pop(key)

删除对应键值

dict.clear()

清空dict

运算

key in dict

判断键是否存在与字典中

key not in dict

判断键是否不存在与字典中

常用函数

len(dict)

长度

常用方法

dict.keys()

获取所有键的迭代对象

dict.values()

获取所有的值的迭代对象

dict.items()

以列表返回可遍历的(键, 值) 迭代对象

if 条件控制

判断规则

当遇到if 或 elif 条件为True时，则执行它下面的语句块，后续的 if elfi else语句不会执行

所有 if 或 elif 条件都为False，则执行else 下的语句块；

条件的值 0 和 None 等价与 False

结构

if ...

单独 if 判断，都条件为 True 值执行语句块，否则跳过

if...else...

当 if 的条件为 True 时执行 if 下的语句块，否则执行 else 下语句块。

if...elif...else...

从 if 的第一个条件开始依次判断，直到条件为 True ，则执行对应 if 或 elif 下的语句块；
如果所有条件都未False，则执行 else 语句块。

当遇到条件未Ture的if 或 elif 时，后续的 if elfi else语句不会执行

if 语句嵌套

可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中

条件

可以使用比较（>,<,== 等）、逻辑（and，or，not）、
成员（in，not int）、身份运算符（is ， not is）

while 条件控制循环

运行规则

不断循环，直到条件表达式结果为 False

结构

while ...

while...else...

else 语句块只有在循环正常结束后使用

break 跳出循环，会跳过else语句执行

while True : ...

无限循环

需要在执行语句块中加入 break，跳出循环

提前结束循环

break

结束循环，不再执行循环

continue

跳过当次循环，继续执行下一次循环

for 序列遍历循环

运行规则

依次访问可迭代对象的元素

用途

遍历序列成员

for i in iterObject

循环计数控制

for i in range( int )

结构

for x in iterObject ....

for x in iterObject ... else ...

else 语句块只有在循环正常结束后执行

break 跳出循环，会跳过else语句执行

嵌套循环

循环中嵌套另外一层循环

使用方法

list 列表

for i in list: ...

tuple 元组

for i in tuple: ...

dict 字典

for key,value in dict.items(): print(key,value)

for key in dict: print(dict[key])

str 字符串

for s in str:....

range() 循环计数控制

range(stop)

从0开始到stop结束（不包含stop）

for i in range(5): ...

循环5次

range(5)相当[0,1,2,3,4]

range(start, stop)

从start开始到stop结束（不包含stop）

for in range(2,5)

循环2到4，循环3次

range(2,5)相当[2,3,4]

range(start, stop,step)

从start开始到stop结束（不包含stop）

每相隔 step 取数

循环 math.ceil((stop-start)/step)) 次；
---(stop-start)/step) 向上取整次---

for in range(1,5,2): ...

循环2次

range(1,5,2)相当[1,3]

提前退出循环

break

结束循环，在循环体内直接退出循环

continue

跳过该次循环，继续下一次循环

迭代器

创建

iter(序列)

创建一个迭代器

访问

next(iterObject)

访问迭代元素，访问后指针向下移一行

def 函数

作用

提高应用的模块性和代码的重复利用率

定义

def 函数名(参数):
函数体
return 返回值

参数可选

可以无return

return

函数执行时遇到return，则返回其结果，结束函数运行，不在运行函数return后的语句

无return

返回None

返回对象数目=1

返回对象

返回对象数目>1

返回tuple

参数

带默认值的参数

必须放在必需参数的最后

无默认值的参数为必需参数，调用时必填

带默认值的参数称为默认参数，调用时选填

可变参数

func(*args) 序列可变参数

args元组存放所有未命名的不带键的参数

调用

func(*tuple)

将tuple序列中的元素，依次传递给函数

func(**kwargs) 键对值可变型参数

kwargs字典存放所有未命名的带有键对值的变量参数

调用

func(**dict)

将dict中的元素，按key与参数名对应传递给函数

func(*args,**kwargs)

可接收任何参数

调用

使用

函数名(参数)

len(list)

获取list的长度

空函数

使用 pass 做占位符，保证函数正常运行

def test():
pass

匿名函数 lambda

逻辑简单，函数体只能有一个表达式，返回表达式的值

lambda [参数1[,参数2,.....参数n]]:表达式

lambda x:x*x+1

lambda parameter : expression1 if condition else expression2

lambda x, y: x if x > y else y # 求两个数最大值

Class 类

OOP

概念

类是模板，（相近似对象，抽象后归为类）

实例则是根据类创建的对象

作用

提高程序的重用性

特点

数据的封装

对外部隐藏

继承

创建包含父类(公共类)的子类(专用类)

多态

对不同类型的对象，可进行相同的操作

对象

Python 中一切皆对象

属性

指明这个类是什么，也就是实例的特征

实例属性

用来区分每个实例不同的基础

不同的实例具有不同的实例属性

类属性

相同类的实例所共有的特征

方法

需要这个类做什么

动词，它是一种行为，一个动作，或需要得到的一种结果

类

# 创建类
class ClassName(object):
def __init__(self): pass
def func(self): pass

class

创建类关键字

ClassName

类名称

规范：首字母必须大写

object

继承与object基类

没有其他父类，一般都是继承与object

def

创建方法关键字

相当于函数

__init__()

类的初始化方法

作用

__init__()中存在除self外的参数，
ClassName()实例化时必需传递参数值

实例化时自动调用，强行绑定实例属性

通过该方法给实例属性赋值

func

方法名

self

类的实例

方法中的第一个参数

代表当前实例的对象

所有方法中必需有self参数，除非使用@staticmethod创建静态方法

self.属性名

能获取实例的属性

示例

创建圆类

class Circle(object):
__pi = 3.14 # 类属性,为私有属性

def __init__(self, r):
self.r = r # 实例属性

def get_area(self):
""" 圆的面积 """
return self.r ** 2 * self.pi

创建半径为2的圆对象

circle = Circle(2)

获取圆的半径

r=circle.r

获取圆的面积

area=circle.get_area()

属性

实例属性

通过 self.xxx 定义的属性都是实例属性

类属性

定义下类下，没在方法中的属性都是类属性

当实例属性和类属性同名时

通过实例名访问，优先获取实例属性的值

通过类名访问，优先获取类属性

私有属性

在属性名前加单或双下划线

不能外部访问

__xxx

或

_x

方法

除了第一个参数必需是self实例外，其他如同函数的使用

私有方法

在方法名前加单或双下划线

不能外部访问

def __xxx(): ...

或

def _x(): ...

类中方法装饰器

@classmethod 类方法

class ClassName(object):

@classmethod
def xxx(cls): pass

cls

表示当前的类对象

@classmethod 装饰的方法不能使用实例属性，只能是类属性

ClassName.xxx()

不用创建实例对象，直接通过类名.方法名访问

使用在与类进行交互，但不和其实例进行交互的函数方法上

@staticmethod 静态方法

class ClassName(object):

@classmethod
def xxx(): pass

方法中没有self或cls参数

ClassName.xxx()

不用创建实例对象，直接通过类名.方法名访问

使用在有些与类相关函数，但不使用该类或该类的实例

@property 将类方法转换为只读属性

class ClassName(object):
__name = 'class'

@property
def name(self):
return self.__name

将一个类方法转变成一个类属性

需要创建实例，才能访问name方法

cn = ClassName()
print(cn.name)

类的继承

概念

他是类与类的一种关系

如：爸爸生个儿子，儿子继承爸爸的属性和方法

爸爸是父类，儿子是子类

提高代码的复用率

如：公共类

类与类之间有一些公共的属性和方法，这时我就可以把相同的属性和方法作为基类

定义

ParentClass

父类

SubClass

子类

通过继承太会拥有父类的属性和方法

def __init__:

继承父类的实例属性需要使用下面方法将属性继承过来
super(SubClass, self).__init__(parameter1)

def method():

子类会继承父类的方法

子类调用方法时先在当前类中查找改方法，然后去上一级父类中查找

重构

是对方法的重构

可以在子类中重构方法

子类与父类的关系

parent是ParentClass的实例，但不是SubClass的实例

sub是SubClass的实例，也是ParentClass的实例

isinstance(sub, ParentClass)

判断sub是否为ParentClass的实例

语法基础

输出

print ("hello,world")

字符编码

# -*- coding: uft-16 -*-

# coding=GBK

代码块

使用缩进，推荐Tab健

标识符

查找保留关键字

print(keyword.kwlist)

用途

变量名，函数名，类名，包名，文件名

注意事项

标识符最好不要使用安装的包名作为标识符

基本数据类型

整数

1、10010、-1、0、-10086、11111133333

浮点数

1.0、1.2、3.14、-9.01、-3.14159、0.266

1.0 也是浮点数

复数

数学中的复数

字符串

'abc'、"abc"、'''hello'''、"This’s dog"、"""My is WoodMan"""、'123'

布尔值

True 、 False

空值

None

转换类型

字符串转换整型

num=int('123')

整型转换为字符串

string=str(12345)

整型转换为浮点型

浮点型转换为整型

num=int(1.23)

字符串转换为浮点型

f=float('123')

浮点转换为字符串

string=str(1.23)

整型转换为浮点型

f=float(123)

变量

作用：存储数据，如需在程序后面引用

定义方法

由大小写英文、数字和下划线 _ 的组合，但不能用数字开头

变量名区分大小写

示例

正确

a、_ab、A1、__abc12A

错误

1A、1_ab、012ABC

不能数字开头

运算符

算术运算符

加（+）、减（-）、乘（*）、除（/）

取模（%）

23%10余3，所以值为3

幂（**）

2**3 的值为 8

取整（//）

10//3 值为3

比较运算符

等于（==）、不等于（!=）、大于（>）小于（<）、大于等于（>=）、小于等于（<=）

结果

True或False

逻辑运算符

连接比较运算符，先计算比较运算，然后再进行逻辑运算

与（and）、或（or）、非（not）

结果

True或False

成员运算符

元素是否在序列中

in 或 not in

结果

True或False

身份运算符

比较两个对象的内存地址

is 或 not is

结果

True或False

is 与 == 的区别

is 比较的是对象的id

== 比较的是type 和 value

当id相同时它的type和value肯定相同，但当type与value相同时id不一定相同

字符串处理

创建字符串

常用单引号( '' ), 双引号 ( " " ) 创建字符串。
大量的文本内容使用三个引号 ( ''' ''' ) 或 (""" """ )

区别

单双引号不支持字符串本身换行。
三个引号可以保留字符串原格式，包括换行

示例

var1 = 'Hello World!'

var2 = "木头人"

var3 = '''我要学习
python'''

var4 = "I'am woodman"

当字符串中出现单引号时，可以使用双引号创建字符串，反之亦然

字符串的连接

使用 '+' 连接字符串

注意

不能输非字符串数据类型连接

str(8)

将整型数据 8 转换为字符串 '8'

字符串运算

连接

+

原始字符串

r/R

是否存在某个字符

in\not in

转义字符

常用

\\

单个反斜杠 \

\'

单引号

\"

双引号

\n

换行

\t

横向制表符，相当于 Tab 键

切片

str[index]

index为下标索引，从0开始，如果索引为负数则是倒着开始

str[start:end]

读取索引start开始到索引为end-1 结束的字符

str[start:end:step]

读取索引start开始每相隔step读取字符直到索引为end-1 结束

常用函数

string.replace(old, new[, count])

替换

string.strip()

去除左右空格

string.split([sep [,maxsplit]])

拆分字符串

string.find(sub [,start [,end]])

查找字符

string.upper()

将字符串全部转为大写

string.lower()

将字符串全部转为小写

string.title()

将字符串单词的第一个字母转为大写，其它字母小写

List 列表

定义

使用中括号 []，里面的值可以为任意类型

list1 = ['Google', 'woodman', True, 2017]

特点

有序

元素可修改

值可重复

访问

list[index]

list[0]

访问第一个值

index 索引号，从0开始，不能越界

新增

list.append(value)

末尾新增

list.insert(index,value)

在index位置插入value

修改

list[0]=1

使用索引号读取列表，直接赋值修改

删除

list.pop()

删除列表末尾的值

list.pop(index)

删除列表对应索引号的值

list.remove(value)

找到符合条件的第一个value删除

切片

str[index]

index为下标索引，从0开始，如果索引为负数则是倒着开始

str[start:end]

读取索引start开始到索引为end-1 结束的字符

str[start:end:step]

读取索引start开始每相隔step读取字符直到索引为end-1 结束

运算

加法

连接两个列表，合并成一个

l = l1+l2

乘法

重复复制列表

l = l1 * 4

判断

value in list

判断value是否在list中

value not in list

判断value不在list中

常用函数

len(list)

列表的长度

max(list)

列表中元素最大值，必须是相同类型对比

min(list)

列表元素最小值，必须是相同类型对比

list(tuple)

将元组转换为列表

常用其他方法

list.count(obj)

统计某个元素的个数

list.extend(seq)

列表末尾追加列表或其他序列

list.index(obj)

查找元素值

list.reverse()

反向列表中元素

list.sort(key=None, reverse=False)

排序

list.clear()

清空列表

list.copy()

复制列表

tuple元组

定义

使用小括号()，里面的值可以为任意类型

t = ('woodman', 1987,True, [1,3])

特点

有序

不可被修改

值可重复

访问

tuble[index]

t[0]

访问第一个值

index 索引号，从0开始，不能越界

删除值

使用 del 删除引用，只能删除整个tuple

del(t)

切片

同 List 切片

运算

加法

连接两个元组，合并成一个新元组

t3 = t1+t2

判断

value in tuple

判断 value 是否在 tuple 中

value not in tuple

判断 value 是否不在 tuple 中

常用函数

len(list)

长度

max(list)

最大值，必须是相同类型对比

min(list)

最小值，必须是相同类型对比

tuple(list)

将列表转换为元组

常用方法

tuple.count(obj)

统计某个元素的个数

tuple.index(obj)

返回值的索引号