python笔记3.0

模块： .py结尾的文件就是一个模块  里面存放了类、函数、数据

 

   导入模块  import 模块名

    模块导入的时候会执行模块中的顶层代码，而函数中的代码只有在调用的时候会执行

 

   from 模块名 import test03            把指定的成员导入进入我当前的作用域里面

 

   from 模块名 import *                     将指定模块中的所有成员导入到当前的作用域中

    如果说该模块中存在以_开头的成员，则通过该方式也无法导入

 

   如果导入进来的成员和自身的成员冲突，距离谁近就执行谁。   as别名解决（from module import test01 as a1

 

__all__=[""]:通过其指定的，只会限制 from 模块名 import * 的导入

__doc__ :获取文档注释

__file__:获取当前文件的绝对路径

__name__:显示模块的名字       __main__ 主模块

 

math模块：

 math.ceil（3.2）：向上取整（4

 math.floor（3.999）：向下取整（3

 math.round（）：全局函数 进行四舍五入 对于奇数，严格遵循四舍五入，对于偶数以0.5为界限，0.5会被舍弃

 math.pow（2,4）：幂函数，返回的是浮点数（16.0

 math.sqrt（16）：开平方，返回浮点数（4.0

 math.exp（2）：求e的x次方（7.3…..

 

time模块：

#asctime 接受时间元组，转换为字符串返回

print(time.asctime(time.localtime()))

#ctime 接收时间戳，返回字符串

print(time.ctime(time.time()))

#random 伪随机数

 random.randint(1,10)    获取某个范围内的随机函数   [left,right]

 int(random.random()*10)    获取0~1直接的随机数[0,1)

 random.choice(ls)   从有序地序列里随机选一个元素，直接返回具体元素     ls=(1,2,3,4)

 random.choices(ls)   返回的是随机抽取的元素组成的列表

#os   与操作系统相关的功能

 os.system("ipconfig")   帮助执行命令的

 os.curdir           获取相对路径

 os.getcwd()     获取当前工作目录的绝对路径

 os.chdir("E:\\")       切换工作路径

  os.listdir("E:\\7、5….")      列出指定目录下的文件

 os.getlogin()            当前登录的用户名

 os.sep         获取分隔符的

 os.rename(旧文件名, 新文件名) # 重命名文件

#os.path   专门针对路径和文件

 from os import path         允许你只从 os 模块中导入 path 子模块

 path.basename(11)   获取的是地址文件名部分

 path.dirname(11)   返回路径

 altsep

 # 检查路径是否存在 

path.exists('/path/to/file_or_directory')

# 连接路径组件  用分隔符将两个参数进行拼接

path.join('dir1', 'dir2', 'file.txt') 

# 输出：dir1/dir2/file.txt

 path.split(11)      分割

# 判断路径是否为目录 

path.isdir('/path/to/directory') 

# 判断路径是否为文件 

path.isfile('/path/to/file.txt') 

#sys：提供的关于操作python自身解释器的方法，以及变量

 import sys

 sys.argv 返回的是脚本名称   返回的列表可以是多个值

 sys.getdefaultencoding()      获取默认编码               在大多数类Unix系统中，默认的文件系统编码通常是UTF-8，而在Windows系统中，则可能是'mbcs'（Windows ANSI代码页）或'utf-8'

'utf-8'

 getfilesystemencoding()       它会返回文件系统默认使用的编码名称。这个编码名称告诉文件系统默认使用的编码方式，用于解码和编码文件名。

sys.getrecursionlimit(): 这个函数用于获取Python解释器的递归限制，即递归调用的最大深度。默认值通常是1000。

sys.setrecursionlimit(limit): 这个函数用于设置Python解释器的递归限制，即递归调用的最大深度。

 

getrefcount(object): 这个函数用于获取一个对象的引用计数。引用计数是指指向对象的引用数量。当引用计数为0时，对象会被垃圾回收。

引用计数     缺点：无法解决循环引用的问题、内存浪费

每当一个对象被引用时，其引用计数就会增加；而当一个对象的引用被删除或超出作用域时，其引用计数就会减少。当引用计数降为零时，Python的垃圾回收机制会自动回收该对象所占用的内存空

间。

UUID:生成一个不会重复的标识

缺点：检索效率会相应的降低

uuid.uuid4（）

hash相关的模块：

哈希表：   1、结果唯一

                 2、无序性

                 3、单向不可逆

加密算法：对称加密：加密和解密用同一秘钥       Des

                 非对称加密： 采用不同秘钥           rsa

 hashlib                               hmac：专门进行数字加密的模块

1、数字检验

2、数据加密

盐值混淆：盐值混淆是指在密码哈希过程中，将盐值与密码组合起来一起哈希。这样做可以确保相同的密码在不同用户之间即使相同也会得到不同的哈希结果，增加破解难度。

#calender模块：

文件的操作：

 i/o流：input output stream

 输入输出流：广义：指代的是计算机中数据的输入与输出，网络的通信

狭义上：指代的是内存中的输入与输出

磁盘----内存----CPU

内存：最重要的缓存设备

 i/o:

数据的流动方向：（站在内存的角度）

输入流：磁盘中的文件读取到内存当中

输出流：把内存中的数据存储到磁盘上

数据的类型：

字节流（01010二进制文件）：图片、音频、视频等媒体文件

字符流：字符串    读取效率高

操作i/o流是通过函数open（file,mode）

字符流：

r:read    w:write

编码解码一致是至关重要的！

open函数最终返回的是一个文件对象

 f.closed 检查文件是否关闭

 f.close()   #关闭i/o流

 f.readable   #返回是否可读

 f.writable #返回是否可写

 txt = f.read()    #从头读到尾，下次读取时为空，默认情况下读取所有数据（可以传参，表示一次读取多少数据

 print(f.readline())  #按行进行读取

 print(f.readlines())    #把每一行作为一个元素，返回一个列表

 f.flush（）#刷新

 f.write() #往原文件后面写入

f.seek(0) 是一个文件对象（File Object）的方法调用，用于将文件指针（File Pointer）移动到文件的起始位置（偏移量为0）。文件指针表示了文件当前的读写位置，

#with 关键字创建了一个运行时的上下文环境，在这个环境中，文件对象 f 被创建并赋值，然后在代码块执行完毕后，自动关闭文件，释放资源，无论代码块是否发生异常。这样可以确保文件在使用完毕后被正确关闭，避免资源泄漏和其他问题.

序列化：将逻辑上存在的对象，转换为字节，进行传输或保存

反序列化：将字符或字节恢复为原来的数据结构形式

持久化：保存在磁盘中    将瞬时数据（内存中的数据）持久化为持久数据（持久存于数据库中）

反持久化：从磁盘中提取

 python模块

#pickle    用于对象序列化和反序列化的标准模块之一。它可以将 Python 对象转换为字节流，以便存储到文件或在网络上传输，并在需要时将这些字节流重新转换回原始对象。

 improt pickle （用as pi后可以直接pi.open（）,而不用pickle.open（））

 load             pickle.load(open("E:\\chijiuhua.txt","rb"))       反持久化

 loads      pickle.loads()   反序列化

 dump      pickle.dump(dict1,open("E:\\chijiuhua.txt","rb"))        持久化

 dumps      序列化

#json

 json.loads（open（“E：\\1.txt”，“rt”，encoding=“utf-8”））

oop：面向对象编程

面向过程：基本功能模块是函数，它将程序分解为一个个独立的、可重用的函数或过程，这些函数按照顺序调用，从而完成特定任务。在面向过程的编程范式中，数据和方法是分离的，数据由全局变量管理，函数则对数据进行操作。

面向对象：它将数据和操作数据的方法封装在一起，形成一个独立的对象。对象是类的实例，类定义了对象的属性（数据）和方法（行为）。面向对象编程通过定义和交互对象来实现程序功能。

类成员：属性

              方法：在类中的函数

python中创建类的方式：

类的名称采用大驼峰命名法进行区分       UserName（首字母大写）

#class 类名称（object【father1，father2】）：

          username = null

          age = null

          zhuanye = null

          id = null

实例化对象：

对象名 = 类名（）

#   self指向的是实例化出来的对象  类中的方法成员，第一个形参不接受传参，默认指向类实例化出来的对象

 def eat(self):

print(self.id)

__init__ 方法是 Python 类中的一个特殊方法，用于在创建类的实例时进行初始化操作。是构造函数的一种实现方式，在对象创建时自动调用。

面向对象的特征：   封装、继承、多态

1.封装

1）类的成员全部封装在类中

2）为了安全考虑，有些属性和方法不希望被随意访问，因此大多数情况下往往要对对象的属性进行私有化，

     然后提供公开的方法进行访问    get_    set_

python进行成员的私有化：  __属性名          __方法名

私有化的成员在class中可以被访问

_方法名、_变量名：表示私有，不能被其他调用

装饰器：借助该项实现函数重载

函数重载：存在多个函数名相同的函数，但是参数个数或类型不同，会使得在调用时自动调用对应函数

继承：

父类：被继承的一方          超类、基类

子类：继承的一方

子类不能继承父类私有成员

 supper() 是一个指针，指向自己的父类 在类中使用

方法重写：父类中的方法已经不能满足子类的需求，因此，在子类中，重新定义一个与父类方法名相同的方法

              我们把这种情况叫做方法重写（方法覆盖）

python中的类的继承，是支持继承多个类的，只需要用逗号隔开，但不同类还需要supper再次指向

如果son类中，也存在__init__，那么一定要在代码第一行手动调用父类

所有类都是继承object类下来的