Python3
2018-10-23 15:11:01 0 举报AI智能生成
python 入门到放弃
作者其他创作
大纲/内容
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
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 数据类型
程序概念层级/构成
表达式 创建处理对象
最小层级
score = 77
语句 包含表达式
判断
if score >= 60:
print('及格')
print('及格')
函数、类
包和模块
包是文件夹，定义一组模块或文件关系
程序包含若干包
vs 数据包
模块是文件 .py
程序
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)
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))
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 open() as f:
for line in f:
print(line)
with as
for in
集合
程序单元类型
函数
模块
类
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
语句 分类
赋值
a = 5
创建对象引用
运行函数
import math
模块
函数 vs 方法
math.pi
math.pow(a, b)
= 函数调用
条件选择
选择执行
if
if x>3:
print('x 大于 3')
print('x 大于 3')
if ... else
其他课程
迭代语句
for 循环
for i in range(1, 6):
print(i**2)
print(i**2)
= 遍历
循环
while
后面循环课程
函数
def
return
返回值
yield
返回生成器对象 Generators
概念
模块与命名空间
mode
mode
import math 模块
from math xxxx 导入 xxx 成员
自学
概念 + 方法论
模块 = .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
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)
也可以
省略括号
参见元组赋值
方括号、圆括号
a = b = []
a.append b 也会变化
引用类型
改进：不想同时变化
分别赋值 a = [] b = []
a, b = [], []
深层次
列表复制
嵌套复制
？？
2016-11-05 23:17:33
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)
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 程序有特定的输入、输出方式
表达式
函数调用
len()
方法调用
list.append(99)
字面值
字符串 ''
数字 200
打印操作
参见上面，输入输出
空格
sep ='分隔符'
换行符
end = '终止符'
打印到文件
file = 指定文件
print(s, name, file = open('result.txt', 'w', encoding = 'utf8'))
流程控制
if ... 语句
一般格式
if ... else
else 与 if 配对，缩进一样
elif
= else if
多重分支
没有 switch
字典表
operation = {
'add': '添加操作',
'update': '更新操作',
'del': '删除操作'
}
'add': '添加操作',
'update': '更新操作',
'del': '删除操作'
}
print(operation.get('add'))
多重条件判断
函数
数据库的增删改查
三元表达式
score = 75,
if score >= 60:
result = '及格'
else:
result = '不及格'
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:]
while x:
print(x)
x = x[1:]
打印字符串，每次减少一个
x 有字符
break
跳出
continue
继续
调到头部
跳？？
2016-11-05 23:25:41
2016-11-05 23:25:41
跳到循环头部继续下次循环
注释代码行
Win: Ctrl + /
pass
占位符
不然语法过不去
函数
def add():
pass
pass
else
？？
2016-11-05 23:26:34
2016-11-05 23:26:34
听到 14. 循环语句 20:00
for 循环
迭代
问题：哪些对象可以使用 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()
def read_book():
print 拿到一本书
print 看书
print 收起
# 使用函数
read_book()
1. def
define
2. 函数名
子主题
3. ()
参数可有可无
4. :
-> 缩进
5. 缩进
代码块
学习
def learning():
print 报名
print 学习
print 退出
learning()
print 报名
print 学习
print 退出
learning()
细化
def learning(name, course, start, end):
print 报名
print 学习
print 退出
learning()
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
Enclosure
函数套函数
def func():
x = 100
def nested():
x = 99
print(x)
print(x)
func()
结果：
100
100
里面为什么没打印呢？没调用呗
def func():
x = 100
def nested():
x = 99
print(x)
nested()
print(x)
func()
结果：
99
100
99
100
先调用了自己，打印出来
再打印 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
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
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()
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__
面向对象（编程）
前情
函数的高级知识点没有涉及
装饰器
元数据编程
转到：包与模块管理
语言的核心思想
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
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 已经写好的类
是 Python 已经写好的类
except ZeroDivisionError as e:
print('不能除0', 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
0 条评论
下一页
