第一阶段笔记

1、Linux命令

1、cp :复制文件或者目录
1、复制文件：cp 源文件 路径
2、复制目录：cp -r 源目录 路径
3、cp *.txt /home/tarena/AID09

2、mv :剪切、重命名
1、剪切：mv 文件名 路径
mv 目录名 路径
2、重命名：mv 文件名1 文件名2
mv 目录名1 目录名2

3、cat :查看文件内容
4、tar :打包并压缩
1、格式：
tar -zcvf 压缩包名字.tar.gz 需要压缩的文件或目录
-z:用gzip对包进行压缩
-c:创建包（create）
-v:显示明细（verbose）
-f:file
2、解压缩
tar -zxvf 压缩包名字.tar.gz -C 路径
-C：指定解压路径，不写默认解压当前目录

5、文件权限
1、查看：ls -l 文件名

   -rw-rw-r--  tarena tarena 0 c.txt

  2、最左侧一列：-带表类型
     1、d:目录
    2、-:文件
    3、l：链接(link)
 3、权限
    r:读
    w:写（编辑）
    x:执行
 4、rwx权限分组
    第一组：文件的所有者权限
    第二组:同组用户对文件的权限
    第三组：其他组用户对文件的权限

6、chmod :修改文件权限
1、方式1 ：给所有用户添加相关权限
chmod +x/-w/+rwx/-wx c.txt
2、给指定组用户修改权限
chmod u+x c.txt
chmod o+rwx c.txt’
a:所有用户（all）
u:所有者(user)
g:同组用户(group)
o:其他用户(other)
2、方式2：（通过数字方式修改）
chmod 644 c.txt :rw-r–r--
r:4
w:2
x:1
chmod 777 c.txt :rwxrwxrwx
3、Linux高级命令

  1、sudo:获取root用户权限执行Linux命令
  
  2、df -h：查看磁盘使用情况
  3、top:打开任务管理器，查看%CPU   q:退出

  4、ps -aux；查看某个应用程序的PID号
  5、kill -9 PID号 :强制关闭

一、python
1、python简介
1、系统运维
2、网络编程
3、人工智能，机器人
4、Web开发
5、云计算、大数据
6、爬虫、游戏、图像…
2、优缺点

  3、我的第一个Python程序
     1、文件：hello.py
        功能：在终端输出 hello world
     2、python3 hello.py
  4、Sublim代码编辑器
      1、多行注释、取消注释：ctrl + /
      2、保存：ctrl + s
      3、回退：ctrl + z
      4、同事选中多个光标：ctrl + 鼠标左键单击

二、Python交互解释器
1、进入：Python3
2、退出：exit()、quit()、ctrl + d

二、变量
　　什么是变量：
　　　　　 是关联一个对象的标识符
　　　　　　　可以绑定一个对象，并可以通过变量名使用这个对象
　　标识符的命名方法：
　　　　以字母或者下划线开头，后跟字母下划线或者数字
　　　　　　说明：
　　　　　　　　标识符区分大小写
　　　示例：　a A set_age_ al2 _abcd _
不合法的标识符：
　　　la 123 $ABC
python 的关键字不能用作变量名：
　　Ture,Fals,None,is,del,if…
赋值语句：statements

   符号　＝
   语法：
   　　变量名　＝　表达式
   或
   　　变量名１　＝　变量名２　＝　表达式
   或　
   　　变量名１　＝　变量名２　...　＝　序列
   　作用：
   　　　创建一个变量并绑定数据对象　
   　　　改变一个变量的绑定的数据对象　
   　示例：　
           a = 10
           b = 20
           c = a + b # c　绑定 30
 赋值语句说明：
 　　１、当变量不存在时，赋值语句会创建该变量，同时将变量
 　　绑定在赋值运算符右侧的对象上
 　　２、当变量存在时，改变此变量的绑定关系
 　　３、一个变量只能绑定一个对象
 　　４、多个变量可以绑定在一个对象上

del 语句
　　　　作用：用于删除变量，同时接触与对象的关联关系，如果可能释放对象
　　　　语法：
　　　　　　del 变量名１，变量名２…
is 和　is not 运算符
　　　作用：
　　　　判断俩个对象是否是同一个对象，当是同一个对象时返回True,否则返回False
is not 与　is 的返回值相反
　　语法：
x is y
x is not y
id 函数：
　　作用：
　　　　　返回一个对象在内存中的地址
　　说明：
　　　　　is 运算符是根据id来进行判断的
　　格式：
　　　　　id (对象)
　小整数对象池：
　　　CPython中，整数　－５　至　２５６永远存在于小整数对象池中，不会被释放，并可重复使用

复合赋值运算符：
　　运算符　　　说明
　　y += x 等同于　y = y + x
　 y -= x 等同于　y = y - x
　 y *= x 等同于　y = y * x
　 y /= x 等同于　y = y / x
　 y //= x 等同于　y = y // x
　 y %= x 等同于　y = y % x
　 y **= x 等同于　y = y ** x
比较运算符
　　< 小于
<=　　　　　　小于等于　
>　　　　　　　大于
>=　　　　　　大于等于
==　　　　　　　等于
!= 不等于

语法：
　　　左表达式　<　右表达式
说明：
　　　比较运算符返回布尔类型的值
示例：
　　　１００　< 200
1　＋　４　＝＝３　＋　２

数值对象的构造（创建）函数
　　　float(obj)   用字符串或者数字转换为浮点数，如果不给出参数，返回0.0
     int(x,base=10)　或　int (x=0)   用数字或者字符串转换整数。不给出参数，返回0
     complex(r=0.0,i=0.0)  用数字创建一个复数(实部为r,虚部为i)
     bool （x）        用x创建一个布尔值（True/False）
     bool(x)　返回假值的情况
     　　值　　　　　说明
     　None        空值
       False       布尔假值
       0 0.0 0j　　　数字０
函数的调用语法：
　　　函数名（传参列表）
      说明：函数调用是一个表达式，一定会返回一个对象的引用关系（或者返回为none）、

预置（內建）　的数值型函数
　　abs(x) 取x的绝对值
　　round(number[,ndigit]) 对数值进行“四舍五入”
　　　　　　ndigit是小数向右取整的位数，负数表示向左取整
　　pow (x,y,z=None) 相当于　xy 或　xy%z

help() 函数查看函数的帮助
　　　　　help(函数名) #查看相应函数的帮助
语句　statement
语句由一些表达式组成，通常一条语句可以独立的执行来完成一部分事情并形成结果
多条语句写在一行内要用分号（;） 分开
示例见：
　　　code/statement.py
显示换行：
　　　当语句太长时，一行无法摆放，用 \ (反斜杠)进行显示
隐式折行
　　　所有的括号的内容换行，称为隐式折行
　　　能用于隐式折行的括号有：
　　　　　　（) [] {}
基本输入、输出函数
　　　　基本输入函数　input
　作用：　从一个标准输入设置上读取一个字符串（不包含换行符）
格式：
input(‘提示字符串’)
说明：
返回用户输入的字符串
‘提示字符串’可以为空
　　　　基本输出函数　print
格式：
print(value, …, sep=’ ‘, end=’\n’,
file=sys.stdout,flush=False)
将一系列的值以字符串形式输出到标准输出设备上（默认为终端）
参数选项：
　　sep:俩个值之间的分隔符（默认为一个空格’’）
end:输出完毕后在末尾自动追加一个字符串（默认为换行符’\n’）
file:流对象（默认为sys.stdout）
flush:

三、if 语句的作用　
　　让程序根据条件选择性的执行某条语句或某些语句
语法：
　　ｉｆ：真值表达式１：
　　　　　　语句１…
　　elif　真值表达式２
　　　　　　语句２．．
　　elif 真值表达式３
　　　　　　语句３．．
　　．．．
　　　else:
语句４
说明：
elif　子句可以有０个人，１个或多个
else 子句可以有０个或１个，且只能放在if语句的最后

ｉｆ　语句的嵌套
　　　ｉｆ语句本身是由多条子句组成的一条复合语句
　　　ｉｆ语句可以作为语句嵌套带另一个复合语句的内部
条件表达式
　　　语法：
　　　
　　　作用：
　　　　　根据真值表达式取值（Ture/False）来决定执行表达式１或者表达式２并返回结果
　　　　示例：
　　　　　
pass 语句
　　　作用：
　　　　　通常用来填充语法空白
　　　　　pass 又名空语句
　　　语法：
　　　　　pass

布尔运算：
　　运算符：
　　not and or
　　非　　　与　　或

布尔非操作　not
　　语法：
not x
作用：
对x进行布尔取非，如bool(x)　为Ture,则返回False,否则为Ture

布尔与操作　and
语法:
x and y
x ,y　代表表达式
作用：
优先返回假值对象，当x的布尔值为False时，返回x，否则返回y

布尔或操作　or
　　　语法
　　　　　x or y
　　　作用：
优先返回真值对象，当x为Ture时返回x，否则返回y

正负号运算符
　　＋（正号）　－(负号)

字符串　str
作用：
用来记录文字（文本）信息
表示方法：
　　在非注释中凡是用引号括起来的部分都是字符串
　’ 单引号
"　　　　双引号
‘’’　　　三单引号
“”"　　　三双引号
空字符串的字面值表达方法
‘’ “” ‘’’’’’ “”""""
非空字符串的字面值的表达方法
　　‘hello’ “hello” ‘’‘hello’’’ “”“hello”""
单引号与双引号区别
　　　单引号内的双引号不算结束符
　　　双引号内的单引号不算结束符

用转义序列代表特殊字符
　　字符串字面值中用字符反斜杠\后跟一些字符代表特殊
　　的一个字符，如：
转字格式　含义
　　　’ 代表一个单引号
"　　　　代表一个双引号
\　　　　代表一个反斜杠
\n　　　　换行
\r　　　　返回光标至行首
\f　　　　换页
\t　　　　水平制表符
\v　　　　垂直制表符
\b　　　　倒退
\0　　　　空字符（字符值为０）
\0oo　　　oo为俩位八进制表示字符
\xXX XX为俩位十六进制表示的字符
\uXXX 四位十六进制表示的Unicode 16字符
\UXXXXXXXX 八位十六进制表示的Unicode 32字符

ASCII编码表
　　　$ man ascii
常用的编码
　　字符　　十进制　　十六进制
　　‘0’ 48 0x30
‘A’ 65 0x41
‘a’　　 97 0x61

序列的概念
　　字符串是序列（有序排列）
　　所有的序列都能用len（x）　函数求其长度
len(x)　　函数
　　返回字符串中字符的个数

raw　字符串（原始字符串）
　　　格式：
　　　r’字符串内容’
　　　r"字符串内容"
　　　r’’‘字符串内容’’’
　　　r""“字符串内容”""
作用：
让转义符号反斜杠 \ 无效

字符串的运算
　　　运算符：
　　　＋　+=　* *=

 + 加号运算符用于拼接字符串
 +=　用于原字符串和右侧字符串拼接，再用变量绑定新的字符串
 *   运算符生成重复的字符串（字符串只能和整数相乘）
 *=  生成重复字符串，再用原变量绑定

字符串的比较运算
　　　运算符：
　　　< <= > >= == !=
　　　　比较规则：
　　　依次按编码值进行两两字符比较，一旦不同，则比较结束并返回
　　　比较结果，当编码值和长度完全相同时，俩个字符串相同

in ，not in 运算符
　　作用：
　　ｉｎ用于序列，字典，集合中，用于判断某值是否存在与容器
　　中，如果存在则返回Ture,否则返回False
　　ｎｏｔ　ｉｎ　与　ｉｎ的运算符的返回结果相反
　格式：
　　对象　ｉｎ　序列

四、字符串的基本操作

索引　index
　　　python字符串是不可以改变的字符序列

索引取值语法：
　　　字符串[整数表达式]
说明;
python的序列都可以用索引（index）来访问序列中的对象
python序列的正向索引是从０开始的，第二个索引为１，最后一个索引为len(s) -1
python序列的反向索引是从-1开始的，－１代表最后一个，-2代表倒数第二个人，以此类推，第一个是-len(s)
示例：
　　s = ‘ABCDE’
s[1] B
s[-1] E
s[100] IndexError 越界

python3中能用于字符串的函数
　len(x) 返回字符串长度
max(x)　　返回字符串编码值最大的字符
min(x)　　返回字符串编码值最小的字符

字符串的编码转换函数：
　　ord© 返回一个字符c的unicode编码值
chr(i) 返回i这个值所对应的字符

示例：
　　　　x = ord(‘A’)　　＃　x = 65
c = chr(66) ＃　c = ‘B’

整数转换为字符串的函数：
　　　bin(i) 将整数转换为二进制字符串
oct(i) 将整数转换为八进制字符串
hex(i) 将整数转换为十六进制字符串

字符串构造函数：
　　　str(obj)　　将对象转换为字符串

python3中常用的字符串方法（method）
　　　方法的调用语法：
　　　　　　对象、方法名（方法传参）

字符串格式化表达式
　　　　　作用：
　　　　　　　生成一定格式的字符串
　　　　　运算符：
　　　　　　%
语法格式：
　　格式化字符串　% 参数值
　　格式化字符串 % (参数值１，参数值２，参数值３,…)
说明：
格式化字符串中以%开头的字符为占位符，占位符的位置将用参数值替换
示例：
fmt = “name: %s, age : %d”
s2 = fmt % (“Tarena”,15)

格式化字符串中的占位符类型码
　　　占位符和类型码　　　　　含义
　　　　　　%s 　 字符串，使用str(x) 函数转换
　　　　　　%r 字符串，使用repr(x) 函数转换
%c 整数转为单个字符
%d　　　　　　　　 十进制整数
%o　　　　　　　　 八进制整数
%x　　　　　　　　 十六进制整数（字符a-f小写）
%X　　　　　　　　 十六进制整数（字符A-F大写）
%e 指数形浮点数（e小写）　　如：2.9e8
%E 指数形浮点数（E大写）　　如：2.9E8

占位符与类型码之间的格式语法
　　　　% [ - + 0 宽度.精度]　类型码
　　　 - 左对齐（默认是右对齐）
　　　　 + 显示正号
　　　　 0 左侧空白位置补零
　　　　宽度　整个数据输入的宽度
　　　　精度　保留小数点后多少位（默认是６位）

循环语句：
　　while 语句
　　for 　语句

while　语句：
　　　　作用：
　　　　　根据一定条件，重复执行一条语句或多条语句
　　　语法：
　　　　　while 真值表达式：
　　　　　　　　　语句块１
　　　　 else:
语句块２
说明：
１、限制性真值表达式，得到布尔值为Ture或False
2、如果真值表达式的值为Ture,则执行语句块１，然后在次返回到第一步，重复
　　进行测试真值表达式的值
３、如果真值表达式的值为False,则执行else子语句部分的语句块２，然后结束次while语句的执行
　　注：else子句部分可以省略（同if语句相似）

五、while语句的注意事项：
　　　１、控制循环的真值表达式的值来防止死循环
　　　２、通常用真值表达式内的循环变量来控制循环条件
　　　３、通常在语句内部改变循环变量

while语句的嵌套：
　　　while语句本身就是语句，和其他语句一样，可以嵌套到任何的复合语句中

示意：
　　　　　　 while　真值表达式：
　　　　　　　　　 ．．．
　　　　　　　　　　 while　真值表达式２：
　　　　　　　　　　　　　　．．．
　　　　　　　　　　 else:
…
…
else:
…

break 语句
问题：
如果在循环过程中不想再继续循环语句的执行，怎么办？
作用：
　　用于循环语句中，用来终止当前循环语句的执行
说明：
　　当break语句执行后，此循环语句break之后的语句将不在执行
　　break　语句通常和if语句组合使用
break 语句终止循环时，循环语句的else子句的语句不会执行
break　语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出嵌套的外重循环
break　语句只能在循环语句的内部使用

死循环
　　　死循环是指循环条件一直成立的循环
　　　死循环能通常用break语句来终止循环
　　　死循环的else子句永远不会执行

循环语句：
　　　while语句
for语句

for语句
作用：
　　用来遍历可迭代对象的数据元素
　　　　可迭代对象是指能一次获取数据元素的对象
　　如：
　　　　字符串、列表、元组、range函数返回的对象等
语法：
　　for 变量列表　in 可迭代对象：
　　　　　语句块１（此处是可能重复执行的语句块）
　　else:
语句块２
　说明：
　　　当在循环体内用break终止循环时，else子句部分的语句不会执行
　　　　else子句部分可以省略

range()函数
　　range(stop)　用来生成０～stop区间内的整数,直到stop为止（不包含stop）
range(start,stop[,step]) 用来生成start~stop区间内的整数，直到stop为止(不包含
stop),每个整数间隔step
作用：
　　用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）
示意：
　　　　range(4) 生成　0,1,2,3
range(3,6) 生成 3,4,5
range(1,10,2) 生成 1,3,5,7,9
range(5,0,-1) 生成　5,4,3,2,1
range(5,0,-2) 生成　5,3,1
range(4,0) 生成　空

continue 语句
　　　　　作用：
　　　　　　　　用于循环语句（while ,for）中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
　　　　　说明：
1、在while语句中执行continue语句，将会直接跳转while语句的真值表达式处，重新判断循环条件
２、在for语句中执行continue语句，将会从可迭代对象中取下一个数据绑定变量后再次进行循环

列表　list
　　　　列表是一种容器
　　　　列表是可以被改变的序列容器
　　　
　　　　创建列表的字面值
　　　　　　　L = [] # L　绑定一个新创建的空列表
　　　　创建空列表的字面值
　　　　　　L = [1,2,3,4]
L = [“北京”,“上海”,“广州”]
L = [1,“二”,3.14,“Four”]
L = [1,2,[3.1,3.2,3.3],4]
列表的构造函数（创建)　list
list() 创建一个空的列表，等同于[]
list(iterable) 用可迭代对象创建一个列表
　　　示例：
　　　　L = list() #L绑定空列表
　　　　L = list(“hello”) # L绑定[‘h’,‘e’,‘l’,‘l’,‘o’]
L = list(range(10)) ＃绑定[0,1,2,3,4,5,6,7,8,9]

列表的运算：
　　　　　算术运算
　　　　　　　+　+= * *=

六、列表的比较运算
　　　运算符：
　　　　　　< <= > >= == !=
说明：
　　　列表的比较规则与字符串的比较规则相同
　　　列表要求每俩个元素能依次进行比较，否则会出现类型错误
示例：
　　[1,2,3] < [1,2,4] #Ture
[1,2,3] !=[1,2,4] #Ture
[“one”,“two”] < [“1”,“2”] #False
[1,‘two’] > [‘two’,1] #TypeError
列表的　in / not in 运算符
　　　判断一个值是否存在于列表中，如果存在返回Ture,否则返回False
同字符串的　in 运算符类似
　
示例：
　　x = 　[1,‘two’,3,“四”]
　　3 in x # Ture
“3” in x # False

列表的索引操作
　　　　索引取值语法：
　　　　x = 列表[整数表达式]
　　　用法：
　　　　　等同于字符串的索引（同样分为正向索引和反向索引）

索引赋值
　　　　列表是可变的序列，可以通过索引赋值改变列表中的元素
　 语法：
　　　　列表[整数表达式] = 表达式
示例：
x = [1,2,3,4]
x[2] = 1 + 2.14 　＃改变了第三个元素的值
print(x)
列表的切片操作
　　切片取值
　　　列表[起始索引:终止索引:步长]
列表的切片取值是从原列表中取出想要的元素再次组成一个新的列表
示例：
L = [0,1,2,3,4,5,6,7,8,9]
y = L[1:10:2] # y = [1,3,5,7,9]
切片的赋值操作
　　作用：
　　　　可以改变原列表的排列，可以插入和修改数据
　　语法：
　　　　列表[切片]　＝　可迭代对象
　　说明：
　　　　切片赋值的赋值运算符(=)的右侧必须是一个可迭代对象
　　　　L = [2,3,4]
L[0:1]
切片的注意事项
　　　对于步长不等于１的切片赋值，赋值元素符的右侧的可迭代对象提供的元素的个数
　　　　一定要等于切片切出的段数
del 语句
　　　可以用于删除列表的元素
　　　语法：
　　　　　del 列表[整数表达式]
del 列表[切片]
示例：
　　L = [1,2,3,4,5,6,7,8,9]
del L[-1] #L = [1,2,3,4,5,6,7,8]
del L[1::2] ＃ L = [1,3,5,7,9]

python3中常用于序列的函数
len(x) 返回序列的长度
max(x) 返回序列的最大元素
min(x) 返回序列的最小元素
sum(x) 返回序列中所有元素的和（元素必须是数字类型）
any(x) 真值测试，如果列表中一个值为真值则返回Ture
all(x) 真值测试，如果列表中所有值为真值则返回Ture

python3中常用的列表方法（method）
/home/tarena/test/python_base_docs_html/list.html

深拷贝　deep copy 和　浅拷贝　　shallow copy
浅拷贝
是指在复制过程中，只复制一层变量，不会复制深层变量
绑定的对象的复制过程
如：
L = [3.1,3.2]
L1 = [1,2,L]
L2 = L1.copy()
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) #[1, 2, [3.1, 3.2]]
L2[2][0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]

深拷贝  deep copy
    如：
    import copy     #导入复制模块
    L = [3.1,3.2]  
        L1 = [1,2,L]
        L2 = copy.deepcopy(L1)   #深拷贝
        print(L1)   # [1, 2, [3.1, 3.2]]
        print(L2)   # [1, 2, [3.1, 3.2]]
        L2[2][0]    = 3.14
        print(L1)   # [1, 2, [3.1, 3.2]]
        print(L2)   # [1, 2, [3.14, 3.2]]

列表与字符串的比较
1. 列表和字符串都是序列，元素之间有先后顺序关系
2. 列表和字符串有相同的操作：+ += * *= < > in…
3. 字符串是不可变化的序列，列表是可变的序列
4. 字符串的每个元素只能存储字符，而列表可以存储任意的元素
5. 列表和字符串都是可迭代对象
字符串的文本解析方法　split 和　join
s.split(sep=None) 将字符串使用sep作为分割符分割字符串，返回分割后的字符串
列表，当不给定sep数时，用空白字符作为分隔符
s.join(iterable) 用可迭代对象中的字符串生成一个中间用S进行分隔的字符串

列表推导式 list comprehesion
列表推导式是用可迭代对象创建列表的表达式
作用：
创建列表
语法：
[表达式　for 变量 in 可迭代对象]
或
[表达式　for 变量 in 可迭代对象 if 真值表达式]
示例：
生成一个数值为１－９的平方的列表
L = [x**2 for x in range(1,10)]
列表推导式的嵌套语法：
[表达式
for 变量1　in 可迭代对象1　if 真值表达式1
for 变量2　in 可迭代对象2　if 真值表达式2
…]

七、
元组　tuple
元组是不可变的序列，同list一样，元组可以存储任意类数据的容器

元组的表示方法：
用小括号（）括起来，单个元素括起来后加逗号(,)区分单个对象还是元组

创建空元组的字面值：
t = ()　　　　＃创建一个空元组用t绑定
创建空元组的字面值
t = 200,
t = (20,)
t = (1,2,3)
t = 100,200,300

type(x)　函数返回x的类型

元组的构造函数 tuple
tuple()　 生成一个空的元组，等同于（）
tuple(iterable) 用可迭代对象生成一个新的元组

示例：
    t = tuple
    t = tuple("ABC")
    t = tuple(range(1,10,3))

元组的运算
+ += * *=

字典　dict
１．字典是一种可变的容器，可以存储任意类型的数据
２．字典中的每个数据都是用“键”(key) 进行索引的，
而不像序列(str,list,tuple)可以用整数进行索引
３．字典中的数据没有先后顺序关系，字典的存储是无序的
４．字典中的数据以键(key)-值(value)对形式进行存储
５．字典键不能重复，且只能用不可变类型作为字典的键
创建字典的字面值方式：
字典的表示方法以｛｝括起来，以冒号（:）分割键值对，各键值对之间用逗号
分隔开
创建空字典：
d = {}
创建非空字典：
d = {“姓名”:“tarena”,“年龄”:20}
创建字典的构造函数：
d = dict() #生成一个空的字典　等同于{}
d = dict(iterable) 用可迭代对象创建一个列表
d = dict(**kwargs) 关键字传参形式生成一个字典
l = [(1,2),(3,4),“ab”]
d =dict(l) #{1: 2, 3: 4, ‘a’: ‘b’}

l= dict(name="whf",age="20")
d = dict(l)   # {'age': '20', 'name': 'whf'}

字典的键必须为不可变类型的值

可变类型只有四种：
list(列表) dict(字典) set(集合)
bytearray(字节数组)

字典的基本操作
字典的键索引
语法：
字典[键]
作用：
用键获取字典的键对应的值
示例：
d = {‘name’:‘tarena’,‘age’:16}
print(d[‘name’],“的年龄是”,d[‘age’])
添加和修改字典的元素
语法：
字典[键] = 值
说明：
键不存在时，创建键，并让键绑定对应的值
键存在，修改键绑定的值
示例：
d = {}
d[‘name’] = “小红” #添加一个键值对
d[‘年龄’] = 20 #添加一个键值对
d[‘年龄’]　+= 1 #修改’年龄’这个键对应的值
删除字典元素
del 语句
语法：
del 字典[键]
示例：
d = dict(name=“张飞”,age=20)
del d[‘age’]
print(d) # {‘name’:‘张飞’}
字典的键判断　in ,not in 运算符
可以用　in 运算符判断一个键是否存在于字典中，
如果存在则返回True,否则返回False
not in 返回值与　in 相反
例如：
d = {‘name’:‘tarena’,‘age’:15}
‘name’ in d #True
15 in d #False
字典的迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {0:‘零’,5:‘五’,1:‘壹’,2:‘贰’}
for n in d :
print(n) #0,1,2,5
可以用于字典的函数
len(x) 返回字典键值对的个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典的所有键的和
any(x) 真值测试，只对键进行测试，只要有一个键为真值，
结果为True
all(x) 真值测试，所有键的真值结果为真才为True

字典推导式
字典推导式是用可迭代对象来创建字典的表达式
语法：
{键表达式 : 值表达式 for 变量 in 可迭代对象
[if 真值表达式]}
注：[]的内容可以省略
示例：
生成一个字典：键为数字0-9，值为键的平方
#如{0:0,1:1,2:4,3:9,…9:81}
d = {x:x**2 for x in range(10)}
print(d)
字典推导式的嵌套
语法同列表推导式嵌套

字典 VS 列表
1.都是可变的容器
2.索引方式不同，列表用整数索引，字典用键索引
3.列表的存储是有序的，字典的存储是无序的
4.字典的插入，删除，修改的速度可能会快于列表（重要）

八、
集合 set
集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变的对象
集合是可迭代的（可以用for语句遍历）
集合是相当于只有键没有值的字典（键则是集合的数据）

创建集合的构造函数
set ()
set(iterable)
示例：
s = set() #s 绑定空集合set()
s = set(range(1,5)) #s = {1,2,3,4,}
非空集合用{}括起来，内部元素用逗号(,)分隔

字面值方式创建非空集合
s = {1,2,3,4}
集合的运算：
交集 & 并集| 补集- 对称补集^ 子集< 超集>

集合是可迭代对象

集合推导式
集合推导式是用可迭代对象创建集合的表达式
‘语法：
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
示例：
l =[1,1,2,2,3,3,4,5,6]
s = {x ** 2 for x in l}
集合推导式的嵌套等同于列表推导式的嵌套

固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
固定集合构造函数
frozenset() 创建一个空的固定集合
frozenset(iterable) 用可迭代对象创建一个新的固定集合
示例：
fz = frozenset()
fz = frozenset(“hello”)
fz = frozenset([1,2,3,4,5,6,4,3 ])

阶段性总结：
数据类型
不可变的数据类型
bool, int, float, complex, str, tuple,
frozenset, bytes(字节串)
可变的数据类型
list, dict, set, bytearray(字节数组)
值:
None, False, True

运算符：
    + - * / // % **
    > < >= <= == !=
    in / not in
    is / is not 
    not and or 
    & | ^
    + (正号) - (负号)
    [] #索引和切片
表达式：
    1 
    True
    1 + 2 * 3
    print("hello") #函数调用
    l.pop(2) #方法调用也是表达式
    sum([1,2,5,10])
    条件表达式：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

内建函数：
     lex(x)
     max(x)
     min(x)
     sum(x)
     any(x)
     all(x)
     ---------------构造函数-------------
     bool(x)
     int(x)
     float(x)
     complex(x)
     str(x)
     list(x)
     tuple(x)
     dict(x)
     set(x)
     frozenset(x)
     -------------------------------
     abs(x)
     round(x,y)
     pow(x,y,z=None)
     -------------------------------
     bin(x)
     oct(x)
     chr(x)
     ord(x)
     ------------------------------
     range(start,stop,step)
     --------基本输入输出函数
     input(x)
     print(....)
     ------------------------------
     id(x)      #返回内存地址
     type(x)    #返回类型

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
　函数 function
什么是函数
函数是可以重复执行的语句块，可以重复调用并执行
函数是面向过程编程的最小单位
作用：
用于封装语句块，提高代码的重要性
定义用户级别的函数
提高代码的可读性和易维护性
　def 语句
语法：
def 函数名（形参列表）：
语句块
作用：
　　创建一个函数，将语句块打包，用函数名绑定，用来调用
说明：
函数名的命名规则与变量的规则相同(必须为标识符)
函数名是一个变量，它用来绑定函数
函数有自己名字空间，在函数外部不可以访问函数内部的变量，
在函数内部可以访问函数外部的变量，但不能对外部的变量赋值
语句部分不能为空，如果为空需要填充pass语句
函数如果不需要传入参数，形参列表可以为空
函数调用：
语法：
函数名（实际调用传递参数）
说明：
函数调用是一个表达式
如果函数内部没有return语句，函数执行完毕后返回None对象的引用
return 语句
语法：
return　[表达式]
注：[]代表其中内容可以省略
作用：
用于函数中，结束当前函数的执行，返回到调用该函数的地方，
同时返回一个对象的引用关系
说明：
1.return　语句后跟的表达式可以省略，省略后相当于return None
2.函数内部没有return语句，则函数执行完最后一条语句后返回None
(相当于在最后加了一条return语句)

九、
函数的传参　（把数据给函数）
函数的形参　（接受函数调用传过来的数据）

python　函数的参数传递
传递方式：
1. 位置传参
1.1 序列传参
2. 关键字传参
2.1　字典关键字传参
位置传参：
实际参数(实参)的对应关系与形式参数(形参)的对应关系
按位置来依次对应的
说明：
实参和形参通过位置进行传递和匹配
实参的个数必须与形参的个数相同
序列传参
序列传参是指在函数调用过程中，用*(星号)将序列拆开
按位置进行传递的传参方式
说明：
序列传参时，序列拆解的位置将与形参一一对应
关键字传参：
关键字传参是指传参时，按着形参名称给形参赋值
实参和形参按名称进行匹配
说明：
可以不按位置进行
字典关键字传参：
指实参为字典，将字典用**拆解后的关键字传参的传递方式
说明：
字典的键名和形参名必须一致
字典的键名必须为符合标识符命名规则的字符
字典的键名要在形参中存在
函数的综合传参
函数的传参方式在能确定形参能唯一匹配到相应实参的情况
下可以任意组合
函数的位置传参要先于关键字传参
-----------------函数的形参－－－－－－－－－－－－－
函数的缺省参数：
语法：
def 函数名(形参名1=默认实参1,形参名2=默认实参2,
形参名3 = 默认实参3,…)
作用：
让函数的调用者少传递参数来调用函数
示例：
说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数
则其右侧的索引参数都必须有缺省参数
缺省参数可以有０个，或多个，甚至全部都有缺省参数
示例：
def fn (a,b=10,c):
pass #错误

    def fn (a=0,b=None,c=False):    
        pass                    #这是对的

函数的可变实参和不可变实参的传递
说明：
当一个可变对象通过函数实参传入函数内时，在函数内可以通过局部
变量来操作可变对象（列表，字典，集合．．）

面试题：
    试运行一下程序的结果是什么?为什么？
    l = [1,2]
    def fn (a,lst=[]):
        lst.append(a)
        print(lst)
    fn (3,l)
    fn (4,l)
    fn(5)
    fn(6)
    fn(7)

函数形参的定义方式
位置形参
星号元组形参
命名关键字形参
双星号字典形参

    位置形参：
        语法：
            def 函数名 (形参变量１,形参变量2,...):
                语句块
    星号元组形参：
        语法：
            def 函数名(*元组形参名)：
                语句块
        作用：
            收集多余的位置传参
        说明：
            元组形参名一般命名为'args'
            *元组形参一个函数只能有一个
    命名关键字形参
        语法：
            def 函数名(*,命名关键字形参1,命名关键字形参2,...):
                语句块
            def 函数名(*args,命名关键字形参1,命名关键字形参2,...):
                语句块
        作用：
            强制所有的命名关键字形参都必须用关键字传参或字典
            关键字传参
    双星号字典形参
        语法：
            def 函数名(**字典形参名)：
                语句块
        作用：
            收集多余的关键字传参
        说明：
            字典形参名一般命名为'kwargs'
            一个函数内字典形参最多只有一个

函数的形参说明：
位置形参，缺省参数，星号元组形参，双星号字典形参可以混合使用
函数形参自左至右的定义顺序为：
位置形参
星号元组形参
命名关键字形参
双星号字典形参
示例：
def fn (a,b,*args,c,**kwargs):
pass
fn(1,2,3,4,c=30,d=40,e=500)
函数的不定长参数：
有俩种：星号元组形参，双星号字典传参
用不定长参数可以接受任意的传参
如：
def fn(*args,**kwargs):
print(args,kwargs)

全局变量和局部变量
局部变量
定义在函数内部的变量称为局部变量（函数的形参也是局部变量）
局部变量只能在函数内部使用
局部变量在函数调用时才能创建，在函数调用之后会自动销毁
全局变量
定义在函数外部，模块内部的变量称为全局变量
全局变量所有的函数都可以直接访问（但函数内部不能直接赋值）
说明：
函数内部赋值语句不会对全局变量造成影响

十、
globals()函数和 locals()　函数
globals ()　返回当前全局作用域内变量的字典
locals() 返回当前局部作用域内变量的字典

函数变量
函数名是变量，他在创建函数时绑定一个函数
示例: day10.py

一个函数可以作为另一个函数的实参传递
可以把一个函数给另一个函数，另一个函数的形参变量将绑定实参函数
函数可以作为另一个函数的返回值

函数的嵌套定义
函数嵌套定义是指一个函数里用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 变量名１，变量名２，．．．．
说明：
１． 全局变量如果要在函数内部被复制，则必须经过全局声明
（否则会被认为是局部变量）
２． 全局变量在函数内部不经过声明就可以直接访问（取值）

　３．　不能先创建局部变量，再用global声明为全局变量
        这种做法不符合规则
  ４．  global变量列表里的变量名不能出现在函数的形参列表里

nonlocal 语句
作用：
告诉解释器，nonlocal声明的变量不是局部变量，
也不是全局变量，而是外部嵌套函数内的变量
语法：
nonlocal　变量名１，变量名２，．．．．
说明:
　　１． nonlocal语句只能在被嵌套函数内部进行使用
　　２． 对nonlocal变量进行赋值将对外部嵌套函数作用域内
的变量进行操作
３． 当有倆层或者倆层以上函数嵌套时，访问nonlocal变量只对
最近的一层变量进行操作
　　４． nonlocal语句的变量列表里的变量名不能出现在此函数的形参列表中
lambda 表达式（又称匿名函数）
作用：
创建一个匿名函数对象
同def类似，但不提供函数名
语句：
lambda [函数形参列表]:表达式
说明：
lambda表达式创建的函数只能包含一条表达式
lambda比函数简单，且可以随时创建和销毁，有利于
降低程序的偶合度
eval 函数和exec()函数
eval(source,global=None,Local=None),把一个字符串
source　当成一个表达式来执行，返回表达式执行后的结果
exec(source,global=None,Local=None) 把一个字符串source
当成程序来执行

十一、
函数式编程
函数式编程是指用一系列函数解决问题
函数是一等公民(Guido)

好处：
    用每一个函数完成细小的功能，一系列函数的任意组合可以解决大问题
    函数仅接收输入并产生输出，不包含任何能影响输出的内部状态

函数的可重入性
当一个函数的输入实参一定，结果也必然一定的函数称为可重入函数
说明：
可重入函数在函数内部一定不访问除局部变量以外的变量

高阶函数　High Order Function
map filter sorted

什么是高阶函数
    满足下列条件中一个的函数即为高阶函数
        １．函数接受一个或多个函数作为参数传入
        ２．函数返回一个函数
    map 函数
        map(func, *iterables)   返回一个可迭代对象，此可迭代对象用
            函数func对可迭代对象iterables中的每一个元素作为参数计算后得到结果;
            当最短的一个可迭代对象不再提供数据时此可迭代对象生成结束

        filter(function, iterable)
            返回一个可迭代器对象，此可迭代对象将对iterabler获取到的数据
            用函数function 进行筛选.function将对iterable中的每个元素进行求值，
            返回False则将此数据丢弃，返回True，则保留此数据
            
        sorted(iterable,key=None,reverse=False)
            返回一个新的包含有所有可迭代对象中数据升序排序的列表
            iterable 可迭代对象
            key 函数是用来提供一个值,这个值将作为排序的依据
            reverse 标志用来设置是否降序排序

递归函数 recursion
函数直接或间接的调用自身
#函数直接调用自身
def f():
f() #调用自己
f()

    #函数间接调用自身
    def fa():
        fb()
    def fb():
        fa()
    fa()

递归说明：
递归一定要控制递归的层数，当符合某一条件时要终止递归　
几乎所有的递归都能用while循环来替代
递归的优缺点：
优点：递归可以把问题简单化，让思路更为清晰，代码更简洁
缺点：递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果
递归函数的执行分为俩个阶段：
递推阶段：调用进入函数内部
回归阶段：返回结果，得到最终结果
示例见：
recursion.py

闭包 closure
什么是闭包
闭包是引用了此函数外部变量的函数
（外部变量包括：外部嵌套函数作用域内的变量）
闭包必须满足三个条件
１．必须有一个内嵌函数
２．内嵌函数必须引用外部函数中的变量
３．外部函数返回值必须是内嵌函数
注意点：
由于闭包会使得函数中的变量都备保留在内存中，
内存消耗比较大，所以不能滥用闭包
示例见 closure.py

十二、
装饰器 decorators(专业提高篇)
什么是装饰器
装饰器是一个函数，主要作用用来包装另一个函数或类
包装的目的是在不改变原函数名（或类名）的情况下改变或添加被包装对象的行为

函数的装饰器
    是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数

    语法：
        def 装饰器函数名（参数）：
            语句块
            return　函数对象

        ＠装饰器函数名<换行>
        def 函数名（形参列表）：
            语句块

函数的文档字符串
函数内第一次未赋值给任何变量的字符串是此函数的文档字符串

语法：
    def 函数名（参数列表）：
        '函数的文档字符串'
        语句块
示例：
    def hello(name):
        '''这是一个向别人问好的函数
        name 绑定人的姓名
        '''
        ｐａｓｓ
说明：
    文档字符串通常迎来说明此函数功能的使用方法
    函数的文档字符串绑定在函数对象的__doc__属性上

函数的__doc__属性
__doc__属性用于绑定函数的文档字符串

函数定义语句的完整的语法
[@装饰器名1]
[@装饰器名2]
…
def 函数名([位置形参],[*元组形参],[命名关键字形参]
,[**字典形参]):
‘文档字符串’
语句块

模块 Module
什么是模块
模块是一个包含有一系列数的数据，函数，类等组成的程序
模块是一个文件，模块文件通常以.py结尾
作用：
1. 让一些相关数据，函数，类等有逻辑的组织在一起，
逻辑结果更加清晰
2. 模块中的数据，函数和类等可提供给其他模块或程序调用
模块分类：
1.内置模块，在解析器的内部可以直接使用
2.标准库模块，在安装python时已安装，且可直接使用
3.第三方模块（通常为开源），需要自己安装
$ pip3 install 模块名
4.用户自己编写的模块（可以作为其他人的第三方模块）

模块的导入 import 语句
import 语句
语法：
import 模块名１　[as 模块新名1],模块名2 [as 模块新名2]
作用：
将某模块整体导入到当前模块
示例：
import math
import sys, os
用法：
　模块名.属性名
　math.factorial(5)

    　dir(obj)    函数，返回模块的所有属性的字符串列表
    　help(obj)   函数，可以查看模块相关的文档字符串

from import 语句
    语法：
        from 模块名 import 模块属性名 [as 属性新名１],模块属性名2 [as 属性新名2],...
    作用：
        将某模块内的一个或多个属性导入到当前模块的作用域
    示例：
        from math import sin,cos,tan
        from math import pi
        from math import factorial as fac
        print(sin(pi/2)*fac(5))
from import * 语句
    语法：
        from 模块名　import *
    作用：
        将某模块的所有属性导入到当前模块

dir([对象]) 返回一个字符串列表
dir 函数作用：
如果没有参数调用，则返回当前作用域内所有变量的列表
如果给定　一个对象作为参数，则返回这个对象所有变量的列表
对于一个模块，返回这个模块的全部变量（属性）
对于一个类对象，返回类对象的所有变量，并递归基类对象的所有变量
对于其他对象，返回所有变量，类变量和基类变量
数学模块
模块名：math

时间模块　time
此模块提供时间相关的函数

系统模块　sys
运行时系统相关的信息

十三、
自定义模块并导入
要求：
模块文件名必须以.py结尾
模块文件名必须是合法的标识符
避免名称和內建模块名冲突
导入方式：
import　语句
from import 语句
from import * 语句
示例见
mymod.py

import 语句查找模块文件的路径顺序
import 模块名　#去哪找这个’模块名.py’

1.搜索內建模块
2.搜索程序运行时的路径（当前路径）
3.sys.path 提供路径
    sys.path 是一个列表，内部存入的都是模块的搜索路径
        >>> import sys
        >>> print(sys.py)
安装第三方模块或包
    pip3 install 模块名
让import 语句能找到自己的模块
    1.把自己写的模块放到sys.path中的某个文件夹内
    2.修改sys.path列表，在内部添加一个文件夹的字符串
        （注：此做法只对当前程序起作用）
        如：
            import sys
            sys.path.append('/houme/tarena')

模块化编程优点
1.有利于多人合作开发
2.是代码更加易于维护
3.提高代码的复用率
4.有利于解决变量名冲突问题（模块内的全局变量的作用域　
为模块内全局）
模块的加载过程
在模块导入时，模块内所有语句都会执行
如果一个模块已经导入，则再次导入时不会重新执行模块内的语句
模块被导入和执行的过程
1.先搜索相关路径找到　模块名.py
2.判断是否有此模块对应的pyc文件,如果.pyc文件比.py
文件新则直接加载.pyc文件
3.如果,pyc文件比.py文件旧，则用模块名.py生成.pyc文件,并加载执行
模块的编译
编译 解释执行
mymod.py------> mymod.pyc ------->python3

模块的属性
__doc__属性
用于绑定模块的文档字符串
模块的文档字符串用于help(模块)　函数提供帮助信息

__file__属性
    用于绑定模块的文件路径名

__name__属性
    用来记录模块自身的名字
    作用：
        记录模块名
        用来判断是否为主模块
    说明：
    当模块作为主模块（也就是第一个运行的模块）运行时
    __name__属性绑定　'__main__'

    当此模块不是主模块时，__name__属性绑定模块名
模块的__all__列表
    作用：
        当from xxx import * 语句导入时，只导入__all__列表内的属性
    说明：
        __all__列表是一个用来存放可导出属性的字符串列表
模块的隐藏属性
    模块中以'_'开头的属性，在用from xxx import * 导入时
    将不被导入，通常称这些属性为隐藏属性

随机模块　random
作用：
用于模拟或生成随机输出的模块

练习：　用random模块随机为自己生成一个６位数的数字密码
442260

包（模块包）　　package
包是将模块以文件夹的组织形式进行分组管理的方法

作用：
    将一系列模块进行分类管理，有利于防止命名冲突
    可以在需要时加载一个或部分模块，则不是全部模块
示例：

包的导入
同模块的导入规则
import 包名　[as 包名]
import　包名.模块名 [as 模块新名]
import　包名.子包名.模块名 [as 模块新名]

from  包名 import 模块名　[as 模块新名]
from　包名.子包名　import 模块名 [as 模块新名]
from　包名.子包名.模块名　import 属性名 [as 模块新名]

init.py 文件
init.py 是常规包内必须存在的文件
init.py 会在包加载时被自动调用

作用：
    编写此包的内容
    在包内填写包的文档字符串
    在__init__.py　文件内可以加载此包所以来的一些其他模块

init.py内的__all__列表
作用：
用来记录此包中有哪些包或模块需要导入
当用from 包 import * 语句导入模块时，只查找　all
中的所有模块或子包
说明：
__all__列表　只在 from xxx import * 起作用

import 语句搜索包的路径的顺序
1. 搜索程序运行时的路径（当前工作目录）
2.sys.path提供的路径

包的相对导入
包的相对导入是指包内模块的相互导入
语法：
from 相对路径包或模块　import 属性或模块名
或
from 相对路径包或模块　import *
相对路径：
在 from import 语句和　from import * 语句中可以用相对路径　　
. 代表当前目录
…代表上一级目录
…代表上二级目录
…依次类推
注：相对导入时不能超出包的外部

十四、
异常 exception(基础)
什么是错误
错误是指由逻辑或语法等导致程序无法正常执行的问题

特点
无法预知

什么是异常、
异常是程序出错时标识的一种状态，当异常发生时，程序不会向下
执行，而转去调用此函数的地方待处理此错误并恢复为正常状态
作用：
用作信号通知，通知上层调用者有错误产生需要处理
程序有两种状态：
正常状态／异常状态

try 语句　的两种语法
try-except语句
try-finally语句

try-except语句的语法
try:
可能触发异常的语句
except 错误类型1 [as 变量1]:
异常处理语句1
except 错误类型2 [as 变量2]:
异常处理语句2
except (错误类型3,错误类型4) [as 变量3]:
异常处理语句3
…
except:
异常处理语句other
else:
未发生异常语句
finally:
最终语句
作用：
尝试捕获错误，得到异常通知，将程序由异常状态转换为正常状态
并继续执行
说明：
as 子句是用于绑定错误对象的变量，可以省略
except　子句可以有一个或多个，但至少有一个
else　子句最多只能有一个，也可以省略
finally　子句最多只能有一个，也可以省略
示例见：
try_except.py

python3中全部错误类型：
文档参见

try-finally语句
语法
try:
可能触发异常语句
finally:
最终语句
说明：
finally子句不可以省略
一定不存在 except子句
作用：
通常用 语句来做触发异常时必须要处理
的事情无论异常是否发生，finally子句都会被执行
注：
try_finally语句不会改变程序的(正常／异常)状态

raise 语句
作用：
触发一个错误让程序进入异常状态
发送错误通知给调用者
语法：
raise　异常类型
或
raise 异常对象
或
raise　#重新触发上一次异常
示例见：
raise.py

assert 语句（判断语句）
语法：
assert 真值表达式，错误数据（通常是字符串）
作用：
当针织表达式为False时，用错误数据创建一个
AssertionError类型的错误，并进入异常状态
通常用来故意制造一个错误
等同于：
if bool(真值表达式) == False:
raise AssertionError(错误数据)
示例见：
assert.py

异常中的语句小结：
try_except 语句
用于捕获（接收）错误通知，把异常
状态转为正常状态

try_finally语句
用于执行在任何状态都必须要执行的语句

raise 语句
触发错误(发送错误通知)，让程序进入异常状态

assert 语句
根据条件触发　AssertionError类型的错误通知

迭代器　Iterator
什么是迭代器
迭代器是访问可迭代对象的工具
迭代器是指iter(obj) 函数返回的对象(实例)
迭代器可以用next(it) 函数获取可迭代对象的数据

迭代器函数 iter 和　next
iter(iterable) 从可迭代对象中获取一个迭代器，iterable
必须是能提供一个迭代器的可迭代对象
next(Iterator) 从迭代器 Iterator中获取下一个记录，如果无法获取
下一条记录，则触发　StopIteration异常
说明：
迭代器只能往前取值，不会后退
用　iter 函数可以返回一个可迭代对象的迭代器

十五、
生成器 Generator
什么是生成器：
生成器是能够动态提供数据的可迭代对象
生成器在程序运行时生成数据，与容器类不同，他通常不会在内存中
保存大量数据，而是现用现生成

好处：
不占用计算机内存
生成器有俩种：
生成器函数
生成器表达式

生成器函数的定义
含有　yield 语句的函数是生成器函数，此函数被调用将返回一个生成器对象
yield　翻译为(产生或生成)

yield　语句
语法：
yield 表达式
说明：
yield 只能用于 def函数中，目的是将此函数作为生成器函数使用
yield 用来生成数据，供迭代器的 next(it) 函数使用
示例见：
yield.py
说明：
生成器函数的调用将返回一个生成器对象，生成器对象是一个可迭代对象
生成器函数用　return　会触发一个 StopIteration 异常（即生成结束）

生成器实用示例见：
myinteger.py

生成器表达式
语法：
(表达式　for 变量 in 可迭代对象　[if 真值表达式])
作用：
用推导式形式创建一个新的生成器
说明：
if 子句可以省略
生成器表达式也可以像列表推导式一样嵌套

迭代工具函数
迭代工具函数的作用是生成一个符合条件的可迭代对象

zip(iter1[,iter2[,...]]) 返回一个zip生成器对象
        此对象用于生成一个元组，次元组的数据分别来自于
        每个参数中的可迭代对象，生成元组的个数由最小的
        一个可迭代对象决定

enumerate(iterable,start=0) 返回一个 enumberate生成器对象
此对象生成类型为(索引，值对)的元组
默认索引从零开始，也可以用　start指定

字节串(字节序列)　bytes
存储以字节为单位的数据
字节串是不可变的字节序列
说明：
字节是0-255之间的整数，用来表示一个字节的取值
创建空字节串的字面值方式：
b ‘’
b “”
b ‘’’’’’
b “”""""
创建非空字节串的字面值
b ‘ABC’
b “ABC”
b ‘’‘aaa’’’
b “”“bbbb”""

字节串的构造函数　bytes
bytes() 生成一个空的字节串，等同于b’’
bytes(整数可迭代对象) 用可迭代对象初始化一个字节串
bytes(整数n) 生成n个值为０的字节串
bytes(字符串，encoding=‘utf-8’) 用字节串转换编码生成
一个字节串

示例见： 
    B = bytes()
    B = bytes(range(0x41,0x61))
    B = bytes([65,66,67,68])
    B = bytes(10)
    B = bytes('hello','utf-8')

字节串的运算：
+ += * *=
< <= > >= == !=
in / not in
索引和切片
函数：
len(x), max(x), min(x), sum(x), any(x), all(x)

bytes 与　str 的区别：
bytes 存储字节（０－２５5之间的整数）
str　存储UNICODE字符(0~0x10FFFF)的字符
bytes 与　str 的转换：
编码（encode）
str ------------------>bytes
b = s.encode(encoding = ‘utf-8’)

        解码（decode）
    bytes ------------------> str
         s =b.decode(encoding='utf-8')

示例见：
s = ‘ABC中文’

字节数组　bytearray
可变的字节串
字节数组的构造函数　bytearray
bytearray()
bytearray(整数可迭代对象)

十六、
文件　File
文件是用于存储数据的基本单位
文件通常用来长期存储数据
文件中数据是以字节为单位进行顺序存储的

文件的操作流程
1.打开文件
2.读／写文件
3.关闭文件
注：任何操作系统，一个应用程序同时打开文件的数量有最大数限制

文件的打开函数
open(filename,mode=‘rt’)用于打开一个文件，返回
此用来操作此文件的文件流对象，如果打开失败，则会触发
OSError错误通知

文件流对象的关闭方法
F.close() 关闭文件.释放系统资源

示例见：
    file_open.py

以十六进制方式显示文件内容命令：
$ xxd 文件名

python中文本文件的读写操作：
文档参见:

文件流对象的 readlines方法见示例
readlines.py

python3文本文件模式：
模式字符 ‘t’
说明：
对文本文件的读写操作需要用字符串(str)进行读写操作
在读写过程中会自动进行编码(encode)和解码(decode)操作
以行为单位分隔，在python内部同意用’\n’作为换行符进行分隔

各操作系统的换行符：
    Linux换行符：'\n'
    Windows换行符：'\r\n'
    新的Mac OS换行符：'\n'

文本文件的写操作：
方法：
F.write(x)
F.writelines(列表)
模式字符串：
‘w’
‘x’
‘a’
参见文档
示例见 file_write_text.py

二进制文件操作
二进制模式字符：‘b’
默认文件中存储的都是以字节(byte)为单位的数据，通常人人为的格式
对二进制文件的读写需要用字符串(bytes)或字节数组(bytearray)进行操作

对于二进制文件读写方法都需要用字节为单位进行操作
    F.rend(n)
    F.readline()
    F.readline()
    F.write(字节串)
    F.writelines(字节串组成列表)
示例见：
    file_read_binary.py


二进制文件的写操作
    示例见： file_writ_binary

F.seek方法
作用：
设置文件的读写位置，返回新的读写位置
格式：
F.seek(偏移量,whence=相对量)
偏移量
大于０代表向文件末尾方向移动
小于０代表向文件头方向移动
相对位置
0代表文件头开始偏移
1代表从当前读写位置开始偏移
2代表从文件尾开始偏移
示例见
seek.py

标准输入输出文件
模块名
sys
sys.stdin 标准输入文件（默认为键盘）
sys.stdout 标准输出文件（默认为屏幕终端）
sys.stderr 标准错误输出文件（默认为屏幕终端）

标准文件不需要打开即可使用，也不用手动关闭　

汉字编码只有俩种
国标系列：(Windows常用)
GB18030(二字节或四字节编码，27533个字)
GBK(二字节编码，20013个字)
GB2313(四字节编码，约７千多字)

国际标准：(Linux/Mac OS X/ IOS/Android常用)
UNICODE(UNICODE16/UNICODE32)<-->UTF-8
    UTF-8中：
    英文ASCII(0x0-0x7F) 一字节
    (0x80-0x3FF)        二字节
    (0x400-0xFFFF)      三字节(中文在此区)

python编码字符串
‘gb2312’
‘gbk’
‘gb18030’
‘utf-8’
‘ascii’
…

如:
s = “你好”
print(s.encode(‘gbk’))
print(s.encode(‘utf-8’))
print(s.encode(‘ascii’))#出错,"你好"不在ascii内

编码注释:
在源文件中,第一行或第二行写入的如下内容是编码注释

-- coding:gbk --

或

-- coding:utf-8 --

十七、
面向对象编程：Object-Oriented Programming
俩种编程思想：
面向过程编程
最小单位是：函数
面向对象编程
最小单位是：类　class

什么是对象：
对象是指现实中的物体或实体
什么是面向对象
把一切看成对象（实例）用各种对象之间的关系来描述事物

对象都有什么特征：
对象有很多属性（名词，形容词）

对象有很多行为（动作，动词）

什么是类
拥有相同属性和行为的对象分为一组，即为一类
类是用来描述对象的工具，用类可以创建此类的对象（实例）

类的创建语句：
语法：
class 类名（继承列表）：
‘’‘类的文档字符串’’’
实例方法（类内的函数method）定义
类变量
类方法（@classmethod）
静态方法（@staticmethod）
作用：
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个对象
说明：
类名必须是标识符
类名实质是变量他绑定一个类
示例见
class.py
构造函数
格式：
类名([传参列表])
作用：
创建这个类的实例对象，并返回次此例对象的引用关系

说明：
对象（实例）可以调用类方法和实例方法
对象（实例）有自己的作用域和名字空间，可以为该实例添加实例变量（也叫实例属性）

实例方法（instance method）
定义格式：
class 类名(继承列表)：
def 实例方法名(self,参数１，参数２，．．．)：
‘’‘方法的文档字符串’’’
语句块
作用：
用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
说明：
实例方法的实质是函数，是定义在类内的函数
实例方法至少有一个形参，第一个形参绑定调用此方法的实例，
一般命名为’self’
实例方法的调用语法
实例.实例方法名(调用传参)
或
类名.实例方法名(实例,调用传参)

实例属性　attribute (也叫实例变量)
每个实例可以用自己的变量来记录每个对象自己的数据，这个变量
称为实例变量
使用语法：
实例.属性名
赋值规则：
首次为属性赋值则创建此属性
再次为属性赋值则改变此属性的绑定关系
作用：
记录每个对象自身的数据
示例
instance_attribute.py

删除属性：
del 对象.实例变量名
del 语句总结
１．删除变量　 del a,b,c
２．删除列表中的元素 del l[0],l[0:3]
３．删除字典中的键 del d[‘name’]
４．删除属性 del obj.name

初始化方法
作用：
对新创建的对象添加属性
语法格式：
class 类名(继承列表)
def init(self[,形参列表])
语句块
注：[]代表内容可省略
说明：
１．初始化方法的名必须是’init’不可改变
２．初始化方法会在构造函数创建实例后自动调用，且将实例自身
通过第一个参数self传入 'init’方法
３．构造函数的实参将通过 __init__方法的参数列表传入到 __init__方法中
４．初始化方法内如果需要return返回，则必须返回None
实例见：
init_method.py

析构方法
格式：
class 类名(继承列表)
def del(self):
…
作用：
在此对象销毁前释放此对象所占用的资源
说明：
析构方法在对象被销毁钱会自动调用
python语音建议不要在对象销毁时做任何事情，因为销毁的时间难以确定
示例见
del_method.py

预置实例属性
__dict__属性
__dict__属性绑定一个存储此实例自身变量的字典

示例：
    class Dog:
        pass
    dog1 = Dog()
    print(dog1.__dict__) #{}
    dog1.color = '白色'
    print(dog1,__dict__) #{'color':'白色'}

__class__属性
    __class__属性绑定创建此实例的类
    
    作用：
        可以借助与此属性来访问创建此实例的类
    示例：
        class Dog:
            pass
        dog1 = Dog()
        print(dog1.__class__)        

用于实例对象的函数：
isinstance(obj,class_or_tuple) 返回这个对象obj是否
是某个类的对象，或者某些类中一个类的对象，如果是则返回
Ture ,否则返回False
type(obj) 返回对象的类型

练习：
有俩个人：
第一个人：　姓名：张三，年龄：３５岁
第二个人：　姓名：李四，年龄：１５岁
行为：
１．教别人学东西　teach
２．工作赚钱 work
３．借钱 borrow
４．显示自己的信息 show_info

事情：
    张三　教　李四　学　python
    李四　教　张三　学　王者荣耀
    张三　上班赚了　1000　元钱
    李四　向　张三　借钱　200　元
    35　岁的　张三　有钱　800　元，他学会的技能是：王者荣耀
    15　岁的　李四　有钱　200　元，他学会的技能是：python

十八、
类
定义方式：
class 类名：
．．．
类也是对象，他是能创建实例的对象
类变量
类变量是类的属性，此属性属于类，不属于此类的实例
作用：
通常用来存储该类创建的对象的共有属性
说明：
类变量可以通过给雷直接访问
类变量可以通过类的实例直接访问(取值)
类变量可以通过此类的对象的　__class__属性间接访问
示例见：
class_varible.py
实例方法和类方法都是类的变量(类变量)
类的文档字符串：
类内第一个没有赋值给仍然变量的字符串为类的文档字符串
类的文档字符串绑定在类的　doc 属性上

类的 slots 列表：
作用：
限定一个类创建的实例只能在固定的属性（实例变量）
不允许对象添加此列表以外的实例属性
防止用户因错写属性名而发生程序错误
说明：
__slots__属性是一个列表，列表的值是字符串
含有　__slots__属性的类所创建的实例对象没有
__dict__属性，即此实例不用字典来存储实例属性
类方法 @classmethod
类方法是用于描述类的行为的方法，类方法属于类，不属于
该类创建的对象

说明：
    类方法需要使用　@classmethod　装饰器定义
    类方法至少有一个形参，第一个形参用于绑定类，约定写为'cls'
    类和该类的实例都可以调用类方法
    类方法不能访问此类创建的对象的实例属性
实例见：
    classmethod.py

静态方法　@staticmethond
静态方法是定义在类内的函数，此函数的作用域是类的内部

说明：
静态方法需要使用　@staticmethond装饰器定义
静态方法与普通函数定义相同，不需要传入self和cls参数
静态方法只能凭借该类或类的实例调用
静态方法不能访问类变量和实例变量

函数，静态方法，类方法，实例方法
共性：
语句块，实现相应的功能

继承 inheritnce　和 派生 derived
什么是继承／派生
派生就是从一个已有的类中衍生成心累
继承是指在衍生出新类中的对象会拥有原类的属性和行为
作用：
用继承派生机制，可以将一些共有功能加在基类中，
实现代码共享
在不改变基类代码的基础上，改变原有类的功能
名词：
基类(base class)/超类(super class)/父类(father class)
派生类(derived class) / 子类 (child class)

单继承
语法：
class 类名(基类名):
语句块

说明：  
    单继承指的是派生类由一个基类衍生出来的类

继承说明：
python3中任何类都直接或间接的继承自object类
object类是一切类的超类

类的　__base__属性
__base__属性用来记录此类的基类
python內建类的继承关系见：
>>>help(builtins)

覆盖　overridde
覆盖是指在有继承关系的类中，子类实现了与基类同名的方法
，在子类的实例调用该方法时，实际调用的是子类额覆盖版本，这种
现象叫做覆盖

作用“
    实现和父类同名，单功能不同的方法

super函数
super(cls,obj) 返回绑定超类的实例(要求obj必须是cls 类或cls子类的对象)
super()　返回绑定超类的二十里，等同于：
super(class,实例方法的第一个参数),必须用在方法内调用

作用：
    借助super()返回的实例间接调用父类的覆盖方法

super的应用
显示调用基类的初始化方法
当子类中实现了 __init__方法，基类的 init　方法将
不会被自动调用，如果需要调用，则需要用 super显示调用
示例见：
super_init.py

十九、
用于类的函数：
issubclass(cls,class_or_tuple) 判断一个类是否继承自某个类
class 或某些类　tuple 中的一个类，是则True,否则False

封装
封装是指隐藏类的实现细节，让使用者不关心这些细节
封装的目的是让使用者通过尽可能少的方法(或属性)操作对象
私有属性和方法
python　类中以双下划线开头，不以双下划线结尾的标识符
为私有成员，私有成员只能使用该类的方法进行访问和修改

多态　polymorphic
编程语言的状态：
静态(编译时状态)
动态(运行时状态)
多态原指在有继承关系的类中，调用基类对象的方法，实际能调用
到子类覆盖方法的现象叫多态
说明：
python全部的对象都只有’运行时状态（动态）’，没有
C++语言里的编译时状态(静态)

面向对象的编程语言的特征：
继承
封装
多态

多继承　multiple inheritance
多继承是指一个子类继承自俩个或俩个以上的基类

多继承的语法：
class 类名(基类名１，基类名２，…)：
语句块

说明：
１．一个子类同时继承自多个父类，父类中的方法可以同时被继承下来
２．如果俩个父类中有同名的方法，而在子类中又没有覆盖此方法时，
调用结果难以确定

多继承的缺陷
标识符（名字空间）　冲突的问题
要谨慎使用多继承

多继承的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 ‘字符串’
实例见：
mynumber.py
str(obj)　函数调用方法说明：
１．先调用obj.str() 方法取值。
２．如果obj.str() 方法不存在，则调用
　　obj.repr() 方法取值
３．如果再不存在　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语句的真值表达式中
说明：
１．优先调用　obj.bool()方法进行取值
２．当不存在　obj.bool() 方法时，用
　　obj.len()的返回值是否为零来测定布尔值
当不存在　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(self) 方法来返回
迭代对象（实例）

二十、
异常
异常相关的语句回顾
try-except
try-finally
raise
assert
with语句
语法：
with 表达式１　[as 变量1],表达式2[as 变量2],…
语句块
作用：
使用于对资源进行访问的场合，确保使用过程中不管是否
发生异常，都会执行必须的’清理’操作，并释放资源
如：
文件使用后自动关闭，线程中锁的自动获取和释放等
说明：
执行表达式，用 as 子句中的变量绑定生成的对象
with语句并不改变异常的状态

环境管理器
类内有　enter 和　exit　实例方法的类
被称为环境管理器
enter 将在进入with语句时被调用，并返回由as
办理管理的对象
exit 将在离开with语句时被调用，且可以用参数
来判断在离开with语句时是否有异常发生，并做出相应处理
实例见：
with.py

运算符重载
什么是运算符重载
让自定义的类生成的对象能够使用运算符进行操作
作用：
让自定义的类的实例像內建对象一样使用运算符让程序
简洁易读
对自定义的对象将运算符赋予新的运算规则
算数运算符重载
方法名 运算符和表达式　　 说明
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 幂运算

示例见：
mynumber.py
说明：
运算符重载方法和参数已经有固定的含义，不建议改变
原来的意义

反向算术运算符的重载
当运算符左侧为内建类型，右侧为自定义类型进行算数运算时，
　会出现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 = x.add(y) 方法，
如果在不存在　__add__方法则会触发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) self == rhs 等于
ne(self,rhs) self != rhs 不等于
注：
l little
e equal
g greater
t than

位运算符重载:
方法名 运算符和表达式 说明
and(self, rhs) self & rhs 位与
or(self, rhs) self | rhs 位或
xor(self, rhs) self ^ rhs 位异或
__lshift(self, rhs) self << rhs 左移
__rshift(self, rhs) self >> rhs 右移

反向位运算符重载:
方法名 运算符和表达式 说明
rand(self, lhs) lhs & self 位与
ror(self, lhs) lhs | self 位或
rxor(self, lhs) lhs ^ self 位异或
__rlshift(self, lhs) lhs << self 左移
__rrshift(self, lhs) lhs >> self 右移

复合赋值位运算符重载:
方法名 运算符和表达式 说明
iand(self, rhs) self &= rhs 位与
ior(self, rhs) self |= rhs 位或
ixor(self, rhs) self ^= rhs 位异或
__ilshift(self, rhs) self <<= rhs 左移
__irshift(self, rhs) self >>= rhs 右移

一元运算符的重载
方法名 运算符和表达式 说明
neg(self) - self 负号
pos(self) + self 正号
insert(self) ~ self 取反

语法:
class 类名:
def xxx(self):
…
示例见:
mylist4.py

in / not in 运算符重载
方法名 运算符和表达式
contains(self, e) e in self

示例见:
mylist5.py

索引和切片运算符的重载
L[0]
L[::2]
方法名 运算符和表达式 说明
getitem(self, i) x = self[i] 取值
setitem(self, i, v) self[i] = v 赋值
delitem(self, i) del self[i] 删除索引

示例见:
mylist6.py
加粗样式
slice 构造函数
作用:
用于创建一个slice切片对象,此对象存储一个切片加粗样式
的起始值,终止值和步长信息,默认都为None
格式:
slice(start=None, stop=None, step=None)
slice对象的属性
s.start 切片的起始值 默认为None
s.stop 切片的终止值,默认为None
s.step 切片的步长,默认为None
示例见:
mylist7.py

特性属性 @property
实现其它语言所拥有的 getter 和 setter 功能

作用:
用来模拟一个属性
通过@property装饰器可以对模拟的属性赋值和取值
加以控制
示例见:
property.py

PEP8编码规范
文档参见:
python_base_docs_html/PEP8编码规范.html