@[T黄金沟通，行业分析职业规划商务礼仪简历面试职场通关
王伟超 邮箱：wangweichao@tedu.cn
冯华 邮箱 ；fenghua@tedu.cn
三大操作系统： 1、unix :Mac os、solaris
2 linux :Rethat centos ubuntu(教学环境版本)
3、windows
VMwear workstation （测试学习）软件 功能强大的桌面虚拟的计算机软件
下载 VMwear workstation 安装包。下载linux操作系统的镜像文件（纯净版）：ubuntu16.04
打开VMwear workstation，打开文件-新建虚拟机（组装电脑）。CD/DVD-插入光盘（.iso文件）-开启虚拟机-通电开机。 安装完后，安装其他软件
linux基础：终端用来输入linux命令
点击图片，点击搜索计算机-gname-terminal
根/：代表文件系统的起始位置
基本格式： 命令名 [选项]
linux 命令 pwd:显示当前所在的路径 ls ：显示目录的详细内容。 常用选项 ls -l 以列表或者是长格式显示文件目录详细信息。 ls -a :显示所有（包含隐藏的以.开头为隐藏）
路径：绝对路径：以根/开始的路径
相对路径：不以根/开始的路径
.代表当前目录。 …上一级目录 ~ 用户主目录
主目录/家目录 超级用户：rootcd ls
创建用户时会自动在/home下创建一个和用户名同名的目录为
此用户名主目录
cd: 切换目录（路径） cd 路径（/home/tarena/aid1809）
cd /home/tarena/
cd直接回车 ：回到主目录 cd -
TAB建自动补齐命令 ctrl l 或clear清除
mkdir:创建一个或者多个目录
格式： mkdir 目录名
常用选项-p :逐层创建目录 （如果中间目录不存在，直接创建）
touch 作用： 文件不存在-创建 ，文件存在-用系统时间更新文件修改时间
touch 文件名1 文件名2
技巧类 1自动补齐 TAB 自动补齐，2 翻出历史执行命令： 键盘上下键 3清屏ctrl l 4 终止命令ctrl c
5终端字体放大ctrl shift “+” 减小 ctrl -
rm : 删除文件、目录 rm -rf 文件名
-r 删除全部 -f 强制删除 -i 删除前 cat提示
文本编译器vi/vim
格式vi 文件名 vi的三种工作模式 浏览模式：启动时进入，不能编辑。
插入模式（a/i/o）编辑文本
命令行模式：（esc ）shift: 保存退出。
文本写入步骤
vi 文件名
按 a/i/o 编辑文本
按esc 保存按shift : 命令模式， wq 保存退出， q!直接退出
day02
LINUX命令
cp :复制文件/目录 cp 源文件 路径
cp -r 源目录 路径
cp *.txt /home/tarena/AID09
mv 剪切/重命名 mv 文件名 路径
mv 目录名 路径
重命名 ： mv 文件名1 文件名2
mv 目录名1 目录名2
cat ：查看文件内容（在终端输出） cat 文件名
创建压缩包
tar 打包并压缩 格式 tar -zcvf 压缩包名字.tar.gz 需要压缩的文件（目录）
-z 用gzip对包进行压缩 ， c创建包 v显示操作文件细节 f ： file
解压缩包
tar -zxvf 压缩包名字.tar.gz -C 路径
-C制定解压路径，不写默认当前路径
文件权限
查看：ls -l 文件名
最左侧一列：-代表类型（文件），d:代表目录 l: 代表链接
权限 r：读 w ：写 x :可执行 rwx 权限分组
第一组：文件所有者权限 第二组：同组用户对文件的权限
第三组：代表用户其他组权限
chmod :修改文件权限 方式一：给所有用户添加相关权限
给指定组用户修改权限（u go )
a:所有用户 u:所有者
g：同组用户 o:其他用户
方式二： 通过数字方式修改 r :4 w:2 x:1
r：读 w ：写 x :可执行
LINUX 高级命令
sudo :获取root用户的权限执行linux 命令
2. df -h 查看内存
3. top 任务管理器 q 退出
4.ps -aux 查看某个应用程序PID号
ps -aux/grep"firefox"
- kill -9 PID 号
3 python
应用领域
1系统运维、网络编程、人工智能、机器人、web开发、云计算、大数据、网络爬虫、游戏
优缺点
1面向对象
2开源、可移植
3简单易学易用，开发效率高
缺点：执行效率低
版本： python2.7 python3.5(3.7/3.8)
文件.py 功能在终端输出hello world
运行python3 hello.py
sublime代码编辑器
多行注释ctrl+/ ,
保存 ctrl +s
回退 ctrl+z
同时选中多个光标 ctrl+鼠标左键单击
进入：python3
退出： excit()、quit()、ctrl+d
数据类型
1数字类型
分类
1整型int
2浮点型float
整形的表示方式
1十进制
二进制
（0b开头）
十六进制（0x开头）
八进制（0o开头）
2字符串
4布尔类型true false
5空值：None
算数运算符
分类
±*/ %：取余数 **：幂运算 //: 地板除，只要整数
占位符（字符串格式化）
%变量名
%（变量一，变量二）
%s 占位： 字符串
%d 占位：整数
%f 占位：浮点数 %.2f(保留两位小数)
print (“电脑出拳:%s you出拳:%s 恭喜,你赢了” % (computer,you))
day03
if语句
作用 ： 让程序根据条件选择性的执行某条语句或某些语句
语法： if 真值表达式1：语句块 elif 真值表达式2 语句块； elif 真值表达式3 语句块；
elif可以有0个或一个或多个，且只能在if 语句后面
例子：
s=input("请输入一个整数: ")
n=int(s)
if n % 2==0:
print(“这个数是奇数”)
else:
print(“这个数是偶数”)
语句嵌套、
语句本身是有多条子句组成的一条复合语句
if语句可以嵌套到另一个复合语句的内部#
month=int (input("请输入月份（1-12）: "))
if 1<=month<=12:
例子： if 1<=month<=3:
print(“春季”)
elif month<=6:
print(“夏季”)
elif month<=9:
print(“秋季”)
else:
print(“冬季”)
else :
print(“你输入的有误”)
条件表达式
语法：
表达式1 if 真值表达式 else 表达式2
作用
根据真值表达式的取值（ture/false）来决定执行表达式1或者表达式2 并返回结果
s=int(input(“请输入一个数:”))
n=s if s>0 else -s
print(s,“的绝对值为:”,n) print不用缩进
pass语句
作用： 通常用来填充语法空白
pass又名空语句
语法： pass=
布尔运算;
运算符 not and or
非 与 或
布尔非操作：not
语法 not x
作用：对x进行布尔取非，如bool(x)为true,则返回false,否则为true
布尔与操作 and
语法：x and y
注释：xy 代表表达式
作用 优先返回假值对象，当x的布尔值为false 时，返回x 否则返回y
布尔或操作 or
语法： x or y
作用：优先返回真值对象，当x为true
正负号运算符
±（一元运算符，一个元素参加运算）
语法+ 表达式 - 表达式
字符串str
作用： 用来记录文字（文本）信息
表示方法：在非注释中凡是用引号括起来的部分都是字符串
‘单引号 ” 双引号 ‘’‘三单引号 “”“三双引号
空字符串的表示方法”" ‘’ ‘’’’’’ “”""""
非空字符串的字面值的表达方法
‘hello’ “hello”
三引号的字符串作用
三引号可以包含单引号和双引号
三引号换行会自动转换为换行符’\n’
隐式字符串字面拼接 print（s）
用转义序列代表特殊字符
字符串字面值中用字符反斜杠\ 后跟一些字符代表特殊的一个字符
转自格式
’ 代表一个单引号
" 代表一个双引号
\n 换行
\r 返回光标至行首
\f 换页
\t 水平制表符
\v 垂直制表符
\b 倒退
\0 空字符（字符值为0）
\0oo oo两位8进制表示字符
\xXX XX表示16进制
\UXXXX 四位16进制表示的Unicode 16字符
\UXXXXXXXX 8位16进制表示的Unicode 32 字符
ascii 编码表
man ascii 输回车
常用的ASCII 编码
字符 十进制 十六进制
‘0’ 48 030
‘A’ 65 041
‘a’ 97 0*61
序列的概念
字符串是序列(有序排列)
所有的序列都能用len(x) 函数求其长度
len(x) 函数
返回字符串中字符的个数
raw 字符串(原始字符串)
格式:
r’字符串内容’
r"字符串内容"
r’’‘字符串内容’’’
r""“字符串内容”""
作用:
让转义符号反斜杠 \ 无效
字符串的比较运算
字符串的运算:
运算符:
+ += * *=
- 加号运算符用于拼接字符串
x = “ABCD”
y = “123”
z = x + y
print(z) # ABCD123
+= 用于原字符串和右侧字符串拼接，再用变量绑定新的
字符串
- 运算符生成重复的字符串
*= 生成重复的字符串，再用原变量绑定
运算符：
< <= > >= == !=
比较规则：
依次按编码值进行两两字符比较，一但不同，则比较结束
并返回比较结果，当编码值和长度完全相同时，两个字符
串相同
in, not in 运算符
作用:
in 用于序列，字典，集合中，用于判断某个值是否存
在于容器中,如果存在则返回True,则返回False
not in 与 in 运算符的返回结果相反
格式:
对象 in 序列
day04
字符串的基本操作：
索引 index
python字符串是不可以改变的字符序列
索引取值语法：
字符串 [整数表达式]
说明：python 的序列都可以用索引来访问序列中的对象
python 序列的正向索引从0开始，第二个索引为1，最后一个索引为len(s)-1
python 序列的反向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，依次类推，第一个是-len(s)
切片
作用： 从字符串序列中取出相应的元素重新组成一个新的字符串
语法： 字符串[(开始索引b):(结束索引e)(:(步长s))]
注释:小括号 （）括起来的可省略
说明：开始索引是切片开始切下的位置，0代表一个元素，1代表第二个元素，-1代表最后一个元素…
结束索引是切片的终止索引（但不包含终止点）
步长是切片每次获取完当前元素后移动的方向和偏移位置
1没有步长，相当于步长为1
2、当步长为正整数时，取正向切片：
开始索引默认为0，结束索引默认为最后一个元素的下一个位置
3、当步长为负整数时取反向切片：
反向切片默认的起始位置为最后下一个元素，终止时的第一个元素的前一个位置
常用函数：
len(x) 返回字符串长度
max(x) 返回字符串编码值最大的字符
min(x) 返回字符串编码值最小的字符
字符串的编码转换函数：
ord© 返回一个字符c的unicode 编码值
chr(i) 返回i这个值所对应的字符
整数转换为字符串的函数：
bin(i) 将整数转换为二进制字符串 binary 二进制
oct(i) 将整数转换为八进制字符串
hex(i) 将整数转换为十六进制字符串
字符串构造函数：
str(obj) 将对象转换为字符串
字符串方法：
语法： 对象、方法名（方法传参）
“abc”.isalpha() # 语法是对的
123.isalpha() # 语法是错的
S.isdigit() 判断字符串中的字符是否全为数字
S.isalpha() 判断字符串是否全为英文字母
S.islower() 判断字符串所有字符是否全为小写英文字母
S.isupper() 判断字符串所有字符是否全为大写英文字母
S.isspace() 判断字符串是否全为空白字符
S.center(width[,fill]) 将原字符串居中，左右默认填充空格
S.count(sub[, start[,end]]) 获取一个字符串中子串的个数
S.find(sub[, start[,end]]) 获取字符串中子串sub的索引,失败返回-1
S.strip([chars]) 返回去掉左右char字符的字符串(默认char为空白字符)
S.lstrip([chars]) 返回去掉左侧char字符的字符串(默认char为空白字符)
S.rstrip([chars]) 返回去掉右侧char字符的字符串(默认char为空白字符)
S.upper() 生成将英文转换为大写的字符串
S.lower() 生成将英文转换为小写的字符串
S.replace(old, new[, count]) 将原字符串的old用new代替，生成一个新的字符串
S.startswith(prefix[, start[, end]]) 返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False,
S.endswith(suffix[, start[, end]]) 返回S是否是以suffix结尾，如果以suffix结尾返回True,否则返回False
以下是不常用的
S.title() 生成每个英文单词的首字母大写字符串
S.isnumeric() 判断字符串是否全为数字字符
字符串格式表达式：
作用：生成一定格式的字符串
运算符：
%
语法格式：
格式化字符 % 参数值
格式化字符 % （参数值1，参数值2，参数值3)
说明：格式化字符串中以%开头的字符为占位符，占位符的位置用参数值替换
格式化字符串中占位符类型码
占位符和类型码 含义
%s 字符串，使用str(x)函数转换
%d 字符串，使用str(x)函数转换
%c 整数转为单个字符
%d 十进制
%o 8进制
%x 十六进制（字符a-f小写）
%X 十六进制（字符A-F大写）
%e 指数型浮点数（e小写）
%E 指数型浮点数（E小写）
%f %F 浮点十进制
%g %G 十进制形式浮点或指数浮点自动转换
%% 等同于一个%字符
语法：
%［－＋０宽度，精度］ 类型码
－ 左对齐，（默认的是右对齐）
＋ 显示正号
０ 左侧空白位置补０
宽度 整个数据输入的宽度
精度 保留小数点多少位（默认为６位）
‘%10d’ % 123 # ’ 123’
循环语句：
while 语句
作用：根据一定条件，重复执行一条语句或多条语句
语法： while 真值表达式：
语句块1（此部分可能会重复执行多次）
else :
语句块2
说明：1先执行真值表达式，得到布尔值为True 或false
2 如果真值表达式的值为True ，则执行语句块1，然后再次返回到第一步，重复进行测试真值表达式的值
3 如果真值表达式的值为false ，则执行else 子句部分的语句块2
然后结束此while语句的执行
for 语句
day 05
while语句注意事项：
1要控制循环的真值表达式的值来防止死循环
2 通常用真值表达式内的循环变量来控制循环条件
3通常在语句内部改变循环变量
while 语句嵌套：
while 语句本身就是语句，和其他语句一样，可以嵌套到任何的复合语句中
while 真值表达式：
…
while 真值表达式2：
…
else：
…
…
else：
…
break 语句：
作用： 用于循环语句（while, for语句）中，用来终止当前循环语句的执行。
说明： 当break 语句执行后，此循环语句break之后的语句将不再执行
break 语句通常和if 语句组合使用
nreak 语句终止循环时，循环语句的else子句的语句不会执行
break 语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出循环嵌套的外重循环
break 语句只能在循环语句的内部使用
死循环：
死循环是指循环条件下一直成立的循环
死循环能通常用break语句来终止循环
死循环的else 子句永远不会执行
s=0
while True:
n=int(input("请输入 "))
if n<0:
break
if n>=0:
s+=n
print("和是 ",s)
for 语句
作用：用来遍历可迭代对象的数据元素
可迭代对象是指依次获取数据元素的对象
语法：
for 变量列表 in 可迭代对象：
语句块1（此句可能重复的语块）
else：
语句块2
说明： 当在循环体内用break终止循环时。else子句部分的语句不会执行
else子句可省略
range 函数：
range(stop) 用来生成0-stop 区间的整数，直到stop为止（不包含stop）
range(start,stop[,step]) 用来生成start-stop 区间内的整数，直到stop为止（不包含stop）每个整数间隔step
作用：用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）
for语句的嵌套：
continue 语句
作用：用于循环语句（while for）中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
说明： 1在while 语句中执行continue 语句，将会直接跳转while语句的
真值表达式处，重新判断循环条件
2在for 语句中执行continue 语句，将会从可迭代对象中取下一个数据绑定变量后再次进入循环
列表 list
列表是一种容器
列表是可以被改变的序列容器
创建列表的字面值
L=[] #L绑定一个新创建的空列表
创建非空列表的字面值
L=[1，2，3，4]
L=[‘上海’，‘北京’]
列表的构造函数
List() 创建一个空的列表，等同于[]
List(iterable) 用可迭代对象创建一个列表
列表的运算：
算术运算符+ += * *=
x=[1,2,3]
y=[4,5,6]
x+=y# x绑定x=[1,2,3,4,5,6]
day06
列表的比较运算：
运算符： < ＜＝ ＞ ＞＝ ＝＝ ！＝
说明：列表的比较规则和字符串的比较规则相同
列表要求每两个元素能依次进行比较，否则会出现类型错误
列表的ｉｎ和not in 运算符
判断一个值是否存在于列表中，如果存在则返回True
否则返回false
同字符串的in 运算类似
列表的索引操作：
索引取值语法：
x=列表[整数表达式]
用法： 等同于字符串的索引（同样分为正向索引和反向索引）
列表的索引赋值：
列表是可变序列，可以通过索引赋值改变列表中的元素
语法：
列表[整数表达式]=表达式
列表的切片操作：
列表[起始索引：终止索引：步长]
列表的切片取值是从原列表中取出想要的元素组成一个新的列表
切片的赋值：
作用：可以改变原列表的排列，可以插入和修改数据
语法：
列表[切片]=可迭代对象
说明： 切片赋值的赋值运算符（=）的右侧必须是一个可迭代对象
注意事项：对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供的元素的个数，一定要等于切片的段数
del语句
可以删除列表的元素
语法：
del 列表[整数表达式]
del 列表[切片]
l=[]
while True:
n=int(input('请输入一个正整数: '))
if n<0:
break
l+=[n]
print(‘l=’,l)
s=0
a=0
for x in l:
s+=x
a+=1
print("平均数为: ",s/a)
zuida=l[0]
i=2
while i<a:
x=l[i]
if x>zuida:
zuida=x
i+=1
print('最大数为: ',zuida)
python3常用于序列的函数：
len(x) 返回序列的长度
max(x) 返回序列的最大值
min(x) 返回序列的最小值
sun(x) 返回序列所有元素的和（元素必须是数字类型）
any(x) 真值测试，如果列表中的一个值为真值则返回true
all(x) 真值测试，如果列表中的所有值为真值则返回true
python3常用的方法（method）：
方法 意义
L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
L.insert(index, obj) 将某个元素插放到列表中指定的位置
L.count(x) 返回列表中元素的个数
L.remove(x) 从列表中删除第一次出现在列表中的值
L.copy() 复制此列表（只复制一层，不会复制深层对象)
L.append(x) 向列表中追加单个元素
L.extend(lst) 向列表追加另一个列表
L.clear() 清空列表,等同于 L[:] = []
L.sort(reverse=False) 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列了
L.reverse() 列表的反转，用来改变原列表的先后顺序
L.pop([index]) aa 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系
深拷贝（deep copy） 浅拷贝（shall copy）
浅拷贝 :是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
深拷贝：
import copy# 导入复制模块
列表与字符串比较：
列表和字符串都是序列，元素之间有先后顺序关系
列表和字符串有相同的操作：+ += * *=
字符串是不可改变的序列，列表是可变序列
字符串的每个元素只能存储字符，而列表可以存储任何的元素
列表和字符串都是可迭代对象
字符串的文本解析方法split 和join :
s.split(sep=none) 将字符串使用sep 作为分隔符分割字符串，返回分割后的字符串列表，当不给定sep 数时，用空白字符作为分隔符
s.join（iterable）用可迭代对象中的字符串生成一个中间用S进行分割的字符串
列表推导式：
是用可迭代对象创建列表表达式
作用 创建列表
语法：
[表达式 for 变量 in 可迭代对象]
或[表达式 for 变量 in 可迭代对象 if 真值表达式]
嵌套：
[表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 …]
day07
元组tuple :
元组是不可变的序列，同list 一样，元组是可以存储任意的数据的容器
元祖的表达方法：
用小括号() 括起来，每个元素括起来加逗号（，），区分单个对象还是元组
创建空元祖字面值:
t=() 创建一个空元组用t绑定
非空元组字面值：
t=200，
t=(20,)
type(x) 函数返回x类型
元组的构造函数：
tuple () 生成了一个空元组（）
tuple（iterable） 用可迭代对象生成立一个新的元组
元祖的运算：
- += * *= 规则和列表完全相同
索引和切片和列表相同
注意： 元组不支持索引赋值和切片赋值
序列相关的函数也能用于元组：
len(x), max(x) ,min(x ),sum(x),any(x),all(x)
字典dict
字典是可变容器，可以存储任意类型的数据
字典中的每个数据都用键（key）进行索引，而不像序列（str,
list ,tuple）可以用整数进行索引
字典中的数据没有先后顺序关系，字典的储存是无序的
字典中的数据以键（key）-值（value）对形式进行储存
字典的键不能重复，且只能用不可变类型作为字典的
创建字典字面值方式：
字典表示方式以{}括起来以冒号（：）分割键值对，各值对之间用逗号分隔开
创建空字典：
d={}
非空字典： d={‘姓名’：‘tarena’,‘年龄’：35}
d={‘one’:1, ‘two’:2}
创建空字典构造函数：
dict（） 生成一个空的字典等于{}
dict(iterable) 用可迭代对象创建一个列表
dict(**kwargs) 关键字传参形式生成一个字典
字典的键必须为不可变类型的值。
可变类型又4种： list（列表）， dict(字典)， set(集合)，
bytearray(字节数组)
字典基本操作
字典键索引 语法：
字典[键]
作用：用键获取字典的键对应的值
添加和修改字典的元素
语法：
字典[键]=值
字典[键]=表达式 添加或修改键的值
说明：键不存在时，创建键，并让键绑定对应的值
键存在修改键绑定的值
d = { }
while True:
n=input("请输入姓名: ")
if not n:
break
m=int(input(“请输入电话号码：”))
d[n]=m
print(d)
删除字典元素
del 语句
语法： del 字典[键]
字典的键判断：
in not in
可以用In 运算符判断一个键是否在于字典中，如果存在，则为True 否则为False
not 相反
d={1:‘春季有1，2，3月’,2:‘夏季有4，5，6月’,3:‘秋季有7，8，9月’,4:‘冬季有10,11,12月’}
print(d)
n=int(input('输入一个整数: '))
if n in d:
print(d[n])
else:
print(‘信息不存在’)
字典的迭代访问：
字典是可迭代对象。字典只能对键进行迭代访问
d={0:“yi”,1:‘er’,3:‘we’}
for a in d:
print(a,end=" ")
print(“键”,a,“值”,d[a])
可以用于字典的函数：
len(x) 返回字典键值得个数
Max（x）返回字典键值最大值
min(x) 返回字典键值最小值
sum(x) 返回字典所有键之和
any(x) 真值测试，只对键进行测试，只有有一个键为真，则为True
all(x) 真值测试，只对键进行测试，只有所有键为真，则为True
d={}
n=input(‘请输入: ‘)
for a in n:
if a not in d:
d[a]=1
else:
d[a]+=1
for b,c in d.items():
print(b,’:’,c,‘次’)
d={}
n=input('请输入: ')
for a in n:
if a not in d:
d[a]=1
else:
d[a]+=1
for b,c in d.items():
print(b,’:’,c,‘次’)
或
for m in d.items():
print(’%s:%d’ % m)
字典推导式：
是用可迭代对象来创建字典的表达式
语法：
{键表达式：值表达式for 变量 in 可迭代对象 [if 真值表达式]}注释：[]里面可省略
d={x:x**2 for x in range(10)}
print(d)
嵌套：
同列表嵌套
字典和列表：
都是可变的容器
索引方式不同，列表用整数索引，字典用键索引
列表存储有序，字典无序
字典插入，删除，修改速度比列表快
day 08
集合 set
集合 是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的储存结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代的（可以用for 语句遍历）
集合相当于只有键没有值的字典（键则是集合的数据）
创建集合构造函数
set（）创建一个空的集合对象（不能用{}来创建）
set （iterable）用可迭代对象来创建新的集合对象
例子：
s=set(range(1,5) # s={1,2,3,4}
注释： 非空集合{}括起来，内部分的元素用逗号隔开
字面值方式来创建非空集合
集合的运算：
交集& 并集| 补集- 对称补集^ 子集<
超级>
交集& 生成两个集合的交集
| 生成两个集合的并集
-
生成两个集合的补集 (互补)
^ 生成两个集合的对称补集
< 判断集合是另一个集合的子集
＞ 判断集合是另一个集合的超集
＝＝ ！＝ 判断相同集合和不同
ｉｎ 和not iｎ
集合字典优缺点：
in/notin 运算符的运算速度比较快
用于集合内建函数：
len(x)…
Python3 集合的方法
方法 意义
S.add(e) 在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e) 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e) 从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear() 清空集合内的所有元素
S.copy() 将集合进行一次浅拷贝
S.pop() 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2) 等同于 S l= s2, 用 S与s2得到的全集更新变量S
集合是可迭代对象
集合推导式：
结合推导式是用可迭代对象创建集合的表达式
语法：
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
集合推导式的嵌套：
同列表
推导式有： 三种（列表，字典，集合推导式）
可变的： 列表 集合
不可变：固定集合： frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用： 可以作为字典的键，还可以作为集合的值
构造函数 frozenset
frozenset（）创建一个空的固定集合
frozenset（iterable）用可迭代对象创建一个新的固定集合
运算：
交集& 并集| 补集- 对称补集^
阶段性总结：
数据类型：不可变 ： bool , int float, complex,str ,tuple,frozenset, bytes(字节串)
可变 ：list dict set bytearray(字节数组)
值：none FALSE TRUE
运算符：+ - * / // % ** > >= < <= == != in not in
not and all & | ^ +(正好) - （负号） is in not
表达式：
1 TRUE print（‘hello’）(函数调用)
l.pop(2)(方法调用也是表达式)
sum（[1,2,5]）
条件表达式： x if x>y else y
全部推导式：
列表，字典，集合 （三种）
语句：
表达式语句(表达式单独在一行可以形成表达式语句)：
print (‘hello’)
赋值语句：
a=100
a=b=c=200
x,y,z=1,2,3
del语句
if语句
while语句
for语句
break 语句
continue语句
pass 语句
内建函数：
len(x) ,max min any all sum
构造函数：
bool int float complex,str ,tuple,frozenset
list dict set
abs(x)
round(x,y)
pow(x,y)
bin (x)
oct(x)
hex(x)
chr(x)
ord(x)
range(star,stop,step)
基本输入输出函数
input print
id(x)返回内存地址 type(x) 返回类型
函数： function
函数是可以重复执行的语句块，可以重复调用并执行
函数得面向过程编程的最小单位
作用：
用于封装语句块。提高代码的重用性
定义用户级别的函数
提高代码可读性和易维护性
def 语句：
语法：
def 函数名（形参数表）：
语句块
作用： 创建一个函数，将语句块打包，用函数名绑定 ，用来调用
说明：1 函数名的命名规则与变量名相同（必须为标示符）
2 函数名是一个变量，它用来绑定函数
3 函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量，但不能对外部的变量赋值
4 语句部分不能为空，如果为空，需要填充pass语句
5 函数如果不需要传入参数，形参列表可以为空
函数调用：
语法： 函数名（实际调用传递参数）
说明：
函数调用是一个表达式
荣国函数内部乜有return 语句，函数执行完毕后返回none对象的引用
def say_hello():
print(‘hello world’)
print(‘hello chhina’)
print(‘hello wangba’)
say_hello() #调用第一次
say_hello() #调用第2次
say_hello() #调用第3次
return 语句
语法：
return [表达式]
[]可省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，同时返回一个对象的引用关系
说明：
1return 语句后跟的表达式可以省略，省略后相当于return none
2函数内部没有none（相当于在最后加了一条return语句）
day09
函数的传参（把数据给函数）
函数的形参（接收函数调用传过来的数据）
Python 函数的参数传递
传递方式：
1 位置传参
1.1 序列传参
2关键字传参
2.1字典关键字传参
位置传参：
实际参数（实参）的对应关系与形式参数（形参）的对应关系按位置来依次对应
说明：实参和形参通过位置进行传递和匹配
实参的个数必须与形参的个数相同
序列传参： 是指在函数调用过程中，用*（星号）将序列拆开，按位置进行传参的传递方式
说明：序列传参时，序列拆解的位置将与形参一一对应
关键字传参：
传参时，按着形参名称给形参赋值，实参和形参按名称进行匹配
说明：可以不按位置进行匹配
字典关键字传参：
是指实参为字典，将字典用** 拆解后进行关键字传参的传递方式
说明： 字典的键名和形参名必须一致
字典的键名必须为符合标识符命名规则的字符
字典的键名要在形参中存在
函数的综合传参
函数的传递方式在能确定形参唯一匹配到相应实参的情况下可以任意组合
函数的位置传参要优先于关键字传参
----------一下内容是函数的形参-------------
函数的缺省参数：
语法： def 函数名（形参名1=默认实参1，形参名2=默认实参2，形参名3=默认实参3，…）
作用：让函数的调用者少传递参数来达到默认的功能
说明：1缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右的所有参数都必须有缺省参数
2 缺省参数可以有0个，1个或多个，甚至全部都有缺省参数
函数的可变实参和不可变实参的传递
说明： 当一个可变对象通过实参传入函数内时，在函数内可以通过局部变量来操作可变对象（列表，字典，集合…）
函数形参的定义方式：
1位置形参
def 函数名（形参变量1，形参变量2，形参变量3…）
语句块
2星号元组形参
语法： def 函数名（*元组形参名）：
语句块
作用：收集多余的位置参数
说明： 元组形参一般命名为‘args’
元组形参一个函数只能有一个
3命名关键字形参
语法：def 函数名（,命名关键字形参1，命名关键字形参2…）：
语句块
或def 函数名（*srgs,命名关键字形参1，命名关键字形参2…）：
语句块
作用：强制所有的命名关键字形参都必须用关键字传参或字典关键字传参
4双星号形参
语法：
def 函数名（**字典形参名）：
语句块
作用： 收集多余的关键字传参
说明：
字典形参名一般命名为‘kwargs’
一个函数内字典形参最多只有一个
函数的参数说明：
位置形参，缺省参数，*元组形参，双星号字典形参可以混合使用
函数自左至右对的定义顺序：
位置形参 星号元组形参 命名关键字形参 双星号字典形参
函数的不定长参数：
有2中： 星号元组形参 ，双星号字典形参
用不定长参数可以接收任意的传参
全局变量和局部变量
局部变量：1定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
2局部变量只能用在函数内部使用
3局部变量在函数调用时才能创建，在函数调用之后会自动销毁
全局变量
定义在函数外部，模块内部的变量称为全局变量
全局变量所有的函数都可以直接访问（但函数内部不能直接赋值）说明;在函数内部赋值语句不会对全局变量造成影响
day10
globals()函数和locals函数
globals() 返回当前全局作用域内变量字典
locals（） 返回当前局部作用域内变量的字典
函数变量
函数名是变量，它在创建函数时绑定一个函数
一个函数0参传递
可以把一个函数给另一个函数，另一个函数的形参变量将绑定实参函数
函数可以作为另一个函数的返回值
解释执行器
def myadd(x,y):
return x+y
def mysub(x,y):
return x-y
def mymul(x,y):
return xy
def get_func(s):
if s==’+’ or s==‘加’:
return myadd
elif s==’-’ or s==‘减’:
return mysub
elif s==’’ or s==‘乘’:
return mymul
def main():
while True:
s=input('请输入计算公式: ')
l=s.split()
a=int(l[0])
b=int(l[2])
fn=get_func(l[1])
print('结果是: ',fn(a,b))
main()
函数的嵌套定义：
函数的嵌套定义是指一个函数里用def 语句来创建其它函数的情况
python的作用域：
作用域也叫名字空间，是访问变量时查找变量名的范围空间
python中的四个作用域LEGB
作用域 英文解释 英文缩写
局部作用域 local(function) L
外部嵌套函数作用域 Enclosing function local E
函数定义所在模块（文件）的作用域
Global(module) G
Python内建模块作用域 Builtin(python) B
变量名的查找规则： L E G B
注：在默认情况下，变量名赋值会创建或改变当前作用域内变量的绑定关系
global 语句：
作用：告诉解释执行器，global语句声明的一个或多个变量，这变量的作用域为模块级的作用域，也称作全局变量
全局声明（global）将赋值语句的变量映射到模块文件内部的作用域
语法：
global 变量名1，变量名2，…
v=100
def f1():
global v
v=200
f1()
print(‘v=’,v)
说明：
1 全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认为是局部变量）
2全局变量在函数内部不经过声明就可以直接访问（取值）
3不能先创建局部变量，在用global声明为全局变量，此种做法不符合规定
4global变量列表里的变量名不能出现在函数的形参列表里
nonlocal 语句：
作用：告诉解释器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量
语法：nonlocal 变量名1，变量名2，变量名3…
说明：
1nonlocal 语句只能在被嵌套函数内部进行使用
2 对nonlocal 变量进行赋值将对外部嵌套函数作用域内的变量进行操作
3当有2层或2层以上函数嵌套时，访问nonlocal变量，只对最近的一层变量进行操作
4 nonlocal 语句的变量列表里的变量名不能出现在此函数的形参列表中
lambda 表达式（又称匿名函数）
作用： 创建一个匿名函数对象
同def 类似，但不提供函数名
语法：
lambda[函数形参列表]：表达式
def myadd(x,y):
return x+y
myadd=lambda x,y:x**y
print(‘20+30=’,myadd(20,30))
print(‘4+5=’,myadd(4,5))
说明：
1 lambda 表达式创建的函数只能包含一条表达式
2 lambda 比函数简单，且可以随时创建和销毁，有利于降低程序的偶合性
def fx(f,x,y):
print(f(x,y))
fx((lambda a,b:a+b),100,200)
fx((lambda x,y:x*y),3,4)
eval 函数和exec（）函数
eval（source，global=none,local=none）
把一个字符串source当成一个表达式来执行，返回表达式执行的结果
exec（source，global=none,local=none）
把一个字符串source当成程序来执行
day11
函数式编程
函数式编程是指用一系列函数解决问题
函数是一等公民（Guido）
好处：
用每个函数完成细小的功能，一系列函数的任意组合可以解决大问题
函数仅接收输入并产生输出，不包含任何能影响输出的内部状态
函数的可重入性：
当一个函数的输入实参一定，结果也必须一定的函数称为可重入函数
说明：
可重入函数在函数内部一定不访问除局部变量以外的变量
高阶函数High Order Function
满足其中一个就是高阶函数：1 函数接受一个或多个函数作为参数传入2 函数返回一个函数
函数 说明
map(func, *iterables) 返回一个可迭代对象，此可迭代对象用
函数func对可迭代对象iterables中的 每一个元素作为参数计算后得到结果;
当最短的一个可迭代对象不再提供数据 时此可迭代对象生成结束
filter(function, iterable)
返回一个可迭代器对象，此可迭代对象 将对iterabler获取到的数用函 数function 进行筛选.function将对 iterable中的每个元素进行求值，
返回False则将此数据丢弃，返回True ，则保留此数据
sorted(iterable, 返回一个新的包含有所有可迭代对象中 key=None,reverse=False) 数据升序排序的列表
iterable 可迭代对象
key 函数是用来提供一个值,这个值将 作为排序的依据
reverse 标志用来设置是否降序排序
def pow2(x):
return x2
for x in map(pow2,range(1,10)):
print(x)
def mypow2(x,y):
return xy
for x in map(mypow2,[1,2,3,4],[4,3,2,1]):
print(x)
def isodd(x):
return x%2==1
for x in filter(isodd,range(1,11)):
print(x)
for x in filter(lambda x :x %2,range(11)):
print(x)
l=[x for x in filter(lambda x :x %2,range(11))]
print(l)
递归函数 recursion
是指函数直接或间接的调用自身
说明： 递归一定要控制递归的层次，当符合某一条件时要终止递归 几乎所有的递归都可以用while循环来代替
递归的优缺点：
有点：递归可以把问题简单化，让思路更为清晰，代码更简洁
缺点： 递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
递归函数的执行分为2个阶段：
递推阶段：调用进入函数内部
回归阶段：返回结果，得到最终结果
闭包 closure
引用了此函数外部变量的函数
外部变量指：外部嵌套函数作用域内的变量
闭包必须满足三个条件：
1必须有一个内嵌函数
2内嵌函数必须引用外部函数中的变量
3外部函数返回值必须是内嵌函数
注意点： 由于闭包会使得函数中的变量都被保留在内存中，内存消耗比较大，所以不能滥用闭包
def make_power(y):
def fn(x):
return x**y
return fn
pow2=make_power(2)
print('5的平方是: ',pow2(5))
pow3=make_power(3)
print('6的平方是: ',pow3(6))
def get_fx(a,b,c):
def fx(x):
return ax**2+bx+c
return fx
f123=get_fx(1,2,3)
print(f123(20))
print(f123(50))
面试题
def get_funs(n):
l=[]
for i in range(n):
l.append(lambda x:x*i)
return l
funs =get_funs(4)
print(funs0)#30
print(funs1)#30
print(funs2)#30
print(funs3)#30
day12
装饰器 decorators（专业提高篇）
是一个函数，主要作用是用来包装另一个函数或类（后面才讲）
包装的目的是在不改变原函数名（或类名）的情况下改变或添加被包装对象的行为
函数装饰器
是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数
语法：
def 装饰器函数名（参数）：
语句块
return 函数对象
@装饰器函数名<换行>
def 函数名（形参列表）：
语句块
#模拟银行项目
#业务： 存钱和取钱
def pricileded_check(fn):
def fx(n,yuan):
print(‘正在检查权限…ok!’)
fn(n,yuan)
return fx
def send_message(fn):
def fy(n,x):
fn(n,x)
print(‘正在发送给…’,n)
return fy
@send_message
@pricileded_check
def savemoney(name,x):
print(name,'存钱',x,'元')
@send_message
@pricileded_check
def withdraw(name,x):
print(name,‘取钱’,x,‘元’)
savemoney(‘小红’,200)
savemoney(‘小飞’,400)
savemoney(‘小王’,500)
withdraw(‘小王红飞’,500)
函数的文档字符串
函数内第一次未赋值给任何变量的字符串是此函数的文档字符串
语法：
def 函数名（参数列表）：
‘函数的文档字符串’
语句块
说明：
文档字符串通常用来说明本函数的功能的使用方法
函数的文档字符串绑定在函数对象的__doc__属性上
函数的__doc__属性
__doc__属性用于绑定函数的文档字符串
函数定义语句的完整的语法：
[@装饰器1]
[@装饰器2]
…
def 函数名（[位置形参]，[元组形参],[命名关键字形参]，[**字典形参]）:
‘文档字符串’
语句块
模块 Module
模块是一个包含有一系列数的数据，函数，类等组成的程序
模块是一个文件，模块文件通常以.py结尾
作用：
1让一些相关的数据，函数，类等有逻辑的组织在一起，逻辑结束更加清查
晰
2模块中的数据，函数和类等可提供给其他模块或程序
模块的分类：
1内置模块，在解析器的内部都可以直接使用
2标准库模块，安装python时已安装，且可以直接使用
3第3方模块（通常为开源），需要自己安装
4用户自己编写的模块（可以作为其他人的第三方模块）
模块的导入import 语句
import 语句
语法：
import 模块名1[as 模块新名1]，模块名2[as 模块新名2]
作用：将某模块整体导入到当前模块
用法： 模块名.属性名
math.factorial(5)
dir (abj)函数，返回模块的所有属性的字符串列表
help（obj）函数，可以查看模块相关的文档字符串
from import 语句
语法：
from 模块名 import 模块属性名1[as 属性新名1]，模块属性名2[as 属性新名2]，…
作用：将某模块内的一个或多个属性导入到当前模块的作用域
from import *语句
语法：
from 模块名 import *
作用：将某模块的所有属性导入到当前模块
dir([对象])返回一个字符串列表
dir 函数的作用：
如果没有参数调用，则返回当前作用域内所有变量的列表
如果给定一个对象作用参数，则返回这个对象搜友变量的列表
对于一个模块，返回这个模块的全部变量（属性）
对于一个类对象，返回类对象的所有变量，并递归基类对象所有变量
对于其他变量，返回所有变量，类变量和基类变量
数学模块：
模块名： math
时间模块：time
此模块提供了时间相关函数
系统模块 sys
运行时系统相关的信息
day13
自定义模块并导入
要求：
1 模块文件名后缀名必须以.py 结尾
2 模块文件名必须是合法的标示符
3 避免名称和内建模块名冲突
导入方式：
import 语句
from import 语句
from import * 语句
import 语句查找模块文件的路径顺序
import 模块名 #去哪找这个"模块名.py"
1搜索内建模块
2 搜索程序运行时的路径（当前路径）
3 sys .path 提供的路径
sys.path 是一个列表，内部存入的都是模块的搜索路径
安装 第三方模块或包
pip3 install 模块名
让 import 语句能找到自己模块
1把自己写的模块放到sys.path中的某个文件夹内
2 修改sys.path列表，在内部添加一个文件夹的字符串
（注释： 此做法只针对当前程序起作用）
如： import sys
sys.path.append
模块化编程的有点：
1有利于多人合作开发
2使代码更加易于维护
3提高代码的复用率
4有利于解决变量名冲突问题（模块内的全局变量的作用域为模块内全局）
模块的加载过程
在模块导入时，模块内的所有语句都会执行
如果一个模块已经导入，则再次导入时不会重新执行模块内的语句
模块被导入和执行的过程
1先搜索相关路径找到 模块名.py
2判断是否有此模块对应的pyc文件，如果.pyc文件比.pyc文件新 则直接加载.pyc
3 如果.pyc 文件比.py文件旧，则用模块名.py生成 .pyc 文件，并加载执行
模块的编辑
编译 解释执行
mymod.py----->mymod.pyc---->python3
模块的属性
__doc__属性
用于绑定模块的文档子妇产
模块的文档字符串用于help(模块) 函数提供帮助信息
快捷键 ctrl 鼠标单击
__file__属性
用于绑定模块的文件路径名
__name__属性
用来记录模块自身的名字
作用：
1 记录模块名
2用来判断是否为主模块
说明：
当模块为主模块（也就是第一个运行的模块）运行时，__name__属性绑定
‘main’
当此模块不是主模时，__name__属性 绑定模块名
模块的__all__列表
作用：
当用from xxx import * 语句导入时，直导入__all__列表的属性
说明：
__all__列表是一个用来存放可导出属性的字符串列表
模块的隐藏属性
模块中以’_'开头的属性，在用 from xxx import* 导入时将不被导入，通常称这些属性为隐藏属性
随机模块fandom
作用：
用于模拟或生成随机输出的模块
包（模块包）package
包是将模块以文件夹的组织形式进行分组管理的方法
作用：
将一系列模块进行分类管理，有利于防止命名冲突
可以在需要时加载一个或部分模块，则不是全部模块
包的导入
同模块的导入规则
import 包名[as 包别名]
import 包名.模块名[as 模块新名]
import 包名.子包名.模块名[as 模块新名]
from 包名 import 模块名[as 模块新名]
from 包名.子包名 import 模块名[as 模块新名]
from 包名.子包名.模块名 import 属性名 [as 属性新名]
from 包名 import *
from 包名 模块名 import *
init.py文件
init.py是常规包中必须存在的文件
init.py 会在包加载时被自动调用
作用：
编写此包的内容
在包内填写包的文档字符串
在__init__.py文件内可以加载此包所依赖的一些其他模块
init.py内的__all__列表
作用：
用来记录此包中有哪些包或模块需要导入
当用from 包import*语句导入模块时，只查找__all__中所有模块或子包
说明：
__all__列表只在from xxx import *起作用
import 语句搜索包的路径的顺序
1搜索程序运行时的路径（当前工作目录）
2 sys.path提供的路径
包的相对导入
是指包内模块的相互导入
语法：
from 相对路径包或模块 impot 属性或模块名 或
from 相对路径包或模块 impot *
相对路径：在from import 语句和from import* 语句中可以使用相对路径
. 代表当前目录
… 代表上一级目录
… 代表上2级目录
…以此类推
注释：相对导入时不能超出包的外部
day14
异常exception(基础)
错误是指由于逻辑或语法等导致程序无法正常执行的问题
特点：
无法预知
异常时程序出错时标识的一种状态，当异常发生时，程序不会再向下执行，而转去调用此函数的地方待处理此错误并恢复为正常状态
作用：
用作信号通知，通知上层调用者有错误产生需要处理
程序有两种状态：
正常状态和异常状态
try语句 的两种语法
try-expect语句
语法：
try:
可能发生异常的语句
except 错误类型1[as 变量1]：
异常处理语句1
except 错误类型2[as 变量2]：
异常处理语句2
except 错误类型3[as 变量3]：
异常处理语句3
…
except:
异常处理语句other
else:
未发生异常的语句
finally:
最终语句
作用：
尝试捕获错误，得到异常通知，将程序由异常状态转换为正常状态并继续执行
说明：
as 子句是用于绑定错误对象的变量，可以省略
except 子句可以有一个或多个，但至少要有一个
else 子句最多只能有一个，也可以省略
finally 子句最多只能有一个，也可以省略
def div_apple(n):
print(’%d个苹果先分给几个人?’ % n)
s=input(‘请输入人数’)
count=int(s)
result=n/count
print(‘每个人分了’,result,‘个苹果’)
try:
div_apple(10)
print(‘分苹果成功’)
except ValueError:
print(‘div_apple发生错误’,‘已处理，程序回复正常’)
print(‘程序结束’)
try-finally语句
Python3 中全部错误类型
错误类型 说明
ZeroDivisionError 除(或取模)零 (所有数据类型)
ValueError 传入无效的参数（值错误）
AssertionError 断言语句失败
StopIteration 迭代器没有更多的值
IndexError 序列中没有此索引(index)
IndentationError 缩进错误
OSError 输入/输出操作失败
ImportError 导入模块/对象失败
NameError 未声明/初始化对象 (没有属性)
AttributeError 对象没有这个属性
GeneratorExit 生成器(generator)发生异常来通知退出
TypeError 对类型无效的操作
KeyboardInterrupt 用户中断执行(通常是输入^C)
OverflowError 数值运算超出最大限制
FloatingPointError 浮点计算错误
BaseException 所有异常的基类
SystemExit 解释器请求退出
Exception 常规错误的基类
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
WindowsError 系统调用失败
LookupError 无效数据查询的基类
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了 的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
以下为警告类型
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告
详见：help(builtins)
try-finally语句
语法：
try:
可能触发异常的语句
finally:
最终语句
说明：
finally 子句不可以省略
一定不存在except子句
作用：
通常用try-finally语句来做触发异常时必须要处理的事情，无论异常是否发生，finally子句都会被执行
注释： try-finally语句不会改变程序的（正常/异常）状态
raise 语句
作用：触发一个错误，让程序进入异常状态
发送错误通知给调用者
语法：
raise 异常类型
或
raise 异常对象
或
raise #重新触发上一次异常
assert 语句（断言语句）
语法：
assert 真值表达式， 错误数据（通常是字符串）
作用：
当真值表达式为False 时，用错误数据创建一个AssertionError类型的错误，并进入异常状态，通常用来故意制造错误
等同于： if bool(真值表达式)==False:
raise AssertionError(错误数据)
异常中的小结：
try—expect 语句用于捕获（接收）错误通知，把异常状态转为正常状态
try-finally 语句 用于执行在任何状态都必须要执行的语句
raise 语句 触发错误（发送错误通知），让程序进入异常状态
assert 语句 根据条件触发AssertionError类型的错误通知
迭代器Iterator
是访问可迭代对象的工具
迭代器是指iter(obj)函数返回的对象（实例）
迭代器可以用next(it)函数获取可迭代对象的数据
迭代器函数iter 和next
iter（iterable） 从可迭代对象中获取一个迭代器，iterable 必须能提供一个迭代器的可迭代对象
next（Itrator）从迭代器Itrator中获取下一个记录，如果无法获取下一条记录，则触发Stop Iteration 异常
说明：
迭代器只能往前取值，不会后退
用iter 函数可以返回一个可迭代对象的迭代器
day15
生成器 Generator
生成器是能够动态提供数据的可迭代对象
生成器在程序运行时生成数据，与容器类不同，它通常不会在内存中保留大量的数据，而是现用现生成
优点：
不占用计算机内存
生成器有两种:
生成器函数
生成器表达式
生成器函数的定义
含有yield语句的函数是生成器函数，此函数被调用将返回一个生成器对象
yield翻译为（产生或生成）
yield语句
语法：
yield 表达式
说明：
yield只能用于def 函数中，目的是将此函数作为生成器函数使用
yield用来生成数据，使迭代器的next(it)函数使用
说明：
1生成器函数的调用将返回一个生成器对象，生成器对象是一个可迭代对象
2生成器函数用return 会触发一个Stopitration异常（既生成结束）
生成器表达式
语法：
（表达式 for 变量 in 可迭代对象 [if 真值表达式]）
作用：
用推导式形式创建一个新的生成器
说明：
if 子句可以省略
生成器表达式也可以像列表推导式一样嵌套
迭代工具函数：
迭代工具函数的作用是生成一个符合条件的可迭代对象
zip(iter1[,iter2…])返回一个zip 生成器对象
此对象用于生成一个元组，此元祖的数据分别来自参数中的每个可迭代对象，生成元组的个数由最小的一个可迭代对象决定
enumerate(iterable,start=0) 返回一个enumerate生成器对象，此对象生成类型为（索引，值对）的元组 默认索引从零开始，也可以用start指定
numbers=[10086,10000,10010,95588]
names=[‘中国移动’,‘中国电信’,‘中国联通’,‘王八’]
for t in zip(numbers,names):
print(t)
names=[‘中国移动’,‘中国电信’,‘中国联通’,‘王八’]
for x in zip(range(10000000000),names):
print(x)
for t in enumerate(names):
print(t)
zip 函数的原理
示例
容器
字节串和字节数组
字节串（字节序列）bytes
储存意字节为单位的数据
字节串是不可改变的字节序列
说明：
字节是0-255之间的整数，用来表示一个字节的取值
创建空字节串的字面值方式：
b’’
b""
b’’’’’’
b""""""
创建非空字节串的字面值方式
b’ABCD’
b"ABC"
b’’‘aaaa’’’
b""“bbbb”""
字节串构造函数bytes
bytes() 生成一个空的字节串等同于b’’
bytes(整数可迭代对象) 用可迭代对象始化一个字节串
bytes（整数n）生成n个为0的字节串
bytes（字符串，encoding=‘utf-8’）用字节串转换编码生成一个字节串
>>> bytes(range(0x41,0x61))
b’ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`
字节串： + += - -= < <= > >= == != in not in 索引和切片
函数：
len(x)…
bytes与str 区别：
bytes储存字节（0-255之间的整数）
str 储存unicod字符（0-0x10FFFF）的字符
bytes与str 转换：
编码（encode）
str---------->bytes
b=s.encode(encoding=‘utf-8’)
解码（decode）
bytes----------->str
s=b.decode(encoding=‘utf-8’)
字节数组：bytearray
可变的字节串
字节数组的构造函数bytearray
bytearray()
bytearray(整形可迭代对象)
bytearray（整数）
bytearray（字符串， encoding=‘utf-8’）
字节数组的运算：
- += - -= < <= > >= == != in not in 索引和切片
bytearray的方法：
方法 说明
B.clear() 清空
B.append(n) 追加一个字节(n为0-255的整数)
B.remove(value) 删除第一个出现的字节,如果没有出现，则产生 ValueError错误
B.reverse() 字节的顺序进行反转
B.decode(encoding=‘utf-8’)
B.find(sub[, start[, end]])
day16
文件 file
文件是用于存储数据的基本单位
文件通常用来长期存储数据
文件中数据是以字节为单位进行顺序存储的
文件的操作流程
1打开文件
2读/写文件
3关闭文件
注释：任何的操作系统，一个应用程序同时打开文件的数量有最大限制
文件的打开函数：
open(filename,mode=‘rt’)用于打开一个文件，返回此用来操作此文件流对象，如果打开失败，则会触发OSError错误异常
文件流对象的关闭方法
F.close() 关闭文件。释放系统资源
以十六进制方式显示文件内容的命令：
$ xxd 文件名
python 的文本文件模式：
模式字符‘t’
说明：
1对文本文件的读写操作需要用字符串（str）进行读写操作
2在读写过程中会自动进行编码（encode）和解码（decode）操作
3以行2为单位分隔，在python 内部统一用‘\n’作为换行符进行分隔
各操作系统的换行符：
linux换行符：‘\n’
windows换行符：‘\r\n’
新的mac os 换行符‘\n’
文本文件的写操作：
方法：
F.write(x)
F.writelines(列表)
模式字符串：
‘w’ 以只写方式打开，删除原有文件内容(如果文件不存在，则创建该文 件并以只写方式打开)
‘x’ 创建一个新文件, 并以写模式打开这个文件,如果文件存在则会产生 "FileExistsError"错误
‘a’ 以只写文件打开一个文件，如果有原文件则追加到文件末尾
二进制文件操作：
模式字符：‘b’
默认文件中存储的都是以字节（byte）为单位的数据，通常人为的格式
对二进制文件的读写需要用字符串（bytes）或字节数组（bytearry）进行操作
对于二进制文件读写方法都 需要用字节为单位进行操作
F.read(n)
F.readline()
F.readlines()
F.write(字节串）
F.write lines(字节串组成的列表)
示例见：
file_read_binary.py
二进制文件的写操作：
file_write_binary.py
F.seek(offset, whence=0)方法：
作用：设置文件的读写位置，返回新的读写位置
格式：F.seek(偏移量, whence=相对位置)
偏移量
大于0代表向文件末尾方向移动
小于0代表向文件头方向移动
相对位置
0代表从文件开头偏移
1diabetes从当前读写位置开始偏移
2 代表从文件末尾开始偏移
标准输入输出文件：
模块名：
sys
sys.stdin 标准输入文件（默认为键盘）
sys.stdout 标准输出文件（默认为屏幕终端）
sys.stderr 标准错误输出文件（默认为屏幕终端）
标准文件不需要打开既可 以使用，也不用手动关闭
汉子编码（2中）
国标系列：
GB18030（二字节或四字节编码，27533个字）
GBK(二字节编码，20013个字)
GB2313(二字节编码，约7000多个字)
（windows常用）
国际标准:
UNICODE(UNCODE16/UNICODE32) <-> UTF-8
(Linux/Mac OS X/ IOS/ Android 常用)
UTF-8中:
英文ASCII (0x0 - 0x7F) 一字节
(0x80 - 0x3FF) 二字节
(0x400 - 0xFFFF) 三字节(中文在此区)
python 编码字符串:
‘gb2312’
‘gbk’
‘gb18030’
‘utf-8’
‘ascii’
…
编码注释:
在源文件中,第一行或第二行写入的如下内容是编码注释
-- coding:gbk --
或
-- coding:utf-8 --
day17
面向对象编程：ojbect-oriented progiamming
两种编程思想：
面向过程编程
最小单位：函数
面向对象编程 最小单位： 类 class
对象是指现实中的物体或实体
面向对象： 把一切看成对象（示例），用各种对象之间的关系来描述事物
特征：
对象有很多的属性（名词，形容词）
姓名，年龄，性别，头发颜色
对象有很多行为（动作，动词）
学习吃饭…
类： 拥有相同属性和行为的对象分为一组，即为一个类
类是用来描述对象的工具，用类可以创建此类的对象（示例）
类的创建语句：
语法：
class 类名（继承列表）：
‘’‘类的文档字符串’’’
实例方法（类内的函数method）定义
类变量
类方法（@class method）
静态方法（@static method）
作用：
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个对象（实例）
说明：
类名必须是标示符
类名实质是变量，它绑定一个类
构造函数：
格式：
类名（[传参列表]）
作用：
创建这个类的示例对象，并返回此实例对象的引用关系
说明：
对象（实例）可以调用类方法和实例方法
对象（实例） 有自己作用域和名字空间，可以为该 实例 添加实例变量（也叫实例属性）
对象（实例）方法：
定义格式：
class 类名(继承列表)：
def 示例方法名（self, 参数1，参数2…）：
‘’‘方法的文档字符串’’’
语句块
作用：
用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
说明：
实例方法的实质是函数，是定义在内类的函数
实例方法至少有一个形参，第一个形参绑定调用此方法的实例，一般命名为’self’
实例方法的调用语法：
实例.实例方法名(调用传参)
或
实例.实例方法名（实例，调用传参）
实例属性 attribute(也叫实例变量)
每个实例可以用自己的变量来记录每个对象自己的数据，这个变量称为实例变量
使用语法;
实例.属性名
赋值规则：
首次为属性赋值创建此属性
再次为属性赋值改变此属性
作用：
记录每个对象自身的数据
删除属性：
del语句
del 对象，实例变量名
del 语句总结：
1 删除变量 del a,b,c
2 删除列表中的元素 del l[0]
3 删除字典中的键 del d[‘name’]
4 删除属性 del obj.name
初始化方法：
作用：
对新创建的对象添加属性
语法格式：
class 类名（继承列表）：
def init(self[,形参列表])
语句块
注释：[] 代表内容可省略
说明：
1初始化方法的名必须是 'init’不可改变
2初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self 传入‘init’
3构造函数的实例将通过__init__方法的 参数列表传入到__init__方法中
4初始化方法内如果需要return 返回，则必须返回None
析构方法：
格式：
class 类名（继承列表）：
def del(self):
…
作用：
在此对象销毁前释放此对象所占用资源
说明：
析构方法在对象被销毁前被自动调用
python 语言建议不要在对象销毁时做任何事情，因为销毁的时间难以确定
预置实例属性
__dict__属性
__dict__属性绑定一个储存此示例自身变量的字典
__class__属性
__class__属性绑定创建此实例的类
作用：可以借助于此属性来访问创建此实例的类
用于实例对象的函数：
isinstance(obj,class_or_tuple)返回这个对象的obj
是否是某个类的对象，或者某些类中一个类的对象，如果是则返回True,否则返回False
type(obj)返回对象的类型
day19
用于类的函数：
issubclass(cls,class_or_tuple)判断一个类是否继承自某个类class或某些类tuple中的一个类，如如果是则返回True,否则返回False
封装
封装是指隐藏类的实现细节，让使用者不关心这些细节
封装的目的是让使用者通过尽可能少的方法（或属性）操作对象
私有属性和方法：
python 类中以双下划线__开头，不以双下划线结尾的标示符为私有成员，私有成员只能使用该类的方法进行访问和修改
多态polymorphic 意思为：多种状态
编程语言的状态：
静态（编译时状态）
动态（运行时状态）
多态原指在有继承关系的类中，调用基类对象的方法，实际能调用到子类覆盖方法的现象叫多态
说明：python全部的对象都只有‘运行时状态（动态）’没有c++语言里的编译时状态
面向对象编程语言的特征：
继承
封装
多态
多继承multiple inheritance
多继承是指一个子类继承自两个或两个以上的基类
多继承的语法：
class 类名（基类名1，基类名2，…）
语句块
说明：
1一个子类同时继承自多个父类，父类中的方法可以同时被继承下来
2如果两个父类中有同名的方法，而在子类中又没有覆盖此方法时，调用结果难以确认
多继承的缺陷：
标识符（名字空间）冲突的问题
要谨慎使用多继承
多继承的MRO(method resolution order)问题
MRO 翻译为方法的解决顺序
类的__mro__属性
用来记录类的方法的查找顺序
对象转字符串函数的使用：
repr(obj) 返回一个附和python 语法规则的字符串
通常：
eval(repr(obj))==obj
str(obj) 通过给定的对象返回一个字符串（这个字符串通常是给人阅读的）
说明：以上两个函数返回的一定是一个字符串
函数重写：
函数重写是指在自定义的类内添加相应的方法，让自定义的类创建的事例可以像内建对象一样进行函数操作
对象转字符串函数的重写方法
repr（obj） 函数的重写方法：
def repr(self):
return ‘字符串’
str (obj)函数的重写方法：
def str(self):
return ‘字符串’
str (obj)函数调用方法说明：
1先调用obj.str()方法取值
2如果obj.str()方法不存在，则调用obj.repr()方法取值
3如果在不存在obj.repr()方法，则调用object类的__repr__方法取值
内建函数重写
方法名 函数名
abs(self) abs(obj)函数
len(self) len(obj)函数
reversed(self) reversed(obj)
round(self) round(obj)
数值转换重写
方法名 函数名
complex(self) complex(obj)
int(self) int(obj)
float(self) float(obj)
bool(self) bool(obj)
布尔测试函数（bool）函数重写
作用;
用于bool(obj) 函数取值：
用于if 语句的真值表达式中
用于while 语句的真值表达式中
说明：
1优先调用obj.bool()方法进行取值
2当不存在obj.bool()方法时，用obj.len()的返回值是否为零来测试布尔值
当不存在obj.len()方法时，则直接返回true
对象的属性管理函数
函数 说明
getattr(obj, name[, default]) 从一个对象得到对象的属性；getattr(x, ‘y’) 等同于x.y; 当属性不存在时,如果给出default参数,则返 回default,如果没有给出default 则产生一个 AttributeError错误
hasattr(obj, name) 用给定的name返回对象obj是否有此属性,此种做法可以避 免在getattr(obj, name)时引发错误
setattr(obj, name, value) 给对象obj的名为name的属性设置相应的值value, set(x, ‘y’, v) 等同于 x.y = v
delattr(obj, name) 删除对象obj中的name属性, delattr(x, ‘y’) 等同于 del x.y
迭代器（高级）
什么是迭代器
可以能对next(it)函数取值的对象就是迭代器
迭代器协议：
迭代器协议：
迭代器协议是指对象能够使用next函数获取下一项数据，在没有下一项数据时触发一个stopiteration异常来终止迭代的约定
迭代协议的实现方法：
next(self)方法来实现迭代器协议
什么事可迭代对象：
是指能用iter(obj)函数返回迭代器的对象（实例）
可迭代对象的内部要定义__iter__()方法来返回迭代器对象（实例）
day20
异常
异常相关的语句： try-except try-finally rai环境管理其se assert
with语句
语法：
with 表达式1[as 变量1]，表达式2[as 变量2]，…：
语句块
作用：使用于对资源进行访问的场合，确保使用过程中不管是否发生异常，都会执行必须的‘清理’操作，并释放资源
如： 文件使用后自动关闭，线程中锁的自动获取和释放等
说明：
执行表达式，用于as子句中的变量绑定生成的对象
with语句并不改变异常的状态
环境管理器
类内有__enter__和__exit__示例方法的类被称为环境管理器
__enter__将在进入with语句时被调用，并返回由as 变量管理的对象
__exit__将在离开with语句时被调用，且可以用参数来判断在离开with语句时是否有异常发生，并作出相应的处理
运算符的重载
让自定义的类生成的对象（示例）能够使用运算符进行操作
作用：
让自定义的类的示例像内建对象一样使用运算符
让程序简洁易读
对自定义对象将运算符赋予新的运算规则
算术运算符的重载
方法名 运算符和表达式 说明
add(self,rhs) self+rhs 加法
sub(self,rhs) self-rhs 减法
mul(self,rhs) self*rhs 乘法
truediv(self,rhs) self/rhs 除法
floordiv(self,rhs) self//rhs 地板除
mod(self,rhs) self%rhs 求余
pow(self,rhs) self**rhs 幂运算
说明：运算符的重载的方法的参数已经有固定的含义，不建议改变原来的意义
反向算数运算符的重载
当运算符左侧为内建类型，右侧为自定义类型进行算数运算时，会出现TypeError错误
因无法修改内建类型的代码来实现运算符重载，此时需要使用反向运算符重载来完成重载
方法名 运算符和表达式 说明
radd(self,lhs) lhs+self 加法
rsub(self,lhs) lhs-self 减法
rmul(self,lhs) lhs*self 乘法
rtruediv(self,lhs) lhs/self 除法
rfloordiv(self,lhs) lhs//self 地板除
rmod(self,lhs) lhs%self 求余
rpow(self,lhs) lhs**self 幂运算
复合赋值算术运算符重载
以复合赋值算术运算符x+=y为例，此运算符会优先调用x.iadd(y)方法，如果没有__iadd__方法 时会将复合赋值运算符拆解为x=x+y然后再调用x.iadd(y)
方法，如果在不存在__iadd_方法则会触发TypeError异常
其他复合赋值运算符也具有相同的规则
方法名 运算符和表达式 说明
iadd(self,rhs) self+=rhs 加法
isub(self,rhs) self-=rhs 减法
imul(self,rhs) self*=rhs 乘法
itruediv(self,rhs) self/=rhs 除法
ifloordiv(self,rhs) self//=rhs 地板除
imod(self,rhs) self%=rhs 求余
ipow(self,rhs) self**=rhs 幂运算
比较运算符的重载
方法名 运算符和表达式 说明
lt(self,rhs) self<rhs 小于
le(self,rhs) self<=rhs 小于等于
gt(self,rhs) self>rhs 大于
ge(self,rhs) self>=rhs 大于等于
eq(self,rhs) selfrhs 等于
ne(self,rhs) self!=rhs 不等于
位运算符的重载
方法名 运算符和表达式 说明
and(self,rhs) self&rhs 位于
or(self,rhs) self|=rhs 位或
xor(self,rhs) self>rhs 位异或
ge(self,rhs) self>=rhs 左移
eq(self,rhs) selfrhs 右移
ne(self,rhs) self!=rhs 不等于
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
