python基础思维导图模板_ProcessOn思维导图、流程图

python真假值测试

特性

所有对象均有一个继承的真、假值

所有非0数字或非空对象均为True

0、空对象及特殊对象None被视为False

>>> bool(None)

False

>>> bool(0)

False

>>> bool([])

False

比较及等值(真假值)测试返回True 或 False （即 1、0的自定义版本）

当结果已知时立即停止布尔运算（短回环）

运算符

and

or

not

三元表达式

result = '及格' if score > = 60 else '不及格'

函数

作用

最大化代码重用

最小化代码冗余

查看内存地址

>>> id(5)

4455045856

>>> def hello():

... print ('hello')

...

>>> hello()

hello

>>> type(hello)

>>> id(hello)

4470226456

>>> print(hello())

hello

None

print 打印的是hello这个函数的返回值，因为这个hello函数没有返回值，所以打印的时候出来的是None

应用

定义

def xxx(): 冒号表示函数名或者是头声明完毕

执行时机，（python 是动态类型，解释型语言）代码执行到的时候执行该函数

返回值

print 打印的是函数的返回值

参数

内置函数，定义在builtin 里面

作用域

local：函数本地（函数内的变量）范围，函数变量以内的声明不影响函数以外的变量的值

def func(): x=100 print(x+10) 这里的x 是本地范围内的变量

global :全局变量

函数本地变量不影响全局变量

使用是 global xx

enclosing ：封装函数内

nolocal 就是会影响上一层的变量的值

在封装的函数内使用 nolocal xxx

Builtins ：内置

执行顺序： LEGB

参数

位置参数

默认匹配：从左至右位置匹配

名称匹配：顺序无关

譬如： def test(a,b,c): test(c=12,b=13,a=7) 这种是名称匹配

默认值参数

默认值参数位于位置参数的后面

def test(a,b,c=10): c=10就是默认值参数

任意参数

关键字参数

参数前面加上** ,传进来的参数被当做字典表来处理

处理的时候当做字典表，但传的时候要传键值对

解包 **args

def func(a,*args,**kwargs):
    print (a,args,kwargs)

    for k,v in kwargs.items():
        print ("{}-->{}".format(k,v))

func(12,1,3,4,41,344,name="tom",age=18,school="big")

子主题

def func(a,*args,**kwargs):
    print (a,args,kwargs)

    for k,v in kwargs.items():
        print ("{}-->{}".format(k,v))

t = (1,3,4,41,344)
kw = {'school': 'big', 'name': 'tom', 'age': 18}

func(12,*t,**kw)

序列参数

参数的前面加上* ，传进来的参数被当做元祖来处理

>>> def func(a,*args):

... print (a,args)

...

>>> func(10,2,3,4,5)

10 (2, 3, 4, 5)

*args ，元祖序列参数

>>> t = (1,2,3)

>>> func(20,t)

20 ((1, 2, 3),)

>>> func(20,*t)

20 (1, 2, 3)

解包，前面加*

位置参数，默认值参数，任意参数顺序要这样

*解包元祖，**解包字典表

参数传递机制

值传递：不可变类型对象向函数传递值副本（函数内操作不影响原始值）

>>> def test(a):

... a +=10

... print (a)

...

>>> print (x)

5

>>> test(5)

15

>>> print(x)

5

引用传递：可变类型对象向函数传递对象引用（函数内操作会影响原始对象），为什么会影响呢，因为传递的是引用的副本

>>> l =[1,2,3]

>>> def ttt(oo):

... oo[0]=100

... print (oo)

...

>>> print (l)

[1, 2, 3]

>>> ttt(l)

[100, 2, 3]

>>> print (l)

[100, 2, 3]

如果不想被影响的话，直接写 ttt(l.copy()) ,copy() 这个函数是取得副本，包括引用和原始的数值

l[:] 也是将序列的原始的值的副本复制出来，函数外的序列值不会被改变

传递引用和值副本

x.copy()

x[:]

lambda 表达式(匿名函数)

表达式，不是语句

语句是用来声明逻辑，表达式是用来计算和返回一个值

def 定义有名称函数对象(名称必须)

lambda 表达式（匿名函数）

表达式，而非语句

语句是声明逻辑，表达式是返回一个值

def 定义函数，必须要有名称

lambda 返回函数对象(值)，名称可选

>>> gretting = lambda : print ("hello")

>>> gretting()

hello

>>> type(gretting)

函数主体为单一表达式，而非语句块，设计目标是实现一些简单的函数

lambda 名称和参数列表声明在冒号的左侧，右侧是代码体

>>> action = lambda a,b :a+b

>>> action(1,2)

3

默认冒号后面的值，总会返回的，所以不需要写return

>>> xx = lambda x :x**2

>>> xx(3)

9

优势

函数嵌套更简便

def func(x):
    def f1(x):
        return x**2
    def f2(x):
        return x**3
    return f1(x)+f2(x)
print (func(2))

def funcc(x):
    f1 = lambda x:x**2
    f2 = lambda x:x**3
    return f1(x)+f2(x)
print(funcc(2))

方便嵌入列表或字典表之类的序列以执行操作

a,b = 5,3
func_list =[lambda x,y :x+y,lambda x,y :x-y,lambda x,y:x*y] #列表可以包含任何类型的元素
for func in func_list:
    print (func(a,b))

替代实现多重分支

a,b = 5,3
def add(a,b):
    return a+b
def subtract(a,b):
    return a-b
action = {'a':add,'s':subtract,'m':lambda a,b:a*b,'d':lambda a,b :a%b}
print (action.get('z',add)(a,b))

作为回调函数处理句柄列便捷

a,b = 5,3
def add(a,b):
    return a+b
def subtract(a,b):
    return a-b
def calculate(a,b,func):
    return func(a,b)
print(calculate(a,b,lambda a,b :a/b))

装饰器

概述

用于管理和增强函数和类行为的代码

提供一种在函数或类定义中插入自动运行代码的机制

特点

更明确的语法

更高的代码可维护性

更好的一致性

编写

函数基础

将函数赋给变量

将函数作为参数传递

函数嵌套及跨域访问

函数作用域，legb

l ，local 本地

e,enclosing 封装

g glbal 全局

b builtin内置

函数定义装饰器

既可以用在脚本里面包含的普通函数上，也可以用在类包含的方法上

类定义装饰器

可以用在脚本里面包含的普通函数上，用在另一个类包含的方法上可能会有些问题

闭包

所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象

使用价值

：封存函数执行的上下文环境

闭包在其捕捉的执行环境（def语句块所在上下文）中，也遵循LEGB规则逐层查找，直到找到符合要求的变量，或者抛出异常

函数工具

编程语言（编程范式）

面向过程

c

面向对象

c++,c#,java.php

函数式编程

把运算过程尽量的写成一套函数进行调用

工具函数

映射操作到可迭代对象 map()

students = ['jerry','tom','lucy']
resu = list(map(lambda a :a.upper(),students))
print (resu)

map(func,s) func是函数，s是可迭代序列

filter(func,iterable) 过滤函数

从可迭代对象中选择过滤项，保留序列里面满足条件成立的元素

filter 过滤效率会高于手动写的python程序，因为它的实现是通过底层的C来实现的

scores = [55,12,34,89,6,76,78,90,89]
def func(x):
    return x>=60
results = list(filter(func,scores))
print (results)

[89, 76, 78, 90, 89]

students = ['jerry','tom','lucy']
reseee = filter(lambda n :'e' in n,students)
print (list(reseee))

['jerry']

functools.reduce()合并迭代项

不属于全局命名空间，对序列里面的元素，逐个实现两两操作

>>> import functools

>>> L = [1,2,3,4,5]

>>> functools.reduce(lambda x,y :x+y,L)

15

>>> functools.reduce(lambda x,y :x*y,L)

120

>>> functools.reduce(lambda x,y :x-y,L)

-13

operator 数学运算的库，好多操作符

>>> import operator

>>> functools.reduce(operator.add,L)

15

>>> L = [1,2,3,4,5]

>>> functools.reduce(operator.mul,L)

120

针对L里面的元素实现两两相加

计算机常识

计算机

概念

存储和计算处理的电子设备

硬件

CPU中央处理器

内存

外部存储设备

移动硬盘之类

输入设备

键盘，鼠标，麦克风，扫描仪，照相机

输出设备

显示器

打印机

通信设备

有线、无线网卡

软件

由程序和文档构成

程序是对文档处理的指令

系统软件

安装操作系统的时候带的软件

人机交互的桥梁

应用软件

针对于不同的具体任务诞生的

编程语言

机器语言

0或1

汇编语言

高级语言

java

python

c

c++

...

编译类：编译器

通过编译器编译成计算机认识的0或1

类似于文字翻译，笔译

优：运行效率高

缺点不灵活，修改后要重新翻译

c、java之类

解释类：解释器

通过解释器解释成计算机认识的0或1

同声传译，一遍翻译一边传达

优：更灵活

缺点是效率低

python、php

二进制

数据存储与运算

数据单位

bit比特位

1byte=8bit

1kb=1024byte

1mb=1024kb

1gb=1024mb

1tb=1024gb

...

语句与流程控制

语句

赋值

x = 5

运行函数语句

>>> math.pow(x,2)

25.0

选择执行语句

>>> if x>3:

... print ("大于3")

...

大于3

迭代语句

>>> for i in range(6):

... print (i**2)

...

0

1

4

9

16

25

一般循环语句

while

函数相关语句

模块与命名空间

类

异常处理

。。。

语法

强制缩进

4 个空格

PEP8

赋值语句

机制

赋值创建对象引用

名称创建于首次赋值

名称引用前必须赋值

某些操作会执行隐式赋值

赋值

基本赋值

x=5

元祖/列表赋值

>>> name,age = "tom",20

>>> name

'tom'

>>> age

20

>>> (name,age) = ("tom",20)

>>> age

20

序列赋值

多目标赋值

a,b = 6,90

参数化赋值

a+=10

顺序执行及输入输出

输入

input("输入信息提示")

输出

print("obj")

一个print一个换行符

print(name,job,sep="~")

默认的分隔符是空格，也可以通过sep改变默认分隔符

print ("薪资:{:10.3f}".format(salary))

10是占十位，逗号是以逗号分隔的数值，点3是小数点后保留3位，f是浮点数显示

if条件语句

一般格式if语句

if xx: else:xxx

多重分支及增强实现

score = 90

if score<60:
    print ("不及格")

elif score>=90:
    print ("优秀")
elif score>=80:
    print ("良好")

else:
    print ("及格")

lang = "ez"
greeing = {"cn":"您好","en":"hello","ru":"dskdnk"}
print (greeing.get(lang,"不存在这种语言"))

真假值测试与三元表达式

运算符

and

or

not

特性

所有对象均有一个继承的真，假值

>>> bool(True)

True

>>> bool(0)

False

>>> bool("a")

True

>>> bool(2)

True

>>> bool(2)

True

所有非0数字或非空对象均为True

>>> bool([])

False

>>> bool([1])

True

0,空对象，及特殊对象None均被视为False

比较及等值测试返回True 或False（即1，0的自定义版本）

and,or布尔运算符返回真，假操作对象

当结果已知时立即停止布尔运算，这种称为短回环

三元表达式

>>> score = 90

>>> rsult = "及格" if score >= 60 else '不及格'

循环语句

while循环

一般格式

>>> i = 10

>>> while i>=1:

... print ("{}的平方值{}".format(i,i**2))

... i-=1

...

10的平方值100

9的平方值81

8的平方值64

7的平方值49

6的平方值36

5的平方值25

4的平方值16

3的平方值9

2的平方值4

1的平方值1

>>> students = ["tom","jerry","mike"]

>>> i = 0

>>> while i<len(students):

... print (students[i])

... i+=1

...

tom

jerry

mike

关键字

pass/...

break

跳出整个while循环体

continue

跳出当前循环，执行下一次循环

x = 0

while x<10:
    x +=1
    if x%2 ==0 :
        continue
    print (x)

else

for ...in遍历

while 是条件满足时重复执行操作， for…in…是对一个序列元素逐一操作

for一般用于知道循环次数的时候，while的话用于不知道循环次数但知道结束条件的情况。

模块与包管理

python程序结构

表达式

语句

...

脚本/模块

模块(Module)

功能角色

代码重用

系统命名空间的分割

共享服务或数据

代码组织

一个顶层文件：包括主要控制流用于启动程序

0-N个支持文件（模块）：提供功能组件以备顶层文件使用

导入

机制

import指令运行时执行并载入文件

标识被载入文件

分配模块变量名称

过程

1.查找模块文件：按模块搜索路径

2.编译到字节码（如果必要），导入文件的时候将文件编译成字节码

缓存以提高效率

当字节码旧于源文件或版本有差异时重新编译

隔离存贮于 __pycache__目录

3.运行代码构造其定义的对象

模块搜索路径

1.程序主目录

2.系统环境变量 PYTHONPATH 设定的目录

3.标准库目录

4.任意 .pth文件内容指定目录

.pth文件放在python安装目录

5.site-packages 目录下安装的第三方扩展

创建

合法标识符

避免与关键字（保留字）冲突

包目录名称不与平台限定冲突

使用

import 导入整模块

from ... import 从模块获取特定成员

导入只执行一次

导入后文件修改不会重新载入当前环境里面

importlib.reload(模块)

不终止python代码的情况下重新载入模块代码

reload（）函数参数必须为模块，而非载入对象名称

对象持久化

扁平文件

文本文件

pickle

序列化为字符串

.dumps(obj) ：将对象序列化为字符串

.loads(s): 将字符串反序列化为对象，对象保持序列化之前数据类型

序列化对象到文件

.dump(obj,file)

import pickle
dic = {"name":"tome","age":10}
ll = pickle.dumps(dic)
ll
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00tomeq\x02X\x03\x00\x00\x00ageq\x03K\nu.'
pickle.loads(ll)
{'name': 'tome', 'age': 10}
pickle.dump(dic,open('dic','wb'))

p = pickle.load(open('dic','rb'))
p
{'name': 'tome', 'age': 10}
type(p)

pickle.load(open('dic','rb'))
{'name': 'tome', 'age': 10}

.load(file)

返回之前序列化的对象，并且保留被序列化对象完整的实际的内容

shelve

数据库

orm

并发编程

概述

非并发

程序由单个步骤序列构成

包含独立子任务的程序执行性能低

并发

异步，高效

分解子任务、简化流程与逻辑

进程 process

一个程序的执行实例

每个进程都有自己的地址空间、内存、数据栈及辅助数据

线程 thread

同一进程内，可被并行激活的控制流

共享相同上下文（空间地址、数据结构）

特点

便于信息共享和通信

线程访问顺序差异会导致结果不一致（条件 race condition）

python GIL全局解释器锁

循环语句

while 循环

一般格式

关键字

pass / ...

占位符

else

break

continue

for ...in 遍历

在某一个序列或者集合中将每一个元素按顺序拿出来做一系列的操作

表达式取出来的值指向变量引用，就是for 后面是临时变量，in 后面是序列

遍历索引例子

>>> stu = ['jerry','tom','lily']

>>> for i,s in enumerate(stu):

... print (i,s)

...

0 jerry

1 tom

2 lily

enumerate 第一位是索引，第二位为遍历元素

正则

匹配

量词(字符，元字符，字符集如何重复)

？ 0或1次

* 0或多次

+ 1 或多次

特定

{n,m} 范围次数

{n} n次

{n,} 至少n次

{,m} 最多m次

批量备选

|yes|no

要是yes，要么是no

单字，预定义元字符

. 除\n外所有的字符

\d 数字，等同于[0-9]

\D 非数字，等同于[^0-9]

\s 空白字符 \t\n\r\f\v

\S 非空白字符 [^\t\n\r\f\v]

\w 字母数字字符 [a-zA-Z0-9_]

\W 非字母数字下划线 [^a-zA-Z0-9_]

贪婪与非贪婪

贪婪模式是默认的，尽量匹配最大范围结果

非贪婪

尽量匹配最小的范围结果

方法：量词后追加？譬如：.*?

例：

？？

*？

+？

边界匹配

^ 行首

$ 行尾

\b 单词边界

\B非单词边界

\A 输入开头

\Z 输入结尾

注：或因上下文差异有不同表现

[]

[A-Z] 意思是可选的范围列表

python正则

模块 import re

RegexObject 正则对象

模式对象，表现编译后的正则表达式（编译为字节码并缓存）

编译

re.compile(r'模式')

findall()

查找出所有的非重叠的匹配项

返回list

.match(string[,pos[,endpos]])

返回 MatchObject

仅从起始位置匹配

.search(string[,pos[,endpos]])

任意位置搜索

返回 MatchObject

finditer()

返回 MatchObject

查找所有匹配项，返回迭代器

MatchObject 匹配对象

表现被匹配的模式

.group()

参数为0 或空返回整个匹配

有参数是返回特定分组匹配细节

参数也可以是分组名称

例子

>>> import re
>>> text = 'Tom is 8 years old Jerry is 23 years old'
>>> pattern = re.compile(r'(\d+).*?(\d+)')
>>> pattern.search(text)
<_sre.SRE_Match object; span=(7, 31), match='8 years old Jerry is 23'>
>>> m = pattern.search(text)
>>> m.groups()
('8', '23')
>>> m.group()
'8 years old Jerry is 23'
>>> m.group(0)
'8 years old Jerry is 23'
>>> m.group(1)
'8'
>>> m.group(2)
'23'
>>> m.start(1)
7
>>> m.end(1)
8
>>> m.start(2)
29
>>> m.end(2)
31

groups()

返回包含所有子分组的元组

.start()

返回包含所有子分组的起始索引

.end()

返回包含所有子分组的终止索引

.span()

>>> m.span(1)
(7, 8)

返回包含所有子分组的起止索引

.groupdict()

以字典表的形式返回分组及结果

Group 编组

场景

从匹配模式中提取信息

re.search(r'(ab)+c','ababc')

<_sre.SRE_Match object; span=(0, 5), match='ababc'>

创建子正则以应用量词

限制备选项范围

>>> re.search(r'Centre|er','Centre')
<_sre.SRE_Match object; span=(0, 6), match='Centre'>
>>> re.search(r'Centre|er','Center')
<_sre.SRE_Match object; span=(4, 6), match='er'>
>>> re.search(r'(Cent)re|er','Center')
<_sre.SRE_Match object; span=(4, 6), match='er'>
>>> re.search(r'Cent(re|er)','Center')
<_sre.SRE_Match object; span=(0, 6), match='Center'>
>>> re.search(r'Cent(re|er)','Centre')
<_sre.SRE_Match object; span=(0, 6), match='Centre'>

重用正则模式中提取的内容

>>> re.search(r'(\w+) \1','hello world world')
<_sre.SRE_Match object; span=(6, 17), match='world world'>

斜杠1 是重用第一个分组

>>> re.search(r'(\w+) \1 \1','hello world world world')
<_sre.SRE_Match object; span=(6, 23), match='world world world'>

声明

(模式)

(?P<name>模式) 编组命名

>>> pattern = re.compile(r'(?P<name>\w+):(?P<score>\d+)')
>>> m = pattern.search(text)
>>> m.groups()
('Tom', '98')
>>> m.group('name')
'Tom'
>>> m.group('score')
'98'
>>> m.group()
'Tom:98'
>>> m.group(1)
'Tom'

>>> import re
>>> text = "Tom:98"

引用

匹配对象内 m.group('name')

模式内（?P=name)

表现内 \g<name>

>>> re.sub(r'\*(.*?)*\*','<strong>\g<1></strong>',text)
'Beautiful is <strong></strong> than ugly'

应用

字符串操作

.split(string,maxsplit=0)

分割字符串

.sub(rep1,string,count=0)

替换字符串

>>> ords = 'ORD000\nORD001\nORD002'
>>> re.sub(r'\d+','-',ords)
'ORD-\nORD-\nORD-'

>>> re.sub(r'([A-Z]+)(\d+)','\g<2>-\g<1>',ords)
'000-ORD\n001-ORD\n002-ORD'

subn ,替换，并返回替换的数量

>>> re.subn(r'([A-Z]+)(\d+)','\g<2>-\g<1>',ords)
('000-ORD\n001-ORD\n002-ORD', 3)

编译标记

改变正则的默认行为

re.I 忽略大小写

re.M 匹配多行

re.S 指定 "."匹配所有字符，包括\n

模块级别操作

re.purge() 清除缓存

re.escape() 逃逸字符

>>> re.findall(re.escape('^'),'^python^')
['^', '^']

去掉字符的原意

python语言概述

历史

作者

语言诞生：1989

设计哲学与定位

优雅

明确

简单

优势

开发效率

可移植性

丰富的库

软件质量

劣势

运行效率

运行时候逐行解释

运行效率可以由硬件来弥补

能做什么？

系统编程

GUI

网络编程

Web编程

数据库变成

大数据

。。。

编程特性

面向过程

面向对象

函数式编程

数据类型

程序概念层级（python程序是怎样构成的）

表达式(最小构成单位)：创建及处理对象

score = 77

语句包含表达式

if score>10：也可以有子语句

if score < 80:
... print ("良")

包和模块

包相当于操作系统中的文件夹，模块相当于文件

.py 脚本文件是模块，模块里面包含很多表达式及语句，甚至是程序逻辑单元，函数或者是类里面

程序

程序物理文件存储在硬盘，运行时候在系统内存中运行

变量与存储

创建变量的目的：是反复引用其中的某一个对象（值）

变量：对象别名

命名规则

字母/数字/下划线

只能以字母或下划线开头

不能包含空格

避免python关键字或函数名, 以print(内置函数) 为例

简短并且具有描述性

区分大小写

变量生成：第一次赋值时生成

类型

描述数据存储形态及支持操作

python是强类型具有动态类型（静态类型语言，声明变量时就确定数据类型，再存数值的时候不能超过类型范围，或者强转的时候才可以）的语言

动态类型，到底是什么类型不是由变量类决定，而是由实际存储的对象来决定

python 动态类型

类型取决于关联对象

变量本身没有类型约束

垃圾回收机制

python自动释放未引用的对象

通过对象引用技术器统计引用

存储

共享引用

多个变量引用同一个对象

内存地址相同

a = 20 ，b = 20, id(a) = id(b)

对象本身带有类型描述及引用计数器

变量名指向实际对象，变量本身无类型

对象有类型，存储在内存区域

内置核心数据类型

程序编写更容易

比自定义的类型，效率更高

python自带的，也是python的一个特性

数值类型

整型int|浮点型float

字面值

0o八进制

0x十六进制

0b二进制

十进制

>>> 8
8
>>> 90
90
>>> 999999
999999
>>> 999999999999999999999999999999999999
999999999999999999999999999999999999
>>> -10
-10
>>> 3.14
3.14
>>> -999
-999
>>> 3.14e5 科学计数法
314000.0

转回来 https://blog.csdn.net/u012063703/article/details/42609833

数学运算符

+ 加

- 减

* 乘

/ 除

21/7 = 3.0

**计算次方

//整除

21//7 =3

%取余

22/7 =1

整型精度无限制，能够存储多大的整型是由硬件结构决定的，就是有多大的内存或者cpu的运算范围来决定,可以处理非常大的数字

常用函数

int("字面值",进制) 强转为整型

int("1101",2) = 13

float()

bin()二进制

hex()十六进制

Oct(八进制)

round()

>>> round(3.12)

3

>>> round(3.98)

4

pow(2,3)

>>> pow(3,2)

9

bool()

>>> bool(True)

True

>>> bool(1)

True

>>> bool(-1)

True

>>> bool(0)

False

>>> bool(False)

False

>>> bool([])

False

>>> bool("")

False

真值测试

等同于False

0，0.0，None，空对象，空序列，空映射

工具模块

math

floor() 总是取小的值

math.floor(3.99)

==》3

math.floor(-3.99)

== 》 -4

trunc() 总是往0 的方向

>>> math.trunc(3.14)

3

>>> math.trunc(-3.14)

-3

ceil()总是往大的取

>>> math.ceil(3.14)

4

>>> math.ceil(-3.14)

-3

pi

>>> math.pi

3.141592653589793

sqrt()开平方

>>> math.sqrt(4)

2.0

decimal

Decimal

>>> import decimal

>>> decimal.Decimal('0.1')+decimal.Decimal('0.1')+decimal.Decimal('0.1')-decimal.Decimal('0.3')

Decimal('0.0')

>>> dd = decimal.Decimal('0.1')+decimal.Decimal('0.1')+decimal.Decimal('0.1')-decimal.Decimal('0.3')

>>> dd

Decimal('0.0')

>>> print (dd)

0.0

这个方法用的时候要传字符串，不能直接传数字，传数值就和下面的0.1加后再减的结果一样

是因计算机内部的二进制存储的机制上就没办法存储某些特定的数值

>>> 0.1+0.1+0.1-0.3

5.551115123125783e-17

浮点型存储有缺陷，所以需要引用此类解决精度计算的问题

布尔型的本质

True 是1，False 是0

序列

可变

列表

可包含任意对象的有序集合

可通过下表索引（位置偏移）来访问某个元素

可变长度，可任意嵌套，异质

支持原位改变

对象引用数组

对象--》引用--》存储对象

排序列表

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

>>> l

[18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 100, 98, 987, 1, 0]

>>> l.sort()

>>> l

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 98, 100, 987]

改变的是原序列

reverse默认是正序，等于True的话是倒序排列

sorted(l)

返回一个新序列

改变某个元素值 s[i]=x

改变特定范围内元素值

s[i:j] = t

t 应该是一个可迭代对象

>>> s = list(range(1,11))

>>> s

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

>>> s[:3]= [99]

>>> s

[99, 4, 5, 6, 7, 8, 9, 10]

>>> s[:3] = [1,2,3,4,5]

>>> s

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

>>> s[:3] = [11,22,33,]

>>> s

[11, 22, 33, 4, 5, 6, 7, 8, 9, 10]

s[i:j:k] = t

>>> l[::2] = [8,8,8,8,8]

>>>

>>> l

[8, 1, 8, 3, 8, 5, 8, 7, 8, 9]

删除元素

del s[i:j:k]

>>> l

[8, 1, 8, 3, 8, 5, 8, 7, 8, 9]

>>> del l[-1]

>>> l

[8, 1, 8, 3, 8, 5, 8, 7, 8]

>>> del l[:3]

>>> l

[3, 8, 5, 8, 7, 8]

>>> del l[::2]

>>> l

[8, 8, 8]

>>> l

[8, 8, 8]

>>> l[:2] = []

>>> l

[8]

类似删除

ss.remove

删除第一个匹配值

>>> ll = [0, 2,1,2, 3, 4, 5, 6, 7, 8, 9, 2, 2, 2, 2]

>>> ll.remove(2)

>>> ll

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

s.clear() 清空序列

>>> ll.clear()

>>> ll

[]

s.insert(x) 插入元素

>>> l[2:2] = [98]

>>> l

[0, 1, 98, 100, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

>>> l.insert(2,987)

>>> l

[0, 1, 987, 98, 100, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

翻转序列 s.reverse()

翻转的是序列本身

复制

s.copy()

传递引用的副本

s[:]

传递引用的副本

s.append(a) 追加元素

追加的括号里内容被认为是一个对象

s.extend(b) 扩展序列

追加一个序列

不可变（不支持原位改变的意思）

tuple 元祖

可包含任意对象的有序集合

通过下标索引（位置偏移）访问元素

固定长度，可任意嵌套，异质是容纳不同类型的元素的意思

对应引用数组

交换变量

>>> a, b = b, a
>>> a
10
>>> b
5

range范围

不支持原位改变

>>> r = range(5)

>>>

>>> r

range(0, 5)

>>> type(r)

>>> r[0]

0

>>> r[0] =9

Traceback (most recent call last):

File "<input>", line 1, in <module>

TypeError: 'range' object does not support item assignment

>>> r[:]

range(0, 5)

>>> min(r)

0

>>> max(r)

4

>>> len(r)

5

声明

range(5)

range(3,10)

range(1,19,2)

参数分别为起始，终止，步长

文本序列 str 字符串,不可变序列

字面值

"字符串"

'字符串'

"""声明多行字符串"""

转义符

\n 换行

\t Tab 键

\\ \

\a 响铃

\b 退格

\r 回车

\'

\"

\？

\0 空字符

\ooo 以八进制数声明字符

\xhh 以十六进制声明字符

r"\a\c\b" 原始字符串，忽略转义符

常用操作

str(obj)

print ("姓名:"+name ,"年龄:"+str(age),"工作:"+job)

"姓名:{},年龄:{},工作:{}".format(name,age,job)

"姓名:{0},年龄:{1},工作:{2}',部门:{dep}".format(name,age,job,dep="dev")

str.replace(old,new,count)count 是可选参数，是前几个的长度

>>> s = "a"*5

>>> s

'aaaaa'

>>> s.replace("a","d")

'ddddd'

>>> s

'aaaaa'

>>> s = s.replace("a","d")

>>> s

'ddddd'

>>> s.replace("d","e",2)

'eeddd'

>>> s.replace("d","e",3)

'eeedd'

str.capitalize()首字母大写

>>> ss = "hello"

>>> ss.capitalize()

'Hello'

str.upper()字母转换成大写

>>> ss.upper()

'HELLO'

str.lower() 字母转换成小写

>>> ss.lower()

'hello'

ss.startswith("he")以什么开头

ss = "hello" >>> ss.startswith("je")

False

>>> ss.startswith("he")

True

ss.endswith("o")

以什么结尾

>>> ss.endswith("o")

True

str.isnumeric()判断当前字符串是否是数字

>>> "321".isnumeric()

True

str.isalpha()判断当前字符串是否是字母

>>> "321".isalpha()

False

str.split(".")以点分割str字符串

":".join(str)用冒号拼接str

str.format()格式化字符串

>>> "部门是{dep}".format(dep="flask")

'部门是flask'

花括号占位符里面可以写下标索引，也可以写一个变量，但是变量在传值的时候要明确指定

>>> "{:f},{:.2f},{:06.2f}".format(3.14159,3.14159,3.14159)最后一个数不足六位就补零

'3.141590,3.14,003.14'

>>> "{:f},{:.2f},{:6.2f}".format(3.14159,3.14159,3.14159)最后一个数，不足六位补空格

'3.141590,3.14, 3.14'

>>> "{:>10}={:<10}".format("alisa","beauty")左对齐，右对齐占10位

' alisa=beauty '

>>> "{:>10}={:^10}".format("alisa","beauty")

' alisa= beauty '

通用操作

判断元素是否在序列之内

x in 序列

x not in 序列

连接两个序列

s1+s2

生成一个新序列

重复序列元素

s*n

下标获取元素

scores = [33, 44, 88, 99, 100] ==> scores[0]

访问指定索引范围

x[i:j]

取到第一个索引到第二个索引的前一个值

按步长访问指定索引范围

[::2]

获取列表长度

len()

min()

需要元素可比较的情况

max()

sum()

找到一个元素第一次出现的索引

li.index(元素)

统计一个元素出现的次数

li.count(元素)

集合

映射

dict字典表

特性

通过键（key)，而非位置偏移(下标索引)访问数据

包含任意对象的无序集合

可变长度，异质，可任意嵌套

属“可变映射”分类

对象引用表(Hash Table)

声明

{}空字典表

{key:value}

dict(key=value)

dict([(key,value),(key,value)])

dict.fromkeys([key1,key2,...])

常用操作

d.copy()

复制副本

d.clear()

清除数据项

d.update(newdict)

newdict更新合并到d，修改原有d，不返回新值

del d.["key"]

删除某一个元素

d.pop("key")

返回删除的key 对应的value，如果key写错了，预防报错可以 d.pop("key",None)

b.popitem()

弹出键值对

传递函数引用

>>> def say_hello():
... print ("say hello")
...
>>> person= {“name":"lily","say":say_hello} say_hello不能直接写()，只是传递引用，写上括号的意思就是执行这个函数，并将返回的值放在say 对应的value
>>> person["say"]
<function say_hello at 0x10fd870d0>
>>> person[“say"]()
say hello
>>> type(say_hello)
<class ‘function'>

程序单元类型

其他

类型对象

type(obj)

>>> type(7)
<class 'int'> <---类型对象：数据类型描述的一个类型对象

空对象 None (什么都没有)

>>> l = [2, 3, 22, 33, 41, 199, 839, 4433,500,2000,231]
>>> aa = l.sort()
>>> aa
>>> l
[2, 3, 22, 33, 41, 199, 231, 500, 839, 2000, 4433]
>>> aa is None
True

布尔 bool

True

>>> type(5>3)
<class 'bool'>
>>> type(5<3)
<class 'bool'>
>>> 5>3
True
>>> 5<3
False

False

文件

声明open('路径','模式',encoding='编码') ANSI默认对应gbk

路径

"c:\\path\\data.txt"

r:"c:\path\data.txt"

'data.txt'

模式

文本

'r'

读

'w'

写

'rw'

读写

'a'

追加

二进制

'*b'

f = open("test.txt",'r')

>>> f.read()

'ehllwlw'

>>> f.seek(0)

0

import os os.getcwd() 获取工作目录

os.chdir("修改目录") 修改工作目录为

操作

.seek(n)

移动指针位置

.close()

关闭文件操作

.readlines()

读取

.readline()

读取下一行

.read(n)加参是读取指定字符或者是指定字节的内容

一次性读取所有文本

.readlines()

读取行到列表

for line in f:遍历迭代

写入

write() 写入字符串

f.flush()

将内存里面缓存的操作映射到最终的结果文件上

不关闭文件的情况下输出缓存到磁盘

f.writelines(ll)

一次写入列表中的多个元素

迭代与推导

迭代

概念

可迭代对象

物理存储的序列

list,tuple,file

或在迭代工具上下文中某个时刻产生

generator生成器

迭代工具/上下文 for ,map ,推导

可迭代工具应用到可迭代对象上，返回一个迭代器对象

支持iter()调用的对象

迭代器

iter()函数返回的，支持next(I)函数的对象

迭代协议

过程

迭代工具(for)将可迭代对象传递到python内置的函数iter()里面获取迭代器

iter()函数返回的迭代器对象具有next()方法

手动迭代

scores = [98,89,67,92,12,36,69]

i = iter(scores)

>>> while True:

... try:

... s = next(i)

... except StopIteration:

... break

... print (s)

...

98

89

67

92

12

36

69

>>> students = ['tom','jerry','mike']

>>> I = iter(students)

>>> s = next(I)

>>> s.upper()

'TOM'

>>> s = I.__next__()

>>> s.upper()

'JERRY'

常见迭代类型

dict_keys

dict_values

dict_items

tuple

list

file

文件本身就是一个可迭代对象，并且已经自动实现iter()返回迭代器对象的过程

>>> f = open('data.txt','r',encoding='utf-8')

>>> next(f)

'helloworld\n'

>>> next(f)

'alisa\n'

>>> next(f)

Traceback (most recent call last):

File "<input>", line 1, in <module>

StopIteration

推导

基本语法

[x for x in iterables]

map()

>>> rev = list(map(lambda a:a+2,scores))

>>> rev

[14, 5, 47, 69, 91]

>>> reu = [x+2 for x in scores]

>>> reu

[14, 5, 47, 69, 91]

filter()

>>> scores = (12,3,45,67,89,67,45)

>>> { s for s in scores}

{89, 67, 3, 12, 45}

[]返回列表，{}返回set() 集合，也就是元素去重，（）返回生成器对象，也是可以迭代的

[12, 3, 45, 67, 89, 67, 45]

>>> list(filter(lambda s:s>=45,scores))

[45, 67, 89, 67, 45]

>>> [s for s in scores if s>=45]

[45, 67, 89, 67, 45]

>>> [s+2 for s in scores if s>=45]

[47, 69, 91, 69, 47]

reduce（）

reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：

1	`reduce(f, [1,` `3,` `5,` `7,` `9],` `100)`

结果将变为125，因为第一轮计算是：

计算初始值和第一个元素：f(100, 1)，结果为101。

面向对象编程oop

编程方法

面向过程

以过程为中心

面向对象

以事物对象为中心

函数式编程

将计算机运算视数学函数运算

基本步骤

分析对象 ooa

有什么？特征

能做什么？行为

关系

聚合

复合

写代码表现对象 ood

类

字段：特征

方法：行为

。。。

实例化对象

面向对象分析与设计案例

人打电话

分析

人

特征

姓名

性别

年龄

....

行为

说话

走路

打电话

发短信

...

电话

特征

品牌型号

价格

颜色

行为

开机

关机

打电话

发送短信

类

概念

对对象抽象的结果

对象的蓝图，模版

实例工厂

类成员和实例成员区分开

构造函数与成员初始化

实例化实例成员的功能函数

__init__(self)

初始化类成员

__repr__(self)定义在控制台的表现形式

通常给开发人员看

__s tr__(self)定义在控制台的表现形式，控制台print的时候使用

通常给普通用户看的

方法

实例方法

定义：def method(self)

调用

instance.method()

实例的方法

类方法

@classmethod 装饰声明

和类关系密切的时候用

cls 关键字引用当前类

静态方法

@staticmethod 修饰

和类和实例关系都不是很密切的时候用

属性

本质是方法用于计算

@property 修饰

@property.setter 修饰赋值函数

关系

依赖

关联

"""类间关系"""

class Project:
def __init__(self,name,team,start_time):
self.name = name
self.team = team
self.start_time = start_time

def __repr__(self):
return f'<项目{self.name} >'

class Department:
def __init__(self,name,manager,tel):
self.name = name
self.manager = manager
self.tel = tel

def __repr__(self):
return f''

class Developer:
def __init__(self,department,name,skills):
self.department = department
self.name = name
self.skills = skills

def __repr__(self):
return f'< Developer:{self.name} >'

def develop_project(self,project):
print (f'{self.name} 正在开发{project}')

dep = Department('tom','领导','13698765678')

pro = Project('python','python项目组','2017')

dev = Developer(dep,'张丽莉','测试')

print (dev)
print (dev.department)
print (dev.department.manager)
print (dev.department.name)

"""类间关系"""

class Project:
def __init__(self,name,team,start_time):
self.name = name
self.team = team
self.start_time = start_time

def __repr__(self):
return f'<项目{self.name} >'

class Department:
def __init__(self,name,manager,tel):
self.name = name
self.manager = manager
self.tel = tel
self.employees = []

def __repr__(self):
return f''

class Developer:
def __init__(self,Department,name,skills):
self.Department = Department
self.name = name
self.skills = skills
self.Department.employees.append(self)

def __repr__(self):
return f'< Developer:{self.name} >'

def develop_project(self,project):
print (f'{self.name} 正在开发{project}')

dep = Department('tom','领导','13698765678')

pro = Project('python','python项目组','2017')

dev = Developer(dep,'张丽莉','测试')

print (dev)
print (dev.Department)
print (dev.Department.manager)
print (dev.Department.employees)

聚合

拥有

继承

封装

将我们抽象的对象使用类或者方法写出来，这个过程就叫做封装

继承

一个关系

多态

特征，状态

同一类型的不同实例对象，对同一消息作出不同的响应能力

class SubClass(BaseClass,..)

super 基类引用