【Python】学习笔记总结（Python基础——第一阶段（1-6）——汇总篇）

一、Python基础

1.注释

注释	代码
单行注释	#内容
多行注释	'''内容'''

• python2需要指定python解析器的路径，指定编码格式

#!/usr/bin/python3 
#-- coding=utf-8 --

2.输入输出

输入输出	代码
普通输入	content = input('请输入内容')——默认为str类型
普通输出	print('内容')
格式化输出1	print('姓名:%s:\n 年龄:%d'%(name,age))
格式化输出2	print('姓名:{} \n 年龄:{}'.format(name,age))

• 常用的格式化符号

格式符号	转换
%c	字符
%s	通过str()字符串转换来格式化
%i	有符号十进制整数
%d	有符号十进制整数
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母）
%e	索引符号（小写’e‘）
%E	索引符号（大写’E‘）
%f	浮点实数
%g	%f和%e的简写
%G	%f和%E的简写

3.数据类型

• type()方法可查看其类型

数据类型	代码
int	a = 10
float	a = 10.5
complex	a = 10j
bool	a = true
str	a = '内容'
dict	dict = {"name":王一,"age":20}
Tuple	tupleA = (1,2,5,'王一')
list	listA = [1,2,5,'王一']

4.运算符

4.1.算数运算符

算数运算符	代码
+	sum = a+b
-	sum = a-b
*	sum = a*b
/	sum = a/b
**	sum = a**2
%	sum = a%2
//	sum = a//2

4.2.比较运算符

比较运算符	代码
==	a == b
!=	a != b
>	a > b
<	a < b
>=	a >= b
<=	a <= b

4.3.逻辑运算符

逻辑运算符	代码
and	a == 10 and b == 10
or	a == 10 or b == 10
not	not a == 10

4.3.1.短路运算

简单的说：
表达式用and的则将容易为False的条件放到前面，
表达式有or的则将容易为True的条件放到前面

详细介绍大家可百度查看

4.4.赋值运算符

赋值运算符	代码
=	a = b
+=	a += b
-=	a -= b
*=	a *= b
/=	a /= b
%=	a %= 2
**=	a **= 2
//=	a //= 2

5. 判断与循环语句

5. 1.If-else

num =int(input("输入一个数字："))
if num>2:    
    if num>3:    
    	print('数大于3')
	else:    
    	print('数大于2且小于等于3')       
elif num<2:    
    print('数小于2')
else:    
    print('数等于2')        

5. 2.While

i = 9
while i >= 1:
    j = 1    
    while j <= i:
        print('%d*%d=%2d\t'%(j,i,i*j),end='')     
        j +=1    
    i -= 1    
    print() 

5. 3.for

 for i in range(0,10) :
     for j in range(0,i+1) :
         print('%d * %d = %d'%(i,j,i*j), end=' ')
     print()

5. 4.break

import random
win = 0
while True:    
    if win >= 3:        
        print('你已经胜利三次')        
        break    
    else: # 胜利小于三次，继续玩        
        inp = int(input('请出拳：'))        
        computer = random.randint(0,2)        
        print('电脑出拳：%d'%computer)        
        if inp >2:            
            print('输入错误')        
        elif (inp ==0  and computer==2) or \
        (inp == 1 and    computer==0)\
        or (inp == 2 and computer==1 ):            
            print("厉害了，居然赢了")            
            win += 1  # 如果胜利一次，胜利次数加1        
        elif inp == computer: # 如果两个人出异样就打平            
            print('不错，居然打平了')        
        else:print('呵呵，输了吧') 

5. 5.continue

a = 'python'
for i in a:
    if i == 'h'#当循环到h的时候，退出当前循环不打印 
        continue
    print(i)

6. 高级数据类型

• 公有方法

公有方法	作用	代码
+	两个对象相加操作，会合并两个对象	-
*	对象自身按指定次数进行 + 操作	-
in	判断指定元素是否存在于对象中	-

6. 1.字符串

strA = 'abc123'

常用方法	作用	代码
[起始下标：结束下标：步长]	字符串切片	strA[2:4]
capitalize()	首字母变大写	-
isalnum()	判断是否是字母和数字	-
islower()	判断是否是小写	-
swapcase()	大写变小写，小写变大写	-
title()	把每个单词的首字母变成大写	-
endswith/startswith()	是否 x结束/开始	-
isalpha()	判断是否是字母	-
join()	循环取出所有值用xx去连接	-
lstrip/rstrip/strip	移除左/右/两侧空白	-
replace(old, new, count=None)	old被换字符串，new替换字符串，count换多少个。无count表示全部替换	-
find()	检测x是否在字符串中	-
isdigit()	判断是否是数字	'abc123’.isdigit()
lower/upper	大小写转换	-
split()	切割字符串	-
count()	统计出现的次数	-

6. 2.列表

listA = ['a','b','c',1,2,3]

常用方法	作用	代码
[起始下标：结束下标：步长]	字符串切片	listA[2:4]
append()	在列表后面追加元素	-
count()	统计元素出现的次数	-
extend()	扩展，相当于批量添加	-
index()	获取指定元素索引号	-
insert()	在指定位置插入	-
pop()	删除最后一个元素	-
remove()	移除左边找到的第一个元素	-
reverse()	反转列表	-
sort()	列表排序(reverse=True 倒序)	-

6. 3.字典

scores= [('英语', 58), ('政治', 79)]

常用方法	作用	代码
scores[‘语文’]	通过key访问value	scores['celery']
scores[‘数学’] = 93	修改/增加key-value对	scores['数学'] = 93
del	删除key-value 对	del scores['数学']
in	判断是否包换键	'数学' in scores
len()	查看字典中有几个键值对	-
keys	返回包含字典所有key值	-
values	返回一个包含所有value值	-
items	返回一个包含所有（键，值）元祖的列表	-
pop(‘键’)	删除指定键	-

6. 4.元组

tupleA = ('a','b','c',1,2,3)#元组元素不可修改

常用方法	作用	代码
[起始下标：结束下标：步长]	字符串切片	listA[2:4]
index()	获取指定元素索引号	-
count()	统计元素出现的次数	-

7. 函数

7.1.参数

• 参数：必选参数、默认参数[缺省参数]、可选参数、关键字参数

7.1.1.必选参数

def Sum(a,b) :
        '''
        打印函数
        :return:
        '''
        sum1 = a+ b;
        print(sum1)

7.1.2.默认参数

def Sum(a=0,b=1) :
        '''
        打印函数
        :return:
        '''
        sum1 = a+ b
        print(sum1)

7.1.3.可选参数：元组类型，参数个数不确定

def Sum(*args):
    '''
    计算累加和
    :param args: 可变长参数类型
    :return:
    '''
    sum1 = 0
    for item in args :
        sum1 += item
    print(sum1)

7.1.4.关键字参数：字典类型，key为字符串

def keyFunc(**kwargs):
    '''
    计算累加和
    :param args: 可变长参数类型
    :return:
    '''

    print(kwargs)

dictA = {'1':2,'2':4}

keyFunc(**dictA)
keyFunc(name='2',age='3')

7.2.返回值

def Sum(a,b) :
        '''
        相加
        :return:和
        '''
        sum1 = a+ b
        return sum1

7.3.局部变量与全局变量

• 注意：函数内修改全局变量需要加关键字global

mark = '1234'
print(mark)
def changeInfo() :
    global mark
    mark = '5678'
    pass

changeInfo()
print(mark)

7.4.函数参数引用传值

python中，万物皆对象，在函数调用时，实参传递的就是对象的引用。
不可变类型（Number（数字）、String（字符串）、Tuple（元组））修改时，修改的是存储实际数据的引用，对原数据无影响
但可变类型（Set（集合）、List（列表）、Dictionary（字典））修改时，修改的是同一地址下的数据，对原数据有影响。
可以使用id()获取数据地址

7.5.匿名函数（lambda表达式）

m = lambda x,y:x+y#相加
print(m(1,2))

age = 15
print( 'ok' if age>18 else 'no' )#判断

m = lambda x,y : x if x>y else y#判断
print(m(1,2))

m = (lambda x,y : x if x>y else y)(1,2)#直接调用
print(m)

7.6.递归函数

def jiecheng(n) :

    if n==1 :
        return 1
    else:
        return n*jiecheng(n-1)

print(jiecheng(5))

7.6.1.文件查找

import  os

def findFile(file_Path) :
    listRs = os.listdir(file_Path) #获得路径下所有文件夹

    for item in listRs :

        full_path = os.path.join(file_Path,item)#组合完整文件路径
        if os.path.isdir(full_path) :#判断是否是文件夹
            findFile(full_path) #继续递归遍历
        else :
            print(item+'----------------------')
    else:
        return

findFile('E:\\umengok')

8. 内置函数

8.1.数学函数

函数	作用
abs()	绝对值
round()	四舍五入，近似值
pow()	幂运算
divmod()	返回一个包含商和余数的元组
max()	最大值
min()	最小值
sum()	求和
eval()	用来执行一个字符串表达式，并返回表达式的值（动态执行的函数）

8.2.类型转换函数

函数	作用
int()	转化为int类型
float()	转化为float类型
str()	转化为str类型
ord()	字符转数字（ASCII）
chr()	数字转字符（ASCII）
bool()	转化为bool类型
bin()	十进制转化为二进制
hex()	十进制转化为十六进制
oct()	十进制转化为八进制
list()	元组转化为列表类型
tuple()	列表转化为元组类型
dict()	创建字典
bytes()	转化为字节数组

8.3.序列操作函数

函数	作用
all()	判断可迭代对象元素是否全部都为True（除了0，空，False都是）
any()	判断可迭代对象元素是否全部为False（0，空，False都是）
sorted()	对可迭代对象进行排序（返回新的list）（reverse参数：升序降序）
reverse()	反转列表中元素
range()	创建一个整数列表
zip()	将可迭代对象打包压缩为元组，返回元组列表（打包序列对应索引存储为一个元组，按照最少的元素那个进行压缩）
enumerate()	可遍历的数据对象组合为一个索引序列

8.4.集合Set

无序、不重复的数据结构不支持索引和切片（类似于一个只有key的字典），作用去重

set1 = {1,2,3,4}

常用方法	作用	代码
add()	添加元素	-
clear()	清空集合	-
difference()	两个集合的差集(set1-set2)	-
intersection()	两个集合的交集（set1&set2）	-
union()	两个集合的并集（set1|set2）	-
pop()	移除数据删除	-
discard()	移除指定数据删除	-
update()	把set2更新到set1中	-

二、Python面向对象

1.类（Class）

1.1.定义类

class Person :
    name = '小明'#类属性
    age = '20'#类属性
    def eat(self):
        print('吃饭')
        pass
    pass

• 使用

xiaoming =  Person()

1.2.类属性

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

name = '小明'#类属性

1.3.实例属性

1.3.1.内部添加

在方法的内部，使用self引用的属性

    def __init__(self):
        self.friend = '小红'

1.3.2.外部添加

class People :
    def eat(self):
        print(self)
        pass
    pass

xiaoming = People()
xiaoming.name = '小明'
xiaoming.age = 20
print(xiaoming.name)

1.4.实例方法

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

def eat(self):
        print('吃饭')
        pass
    pass

1.5.类方法

类对象所拥有的方法，用装饰器@classmethod来标
识其为类方法，对于类方法，第一个参数必须是类对象，
一般以cls作为第- -个参数，
类方法可以通过类对象，实例对象调用

类方法可以访问、修改类属性

	name = '小明'
    @classmethod
    def findNameInfo(cls):
        return cls.name
        pass

1.6.静态方法

静态方法不需要传参例如（cls/self）
静态方法不可以访问类属性
通常用类直接访问静态方法，本身和类与实例无关

import time
class Test :
    def __init__(self,hour,min,second):
        self.hour = hour
        self.min = min
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S" ,time.localtime())
    pass
pass

print(Test(1,2,3).showTime())

1.7.__init__方法（初始化）

*类似于构造函数，对self的属性进行构造
自动执行的初始化方法,自带的内置函数

class People :
    def __init__(self,name,age):
        self.name = name
        self.age = age
        pass
    def showInfo(self):
        print(self.name+'年龄'+self.age)
        pass
    pass

xiaoming = People('小明',20)

1.8.Self(当前对象的引用)

实例化后，python解释器会把当前对象自动传递给self

1.9.魔术方法

• __str__
  打印时调用的方法

class People :
    def __init__(self,name,age):
        self.name = name
        self.age = age
        pass
    def __str__(self):
        return  '姓名：%s 年龄：%d'%(self.name,self.age)
        pass
    pass

xiaoming = People('小明',20)
print(xiaoming)

• __new__
  创建对象实例的方法，调用一次就会生成新的对象cls（class）cls自动提供
  真正创建实例的方法，经常单例模式使用，必须返回实例

class People :
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__')
        pass
    def __new__(cls, *args, **kwargs):
        print('__new__')
        return object.__new__(cls)
        pass
    pass

xiaoming = People('小明',20)

• 区别__new __和__init__

• __new __类的实例化方法必须要返回该实例否则对象就创建不成功
• __init__用来做数据属性的初始化工作也可以认为是实例的构造方法接受类的实例self并对其进行构造
• __new __至少有一个参数是cls代表要实例化的类，此参数在实例化时由python解释器自动提供
• __new __函数执行要是于__init__函数

1.9.1.魔术方法介绍大全

魔术方法介绍大全

2.方法、继承、多态

2.1.析构方法__del__

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__ ()方
法，也称为析构方法

2.1.1.释放对象时调用

class People :
    def __init__(self,name,hp):
        self.name = name
        self.hp = hp
        pass
    def __del__(self):
        print('销毁了')
        pass

    pass

xiaohong = People('xiaohong',100)

2.1.2.手动清空对象

del xiaohong

2.2.继承

2.2.1.单继承

class Animal :
    def eat(self):
        print('吃')
        pass
    pass

class Dog(Animal) :
    def wwj(self):
        print('汪汪叫')
        pass
    pass

2.2.2.多继承

class Animal :
    def eat(self):
        print('吃')
        pass
    pass

class God:
    def fly(self):
        print('飞')
        pass
    pass

class Wukong(Animal,God):
    def Dayaoguai(self):
        print('打妖怪')
        pass
    pass

• 多继承，同名方法查找父类，如没有则向父类的父类查找（广度优先）
• __mro__方法解析顺序，用来了解继承顺序

2.2.3.重写父类方法

class Animal :
    def eat(self):
        print('吃')
        pass
    pass

class Dog(Animal) :
    def eat(self):
        print('大口吃')
        pass
    pass

2.2.4.重写__init__方法

class People :
    def __init__(self,name,hp):
        self.name = name
        self.hp = hp
        print('调用People__init__')
        pass
    pass

class Man(People):
    def __init__(self,name,hp):
        People.__init__(self,name,hp)#调用父类方法1
        #super().__init__(name,hp)#调用父类方法2,可在父类逐个查找
        print('调用Man__init__')
        pass

    pass

man = Man('xxx',100)

2.2.4多态

继承并扩展父类代码，不需要修改父类代码

class Animal :
    def eat(self):
        print('吃')
        pass
    pass

class Dog(Animal) :
    def eat(self):
        print('大口吃')
        pass
    pass

class Cat(Animal) :
    def eat(self):
        print('小口吃')
        pass
    pass


def commonInvoke(obj) :
    obj.eat()

    listObj = [Animal(),Cat(),Dog()]

    for item in listObj :
        commonInvoke(item)

2.3类属性和实例属性区别

实例对象不可以修改类属性，类属性所有权归类所有

2.4类方法和实例方法和静态方法

1.类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法
2.实例方法的第一个参数是实例对象self,通过self引用的可能是类属性、也有可能是实例属
性(这个需要具防分析)，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先
级更高。
3.静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引
用。

3.封装与单例

3.1.封装

• 属性私有化，无法外部访问，不能被继承，只能内部类使用

class Person :
	__age = 20 #类属性私有化
    def __init__(self):
        self.__name = '小明'#实例属性私有化
        pass
    pass

• 方法私有化，无法外部访问，不能被继承，只能内部类使用

class Person :
    def __run(self): #实例方法私有化
        print('跑')
        pass
    pass

• 下划线类型

下划线	说明
_xxx	protected类型（只允许本身和子类访问）
__xxx	private类型（只允许本身访问）
__xxx__	魔术方法，Python内置方法
xxx_	避免属性名与python关键字冲突

• property（属性函数）

• 类属性的方式实现

class Person :
    def __init__(self):
        self.__name = '小明'
        pass
    def get_name(self):
        return self.__name
    def set_name(self,name):
        if name < 0:
            print('no')
        else :
            self.__name = name
            pass

    name = property(get_name, set_name)
pass
person = Person()
print(person.name)#访问类属性name

• 装饰器方式实现

class Person :
    def __init__(self):
        self.__name = '小明'
        pass
    @property #添加装饰器 添加属性标志
    def name(self):
        return self.__name
    @name.setter #提供一个setter方法
    def name(self,name):
        if name == '小明':
            print('no')
        else :
            self.__name = name
            pass
pass
person = Person()
person.name = '小红'
print(person.name)#访问类属性name

• __new__实例化方法

class Person :
    def __init__(self):
        self.__name = '小明'
        pass
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls, *args, **kwargs)
        pass
    pass

3.2.单例模式

不能使用自身new方法，会产生深度递归

class Person :
    __instance = None
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance') :
            cls.__instance = super().__new__(cls, *args, **kwargs)
        return cls.__instance
        pass
    pass

3.3.异常处理

try
  #可能出现错误的代码块
except:
 #出错之后执行的代码块
else:
 #没有出错的代码块
finally:
 #不管出没出错都会执行的代码块

根据错误类型来捕获的（NameError 、IndexError …）
自上而下依次判断

try :
    print(b)
    li = [1,2,3,4]
    print(li[100])
except NameError as msg:
    print('出错')
    print(msg)
except IndexError as msg:
    print('出错')
    print(msg)
except Exception as msg:#所有异常
    print('出错')
    print(msg)

3.3.1.异常类型

当前函数没找到，则向上层一层层传递查找

异常	导致的错误
AssertionError	当assert语句失败时引发。
AttributeError	当 属性分配或引用失败时引发。
EOFError	当input()函数达到文件结束条件时引发。
FloatingPointError	当浮 点运算失败时引发。
GeneratorExit	调用 生成器的close()方法时引发。
ImportError	找不到导入的模块时引发。
IndexError	当序 列的索引超出范围时引发。
KeyError	在字典中找不到键时引发。
KeyboardInterrupt	当用户 按下中断键(Ctrl+c或delete)时引发。
MemoryError	当操作耗尽内存时引发。
NameError	在局部或全局范围内找不到变量时引发。
NotImplementedError	由抽象方法提出。
OSError	当系统操作导致系统相关错误时引发。
Overf lowError	当算术运算的结果太大而无法表示时引发。
ReferenceError	使用弱引用代理访问垃圾收集的引用时引发。
Runt imeError	当错误不属于任何其他类别时引发。
StopIteration	函数引发，以指示迭代器不再返回任何项。
SyntaxError	遇到语法错误时由解析器引发。
Indentat ionError	当缩进不正确时引发。
TabError	当缩进由不一致的制表符和空格组成时引发。
SystemError	当解释器检测到内部错误时引发。
Sys temExit	由sys. exit()函数引发。
TypeError	将函数或操作应用于类型不正确的对象时引发。
UnboundLocalError	当在函数或方法中引用局部变量，但没有将值绑定到该变量时引发。
UnicodeError	当 发生与unicode相关的编码或解码错误时引发。
UnicodeEncodeError	当编码过程中发生与unicode相关的错误时引发。
UnicodeDecodeError	当解码过程中出现与unicode相关的错误时引发。
UnicodeTrans lateError	翻译过程中发生与unicode相关的错误时引发。
ValueError	当函数得到类型正确但值不正确的参数时引发。
ZeroDivisionError	当除法或模运算的第二个操作数为零时引发。

3.3.2.自定义异常类型

class LenException(Exception):

    def __init__(self,leng):

        self.len = leng
        pass

    def __str__(self):
        return '长度超了'
        pass

def name_Test():

    try :
        name = '1111111111'
        if len(name)>5:
            raise LenException(len(name))
        else:
            print(name)
            pass
        pass
    except LenException as msg:
        print(msg)
pass


name_Test()

3.4.动态添加属性和方法

• 动态添加属性

class Student :
    def __init__(self,name):
        self.name = name
        pass
    def __str__(self):
        return '姓名:%s' %(self.name)
student = Student('小明')
student.age = 20 # 动态添加实例属性
Student.age = 20 # 动态添加类属性
print(student)
print(student.age)

• 动态添加实例方法

import types #添加方法的库

def runA(self):
    print(self.name)
    pass

class Student :
    def __init__(self):
        self.name = '小明'
        pass
    pass
stu = Student()
stu.run = types.MethodType(runA , stu)#动态添加实例方法
stu.run()#调用

• 动态添加类方法

@classmethod
def runA(self):
    print(self.name)
    pass

class Student :
    name = '小明'
    pass
Student.run = runA#动态添加实例方法
Student.run()#调用

• 动态添加静态方法

@staticmethod
def runA():
    print('55555')
    pass

class Student :
    name = '小明'
    pass
Student.run = runA#动态添加实例方法
Student.run()#调用

• __slots__属性
  来限制该class能添加的属性。
  子类不会继承，只有在当前类中有效。
  子类声明__slots__属性才会继承
• 限制添加的属性

class Student(object) :
    __slots__ = ('name','age') # 限制添加的属性，避免存储多余的数据
    def __str__(self):
        return '{},{}' .format(self.name,self.age)
        pass
    pass

stu = Student()
stu.name = '1'
stu.age = 20
stu.high = 20 # 添加不了报错了
print(stu)
print(stu.__dict__)#所有可以用的属性都在这里，占空间大
print(stu.__slots__ )#存储限制添加的属性，避免存储多余的数据

• __call__属性

class Student(object) :
    def __call__(self, *args, **kwargs):
        print('1111')
    pass

stu = Student()
stu()

三、Python文件操作

1.打开open('文件名','打开模式')

fileA = open('./Test.txt','w',encoding='utf-8')

• 打开模式

打开模式	模式说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。 如果该文件已存在则将其覆盖。如果该文件不存在， 创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开-一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开-一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开-一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开-一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开-一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2.写操作

• 字符串形式，默认gbk编码

fileA = open('./Test.txt','w',encoding='utf-8')
fileA.write('写入的内容')
fileA.close()

• 二进制形式写入

fileA = open('./Test2.txt','wb')
fileA.write('写入的内容'.encode('utf-8'))
fileA.close()

• 追加写入a

fileA = open('./Test.txt','a')
fileA.write('写入的内容')
fileA.close()

• 追加写入ab

fileA = open('./Test.txt','ab')
fileA.write('写入的内容'.encode('utf-8'))
fileA.close()

3.读操作

• 读取所有

fileA = open('./Test.txt','r',encoding='utf-8')
print(fileA.read())
fileA.close()

• 读取几个

fileA = open('./Test.txt','r',encoding='utf-8')
print(fileA.read(4))
fileA.close()

• 读一行

fileA = open('./Test.txt','r',encoding='utf-8')
print(fileA.readline())
fileA.close()

• 读所有行

fileA = open('./Test.txt','r',encoding='utf-8')
print(fileA.readlines())
fileA.close()

• 读取二进制

fileA = open('./Test.txt','rb')
data = fileA.read()
print(data)
print(data.decode('utf-8'))
fileA.close()

4.With上下文管理对象

自动释放打开关联对象

with open('./Test.txt','rb') as fileA :
    data = fileA.read()
    print(data)
    print(data.decode('utf-8'))
    #自动释放

小结

文件读写的几种操作方式
read r r+ rb rb+
r r+ 只读使用普通读取场景
rb rb+ 适用于文件图片视频音频这样文件读取
write WW+ wb+
w ba ab w wb+ W+每次都会去创建文件
二进制读写的时候要注意编码问题，默认情况下我们写入文件的编码是gbk
a ab a+ 在原有的文件的基础之后去[文件指针的末尾]去追加，并不会每次的都去创建一个新的文件

案例

old_file = input('请输入 要备份的文件名:')
file_list=old_file.split('.')
#构造新的文件名.加上备份的后缀
new_file=file_list[0]+'_ 备份. '+file_list[1]
try:
    #监视啊哟处理的逻辑
    with open(old_file,'r') as old_f,open(new_file,'w')as new_f:
        while True:
            content=old_f.read(1024) #-次读取1024字符
            new_f.write( content)
            if len( content)<1024:
                break
except Exception as msg:
    print (msg )
pass

5.文件定位

• tell() 返回指针当前所在的位置

with open('./Test.txt','r',encoding='utf-8') as fileA :
    fileA.read(1)
    print(fileA.tell())
    fileA.read(2)
    print(fileA.tell())

• truncate() 对源文件进行截取操作

with open('./Test.txt','r+') as fileA :
    fileA.truncate(2)
    print(fileA.read())

• seek() 更改光标指针位置
  只有二进制模式打开文件才能更改光标指针位置

fileA.seek(-2,0)#0初始位置开始
fileA.seek(-2,1)#1当前位置开始
fileA.seek(-2,2)#2末尾位置开始

with open('./test.txt','rb') as fileA :
    data=fileA.read(2)
    print(data.decode('gbk'))
    fileA.seek(-2,1)#当前位置向前移动2格
    ok = fileA.read(2)
    print(ok.decode('gbk'))

四、Python模块

1.import导入模块

import 到首次导入模块的时候会发生如下3步操作

1. 打开模块文件
2. 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
3. 在程序中会有一个模块的名称指向模块的名称空间去

第三方模块安装位置，在python安装 目录下的lib/site- packages/目录下。

import time
print(time.ctime())

2.from…import导入模块

导入模块中部分函数，可以不用加模块名前缀，直接使用

from … import 首次导入发生了3个步骤

1. 以模块为准创造个模块的名称空间
2. 执行模块对应的文件了，将执行过程中产生的名字都丢到模块的名称空间
3. 在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字

from time import ctime
print(ctime())

3.as 给模块取别名

import time as timeA
print(timeA.ctime())

4. os模块

方法	解释
os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
os.chdir (“dimname”)	改变当前脚本工作目录:相当于shell下cd
os.curdir	返回当前目录:()
os.pardir	获取当前目录的父目录字符串名: ("…")
os.makedirs("dir1/dir2)	可生成多层递归目录
os.removedirs( dirname1)	若目录为空，则删除，并递归到上一级目录，如若也为空则删除，依此类推
os.mkdir(’ dimname’)	生成单级目录:相当于shell中mkdir dimname
os.rmdir( dimname’)	删除单级空目录，若目录不为空则无法删除，报错列
os.llistdir( dirname)	出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()	删除一个文件
os.rename(“oldname”,“new”)	重命名文件/目录
os.stat( path/filename’)	获取文件/目录信息
os.sep	操作系统特定的路径分隔符，win下 为"\\",Linux下为"/"
os.linesep	当前平台使用的行终止符，win 下为"\t\n".Linux下为"\n”
os.pathsep	用于分割文件路径的字符串
os.name	字符串指示当前使用平台。win->‘nt’: Linux->‘posix’
os. system/(“bash command”)	运行shell命令，直接显示
os.environ	获取系统环境变量:
os path.abspath(path)	返回path规范化的绝对路径
os.path.split(path)	将path分割成目录和文件名二元组返回
os.path.dirname(path)	返回path的目录。其实就是os path slit(path)的第一个元素
os.path basename(path)	返回path最后的文件名。如何path以/或\结尾，那么就会返回空值。即os path, split(path)的第=个元素
os.path.exists(path)	如果path存在，返回True; 如果path不存在，返回False
os.path.isabs(path)	如果path是绝对路径，返回True
os.path.isfile(path)	如果path是一个存在的文件，返回True。 否则返回False
os.path.isdir(path)	如果path是一个存在的目录，则返回True。 否则返回False
os.path.join(path1[ path2[ ]]	将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)	返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)	返回path所指向的文件或者目录的最后修改时间

• 案例

import os
os.rename( 'Test.txt','Test_ 重命名.txt' )
os.remove('File del.py') #删除文件前提是文件必须存在
os.mkdir('TestCJ') #创建文件夹
os.rmdir('TestCJ') #删除文件夹文件必须存在
#mkdir创建一级目录
os.mkdir( 'd: /Python编程/sub核心') #不允许创建多级
#创建多级目录
os.makedirs( 'd:/Python编程/sub核心/三级sub') #允许
os.rmdir('d:/Python编程') #只能删除空目录
# 如果要删除非空目录的话，需要调用shutil模块
# 非空多级删除
shutil.rmtree('d: /Python编程')
#获取当前的目录
print(os. getcwd())
#路径的拼接
# print(os.path)
print (os . path. join(os . getcwd(),'veny' ))
#获取python中的目录列表
listRs=os .listdir( 'd:/')
for dirname in listRs:
    print(dirname)
#scandir和with一起来使用这样的话上下文管理器会在迭代器遍历完成后自动去释放资源
with os. scandir('d:/') as entries:
    for entry in entries:
        print( entry . name)
#是否是文件，是否是文件夹目录
basePath= 'H:/'
for entry in os .listdir(basePath):
    if os.path. isfile(os.path. join(basePath, entry)):
        print(entry)
    if os.path. isdir(os.path. join(basePath, entry)):
        print(entry)

5.自行编写模块

.py就是模块，以库的形式去封装，可以定义类、函数、变量，只在本模块中使用

• 三种导入方式

import MTest
from MTest import add
from MTest import *

• 模块内测试代码，模块调用时不会执行，未判断则会执行

if __name__=='__main__':
    print('测试')

• 限定调用函数（使用from MTest import *）

__all__=['add']

• 发布
  编写setup.py

from distutils.core import setup
# name模块名称
# version 版本号
# description 描述
# author 作者
# py_ modules 要发布的内容
setup(name="MTest", version="1.0",description="my module",
author="lilei", py_modules=[ 'MTest'])

• 创建模块

python setup.py build

• 生成压缩包

python setup.py sdist

• 安装

pip install MTest-1.0.tar.gz

-------------------------------ppt警告-------------------------------

五、Python垃圾回收

1.引用计数（主）

import sys
a=[]
print(sys.getrefcount(a))#两次引用计数

2.GC负责的主要任务

3.标记-清除

4.引用计数不能回收的案例分析

5.分代收集

6.GC的阈值

有三种情况会触发垃圾回收:
1.当gc模块的计数器达到阀值的时候，自动回收垃圾
2.调用gc. collect()，手动回收垃圾
3.程序退出的时候，python解释 器来回收垃圾

7.GC垃圾回收自动触发机制

7.内存优化

• 大整数池和小整数池的区别是:

1. 从结果来看是一样的
2. 大整数池是没有提前的创建好对象，是个空池子，需要我们自己去创建，创建好之后，会把整数对象保存到池子里面，后面都不需要再创建了直接拿来使用，小整数池是提前将[-5,256]的数据都提前创建好

8.pep8原则

9.命令行参数

import sys
print(len(sys.argv))
print(str(sys.argv))

• 案例

import argparse

#创建一个解析器对象
parse=argparse.ArgumentParser(prog= '系统登录',usage= '%(prog)s[options] usage',description='系统自定义命令行的文件',epilog= 'my - epilog')
#添加位置参数[必选参数]
parse.add_argument('loginType ',type=str, help=' 登录系统类型')
#添加可选参数
parse.add_argument('-u',dest='user',type=str,help= '你的用户名')
parse.add_argument('-p',dest='pwd',type=str,help= '你的密码')
result=parse.parse_args() #开始解析参数
if (result.user=='root' and result.pwd== '111111' ):
    print( ' login sucess!' )
else:
    print('login fail ' )

python test.py mysql -u root -p 111111

六、Python正则表达式

1.re模块

import re
str = 'best language in the world'
result = re.match('b',str)
print(result.group())

2.匹配规则-字符

2.1.的使用

# .的使用:匹配除了换行符之外的字符
data = '王一'
partternA = '王.'
res = re.match(partternA,data)
if res :
    print(res.group())

2.2[]的使用

# []的使用:匹配中括号中任意一个字符
data = 'sdfg'
partternA = '[a-z]'
res = re.match(partternA,data)
if res :
    print(res.group())

2.3\d的使用

# \d的使用:匹配数字0-9
data = '9g'
partternA = '\d'
res = re.match(partternA,data)
if res :
    print(res.group())

2.4\D的使用

# \D的使用:匹配非数字0-9
data = 's9g'
partternA = '\D'
res = re.match(partternA,data)
if res :
    print(res.group())

2.5\s的使用

# \s的使用:匹配空白字符或tab
data = ' s9g'
partternA = '\s'
res = re.match(partternA,data)
if res :
    print(res.group())

2.6\S的使用

# \S的使用:匹配非（空白字符或tab）
data = 's9g'
partternA = '\S'
res = re.match(partternA,data)
if res :
    print(res.group())

2.7\w的使用

# \w的使用:匹配单词字符，a-z，A-Z，0-9，_
data = 's9g'
partternA = '\w'
res = re.match(partternA,data)
if res :
    print(res.group())

2.8\W的使用

# \W的使用:匹配非单词字符
data = '@s9g'
partternA = '\W'
res = re.match(partternA,data)
if res :
    print(res.group())

3.匹配规则-字符数量

3.1*的使用

匹配前一个字符出现0次或者无限次，即可有可无

data = 'Any'
partternA = '[A-Z][a-z]*'#从第二位开始后边都匹配小写字符
res = re.match(partternA,data)
if res :
    print(res.group())

3.2+的使用

匹配前一个字符出现1次或者无限次，即至少有1次

#不能以数字开头，只包含数字字母xia'huai'x'na
data = 'MY_Name'
partternA = '[a-zA-Z_]+[\w]*'
res = re.match(partternA,data)
if res :
    print(res.group())

3.3\?的使用

匹配前一个字符出现1次或者0次，即要么有1次，要么没有

data = '7'
partternA = '[a-zA-Z_]+?[0-9]'#第一位可有可无
res = re.match(partternA,data)
if res :
    print(res.group())

3.4{m}的使用

匹配前一个字符出现m次

data = '12345'
partternA = '\d{4}'#精确匹配多少个数字
res = re.match(partternA,data)
if res :
    print(res.group())

3.5{m,}的使用

匹配前-一个字符至少出现m次
data = '12345'
partternA = '\d{4,}'#精确匹配4-max个数字
res = re.match(partternA,data)
if res :
    print(res.group())

3.6{n,m}的使用

匹配前一个字符出现从n到m次

匹配前-一个字符至少出现m次
data = '12345'
partternA = '\d{4,5}'#精确匹配4-5个数字
res = re.match(partternA,data)
if res :
    print(res.group())

• 邮箱

data = '[e-mail]'
partternA = '[a-zA-Z0-9]{6,11}@163.com'
res = re.match(partternA,data)
if res :
    print(res.group())

4.匹配规则-原生字符串

一般运用在路径上

data = 'c\\a.txt'
partternA = r'c\\a.txt'#正则前面加r，不转义
res = re.match(partternA,data)
if res :
    print(res.group())

5.匹配规则-开头和结尾

data = 'Myname'
partternA = '^M.*'#以M开头
res = re.match(partternA,data)
if res :
    print(res.group())

data = 'Myname'
partternA = '^M\w{5}'#以M开头后边5个长度任意字符
res = re.match(partternA,data)
if res :
    print(res.group())

data = '[e-mail]'
partternA = '[\w]{6,11}@[\w]{3}.com$'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

6.匹配规则-分组匹配

6.1|的使用

匹配左右任意-一个表达式

data = 'zzz-123456789'
partternA = '([0-9]*)-(\d*)|([a-z]*)-(\d*)'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

6.2(ab)的使用

将括号中字符作为一个分组

data = 'zzz-123456789'
partternA = '([0-9]*)-(\d*)|([a-z]*)-(\d*)'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

6.3\num的使用

引用分组num匹配到的字符串

• 一般应用于html文档

data = '<html><h1>测试数据</h1></html>'
partternA = r'<(.+)><(.+)>(.+)</\2></\1>'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

6.4(?P)的使用

分组起别名

data = '<div><h1>测试数据</h1></div>'
partternA = r'<(?P<div>\w*)><(?P<d>\w*)>.*</(?P=d)></(?P=div)>'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

6.5(?P=name)的使用

引用别名为name分组匹配到的字符串_

data = '<div><h1>测试数据</h1></div>'
partternA = r'<(?P<div>\w*)><(?P<d>\w*)>.*</(?P=d)></(?P=div)>'#以.com结尾
res = re.match(partternA,data)
if res :
    print(res.group())

7.re.compile

• compile函数根据- -个模式字符串和可选的标志参数生成一-个正则表达式对象。该对象拥有- -系列方法用于正则表达式匹配和替换。re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

compile re模块中的编译方法可以把个 字符串编译成字节码
优点:在使用正则表达式进行match的操作时，python会将 字符串转为正则表达式对象，而如果使用complie则只需要完成次转换即可， 以后再使用模式对 象的话无需重复转换，

reobj = re.compile('\d{4}')
res = reobj.match('1234567')
print(res.group())

8.re.search

str = 'best language in the world'
res =re.search('world',str)
print(res.group())

9.re.findall

str = 'best language in the world in in'
res =re.findall('i.',str)
print(res)

10.re.sub

str = 'best language in the world in in'
pat = '[a-zA-Z]+'
res =re.sub(pat,'C#',str)
res =re.subn(pat,'C#',str)
print(res)

11.re.split

str = 'best language in the world in in'
pat = 'in'
res =re.split('in',str)
print(res)

12.贪婪模式和非贪婪模式

• 图片匹配
  贪婪

parttern = ‘<img src = ''(.*)>’

非贪婪

parttern = ‘<img src = ''(.*?)>’