Python基础中级

• 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

• 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

为模块取别名.

import w as sm

导入模块内具体的东西

from w import money, read1

绝对导入

from e import w

相对导入

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

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

优点：导入更加简单

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

time模块

函数

datetime模块

函数

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)