python学习第四周

文件的读取和异常

文件的读写

# 打开文件 --> 判断大小 --> 分配内存 --> 读取文件 --> 关闭文件

def main():
    # open 打开文件,( 路径加文件名, ('r'是读取, 'w'是写, 'a'是增加内容), encoding=(编码格式,'utf-8'))
    # fs = open('c:/Users/china/Desktop/hello.txt', 'r', encoding='utf-8')
    # # content = fs.read()
    # for line in fs:
    # print(line, end='')
    # time.sleep(1)
    # # print(content)
    # 异常处理机制, 如果出错还能继续向下执行,except错误类型, 后面跟异常出现后的代码
    try:
        # ./一个点当前路径, ../两个点上一级路径
        with open('../day3016/abc/hello.txt', 'r', encoding='utf-8') as fs:
            # 读多行
            mylist = fs.readlines()
            print(mylist)
            fs.close()
    except (FileExistsError, IOError):
        print('指定的文件无法打开')
    except FileNotFoundError as e:
        print(e)

    print('程序执行结束')


if __name__ == '__main__':
    main()

把图片转二进制数据, 再写入另外的文件中

# 把图片转二进制数据, 再写入另外的文件中
def main():
    try:
        with open('../day3016/abc/123.jpg', 'rb') as fs1:
            # 读多行
            data = fs1.read()   
            print(data)
        with open('./efg/girl.jpg', 'wb') as fs2:
            fs2.write(data)
    except (FileExistsError, IOError):
        print('指定的文件无法打开')
    except FileNotFoundError as e:
        print(e)

    print('程序执行结束')


if __name__ == '__main__':
    main()

json格式保存文件

# 'json格式保存文件'
import json


def main():
    mylist = [1, 3, [122, 200, 567]]

    mydict = {
        'name': '吕海军',
        'age': 24,
        'haha': '哈哈',
        'car': [
            {'brand': 'Benz'},
            {'brand': 'Audi'}
        ]
    }
    try:
        with open('date.json', 'w', encoding='utf-8') as fs:
            json.dump(mydict, fs)
            # json.dump(mylist, fs)
    except IOError as e:
        print(e)
    print('数据存储完成')


if __name__ == '__main__':
    main()

json格式的文件的读取

# 'json读取文件'
import json


def main():
    # mylist = [1, 3, [122, 200, 567]]

    mydict = {
        'name': '吕海军',
        'age': 24,
        'haha': '哈哈'

    }
    try:
        with open('date.json', 'r', encoding='utf-8') as fs:
            abc = json.load(fs)
            print(abc)
    except IOError as e:
        print(e)
    print('数据存储完成')


if __name__ == '__main__':
    main()

联网下载数据, 从api接口拿取数据

# URL - Uniform Resource Locator 统一资源定位符

# http://api.tianapi.com/meinv/?key=08f74bf93234c387b8e4a342c2b15923&num=1
import requests
import json


def main():
    # response响应
    resp = requests.get('http://api.tianapi.com/meinv/?key=08f74bf93234c387b8e4a342c2b15923&num=1')
    mydict = json.loads(resp.text)
    for tempdict in mydict['newslist']:
        pic_url = tempdict['picUrl']
        resp = requests.get(pic_url)
        filename = pic_url[pic_url.rfind('/') + 1:]
        try:
            with open(filename, 'wb') as fs:
                fs.write(resp.content)
        except IOError as e:
            print(e)


if __name__ == '__main__':
    main()

异常处理

把1到10000的数据分别写入三个txt文件中

# json - JavaScript Object Notation
# http://json.org
from math import sqrt


def is_prime(n):
    assert n > 0
    for factor in range(2, int(sqrt(n)) + 1):
        if n % factor == 0:
            return False
    return True if n != 1 else False


def main():
    filenames = ('a.txt', 'b. txt', 'c.txt')
    fs_list = []
    try:
        # 把可能出状况的代码
        for filename in filenames:
            fs_list.append(open(filename, 'w', encoding='utf-8'))
        for number in range(1, 10000):
            if is_prime(number):
                if number < 100:
                    fs_list[0].write(str(number) + '\n')
                elif number < 1000:
                    fs_list[1].write(str(number) + '\n')
                else:
                    fs_list[2].write(str(number) + '\n')
    except IOError:
        # 如果try中出现了状况就通过except来捕获错误(异常)进行对应的处理
        print('读写文件错误')
    else:
        # 如果没有出状况那么可以把无风险的无风险的代码放到else中执行
        pass
    finally:
        # 不管程序正常还是异常最后这里的代码一定会执行
        # 此处是最好的释放外部资源的位置, 因为这里的代码总是会执行
        for fs in fs_list:
            fs.close()
    print('操作完成')


if __name__ == '__main__':
    main()

正则表达式

正则表达式,替换, 拆分

# 正则表达式
import re


# flags=re.IGNORECASE 设置flags参数可以忽略大小写


def main():
    sentence = '马化腾我操你大爷日你二爷Fuck你姑父'
    pure = re.sub('[操草日]|马化腾|fuck', '*', sentence,
                  flags=re.IGNORECASE)
    print(pure)
    sentence = 'you can you up, no can no bb!'
    mylist = re.split(r'[\s,!]', sentence)
    print(mylist)
    sentence = 'aabacddaab'
    m = re.search(r'a.*?b', sentence)
    print(m)


if __name__ == '__main__':
    main()

多线程,多进程

多进程

# 多进程
from multiprocessing import Process
import time
import os


# process 进程 thread


def main(string):
    print(os.getpid())
    num = 0
    while num < 10:
        print(string, end='', flush=True)
        num += 1


def output():
    print(os.getpid())
    p1 = Process(target=main, args=('ping',))
    p1.start()
    p2 = Process(target=main, args=('pong',))
    p2.start()


if __name__ == '__main__':
    output()

多线程

# 多线程
# 1. 直接创建Thread对象并通过target参数指定线程启动后要执行的任务
# 2. 继承Thread自定义线程 通过重写run方法指定线程启动后执行的任务
from time import sleep
from threading import Thread
import os
num = 0


class PrintThread(Thread):

    def __init__(self, string, count):
        super().__init__()
        self._string = string
        self._count = count

    def run(self):
        for _ in range(self._count):
            print(self._string, end='', flush=True)


def output(string):
    # print(os.getpid())
    global num
    inner_num = 0
    while num < 100:
        print(string, end='', flush=True)
        num += 1
        inner_num += 1
    print('\n%s打印了%d次\n' % (string, inner_num))
        # sleep(0.1)


def main():
    # daemon=True将线程设置为守护线程 - 不值得保留的线程 - 其他线程如果都执行完成了那么守护线程自动结束

    # t1 = Thread(target=output, args=('ping', ))
    # t1.start()
    # t2 = Thread(target=output, args=('pong', ))
    # t2.start()
    PrintThread('Ping', 100).start()
    PrintThread('Pong', 200).start()


if __name__ == '__main__':
    main()

多线程解决临界资源保护问题

"""多线程解决临界资源保护问题"""

import time
from threading import Thread, Lock


class Account(object):

    def __init__(self):
        self._balance = 0
        self._Lock = Lock()

    @property
    def balance(self):
        return self._balance

    def deposit(self, money):
        # 当多个线程同时访问同一个资源的时候,就有可能因为竞争资源导致资源的状态错误
        # 被多个线程访问的资源那我们通常称之为临界资源 对临界资源的访问需要加上保护
        if money > 0:
            try:
                # 加锁
                self._Lock.acquire()
                new_balance = self._balance + money
                time.sleep(0.01)
                self._balance = new_balance
            finally:
                # 释放锁
                self._Lock.release()


class AddmoneyThread(Thread):

    def __init__(self, account):
        super().__init__()
        self._account = account

    def run(self):
        self._account.deposit(1)


def main():
    account = Account()
    tlist = []
    for _ in range(100):
        t = AddmoneyThread(account)
        tlist.append(t)
        t.start()
    for t in tlist:
        t.join()
    print('账户余额: %d元' % account.balance)


if __name__ == '__main__':
    main()

版本控制

git 命令

git branch 查看分支

git branch <分支名> 创建新的分支
git –veision(查看版本号, 确认git安装成功)
git merge <分支名>
[cd xx]切换目录
[mkdir xxx]创建文件夹
git init 初始化一个git仓库
git add . 把所有的文件提交到缓存区
git add 把xx文件提交到缓存区
git status
git commit -m ‘输入改版本的原因’
git remote add origin https://git.coding.net/lvhaijun/python.git 将你的改动推送到所添加的服务器上去
git push origin master 将改动提交到远端仓库

建立分支
创建一个叫做“feature_x”的分支，并切换过去：
git checkout -b feature_x
切换回主分支：
git checkout master
再把新建的分支删掉：
git branch -d feature_x
除非你将分支推送到远端仓库，不然该分支就是 不为他人所见的：
git push origin

更新与合并
要更新你的本地仓库至最新改动，执行：
git pull
以在你的工作目录中 获取（fetch） 并 合并（merge） 远端的改动。
要合并其他分支到你的当前分支（例如 master），执行：
git merge
两种情况下，git 都会尝试去自动合并改动。不幸的是，自动合并并非次次都能成功，并可能导致 冲突（conflicts）。 这时候就需要你修改这些文件来人肉合并这些 冲突（conflicts） 了。改完之后，你需要执行如下命令以将它们标记为合并成功：
git add
在合并改动之前，也可以使用如下命令查看：
git diff
标签
在软件发布时创建标签，是被推荐的。这是个旧有概念，在 SVN 中也有。可以执行如下命令以创建一个叫做 1.0.0 的标签：
git tag 1.0.0 1b2e1d63ff
1b2e1d63ff 是你想要标记的提交 ID 的前 10 位字符。使用如下命令获取提交 ID：
git log
你也可以用该提交 ID 的少一些的前几位，只要它是唯一的。
替换本地改动
假如你做错事（自然，这是不可能的），你可以使用如下命令替换掉本地改动：
git checkout –
此命令会使用 HEAD 中的最新内容替换掉你的工作目录中的文件。已添加到缓存区的改动，以及新文件，都不受影响。
假如你想要丢弃你所有的本地改动与提交，可以到服务器上获取最新的版本并将你本地主分支指向到它：
git fetch origin
git reset –hard origin/master
有用的贴士
内建的图形化 git：
gitk
彩色的 git 输出：
git config color.ui true
显示历史记录时，只显示一行注释信息：
git config format.pretty oneline
交互地添加文件至缓存区：
git add -i

python网络编程

创建套接字

写服务器,发送数据

"""python 的网络编程, 写服务器,发送数据"""
from socket import socket, AF_INET, SOCK_STREAM
from datetime import datetime
from time import sleep


def main():
    # socket(AF_INET, SOCK_STREAM)
    # 创建一个基于TCP协议的套接字对象
    # 因为我们做的是应用级的产品或服务所以可以利用现有的传输服务来实现数据传输
    server = socket()
    # 绑定IP地址(网络上主机的身份标志)和端口(用来区分不同服务的IP地址的扩展)
    server.bind(('10.7.189.93', 6889))
    # 开始监听客户端的连接
    server.listen(512)
    print('服务器已经启动正在监听...')
    while True:
        # 通过accept方法接收客户端的连接
        # accept方法是一个阻塞式方法 如果没有客户端连上来
        # 那么accept方法就会让代码阻塞 直到有客户端连接成功
        # accept方法返回一个元组 元组中的第一个值是代表客户端的对象
        # 元组中的第二个值又是一个元组 其中有客户端的IP地址和客户端的端口
        client, addr = server.accept()
        print(client, addr, '连接成功')
        while True:
            sb = datetime.now()
            client.send('hello'.encode('utf-8'))
            client.send(str(sb).encode('utf-8'))
            sleep(1)
        client.close()


if __name__ == '__main__':
    main()

连接服务器,接收数据

"""连接服务器,接收数据"""
from socket import socket
from threading import Thread


def main():
    class ServerThread2(Thread):

        def run(self):
            data = client.recv(512)
            print(data.decode('utf-8'))

    client = socket()
    client.connect(('10.7.189.93', 6666))
    while True:
        your_word = str(input('输入你的话'))
        client.send(your_word.encode('utf-8'))
        ServerThread2(daemon=True).start()


if __name__ == '__main__':
    main()