day01回顾:
变量:
创建变量(赋值语句)
变量 = 表达式
修改变量
变量 = 表达式
删除变量
del 变量名
python 起源
应用领域
优点:
缺点:
执行速度慢
不能封闭源代码
www.python.org
版本 python v2 / v3
解释执行器 python3 (CPython)
CPython/Jython/IronPython
运行:
1. python3 文件名.py
2. python3 <回车>
>>>
数据类型:
数字: 整数int, 浮点型数float, 复数complex, 布尔型数(True/False)
字符串str: "文字内容"
列表list
...
None 空值对象
运算符:
+ - * / // % **
is / is not
print() 函数
id(x) 返回对象的内存地址
变量占用内存吗? 1byte(字节) = 8bit位
复合赋值算术运算符:
+ - * / ...
+= -= *= /= //= %= **=
day02回顾:
运算符:
比较运算符:
> < >= <= == !=
布尔运算符
not and or
bool(x) 为假值的情况:
None, False, 0, 0.0, 0j '' [] ()
一元运算符:
+ (正号) -(负号)
if 语句(分支语句)
if a > b or c > d:
...
elif e < f:
...
else:
...
条件表达式:
表达式1 if 真值表达式 else 表达式2
函数:
函数调用:
函数名 (调用传参列表)
int(x=0)/int('字符串', base=10)
float(x=0)
complex(real=0.0, image=0.0)
bool(x)
abs(x)
round(x, 位数)
round(123.456789, 2)
pow(x, y, z=None)
输入输出函数:
input('提示字符串')
print(value, ....., sep=' ', end='\n')
help(字符串/函数名/类名....) 帮助函数
语句:
显式换行 \
隐式换行: () [] {}
pass 语句
day03回顾:
字符串 str
字符串内存放的是有先后顺序关系的文字编码
字面值:
''
""
''''''
"""""" (所见即所得字符串,回车键会自转换为换行)
转义符号 \
\n \' \" \\ \r \t \b
\0oo \xXX \uXXXX \UXXXXXXXX
\0 等同于 \x00
'A' 65 0x41
'a' 97 0x61
'0' 48 0x30
' ' 32 0x20
原始字符串:
raw字符串
r''
r""
r''''''
r"""""" ( \ 转义无效)
字符串运算:
+ += * *=
< <= > >= == !=
in / not in (返回值是布尔类型)
索引 []
正向索引 0 1 2 3 ....
反向索引 -1 -2 ..... -len(x)
切片 [:] [::]
s[整数开始值: 整数结束值: 整数步长]
函数:
len(x) / max(x) / min(x)
ord(c) chr(i)
bin(x) oct(x) hex(x)
str(x)
字符串的方法:
S.isalpha()
S.isdigit()
S.center(n, fill=' ')
S.replace(old, new, count)
S.strip() 支掉空白字符
S.startswith(ch)
S.endswith(ch)
S.count()
...
print(x.count('a'))
print(x.isalpha())
print(x.isdigit())
print(x.center(10))
print(x.find('a',2,6))
print(x.isupper())
print(x.lower())
print(x.strip())
print(x.replace('a',' '))
print(x.startswith('a'))
详见:
>>> help(str)
day04回顾:
字符串格式化表达式
"格式化字符串" % 参数
"格式化字符串" % (参数1, 参数2,...)
"%d" % 20 # 生成'20'
%s %d %f %7.2f
% [ - + 0 宽度 . 精度] 类型码
while 语句
while 布尔表达式:
语句块1
else:
语句块2
break 语句
死循环
while True:
if xxxx:
break
循环语句:
while 语句
for 语句
day05回顾:
for 语句
for 变是列表 in 可迭代对象:
语句块1(重复执行多次)
else:
语句块2(在可迭代不再能提供数据时执行)
可迭代对象:
字符串 列表 range(开始,结束,步长)
continue 语句
while 中
for 中
语句嵌套:
if while for .....
如:
if xxx:
while ....:
for xxxx:
if xxxx:
while xxx:
for yyy:
...
if zzz:
....
else:
print(...)
print("hello)
列表 list
[]
[1, 2, 3. 3.14, True, ...]
序列,可变的, 容器
构造函数
list()
list(可迭代对象)
列表的运算:
运算符:
+ += * *=
< <= > >= == !=
in / not in
索引[] / 切片[:] [::]
索引和切片支持赋值操作:
列表[整数列表] = 值
列表[开始索引:结束索引:步长] = 可迭代对象
day06回顾
列表
方法:
L.append(x)
L.extend(iterable) +=
L.insert(索引位置，值)
L.remove(x) # 删除
L.clear()
L.pop([索引]) 取出
L.copy() 复制
L.count(元素,begin,end) 计数
L.sort(reverse=False)
L.reverse() 反转
len(x) 求长度
max(可迭代对象)/max(值1,值2,....)
min(可迭代对象)/min(值1,值2,....)
sum(可迭代对象) # 求和
any(可迭代对象)
all(可迭代对象)
列表是可变的对象
浅拷贝和深拷贝
变量1 = 变量2 # 不复制
变量1 = 列表2.copy() # 浅拷贝
import copy
变量1 = copy.deepcopy(列表2) # 深拷贝
字符串的方法:
str.split()
str.join()
列表推导式:
[表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 ...]
day07回顾
元组 tuple
可以是任意类型的数据(类似于列表)
元组是不可变的序列(类似于字符串)
() (20,) (10, 20)
20, 10, 20
构造函数tuple() / tuple(可迭代对象)
字符串, 列表,元组的运算:
+ += * *=
< <= > >= == !=
in / not in
索引 index / 切片 slice
reversed(可迭代对象) 反转序列
字典 dict
表示方式
{}, {1:'一'}, {1:'一', 2:'二'}
构造函数 dict
dict()
dict(可迭代对象)
dict(["AB", (1,2), [3, 4]])
dict(关键字传参)
dict(name="laowei", age=35)
键索引
字典[键表达式] # 取值
字典[键表达式] = 表达式 # 赋值
del 字典[键表达式]
D.clear() 清空
D.pop(键) 移除
D.copy()
D.update(D2) 合并
D.get(键, default=None)
D.keys() # 键 key
D.values() # 值 value
D.items() # 键值对
for k, v in D.items():
pass
字典推导式:
生成字典:
{键表达式: 值表达式 for 变量in 可迭代对象 if 条件表达式 .....}
阶段总结：
数据类型：
不可变类型
bool int float complex str tuple
frozenset bytes(字节串)
可变类型
list dict set bytearray(字节数组)
运算符：
＋ －×/ //% < <= ==
not in/in
is / is not
& |^-
索引／切片
表达式
１
１＋２
max(1.2.3)+max(4,5,6)
条件表达式 x if x<y else y
全部的推导式： 列表，字典，集合推导式（三种）
语句：
表达式语句
赋值语句
判断语句
循环语句
del 语句 if 语句 for 语句 break 语句 continue语句 pass 语句
内建函数
max()
len()
构造函数
int()
float(str())
list()
tuple()
dict()
set()
frozenset()
数值处理函数
abs(x)
round(x)
pow(x,y,z=None)
编码转换
ord()
chr()
进制转换
hex()
bin()
oct()
返回可抵达对象的函数
range(start,stop,step)
reversed(x)
输入输出函数
input()
print()
ay08回顾
两个容器类型
set (可变集合)
frozenset (不可变集合)
存储不可变数据的容器
无序/不能存在重复元素
运算:
&交集 |并集 -补集 ^对称补集
< > == != <= >=
in / not in
集合:
{1,2,3} / set()
frozenset({1,2,3}) / frozenset()
方法:
S.add()
S.remove()
S.discard()
S.clear()
S.pop()
S.copy()
S.update()
集合推导式:
{x**2 for x in range(10)}
{x for x in "AABCABC"} # {'A','B','C'}
函数:
创建函数的语法:
def 语句:
def 函数名(形参变量1, 形参变量2, ...):
语句块
函数的调用:
函数名(实参1, 实参2, ...)
表达式返回None
return 语句
语法:
return # 相当于return None
或
return 表达式
作用:
用于终止函数的执行,返回一个对象的引用关系(默认返回None)
day09回顾:
实参 -----> 形参
参数传递:
位置传参
序列传参 (*序列)
关键传参
print(1, 2, 3, sep='#')
字典关键传参(**字典)
形参有四种
1. 位置形参
2. *元组形参 (接收多余的位置传参:*args)
3. 命名关键字形参(强制使用关键字传参)
4. **字典形参(接收多余的关键传参:**kwargs)
缺省参数:
def fx(a,b=0,*,c=0,d=0):
pass
全局变量
局部变量
函数内部创建的变量是局部变量
globals()
locals()
函数变量
def 函数变量名(形参列表):
语句块
def f1():
pass
f2 = f1 # f2 绑定 f1绑定的函数
f2 = f1() 调用后返回None
函数可以作为参数传入另一个函数
def fx(fn):
...
fx(f1) # 和 fx(f1()) 不同
函数可以作为另一个函数的返回值
def fy():
return max
def fz():
def f2():
pass
return f2
函数嵌套定义
python 的四个作用域
局部 L
外部嵌套函数作用域 E
全局(函数所在模块的作用域) G
内建函数作用域 B
global 语句 (声明变量为全局变量)
nonlocal 语句 (声明变量为外部嵌套函数作用域内的变量)
lambda 表达式
作用:
创建匿名函数
语法:
lambda 形参列表: 表达式
eval(字符串, 全局变量的字典,局部变量的字典)
返回表达式执行后返回的对象
exec(字符串, 全局变量的字典,局部变量的字典)
把字符串当成程序解释执行
day11回顾
函数式编程
建议使用可重入函数
可重入函数一定不使用除局部变量以外的变量
高阶函数:
map(func, 可迭代对象1, 可迭代对象2,...)
filter(func, 可迭代对象)
sorted(可迭代对象, key=None, reverse=False)
递归函数
函数直接或间接调用自身
闭包 closure
内嵌函数引用了外部变量,返回的内嵌函数叫做闭包
ay12 回顾:
装饰器
def 装饰器函数名(被装饰函数形参):
创建闭包
return 闭包
@装饰器函数名
def 被装饰函数(形参列表):
pass
被装饰函数(实参列表)
函数的文档字符串:
def 函数名(...):
'文档字符串'
>>> help(函数名)
__doc__属性
函数名.__doc__ = '文档字符串'
模块
模块内通常有 数据,函数,类
四类模块:
内建模块
标准库模块
第三方模块
自定义模块
模块的导入语句有三种:
import 语句
import sys
sys.path
from import 语句
from sys import path
print(path)
from import * 语句
from sys import *
print(path)
dir() 函数
三个模块:
math
time
sys
day13回顾:
自定义模块
模块名(标识符).py
全局变量将成为模块的属性
导入方式:
import 语句
from import 语句
from import *语句
搜索:
1. 内建模块
2. 当前工作路径
3. sys.path提供的路径
import mymod # 执行 mymod.py
mymod.py ---> mymod.pyc ---> python
模块内的序置属性
__doc__ 属性
__file__属性
__name__属性
__all__ 列表
from import *语句
隐藏属性
以 _ 开头的 标识符 在 from import *语句导入时不会被导入
随机模块 random
包 pack
包的导入:
import 语句
import 包位置
from import 语句
form 包位置 import 子包/模块/属性
绝对位置 mypack.menu
相对位置 ..menu
from import * 语句
from 包位置 import *
__init__.py
文档字符串
函数
__all__列表
day14回顾:
异常 exception
错误
异常
异常相关的语句:
发出(触发/抛出)异常通知:
raise 语句
assert 语句
捕获异常:
try-except 语句
try:
.... 可以触发异常的语句
except 类型 as 变量名:
...
except (类型2,类型3,...) as 变量名:
...
except: (通常放在所有except之后)
...
else:
...
finally:
...
做必须要做的事儿(执行必须要执行语句)
try-finally语句
try:
...
finally:
...
迭代器 iterator
iter(可迭代对象) 返回的是迭代器
next(迭代器) 从可迭代对象中取值
在没有数据时会触发StopIteration异常
day15回顾
生成器
生成器函数
含有yield 语句的函数
1. 返回生成器对象(生成器对象也是可迭代对象)
2. 执行顺序与普通函数不同
1) 当next(it)函数调用时,生成器函数才执行
2) 当遇到yield语句时,保存当前函数的执行状态,将yield 表达式 结果返回给next(it) 函数
3) 生成器的返回会触发StopIteration异常
def myyield():
yield 1
yield 2
生成器表达式:
(表达式 for 变量 in 可迭代对象 if ...)
迭代工具函数
zip(*iterables)
zip([1,2,3], "ABCDE")
(1, 'A')
(2, 'B')
(3, 'C')
enumerate(iterable, start=0)
enumerate("ABC")
(0, 'A')
(1, 'B')
(2, 'C')
enumerate("ABC", 100)
(100, 'A')
(101, 'B')
(102, 'C')
序列
字节串 bytes
不可变序列
字面值:
b'' b"" b'''''' b""""""
b'hello'
字节数组 bytearray
可变的序列
构造函数:
bytes() / bytearray()
bytes(整数可迭代对象)/bytearray(整数..)
bytes(整数n) / bytearray(整数n)
bytes(字符串,encoding='utf-8') /.....
运算:
+ += * *=
< <= > >= == !=
in / not in
索引和切片
字节
0(0b00000000) ~ 255(0b11111111)
day16笔记:
文件
长期存储数据
单位是字节(byte)
文件的操作:
1. 打开文件
2. 读/写文件
3. 关闭文件
释放资源(缓冲区, 内核资源)
打开文件的函数:
open(文件路径名, 打开模式)
方法:
F.close() 关闭文件
# 读,仅在'r'模式下可用
F.read([n]) 读取n个字节/n个字符
F.readline()
F.readlines()
# 写,仅在'w', 'x', 'a' 模式下可用
F.write(字节串/字符串)
F.writelines([字节串/字符串元素])
# 以下两个函数通常只对二进制模式文件操作
F.seek(偏移量,起始位置)
F.tell() # 得到当前读写位置指针
F.flush() # 清空缓冲区
打开模式:
二进制模式: 'b'
把文件看成的字节数据,读写时会直接把磁盘数据以字节串形式返回或写入
文本模式: 't'
把文件看成是字符数据,读写过程中会自动编/解码(默认是'utf-8'),而且会把换行符进行自动转换
汉字编码
只有两种:
GB系列(国家标准)
GB18030(GBK(GB2312))
UNICODE系列(国际标准)
UNICODE32(UNICODE16) <--> UTF-8互转
编码字符串:
'gb18030', 'gbk', 'gb2312','utf-8', 'ascii' ...
编码注释:
# -*- coding:gbk -*-
标准输入输出文件:
sys.stdin
sys.stdout
sys.stderr
day17回顾:
面向对象
对象 object(实例 instance)
面向对象
类 class
类的定义的语句 class 语句
class 类名(继承列表):
# 实例方法
def 实例方法名(self, 方法的形参):
...
def __init__(self, 形参列表):
...
def __del__(self):
...
构造函数:
类名(调用传参)
对象的特征:
行为(实例方法)
吃,睡,
属性(实例变量)
姓名,年龄
class Dog:
pass
dog1 = Dog()
dog1.color = "白色"
del 语句:
删除对象的属性
序置属性:
__dict__ 属性
绑定存储此对象的属性的字典
__class__属性
绑定创建此对象的类
函数:
isinstance(对象, 类或元组) 判断对象是否属于某个类或某些类的一个类的实例
type(对象) # 返回一个对象的类
day18回顾:
类
类变量(类属性)
特列的类变量
__slots__ 列表
预置的类变量:
__doc__
__base__
类方法(@classmethod)
@classmethod
def get_v(cls):
pass
静态方法 @staticmethod
依懒于类或此类的对象来调用
继承/派生
继承可以直接使用父类的方法
派生可以添加新的方法
单继承
class 类名(只有一个父类):
pass
示例:
class A:
def a(self):
pass
def b(self):
pass
class B(A):
pass
覆盖 override
1.有继承
2.子类中有同名的方法
3.子类对象来调用同名的方法
出现覆盖现象
super(类, 对象)
super() # 等同于super(当前类, self)
示例:
class A:
def m(self):
print("A.m")
class B(A):
def m(self):
print("B.m")
class C(B):
def m(self):
print("C.m")
c = C()
c.m() # C.m
super(C, c).m() # B.m
super(B, c).m() # A.m
day19回顾:
issubclass(cls, 类或元组) 判断类的父子关系
面向对象编程语句的特征:
封装
__ 变量(实例变量(实例属性),类变量(类属性))
继承
多态
多继承
支持多继承的语言(C++,Python)
方法名冲突
class A:
pass
__mro__ 类属性
函数重写
让自定义的类添加相应的方法,让此类的对象能够使用内建函数进行操作
repr
str
len
abs
round
reversed
int
float
bool
complex
next(it) __next__(self)
iter(obj) __iter__(self)
