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

1.1 计算机常识

计算机

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

硬件

CPU

内存

外部存储设备

= 外存

硬盘

U 盘

光盘

输入设备

鼠标

键盘

麦克风

声音

语音输入 audio input

扫描仪

文档

scanner

摄像头

视频

照相机

vs 摄像机

输出设备

显示器

文档

视频

打印机

通信设备

路由器

无线网卡

有线网卡

软件

概念：由程序和文档构成

系统软件

操作系统

vs 系统软件

人机交互的中间桥梁

Windows

Mac OS

Linux

应用软件

完成特定任务

排版

处理文档

处理图片

写程序

商城

BS 架构

浏览器

服务器

≠ CS 架构

客户端

服务器

编程语言

发号指令，执行特定任务

计算

调度

语音助手

Siri

Google Now

小娜

人类语言的歧义性

天冷了，能穿多少穿多少

音乐的简谱、五线谱

数学、物理化学

1. 机器语言

计算机能够理解的语言

0 vs 1

人类无法理解

2. 汇编语言

英文指令

指令和 CPU 息息相关

Intel

AMD

ARM

学习难度大

底层硬件驱动

优势

文件极小

速度极高

总结：应用

编写驱动

破解软件

3. 高级语言

C Java PHP

没有最好最坏，只有适应场景

while 循环 vs if ... else 判断

编译类：编辑器

文字翻译/笔译

运行效率高

修改麻烦一些

C C++ Java C#

解释类：解释器

同声传译/口译

更灵活

运行效率低一些

Python

二进制

电源开关的两种状态

逢二进一

数据存储与运算

数据单位

bit 比特位

1Byte = 8bit

1KB

1MB

1GB

1TB

...

编码

ASCII

一个字节

美国信息交换标准代码

128

UTF8

Unicode (or Universal Coded Character Set) Transformation Format – 8-bi

UTF16

1.2 Python 语言概述

历史

作者：Guido van Rossum

1956.01.31

语言诞生：1989

版本分支：3.5.2 vs 2.x

初学上 3.x

设计哲学与定位

用一种方法，最好是只有一种方法来做一件事情

There should be one-- and preferably only one --obvious way to do it.

优雅

明确

简单

import this

优势

开发效率

突出优势

可移植性

跨平台

丰富的库/扩展

Library extension

软件质量

代码少、出错少

劣势

运行效率

解释性

逐行解释源代码

vs 编译类

C

JAVA

C #

硬件弥补 vs 人力成本

事物的两面性

哪些公司在用？

大型公司和项目混用语言和架构

Youtube

知乎

果壳儿

能做什么？

系统编程

系统运维

vs C #

vs

研发

测试

系统管理

GUI

graphical user interface

窗体程序

图形用户界面

vs 命令行

跨平台

vs C # 仅 Win

cross platform

网络编程

收发邮件

传输 FTP

Web 爬虫

ASP

WEB 编程

网站后台开发

有很多成熟的框架

PHP

PHP: Hypertext Preprocessor

JSP

JavaServer Pages

ASP.NET

open source

数据库

关系型数据库

非关系型

MongoDB

NoSQL

Structured Query Language

大数据数据分析

数学及科学计算

快速产品原型

物联网

硬件编程

人工智能

机器学习

编程特性

C 面向过程

Java C# 面向对象

1. 面向过程

2. 面向对象

3. 函数式编程

λ 演算（lambda calculus）

Lisp

vs 指令式编程

Imperative programming

1.2 准备工作

安装与运行

Windows

官网下载

安装

有 64 executable 版本

32 位可装 32/64 系统

运行

REPL

read–eval–print loop

读取、计算、打印、循环

IDLE

Windows 命令提示符

运行脚本

Python c: > path file.py

Python/Py 都可不输入

代码编辑器

记事本

保存为 py 文件

编码选 utf8

Notepad++

SublimeText3

...

初学建议使用原始的编辑器

Linux

Ubantu

默认安装好

2.7.12

3.5.1

REPL

编辑器

Mac OS

默认安装好了，启动运行就好

以 Mac 10.11 为例

Python 2.7.10

输入 Python3

Python 3.5.2

REPL

Sublime Text

写代码保存 file.py

进入目录

Python3 file.py

Python 是怎样运行的

安装组件

1. 解释器

2. 支持的库

组件

算法

algorithm

数据结构

程序运行

开发人员编码

encode

解释器解释运行

字节码编译

.pyc

放在 __pycatch__ 文件

缓存加快运行

字节码改变再缓存

版本变化也会再编译

PVM 运行

Python Virtual Machine

Runtime 运行环境

图例

代码编写工具 IDE

编辑、编写、调错、编译、程序运行的开发环境

PyCharm

安装后左侧列表的项目

Pure Python

Django

Flask

Angular CLI

AngularJS

...

Web Starter Kit

轻量级 Sublime Text

优秀的 NotePad ++

Win 自带记事本太简陋

IDLE

编辑脚本文件

File > New

保存为 file.py

vs 记事本：有函数功能提示功能

Shell

>>>

简单的代码片段可直接测试编码

数学运算

REPL 环境

函数和类注意缩进

自动缩进

函数相当于成员变量

≠ iTerm

设置

字体

等宽字体

Courier new

字号

16

背景

IDLE Dark

1.4 数据类型

5 种数据类型：数字 vs 列表 vs 元组 vs 字符串 vs 字典

+ range

变量与存储

Why 变量

频繁操作：运算、打印

反复引用某一个值、对象

变量：对象命名

命名规则

包含：字母、数字、下环线

只能以字母或下划线开头

不能以数字开头

_Score

不能包含空格

vs _

以下划线分割

骆驼命名法已不推荐

避免关键字与函数名

print

if

简短且具有描述性

区分大小写

变量小写

语句小写

函数小写

类大写字母开头

创建：第一次赋值时生成

变量不赋值会抛出错误

由 Python 的动态类型决定的

类型 why

描述数据形式及支持操作

Python 动态类型特征

变量无类型约束

类型取决于关联对象

引号 '' 代表字符串数据类型

数字

存储

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

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

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

自动释放未被引用的对象

参见下面垃圾回收机制

共享引用：多变量引用同一对象

== 判断字面值时候相等

is 判断引用对象地址是否相同

vs id

≠ ID

0-255 Python 自动缓存

短字符串也可能被缓存

id(obj) 检测对象地址

垃圾回收机制

Python 自动释放未被引用的对象

通过对象引用计数器统计引用

内置核心数据类型

= 数据结构，C、C++

很多是自己来定义的

尽量使用内置 why

编写容易

扩展组件是基于内置数据类型开发实现的

效率更高

标准数据类型特殊需求 vs 反思需求

内置

基于内置的对象

1. 数值类型

数字

int 整形 | 浮点型 float

概念：通俗理解：整形是不带小数点的整数 vs 浮点型是带小数点的小数

字面值

十进制直接写

整形精度无限制

由硬件决定

CPU 运算范围

32 位 = 32 bit

64 位 = 64 bit

CPU一次处理数据的能力

64 位 CPU 可装 32 位系统

参见安装

负数

科学计数法 3.14e5

= 3.14x10^5

0o 八进制

0o177

127

Octal

0x 十六进制

0x9ff

2559

Hexa

Sexa

0b 二进制

0b1101

零 b

Binary

数学运算符

+ 加

- 减

* 乘

** 乘方

3**2**3 = 6561

9**3 = 729

/ 除

21 / 7 = 3.0

提高返回结果的精度

// 整除

21 // 7 = 3

22 // 7 = 3

% 取余/取模

...

用括号是好习惯

常用函数

内置函数

int('字面值', 进制) 强转为整形

10 + '30' 报错

10 + int('30')

二进制：int('1101', 2)

八进制

十六进制

float('字面值') 强转为浮点

“3.14” * 2

float('123')

= 123.0

float(123)

= 123.0

hex(number) 转为十六进制

hex(15)

= 0xf

hex('15')

TypeError

oct(number) 转为八进制

bin(number) 转为二进制

bin(10)

round(number) 四舍五入

round(22/7)

工具模块

math

import math

.floor

地板、向下

负数也向下

更小

.ceil

天花板、向上

.trunc

向 0 点靠近

只是四舍五入直接使用内置函数 round(3.14)

math.pi

math.sqrt

开平方

decimal

计算机二进制浮点型存储机制缺陷造成的

0.1 + 0.1 + 0.1 - 0.3

5.551115123125783e-17

金融、财务领域无法容忍

Decimal 类

Decimal('0.1')

以字符串传参

import decimal

decimal.Decimal('0.1') + ...

from decimal import Decimal

Decimal('0.1') + ...

x = Decimal('y')

print(x)

注意

浮点型存储是有缺陷的

传字符串

Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)

依旧不精确

布尔型的本质

True 的本质是 1

把 True 当 1 来用

True == 1

False 的本质是 0

False == 1

x = 3 + True

= 4

参见其他布尔型

序列

一系列的对象，形成集合或数据结构

5 种数据类型：数字 vs 列表 vs 元组 vs 字符串 vs 字典

可变

可变 vs 不可变：序列元素是否支持原位置被改变

3. list 列表 []

使用频率最高

1. 可包含任意对象的可变序列、有序集合

2. 通过下标序列（位置索引）来访问元素

3. 可变长度、异质、可任意嵌套

.append 方法

4. 支持原位改变

可变序列的特性

引用指向新的对象

score[0] = 85.2

5. 对象引用数组

x = [1, 2, 3]

x 指向引用，引用指向 [1, 2, 3]

ni

z = 2

== vs is

a is b

vs: l in list

a is not b

虽然有些多余

vs: l not in list

常用操作

排序

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

数字 vs 字母

按名字最后一个字母排序

people.sort(key = lambda x:x[-1])

.sort 默认从小到大

从大到小

score.sort(reverse = True)

sorted()

全局函数

不依附于某个对象

sorted(score)

参数：按第二个字母排序

sorted(people, key = lambda n:n[1])

初始化

x = [1, 2, 3]

name = list('优品课堂')

打印出现其他码

打印 name = ['u', 'p', 'k', 't']

range(5)

list(range(5))

[0, 1, 2, 3, 4]

不包含 5

通用操作

改变某个元素值

s[i] = x

改变特定范围内元素值

s[i:j] = t

s[:3] = 100 报错

s[:3] = [100] OK

数量不须匹配，一次可多个值

s[i:j:k] = t

数量须匹配

t 可迭代序列，单个数值不行

删除元素

del s[i]

del s[i:j]

del s[i:j:k]

del 等同于赋空值 []

1. 上面通过索引/位置来删除

2. 如果知道值，通过 remove 方法

s.remove(x)

序列 remove 方法，删除第一个匹配值

3. 清空序列

s.clear()

追加元素

s.append(x)

x.append([7, 8])

[7, 8] 当作一个元素追加到了列表 [5, 6, [7, 8]]

追加一个元素

vs s.extend(x)

扩展元素/序列

s.extend(x)

序列追加

独立元素

扩展一个序列

vs s.append(x)

插入元素

s.insert(i, x)

注意位置偏移 1

x[i, i] = [x]

弹出/检索并删除特定元素

s.pop([i])

不给位置，默认最后一个

反转序列

s.reverse()

() 括号不能省

省略括号

<built-in method reverse of list object at 0x7f16f6ea9688>

函数、函数的方法括号不能省

顺序反过来

y = s.reverse()

y 是空的

复制序列

s = l

共享引用

操作后相互影响

s = l.copy()

s = l[:]

vs s[i:i] 插入元素

共享引用

注意

改变特定范围内元素值

有范围须匹配序列 [ ]

有步长须匹配数量

不可变

4. tuple 元组 ( )

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

通过下标索引/位置偏移来访问元素

vs list

对象引用数组

不支持原位改变

注意

仅单个元素时后跟逗号 ,

name = ('Jerry', )

声明时，圆括号可省略

t2 = 1, 2, 3

转 list 到 tuple

tuple(list)

vs

访问嵌套元组

t[i][j]

常用操作

连接

+

重复

*

不支持

.append

.extend

重新赋值

特殊应用

赋值语句

a, b = 5, 10

等于 a = 5, b = 10

交换变量

a, b = b, a

list vs tuple

? 更类似数据行的概念

加上课程链接 links

range 范围

一般用于生成数据序列，以便执行特定次数的循环

for i in range(5): print('hello, world!' + str(i))

r = range(5) 不包含 5

range(0, 5)

type(r)

Win: <class range>

range(11, 21)

不像 list 和 tuple 那么直观

声明

range(i)

range(i, j)

range(i, j, step)

2. 文本序列 str 字符串

字母、数字，ASCII vs utf8

声明：引号

单引号

双引号

单双引号同时交叉使用

三引号

输出声明来查看换行符

print 打印结果查看输出结果

换行字符 vs 换行效果

字面值

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

RAW

转义字符

\n 换行

\t tab

\\ 双斜杠

\a 响铃

\b 退格

\r 回车

\'

\"

\? ?

\0 空字符

零

杠铃

\ooo 以八进制数声明字符

\xhh 以十六进制

为了呈现电脑无法呈现或键盘不方便输入的特殊符号

字节

text.encode() 转码

‘优品课堂’.encode()

text.decode() 解码

字节表示声音、视频

转码、解码在进阶课堂讲解

通用常用操作

序列的通用操作都支持

+

vs s = ‘优品’ ‘课堂’

中间有空格

print s ‘优品课堂’

本身常用操作

str(obj)

vs int float

改变字符

字符串拼接

‘x' + s[1:]

灵活度不高

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

str 不会变

赋值

变通

s = s.replace('a', 'b')

str.capitalize()

首字母大写

str.upper()

全为大写

str.lower()

str.starstwith('str')

str.endswirh('str')

str.isnumernic('str')

str.isalpha()

str.split()

str.join()

str.format()

name, age, job = 'Tom', 20, 'Dev'
print('姓名：'+name+'，年龄'+str(age)+',工作:'+job)

'姓名：{0}，年龄：{1}，工作：{2}'.format(name, age, job)

多次重复姓名：'姓名：{0}，年龄：{1}，工作：{2}，{1}'.format(name, age, job)

去掉1,2,3：'姓名：{}，年龄：{}，工作：{}'.format(name, age, job)

添加元素：'姓名：{0}，年龄：{1}，工作：{2}，部门：{department}'.format(name, age, job, department = 'tech')

更多格式

占位符

'{0:10} = {1:10}'.format('优品课堂', 123.4567)

对齐方式

'{0:>10} = {1:<10}'.format('优品课堂', 123.4567)

指定数字格式

'{},{},{}'.format(3.14159, 3.14159, 3.14159)

小数位数

'{:f},{:.2f},{:06.2f}'.format(3.14159, 3.14159, 3.14159)

序列的通用操作

列表、元组、字符串

判断元素是否在序列之内

x in s

x not in s

连接两个序列

s1 + s2

[1, 2, 3] + [99, 100]

重复序列元素

s * n

下标获取元素

s[i]

访问指定范围元素

s[i, j]

缝隙位置

最后一个位置没有

cities[5] 报错

cities[-1]

右侧有内容的时候前面的索引才会起作用

省略一个值

cities[:3]

起始位置省略

终止位置省略

全省略

所有元素

cities[0:-1]

按步长访问制定索引范围

s[i:j:k]

步长不写，默认步长为 1

cities[::2]

跳过一个

cities[::2]

跳过两个

获取序列长度

len(s)

序列元素个数

获取最小值

min(s)

可以比较的元素

获取最大值

max(s)

统计总和

sum(s)

检索某元素第一次出现位置下标

在不在使用 in 和 not in

s.index(x)

方法

cities.index('上海')

统计元素出现的次数

s.count(x)

元素数量

总结

通过函数完成

通过方法完成

注意

s[-3:-5:-1]

自后至前不给负步长报错

s[::-1]

可以倒序

映射

5. Dict字典表

特性

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

可包括任意对象的无序集合

有序的在扩展的包里面

创建顺序 vs 呈现顺序

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

属”可变映射“分类

对象引用表 Hash Table

声明

{} 空字典表

{key: value}

键加引号

dict(key, value)

dict 是函数，有圆括号；= 传入参数的形式（一次可多个）

函数转换

键参数不加字符串

默认转换为字符串

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

可转 list 为 dict

list 内的 list 含有两个元素

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

keys = ['name', 'age', 'job']

常用操作

键区分大小写

访问

data['key']

book['title']

输入键不对会报错

book.get('key', default)

book.get('title')

输入键不对不会报错

book.get('title', '未找到')

输入键不对返回“未找到”

key in data

’name' in emp

data.keys() 所有键

视图

可转为 list

data.values() 所有值

data.items() 所有项

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

len(data) 项的数目

data.copy() 拷贝

data.clear() 清楚数据项

data.update(data2) 更新合并数据

del data['key']

data.pop('key', default) 键删除、值返回

vs .get()

data.popitem()

按顺序弹出

函数都可以加进字典表

字典表内的函数名，不加括号

调用时加上括号

1.11 文件

声明：file = open(' 路径', '模式', encoding = '编码')

1. 路径

'c:\\path.data.txt'

标准字符串声明方式

r'c\path\data.txt'

声明为原始字符串

'data.txt'

相对路径

后两个可省略

2. 模式

文本

在 Python 3 统统当作 Unicode 字符串

'r'

read

可以省略

'w'

write

写模式默认替换

vs a/append

'rw'

+

'a'

append

追加

二进制

'*b'

声音、视频

操作

.read()

读取所有的信息

.seek() 移动指针位置

.close 关闭当前文件连接

垃圾回收机制

非必须，但是好习惯

读取

.read(N) 一次性读取所有文本或指定字符（字节）信息

f.read(4)

读取后指针移动

.readlines() 读取行到列表

[ ]

.readline() 读取下一行

for line in f: 遍历迭代

for line in f.readlines()

可迭代的对象能使用 for ... in 语句

后面有课程讲可迭代的原理

演示

编码

GBK vs utf8

UnicodeDecodeError

通过 encoding 参数指定编码方式

路径

import os

os.getcwd()

返回当前路径

os.chdir(r’f:\Demo')

改变目录

change

写入

.write() 写入字符串

打开文件没有内容

未使用 .close 之前是在内存中操作

vs .flush

要换行需写入 \n

.writelines()

多行文本放入列表

.flush() 不关闭文件的情况下输出缓存到磁盘/写出到文件

names = [name + '\n' for name in manes]

文件写模式默认替换

上下文语法，避免显式调用 close：
with open() as f:
for line in f:
print(line)

with as

for in

集合

？？
2016-11-05 23:32:18

程序单元类型

函数

模块

类

vs 函数的集合

其他

类型对象检查 type(obj)

动态类型

内置函数

直接写就行了

type(8)

int

Win: <class int>

Mac: <type int>

float

3.14

str

name = "Tom"

空对象 None

list = []

x = list.sort()

列表排序

方法叫 sort

只影响到原来的列表

x is None

x == None

is

注意：None 首字母大写

布尔型 bool

常量

True

False

注意：第一个字母大写

测试条件

5 < 3

表达式

表达式创建和处理对象

表达式是布尔类型的

type(5<3)

表达式创建的对象是布尔类型的

函数

bool(obj)

真值测试

等同于 False

0

0.0

None

'', (), []

{}

False 本身

if x:

if x 有值的话

不用 x =

尝试

bool(5 = 5.0)

True

Bool(5>3)

NameError: name 'Bool' is not defined

bool ≠ Bool

注意：bool 首字母小写

首字母大写的

True

False

None

首字母小写的

int

float

x = float(2)

x = 2.0

str

bool

参见数值类型布尔型本质

1.12 语句与流程控制

从本节开始使用 IDE

基础 + VIP 课程

语句分类

赋值

a = 5

创建对象引用

运行函数

import math

模块

函数 vs 方法

math.pi

math.pow(a, b)

= 函数调用

条件选择

选择执行

if

if x>3:
print('x 大于 3')

if ... else

其他课程

迭代语句

for 循环

for i in range(1, 6):
print(i**2)

= 遍历

循环

while

后面循环课程

函数

def

return

返回值

yield

返回生成器对象 Generators

概念

模块与命名空间
mode

import math 模块

from math xxxx 导入 xxx 成员

自学

概念 + 方法论
2016-11-05 21:16:02

模块 = .py 文件

模块也是一个命名空间，从而避免了变量名称冲突的问题

系统默认模块 = 内置函数

不 import 直接使用

from mode import argv

调用模块中的函数的时候就
不需要输入模块名称即可直接调用

from ... import ... as ...

名称替换

首选 import

增加程序可读性

避免名称冲突

类 class

面向对象

异常处理

try

except

finally

...

语法

强制缩进

4 个空格

首选

tab

≠ 4 个空格

嵌套代码块

增加可读性

其他

相对于 C

if 后不适用括号而是用冒号 :

代码块不使用花括号 {}

嵌套代码块继续缩进

PEP8

增强标准

= 代码风格指南

强制 vs 非强制

案例

展示语法和语句使用

while True:

txt = input('请输入一个数字：')

if txt == 'stop':

break

elif not txt.isdigit():

print('你说如的不是数字！！')

else:

num = int(txt)

if num < 20:

print('too small')

elif num > 20:

print('too big')

else:

print('恭喜你，你猜对了')

while True: 执行死循环

if ... elif ... else 条件选择

代码写在脚本文件里便于重用

代码缩进

代码测试通过

输入 stop 停止

VIP 课程
代码风格

不要空格和 tab 混用

一行不超过 79 字符，不强制

分屏 split

py 文件右键分屏

\ 换行不要求

= 前后空格

空行

def 函数前后空两行

赋值语句

机制

赋值创建对象引用

名称创建于首次赋值

名称引用前必须赋值

某些操作会执行隐式赋值

赋值

基本赋值

元组/列表赋值

两个值赋给两个变量

逗号分隔，实现两个变量赋值

不用显式声明为元组 () []

交换两个变量

a, b = b, a

本质 tuple 元组

序列赋值

0. 自动将序列某一元素分配给某一变量对象

字符串

a, b, c, d = '优品课堂'

数目不一致报错

解包赋值

.join

？？
2016-11-05 23:20:01

x, *y, z = '优品课堂'

扩展的序列解包

y 当作序列处理

*变量，获取剩余元素到 list

vs 后面讲参数传递

多目标赋值

a = b = 5

参见下面列表赋值

a, b = 5, 5

参数化赋值

a += 10

a = a + 10

extend 列表

append 加一个

VIP 课程

动态类型

[a, b, c] = (1, 2, 3)

也可以

省略括号

参见元组赋值

？？方括号、圆括号
2016-11-05 23:16:46

a = b = []

a.append b 也会变化

引用类型

改进：不想同时变化

分别赋值 a = [] b = []

a, b = [], []

深层次

列表复制

嵌套复制

？？
2016-11-05 23:17:33

a += [9, 10]

列表连接

列表加一个 .append

vs 多个时为嵌套序列

列表扩展 list.extend([3, 5, 7])

.entend 效率更高

顺序执行及输入输出

输入

控制台/交互提示符下的动态输入

input('提示信息：\n')

\n 换行符

默认 str

数字 float 转换以计算

输出

print(' 员工姓名：{}".format(name))

花样多一些

print('=' * 20)

多态的呈现方式

print(name, job, salary)

一行

默认空格分割

print(name, job, salary, sep = ' | ')

sep = '分隔符'

手动制定分隔符

print(name, end = ',')
print(job, end = ','
print(salary)

默认 end = '\n'

print 打三次，打一行

数字的格式化输出

print('薪资：{}'.format(salary)

原样

{0} {1} .. 0, 1 省略掉

print('薪资：{:.2f}'.format(salary)

:.2f

浮点、两位小数

print('薪资：{:,.2f}'.format(salary)

,

增加逗号千位分割

print('薪资：{:12,.2f}'.format(salary)

12

指定整体宽度，12

file 制定文件

??

参考官方文档

GUI 或 Web 程序有特定的输入、输出方式

VIP 课程
表达式

函数调用

len()

方法调用

list.append(99)

字面值

字符串 ''

数字 200

打印操作

参见上面，输入输出

空格

sep ='分隔符'

换行符

end = '终止符'

打印到文件

file = 指定文件

print(s, name, file = open('result.txt', 'w', encoding = 'utf8'))

流程控制
VIP 课程

if ... 语句

一般格式

if ... else

else 与 if 配对，缩进一样

elif

= else if

多重分支

没有 switch

字典表

operation = {
'add': '添加操作',
'update': '更新操作',
'del': '删除操作'
}

print(operation.get('add'))

多重条件判断

函数

数据库的增删改查

三元表达式

score = 75,
if score >= 60:
result = '及格'
else:
result = '不及格'

三元运算符

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

一行

前面：条件成立的情况

中间：条件

后面：条件不成立的情况

a = Y if X else Z

没有 switch

字典表变通

while 循环

一般格式

没有 do while

x = 'youpinketang'
while x:
print(x)
x = x[1:]

打印字符串，每次减少一个

x 有字符

break

跳出

continue

继续

调到头部

跳？？
2016-11-05 23:25:41

跳到循环头部继续下次循环

注释代码行

Win: Ctrl + /

pass

占位符

不然语法过不去

函数

def add():
pass

else

？？
2016-11-05 23:26:34

听到 14. 循环语句 20:00

for 循环

子主题

？？
2016-11-05 23:26:50

迭代

问题：哪些对象可以使用 for 循环，可以遍历？

可迭代的对象支持循环

iterator

语句

for x in

序列 []

元组 ()

字典表 {}

文件

for x in f:

迭代协议

支持 __next__() 方法

f.__next__()

next(f)

迭代工具 for... 推倒 ...map...

迭代器对象

已经实现

iter(f) is f

可迭代对象

列表

可简单可复杂

iter()-> __iter__ 用于生成迭代器

result = [x**2 for x in l]

内置可迭代对象

range()

map()

zip()

...

1.18 函数 Function

前情提要

功能

看书

# 定义函数
def read_book():
print 拿到一本书
print 看书
print 收起

# 使用函数
read_book()

1. def

define

2. 函数名

子主题

3. ()

参数可有可无

4. :

-> 缩进

5. 缩进

代码块

学习

def learning():
print 报名
print 学习
print 退出
learning()

细化

谁在学习？学习什么？从第几章第几节到？

def learning(name, course, start, end):
print 报名
print 学习
print 退出
learning()

定义参数 -> 使用参数

def learning(name, course, start, end):

print 报名

print 学习

print 退出

learning('Tom', 'Python 入门', 1, 3)

逻辑还没有用上

def learning(name, course, start, end):

print('{} 报名课程：《{}》'.format(name, course))

print('第 {} 节学习到第 {} 节'.format(start, end))

print('{} 学习结束'.format(name))

learning('Tom', 'Python 入门', 1, 3)

形参 vs 实参

关于参数，后面还有很多要讲的

返回值

def add_number(x, y):

result = x + y

print(result)

add_number(3, 5)

参数值并没有返回到外面

返回用关键字 return

def add_number(x, y):

result = x + y

return result

add_number(3, 5)

函数负责计算，值给你
怎么用是你的事

控制台上用

打印

显示到网页上

返回一个值给调用者

def add_number(x, y):

result = x + y

return result

print(add_number(3, 5) + 10)

无 return

print(add_number(3, 5))，= None

目的 why

最大化代码重用

DRY

Don't Reapeat Yourself

最小化代码冗余

过程分解

定义

def 方法名(参数列表...):
函数体

vs 方法体

def multiply(x, y): return x*y

print(multiply(5, 10))

return 直接写在冒号后面是可以的

方法的名称都可以省略掉：lambde 表达式

print(multiply('优品课堂\n', 10))

多态特性

字符串的特性

操作符/运算符重载

调用

函数名(实际参数)

变量作用域

Built-in

内置

最高

Global

全局

global xxx

封装
Enclosure

函数套函数

def func():

x = 100

def nested():

x = 99

print(x)

func()

结果：
100

里面为什么没打印呢？没有调用

def func():

x = 100

def nested():

x = 99

print(x)

nested()

print(x)

func()

结果：
99
100

先调用了自己，打印出来
再打印 100

嵌套后，二者不相干

def func():

x = 100

def nested():

nonlocal x

x = 99

print(x)

nested()

print(x)

func()

nonlocal xxx
会影响到外面，但还在函数内

Local

函数内

改变为全局：global x

x = 55

def func():

x = 99

print(x)

print('全局x：', x)

print('函数内：')

func()

全局x： 55

函数内：

99

x = 55

def func():

global x

x = 99

print(x)

print('全局x：', x)

print('函数内：')

func()

print('全局x：', x)

global x

全局x： 55

函数内：

99

全局x： 99

调用顺序：LEGB

注意函数名称

参数

一个声明，一个传递

传值方式

def change_number(x):

x += 10

x = 5

print('x = {}'.format(x))

change_number(x)

print('x = {}'.format(x))

结果：

x = 5

def change_number(x):

x += 10

return x

x = 5

print('x = {}'.format(x))

change_number(x)

print('x = {}'.format(x))

return x

结果：

x = 5

def change_number(x):

x += 10

return x

x = 5

print('x = {}'.format(x))

x = change_number(x)

print('x = {}'.format(x))

x = change_number(x)

x = 5

x = 15

传递

不可变类型，传递副本给函数，函数内操作不影响原始值

可变类型，传递地址引用，函数操作可能会影响原始值

跳坑：列表复制

l.copy()

l[:]

lambda

C# 也有

对比

正常函数

def 名称参数冒号逻辑/方法体 return

临时用一下 lambda 表达式

本质：定义匿名函数

f = lambda name: print(name)

f('tom')

f2 = lambda x, y: x + y

print(f2(10, 5))

不用 return

给匿名函数取名称

name = lambda

赋值给变量

f = lambda name: print('Hello', name)

f('Tom')

可以定义到表达式的内部

基本格式

lambda 参数1 ... : 函数

演示

代码步步升级

通过字典表模拟 switch

避免多个 if ... else

19. 函数高级工具

for .. in 列表推倒

l = list(range(1, 21))

res = [x+5 for x in l]

print(res)

最高效

map(函数, 可迭代对象)

l = list(range(1, 21))

def add_number(x):

return x+5

res = list(map(add_number, l))

print(res)

list 是需要的

map 灵活性最高

l = list(range(1, 21))

res = list(map((lambda n:n**2), l))

print(res)

推荐给 lambda 表达式加括号

filter(函数, 可迭代对象)

l = list(range(1, 21))

def even_number(x):

return x % 2 == 0

res = list(filter(even_number, l))

print(res)

可迭代的对象，不是列表

l = list(range(1, 21))

res = filter((lambda n: n % 2 == 0), l)

for i in res:

print(i, end = ' ')

20. 包与模块管理

20. 课程

高级课程才会讲：装饰器、元数据编程

补课

装饰器

概念

闭包

元数据编程

以前讲知识点

现在可以动手写、封装

模块

打印

函数，调用

def

调用：函数名称 + 括号() + 有参数传参数

入口文件

name

if __name_ == " __main__":
hello()

演示

.py 文件

models 模型

类

page = 5

def test():

print('models.test()')

views 视图

x = 99

def test():

print('views.test()')

代码重用，分门别类

引入

三个关键字

import

from

reload

指令

import

导入

变量

函数

类

math

models

函数

方法

不同的逻辑把功能组织在不同的模块

关注分离

单一职责

导入整个模块 vs from

from

from models import page

不用写 models，直接写 page，像当前页面一样

只关注想要的信息

from models import *

都过来

问题

重名

How

显式指定

from ... import ... as

起别名

import

推荐这样

reload

重新导入

importlib.reload(模块)

只能是模块

import

from ... import 无效

why

1. 代码重用

2. 命名空间

= 区分重名

3. 实现数据或服务共享

导入步骤

1. 找到模块文件

2. 编译为字节码

3. 运行模块文件

搜索范围

1. 程序主目录

内部的 math vs built-in math

2. 环境变量

3. 标准库

4. 扩展库

自己写的优先

包 package

文件夹 vs 包

__init__

1.20~1.23 面向对象
（编程）

前情

函数的高级知识点没有涉及

装饰器

元数据编程

转到：包与模块管理

语言的核心思想

C

C 为代表的面向对象

很多自己来做

贴合硬件；底层

C 核心点：数据结构和算法

两种情况

学的好

没学好

不能做网站

不能数据库

企业应用不是强项

Python

数据结构是设计好的

vs C

补课：百度百科

数据结构：计算机存储、组织数据方式

数据 + 关系 D + R

关系有函数实现

面向对象

Who

C#

JAVA

Python

类比

3D 打印

面向过程

房子改造

模块化设计

乐高造房子

面向对象核心思想

跳出 C 之坑

不是函数调用的问题

系统设计

面向过程

人围绕计算机转

按计算机的套路走

关键：算法、数据结构

面向对象

计算机围绕人的思维习惯

先抛开代码

代码为思想服务

关键字

类

封装

继承

多态

public

属性

字段

方法

尽量以符合人的思维习惯来分析问题，分解问题、解决问题

对象

万物皆对象

看不见摸不着的

想法

课程

对象特征

对象行为

思想比代码更重要

杯子打碎之面向对象

杯子

特征

材质

容量

行为

桌子

尺寸

高度

有没有抽屉

颜色

几条腿

腿是圆的方的

腿下面有没有垫子

桌面的厚度

材质

密度

刷油漆没有

油漆材质

油漆厚度

有没有桌布

桌腿空心还是实心

杯子属性

完整性

True

人

推杯子动作

地球

引力

乘车：下班坐公交车

公交车

特征

几路

起点

终点

多少个座位

我上车有没有座？

有没有空调

空调开没开

行为

停

开门

启动

鸣笛

开空调

乘客

特征

姓名

年龄

性别

身高

起点

终点

行为

人乘车

驾驶员

开车

没有最好，只有相对合理

对象关系

人开车

开车行为依赖一辆车

得有车

组成和复合的关系

公交车

车轮

车门

车窗

驾驶员和乘客有共性

前情

C++ 在 C 基础上加入面向对象

C# 在 C++ 基础上再改进，纯粹面向对象

Python 混合型

分析面型对象的方法

特征

有什么

行为

能做什么

对象关系

人派生乘客和驾驶员

车派生线路、开关门、加速、启动

代码为分析的结果服务

实例：图书管理系统

图书信息

标题

定价

作者

赋值语句

行为

添加图书

搜索图书

def search

图书入库

函数定义

封装

松散字段封装到一个字段里，定义到函数里

使用内置数据类型

列表

遍历不方便

数据不一致

字典表

类之前，封装的第一选择

def search_book(title):

print('搜索包含关键字{}的图书'.format(title))

book = {

'title' : 'Python 入门',

'price' : 39.00,

'author' : 'peter',

'search_book' : search_book

}

print(book['title'])

print(book.get('price', 0.0))

book.get('search_book')('Python')

字典表的逗号 ,

print(book.get('price', 0.0))
不抛异常，返回默认值

可以查询

括号

传参数

字典表让代码显得干净

提高代码重用性，降低代码冗余

步骤

1. 面向对象分析 OOA

2. 面向对象设计 OOD

3. 面向对象编程 OOP

码农

实现

1. 分析对象特征和行为

图书

出版社

作者

关系

聚合 Aggregation

复合/组合 Composition

不可分割

依赖 Dependency

继承/泛化 Generalization

人 | 驾驶员、乘客

UML 关系、UML 类图

分析人员画 UML 图 -> 开发人员

2. 写类定义对象模板/蓝图

目的把分析的对象编成代码

class Book

class Publisher

class Author

3. 创建对象/实例化，模拟过程

实例

类

首字母大写

无下划线，帕斯卡命名法

成员变量小写、下划线分割

无括号 ()

构造函数

出版时间

特征

封装

继承

代码重用

多继承会带来混乱

C# 取消了

多态

同一类型的不同实例

对咯的不同理解

实例

前情

class Person:

def __init__(self, name):

self.name = name

def __repr__(self):

return " "

def __str__(self):

return " "

repr 打印效果

import math

class Circle:

def __init__(self, radius):

self.radius = radius

def get_area(self):

return math.pi * self.radius ** 2

c = Circle(4.0)

print('Cicle Area is: {}'.format(c.get_area()))

操作是行为

import math

class Circle:

def __init__(self, radius):

self.radius = radius

@property

def area(self):

return math.pi * self.radius ** 2

c = Circle(4.0)

print('Cicle Area is: {}'.format(c.area))

属性本质是函数

不用调函数

像调字段

继承

基类

class Programmer(Emplyee):
def __init__(self, ,,,,):
super().init__(deparment, name, birthdate, salary)
self.specilaity = speciality
self.project = project

1.23 错误异常处理

错误类型

语法

SyntaxError

拼写有问题

语义

/0

ZeroDivisionError

逻辑

和代码无关，但结果不正确

在于设计

不抛异常

异常处理

处理逻辑错误

try 有可能出现异常代码

try:

x = 5 / 0

print(x)

except:

print('程序遇到错误')

except 异常类型 as 实例：捕获特定异常

try:

x = 5 / 2

print(x)

except ZeroDivisionError:

print('不能除0')

except:

print('其他错误')

else:

print('没有异常')

ZeroDivisionError:
是 Python 已经写好的类

except ZeroDivisionError as e:
print('不能除0', e)

finally 不论是否遇到异常均会执行

必须要释放的资源

else 未遇到异常时

raise 手动抛出异常

1.23 测试

import unittest

TDD

测试驱动开发

测试用例

虚拟环境配置/csv文件读取处理

现状

不同项目用到不同的包和库

用到解释器

项目不会影响到全局

How

PyCharm 创建时点设置 >

txt 文件读写

csv

Comma-Separated Values

tsv, tab

不用第三方库，内置函数就有

import csv

def csv_read():

with open('product.csv', encoding='utf8') as f:

reader = csv.reader(f)

headers = next(reader)

print(headers)

for row in reader:

print('编号：{}\t产品：{}\t单价：{}'.format(row[0], row[1], row[3]))

if __name__ == '__main__'

一行就是一个 list

namedtuple

JSON / Excel 数据文件处理

Python 操作 SQLite

1.28-1.29 爬虫

简介

what

爬取

整理成数据库

存储

对象

深网

看得见的内容

暗网

非直观

限制访问的内容

登陆后访问的内容

分析脚本

开放的数据接口

API

why

找内容填充网站、更新数据库

商业公司市场调研、数据分析

关注度

价格

可能开进阶版课程

基本的过程

网页

BS

浏览器、服务器

网址

url

后面讲 Flask 会讲 http

域名解析

请求方式

Request

主页

搜索关键字

提交数据

Get

简单直观

没有加密

post

表单加密

响应

Response

前端

HTML

内容

文件格式

.txt 另存

编码 UTF8

.rtf

.doc

.docx

html

HyperText Markup Language

超文本标记语言

index.html

<style>

<html>

标记语言

严格算不上编程语言

表明网页开头和结尾

<head>

元数据的声明

</head>

sublime

+ emmet 插件

前身 Zen coding

! + tab

子主题

<body>

网页的主题

一级标题

<p>优品课堂 www.codeclassroon.com</p>

段落

插入图片

以链接的方式的图片

or 互联网绝对的地址

与其他不同，自封闭

容器，界定范围

布局，加边框

链接

</body>

</html>

标签

有很多

知识点

h1~h6，普通文字相当于 h5

Sublime Text

右键 > 查看网页源文件

<div>

容器

href

链接

html

两个分支

head

title

body

h1

div

p

文字

超链接

创建项目 37:00

新建文件

index.html

创建目录 directory

需要第三方包

创建虚拟环境