Python基础
面向对象编程Object-Oriented Programming 1
一、Python基础Ⅰ
Day01_python简介
Python简介
创建人：Guido Van Rossum（荷兰人）
时间：1989年
Python的应用领域：
系统运维 网络编程 科学计算
人工智能 web开发 云计算
大数据及数据库编程 教育 游戏、图像 其他
Python的优缺点
优点：
面向对象（Java、C++、Python）
免费
可移植
可混合编程（C/C++/Java/.net）
简单易学易用
开发效率高
应用领域广泛
开源
缺点：
与C/C++相比：执行速度不够快
不能封闭源代码
不能编驱动与内核
Python官网
Python的安装
兼容的操作系统：
Windows、Linux、Mac OS X、UNIX
Python的运行:
Python 的解释执行器的类型
CPython（C语言开发）
Jython（Java开发）
IroPython（.net开发）
第一个Python程序：
hello world
常用的程序文件后缀：
.py： Python文件后缀
.c ： C语言文件后缀
.cpp： C++文件后缀
.java: Java语言文件后缀
Python交互模式下的编写与执行代码
进入交互模式： Python3
退出：quit() 、 exit()
Python的注释
#开头至尾
Sublime中快速注释：ctrl+/（批量注释）
Python的程序构成
程序由模块组成
模块由语句、函数+类构成
语句包含表达式
表达式建立并处理数据对象
Python的核心数据类型
1.数字
(1)整形 int ：不带有小数部分的数据，包含自然数，0，负数
整形字面值的表达方式：
十进制
八进制（0o开头，后跟0--7）：0o11 （9）
十六进制（0x开头，后跟0—9，A—F或a--f）：0x11 （17）
二进制（0b开头，后跟0--1）：0b11 （2）
(2)浮点型float：带有小数部分的数字（小数部分可以是0）
浮点型数的两种表示方式：
小数形式：3.1415926535897932384626433832795028841971693993
751058209749445923078164062862089986280348253421190679
科学计数法：小数e/E(正负号)指数 例：6.18E-1=0.618 2.9E8=2.9*10^8
(3)复数 complex:
分为两个部分：
实部（real）：
虚部（image）：
注：虚部是以j或者J结尾的
复数的字面值表示： 1*1j=（-0-1j）
1j 、 （2j） 、 1+1j 、 （-1+1j）
布尔型bool：用来表示真假两种状态的类型
True：真，条件成立 值为1
False：假，条件不成立 值为0
空值None：空值是一个不存在的特殊对象
作用： 1.为了占位 2.变量解除绑定
2.字符串 str
3.列表 list
…
Python中的表达式与运算符
表达式expression：由一个数字和运算符组成
作用：通常让计算机做一些事情并返回结果
运算符：
算数运算符：
+ | - | * | /（除，不会丢弃小数部分）
// （底板除，结果去掉小数部分，向下取整）
%（取余） | **（幂运算）
优先级：** > * 、/、 //、 % > +、-
（）可以将表达式分组：优先计算括号内的
混合类型自动升级
1.5+1.5=3.0
基本输出函数print
变量： 关联一个对象的标识符
变量可以绑定一个对象，并且可以通过变量来使用这个对象
标识符的命名方法：
以下划线为开头，后跟字母或者下划线或数字
说明：
不能使用Python的关键字
区分大小写
赋值语句
语法：变量名=表达式 or 变量名1=变量名2=表达式 or 变量名1，变量名2=序列
作用：创建一个变量或修改一个变量的绑定对象；
一个变量只能绑定一个对象，两个变量可以绑定到一个对象上；
Python中关联/绑定/引用的含义
在Python，变量没有类型
关联/绑定/引用都是指一个变量和一个对象的关联关系
在交互模式下查看当前作用区域内的所有变量>>>help(“_main_”) q退出
del语句（delete的简写）
用于删除变量，同时解除变量与对象的绑定关系
如果可能则释放对象
语法：del 变量名
自动化内存管理的引用计数
每个对象会记录几个变量引用自身，当引用的数量为0时此对象被销毁，此种自动化内存管理的方式叫做引用计数。
is/is not 运算符
作用：判断两个对象是否是同一对象，当是同一对象时返回True，否则返回False
is not作用与is相反
语法：x is y 、 x is not y
小整数对象池
Cpython中 整数-5至256永远存在于小整数对象池中，不会释放且可以重复使用
id（x）函数
作用：返回一个对象的id
Day02_运算&if
复合赋值运算符：
运算符 说明
y+=x y=y+x
y-=x y=y-x
y*=x y=y*x
y%=x y=y%x
比较运算
< 小于 >大于 ==等于 >=大于等于 ！=不等于
语法：左边表达式 > 右边表达式
返回值：通常返回布尔值；
数值对象的构造（创建）函数
float（obj）
用字符串或数字转换为浮点数，如果不给出参数，则返回0,0
int(x，base=10)或int（x=0）
用数字或字符串转换为整数，如果不给出参数则返回0， base为进制转换的底数（进制）
complex(r=0.0,i=0.0) 用数字创建一个复数（实部为r，虚部为i）#（1，1）1+1j
bool（x） 用x创建一个布尔值（True/False）
函数调用：
函数名（参数列表）
说明：函数调用表达式，一定会返回一个对象的引用关系
bool（x）返回假值的情况
bool（x）用于获取显示x的布尔值
假值情况：
None 空值
0 0.0 0j 所有数字0
----------------------------------
‘空字符串’ [空列表] (空元组) {空字典} set（）空集合
预置数值型函数
abs（x） 取x的绝对值
round（number，ndigits）对数值进行近似值的四舍五入，ndights是小数向右取整的位数，负数表示向左取整
pow（x，y，z=None）相当于x**y或x**y%z
help（）查看帮助
基本输入函数
input（‘提示字符串’）
基本输出函数print
作用：将一系列的值以字符串的形式显示在终端上
格式：print（’’,’’,sep=’’,end=’’）
sep:两个数之间的分隔符，默认为一个空格
end：末尾默认自动追加一个\n
语句statement
语句是由一些表达式组成，通常一条语句可以独立来完成一部分事情并形成结果
一行语句建议写在一行内，多行语句写在一行要用 ； 分开。
显式换行
折行符 \：折行符必须放在一行的末尾，来示意执行器的下一行也是本行的语句
隐式换行
被()[]{}括起来的内容可以隐式换行
if语句
1. if 真值测试表达式1：
语句1
...
elif 真值测试表达式2：
语句2
...
elif 真值测试表达式2：
语句2
...
...
else：
语句3
...
书写格式：
1.if的大小写一致
2.有if的语句都有真值测试表达式
3.：英文冒号必须有
4.每个分支下必有一条语句
5.语句要缩进（对齐）
6.elif 分支可选
7.else 分支可选
if语句的真值表达式
if 100：等同于 if bool（100）：
if语句的嵌套：
if语句本身是由多条子句组成的一条复合语句
if语句可以作为语句嵌套到另一个语句的内部
条件表达式：
语法：
表达式1 i 真值表达式2 else 表达式2
作用：
根据真值表达式的取值（True/False）来决定执行表达式1或者2并返回结果
例子： a= b -20 if money >=100 else money
pass语句：
作用：通常被用来填充语法空白
语法：pass
布尔运算
运算符：
not and or
布尔非操作： not 语法： not x
作用：对x进行布尔取非，bool（x）为True，则返回False，否则返回True
布尔与操作：and 语法：x and y
作用：优先返回假值对象，当x为False时，返回x，否则返回y
布尔或操作： or 语法：x or y
作用：优先返回真值对象，当x为True时，返回x，否则返回y
正负号运算符
+ -
一元运算符
语法：
+表达式 - 表达式
Day03_字符串&切片
字符串str（string）’’
作用：用来记录文字信息
表示方法：在非注释中凡是用引号括起来的部分都是字符串
‘单引号’ “双引号” ’’’三引号’’’
空字符串的表示方式： ‘’ 、 “” 、 ‘’’’’’ 、 “”””””
注:空字符串的布尔bool（x）为False
单引号与双引号的区别：
单引号内的双引号不算结束字符
双引号内的单引号不算结束字符
三引号字符串:
以’’’或”””开头，以’’’或”””结尾
作用：三引号字符串中的换行符会自动转换为‘\n’
三引号中可以包含单引号和双引号
‘’’Lalalalala
Hafuhafu‘’’
隐式字符串字面值的拼接
S=”哈’哈哈，” ‘啦”啦啦，’ ‘’’呜’呜”呜’’’ s得到：哈’哈哈,啦”啦啦, 呜’呜”呜
用转义序列代表特殊字符
\’ 代表一个 ’
\” 代表一个 ”
\\ 代表一个 \
\n 代表一个换行
\r 返回光标至行首 （打印时用后面的字符替换前面的字符）
\t 水平制表符
\f 换页
\v 垂直制表符
\b 倒退 （backspace）在print（）首可以前空一行
\0 字符串，字符值为 0（空打印）
\0oo oo 为两位八进制表示的字符
\xXX XX 为两位十六进制表示的字符
\uXXXX Unicode 16 的十六进制的字符
\ UXXXXXXXX Unicode 32 的十六进制表示的字符
ASCII编码：
#查看ASCII编码表
$man ascii 仅Linux下
常用的ASCII编码：
字符 | 十进制 | 十六进制 |
‘0’ | 48 | 0x30 |
‘A’ | 65 | 0x41 |
‘a’ | 97 | 0x61 |
序列
概念：字符串就是序列
求序列的长度的函数len
len（x）返回字符串中字符的个数
raw字符串（原始字符串）
格式：
r“字符串内容” （单引号或双引号或三引号）
作用：让转义字符‘\’无效 （打印\t 或\n等时）
字符串的运算
+ | 加号用于拼接字符串 |
+= | 用于拼接运算后改变原变量的绑定关系 ‘abc’ +=’123’ :abc123 |
* | 运算生成重复的字符串，字符串只能和整数相乘 ‘✐’*3=’✐✐✐’ y*=’✯’ ✏ y=y*✯ |
字符串的比较
运算符： < 、<= 、> 、>= 、== 、!=
‘a’>’A’ 、 ‘BA’>’AB’ ✏✏ 逐项比较
in/not in 运算符
作用：in用于序列，字典，集合中，用于判断某个值是否存在于容器中，如果存在，则返回True，否则返回False
说明：not in 与in 结果相反
格式：对象in 序列
索引 index
Python的字符串是不可以改变的序列，所有的序列都可以用所引来获取其中的数据元素
语法：字符串[整数表达式] ‘abcdefg’[-7]=’abcdefg’[0]=a
说明： 1.序列的正方向是从0开始的，第二个索引为1，最后一个索引为len(s)-1
2..序列的反方向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，第一个为-len(s)
切片 slice
从字符串序列中取出相应的元素组成一个字符串序列
语法：s[(开始索引b)：（结束索引e）（：（步长s））] ‘abcde’[1:4:2]=’bd’ （）内的可省略 ；越界得空字符串s=-1,反向输出
说明：
1.切片切下的位置，0代表第一个元素，1代表第二个元素，-1代表最后一个元素···
2.结束索引是切片的终止索引（但不包括终止点）
3.步长是切片每次获取完当前元素后移动的方向和偏移量
3.1没有步长，代表步长为1（默认为1）
3.2当步长为正整数时，取正向切片，开始索引默认为0，结束索引为最后一个元素的下一个位置e=len(s)+1
3.3当步长为负数时，取反向切片，反向切片时，默认的起始位置为最后一个元素，终止位置是第一个元素的前一个位置
Python中能用于字符串的函数
len(x) | 返回字符串长度 |
max(x) | 返回编码最大的字符 |
min(x) | 返回最小的字符 |
字符串编码转换函数
ord(c) | 返回一个字符串c的Unicode编码 |
chr(i) | 返回i这个值所对应的字符 |
整数转字符串的函数
bin() | 将整数转为二进制字符串 |
oct() | 将整数转为八进制字符串 |
hex() | 将整数转为十六进制字符串 |
字符串的构造（创建）函数
str(obj=’ ’) 将对象转为字符串
python3中常用的字符串方法(method)
对象.方法名（方法传参） ‘abc’.isalpha() 判断abc是否为字母
注：Str.html
-----------------------------------------------------------------------
方法 | 说明 |
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() | 判断字符串是否全为数字字符 |
Day04_字符串&while
字符串格式化表达式
作用：生成一定格式的字符串
运算符：%
语法格式：格式字符串%参数值
或 ：格式字符串 %(参数值1，参数值2……)
说明：
%左侧为格式字符串
%右侧为参数多个用（，）
格式化字符串中以%开头的为占位符，占位符的位置将用参数值替换 “%s%s”%（x，y）
格式化字符串中的占位符和类型码
%s | 字符串，使用str(x)将x转为字符串 |
%r | 字符串，使用repr(x)将x转换为字符串 |
%c | 整数转为单个字符 |
%d | 转为十进制 |
%o | 转为八进制 |
%x | 转为十六进制（a---f） |
%X | 转为十六进制（A--F） |
%e | 指数型浮点数（e）2.9e+10 |
%E | 指数型浮点数（E）2.9E+10 |
%f | %F浮点数（小数形式） |
%g | %G十进制浮点数或指数浮点自动转换 |
%% | 等同于一个%字符 |
占位符和类型码之间的格式化语法
%： | [- + 0 宽度·精度]型码 |
-： | 左对齐 |
+： | 显示行号 |
0： | 左侧空白位置补零 |
宽度： | 整个字符串的字符个数 |
精度： | 保留小数点后多少位（默认6位） |
‘’%07.3f‘’%3.1415926535 ：‘003.141’ p： 08061.py
循环语句（while，for）
有两条循环语句：
while语句：根据一定条件，重复的执行一条或多条语句
语法：
while 真值表达式：
语句块1
else：
语句块2
说明：
1. 先判断真值表达式，为True或False
2. 如果为True，则执行语句块1再回到第一步
3. 如果为False，则执行语句块2
注意事项：
要控制循环真值表达式的值来防止死循环
通常用真值表达式内的循环变量来控制循环条件
通常在循环语句块内改变循环变量来控制循环次数和变量走向
while语句的嵌套
while语句本身是语句，和其他语句一样，可以嵌套到任何复合语句中
P：080602.py
break语句
作用：用于循环语句（while，for） 中，用来终止当前循环语句的执行
语法：break
说明：
1.当break诗句执行后，此循环语句break之后的语句将不再执行
2.break语句通常和if语句组合使用
3.break语句终止循环时else子句的语句将不会执行
4.break语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出外重循环
死循环
指条件一直成立的循环，死循环通常用break语句来终结，死循环的else永远都不会被执行
Day05_for&列表
for语句
作用：用来遍历可迭代对象的数据元素，可迭代对象是指能依次获取数据元素的对象
可迭代对象包括：
字符串str
列表 list
元组 tuple
字典 dict
for语法：
for 变量列表 in 可迭代对象：
语句块1
else ：
语句块2
for语句说明：
else子句部分可以省略
当在循环内部用break终止循环时，else子句部分不会执行
range函数
range（stop）用来生成0---stop间的整数，直到stop为止（不包括stop）
range（start，stop[,step]）
用来生成start—stop间的整数，直到stop为止（不包括stop）每次生成后移动step
作用：用来创建一个生成一系列整数的可迭代对象（也叫整数序列生成器）
说明：range返回的对象可以由for语句来进行一次迭代访问取出其中的整数
range（1,10,2） #1,3,5,7,9
for语句变量可能不创建的问题：
for x in range（0,4）
print（x）
print（x） #for结束后x=3
range只调用一次
for语句的嵌套
for x in “ABC”:
for y in “123”:
print(x+y)
continue语句
作用：用于循环语句（while，for）中，不再执行本次循环continue之后的语法，重新开始一次新的循环
语法：continue
说明：
1.在while语句中执行continue，将会直接跳转到while语句的真值表达式处重新判断循环条件
2.在for语句中执行continue语句，降会从可迭代对象中取下一个元素，绑定变量后再次进行循环
continue之后的语句不会执行
循环小结
四条语句：
while语句 for语句 break语句 continue语句
可迭代对象：
str字符串 range（）函数返回的对象
列表list
列表的定义：
列表是一种容器
列表是可以被改变的序列
列表是由一系列特定元素组成的，元素与元素之间可能没有任何的关联关系，但他们之间有先后顺序关系
Python3中的序列类型：
字符串str
列表list
元组tuple
字节串bytes
字节数组bytearray
创建空列表的字面值表达式
[] #创建一个空列表
L=[] #L绑定了一个新建的空列表
创建非空的列表的字面值
L=[1,2,3,4] #L绑定了有四个元素的列表
L=[1,2,[3.1,3.2],4]
列表的构造函数list
list()生成一个空的列表，等同于[]
list（iterable） 可用迭代对象创建一个列表
L=list()
L=list(‘hello’) #L=[‘h’,’e’,’l’,’l’,’o’]
L=list(range(5))
列表的运算：
算数运算：
+ 、+=、*、*=
+：用于拼接列表，生成新的列表
+=：用原列表与有可迭代对象来修改追加原列表，会改变原来的对象，不创建新的元素
*：生成重复的列表
*=：生成重复的列表，并改变对变量的绑定
列表的比较运算：
运算符：< 、<=、 > 、>= 、== 、!=
比较规则与字符串相同，依次比较
列表是可迭代对象
L=[1,3,5,7]
for x in L:
Print(x) # 1 3 5 7
Day06 列表
列表的in/not in 运算符
判断一个值是否存在于列表中，如果存在返回True，否则返回False
同字符串的in运算
用于检查一个值是否存在列表中，如果存在返回True，否则返回False
列表的索引操作
语法：列表[整数表达式]
用法：与字符串索引的方法相同（分为正向索引和反向索引）
列表的索引赋值：
列表是可变的，可以通过索引赋值改变列表中的元素
语法：
列表[]=表达式
作用：
改变列表中索引的绑定关系
列表的切片：
列表[：]
列表[：：]
列表的切片取值返回一个新的列表，返回规则等同于字符串切片
列表的切片赋值：
作用：可以改变列表的数据排列，可以插入和修改数据，可以用切片改变列表的对应元素的值
语法：列表[切片]=可迭代对象
说明：切片赋值的赋值运算符（=）的右侧必须是一个可迭代对象
切片的注意事项
对于步长不等于1的切片赋值，赋值运算符的左侧的可迭代对象提供元素的个数一定要等于切片切除的段数
del语法用于删除列表的元素
语法：del列表[索引] del列表[切片]
Python3中常用于序列的函数
len(s) | 返回序列的长度 |
max(x) | 返回最大值 |
min(x) | 返回最小值 |
sum(x) | 返回所有值得和（必须全是数值类型） |
any(x) | 真值测试，如果其中一个为真返回True |
all(x) | 真值测试，如果其中一个为假返回False |
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]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系拿走的v=L.pop(2) |
深拷贝和浅拷贝
浅拷贝shallow copy
浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
深拷贝deep copy
复制对象及对象关联的对象一起复制的过程叫做深拷贝
列表与字符串
1.都是序列，有先后顺序关系，有相同的运算操作
2.列表可变是，字符串是不可变的
3.列表可以存任意类型的数据，字符串只能存字符
字符串的文本解析方法：
S.split（sep==None）,将字符串使用sep作为分隔符分割S字符串，当不给定参数时，索引空白字符作为分隔符分割
S.join(iterable)用可迭代对象中的字符串，返回一个中间用S进行分割的字符串
示例Day0602.py
列表推导式list comprehension
列表推导式是用可迭代对象创建列表的表达式
作用：用简易方法生成列表
语法：[表达式 for 变量 in 可迭代对象]
或[表达式 for 变量 in 可迭代对象 if 真值表达式]
示例：Day0602.py #生成一个数值为1-9的平方的列表：l=[x**2 for x in range(1,10)]
列表推导式的嵌套
语法：[表达式 for变量1 in可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2…]
示例：两个可迭代对象之间进行运算：Day0602.py #L=[x+y for x in [10,20,30] for y in [1,2,3]]
Day07 元组&字典
元组tuple
元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，元组一旦创建就不可改变
元组的表示方式
用小括号()括起来，单个元素括起来加逗号（，）
区分单个对象还是元组
创建空元组的字面表达式
t=() #（）是创建一个空的元组对象
创建非空元组的字面表达式：
t=200， t=(20,) t=(1,2,3) t=100,200,300
注：type（x）函数，可以返回对象x的类型
元组错误示例：
t=（200）#t绑定200这个对象，不是元组
x,y,z=100,200,300#序列赋值
x,y,z=(1,2,3) x,y,z =[1,2,3] x,y,z =”aaaa”
元祖的构造函数
tuple()生成一个空的元组，等同于（）
tuple（iterable）用可迭代对象生成一个元组
示例：t=tuple（）
元组的运算:
+用于用拼接的方式创建一个新的元组
*用于生成新的重复的元组
T=（1,2,3）+（4,5,6） T=（1,2,3,4,5,6）
T+=（7，8，9） #t=（1，2，3，4,5,6,7,8,9）
T=（1,2）*3 T=（1,2,1,2,1,2）
元组的比较运算：
< <= > >= == != 规则与列表相同
元组的in /not in 运算符
用于判断元素是否存在是元组之中，规则与列表相同
索引index
用法与列表相同
元组不支持索引赋值
切片
用法与列表的切片相同
元组的切片返回一个新的元组
元组不能切片赋值
元组的方法：
T.index（V[,begin[,end]]）返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
S.count(sub[, start[,end]]) 获取一个字符串中子串的个数
序列小结：
字符串：str
列表 ：list(可变)
元左右 tuple
------后面学的---
字节数 bytes
字节数组 bytearray（可变的）
序列的相关函数
len(s) | 返回序列的长度 |
max(x) | 返回最大值 |
min(x) | 返回最小值 |
sum(x) | 返回所有值得和（必须全是数值类型） |
any(x) | 真值测试，如果其中一个为真返回True |
all(x) | 真值测试，如果其中一个为假返回False |
reversed(x) | 返回反向顺序输出 |
字典dict
什么是字典：
1.字典是一种可变的容器，可以存存储任意类型的数据
2.字典中的每个数据都是用‘键’（key）进行索引的，而不像序列可以用索引下表进行索引，键值不能用可变的如list
3.字典中的数据没有先后顺序关系，字典的存储是无序的
4.字典的数据以键-值对（key-value）对形式进行映射存储
5.字典的键不能重复，且只能用不可变类型作为字典的键
字典的字面表示方法：
用{}括起来，以冒号（：）分隔-键值对时，各键值对用逗号分隔开
创建空字典
d={} #{}表达式用来创建一个空的字典
创建非空字典：
d={‘name’:‘vijwjn’，‘age’：35}
d={‘a’：100}
d={‘t’：tuple（“abc”）}
d={‘abc’：list（“ABC”）}
d={‘a’：{‘b’：100，‘c’：300}}
d={True：‘真值’，False：‘假值’，None：‘空’，100：‘壹佰’}
d={（1970，1,1）：‘计算机元年’}
字典的构造函数dict
dict创建一个空的字典，等同于{}
dict（iterable）用可迭代对象创建一个新的字典
dict（**kwargs）用关键字传参的形式创建一个新的字典
示例：d=dict() d=dict([(‘a’,1),(‘b’,2)]) d=dict(name=’a’,age=5)(键不能是表达式)
字典的操作
字典的键索引
用[]运算符可以获取字典内‘键’对应的‘值’
语法：
v=字典[键]
添加/修改字典的元素
语法：
字典[键]=表达式
示例：
d={}
d[‘name’]=’tarena’ #创建新的‘name’同时关联值
d[‘age’]=15 #创建键并绑定15
d[‘age’]=116#修改原来的键‘age’，重新绑定为116
说明：键不存在则创建，存在则修改绑定关系
删除字典元素del语句
del 字典[键]
字典的in /not in 运算符
In/not in ：in用来判断一个键是否存在于字典中，如果在返回True，否则返回False；not in 相反
字典的迭代访问
字典是可迭代对象，字典只对键进行访问
字典中可用的函数
len(s) | 返回字典的键值对个数 |
max(x) | 返回字典键的最大值 |
min(x) | 返回字典键的最小值 |
sum(x) | 返回所有键值的和（必须全是数值类型） |
any(x) | 真值测试，只对键测试，如果其中一个为真返回True |
all(x) | 真值测试，只对键测试，如果其中一个为假返回Fal se |
字典的方法
函数 | 说明 |
D.clear() | 清空字典 |
D.pop(key) | 移除键，同时返回此键所对应的值 |
D.copy() | 返回字典D的副本,只复制一层(浅拷贝) |
D.update(D2) | 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值 |
D.get(key, default) | 返回键key所对应的值,如果没有此键，则返回default |
D.keys() | 返回可迭代的 dict_keys 集合对象（键） |
D.values() | 返回可迭代的 dict_values 值对象（值） |
D.items() | 返回可迭代的 dict_items 对象 |
例：Day0701.py
字典推导式
是用可迭代对象生成字典的表达式
语法：{键表达式:值表达式:for 变量 in 可迭代对象 [if 真值表达式]}
注：[]内可省
字典推导式的嵌套等同于列表推导式的嵌套
区别 | 字典 | 列表 |
都是可变对象 | 可变 | 可变 |
索引方式 | 整数索引 | 键索引 |
插入修改删除速度 | 快 | 不快 |
存储 | 无序 | 有序 |
Day08 集合
集合set
集合是可变的容器
集合内的数据对象都是唯一的（不能重复多次）
集合是无序的存储结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代对象
集合是相当于只有键没有值得字典（键则是集合的数据）
创建空的集合
set（）
创建非空的集合的字面值：
s={1,2,3}
集合的构造函数
创建一个空的集合（不能用{}创建空集合）
set（iterable） 用可迭代对象创建一个新的集合
示例：s=set()
s=set(“ABC”)#s={“A”,”B”,”C”}
s=set({1:”A”,2:”B”})#s={1,2}
s=set((1,2,3,4))#set(可迭代对象) s={1,2,3,4}
集合的运算
交集：&、并集：|、补集：-、对称补集：^、子集：<、超集：>、……
==、!=：集合相同不相同
示例08_0810_1.py
In/not in运算
同列表与字典的运算规则
用于集合的函数：
len(s) | 返回序列的长度 |
max(x) | 返回最大值 |
min(x) | 返回最小值 |
sum(x) | 返回所有值得和（必须全是数值类型） |
any(x) | 真值测试，如果其中一个为真返回True |
all(x) | 真值测试，如果其中一个为假返回False |
集合是可迭代对象，可以用于for语句中
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|=s2 |
S.difference(s2) | S - s2 补集运算，返回存在于在S中，但不在s2中的所有元素的集合 |
S.difference_update(s2) | 等同于 S -= s2 |
S.intersection(s2) | 等同于 S & s2 |
S.intersection_update(s2) | 等同于S &= s2 |
S.isdisjoint(s2) | 如果S与s2交集为空返回True,非空则返回False |
S.issubset(s2) | 如果S与s2交集为非空返回True,空则返回False |
S.issuperset(s2) | 如果S为s2的子集返回True,否则返回False |
S.symmetric_difference(s2) | 返回对称补集, 等同于 S ^ s2 |
S.symmetric_difference_update(s2) | 等同于 S ^= s2, 用 S 与 s2 的对称补集更新 S |
S.union(s2) | 生成 S 与 s2的并集, 等同于 S|=s2 |
集合推导式
使用可迭代对象传创建的表达式
语法：{表达式 for x in可迭代对象 [if真值表达式]}
固定集合frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用：固定集合可以作为字典的键，也可以作为集合的值
固定集合的构造函数froenset
frozenset()创建一个空的固定集合
frozenset（iterable）用可迭代对象创建一个新的固定集合
固定集合的运算：
& 交集 、|并集、-补集、^对称补集、in/not in 运算 、、> >= <= == ！=
固定集合的方法：
相当于集合的所有方法 - 修改集合的方法
阶段总结
python3中的可变不可变数据类型
不可变：bool、int、float、complex、str、tuple、frozenset、bytes |不可变的值：None
可变：list、dict、set、bytearray
运算符
+、-、*、/、//、%、** | < <= > >= ==!= | is/is not | in/not in | not/and/or
&、|、-、^
表达式
100
100+200
max（1,2,3）#函数调用也是表达式
条件表达式
全部的推导式
列表，字典、集合推导式（只有三种）
语句
表达式语句：print（“holy fucking shit”）、“─=≡Σ(((つ•̀ω•́)つ”
赋值语句：a=100、x，y=100,200、列表[整数表达式]=表达式、字典[键]=表达式
if语句
while 语句
for语句
break语句
return语句
pass语句
continue语句
函数
len(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),forzenset(x)
abs(x),round(x),pow(x,y,z=None)
bin(x),oct(x),chr(x),hex(x),chr(x),ord(x)
range(start,stop,step)
input(x),print(……)
二、Python基础Ⅱ
函数function
什么是函数：函数是可以重复执行的语句块，可以重复调用
作用：
用于封装语句块，提高代码的重用性
定义用户级别的函数
def语句
语法：
def 函数名（形参列表）：
语句块（代码块）
作用：用语句块创建一个函数，并用函数名变量绑定这个函数
语法说明：
1.函数名是变量，它用于绑定语句块
2.函数有自己的名字空间，在函数外部不可以访问函数内部的变量，在函数内部可以访问函数外部的变量
（要让函数处理外部的数据需要用参数给函数传入一些数据）
3函数不需要传入参数时，形参列表可以为空
4.语句部分不能为空，如果为空需要填充pass语句
函数调用：
函数名（实际调用传递参数）
注：实际调用传递参数，以后成为实参
说明：
函数是一个表达式
如果函数内部没有return语句，则函数执行完毕后返回None对象
return语句
语法： return[] [可省]
作用：用于函数这结束当前函数的执行， 返回到调用该函数的地方，同时返回一个对象的引用关系
return语句说明：
1. return语句后跟表达式可以省略，相当于return None
2. 如果函数内没有return语句，则函数执行完最后一条语句后返回None（相当于加了return None）
——Day09分隔线——
Python 函数的参数传递
传递方式：
位置传递
序列传递
关键字传参
字典关键字传参
位置传参：
实际参数（实参）的对应关系与形式参数（形参）的对应关系是按位置来依次对应的
示例：def mymin （a，b，c）：
pass
mymin（1，2，3）#1，2，3位置位置对应关系传给a，b，c
说明：
实际参数和形式参数通位置经行传递和匹配
实际参数的个数必须与形式参数的个数形同
序列传参：
序列传参是指在函数调用的过程中，用*将序列拆节后按位置经行传参的传参方式
说明：
序列传参时，序列拆解的位置将于形参一一对应
序列的位置虚席对应相应的参数位置
示例： s3='ABC'
myfun(*s3)#序列传参 *拆解
关键字传参
关键字传参是指传参时，按照形参的名称给形参赋值
实参和形参按名称经行匹配
示例：
myfun( b=22,c=33,a='aaa')
说明：可以不按位置经行排序
字典关键字传参
是指实参为字典，将字典用**拆解后经行关键字传参的方式
说明：
字典的键名与形参名一致
字典的键名必须为字符串（且为标识符的命名方式）
字典的键名要在形参中存在
示例： d1=dict([('a','Q'),('b','W'),('c','E')])
myfun(**d1)
函数的综合传参
函数的传参方式，再能确定形参能唯一匹配到相应实参的情况下可以任意组合
函数的位置传参优先于关键字传参
说明：
1.位置传参和序列传参可以混合使用且可以顺序颠倒
Myfun(100,*[100,200])
2.函数的关键字传参和字典关键字传参可以混合使用，且可以顺序颠倒
myfun(c=300,**{'b':200,'a':100})
3.函数的位置传参和关键字关键字传参可以混合使用，但位置传参要先于关键字传参
Myfun(100,b=2000,c=300)
myfun(100,{‘b’:100,’c’:200})
函数的定义时如何定义形参
函数的缺省参数
语法:
Def 函数名(形参名1：默认实参1，……)：
语句块
说明：
缺省参数必须自右向左依次存在，如果一个参数有缺省参数，择期向右测的所有参数必须有缺省参数
缺省参数可以有0个或多个，甚至全有
函数形参的定义方式
位置形参
星号元组形参
命名关键字形参
双星字典形参
位置形参
Def 函数名（形参1，形参2）：
语句块
星号元组形参
语法：
Def 函数名（*元组形参名）：
语句块
作用：
收集多余的位置传参，可以接收无限个实参
说明：
元组形参一般命名为‘args’
示例：def func(*args):
print(len(args)；print(args)
func(546546546546,5645,456,456,456,456,4)
命名关键字形参
语法：
Def 函数名（*，命名关键字形参）：#*为分隔符
语句块
或
Def 函数名（*args，命名关键字形参）：
语句块
作用：强制所有的参数都必须用关键字传参或字典关键字传参
双星号字典形参
语法：
Def 函数名（**字典形参名）：
语句块
作用：收集多余的关键字传参
说明：字典形参名一般命名为kwargs
示例： def fffff(**kwargs):
print('len(kwargs)=',len(kwargs))
print(kwargs) #len(kwargs)= 2
fffff(a=1,b=2) #{'a': 1, 'b': 2}
函数的参数说明
位置形参，缺省形参，星号元组形参，双星号字典形参等可以混合使用
函数参数自左至右顺序为：
1.位置形参2.星号元组形参3.命名关键字形参4.双星号字典形参
示例： def fn(a,b,*args,c,**kwargs):
Pass
Fn(100,200,3,1,5,d=5,c=66)
——Day10分割线——
全局变量和局部变量
局部变量：
定义在函数内部的变量称之为局部变量（函数的形参也是局部变量）
局部变量只能在函数内部使用
局部变量在函数调用时才能被创建，在函数调用后会自动销毁
全局变量：
定义在函数外部，模块内部的变量称之为全局变量
全局变量所有的函数都可以直接访问（但函数内部不能将其赋值=）
说明：
1.局部变量只能在其被生命的函数内部访问，而全局变量可以在整个模块内访问
2.在函数内部赋值语句不会对全局变量产生影响
globals/local函数
globals（）返回当前全局作用域内变量的字典
locals（）返回当前局部作用域内变量的字典
函数变量：
函数名是变量，它在创建函数时绑定一个变量
一个函数可以作为另一个函数的实参传递
函数可以返回另一个函数
10_0814_1.py
def max_min_sum():
s=input("输入您要用的函数:")
if s=='max':
return max
if s=='min':
return min
if s=='sum':
return sum
L=[1,6,3,5,9]
sss=max_min_sum()(L)
print(sss)
函数的嵌套定义
函数嵌套定义是指一个函数里用def 语句来创建另一个函数的情况
python3的四个作用域
作用域也叫做名字空间，是访问变量时查找变量名的范围空间
python的四个作用域 LEGB
作用域 | 英文解释 | 英文简写 |
局部作用域（函数内） | Local(function) | L |
外部嵌套函数作用域 | Enclosing function locals | E |
函数定义所在模块作用域 | Global(module) | G |
python内置模块的作用域 | Builtin(Python) | B |
变量名查找规则：
在访问边量时，先查找本地文件，然后是包裹此函数外部的函数内的变量，之后是全局变量，最后是内建作用域的变量
LàEàGàB
在默认的情况下，变量名赋值会在当前作用域内创建和修改变量
global语句
作用：告诉执行器，global语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也成作全局变量
全局声明global将赋值变量映射到模块文件内部的作用域
语法：global 变量名1 、变量名2……
说明：
1.全局变量如果要在函数内部被赋值，则必须经过全局声明（否则会被认成局部变量）
2.全局变量在函数内部不经过声明就可以直接访问
3.不能先声明局部变量，再用global声明为全局变量，此做法不符合规则
4.global变量列表里的变量名不能出现在函数的形参列表里
nonlocal语句
作用：告诉解释执行器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量
语法：nonlocal 变量名1，变量名2……
说明：
1.nonlocal语句只在被嵌套函数的内部进行使用
2.对nonlocal变量经行赋值操作，将对外部嵌套函数作用域内的变量经行操作
3.当有两层或者两层以上的函数嵌套时，访问nonlocal变量只对最近一层变量进行操作
4.nonlocal语句的变量列表里的变量名，不能出现在此函数形参列表中
def语句
语法：def 变量/函数名（形参）：
……
lambda表达式
作用：创建一个匿名的函数对象
同def类似，但不提供函数名
语法：lambda[形参1，形参2……]？：表达式
语法说明：
1.lambda只是一个表达式，它用来创建一个函数
2.当lambda表达式调用时，先执行冒号[:]后的表达试。并返回表达式的结果的引用
3.lambda表达式创建的函数磁能包含一条表达式
4.lambda比此函数简单且可以随时创建和销毁，有利于减少程序的耦合度
eval,exec函数
eval函数
作用：
把一个字符串当成一个表达式来运行，返回表达式执行后的结果
格式：
eval（source，globals=None，locals=None）
exec函数
作用：把一个字符串当成一个程序来运行
格式：exec（source，globals=None，locals=None）
——Day11分割线——
函数式编程
是指用一系列函数解决问题
函数的可重入性:
当一个函数的输入一定,则输出必然一定的函数称为可重入函数
说明:可重入函数内一定时间不会访问局部变量以外的变量
(๑ŐдŐ)b
高阶函数High Order Function
什么是高阶函数：
满足下列条件中的一个函数即为高阶函数
1. 函数接受一个或多个函数作为参数输入
2. 函数返回一个函数
python内置的高阶函数：
map filter sorted
map函数：
map（func，*iterable）
返回一个可迭代对象，此可迭代对象用函数func对可迭代对象iterable中的每一个元素作为参数计算后得到新的数据
示例：sum=sum(map(lambda x:x**2,range(1,10)))
filter函数
filter（function，iterable）
作用：筛选可迭代对象iterable中的数据，返回一个可迭代对象，此可迭代对象只返回iterable中符合条件的数据
function将对iterable中提供的每个数据进行布尔求值，如果为True则保留，返回False则丢弃数据
sorted函数
作用：将原可迭代对象进行排序，生成排序后的列表
函数参数格式：
sorted（iterable，key=None，reverse=False）
说明：
iterable可迭代对象
key 函数来提供一个值，这个值将作为排序的依据，如果不给出key值，则用原函数的数据进行排序和比较
reverse 标志是否降序排列
递归函数recursion
递归是指函数直接或者间接的调用本身。
递归说明：
递归一定要控制递归的层数，当符合某一条件时要终止递归调用，几乎所有的递归都能用while来代替。
递归的优缺点：
优点：
可以把问题简单化，让思路更加清晰，代码更加简洁
缺点：
递归因为环境影响大当递归过深时，可能会导致预期外的结果
递归调用分为两个阶段：L
递推阶段：
从原问题出发，按公式递推，从未知到已知，最终达到递归终止条件
回归阶段：
按递归终止条件求出结果，逆向逐步带入递归公式，回归原问题求解
闭包closure
什么是闭包
闭包是指引用了此函数外部变量的函数
如果一个内嵌函数访问了外部嵌套函数的变量，则这个内嵌函数就是闭包
闭包要满足三个条件：
1.必须有一个内嵌函数
2.内嵌函数必须引用外部函数中的变量
3.外部函数返回值必须是内嵌函数
def make_power(y):
def fn(x):
return x**y
return fn
print(make_power(2)(5))
——Day12分割线——
装饰器deforator(专业提高篇)
什么是装饰器
装饰器是一个函数,主要作用是用来包装另一个函数或类,包装的目的是在不改变原函数的情况下改变被包装对象的行为
函数装饰器
是指装饰器是一个函数,传入的是一个函数,返回的是一个函数
语法:
def 装饰器函数名(参数):
语句快
return 函数对象
@装饰函数名<换行>
def 函数名（形参列表）：
语句块
示例； myfun=mydeco（myfum）
原理：被装饰函数的变量（函数名）绑定装饰器函数调用后的返回的函数
函数的文档字符串：
函数内第一次未赋值给任何变量的字符串是此函数的文档字符串
语法：
def 函数名（参数列表）：
‘函数文档字符串’
语句块
说明：
1.文档字符串通常用来使用说明函数的功能和使用方法
2.在交互模式下，请输入：
>>>help（函数名）可以查看
3.函数的文档字符串绑定在__doc__属性上
函数的__doc__属性
__doc__属性：用于记录文档字符串
函数的__name__属性
__name__属性：用于记录函数名
说明：以双下滑线开头，以双下滑线结尾的标识符通常代表python中的特殊变量
函数的定义的完整语法：
[@装饰名1]
[@装饰名2]
[……]
def 函数名（位置形参，*元组形参名，命名关键字形参，**字典形参）：
‘’‘文档字符串’‘’
语句块
面试题：
L=[0,1]
def f(n=0,lst=[]):
lst.append(n)
print(lst)
f(1,L)
f(2,L)
f(100) [100]
f(200) [100,200]
模块Module
什么是模块
模块是包含有一系列数据、函数、类等组成的程序组
模块是一个文件，模块文件名通常以.py结尾
作用
让一些相关的数据、函数、类，等有逻辑的组织在一起，是逻辑结构更加清晰
模块中的数据函数和类可以让其他模块或程序使用
模块的分类：
1. 内置模块，在解释执行器内部定义，可以直接使用
2. 标准库模块，安装python即可直接使用
3. 第三方模块（通常开原），需要自己安装
4. 用户自定义模块（可以作为其他人的第三方模块）
模块的导入import
import语句
语法：import 模块1[as 模块新名]，模块2[as 模块新名2]……
作用：将某模块整体导入到当前模块中
示例：
import math #导入数学模块
import sys，time#导入系统及时间模块
用法：
模块名：属性名
函数：
dir（obj）函数，返回所有属性的字符串列表
help（obj）函数，查看模块的文档字符串
from import 语句
语法：
from 模块名 import 模块属性名1[as 属性名1]，
模块属性名2[as属性新名2]，……
作用：
将某模块中的一个或多个属性导入到当前模块的作用域
from math import pi as p
from import *语句
语法：from 模块名 import*
作用：
将某模块的所有属性导入到当前模块
from math import*
dir函数：
dir([对象])返回一个字符串列表
作用：
1. 如果没有参数调用，则返回当前作用域内所有变量的列表
2. 如果给定一个对象作为参数，则返回这个对象的所有变量的列表
1）对于一个模块，返回这个魔窟的所有属性
2）对于一个类对象，返回类对象的所有变量病递归基类对象的所有变量
3）对于其他对象返回所有变量，类变量和基类变量
数学模块math
数据 | 描述 |
math.e | 自然对数的底e |
math.pi | 圆周率pi |
-
函数名 | 描述 |
math.ceil(x) | 对x向上取整，比如x=1.2，返回2 |
math.floor(x) | 对x向下取整，比如x=1.2，返回1 |
math.sqrt(x) | 返回x的平方根 |
math.factorial(x) | 求x的阶乘 |
math.log(x[, base]) | 返回以base为底x的对数, 如果不给出base,则以自然对数e为底 |
math.log10(x) | 求以10为底x的对数 |
math.pow(x, y) | 返回 x**y (x的y次方) |
math.fabs(x) | 返回浮点数x的绝对值 |
角度和弧度degrees互换 | |
math.degree(x) | 将弧度x转换为角度 |
math.radians(x) | 将角度x转换为弧度 |
三角函数 | |
math.sin(x) | 返回x的正弦(x为弧度) |
math.cos(x) | 返回x的余弦(x为弧度) |
math.tan(x) | 返回x的正切(x为弧度) |
math.asin(x) | 返回x的反正弦(返回值为为弧度) |
math.acos(x) | 返回x的反余弦(返回值为为弧度) |
math.atan(x) | 返回x的反正切(返回值为为弧度) |
时间模块time
时间相关的函数
time.html
时间简介
· 公元纪年是从公元 0000年1月1日0时开始的
· 计算机元年是从1970年1月1日0时开始的,此时时间为0,之后每过一秒时间+1
· UTC 时间 (Coordinated Universal Time) 是从Greenwich时间开始计算的.
UTC 时间不会因时区问题而产生错误
· DST 阳光节约时间(Daylight Saving Time)，又称夏令时, 是一个经过日照时间修正后的时间
时间元组
· 时间元组是一个9个整型元素组成的,这九个元素自前至后依次为:
o 四位的年(如: 1993)
o 月 (1-12)
o 日 (1-31)
o 时 (0-23)
o 分 (0-59)
o 秒 (0-59)
o 星期几 (0-6, 周一是 0)
o 元旦开始日 (1-366)
o 夏令时修正时间 (-1, 0 or 1).
· 注：
o 如果年份值小于100,则会自动转换为加上1900后的值
模块名: time
时间模块用法：
import time
# 或
from time import xxx
# 或
from time import *
数据 | 描述 |
time.altzone | 夏令时时间与UTC时间差(秒为单位) |
time.daylight | 夏令时校正时间 |
time.timezone | 本地区时间与UTC时间差(秒为单位) |
time.tzname | 时区名字的元组， 第一个名字为未经夏令时修正的时区名, |
注： CST为中国标准时间(China Standard Time UTC+8:00)
函数名 | 描述 |
time.time() | 返回从计算机元年至当前时间的秒数的浮点数(UTC时间为准) |
time.sleep(secs) | 让程序按给定秒数的浮点数睡眠一段时间 |
time.gmtime([secs]) | 用给定秒数转换为用UTC表达的时间元组 |
time.asctime([tuple]) | 将时间元组转换为日期时间字符串 |
time.mktime(tuple) | 将本地日期时间元组转换为新纪元秒数时间(UTC为准) |
time.localtime([secs]) | 将UTC秒数时间转换为日期元组（以本地时间为准) |
——Day13分割线——
系统模块sys
运行时系统相关的信息
sys模块的数据
数据 | 描述 |
sys.path | 模块搜索路径 path[0] 是当前脚本程序的路径名，否则为 '' |
sys.modules | 已加载模块的字典 |
sys.version | 版本信息字符串 |
sys.version_info | 版本信息的命名元组 |
sys.platform | 操作系统平台名称信息 |
sys.argv | 命令行参数 argv[0] 代表当前脚本程序路径名 |
sys.copyright | 获得Python版权相关的信息 |
sys.builtin_module_names | 获得Python内建模块的名称（字符串元组） |
sys模块的函数
函数名 | 描述 |
sys.exit([arg]) | 退出程序，正常退出时sys.exit(0) |
sys.getrecursionlimit() | 得到递归嵌套层次限制（栈的深度） |
sys.setrecursionlimit(n) | 得到和修改递归嵌套层次限制（栈的深度） |
用户自定义模块
要求:
模块名以'.py'结尾
模块名必须是标识符的命名规则
避免与内建模块冲突
导入方式:
import 语句
from import 语句
from import *语句
import语句的搜索路径顺序
1.索引内建模块builtin
2.搜索程序的运行时路径(当前路径)ꢁ
3.sys.path提供的路径
两种放放松让用户自定义模块被导入：
1）将模块安装（复制）到sys.path提供的路径
2）在运行程序时，在sys.path里添加自定义路径
模块的加载过程：
在模块导入时，模块的所有语句都会被执行
如果一个模块已经被导入了，当再次导入时，语句不会再执行
模块的重新加载：
import mymod
import imp
import reload(mymoad)
模块被导入和被执行的过程
1.先搜索相关路径查找模块文件
2.判断是否有此模块对应的.pyc，如果.pyc文件存在且比.py文件新，直接加载.pyc文件
3.否则用模块名.py生成.pyc文件执行
模块的编译
mymoad.pyà编译àmymod,pycà解释执行àpython2
模块的属性
模块的文档字符串
模块内的第一次没有赋值给任何变量的字符串为模块的文档字符串模块内的文档字符串绑定在模块的__doc__属性上
__doc__用来绑定字符串属性
__file__用来绑定此模块对应的文件路径
__name__：
1.用来记录模块自身的名字
2.用来判断是否为主模块（注：主模块是指程序最先被python3执行的模块）
说明：
当此模块为主模块运行时，__name__的值为'__main__'
当此模块不是主模块时，绑定自己的名字
__all__列表：
模块中的__all__列表必须是一个字符串列表
作用：
当用from my mod import*导入时，只导入__all__列表内的属性
示例见mymod2.py
模块的隐藏属性
模块中以‘_’开头的属性，在from xxx import*导入时将不被导入，通常称这些属性为隐藏属性
随机模块random
作用：
用于模拟或生成随机输出的模块.
用法示意:
import random as R
函数名 | 描述 |
R.random() | 返回一个[0, 1) 之间的随机实数 |
R.uniform(a,b) | 返回[a,b) 区间内的随机实数 |
R.randrange([start,] stop[, step]) | 返回range(start,stop,step)中的随机数 |
R.choice(seq) | 从序列中返回随意元素 |
R.shuffle(seq[, random]) | 随机指定序列的顺序(乱序序列） |
R.sample(seq,n) | 从序列中选择n个随机且不重复的元素 |
包（模块包）package
定义：将模块以文件夹的形式进行分组管理的方法
作用：将一系列模块进行分组管理，有利于防止命名冲突，可以在需要时加载一个或部分模块而不是全部模块
包内的__init__.py文件
__init__.py是常规包内必须存在的文件
__init__.py文件会在包加载时被自动调用
作用：
1. 编写此包的内容
2. 编写包的文档字符串
包的导入：
规则类似于模块的导入规则
import包名[as 新包名]
import包名.模块名[as 模块新名]
import包名.子包名.模块名[as 模块新名]
……
from 包名 import 模块名[as 模块新名]
from 包名.子包名 import 模块名[as 模块新名]
from 包名.子包名.模块名 import 属性名[as 属性新名]
……
from 包名 import *
from 包名.模块名 import *
……
import语句搜索引 包的路径顺序
1. 搜索程序运行时的路径（当前路径）
2. sys.path提供的路径
__inut__.py内的__all__列表
作用：用来记录此包中有哪些子包或模块需要导入
当用from包import*语句导入模块时，只查找__all__列表中所有的模块或子包
说明：
__all__列表只有在from xxx import *导入时起作用
包的相对导入
包的相对导入是指包内模块的相互导入
语法：
from 相对路径包或模块名 import 属性名或模块名
或
from 相对路径包或模块名 import*
相对路径
在from和import间可以用相对路径：
.当前目录
..上一级目录
…上二级目录
注：相对导入时不能超出包的外部
——Day14分割线——
异常 exception
什么是错误：
作物是由于逻辑或语法导致一个程序无法运行的问题
什么是异常：
异常是指程序出错时标注的一种状态
当异常发生时，程序不会继续向下运行，而转调用此函数的地方待处理此错误病恢复为正常状态
作用：
用作信号，通知上层调用者有错误产生需要处理
Try 语句的两种用法
try-except语句
try-finally语句
try-except语法
try可能触发异常的语法
except 错误类型1 [as 变量1]：
异常处理语句1
except 错误类型2 [as 变量2]：
异常处理语句2
except(错误类型3错误类型4)：
异常处理语句3
except：
异常处理语句other
else：
未发生异常语句#未报错执行
finally：
最终语法#一定会执行
作用：
尝试捕获异常，将程序由异常状态转换为正常状态并运行
try-except语句说明：
as 字句是用于绑定错误对象的变量，可以省略
except字句可以有一个或多个，但至少要有一个
else字句最多只能有一个，也可以省略不写
finally字句只能有一个，可省略
Python全部的错误类型
错误类型 | 说明 |
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语句不会改变程序的（正常/异常状态）
try语句嵌套
try嵌套是指一个try语句嵌套在另一个try语句内使用
raise语句：
作用：
触发一个错误，让程序进入异常状态发送错误通知给调用者看
语法：
raise 异常类型
或
raise 异常对象
或
raise#重新触发上一次异常
raise XXXError（‘sdsad’）
assert语句（断言语句）
语法：
assert 真值表达式，错误数据（通常是字符串）
作用：
当真值表达式为false时，用错误数据创建一个AssertionError类型的错误raise出去，并进入异常状态
等同于：
if 真值表达式 ==false
raise AssertionError（错误数据）
示例：
def get_score():
s=int(input('ur score in 1 to 100' ))
assert 0<=s<=100,'u pause a wtf?'
return s
try:
score=get_score()
except AssertionError as e:
score=e
except ValueError :
score='¿'
print('ur score ==%s'%score)
为什么要用异常处理机制
在程序调用层数较空时，向主调函数传递错误信息需要层层return，返回很麻烦，故用异常处理机制
——Day15分割线——
迭代器Iterator
什么是迭代器:
迭代器是访问可迭代对象的工具
迭代器是指用iter(obj)函数返回的对象(实例)
迭代器可以用next(it)函数获取可迭代对象的数据
迭代器函数iter和next
iter(iterable)从可迭代对象中返回一个迭代器,iterable必须是一个能提供可迭代器的对象
next(iterable)从迭代器iterable中获取下一个记录,如果无法获取下一个记录,则返回StopIterator异常
说明:
1. 迭代器只能往前取值不会后退
2. 用iter 函数可以返回一个可迭代对象的迭代器
用途:
用迭代器可以依次访问可迭代对象的数据,
示例:
s={'唐僧','悟空','悟净','悟能','白龙马'}
for x in s:
print(x)
else:
print('end')
it=iter(s)
while True:
try:
x=next(it)
print(x)
except:
break
生成器Generator
什么是生成器
生成器是能够动态提供数据的对象,生成器对象也是可迭代对象(实例)
生成器有两种
生成器函数
生成器表达式
生成器函数的定义
含有yield语句的函数是生成器函数,此函数被调用将返回一个生成器对象
yield翻译为产生(或生成)
yield语句
语法:
yield表达式
说明:
yield用于def函数中,目的是将此函数作为生成器函数使用
yield用来生成数据,供迭代器和next(it)函数使用
生成器函数说明:
生成器函数的调用将返回一个生成器对象,生成器对象是个可迭代对象,通常用来动态生成数据
生成器函数调用return语句会触发一个异常
生成器表达式
语法:
(表达式 for 变量 in 可迭代对象 [if 真值表达式]])
作用:
用推导式形式创建一个新的生成器
说明:
if 字句可以省略
示例
gen=(x**2 for x in range (1,5))
it=iter(gen)
print(next(it))
生成器表达式和列表推导式的区别
L=[2,3,5,7]
L2=[x**2+1 for x in L]
it=iter(L2)
print(next(it))
L[1]=30
print(next(it))
列表推导式一次性生成静态数据
L=[2,3,5,7]
gen=(x**2+1 for x in L)
it=iter(gen)
print(next(it))
L[1]=30
print(next(it))
生成器表达式现用现生成.
迭代工具函数:
作用是生成一个个性化的可迭代对象
函数:
zip(iter1[,iter[……]])
返回一个zip对象，此对象用于生成元组，此元组的每个数据源于参数中的可迭代对象，当最小的可迭代对象不再提供数据时迭代结束
enumerate（iterable[，start]）
生成带索引的枚举对象，返回的迭代类型为索引-值对（index-value）对，默认索引从0开始，也可以用start绑定
zip 示例：
numbers=[10086,10000,10010,95588]
names=['中国移动','中国联通','中国圆通]
for t in zip(numbers,name):
print(t) #(1, 10086, '中国移动')
for x,y,z in zip(range(10),range(5,9),range(80,90)):
print(x,y,z)
序列的种类：
字符串str
列表list
元组tuple
字节串bytes
字节数组bytearry
字节串和字节数组
字节串：
作用：存储以字节为单位的数据
字节串是不可改变的字节数列
字节：
字节是0-255之间的整数，字节是数据传输和数据存储的基本单位
创建空字符串的字面值
b'' b"" b""""""
创建非空字符串的字面值
b'ABCD' b"\x41"
字符串的构造函数：
bytes()#生成一个字的字节串
bytes(整形可迭代对象)#用可迭代对象创建一个字节串
bytes（整数n）生成n个值为0的字符串
bytes（字符串，encoding='utf-8'）#用字符串的转换编码生成一个字符串
bytes的运算：
与其他序列的运算规则完全相同
+ += * *= == ！=
in /not in
索引和切片
len（x），max（x），min(x),any(x),all(x)
bytes 与str 的区别
bytes 存储字节（0-255）
str存储字节（表示文本信息 0-65535或更大）
bytes与str相转换
编码（encoding）
strààààbytes
b= s.encode（encoding='utf-8'）
编码（decode）
bytesààààstr
s=b.decode（encode=“utf-8”）
序列：
str（不可变）
list（可变）àtuple（不可变）
bytearray（可变）àbytes(不可变)
字节数组bytearray
可变的字节序列
构造函数
byteary()#生成一个字的字节串
byteary(整形可迭代对象)#用可迭代对象创建一个字节串
byteary（整数n）生成n个值为0的字符串
byteary（字符串，encoding='utf-8'）#用字符串的转换编码生成一个字符串
运算与字节串完全相同
字节数组支持索引和切片赋值
方法 | 说明 |
B.clear() | 清空 |
B.append(n) | 追加一个字节(n为0-255的整数) |
B.remove(value) | 删除第一个出现的字节,如果没有出现，则产生ValueError错误 |
B.reverse() | 字节的顺序进行反转 |
B.decode(encoding='utf-8') | |
B.find(sub[, start[, end]]) |
bytearray 的方法:
——Day16分割线——
文件File
什么是文件
文件是用于数据存储的单位
文件通常用来长期存储数据
文件中的数据是以字节（bytes）为单位进行存储的
文件的操作流程：
1打开文件
2.读/写文件
3.关闭文件
任何操作系统，一个应用程序同时打开文件的数量有最大限制
文件的打开函数：
open（file，mode=‘rt’）
用于打开一个文件，返回此文件对应的文件流对象，如果打开失败则会触发OSError错误
文件的关闭方法：
F.close（）#关闭文件，释放系统资源
文本文件的操作：
文件文本的模式字符‘t’
说明：
1.对文本文件的读写需要用字符串str进行读取写入操作
2.默认文件中存储的都是字符（文字）数据，在读写中会自动进行编码操作
3.以行为为单位分割，在python内统一用‘\n’作为换行符进行分隔
各操作系统的换行符：
Linux | \n |
windows | \r\n |
旧Maxintosh | \r |
新Max OS | \n |
文件
mode 模式字符的含义
字符 | 含义 |
'r' | 以只读方式打开(默认) |
'w' | 以只写方式打开，删除原有文件内容(如果文件不存在，则创建该文件并以只写方式打开) |
'x' | 创建一个新文件, 并以写模式打开这个文件,如果文件存在则会产生"FileExistsError"错误 |
'a' | 以只写文件打开一个文件，如果有原文件则追加到文件末尾 |
'b' | 用二进制模式打开 |
't' | 文本文件模式打开 (默认) |
'+' | 为更新内容打开一个磁盘文件 (可读可写) |
· 缺省模式是 'rt'
· 'w+b' 可以实现二进制随机读写，当打开文件时，文件内容将被清零
· 'r+b' 以二进制读和更新模式打开文件,打开文件时不会清空文件内容
· 'r+' 以文本模式读和更新模式打开文件,打开文件时不会清空文件内容
python 文件常用方法:
方法 | 说明 |
F.close() | 关闭文件(关闭后文件不能再读写会发生ValueError错误) |
F.readline() | 读取一行数据, 如果到达文件尾则返回空行 |
F.readlines(max_chars=-1) | 返回每行字符串的列表,max_chars为最大字符(或字节)数 |
F.writelines(lines) | 将字符串的列表或字符串的列表中的内容写入文件 |
二进制文件操作方法 | |
F.read(size=-1) | 从一个文件流中最多读取size个字符(文本文件)或字节(二进制文件),如果不给出参数，则默认读取文件中全部的内容并返回 |
F.write(text) | 写一个字符串到文件流中，返回写入的字符数(文本文件)或字节数(二进制文件) |
F.tell() | 返回当前文件流读写指针的绝对位置(字节为单位) |
F.seek(offset, whence=0) | 改变数据流读写指针的位置，返回新的绝对位置 |
F.flush() | 把写入文件对象的缓存内容写入到磁盘 |
F.readable() | 判断这个文件是否可读,可读返回True,否则返回False |
F.writable() | 判断这个文件是否可写,可写返回True,否则返回False |
F.seekable() | 返回这个文件对象是否支持随机定位 |
F.truncate(pos = None) | 剪掉 自pos位置之后的数据，返回新的文件长度 |
文本文件读方法：
F.readline（）
F.readlines（）
F.read（[字符数或字节数]）
文本文件写方法
F.writelines（）
F.write（）
文件的迭代读取
文件流对象是可迭代对象，迭代过程将以换行符‘\n’作用分隔符依次获取
标准输入输出文件：
sys.stdin标准输入文件（默认为键盘设备）
CTRL+D输入结束符
sys.stdout标准输入文件（默认为屏幕终端）
sys.stderr标准错误输出文件（默认为屏幕终端）
模块名：sys
import sys
s=sys.stdin.readline()
print(s)
说明：
1. 标准文件不需要打开和关闭就可以使用
2. 每一个python程序启动后都会有以上三个文件供我们使用
二进制文件操作
模式字符：'b'
默认文件中存储的都是以字节为单位的数据，通常有人为的格式对二进制文件的读写需要用字符串进行操作（bytes）
常见的操作方法:
F.read([字节数/字符数])
对于文本文件，F.read（）返回的为字符串str
对于二进制文件，F.read返回的为字节串bytes
F.write（）
同上，对于二进制文件，返回的为bytes或byteary
F.tell()方法
返回当前读写位置
F.seek()方法
作用设置文件的读写位置
格式：
F.seek（偏移量，whence=相对位置）
偏移量
大于0代表向文件尾方向移动
小鱼0代表向文件头移动
相对位置
0代表从文件头开始偏移
1代表从当前位置开始偏移
2代表从文件尾开始偏移
汉字编码（两种）
十个汉字占多少字节？
20个（GBK编码）
10个（UTF-8编码）
国标编码：
GB18030（二字节或四字节编码，27533个字）
GBK（二字节编码，21003个字）
GB2312（二字节编码，6763个字）
国标标准：
UNICODEßàUTF-8
(Linux/Mac OS X/IOS/Android常用)
Python的编码（encode）字符串：
'gb2312'
'gbk'
'gb2312'
'ascii'
编码注释
在源文件中的第一行或第二行写入如下内为编码注释
#-*- coding:gbk
、、-*-
#设置源文件的编码格式为GBK
作用：告诉解释执行器，当前的文件的编码方式
——Day17分割线——
三、面向对象
面向对象编程Object-Oriented Programming
什么是对象：
对象是指现实中的物体或实体
什么是面向对象
把一切看成对象（示例），用各种对象之间的关系来描述事物
对象的特征
1.对象有很多属性（名词或形容词）
年龄、姓名、性别
2.对象有很多行为（动作、动词）
学习，吃饭
什么是类：
拥有相同属性和行为的对象分为一组，即一个类
类是用来描述对象的工具，用类可以创建此类的对象
类的对象示意
语法：
class类名（继承列表）：
'''类文档字符串'''
实例方案定义
类变量定义
类方法定义（@classmethod）
静态方法的定义（@staticmethod）
作用：
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个的对象（实例）
说明：
类名必须为标识符
类名实质就是变量，它绑定一个类
构造函数
构造函数调用表达式：
类名（[创建传参列表]）
作用：
创建这个类的实例对象，并返回此实例的引用关系
说明：
实例有自己的作用域与名字空间，可以为该实例添加实例变量（也叫属性）
实例可以调用类方法和实例方法
实例可以访问类变量和实例变量
实例方法（method）
语法：
class 类名（继承列表）
def 实例方法名（self ，形参名1，形参名2）
文档字符串
语句块
作用：用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
说明：实例方法的实质是函数，是定义在类内的函数
实例方法至少有一个形参，第一个形参用来绑定调用这个方法的实例，一般命名为'self'
实例方法的调用语句：
实例.实例方法名（调用传参）
#或
类名.实例方法名（实例.调用传参）
实例属性atrribute（也叫实例变量）
每个实例可以有自己的变量来保存对象自己的数据，称为实例变量（也叫属性）
语法：
实例.属性名
赋值规则同变量的赋值规则：
首次为属性赋值则创建此属性
再次为属性赋值则改变属性的绑定关系
作用：记录每个对象自身的数据
del语句
可以删除对象的属性
语法：
del 对象.实例变量名
del小结
1） 删除变量 del name
2） 删除列表中的元素 del[0] del[::2]
3） 删除字典的键 del['name']
4） 删除对象的属性 del god1.name
初始化方法
作用：
对新创建的对象添加属性
语法格式：
class 类名（继承列表）
def __init__(self,[形参列表])：
语句块
注：[]内的内容可以省略
说明：
1.初始化方法名必须为‘__init__’不可改变
2.初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self传入__init__f方法
3.构造函数的实参将通过__init__方法的参数列表传入到__init__方法中
4.初始化方法内如果需要return语句返回，则只能返回None
析构方法
class 类名（继承列表）
def __del__(self):
语句块
析构方法在对象呗销毁时被自动调用
Python语言建议不要在对象销毁时做任何事情，因为销毁时间难以确定
预置实例属性
__dict__属性
__dict__属性绑定一个存储此实例自身变量字典
示例:
class Dog:
pass
dog1=Dog()
print(dog1.__dict__)#{}
dog1.color='white'
print(dog1.__dict__)
dog1.kind='A型狗'
print(dog1.__dict__) # {'color': 'white', 'kind': 'A型狗'}
__class__属性
'__class__'属性绑定创建此实例的类
作用：
可以借助此属性来访问创建此实例的类
用于类的函数
isinstance(obj,class_or_tuple) 返回这个对象obj是否是某个类的对象或者某些类中的一个类的对象，如果是则返回True
type(3.14) is float
—Day18分割线——
类变量
类变量是类的属性，此属性属于类，不属于此类的实例
作用：
通常用来存储该类创建对象的共有属性
说明：
类变量可以通过该类直接访问
类变量可以通过类的实例直接访问
类变量可以通过此类的对象的__class__属性间接访问
类的文档字符串
类内第一个没有赋值给任何给任何变量的字符串为类的文档字符串.__doc__
类的__slots__列表
作用：
限定一个类创建的实例只能有固定的属性，（实例属性）
不允许对象添加列表以外的属性（实例变量）
防止用户因写错属性名而发生程序错误
说明：
__slots__属性绑定一个字符串列表
含有__slots__属性的类所创建的实例对象没有__dict__属性，即此实例
__slots__=[属性]
类方法@classmethod
类方法是用于描述类的行为的方法，类方法属于类，不属于类的实例对象
说明：
类方法需要使用@classmethod装饰器定义
类方法至少有一个形参，第一个形参用于绑定类，约定为‘clas’
类和该类的实例都可以调用类方法
类方法不能访问此类创建的对象的实例属性
静态方法@staticmethod
静态方法是定义在类的内部的函数，此函数的作用域是类的内部
说明：
静态方法需要@staticmethod装饰器定义
静态方法与普通函数的定义相同，不需要传入self实例参数和cls类参数
静态方法只能凭借该类或类创建的实例调用
静态方法不能访问类变量与实例变量
继承与派生inheritance&derived
什么是继承/派生
1.继承是从已有的类中派生出新的类，新类具有原类的数据属性和行为，并能拓展新的行为
2.派生类就是从一个已有的类中衍生出新的类，在新类的基本上添加新的属性和行为
为什么继承/派生
继承的目的是延续旧类的功能
派生类的目的是在旧类的基础上改变原有的功能
名词：
基类（base class）/超类（super class）/父类（father class）
派生类（derived class ）/子类（child class）
单继承
语法：
class类名（基类名）：
语句块
说明：
单继承是指派生类由一个基类衍生出来新类
继承派生机制的作用：
1.可以将一些共有的功能加在基类中，实现代码共享
2.在不改变积累的基础上改变原有的功能
继承说明：
python3中任何类都直接或间接的继承于object类
object类是一切类的超类
类的__base__属性
__base__属性用来记录此类的基类
覆盖override
什么是覆盖：
覆盖是指在有继承关系的类中，子类中实现了与基类同名的方法，在子类的实例调用该方法时，实际调用的是子类中的覆盖版本，这种现象叫做覆盖
当覆盖发生时子类如何调用原方法：
基类名.方法名（实例）
super函数
super（cls，ob）返回绑定超类的实例（要求obj必须为cls类型的实例）
super（）返回绑定超类的实例，等同于：super（__class__,实例方法的第一个参数，必须在方法中调用）
作用：
借助super（）返回的实例间接调用父类被覆盖方法
super（子类，子类对象）.被覆盖方法() #将子类当做父类调用
显式调用积累的初始化方法
当子类中实现了__init__法法，基类的构造当大并不会被调用，此时需要显式调用
—Day19分割线——
用于类的函数
issubclass(cls,class_or_tuple)判断一个类是否继承自其他的类,如果此类cls是class或tupleBS一个派生子类则返回True
class A:
pass
class B(A):
pass
class C(B):
pass
print(issubclass(C,B))#C是B的子类True
print(issubclass(C,A))#True
封装 enclosure
封装是指隐藏类的实现细节,让使用者不必关心这些细节
封装的目的是让使用者通过尽可能少的方法,或属性操作对象
私有属性和方法
python中,以双下滑线开头，不以双下划线结尾的标识符为私有成员，私有成员只能使用该类的方法来进行访问和修改
1. 以__开头的属性为私有属性
2. 以__开头的方法为私有方法
多态polymorphic
字面意思：‘多种状态’
多态是在继承/派生关系的类中，调用基类的对象的方法，实际能调用子类的覆盖方法的现象叫做多态
状态：
静态（编译时状态）
动态（运行时状态）
说明：
多态调用的方法与对象相关，不写类型相关
python全部对象都只有‘运行时状态（动态）’，没有c++里的编译时的状态（静态）
面向对象编程语言的特征：
继承
封装
多态
多继承multiple inheritance
多继承是指一子类继承自两个或两个以上的基类
语法：
class类名(基类名1，基类名2……)
pass
说明
1.一个子类同时继承自多个父类，父类中的方法可以同时被继承下来
2.如果两个父类中有同名的方法，而在子类中又没有覆盖此方法时，调用结果难以确定
多继承的问题（缺陷）
class A:
def m(self):
print('A.m()')
class B():
def m(self):
print('B.m()')
class AB(A,B):
pass
ab=AB()
ab.m()
结果：A.m()
多继承的MRO（Method Resolution Order）问题
类的__mro__属性
作用：用来记录类的方法查找顺序
super（）函数就是根据__mro__调用上层的方法
见d19 mro.py
函数重写overwritd
什么是函数重写
在自定义类内添加相应的方法，让自定义的类创建的实例能够使用内建函数进行操作
对象转字符串函数
repr(x)返回一个能表示python对象的表达式字符串，
通常eval（represent（obj））==obj
str（x）通过给定的对象返回一个字符串（这个字符串通常供人阅读）
示例:
s='I am teacher'
print(str(s))# I am teacher
print(repr(s))#" I am teacher "
对象转字符串函数的重写方法：
repr（）函数的重写方法：
def __repr__(self):
return 字符串
str（）函数的重写方法：
def __str__(self):
return 字符串
str（obj）函数调用方法说明：
1. str（obj）函数先查找obj.__str__方法，调用此方法并返回结果
2. 如果obj.__repr__方法不存在，则调用object类的__repr__方法不存在，则调用object类的__repr__实例方法显示<__main__.XXXX object at 0xXXXXXXXX>格式的字符串
class Mynumber:
def __init__(self,val):
self.data=val
def __str__(self):
return '数字：%d'%self.data
def __repr__(self):
return "mynumber(%d)"%self.data
n1=Mynumber(100)
print('str',str(n1))
print(n1.__str__())
print('repr',repr(n1))
print(n1.__repr__())
print(n1)#print会把n1转成str()
内建函数重写
--------
class mylist:
'''此类型的对象用data属性绑定的列表存储'''
def __init__(self,iterable=()):
self.__data=[x for x in iterable]
def __repr__(self):
return 'mylist%s'%self.__data
def __len__(self):
return len(self.__data)#重写len
def __abs__(self):
return [abs(x) for x in self.__data]
myl=mylist([1,-1,6,-5,-88,88,1,1,2])
print(mylist.__doc__)
print(myl)
print(len(myl))
print(':',(myl.__str__()))
print(abs(myl))
-------------
数值转换函数的重写：
class Mynumber:
def __init__(self,val):
self.data=val
def __repr__(self):
return 'mynumber(%d)'%self.data
def __int__(self):
return int(self.data)
def __float__(self):
return float(self.data)
#def __complex__(self):
n1=Mynumber(100)
n=int(n1)
print(n)
f=float(n1)
print(f)
print(f.__float__())
布尔测试函数的重写
格式：
def __bool__（self）
作用：
用于bool（obj）函数取值
用于if 语句真值表达式中
用于while语句的真值表达式中
说明：
1. 当自定义类内含有__bool__(self)方法时，此方法时的返回作为bool(x)的返回值
2. 当不存在__bool__(self)方法时，返回__len__(self)方法的返回值是否为0来测试布尔值
3. 当不存在__len__(self)方法时，则直接返回True
示例：
class Mylist:
def __init__(self,iterable=()):
self.__data=[x for x in iterable]
def __repr__(self):
return 'mylist%s'%self.__data
def __len__(self):
return len(self.__data)#重写len
def __bool__(self):
print('__bool__方法被调用')
return False
MYL=Mylist([False,0,0,1])
print(bool(MYL))
if MYL:
print(MYL,'True')
else:
print(MYL,'False')
#__bool__方法被调用
#False
#__bool__方法被调用
#mylist[False, 0, 0, 1] False
对象的属性管理函数：
getattr(obj，name[,default])
从一个对象用字符串name得到对象的属性，getattr(x,'y')等同于x，y；当属性不存在时，如果给定defult参数则返回default，如果没有给出default则触发AttributeError错误
hasttr（obj,name）避免在getattr时发生错误
setattr（obj，name，value）给对象obj的名为那么的属性设置相应的值value，setattr（x，‘y’，v）等同于x.y=v
delattr（obj，name）删除对象obj中的name属性del（x,'y'）等同于del x.y
迭代器（高级）
什么是迭代器：
由iter（x）函数返回，可以通过next（it）函数取值的对象就是迭代器
迭代器协议：
迭代器协议是指对象能够使用next()函数获取下一项数据，在没有下一项数据时触发一个StopIteration异常来终止迭代的约定
迭代器协议的实现方法：
def __next__(self):
……
注：此方法需要实现迭代器协议
什么是可迭代对象
是指能用iter（obj）函数返回迭代器的对象（实例）
可迭代对象的内部要定义__iter__(self)方法来返回迭代器对象
class Mylist:
def __init__(self,iterable=()):
self.data=[x for x in iterable]
def __repr__(self):
return 'mylist%s'%self.data
def __iter__(self):
'''此方法用来描述能够访问self类型的迭代器'''
print('__iter__被调用')
return MyListIteroator(self.data)
class MyListIteroator:
'''此类用来描述能够访问Mylist类型的迭代器'''
def __init__(self,lst):
self.data_lst=lst
self.cur_index=0#访问的起点
def __next__(self):
'''此方法来实现迭代器的协议'''
if self.cur_index>=len(self.data_lst):
raise StopIteration
r=self.data_lst[self.cur_index]
self.cur_index +=1
return r
myl=Mylist([2,3,5,7,7])
it=iter(myl)
print(next(it))
for x in myl:
print(x)
__iter__被调用
2
__iter__被调用
2
3
5
7
7
—Day20分割线——
异常(高级)
with语句
语法:
with 表达式1 [as 变量1]，表达式2 [as 变量2]……
作用：
使用于对资源进行访问的场合，确保使用过程中不管是否发生异常都会执行必须的‘清理’操作，并释放资源
如：文件打开后自动关闭，线程中锁的自动获取和释放等
说明：
执行表达式as 子句中的变量绑定生成的对象
with语句并不改变异常的状态
with open("x.txt") as f：
………… #自动关闭
环境资源管理器
1.类内有__enter__和__exit__实例方法的类创建的对象称为环境管理器
2.能够用with语句进行管理的对象必须是环境管理器
说明：
3.__enter__方法将在进入with语句时被调用，由as变量绑定返回的对象
4.__exit__方法将在离开with语句时被自动调用，且可以通过参数来判断离开with语句时是否发生异常并作出相应的处理
class A:
'''此类的对象可以用于with语句进行管理'''
def __enter__(self):
print('此方法已进入，是在with语句内执行的')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
'''exc_tb用来绑定错误类型，没有错误发生时，绑定None
exc_val用来绑定错误对象，当没有发生异常时绑定None
exc_tb用来绑定TraceBack对象，当没有异常时绑定None'''
if exc_type is None:
print(' 您已经退出了with语句，没有发生异常')
else:
print('您已经离开with')
print('错误类型为',exc_type)
print('错误的对象是：',exc_val)
print('TrackBack',exc_tb)
with A() as a:
print('with语句内部的输出')
x=1/0
print('程序结束')
运算符重载
什么是运算符重载
让自定义的类生成的对象（实例）能够使用运算符进行操作
作用：
1. 让自定义的类的实例能够运行运算符操作
2. 让程序简洁易读
3. 对自定义对象将运算符赋予新的规则
方法名 | 运算符和表达式 | 说明 |
__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 | 幂 |
rhs(right,hand)右手边 | ||
n3=n1+n2✏等同于✏n3=n1.__add__n2
二元运算符的重载方法格式
def __xxx__(self,other):
语句块
反向算术运算符的重载
当运算符的左侧为内建类型时，右侧为自定义类型进行算术运算时会出现TypeError错误，因无法修改内建类型的代码实现运算符重载;，此时需要使用反向运算符的重载
方法名 | 运算符和表达式 | 说明 |
__radd__(self,rhs) | lhs+self | 加法 |
__rsub__(self,rhs) | lhs-self | 减法 |
__rmul__(self,rhs) | lhs*self | 乘法 |
__rtruediv__(self,rhs) | lhs/self | 除法 |
__rfloordiv__(self,rhs) | lhs//self | 地板除 |
__rmod__(self,rhs) | lhs%self | 模求余 |
__rpow__(self,rhs) | lhs**self | 幂 |
复合赋值算术运算符的重载
以复合赋值算术运算符x+=y为例，此运算会优先调用x.__iadd(y)方法，如果没有__iadd__方法，如果再不存在__add__方法则会触发TypeError类型的错误异常
比较算术运算符的重载
__lt__、__le__、__gt__、__ge__、__eq__、__ne__
True或False
位运算符的重载
invert xor lshift shift
反向位运算符的重载
复合位运算符的重载
一元运算符的重载
方法名 | 运算符 | 说明 |
__neg__(self) | -self | 负号 |
__pos__(self) | +self | 正号 |
__invert__(self) | ~self | 取反 |
in notin运算符重载
格式：
def __contains__(self,e)
语句
注：in/not in 返回True/Flase
当重载在了__contains__后，in和not in 运算符都可用，not in的返回值与in相反
索引和切片运算符重载方法：
作用：让自定义的类型的对象能够支持索引和切片操作
slice构造函数
作用：
用于创建一个slice对象，此对于用于切片操作的传值
格式：
slice（start=None,stop=None,step=None）
slice对象的实例属性：
start 切片的起始值，默认为None
stop 切片的终止值，默认为None
step切片的步长，默认为None
特殊属性@property
实现其他语言所拥有的getter和setter功能
作用:
用来模拟一个属性,通过@property可以对模拟属性的取值和赋值加以控制
PEP8编码规范
代码编排
1. 使用4空格缩进，不使用Tab,更不允许用Tab和空格混合缩进
2. 每行最大长度最大79字节，超过部分使用反斜杠折行
3. 类和全局函数定义间隔两个空行,类内方法定义间隔一个空行.其它地方可以不加空行。
文档编排
1. 其中import部分，又按标准、三方和自己编写顺序依次排放，之间空一行。
2. 不要在一句import中导入多个模块，比如不推荐import os, sys。
3. 尽可能用import XX 而不采用from XX import YY引用库,因为可能出现名字冲突。
空格的使用
1. 各种右括号前不用加空格
2. 逗号、冒号、分号前不要加空格。
3. 函数的左括号前不要加空格。如func(1)。
4. 序列的左括号前不要加空格。如list[2]。
5. 操作符左右各加一个空格，不要为了对齐增加空格。
6. 函数默认参数使用的赋值符左右省略空格。
7. 不要将多条语句写在同一行，尽管使用‘;’允许。
8. if/for/while语句中，即使执行语句只有一句，也必须另起一行
原则：避免不必要的空格
用户信息
用户:
等级: lv-1
资料列表
Python基础
Django
PythonNet
正则表达式
Linux命令
Mysql
Javascript