AI编程篇-python高级进阶_ai辅助python编程

1. python三大特性

python是一门面向对象的语言，拥有三大特性：
继承：子类继承父类的属性和方法，使得子类拥有父类的属性及方法。
封装：将对象的属性和方法隐藏起来，提供对外公开接口。
多态：同一个函数在不同场景下有不同的表现形式。
1
2
3
4

2.类

1.定义：
1

class Car():
  ...属性和方法....
1
2

2.创建对象(也叫类实例化)
1

对象名 = 类()
1

3.调用方法或属性
1

对象名.方法或属性()
1

4.self关键字,作用：用来指向实例对象本身
1

def func(self):
	self.color = 'red'
1
2

2-1.魔法方法

2-1-1. init()方法：

当创建对象时对自动触发,一般用于初始化
1.无参：
1
2

class Car:
	    def __init__(self):
        self.age = 18
        self.name = '小红'
1
2
3
4

2.有参：
1

#定义：
class Car:
	def __init__(self, name, age):
#调用：
my_car = Car('wc',14)
print(my_car.name,my_car.age)
1
2
3
4
5
6

2-1-2. str()方法 :(必须有return)

默认打印对象时调用
1

class Car:
    def __init__(self):
        self.age = 18
        self.name = '小红'

    def __str__(self):
        return f'{self.age}, {self.name}'

car = Car()
print(car)
1
2
3
4
5
6
7
8
9
10

2-1-3. del()方法

默认删除对象时(调用del删除对象或文件执行结束后)，python解释器会默认调用该方法
1

class Car:
    def __init__(self):
        self.age = 18
        self.name = '小红'

    def __del__(self):
        print('删除删除')

car = Car()
del car
1
2
3
4
5
6
7
8
9
10

2-2.继承

1. 定义格式：

class 子类名(父类):
	pass
#子类可以使用父类中的属性和方法，提高代码复用率
1
2
3

2.多继承

class 子类名(父类1, 父类2, ....)
	pass
# 当一个类有多个父类时，默认使用第一个父类的同名属性和方法，可以使用__mro__或者mro()查看调用的先后顺序：
print(子类名.__mro__)
print(子类名.mro())
1
2
3
4
5

3.重写

重写也叫做覆盖，当子类属性或方法和父类的属性或方法名相同时，子类重写定义这些属性或方法
1

4.调用父类中的方法

1. 父类名.父类方法名()
2. 子类对象.父类方法名()
3. super().父类方法名()
1
2
3

2-3 封装

定义和获取私有属性
1

self.__name
# 外界调用时只能通过定义的get、set方法
def set__name(self, name)
	self.__name = name
def get__name(self)
	return self.__name
1
2
3
4
5
6

2-4 多态

1.多态的条件

1.有继承
2.函数重写
3.父类引用指向子类对象（子类对象传给父类对象调用者）
1
2
3

class Animal(object):
    def speak(self):
        print("animal 嗯嗯 ")
        pass


class Dog(Animal):
    def speak(self):
        print('汪汪汪')


class Cat(Animal):
    def speak(self):
        print('喵喵喵')


# def make_noise(animal):
def make_noise(animal:Animal):
    animal.speak()

if __name__ == '__main__':
    mydog = Dog()
    mycat = Cat()
    animal =  Animal()

    make_noise(mydog)
    make_noise(mycat)
    make_noise(animal)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.小结：

如果说继承是子类可以调用父类的方法的话，多态可以说是父类可以使用子类的方法
1

3.抽象类

抽象类其实也可以叫做接口
抽象类其实就是父类方法的方法体中是pass
1
2

class Animal(object):
	def make_voice(self):
		pass
		
class Dog(Animal):
	def make_voice(self):
		print('汪汪汪')
		
class Cat(Animal):
	def make_voice(self):
		print('喵喵喵')
1
2
3
4
5
6
7
8
9
10
11

2-5 类方法

类方法其实就是类拥有的方法，使用装饰器@classmethod来装饰
格式：
1
2

@classmethod
def 类方法名(cls):
    ...
#调用：
类名.类方法名()  或者对象名.类方法名()
1
2
3
4
5

2-6 静态方法

使用@staticmethod装饰器来装饰的方法，应用场景在方法体固定不变的方法上
1

@staticmethod
def 静态方法名():
    ...
#调用：
类名.类方法名()  或者对象名.类方法名()
1
2
3
4
5

3.深拷贝、浅拷贝

拷贝可以理解为以原对象围殴模板，复制出了一个新对象，指向一个新的内存地址，虽然拷贝后的对象和原对象值一摸一样，但是内存地址指向不同。

可变数据类型：列表、字典、集合
不可变类型：字符串、数值型（int、float）、元组
对于可变数据类型：
	浅拷贝只拷贝第一层，内层依旧指向同一个内存地址
	深拷贝全部拷贝
对于不可变数据类型：
	不管是深拷贝还是浅拷贝，都是全部拷贝，可以理解为都是引用赋值，指向统同一内存空间
1
2
3
4
5
6
7
8
9

4.闭包和装饰器

4-1 函数名的作用

1.函数名存放的是函数所在内存空间的地址
2.函数名()执行的是函数所在内存空间地址中的代码
3.函数名可以像普通变量一样赋值。
1
2
3

4-1 闭包

1.定义：
1

def 外部函数(外部参数):
	def 内部函数(内部参数):
		...
	return 内部函数名
# 调用
对象名 = 外部函数名(外部函数参数)
对象名(内部函数参数)
1
2
3
4
5
6
7

2.闭包的作用： 闭包可以保存函数中的变量，而不会随着调用完函数而被销毁。
3.内部函数构成条件：
1
2

• 有函数嵌套
• 有引用(内部函数引用外部函数的变量)
• 有返回(外部函数要返回内部函数名)
  4.nonlocal关键字：
  nonlocal：声明全局变量，能够让内部函数去修 改外部函数的变量。
  语法：

nonlocal 外部函数变量名
1

5.装饰器

5-1 装饰器的定义

装饰器就是在不改变原有函数的基础上，给原有函数增加额外功能。
1

5-2 装饰器构成条件

1. 有嵌套(函数嵌套)
2. 有引用(内部函数使用了外部函数的变量)
3. 有返回(外部函数返回了内部函数名)
4. 有额外功能(有需要装饰的原有函数增加额外功能)

5-3 语法

def func_out(fn):
	def func_in():
		额外功能
		fn()
	return func_in

@func_out
def fn():
	原函数功能
#调用
fn()
1
2
3
4
5
6
7
8
9
10
11

5-4 当原函数有参数和返回值时

口诀：
	原函数有返回值，那内部函数中也得有原函数返回值
	原函数有参数，则内部函数和内部函数调用的原函数也有参数值
1
2
3

6.网络编程

6-1 客户端开发：

import socket

if __name__ == '__main__':
    # 1.创建客户端套接字对象      socket.AF_INET表示ipv4  socket.SOCK_STREAM表示tcp
    tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2.和服务端套接字建立连接
    tcp_client_socket.connect(("192.168.33.65", 8080))
    # 3.发送数据
    tcp_client_socket.send("nihao".encode(encoding="utf-8"))
    # 4.接收数据 recv阻塞等待数据的到来
    recv_data = tcp_client_socket.recv(1024)
    print(recv_data.decode(encoding="utf-8"))
    # 5.关闭客户端套接字
    tcp_client_socket.close()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6-2 服务端开发

import socket

if __name__ == '__main__':
    # 1.创建服务端套接字对象
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    #端口复用
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 2.绑定ip地址和端口号   如果bind中的ip元素设置为“”，默认为本机ip
    tcp_server_socket.bind(("192.168.33.65", 8889))
    # 3.设置监听   127:代表服务器等待排队链接的最大数量
    tcp_server_socket.listen(128)
    while True:
        # 4.通过accept从linux内核中获取已经建立好的连接
        conn_socket, ip_port = tcp_server_socket.accept()
        print("客户端地址: ", ip_port)
        # 5.接受数据
        recv_data = conn_socket.recv(1024)
        print("接收到的数据: ", recv_data.decode(encoding="GBK"))
        # 6.发送数据
        conn_socket.send("客户端你的数据我收到了".encode(encoding="GBK"))
        # 7.关闭套接字
        conn_socket.close()
    tcp_server_socket.close()
    # 注意 服务器一般不主动关闭连接，若客户端把连接关闭，则服务端才会关闭连接
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7. 多任务

7.1 进程

进程：cpu资源分配的最小单位，一个运行的程序就是一个进程
工作方式： 先创建一个主进程，通过主进程创建子进程
创建：
1
2
3

import multiprocessing
# 函数不带参数:
p1 = multiprocessing.Process(target=函数名)
# 函数带参数：#使用args元组形式传参时，要注意和原函数参数顺序对应
p1 = multiprocessing.Process(target=函数名，args=元组形式或者kwards = 字典形式)
p1.start()	
#注意：若要主进程等待子进程完成
子进程.join()
# 获取当前进程编号：
	1.os.getpid()
	2.multiprocessing.current_process().pid
# 获取父进程编号：
	os.getppid()
1
2
3
4
5
6
7
8
9
10
11
12
13

7.2 线程

线程：cpu调度的基本单位
创建：
1
2

# 1.导包
 import threading
# 2.通过线程类创建线程对象
线程对象 = threading.Thread(target=任务名)
# 3.启动线程执行任务
线程对象.start()
# 注意：若要主进程等待子进程完成
子进程.join()
# 获取当前线程的id:
tid = threading.current_thread()
# 设置守护主线程：
1.创建线程参数daemoin=True
2.线程对象.setDaemon(True)
1
2
3
4
5
6
7
8
9
10
11
12
13

执行顺序：线程之间执行是无序的
多个线程共享全局变量出现数据错误问题：
造成原因：线程1读内存空间数据以后，还没有来得及更新内存空间，结果线程2又读 内存空间，造成两个线程对同一内存空间进行了读写，重复，解决方法：加互斥锁，操作：

# 1.创建锁对象：
lock = threading.Lock()
# 2.上锁：
lock.acquire()
# 3.释放锁：# 若不适当的释放锁，会造成死锁问题
lock.release()

1
2
3
4
5
6
7

7.3 进程和线程的对比

1. 进程是操作系统资源分配的基本单位，线程是cpu调度的基本单位
2. 一个进程默认创建一条线程，线程是依附在进程里的
3. 进程之间不共享全局变量，线程之间共享全局变量，但是要注意资源竞争问题，解决：互斥锁
4. 创建进程的资源开销比创建线程的资源开销大
5. 多进程开发比单进程多线程开发稳定性要强

8. python其他语句

8.1 with语句

语法：

# 无论是否会出现异常，最终都会自动运行文件关闭的操作 f就是上下文管理器
with open('./a.txt', 'w', encoding='utf8') as f :
    f.write('abcdefg')
1
2
3

with语句管理的对象就是上下文管理器。
实现原理：(实现了__enter__和__Exit__方法)
__enter__上文方法：返回一个操作对象
__exit__下文方法：with语句执行完成后自动执行，即使出现异常也会执行。

8.2 生成器推导式

8.2.1 列表推导式

定义：
1

generator = （i * 2 for i in range(5)）
# 迭代下一个元素:
next(generator)
# 遍历
for i in generator:
    print(i)

1
2
3
4
5
6
7

8.2.2 yield关键字

定义：
1

def myGenerator():
    for i in range(5):
        yield i
1
2
3

yield关键字作用：返回后面的数、挂起等待next激活
1