python基础学习6和7

模块类与对象

• 模块

  内置模块 time, random, os, json

  第三方模块 requests, pandas, numpy,....

  自定义模块 xxx.py

  常见的内置模块

• hashlib 模块

  该模块主要是进行数据加密的作用。

  常见的加密方式：sha256()【可逆】 md5()【不

  可逆】

  import hashlib
  info = '123456'
  # 创建hashlib中的加密对象
  md5_obj = hashlib.md5()
  # 设置编码
  md5_obj.update(info.encode('UTF-8'))
  # 调用函数，开始加密
  mi_wen = md5_obj.hexdigest()
  print(f"明文：{info},通过md5加密后得到密文：
  {mi_wen}") #
  e10adc3949ba59abbe56e057f20f883e
  

  一般情况下，在企业中，若想要对一个明文进行MD5

  加密的话，一般都不是直接进行加密，而是先对名进

  行加盐操作，之后才会进行md5加密。

  import hashlib
  info = '123456'
  # 创建hashlib中的加密对象
  md5_obj = hashlib.md5('shujia'.encode('UTF-
  8')) # 加盐操作
  # 设置编码
  md5_obj.update(info.encode('UTF-8'))
  # 调用函数，开始加密
  mi_wen = md5_obj.hexdigest()
  print(f"明文：{info},通过md5加密后得到密文：
  {mi_wen}") #
  0ead149c250ec554aff85fa083312a83
  

  json模块

  本质上是一个特殊格式的字符串，但是相比较于字符

  串而言，json是可以通过键获取值的。

  判断一个字符串是否符合json的格式：

  看字符串是否是由双引号括起来，若不是，那么该

  字符串转不了json格式数据

  若值是由小括号括起来的多个元素，也是不能够转

  json格式数据的

• 序列化：将代码中的数据转化成网络中传输的数据流

  【python中的字典数据 --> json格式的字符串】

  import json
  dict1 = {
  'name': '黄沪生'
  ,
  'age': 18,
  'likes': ['踢足球'
  ,
  '钓鱼'
  ,
  '打游戏'],
  'pets': [
  {'name': '小花'
  ,
  'age': 2},
  {'name': '小黑'
  ,
  'age': 3}]
  }
  s3 = json.dumps(dict1, ensure_ascii=False)
  print(s3, type(s3))
  

• 反序列化：将网络中传输的数据流还原成代码中的数

  据格式 【json格式的字符串 --> python中的字典数

  据】

• import json
  # s2 ='''{"name":"黄沪生","age":18,"likes":["踢足球","钓鱼","打游戏"]}
  # '''
  # print(s2, type(s2))
  # # print(s2['age'])
  # res1 = json.loads(s2)
  # print(res1, type(res1))
  

时间相关的模块

time

import time
res1 = time.time() # 得到的是一个时间戳格式的数
据
print(res1, type(time)) # 2024-11-29
10:45:58

时间戳存储时占用的字节相比较于格式化后的字符串

而言，是少很多的。

datetime


时间戳，datetime, 格式化日期字符串互相转换

import time
from datetime import datetime
#
# res1 = time.time() # 得到的是一个时间戳格式的数据
# print(res1, type(time)) # 2024-11-29

# '2024年11月29日 10时51分00秒'
# datetime -> str 日期格式化
s1=datetime.now()
print(s1)
res1 = datetime.strftime(s1,'%Y-%m-%d %H:%M:%S')
print(res1)
print("-------------------------------")
# time.time()
# 时间戳 -> datetime
tp = time.time() # 当前的时间戳
print(tp)
res2 = datetime.fromtimestamp(tp)
print(res2, type(res2))
# datetime -> str
res3 = datetime.strftime(res2,'%Y/%m/%d %H:%M:%S')
print(res3, type(res3))
print("-------------------------------")
# 字符串 -> datetime
s2 = '2024/11/29 11:02:28'
d2 = datetime.strptime(s2,'%Y/%m/%d %H:%M:%S')
print(d2, type(d2))
# datetime-> 时间戳
tp2 = d2.timestamp()
print(int(tp2))

date还有一种方式可以时间获取年月日时分秒, 使用

datetime对象中的属性

tp = 1732849348
dt1 = datetime.fromtimestamp(tp)
print(f"{dt1.year}年{dt1.month}月{dt1.day}
{dt1.hour}时{dt1.minute}分{dt1.second}秒")

OS模块

使用os模块中的功能操作文件或者文件夹

• 判断目标是否存在

import os
# data/user_info
b = os.path.exists('C:\projects\PycharmProjects\\bigdata33\day07\data\\user_info')
print(b) # True

• 路径拼接

import os
s1 = os.path.join('data','user_info')
print(s1,type(s1))
if os.path.exists(s1):
    f = open(s1,'r',encoding='UTF-8')
    text1 = f.read()
    print(text1)
else:
    print("目标路径不存在！")

• 获取当前文件所在的路径

ml1 = os.path.abspath(__file__) # __file__ 代表的是当前的文件
print(ml1, type(ml1))

• 获取某一个文件所处的父级目录路径

ml2 = os.path.dirname(ml1)
print(ml2,type(ml2))

• 判断一个路径是否是文件

ml1 = os.path.abspath(__file__) # __file__ 代表的是当前的文件
print(ml1, type(ml1))
ml2 = os.path.dirname(ml1)
print(ml2,type(ml2))
print(os.path.isfile(ml1)) # True
print(os.path.isfile(ml2)) # False
print(os.path.isdir(ml1)) # False
print(os.path.isdir(ml2)) # True

• 判断一个路径是否是文件夹

ml1 = os.path.abspath(__file__) # __file__
代表的是当前的文件
print(ml1, type(ml1))
ml2 = os.path.dirname(ml1)
print(ml2,type(ml2))
print(os.path.isdir(ml1)) # False
print(os.path.isdir(ml2)) # True

• 创建一个文件夹

lj1 = os.path.join('data','aaa')
os.mkdir(lj1)

注意：

若要创建一个文件夹，使用os模块中的mkdir函数

若要创建一个文件，使用open函数以写的方式打

开

ml1 = os.path.abspath(__file__) # __file__
代表的是当前的文件
ml2 = os.path.dirname(ml1)
res1 = os.walk(ml2)
'''
a1: 表示遍历到的文件夹的名称
b1: 表示遍历到的文件夹下所有的文件夹名称组成的列表
c1: 表示遍历到的文件夹下所有的文件名称组成的列表
'''
for a1,b1,c1 in res1:
print(f"a1:{a1}")
print(f"b1:{b1}")
print(f"c1:{c1}")
print("----------------------")

• 删除路径
  • 若目标路径是一个文件

lj1 = os.path.join('data','bbb')
os.remove(lj1)

• 若目标文件是个文件夹

lj1 = os.path.join('data','aaa')
os.rmdir(lj1)

os模块练习

练习1：企业中有一个网站，每一天都有新的用户

注册，要求每一天需要使用一个新的文件存储当天

注册的用户信息。

自定义模块

第三方模块

类和对象

面向对象概述

面向过程的编程思想：每一步的实现过程都是我们一步一步
参与实现的，相当于参与者
【代表语言：C语言】
面向对象的编程思想：我们在自己程序中，创建别人写好类
的对象，调用别人写好的功能，相当于指挥者 
【代表语言：java,python】
举例现实生活中面向对象的例子：
吃饭:
面向过程的角度：自己买鸡蛋，自己打鸡蛋，自
己煮饭，自己将蛋和饭一起炒，自己装盘
面向对象的角度：点一份蛋炒饭，饭店人员完成
上面的事情
接水：
面向过程的角度：自己拿起水杯，走到饮水机面
前，选择热水还是冷水，接水
面向对象的角度：祈求同桌接水，剩下事情，由
同桌这个对象去完成
如何在python中描述或者使用现实生活中的一个对象呢？
1. 需要我们先创建一个概念性的东西，用于描述某一种所
有对象的共同特点，在python中称之为类 class
2. 我们就可以根据创建好的类，来创建若干个对象
世间万物，皆为对象，同一种对象之间，会有相同的特点，
都可以使用属性和行为对任意一个对象进行描述。
人：                                     class Person:
属性：姓名，年龄，性别...                   成员变量：name,age,gender
行为：吃饭，睡觉，学习...                   成员方法：eat(),sleep(),study()

创建类和对象

注意：class类中的函数，必须要有一个参数，且是第一个定义，self self: 表示当前调用该方法的对象

创建类：类名首字母要大写

init方法里面的参数就是这个是对象的属性值，在创建类的时候进行定义，创建对象的时候进行赋值，且每一个对象都有这些属性

self.属性或者方法，这是代表时类内部的属性或者方法

class 类名:
    def __init__(self,属性1,属性2,...属性n):
        self.属性1 = 属性1
        self.属性2 = 属性2
        . . .
        self.属性n = 属性n
    def method1(self):
        pass
    def method2(self):
        pass

创建对象：创建的类有多少个属性，则根据这个类创建对象的时候就传入几个参数，一个类可以创建多个对象

对象1 = 类名(属性1,属性2,...属性n)
...
对象n = 类名(属性1,属性2,...属性n)

属性赋值【针对类中没有创建属性的情况】：

# 在外部对对象的属性进行赋值
对象.属性 = 参数

面向对象编程那些改进场景

• 可以改进多个传参的问题

  # 改进前，需要进行多次定义参数列表和传参
  def fun1(a1,b1,c1,d1):
   pass
  def fun2(a1,b1,c1,d1):
   pass
  def fun3(a1,b1,c1,d1):
   pass
  fun1(11,22,33,44)
  fun2(11,22,33,44)
  fun3(11,22,33,44)
  
  #改进后，这样每次调用fun就都会有四个属性值，只需要进行一次传参
  class Demo:
      def __init__(self,a1,b1,c1,d1):
          self.a1 = a1
          self.b1 = b1
          self.c1 = c1
          self.d1 = d1
      def fun1(self):
          pass
      def fun2(self):
          pass
      def fun3(self):
          pass
  

• 改进某一个事物的封装

  class Person:
      def __init__(self,name,age):
          self.name = name
          self.age = age
      def __str__(self):
          return f"name:{self.name},age:{self.age}"
  
  user_list = []
  for i in range(1,4):
      name = input("请输入你的名字：")
      age = input("请输入你的年龄：")
      p = Person(name,age)
      user_list.append(p)
      
  for p in user_list:
      print(p.__str__())
  for p in user_list:
      print(p)
  # 最后两个for结果一样
  

  注意：一个类一旦创建了，一定至少有两个方法:

  # __init__()
  相当于构造函数，对属性进行赋值
  # __str__()
  这个在打印对象的时候进行调用，前提没有指定调用某个函数，就默认调用__str__()方法
  

面向对象的三大特征

封装

• 属性与方法的私有化

  私有化的属性与方法除了类就不能在进行调用，只能在类的内部自己调用，可间接性地通过没有私有化的方法去调用私有化的属性与方法

  class Person:
      def __init__(self,name,age):
          self.__name = name
          self.__age = age
  
      def set_name(self,name):
          self.__name = name
      def get_name(self):
          return self.__name
      def __eat(self):
          print("人是铁，饭是钢，一顿不吃饿得慌！")
      def fun(self):
          self.__eat()
      def __str__(self):
          return f"name:{self.name},age:{self.age}"
  
  p = Person('fz',18)
  print(p.get_name())
  p.fun()
  

继承

继承是将多个类中的相同的部分，单独提取到一个类 中，这些类于单独提出来的这个类产生一个关系 这个关系，就叫做继承关系，其他类中也就拥有了相 同的部分，不需要特地定义出来。

总结：子类继承父类，父类有的子类一定有，父类没有的子类也可以有

• 通过继承，子类拥有了父类中的成员(私有成员除外)

  class Fu:
   def fun1(self):
      print("好好学习，天天向上！")
   def __fun2(self):
      print("这是父类中私有的成员函数__fun2")
  class Son(Fu):
   pass
  s1 = Son()
  s1.fun1() # 好好学习，天天向上！
  s1.__fun2() # 报错
  

• 若子类中出现与父类的函数名以及函数参数都一样， 只是实现不一样的情况，子类对象调用的是自己的函数

  注意：这样的函数称之为函数的重写 override

  class Fu:
   def fun1(self):
    print("好好学习，天天向上！")
   def __fun2(self):
    print("这是父类中私有的成员函数__fun2")
   def fun3(self):
    self.__fun2()
  class Son(Fu):
   def fun1(self):
    print("这是子类中的函数fun1")
    pass
  
  s1 = Son()
  s1.fun1() # 这是子类中的函数fun1
  

• 子类中可以使用super()来调用父类中非私有的成员

  class Fu:
   def fun1(self):
    print("这是父类中的fun1")
  class Zi(Fu):
   def fun1(self):
    print("这是子类中的fun1")
   def show(self):
    self.fun1()  # 调用的是子类中重写后的fun1函数
  # 调用父类中的fun1
    super().fun1()
  z = Zi()
  z.show()
  

• 若同时继承的类中有相同的函数名，谁先写就调用谁的

  class Fu:
   def fun1(self):
    print("这是父亲中的函数fun1")
   def show(self):
    print("这是父亲中的函数show")
  class Mather:
   def fun2(self):
    print("这是母亲中的函数fun2")
   def show(self):
    print("这是母亲中的函数show")
  class Son(Mather,Fu):
   def function1(self):
    print("这是儿子自己的函数")
  s1 = Son()
  s1.show() # 这是母亲中的函数show
  

多态

表示的是某一个事物在不同时刻下的不同状态

在python中默认支持多态，因为python是动态数

据类型语言

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return f"name:{self.name}, age:{self.age}"
    def eat(self):
        print("吃")
    def sleep(self):
        print("睡")

class Dog(Animal):
    pass
a1 = Animal('小黄',2)
a1 = Dog('小黑',3)
print(a1)
# Animal a = new Dog('小黑',3)

抽象

class Animal:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"name:{self.name}, age:
{self.age}"
@abstractmethod
def eat(self):
pass
@abstractmethod
def sleep(self):
pass
class Dog(Animal):
@override
def eat(self):
print("

标签：__,name,python,self,基础,学习,print,os,def	

From： https://www.cnblogs.com/lanzhi666/p/18580440