import requests
# 根据网络接口请求数据: 通过第三方库requests提供的方法
# 1.获取网络数据
response = requests.get('http://wimg.spriteapp.cn/profile/large/2017/10/05/59d644960c99b_mini.jpg')
print(response)
# 1)获取字符串形式的数据结果
# text = response.text
# print(type(text), text)
# 2)获取二进制数据
data = response.content
print(type(data), data)
with open('img.jpg', 'wb') as f:
f.write(data)
# 3)获取json数据
# message = response.json()
# print(type(message), message)
# print(message['data'])
"""
1.什么是进程
一个正在运行的应用程序就是一个进程。系统会给每个进程分配一个独立的内存区域，用来保存程序运行过程中产生的数据，
当进程结束的时候，这个内存区域会自动销毁
2.什么是线程
进程想要执行任务，就必须要有线程。每个进程默认都有一个线程，这个线程叫主线程；其他的线程叫子线程
程序默认都是在主线程中执行的
一个线程中执行多个任务，任务是串行执行的(一个一个的按顺序执行)
一个进程中如果有多个线程，多线程执行不同任务的时候是并行(同时执行)
3.python中怎么使用多线程
python通过内置的threading模块来提供多线程相关技术;
其中有一个Thread类，这个类的对象就是线程对象
"""
def download(film):
print('开始下载: %s time: %s' % (film, str(datetime.now())))
sleep(15)
print('%s下载完成 time:%s' % (film, str(datetime.now())))
print(threading.current_thread())
# 在主线程中下载两个电影: 一个一个的下载，一个下载完才下载另一个，总耗时两个电影耗时之和
# download('恋恋笔记本')
# download('摔跤吧爸爸')
# 1.直接创建线程类的对象
"""
a.语法:
线程对象 = Thread(target=函数, args=参数) - 创建一个线程对象，并且返回。
b.说明
函数 - function类型的变量; 这个函数的函数体就会在子线程中执行
参数 - 元祖; 参数会传给target对应的函数
"""
import socket
from threading import Thread
"""
1.socket
1)服务器套接字
创建套接字对象(买电话机) -> 绑定ip地址和端口(插电话线) -> 开始监听(安排人等电话) -> 保证服务器一直处于运行状态
-> 接受请求(接电话) -> 发送消息(说)/接受消息(听) -> 关闭连接(挂电话)
2)客户端套接字
创建套接字对象 -> 请求连接服务器(打电话) -> 发送消息/接受消息 -> 关闭连接
2.多线程(很重要)
线程对象 = Thread(target=函数,args=(实参列表))
线程对象.start()
线程对象.join()
"""
class YtThread(Thread):
def __init__(self):
super().__init__()
def run(self):
pass
t1 = YtThread()
t1.start()
import time
from threading import Thread, Lock
from random import randint
"""
多条线程对一个数据进行操作的时候，可能会出现数据安全/混乱问题。解决问题的方案就对公共的数据进行加锁
1.加锁的方法
一个公共数据对应一个锁对象
在获取数据前加锁，数据操作完成后解锁
注意: 加锁后，加锁的部分会串行执行，但是没加锁的代码还是并行的
"""
class Account:
"""银行账号"""
def __init__(self, name, tel):
self.name = name
self.num = '623223147342798347'
self.balance = 1000
self.tel = tel
# 创建锁对象
self.lock = Lock()
def save(self, money):
"""存钱"""
print('开始存钱')
# 加锁
"""
锁对象.acquire(timeout=超时时间)
"""
self.lock.acquire()
balance = self.balance
time.sleep(3)
self.balance = balance + money
print('存钱结束,当前余额:', self.balance)
# 解锁
self.lock.release()
def pay(self, money):
"""取钱"""
print('开始取钱')
self.lock.acquire()
balance = self.balance
time.sleep(3)
if balance >= money:
self.balance = balance - money
else:
print('余额不足')
print('当前余额:', self.balance)
self.lock.release()
acount = Account('余婷', '15300022703')
# acount.save(1000)
# acount.show()
# acount.pay(500)
# acount.show()
t1 = Thread(target=acount.save, args=(1000,))
t2 = Thread(target=acount.pay, args=(500,))
# t2.start()
# t1.start()
#
#
# t1.join()
# t2.join()
# print(acount.balance)
a = 1000
lock_a = Lock()
def add(num):
print('网络请求，获取数据1')
lock_a.acquire()
global a
a1 = a
time.sleep(3)
a = a1 + num
print(a)
lock_a.release()
def sub(num):
print('网络请求，获取数据2')
lock_a.acquire()
global a
a1 = a
time.sleep(3)
a = a1 - num
print(a)
lock_a.release()
t11 = Thread(target=add, args=(10000,))
t22 = Thread(target=sub, args=(100,))
t11.start()
t22.start()
from copy import copy, deepcopy
"""
1.拷贝: 将对象中的内容拷贝一份产生一个新的对象。原对象和新对象的地址不同
列表.copy(), 字典.copy(), 列表[:] --- 浅拷贝
2.浅拷贝和深拷贝
1)浅拷贝
新对象 = copy(对象)
创建新的对象，新对象中的内容和原对象中的内容的地址一样（直接拷贝, 地址也是直接赋值）
2)
新对象 = deepcopy(对象)
创建新的对象，原对象中的内容也会拷贝一份产生新的地址， 最终保存新的地址
（不是直接拷贝，地址不是直接赋值，而是拷贝地址对应的对象产生新的地址）
"""
list1 = [1, 2, [3, 4]]
list2 = copy(list1)
print(list1, list2)
print(id(list1), id(list2))
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return str(self.__dict__)
class Person:
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
self.dog = None
def __repr__(self):
return str(self.__dict__)
p1 = Person('小明', 18, '男')
p1.dog = Dog('大黄', 3)
p2 = deepcopy(p1)
p2.name = '小红'
p2.dog.age = 4
print(p1, p2)
# 浅拷贝和深拷贝
list1 = [1, 2]
list11 = [0, 1, list1]
list22 = copy(list11)
list33 = deepcopy(list11)
list11[2].append(100)
print(list22, list1)
print(list33)
