Python基础中级

4.中级====高级函数

• 匿名函数
  • (lambda c,y:c+y)(1,2)
• @fun2()
• def fun1(n):
  • pass
• fun1(100)
• 装饰器
  • def fun2(fun3):
    • def fun4(*args,**kwargs):
      • fun3(*args,**kwargs)
    • return fun2

5.中级====异常

        

• 1、普通异常
  • try:
    • 执行命令
  • except 异常名称 as e:
    • 执行命令
  • else: 代码正确执行
    • 执行命令
  • finally: 最后都会执行
    • 执行命令
• 2、自定义异常
  • if len(l) == 9:
    • raise TypeError('异常')
  • assert len(l) == 8

6.中级====文件操作

        

• 打开文件
  • 绝对路径
    • f = open(r'小六\Python文件\python1\a.txt', encoding='UTF-8')
  • 相对路径
    • f = open(r'../../a.txt', encoding='UTF-8')
• 读取文件
  • f.read()
• 关闭文件
  • f.close()
• 模式
  • rt只读模式
    • with open(r'../../a.txt', mode='rt', encoding='UTF-8') as f:
      • 执行命令
  • wt:只写模式 （ 当文件不存在时，新建一个空文档, 文件存在有内容，则清空）
    • with open(r'../../b.txt', mode='wt', encoding='UTF-8') as f:
      • 执行命令
  • at:只追加写模式（文件不存在，就新建，存在，就指针指向末位）
    • with open(r'../../c.txt', mode='at', encoding='UTF-8') as f:
      • 执行命令
  • 二进制文件 b模式
    • with open(r'../../1.png', mode='rb') as f:
      • 执行命令
  • 二进制写入
    • with open('wb模式.txt', mode='wb') as f:
      • 执行命令
  • 可读可写模式 r+t 在末位写,不可创建
    • with open('wb模式.txt', mode='r+t', encoding='UTF-8') as f:
      • 执行命令
  • w+t 可读可写，可以创建
    • with open('ww模式.txt', mode='w+t', encoding='UTF-8') as f:
      • 执行命令
  • a+t 模式
    • with open('we模式.txt', mode= 'a+t', encoding='UTF-8') as f:
      • 执行命令

• 函数

  • readable()	判断是否可读
    writable()	判断是否可写
    readline()	读取一行
    write()	写入文件
    writelines(info)	列表写入多行
    encode()	编码成**编码
    decode()	解码成**编码
    seek()	指针移动 字节

• OS指令
  • 删除文件
    • os.remove(文件名）
  • 修改文件
    • os.rename(文件名， 文件名)

7.中级====迭代器与生成器

• 可迭代对象
  • 有__iter__()方法，没有__next__()方法
  • 例
    • a = 'sdf'
    • a.__iter__()
    • iter(a)
• 迭代器
  • 同一个迭代器，只能取值一次
  • 有__iter__()方法，有__next__()方法
  • 例：
    • d = {'sdf':2,'w':4}
    • next(d)
• yield 函数返回多个值
  • 例
    • def func():
    •     print('====1')
    •     # 迭代返回值，可以返回多个值
    •     yield 1
    •     yield 2
    •     yield 3
    • g = func()

8.中级====面向对象

• class Teacher:
•     school = '金职院'

•     def __init__(self, name, age, sex):（创建对象时，会自动运行该代码）
•         self.name = name
•         self.age = age
•         self.sex = sex

•     def course(self, name):
•         print(name + '现在' + self.age + '岁了')

• t1 = Teacher('帜邑', 20, '女')
• t2 = Teacher('帜邑1', 20, '女')
• print(t1.__dict__)（返回该对象有的属性）
• print(t2.__dict__)
• t1.name = '小六'
• 绑定对象的方法
  • class A:
  •     def f(self, n):
  •         print(n)
  •         print('我是f函数')
  • a1 = A()
  • a1.f(1)
  • # 调用类的函数时，需要传入对象，self是自身
  • A.f(a1, 2)
• 绑定类的方法
  • class B:
  •     @classmethod
  •     def f2(cls, n):
  •         print(n)
  •         print('我是绑定类的方法')

• B.f2(1)

• 非绑定方法 == 静态方法
  • class C:
  •     # 纯粹的一个函数
  •     @staticmethod
  •     def f3(n):
  •         print(n)
  •         print('我是绑定方法/静态方法')

• C.f3(2)

9.中级====继承与派生

• obj1 = Foo(1, 2)
• obj1(1, 2, x=3, y='w')
•     def __call__(self, *args, **kwargs):
•         print(self, args, kwargs)
• # __call__:在对象被调用的时候自动触发该方法
•  
  • class Foo:
  •     def __init__(self, name, age):
  •         self.name = name
  •         self.age = age
• obj = Foo()
• obj1 = Bar()
• obj.attr = obj1
• print(obj.attr)
• print(obj.attr.yyy)
• obj.attr.zzz()
•     def zzz(self):
•         print('我是Bar类实例化对象的方法')
• class Bar:
•     yyy = 222
• 组合
  • # 组合:通过为某一个对象添加属性，间接的将两个类组合在一起
  • class Foo:
  •     xxx = 100
• obj = A()
• # obj.x = 'obj'
• 查看继承信息
• print(A.mro())
• class A(B, C, D):
•     # x = 'A'
•     pass
• class D(G):
•     # x = 'D'
•     pass
• class C(F):
•     # x = 'C'
•     pass
• class B(E):
•     # x = 'B'
•     pass
• class F(G):
•     # x = 'F'
•     pass
• class E(G):
•     # x = 'E'
•     pass
• 多继承
  • class G(object):
  •     x = 'G'
  •     pass
• class Student(People):
•     def __init__(self, name, age, sex, score=0):
•         # 调用父类 super
•         super().__init__(name, age, sex)
•         self.score = score
•     def __init__(self, name, age, sex):
•         self.name = name
•         self.age = age
•         self.sex = sex
• 调用父类方法
  • super使用方法，super(自己的类名, 自己的对象),或super()【自动传值】
  • class People:
  •     school = '金职院'
• # 继承Paren1类
• class Sub1(Paren1):
•     xxx = 33
•     pass
•     def run(self):
•         print('我是父类')
• 继承
  • 例：
    • class Paren1():
    •     xxx = 222

10.中级====封装、反射、单例模式、元类

• print(Teacher.__dict__)
•     def run(self):
•         print('%s在跑步' % self.name)
• # 控制类的产生
• class Mymeta(type):
•     def __init__(self, class_name, class_bases, class_dic):
•         if class_name.islower():
•             raise TypeError('类名必须使用驼峰体')
•         doc = class_dic.get('__doc__')
•         if doc is None or len(doc) == 0 or len(doc.strip('\n'))==0:
•             raise TypeError('类的体代码必须有文档注释，且不能为空')
• # 自定义元类
• class Teacher(object, metaclass=Mymeta):
•     school = '金职院'
•     def __init__(self, name, age, sex):
•         self.name = name
•         self.age = age
•         self.sex = sex
• def run(self):
•     print('%s在跑步' % self.name)
• '''
• class_dic = {}
• # 介绍exec函数  可以执行字符串里面的代码
• exec(class_body, {}, class_dic)
• Teacher = type(class_name, class_bases, class_dic)
• a = Teacher('帜邑', 20, 'se')
• a.run()
• """
• 元类
  • # 不依赖class关键字创建一个自定义类
  • class_name = 'Teacher'
  • # 拿到类的基类/父类们:(object.)
  • class_bases = (object, )
  • class_body = '''
  • Hp = 100
  • def __init__(self, name, age, sex):
  •     self.name = name
  •     self.age = age
  •     self.sex = sex   
• obj1 = Mysql.from_conf()
• print(obj1.ip)
• obj2 = Mysql('123',456)
• print(obj2.ip)
•     @classmethod
•     def from_conf(cls):
•         if cls.__instance is None:
•             cls.__instance = cls('127.0.0.1', 1234)
•         return cls.__instance
•     def __init__(self, ip, port):
•         self.ip = ip
•         self.port = port
• 单例模式
  • # 单例模式,当实例化多次得到的对象中都一样的情况，应该将多个对象指向同一个内存，即同一个实例
  • class Mysql:
  •     __instance = None
• s = ShoppingCart()
• s.run()
•     def run(self):
•         while True:
•             cmd = input('请输入>>>').strip()
•             '''
•             if cmd == 'login':
•                 self.login()
•             elif cmd == 'shopping':
•                 self.shopping()
•             elif cmd == 'football':
•                 self.football()
•             '''
•             if hasattr(self, cmd):
•                 method = getattr(self, cmd)
•                 method()
•             else:
•                 print('输入方法不存在')
•     def football(self):
•         print('football')
•     def login(self):
•         print('login')
• 反射
  • # 反射方法的应用
  • class ShoppingCart:
  •     def shopping(self):
  •         print('shopping')
•     # 将它当成一个属性来看
•     @property
•     def bmi(self):
•         return self.weight / (self.height ** 2)
• 函数
  • # 判断字符串是否有name属性
  • print(hasattr(obj, 'name'))
  • # 获取对象属性,没有就返回自定义的值
  • print(getattr(obj, 'namx', None))
  • # 修改对象属性,不存在就添加
  • setattr(obj, 'yyy', 'xiaoliu')
  • print(getattr(obj, 'yyy'))
  • # 删除对象属性
  • delattr(obj, 'name')
  • print(obj.__dict__)
  • # 判断类里面是否有这个属性
  • print(hasattr(list, 'append'))
• class People:
•     def __init__(self, name, weight, height):
•         self.name = name
•         self.weight = weight
•         self.height = height
• print(Foo.__dict__)
• # 封装在类的定义阶段进行，在定义之后不会变形
• Foo.__z = 234
• print(Foo.__z)
• 封装函数的意义,将类的内部封装起来
•     def get_info(self):
•         print(self.__x, self.__y, self.__name)
•         self.__func()
•     def __func(self):
•         print('func')
•     def __init__(self, name, age):
•         self.__name = name
•         self.__age = age
• 封装
  • class Foo:
  •    变量前加__ 实现隐藏
  •     __x = 111
  •     __y = 222

11.中级====模块

        

为模块取别名.

import w as sm

导入模块内具体的东西

from w import money, read1

绝对导入

from e import w

相对导入

相对导入：参照当前所在文件夹为起始开始查找

符号：.代表当前所在文件夹的文件，..代表上级文件夹，...代表上一级的上一级文件夹

优点：导入更加简单

缺点：只能在导入包中的模块时才能使用，不能在执行文件中用

time模块

函数

time.time()	用来计算时间差
time.localtime()	获取当地时间 返回的是结构化时间
time.gmtime()	获取UTC时间，返回的还是结构化时间 比中国时间少8小时
time.strftime('%Y-%m-%d %H:%M:%S')	将当前时间格式化，输出格式化后的时间
time.localtime(10)	10秒时间戳
time.localtime(time.time())	当前时间戳
time.mktime(time.localtime())	结构化转时间戳

datetime模块

函数

datetime.now()	获取当前时间
d = datetime.now() print(d.year) print(d.month) print(d.day) print(d.minute) print(d.second) print(d.microsecond)	单独获取某个时间 年 月
datetime(2018, 8, 9, 9, 50, 00)	手动指定时间
d.replace(year=2019)	替换某个时间单位的值

hash模块

例

# m = hashlib.md5()

# # 运输的是二进制

# m.update('hello'.encode('UTF-8'))

# m.update('world'.encode('UTF-8'))

# # 产生hash值

# print(m.hexdigest())

pwd = 'abc123'

m = hashlib.md5()

# 密码前后加密

m.update('帜邑'.encode('UTF-8'))

m.update(pwd.encode('UTF-8'))

m.update('帜邑2'.encode('UTF-8'))

print(m.hexdigest())

# 无论校验的内容有多大，得到的hash值长度是固定的，不影响传输

# 加密方式不一样，得到的hash值长度不一样

m = hashlib.sha512()

m.update('abcdddkkjkjkljkljkjjljljlljkljkljkjljkkkkljkkdddd'.encode('UTF-8'))

print(m.hexdigest())

base64模块

例

a = '帜邑'.encode('UTF-8')

# 加密

str_a = base64.b64encode(a)

print(str_a)

# 解码成二进制，然后转化成UTF-8编码格式

str_b = base64.b64decode(str_a).decode('UTF-8')

print(str_b)

json序列化

意义:

把对象（变量）从内存中变成可储存或传输的过程称之为序列化

序列化就是将内存中的数据结构转换成一种中间格式储存到硬盘或者基于网络传输

反序列化就是硬盘中或者网络中传来的一种数据格式转换成内存中数据结构

为什么要有：

可以保存程序的运行状态

数据的跨平台交互

例：

dic = {'name': 'zhiyi', 'age': 20, 'sex': 'girl'}

# 前后端数据交互使用的是json

print(json.dumps(dic))

# 写入json文件  后缀名为.json

with open('db.json', 'wt', encoding='UTF-8') as f:

    json.dump(dic, f)

json的反序列化

例：

with open('db.json', 'rt', encoding='UTF-8') as f:

    json_str = f.read()

    # 将json_str转成内存中的数据类型

    dic = json.loads(json_str)

    print(dic)

with open('db.json', 'rt', encoding='UTF-8') as f:

    # 将json_str转成内存中的数据类型

    dic = json.load(f)

    print(dic)

OS模块

例

# # 获取当前工作目录，绝对路径

# print(os.getcwd())

# # 生成目录

# os.mkdir('zhiyi')

# # 删除空目录,目录不为空不能删除

# os.rmdir('e')

# # 拿到当前脚本工作的目录，相当于cd

# os.chdir('e')

# # 删除文件

# os.remove('w.py')

# 生成多层递归目录

# os.makedirs('dir1/dir2/dir3')

# 删除多层递归目录,有保护机制

# os.removedirs('dir1/dir2/dir3')

# 拿到当前文件夹的文件名或者文件夹放入列表

# 绝对路径

# print(os.listdir(r'D:\小六\Python文件\python1\开发\课上基础'))

# 相对路径

# print(os.listdir('.'))

# 上一级

# print(os.listdir('..'))

# 重命名文件/目录

# os.rename('w', 'e')

# 运行终端命令

# os.system('tasklist')

# 将path分割成目录和文件名二元组返回

print(os.path.split('/a/b/c/d.txt'))

# 返回文件名

print(os.path.split('/a/b/c/d.txt')[0])

# 返回文件

print(os.path.split('/a/b/c/d.txt')[1])

# 返回path目录，就是os.path.split(path)的第一个元素

print(os.path.dirname('/a/b/c/d.txt'))

# 返回path最后的文件名。即os.path.split(path)的第二个元素

print(os.path.basename('/a/b/c/d.txt'))

# 判断路径是否存在 文件和文件夹都可以 如果path存在，返回True；如果path不存在，返回False

print(os.path.exists('D:\小六\Python文件\python1\开发\课上基础'))

# 判断path是一个存在的文件，返回True，否则返回False

print(os.path.isfile('D:\小六\Python文件\python1\开发\课上基础\9.面向对象.py'))

# 如果path是一个存在的目录，则返回True。否则返回False

print(os.path.isdir('D:\小六\Python文件\python1\开发\课上基础'))

# 拼接一个绝对路径，会忽略前面的路径

print(os.path.join('a', 'b', 'c', 'D:\\', 'f', 'd', 't.txt'))

sys模块

sys模块是与python解释器交互的一个接口

import sys

sys.path.append('D:\小六\Python文件\python1\开发\课上基础\w')

print(sys.path)