Python下

最新推荐文章于 2024-07-25 18:55:58 发布

daimabanyun

最新推荐文章于 2024-07-25 18:55:58 发布

阅读量572

点赞数 16

文章标签： python

本文链接：https://blog.csdn.net/daimabanyun/article/details/138531402

版权

面向对象

面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；继承指的是某个对象可以继承另一个对象的特性，从而快速构建具有相似属性的对象；多态是指同一种行为在不同的对象上具有不同的表现形式，即在不同的情境下，同一个方法可以被不同的对象进行调用。

具有高度封装性、灵活的继承性和强大的多态性，通过使用对象作为程序的基本处理单元，实现了数据和行为的有机结合，可以使程序更加高效、结构清晰，并方便管理和扩展。

类与对象

类是一种抽象的数据类型，它定义了一组属性和方法，描述了一类对象的共同特征和行为。

对象是类的实例化，是具体的数据实体，具有类所定义的属性和方法。

实例化：类是一种封装技术，我们把数据和方法都封装到了类里，如果你想使用数据和方法，那么你需要用类创建出一个实例来，这个过程就叫做实例化

类也称为“类对象”，类的实例也称为“实例对象”。

class关键字定义类的语法格式如下：

class 类名：

类体

要点如下：

1.类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。

2.类体中我们可以定义属性和方法。

3.属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

类

类属性

类属性是从属于**“类对象”**的属性，也称为“类变量”。由于类属性从属于类对象，可以被所有实例对象共享。

类属性的定义方式：

class 类名：类变量名= 初始值

在类中或者类的外面，可以通过：“类名.类变量名”来读写。

例

class Student: company = "hebut" #类属性 count = 0 #类属性 def __init__ (self,name,score): self.name = name #实例属性 self.score = score Student.count = Student.count+1 def say_score(self): #实例方法 print("我的公司是：",Student.company) print(self.name,'的分数是：',self.score) s1 = Student('张三',80) #s1 是实例对象，自动调用 init ()方法 s1.say_score()#我的公司是：hebut 张三的分数是： 80 print('一共创建{0}个 Student 对象'.format(Student.count)) #一共创建 1 个 Student 对象

类方法类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod

def 类方法名(cls [，形参列表]) ：

函数体

要点如下：

1.@classmethod 必须位于方法上面一行

2.第一个 cls 必须有；cls 指的就是“类对象”本身；

3.调用类方法格式：“类名.类方法名(参数列表)”。参数列表中，不需要也不能给 cls 传值。

4.类方法中访问实例属性和实例方法会导致错误

5.子类继承父类方法时，传入 cls 是子类对象，而非父类对象

例

class Student: company='hebut' @classmethod def printCompany(cls): #测试类方法 print(cls.company) Student.printCompany()#hebut

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

1.实例属性一般在__init__ ()方法(魔法方法)中通过如下代码定义：

self.实例属性名 = 初始值

2.在本类的其他实例方法中，也是通过 self 进行访问：

self.实例属性名

3.创建实例对象后，通过实例对象访问：

obj01 = 类名() #创建对象，调用 init ()初始化属性

obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

实例方法实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def 方法名(self [, 形参列表])：

函数体

方法的调用格式如下：

对象.方法名([实参列表])

注

方法的定义和普通函数一模一样，不同的是，方法的第一个参数必须是self，这是python语法规定的。self就表示调用方法的对象自己。
init(self)是个初始化方法，一般常用来定义属性。这样的好处是，在创建完对象之后，能自动调用这个方法。
定义方法时，第一个形参必须是self。
在类的内部，无论是定义属性，还是调用属性，属性名前面要加self ，只有这样才叫属性。

要点：

1.定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。

2.调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。

例：

class Animal:#类

foot = 4#类属性

@classmethod

def pao(cls):#类方法

print("动物可以跑")

def _init__(self, name , pinzhong):

self.name = name#实例属性

self.pz = pinzhong#实例属性

def sleep(self):#实例方法

print("动物可以睡觉")

dog = Animal("小黄","中华田园犬")

print(dog.pz)#中华田园犬

dog.pao()#动物可以跑

dog.sleep()#动物可以睡觉

私有属性私有方法

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：

1.通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。

2.类内部可以访问私有属性(方法)

3.类外部不能直接访问私有属性(方法)

4.类外部可以通过“_类名私有属性(方法)名”访问私有属性(方法)

【注】方法本质上也是属性！只不过是可以通过()执行而已

例

#测试私有属性

class Employee:

def __init__(self,name,age):

self.name=name

self.__age=age#私有属性

e=Employee('关关雎鸠',18)

print(e.name)#关关雎鸠

print(e.age)#报错

#测试私有方法

class Employee:

def __init__(self,name,age):

self.name=name

self.__age=age #私有属性

def __work(self):

print('好好工作，私有方法') #私有方法

e=Employee('关关雎鸠',18)

print(e.name)#关关雎鸠

print(e._Employee__age)#18

e._Employee__work()#好好工作，私有方法

私有属性调用方式一

get set 方法

class Demo:

def __init__(self, name,age):

self.name = name

self.__age = age

def getAge(self):

return self.__age

def setAge(self,age):

self.__age = age

d=Demo(”张三"，18)

print(d.getAge())#18

d setAge(20)

print(d.getAge())#20

方式二

@property 装饰器可以将一个方法的调用方式变成**“属性调用”**。

class Demo:

def __init__(self, name,age):

self.name = name

self.__age = age

@property

def age(self):

return self.__age

@age.setter

def age(self, age) :

self.__age = age

d=Demo(”张三"，18)

print(d.age)#18

d age(20)

print(d.age)#20

静态方法

用装饰器@staticmethod定义，静态方法不接收类或实例参数，无论它是由类的实例还是由类本身调用。

静态方法特征

在类中声明静态方法。
它不能有cls或者self范围。
静态方法不能访问类属性或实例属性。
静态方法可以通过 using 来调用ClassName.MethodName()，也可以通过 using 来调用object.MethodName()。
它可以返回该类的一个对象。

魔法方法

三大特性封装（隐藏）隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。通过“私有属性、私有方法”的方式，实现“封装”。

使用私有变量和方法：在变量或方法名称前加上双下划线“__”即可将其定义为私有的，外部程序无法直接访问。需要注意的是，Python中的私有变量和方法并非完全无法访问，而是通过一定的方式进行访问。
使用属性：Python中的属性是一种特殊的方法，可以用来控制对类的成员变量的访问。通过属性，可以在访问成员变量时进行一些逻辑判断和处理，从而保护数据的完整性和安全性。
使用访问器和修改器：访问器和修改器分别是用来获取和设置私有变量的方法，可以在方法内部进行一些逻辑判断和处理，从而保护数据的完整性和安全性。
使用装饰器：装饰器是Python中一种特殊的语法结构，可以用来修改或扩展函数或类的功能。通过装饰器，可以在类或方法定义时对其进行修饰，从而实现封装的目的。

继承

继承可以让子类具有父类的属性和方法，提高了代码的重用性。

从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

语法

继承的语法格式如下：

class 子类类名(父类)：类体

例：

class A: def __init__ (self, name, age): self.name = name self.age = age def run(self): print("父类的方法") class B(A): pass b= B("张三"，18) b.run()#父类的方法

单继承

在Python中，单继承是指一个子类只能继承一个父类的属性和方法。Python中的类可以通过继承来扩展父类的功能，并添加自己的属性和方法。

下面是一个简单的Python单继承的例子：

class Animal: def __init__(self, name): self.name = name def eat(self): print(self.name + " is eating.") class Dog(Animal): def __init__(self, name, breed): super().__init__(name) self.breed = breed def bark(self): print(self.name + " is barking.") dog = Dog("Tom", "Husky") dog.eat() # 输出"Tom is eating." dog.bark() # 输出"Tom is barking."

这段代码定义了一个Animal类和一个继承自Animal类的Dog类。Animal类有一个构造函数__init__()和一个eat()方法，eat()方法输出动物正在吃东西的信息。Dog类有一个构造函数__init__()和一个bark()方法，bark()方法输出狗正在叫的信息。

在Dog类的构造函数中，使用super()函数调用父类的构造函数，并传递name参数。然后，为Dog类添加一个名为breed的属性。

多继承

多继承是指一个类可以同时继承多个父类的特性和方法。多继承的语法非常简单，只需要在定义类时在类名后面添加括号，括号中写上要继承的所有父类的名称，用逗号隔开即可。

例如，下面的代码定义了一个名为MyClass的类，它同时继承了父类A和B：

class A: def method1(self): print("Method 1 of A called.") class B: def method2(self): print("Method 2 of B called.") class MyClass(A, B): def method3(self): print("Method 3 of MyClass called.") my_object = MyClass() my_object.method1() # 输出"Method 1 of A called." my_object.method2() # 输出"Method 2 of B called." my_object.method3() # 输出"Method 3 of MyClass called."

在这个例子中，我们定义了两个父类A和B，它们分别有一个方法method1和method2。然后，我们定义了一个名为MyClass的类，它同时继承了A和B两个父类，并添加了一个方法method3。

在主程序中，我们创建了一个MyClass对象，并调用了它的三个方法，它们分别输出了不同的信息。

多层继承

在Python中，一个类可以同时继承多个父类，这被称为多重继承。多重继承可以形成多层继承，即一个类继承了另一个类，而另一个类又继承了另一个类，以此类推。

例如，下面的代码定义了一个名为A的父类，一个名为B的子类，和一个名为C的子类，C类同时继承了A和B类：

class A: def method1(self): print("Method 1 of A called.") class B: def method2(self): print("Method 2 of B called.") class C(A, B): def method3(self): print("Method 3 of C called.") my_object = C() my_object.method1() # 输出"Method 1 of A called." my_object.method2() # 输出"Method 2 of B called." my_object.method3() # 输出"Method 3 of C called."

在这个例子中，A类有一个名为method1()的方法，B类有一个名为method2()的方法，C类同时继承了A和B类，并添加了一个名为method3()的方法。在主程序中，我们创建了一个名为my_object的C对象，并调用了它的三个方法，它们分别输出了不同的信息。

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

实现多态的方式主要有两种：

方法重写：方法重写是指在子类中重新定义父类的方法，从而实现对该方法的重载。这种方式可以让子类对父类的方法进行扩展或修改，从而实现多态。

方法重载：方法重载是指在同一类中定义多个同名的方法，但是它们的参数列表不同。这种方式可以让同一个方法名实现不同的功能，从而实现多态。

例如，假设有一个动物类Animal，其中定义了一个speak()方法，不同的动物可以根据自己的特点进行不同的叫声。我们可以定义一个Dog类和一个Cat类继承自Animal类，并且重写speak()方法，使得它们能够发出不同的叫声：

class Animal: def speak(self): pass class Dog(Animal): def speak(self): print("汪汪汪！") class Cat(Animal): def speak(self): print("喵喵喵！")

重写和调用 python重写

在Python中，子类可以重写（覆盖）父类的方法，以实现自己的功能。

重写方法时，需要注意以下几点：

子类的方法名与父类的方法名相同。
子类的方法参数与父类的方法参数相同。
子类的方法返回值类型与父类的方法返回值类型相同或者是父类方法返回值类型的子类型。

例如，下面的代码定义了一个名为Animal的父类和一个名为Dog的子类，子类重写了父类的方法：

class Animal: def make_sound(self): print("The animal makes a sound.") class Dog(Animal): def make_sound(self): print("The dog barks.") my_dog = Dog() my_dog.make_sound() # 输出"The dog barks."

在这个例子中，Animal类有一个名为make_sound()的方法，它输出“动物发出声音”的信息。Dog类继承了Animal类，并重写了make_sound()方法，使其输出“狗叫”的信息。在主程序中，我们创建了一个Dog对象my_dog，并调用了它的make_sound()方法，输出了“狗叫”的信息。

python调用在Python中，调用父类的方法有两种方式：

使用super()函数调用父类的方法。

直接使用父类的类名调用父类的方法。

使用super()函数调用父类的方法是比较常用的方式，它可以自动识别出哪个父类的方法需要被调用。例如：

class Animal: def __init__(self, name): self.name = name def eat(self): print(self.name + " is eating.") class Dog(Animal): def __init__(self, name, breed): super().__init__(name) self.breed = breed def bark(self): print(self.name + " is barking.") my_dog = Dog("Tom", "Husky") my_dog.eat() # 输出"Tom is eating."

在这个例子中，Animal类有一个名为eat()的方法，它输出动物正在吃东西的信息。Dog类继承了Animal类，并使用super()函数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

直接使用父类的类名调用父类的方法也是一种有效的方式。例如：

class Animal: def __init__(self, name): self.name = name def eat(self): print(self.name + " is eating.") class Dog(Animal): def __init__(self, name, breed): Animal.__init__(self, name) self.breed = breed def bark(self): print(self.name + " is barking.") my_dog = Dog("Tom", "Husky") my_dog.eat() # 输出"Tom is eating."

在这个例子中，Dog类的构造函数使用Animal类名和self参数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

super()函数

在Python中，super()函数用于调用父类的方法。使用super()函数调用父类的方法时，可以不使用父类的类名，而是使用super()函数自动识别出需要调用的父类的方法。

super()函数的语法如下：

super([type[, object-or-type]])

其中，type是子类的类型，object-or-type是子类的对象或类型。如果只有一个参数，则默认为子类的类型。

例如，下面的代码定义了一个名为Animal的父类和一个名为Dog的子类，子类使用super()函数调用了父类的方法：

class Animal:

def __init__(self, name):

self.name = name

def eat(self):

print(self.name + " is eating.")

class Dog(Animal):

def __init__(self, name, breed):

super().__init__(name)

self.breed = breed

def bark(self):

print(self.name + " is barking.")

my_dog = Dog("Tom", "Husky")

my_dog.eat() # 输出"Tom is eating."

Animal类有一个名为eat()的方法，它输出动物正在吃东西的信息。Dog类继承了Animal类，并使用super()函数调用了父类的构造函数__init__()，以初始化name属性。在主程序中，我们创建了一个名为my_dog的Dog对象，并调用了它的eat()方法，输出了“Tom is eating.”的信息。

isinstance(b,B)判断b是不是B实例化出来的返回true false

issubclass(b,B)判断b是不是B的子类返回true false

object 根类

object 类是所有类的父类，因此所有的类都有 object 类的属性和方法。

重写__str__()方法

object 有一个 str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str()经常用于 print()方法，帮助我们查看对象的信息。 str__()可以重写。

#重写__str__()方法

class Person:

def __init__(self,name):

self.name=name

s=Person('关关雎鸠')

print(s)

#重写__str__()方法

print(对象名)时候，可以显示一些想要的信息，而不是显示内存空间,str方法中，必须要有return，且return返回的必须是一个字符串。只有一个参数self。

class Person:

def __init__(self,name):

self.name=name

def __str__(self):

return '名字是{0}'.format(self.name)

s=Person('关关雎鸠')

print(s)

反射

程序可以访问、检测和修改'本身状态'或者行为的一种能力。大白话：其实就是通过字符串操作对象的数据和方法

反射的作用

正常使用对象中的方法是要通过变量名去调用的，使用反射可以让用户，通过输入字符串，调用对象中的数据或者方法。

python反射的四个方法

hasattr() 判断对象是否含有字符串对应的属性/方法

getattr() 根据字符串获取对应的变量名或者函数名

setattr() 根据字符串给对象设置数据 (名称空间的名字)

delattr() 根据字符串删除对象对应的数据 (名称空间中的名字)

代码演示 hasattr()

class Dog(): name='123' def printagename(self): print('111') z=Dog(1) print(hasattr(z,Dog))#true

getattr()

class Dog(): name='123' def printagename(self): print('111') #1.获取类中的值 print(getattr(Dog,'name')) #2.获取类中的方法 print(getattr(Dog,'printagename')) #3.调用 a=Dog() getattr(Dog,'printagename')(a) #4.获取对象中的方法 print(getattr(a,'name'))

setattr()

class Dog(): name='123' def printagename(self): print('111') #1.获取类中的值 print(getattr(Dog,'name')) #2.通过反射修改 setattr(Dog,'name','addddd') #3.获取修改后结果 print(getattr(Dog,'name'))

delattr()

class Dog(): name='123' def printagename(self): print('111') #1.获取类中的值 print(getattr(Dog,'name')) #2.通过反射删除 delattr(Dog,'name') #3.获取修改后结果 print(getattr(Dog,'name'))

库管理

python-pip库管理学习

pip 命令： pip 安装包：

python -m pip install SomePackage # 最新版本 python -m pip install SomePackage==1.0.4 # 指定版本 python -m pip install 'SomePackage>=1.0.4' # 最小版本 pip install SomePackage -i 国内镜像源地址 --trusted-host 镜像源域名 #从国内下载，报错加--trusted-host 镜像源域名

pip卸载包：

python -m pip uninstall package_name

从指定文件中安装PIP包

#requirements.txt

pandas==1.0.0

pyspark

python -m pip install -r requirements.txt

将项目用到的PIP包存到指定文件中

pip freeze > r.txt

列出已经安装的包

python -m pip list

包的更新：

python -m pip install package_name --upgrade

卸载pip 安装的所有包

python -m pip freeze > requirements.txt && python -m pip uninstall -r requirements.txt -y

不通过创建requirements.txt 卸载pip安装的包

python -m pip uninstall -y -r <(pip freeze)

检查安装的包是否兼容

python -m pip check

获取已经安装包的信息

python -m pip show package_name

异常管理

当检测到⼀个错误时，解释器就⽆法继续执行了，反而出现了⼀些错误的提示，这就是所谓的" 异常 " 。

例如：以 r ⽅式打开⼀个不存在的⽂件。

open('test.txt', 'r')

python中的异常（try...except...else...finally）

异常的写法异常语法

try: 可能发⽣错误的代码 except: 如果出现异常执⾏的代码示例需求：尝试以 r 模式打开⽂件，如果⽂件不存在，则以 w ⽅式打开。 try: f = open('test.txt', 'r') except: f = open('test.txt', 'w')

捕获指定异常语法：

try: 可能发⽣错误的代码 except 异常类型: 如果捕获到该异常类型执⾏的代码示例代码： try: print(num) except NameError: print('有错误')

注意：

如果尝试执⾏的代码的异常类型和要捕获的异常类型不⼀致，则⽆法捕获异常。

⼀般try下⽅只放⼀⾏尝试执⾏的代码。

捕获多个指定异常当捕获多个异常时，可以把要捕获的异常类型的名字，放到except 后，并使⽤元组的⽅式进⾏书写。

try: print(1/0) except (NameError, ZeroDivisionError): print('有错误')

捕获异常描述信息

try: print(num) except (NameError, ZeroDivisionError) as result: print(result)

捕获所有异常

Exception是所有程序异常类的⽗类。

try: print(num) except Exception as result: print(result)

异常的else

else表示的是如果没有异常要执⾏的代码。

try: print(1) except Exception as result: print(result) else: print('我是else，是没有异常的时候执⾏的代码')

异常的finally

finally表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件。

try: f = open('test.txt', 'r') except Exception as result: f = open('test.txt', 'w') else: print('没有异常，真开⼼') finally: f.close()

自定义异常

在 Python 中，抛出⾃定义异常的语法为 raise 异常类对象。

示例需求：密码⻓度不⾜，则报异常（⽤户输⼊密码，如果输⼊的⻓度不⾜ 3 位，则报错，即抛出⾃定义异常，并捕获该异常）。

#⾃定义异常类，继承Exception class ShortInputError(Exception): def __init__(self, length, min_len): self.length = length self.min_len = min_len # 设置抛出异常的描述信息 def __str__(self): return f'您输⼊的⻓度是{self.length}, 不能少于{self.min_len}个字符' def main(): try: con = input('请输⼊密码：') if len(con) < 3: raise ShortInputError(len(con), 3) except Exception as result: print(result) else: print('密码已经输⼊完成') main()

文件操作

文件打开/创建通过 Python 内置的 open() 函数打开一个文件，然后使用一些相关的方法进行读写操作。open() 函数的一般使用方法为：

file = open(file_name [, access_mode][encoding="utf-8"][, buffering])

其中，file_name 是文件名字符串，access_mode 是打开文件的模式，encoding是编码格式，buffering 是缓冲区大小，是可选参数

在 Python 中，access_mode 是指打开文件时的模式，用于指定文件的操作方式。Python open() 函数可以接受以下常用不同的 access_mode：

'r': 只读模式，打开文件后只能从其中读取数据，不能写入或修改文件。

'w': 写入模式，打开文件后可以写入数据，每次打开一个文件时，文件的内容都会被清空。

'a': 在末尾追加模式，打开文件后可以写入数据，但该数据会被追加到文件的末尾，不会清空文件原有内容。

'x': 排他模式，用于创建并写入一个新文件，如果文件已经存在则会报错。

'b': 二进制模式，以二进制格式进行文件的读写，用于读写非文本文件，例如图像或音频文件。

以上模式可以组合使用，例如 'rb' 表示以二进制格式打开一个文件

文件读取/写入

文件指针 tell()#查看文件指针所在位置seek(0)#将文件指针返回指定位置(0)返回开头

读取步骤：打开文件—读取文件/写入文件—关闭文件(使用"with open…as…:"格式无需用close()关闭)

#方法一：普通写法 file1=open("文件地址","读写模式") file1.write()/file1.read()... file1.close #方法二：使用with关键字写法 with open("文件地址","读写模式") as 变量名: file1.write('')

使用 with open…as…: 格式要注意

冒号不能掉
对文件操作要缩进
无需用close()关闭

读取文件（read()、readline()、readlines()、readable() )

方法描述

read() 一次性读取整个文件内容。

readable() 判断文件是否可读

readline() 每次读取一行内容。内存不够时使用，一般不太用

readlines() 一次性读取整个文件内容，并按行返回到list，方便遍历

例

# 普通写法： file1 = open('F:\\python_test\\scores.txt','r',encoding='utf-8') file_read = file1.read() file1.close() print(file_read) # "with open...as...:"格式 with open('F:\\python_test\\scores.txt','r',encoding='utf-8') as f: file_read =f.read() print(file_read)

写入

写入文件（write()、writelines()、writeable()）

方法	描述
write()	如果打开文件模式中包含 w（写入），那么向文件中写入内容时，会先清空原文件中的内容，然后再写入新的内容。参数必须是字符串类型
writelines()	向文件中写入多行数据时，不会自动给各行添加换行符。参数可以是list(序列)类型
writeable()	判断文件是否可写

#普通写法： file1 = open('F:\\python_test\\abc.txt','w',encoding='utf-8') file1.write('张无忌\n') file1.write('宋青书\n') file1.close() #"with open...as...:"格式 with open ('F:\\python_test\\abc.txt','w',encoding='utf-8') as f: f.write('张无忌\n') f.write('宋青书\n')

内置库

Python中的包

包->模块->类->方法/函数

包是一个分层次的目录结构，它将一组功能相近的模块组织在一起

作用

代码规范

避免模块名称冲突

包与目录的区别

包含__init__.py文件的目录称为包

目录里通常不包含__init__.py文件

包的导入

import 包名.模块名 """ 使用import导入的时候只能跟包名和模块名称使用from导入的时候也可以直接导入到函数名、变量名 from package1.moduleA import a *导全部 from package1.moduleA import * """ import package1.moduleA as ma#导入package1包太长了可以用别名 print(ma.a)

时间戳time

以格林威治时间1970年01月01日00时00分00秒为零点（北京时间 1970 年 01 月 01 日 08 时 00 分 00 秒），开始计算的总秒数。对时间戳时间戳单位最适于做日期运算。1970年之前的日期无法以此表示。太遥远的日期也不行，UNIX和Windows只支持到2038年。

时间戳通过 time.time() 来获取

import time print(time.time()) #获取当前时间戳1682237692.9241743秒 time.sleep(3) #代码暂停执行3秒 t=time.strftime("%Y/%m/%d %H:%M:%S") #可转化指定时间 print(t) #格式化显示转换时间2024/04/15 10:05:21

随机数random

用于生成随机数。示例代码：

import random random_number = random.randint(1, 10)#生成1到10的随机整数 r=random.random()#生成0到1的随机小数 print(random_number)#2 print(r)#0.1649684351684

os 模块是python系统编程的操作模块，提供了非常丰富的功能去处理文件和目录。

import os print(os.path.exists(". /bao/import_demo1.py"))#判断路径是否存在 print(os.path.isfile("./bao/import_demo.py"))#判断是否是文件 print(os.path.dirname(__file__))#返回当前文件所在上一级路径可嵌套 print(__file__)#返回当前文件所在路径

json

用于处理JSON数据的编码和解码。

import json data = {'name': 'John', 'age': 30} s = json.dumps(data)#字典转成字符串 print(type(s))#<class 'str'> print(s)#{"name": "John", "age": 30} d = json.loads(s)#字符串转成JSON字典 print(type(d))#<class 'dict'> print(d)#{'name': 'John', 'age': 30}

日志logging 日志的级别

级别从低到高

级别何时使用

DEBUG 调试信息，细节信息，仅当诊断问题时使用。

INFO 调试信息正常运行信息，确认程序按预期运行。

WARNING 警告，程序仍在工作，但可能有错误发生，表明有已经或者即将发生的意外（例如：磁盘空间不足），程序仍然按照预期进行。

ERROR 严重错误，程序某些功能不能正常执行。

CRITICAL 严重的错误，表明程序已经不能继续执行。

日志模块常用函数

logging.debug(msg,*args,**kwargs) #创建一条严重级别为DEBUG的日志记录 logging.info(msg,*args,**kwargs) #创建一条严重级别为INFO的日志记录 logging.warning(msg,*args,**kwargs)#创建一条严重级别为WARNING的日志记录 logging.error(msg,*args,**kwargs)#创建一条严重级别为ERROR的日志记录 logging.critical(msg,*args,**kwargs)#创建一条严重级别为CRITICAL的日志记录 logging.log(level,*args,**kwargs)#创建一条严重级别为Level的日志记录 logging.basicConfig(**kwargs)#对 root logger进行一次性配置

注：logging默认日志级别是warning。根据定义的级别，打印当前级别及以上级别的日志，比如：定义的是warning的话，则会打印warning及其以上级别的日志，即warning、error、critical级别。

basicConfig 一定要定义在代码最前面，因为basiConfig只执行一次，并且没有累加的效果。如果设置再后面，只对basicConfig之后的代码生效，之前的无效。

使用logging.basicConfig()中的filename参数来确定日志文件的名称和日志保存的位置。

logging.basicConfig(filename="example.log",level=logging.DEBUG)

日志组件

Loggers:记录器，提供应用程序代码能够直接使用的接口

Handlers:处理器，将记录器产生的日志发送目的地

Filters:过滤器，提供更好的粒度控制，决定哪些日志会被输出

Formatters:格式化器，设置日志内容的组成结构和消息字段

封装日志公共模块

例：封装日志公共模块后，更加方便代码开发与调用。

import logging import os #封装一个记录器 def get_logger(): # 定义了记录器 logger = logging.getLogger(os.path.basename(__file__)) logger.setLevel(logging.DEBUG)#设置打印等级 # 定义了一个处理器 sh = logging.StreamHandler()#终端处理器将日志信息打印到终端 ch = logging.FileHandler(filename='mylog.log', encoding="utf-8")#文件处理器 ch.setLevel(logging.DEBUG) sh.setLevel(logging.DEBUG) # 定义了一个格式器 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 将格式器加入处理器中 ch.setFormatter(formatter) sh.setFormatter(formatter) # 将处理器加入记录器中 logger.addHandler(ch) logger.addHandler(sh) return logger #封装一个info级别方法 def log_info(message): logger.info (message) #声明一个get_logger对象 logger=get_logger() #使用封装的方法输入info级别日志 log_info('info message') logger.debug('debug message') logger.warning('warn message') logger.error('error message') logger.critical('critical message') """ 日志文件中输出内容： 2022-09-09 13:57:33,066 - demo.py - INFO - info message 2022-09-09 13:57:33,067 - demo.py - DEBUG - debug message 2022-09-09 13:57:33,067 - demo.py - WARNING - warn message 2022-09-09 13:57:33,068 - demo.py - ERROR - error message 2022-09-09 13:57:33,069 - demo.py - CRITICAL - critical message """

第三方库

pymysql

Python操作MySQL数据库

pip install pymysql #安装

使用

import pymysql from pymysql.cursor import DictCursor con = pymysql.connect(#连接数据库 host="192.168.204.128",#数据库主机地址 port=3306,#数据库端口号 user="root",#数据库用户名 password="123456"，#数据库密码 db="test_db",#哪一个数据库 cursorclass=DictCursor#改为列表格式显示结果 ) cursor = con.cursor()#获取游标，光标 sql = "select * from student; "#sql查询语句 crsor.execute(sql)#执行 res = cursor.fetchall()#获取全部结果 res = cursor.fetchone()#获取第一行结果 res = cursor.fetchmany(2)#获取指定行结果2行 print(res) sql = """ insert into student(name,age, sex) values("赵六"，22，"男") """#sql插入语句 crsor.execute(sql)#执行 con.commit#提交相当于navicat对号 con.close()#关闭连接

Redis

操作redis数据库

pip install redis #安装

使用

import redis config = (#连接数据库 host="127.0.0.1",#数据库主机地址可变 port=3306,#数据库端口号 password="123456"，#数据库密码 #哪一个数据库默认0#db=" ", ) pool = redis.ConnectionPool(**sconfig)#redis连接池将字典解包到这 con = redis.Redis(connection_pool=pool)#放到redis连接方法里 r = con.keys("*")#所有的key print(r) r = con.get("name")#指定的key print(str(r, encoding="utf-8"))#encoding="utf-8"强转为字符串格式

jsonpath

import json, jsonpath content = ''' { "store": { "book": [ { "category": "reference", "author": "Nigel Rees", "title": "Sayings of the Century", "price": 8.95 }, { "category": "fiction", "author": "Evelyn Waugh", "title": "Sword of Honour", "price": 12.99 }, { "category": "fiction", "author": "Herman Melville", "title": "Moby Dick", "isbn": "0-553-21311-3", "price": 8.99 }, { "category": "fiction", "author": "J. R. R. Tolkien", "title": "The Lord of the Rings", "isbn": "0-395-19395-8", "price": 22.99 } ], "bicycle": { "color": "red", "price": 19.95 } } } ''' obj = json.loads(content)####只能取不能修改 jsonpath.jsonpath #取所有书的作者 authors = jsonpath.jsonpath(obj, "$.store.book[*].author") print(authors) #取所有的作者 authors = jsonpath.jsonpath(obj, "$..author") print(authors) #取store下所有的子节点 staff = jsonpath.jsonpath(obj, "$.store.*") print(staff) #取store下所有的价格，包括书、自行车的价格 prices = jsonpath.jsonpath(obj, "$.store..price") print(prices) #取第一本书的价格 first_book = jsonpath.jsonpath(obj, "$..book[0]") print(first_book) #最后一本书 last_book = jsonpath.jsonpath(obj, "$..book[(@.length-1)]") print(last_book) #前两本书 first_two_books = jsonpath.jsonpath(obj, "$..book[0,1]") print(first_two_books) #前两本书的另一种取值方法 first_two_books = jsonpath.jsonpath(obj, "$..book[:2]") print(first_two_books) #所有书中有isbn属性的节点 books_contains_isbn = jsonpath.jsonpath(obj, "$..book[?(@.isbn)]") print(books_contains_isbn) #价格小于10的书 books_low_price = jsonpath.jsonpath(obj, "$..book[?(@.price<10)]") print(books_low_price) #作者是Nigel Rees的书 books_nigel_rees = jsonpath.jsonpath(obj, "$..book[?(@.author=='Nigel Rees')]") print(books_nigel_rees) from jsonpath_ng import parse b= parse("$..book[0].price")#取地址 b.update(obj，111)#修改内容 print(obj)

Zmail邮件

import zmail mail_content = { #邮件内容 "subject":"这是邮件标题", "content_text":"这是邮件的内容",#文本文件 "content_html":["<div style='color: red'>这是html内容</div>"],#html文件 "attachments":r"E:\beiyong\xz_11\r.txt"#附件，地址 } server = zmail.server("发送账号","EWFIWGOKFHWKWIKK")#发送账号，授权码 server.send_mail([ "收件邮箱" ,"shoujian2","shoujian3",...], mail_content)#收件邮箱,邮件内容，抄送人（可写可不写）

openpyxl操作表格

import openpyxl #写入创建 wk = openpyxl.Workbook()#创建一个工作表.xlsx文件 sheet = wk.active# 实例化工作表 sheet.cell(1,1).value = "username"#往第一行第一列写入数据 sheet.cell(1,2).value = "password"#往第一行第二列写入数据 wk.save ("userinfo.xlsx")#保存在哪路径 wk = openpyxl.load_workbook(r"E:\beiyonglxz_11\userinfo.xlsx")#打开工作表.xlsx文件 sheet = wk[ "Sheet" ]#选中哪一个Sheet页名 sheet.title="num1"#修改Sheet页名为num1 wk.create_sheet(title = 'Sheet1', indx=0) # 创建工作表Sheet1indx在哪个位置不写默认末尾 sheet.append([ "zhangsan"，19])#插入一行数据 sheet["A3"] = "lisi"#单元格插入数据 sheet["B3"] = "22" wk.save("userinfo.xlsx") #读取 wk = openpyxl.load_workbook(r"E: \beiyonglxz_11(userinfo.xlsx") sheet = wk.active value = sheet.cell(1,1).value#读取第一行第一列数据 print(value) for i in sheet.values:#方式二可迭代以元组形式输出 print(i) print(sheet.max_column)#获取最大列数 print(sheet.max_row)#获取最大行数 print(wk.sheetnames)#获取所有工作表名

pyyaml

YAML 是一种文本格式，通常用于配置文件和数据序列化。Python 中可以使用 PyYAML 库来读写 YAML 文件

#YAML文件

name: John

age: 30

languages:

-Python

-Java

-C++

上面的 YAML 文件定义了一个名为 John，年龄为 30 岁，会 Python、Java 和 C++ 三种编程语言的对象。可以嵌套

读取 YAML 文件

使用 PyYAML 库的 load 函数来读取 YAML 文件，例如：

import yaml with open('example.yaml', 'r') as f: data = yaml.safe_load(f) print(data)

上面的代码中，首先使用 open 函数打开 YAML 文件，然后使用 yaml.load 函数将文件内容加载到 data 变量中。最后打印 data 变量的值。

输出结果为：

{'name': 'John', 'age': 30, 'languages': ['Python', 'Java', 'C++']}

写入 YAML 文件

import yaml data = { 'name': 'John', 'age': 30, 'languages': ['Python', 'Java', 'C++'] } with open('example2.yaml', 'w') as f: yaml.dump(data, f) f.truncate()#清空yml文件内容