python 知识点总结

第一张

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)