第一张
1)变量
内存空间的表达式
命名要遵守规则
赋值使用 =
2)类型转换
str()将其他类型转成字符窜
int() 将其他类型转成整数
float()将其他类型转成浮点数
3）数据类型
整数类型 int
浮点数类型 float
布尔类型 True/False
字符窜类型 str
4)注释
单行注释 #
多行注释 ''' 或者 """
中文编码声明 #coding:utf-8
第二章
1)程序的三种组织结构
顺序结构
选择结构
循环结构
2)选择结构
单分支结构
双分支结构
多分支结构
嵌套if
条件表达式
3)对象布尔值
False
False
数值0
None
空字符窜
空列表、空元祖、空字典、空集合
True
第三章
1)内置函数range
生成整数数列
起始值默认为0
步长默认为1
2)循环结构
while
用于次数不固定的循环
初始条件不成立一次都不执行
for-in
用于遍历可迭代对象
3)break continue else
break
退出当前循环结构
continue
结束当前循环进入下一次循环
else
if..else
while..else
for..else
4)嵌套循环
外层循环执行一次内层循环执行完整一轮
while与for-in 互相嵌套
示例:
#乘法口诀表
for i in range(1,10):
for j in range(1,i+1):
print(i,'*',j,'=',i*j,end='\t')
print()
#while 循环 1-100 偶数和
sum=0
a=1
while a<=100:
if a%2==0:
sum+=a
a+=1
print(sum)
#for 循环1-100偶数和
zong=0
for i in range(1,101):
if i%2==0:
zong+=i
print(zong)
第四章
1）列表
创建
使用中括号
内置函数list()
列表生成式
查询
查询元素索引
获取单个元素
获取多个元素
in/not in
增删改
增
append()
extend()
insert()
切片
删
remove()
pop()
clear()
del
切片
改
索引
切片
排序
方法sort()
内置函数sorted()
2）字典
字典的创建
使用{}花括号
内置函数dict()
字典生成式
常用操作
获取value
字典名[key]
字典名.get(key)
删除key-value对
del 字典名[key]
修改/新增
字典名[key]=value
in/not in
3）元祖
创建元组
使用()小括号
内置函数tuple()
元组的遍历
for--in
不可变序列
4）集合
创建集合
使用{}花括号
内置函数set()
集合生成式
集合的遍历
for--in
新增
add()
update()
删除
remove()
discard()
pop()
clear()
可变序列
5）
数控结构 是否可变 是否重复 是否有序 定义符号
列表(list) 可变 可重复 有序 []
元组(tuple) 不可变 可重复 有序 ()
字典(dict) 可变 key 不可重复 无序 {key:value}
value 可重复
集合(set) 可变 不可重复 无序 {}
第五章
字符窜
字符窜的驻留
驻留的几种情况
驻留的优点
强制驻留的方法
常用方法
查询的方法
index(),rindex()
find(),rfind()
大小写转换
upper(),lower()
内容对其
center()
字符窜的劈分
split()
字符窜判断
isdecimal()
字符窜的替换
replace()
字符窜的合并
join()
字符窜的比较
>,<,>=,<=,==,!=
字符窜编码
%,format()
第六章
函数：
函数的定义与调用
函数使用def 定义
函数定义的形参
* 定义个数可变的位置形参
** 定义个数可变的关键字形参
定义默认值参数
函数调用的实参
位置实参
关键字实参
函数可以多返回值
变量的作用域
局部变量
全局变量
递归函数
函数本身调用本身
递归的组成部分
调用条件
终止条件
重要知识点示例：
1)个数可变的位置参数
结果为一个元祖
def fun(*args):
print(args)
fun(1,2)
fun(1,2,3,4,5)
结果：
(1, 2)
(1,2,3,4,5)
2）个数可变的关键字形参
结果为一个字典
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=10,b=20,c=30)
结果：
{'a': 10}
{'a': 10, 'b': 20, 'c': 30}
3）在一个函数定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前。
def fun1(*args1,**args2):
print(args1,args2)
fun1(1,2,3,a=10,b=20,c=30)
(1, 2, 3) {'a': 10, 'b': 20, 'c': 30}
4）函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
def func5():
global age
age=20
print(age)
func5()
print(age)
第七章
Bug常见类型
粗心导致的语法错误
自查宝典
知识点不熟悉
连练练
思路不清
print()语句
使用 # 注释
被动掉坑
try...except
异常处理机制
try...except
try...except...except
try...except...else
try...except...else...finally
traceback模块打印异常信息
1）try except 处理示例：
try:
a = int(input('请输入第一个整数')) #可能出现异常的代码
b = int(input('请输入第二个整数'))
result = a / b
except BaseException as e: #将异常起了一个别名为 e
print('出错了',e)
else: #else 与 except 二者执行其中一个，如果遇到异常则执行异常，如果是正常就执行else内容
print('计算结果为:',result)
finally: #无论是否异常，总会被执行的代码
print('感谢使用')
请输入第一个整数:a
出错了 invalid literal for int() with base 10: 'a'
感谢使用
第二种情况，输入正常,则执行else 内容
请输入第一个整数:10
请输入第二个整数:2
计算结果为: 5.0
感谢使用
第八章
编程思想
面向过程:具体
面向对象:宏观
类对象
类属性
类方法
实例方法
静态方法
实例对象
类名()，创建实例对象c
动态绑定属性
动态绑定方法
类对象拥有：
类
id
type
valuve
1）
类的组成
类属性：直接写在类里面方法之外的变量，称为类属性，访问类属性，print(Student.native_place)
实例方法：在类之外定义的称为函数，在类之内定义的称为方法 ,必须创建类的对象才能调用该方法，stu1=Student('张三',20) stu1.eat() 即对象名.eat()调用
类方法:@classmethod ,使用类名直接访问的方法, print(Student.cm())
静态方法:@staticmethod,使用类名直接访问的方法，print(Student.sm())
注意：
一个Student 类可以创建N多个Student类的实例对象，每个实体对象的属性值不同（即实例属性不同）
示例：
class Student: #Student 为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
native_pace='邯郸' #直接写在类里面的变量，称为类属性
def __init__(self,name,age): #初始化方法
self.name=name #self.name 称为实例属性，进行了一个赋值的操作，将局部变量的name 的值赋给实例属性
self.age=age
#实例方法，在类之内定义的称为方法必须有self
def eat(self):
print('学生在吃饭')
#静态方法
@staticmethod
def method():
print('我使用了staticmethod 进行修饰，所以我是静态方法')
#类方法,必须有 cls
@classmethod
def cm(cls):
print('我是类方法，因为我使用了 classmethod 进行修饰')
#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
print('喝水')
#创建Student 类的对象，即类的对象的创建又称为类的实例化
stu1=Student('张三',20)
stu1.eat()
#调用实例属性
print(stu1.age)
print(stu1.name)
print('xxxxxxxxxxxxxxxxxxxxxx')
Student.eat(stu1) #stu1.eat() 与Student.eat(stu1) 功能相同，都是调用Student 中的eat 方法;
#类名.方法名(类的对象) --> 类的对象实际上就是方法定义处的 self
#
即类的对象的创建又称为类的实例化
2）动态绑定实例属性，必须在创建实例对象之后进行绑定
stu5=Student('倩倩',18)
stu6=Student('果果',19)
stu6.gender='女'
print(stu5.name,stu5.age)
print(stu6.name,stu6.age,stu6.gender)
3）动态绑定实例方法，必须在创建实例对象之后进行绑定，当绑定在实例对象之后就叫做方法了
def show():
print('定义在类之外的，称为函数')
stu5.show=show
stu5.show()
第九章
面向对象的三大特征
封装
继承
多继承
方法重写
多态
动态语言
关注对象的行为
静态语言
继承
方法重写
父类引用指向子类对象
object
所有类的父类
__new__()创建对象
__init__()初始化对象
__str__()对象的描述
1.封装
2.继承
3.方法重写
4.object 类
5.多态
6.特殊方法和特殊属性
1）封装
将实例属性和实例方法包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用
class Car:
def __init__(self,brand):
self.brand=brand
def Start(self):
print(self.brand,'is start')
car=Car('宋Pro')
car.Start()
print(car.brand)
结果：
宋Pro is start
宋Pro
#不希望在外部被直接调用实例属性
class Student:
def __init__(self,name,age):
self.name=name
self.__age=age
def show(self):
print(self.name,self.__age)
stu1=Student('李明',20)
stu1.show()
print('----------------------------------------------')
print(stu1.name)
# print(dir(stu1))
print(stu1._Student__age) #可以在外部直接调用变量
# print(stu1.__age)
李明 20
----------------------------------------------
李明
20
1.1)封装-私有属性与私有方法，不希望外部直接调用使用，而是用于内部调用使用
class Phone(object):
__current_voltage = 0
def __keep_single_core(self):
print("让CPU 以单核模式运行")
def call_by_5g(self):
if self.__current_voltage >= 1:
print("5g通话已开启")
else:
self.__keep_single_core()
print("电量不足，开启单核模式运行了")
phone = Phone()
phone.call_by_5g()
#输出结果
让CPU 以单核模式运行
电量不足，开启单核模式运行了
2）继承与多继承
默认继承 object类
class Person(object): #Person 继承object 类，不写默认是object
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Person): #继承Person类
def __init__(self,name,age,stu_nomber): #自身初始化函数，其中name，age必须与父类相同，stu_nomber 是自身独有的属性
super().__init__(name,age) #继承父类 Person
self.stu_nomber=stu_nomber
class Teacher(Person):
def __init__(self,name,age,teachofyer):
super().__init__(name,age)
self.teachofyer=teachofyer
stu1=Student('zhangsan',21,10001)
teacher1=Teacher('lisi',32,13)
stu1.info()
teacher1.info()
结果：
zhangsan 21
lisi 32
3）方法重写
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)进行重新编写
子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法，例如super().info()
def info(self): #info 方法重写
super().info() #调用父类方法
print(self.teachofyer)
示例如下：
class Person(object): #Person 继承object 类，不写默认是object
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Person): #继承Person类
def __init__(self,name,age,stu_nomber): #自身初始化函数，其中name，age必须与父类相同，stu_nomber 是自身独有的属性
super().__init__(name,age) #继承父类 Person
self.stu_nomber=stu_nomber
def info(self): #info 方法重写
super().info() #调用父类方法
print(self.stu_nomber)
class Teacher(Person):
def __init__(self,name,age,teachofyer):
super().__init__(name,age)
self.teachofyer=teachofyer
def info(self): #info 方法重写
super().info() #调用父类方法
print(self.teachofyer)
stu1=Student('zhangsan',21,10001)
teacher1=Teacher('lisi',32,13)
stu1.info()
print('---------------------------------')
teacher1.info()
结果：
zhangsan 21
10001
---------------------------------
lisi 32
13
#方法重写示例2：
class Car(object): #定义的类名，默认继承object 类
def __init__(self,type,number): #类初始化方法，包含self.自身的属性
self.type=type #类实例属性
self.number=number
def start(self): #类方法
print('我是父类---Start----------------')
def stop(self): #类方法
print('我是父类---Stop---------------')
class TaxiCar(Car): #继承Car 类
def __init__(self,type,number,company): #类实例的初始化方法，新增加 company 属性
super().__init__(type,number) #调用父类方法，就是免去了前面两个类实例属性的赋值
self.company=company #新类实例的属性赋值
def start(self): #类方法进行重写
super().start() #类方法调用父类，先输出父类内容
print('我是%s的，我的车牌号码是 %s,您要去哪里?' %(self.company,self.number)) #方法重写内容
def stop(self): #类方法进行重写
print('目的地到了，请您付费下车，欢迎再次乘坐') #直接重写，不调用父类
if __name__ == '__main__':
taxicar=TaxiCar('上汽大众','京A88888','长城出租车公司') #给类传参
taxicar.start()
taxicar.stop()
输出内容：
我是父类---Start----------------
我是长城出租车公司的，我的车牌号码是 京A88888,您要去哪里?
目的地到了，请您付费下车，欢迎再次乘坐
第十章
模块与包
模块
避免函数名/变量名重名
自定义模块
一个.py文件称为一个模块
第三方模块
安装:pip install 模块名
使用:from ..import 模块名
包
避免模块名重名
包含__init__.py 文件
第十一章
编码格式
内存为unicode
.py文件为utf-8
文件操作
写
writelines()
write()
读
read()
readline()
readlines()
打开模式
只读r
只写w
追加a
二进制是b
目录操作
os模块
os.path
读写模式
1)文件读 r，文件指针在文件的开头
file=open('a.txt','r',encoding='utf-8')
print(file.readlines()) #readlines 输出是列表
file.close()
结果:
['中国\n', '美丽']
2)文件写 w 以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头
file=open('b.txt','w',encoding='utf-8')
file.write('Python22')
file.close()
3）文件追加 a ，以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在文件末尾
file=open('b.txt','a',encoding='utf-8')
file.write('Python33')
file.close()
b.txt 结果：
Python22Python33Python33
4)以二进制方式打开文件，不能单独使用，需要与其他模式一起使用，rb，或者 wb
src_file=open('liang.jpg','rb')
target_file=open('copyliang.jpg','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
5）以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+
文件对象的常用方法
1)read([size]) 从文件中读取size 个字节或字符的内容返回，若省略[size]，则读取到文件末尾，即一次读取文件所有内容
file=open('a.txt','r',encoding='utf-8')
print(file.read())
file.close()
结果：
中国
美丽
file=open('a.txt','r',encoding='utf-8')
print(file.read(2))
file.close()
结果：
中国
2）readline()，从文本文件中读取一行内容
file=open('a.txt','r',encoding='utf-8')
print(file.readline())
file.close()
结果：
中国
3）readlines()，把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
file=open('a.txt','r',encoding='utf-8')
print(file.readlines())
file.close()
结果：
['中国\n', '美丽']
4）write(str) 将字符串str 内容写入文件
file=open('c.txt','a',encoding='utf-8')
file.write('hello')
file.close()
c.txt 结果：
hello
5）writelines(s_list) 将字符串列表 s_list 写入文本文件，不添加换行符
file=open('c.txt','a',encoding='utf-8')
lst=['a','b','c']
file.writelines(lst)
file.close()
c.txt 结果：
helloabc
6)seek(offset[,whence]) 把文件指针移动到新的位置，offset 表示相对于whence 的位置：
offset:为正往结束方向移动，为负往开始方向移动
whence 不同的值代表不同含义：
0：从文件头开始计算（默认值）
1：从当前位置开始计算
2：从文件末尾开始计算
注释：一个中文两个字节
a.txt内容:
pythongojava
file=open('a.txt','r',encoding='utf-8')
file.seek(2)
print(file.read())
print(file.tell())
file.close()
结果：
thongojava
12
7)tell() 返回文件指针的当前位置
print(file.tell())
8）flush()把缓冲区的内容写入文件，但不关闭文件
9）close() 把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
file=open('d.txt','a',encoding='utf-8')
file.write('hello')
file.flush()
file.write('world')
file.close()
d.txt结果：
helloworld
如果将flush与 close 调换位置，则报错：
file=open('e.txt','a',encoding='utf-8')
file.write('hello')
file.close()
file.write('world')
file.flush()
报错：
ValueError: I/O operation on closed file.
with 语句(上下文管理器)
- with 语句可以自动管理上下文资源，不论什么原因跳出with 块，都能确保文件正确的关闭，一次来打到释放资源的目的
with open('liang.jpg','rb') as src_file:
with open('liangliang.jpg','wb') as target_file:
target_file.write(src_file.read())
旧代码：
src_file=open('liang.jpg','rb')
target_file=open('copyliang.jpg','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()
OS 模块操作目录相关函数
os.system('calc.exe') 调用系统计算机
getcmd() 返回当前的工作目录
listdir(path) 返回指定路径下的文件和目录信息 print(os.listdir('../0330'))
mkdir(path,[,mode]) 创建目录 os.mkdir('aaa')
makedirs(path1/path2/...[,mode])创建多级目录 os.makedirs('A/b/C')
rmdir(path)删除目录 os.rmdir('aaa')
removedirs(path1/path2.....) 删除多级目录 os.removedirs('A/b/C')
chdir(path) 将path 设置为当前工作目录
OS.path 模块操作目录相关函数
obspath(path) 用于获取文件或目录的绝对路径
exists(path) 用于判断文件或目录是否存在，如果存在返回True，否则返回False
join(path,name) 将目录与目录或者文件名拼接起来
splitext() 分离文件名和扩展名
basename(path) 从一个目录中提取文件名
dirname(path) 从一个路径中提取文件路径，不包括文件名
isdir(path) 用于判断是否为路径
import os.path
print(os.path.abspath('demon10.py'))
print(os.path.exists('demon04.py'),os.path.exists('demon044.py'))
print(os.path.join('E:\\Python','demon10.py'))
print(os.path.split('E:\\Django\\python\\a.py'))
print(os.path.splitext('demon10.py'))
print(os.path.basename('E:\\Django\\python\\a.py'))
print(os.path.dirname('E:\\Django\\python\\a.py'))
示例：
1.#获取指定目录下的所有 py 文件
import os
path=os.getcwd()
lst=os.listdir(path)
for file in lst:
if file.endswith('.py'): #获取以 .py 结尾的文件
print(file)
2.循环遍历嵌套目录下所有文件
import os
path=os.getcwd()
lst_files=os.walk(path)
for mydirpath,mydirname,myfilename in lst_files:
# print(mydirpath)
# print(mydirname)
# print(myfilename)
# for dir in mydirname:
# print(os.path.join(mydirpath,dir))
for file in myfilename:
print(os.path.join(mydirpath,file))
print('------------------------------------')
日常问题处理
重点关注：
一、列表、字符串、文本文件存入修改操作
1) 列表中存放字典，列表可以直接append 添加字典内容，student_list列表中的每一项都是字典
student_list=[]
student={'id':id,'name':name,'english':english,'python':python,'java':java}
student_list.append(student)
结果如下：[{'id': '1010', 'name': 'jh', 'english': 21, 'python': 21, 'java': 23}, {'id': '1011', 'name': 'jk', 'english': 23, 'python': 43, 'java': 223}]
2) 文本txt 文件存放列表中的字典内容，需要先将列表中的每一个字典转换为字符串存放，否则会报错： TypeError: write() argument must be str, not dict，如下：
stu_txt=open(filename,'a',encoding='utf-8')
for item in student_list:
stu_txt.write(str(item)+'\n')
stu_txt.close()
3) 删除文本中的某一行，student_old 列表中的每一项字典都是字符串类型，操作需要将字符串类型转化为字典
student_id=input('请输入要删除的学生id:')
with open(filename,'r',encoding='utf-8') as file:
student_old=file.readlines()
student_old 列表内容如下，可以查看到文本里面存放的是字符串类型
["{'id': '1003', 'name': 'kubn', 'english': 123, 'python': 45, 'java': 67}\n", "{'id': '1004', 'name': 'bhs', 'english': 3, 'python': 4, 'java': 6}\n"]
d={}
with open(filename,'w',encoding='utf-8') as wfile:
for item in student_old:
d=dict(eval(item)) #将字符串转换为字典
if d['id']!=student_id:
wfile.write(str(d)+'\n') #存放时候再将字典转换为字符串进行存放
二、格式化输出
#定义标题显示格式
format_title='{:^6}\t{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^8}\t'
print(format_title.format('ID','姓名','英语成绩','Python 成绩','Java成绩','总成绩'))
#定义内容的显示格式
format_data='{:^6}\t{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^8}\t'
for item in student_new:
print(format_data.format(item.get('id'),
item.get('name'),
item.get('english'),
item.get('python'),
item.get('java'),
item.get('总成绩')
))
输出结果：
ID 姓名 英语成绩 Python 成绩 Java成绩 总成绩
101 xin 21 22 23 66
三、匿名函数用作数据排序展示，（reverse=True 降序，reverse=False 升序）
student_new=[{'id': '103', 'name': 'ki', 'english': 11, 'python': 11, 'java': 11, '总成绩': 33}, {'id': '101', 'name': 'xin', 'english': 21, 'python': 22, 'java': 23, '总成绩': 66}]
student_new.sort(key=lambda x: int(x['java']), reverse=True)
