【第一周】

尐T

于 2021-12-26 14:20:47 发布

阅读量61

点赞数

文章标签：其他

本文链接：https://blog.csdn.net/wbt321/article/details/122070987

版权

一、用python完成10道题目

我使用py.CheckiO编程挑战练习

这个网站就更有趣味性一点，做成了游戏挑战的形式来帮助大家学习。

游戏模式就是闯关类型，完成题目，获取积分，一步步解锁新关卡。

遇到不会的题，在这里可以一步步获得提示，更有利于形成一个思路。

这里是编码区。

（1）len()函数的使用

使用len()函数要先将int转成str

(2)求后置0

(3)以相反的顺序返回给定的字符串

(不知道为什么我使用reverse()函数没有成功)

reverse()：

是python中列表的一个内置方法（也就是说，在字典，字符串或者元组中，是没有这个内置方法的），用于列表中数据的反转；
exp：

lista = [1, 2, 3, 4]
lista.reverse()
print(lista)
1
2
3
打印结果：

[4, 3, 2, 1]

其实，lista.reverse() 这一步操作的返回值是一个None，其作用的结果，需要通过打印被作用的列表才可以查看出具体的效果。

reversed()：
而reversed()是python自带的一个方法，准确说，应该是一个类；
关于reversed()官方解释：

reversed(sequence) -> reverse iterator over values of the sequence
Return a reverse iterator

translate it :
reverse（sequence） - >反转迭代器的序列值
返回反向迭代器

也就是说，在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者List,或者next()等方法，获取作用后的值；

下面通过几个案例进行说明：
1.列表的反转：

bb = [1,3,5,7]
print(list(reversed(bb)))
1
2
打印结果：

[7, 5, 3, 1]

2.元组的反转：

aa = (1, 2, 3)
print(tuple(reversed(aa)))
1
2
打印结果：

(3, 2, 1)

3.字符串的反转

ss = "qwer1234"
print(''.join(reversed(ss)))
1
2
join的用法介绍

打印结果：

4321rewq

(4)求前置0

二、Mysql

(1)Python连接MySQL

(2)数据库增删改查

三、TCP协议与UDP协议

TCP:

传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793 [1]

定义。

TCP旨在适应支持多网络应用的分层协议层次结构。连接到不同但互连的计算机通信网络的主计算机中的成对进程之间依靠TCP提供可靠的通信服务。TCP假设它可以从较低级别的协议获得简单的，可能不可靠的数据报服务。原则上，TCP应该能够在从硬线连接到分组交换或电路交换网络的各种通信系统之上操作。

UDP:

Internet 协议集支持一个无连接的传输协议，该协议称为用户数据包协议（UDP，User Datagram Protocol）。UDP 为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据包的方法。RFC 768 [1]

描述了 UDP。

Internet 的传输层有两个主要协议，互为补充。无连接的是 UDP，它除了给应用程序发送数据包功能并允许它们在所需的层次上架构自己的协议之外，几乎没有做什么特别的事情。面向连接的是 TCP，该协议几乎做了所有的事情。

一条视频讲清楚TCP协议与UDP协议-什么是三次握手与四次挥手_哔哩哔哩_bilibiliTCP协议与UDP协议有什么区别？TCP协议是如何保证数据传输的？三次握手、传输确认、四次挥手又是什么？听芝士君简单讲网络4-TCP协议与UDP协议https://www.bilibili.com/video/BV1kV411j7hA?from=search&seid=5542788383302184421&spm_id_from=333.337.0.0

四、base64编码

Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。

Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性，需要解码后才能阅读。

Base64由于以上优点被广泛应用于计算机的各个领域，然而由于输出内容中包括两个以上“符号类”字符（+, /, =)，不同的应用场景又分别研制了Base64的各种“变种”。为统一和规范化Base64的输出，Base62x被视为无符号化的改进版本。

原理到实现 | 一个视频完全掌握base64编码_哔哩哔哩_bilibili第一次以这种方式录视频，希望大家多提建议~9月一共更新了8次视频(含本次)10月希望能稍稍休息休息23333https://www.bilibili.com/video/BV1Wt4y1q7dH?from=search&seid=940035189622974025&spm_id_from=333.337.0.0

五、Threading

(1)add

import threading


def main():
    print(threading.active_count()) # 统计线程个数
    print(threading.enumerate()) # 列举线程
    print(threading.current_thread()) # 当前线程


if __name__ == '__main__':
    main()

(一开始'__main__'打错没发现，找了好久)

import threading

def thread_job():
    print('This is an anded Thread, number is %s' % threading.current_thread())

def main():
    added_thread = threading.Thread(target=thread_job)
    added_thread.start()

if __name__ == '__main__':
    main()

(2)join

import threading
import time


def thread_job():
    print('T1 start\n')
    for i in range(10):
        time.sleep(0.1)
    print('T1 finish\n')


def T2_job():
    print('T2 start\n')
    print('T2 finish\n')


def main():
    added_thread = threading.Thread(target=thread_job, name='T1')
    thread2 = threading.Thread(target=T2_job(), name='T2')
    added_thread.start()
    thread2.start()
    added_thread.join()
    thread2.join()
    print('all done')


if __name__ == '__main__':
    main()

(3)Queue

import threading
from queue import Queue

def job(l,q):
    for i in range(len(l)):
        l[i] = l[i]**2
    q.put(l)

def multithreading():
    q = Queue()
    threads = []
    data = [[1,2,3],[3,4,5],[4,4,4],[5,5,5]]
    for i in range(4):
        t = threading.Thread(target=job,args=(data[i],q))
        t.start()
        threads.append(t)
    for thread in threads:
        thread.join()
    results = []
    for _ in range(4):
        results.append(q.get())
    print(results)

if __name__ == '__main__':
    multithreading()

(4)lock

import threading


def job1():
    global A,lock
    lock.acquire()
    for i in range(10):
        A += 1
        print('job1', A)
    lock.release()

def job2():
    global A,lock
    lock.acquire()
    for i in range(10):
        A += 10
        print('job2', A)
    lock.release()

if __name__ == '__main__':
    lock = threading.Lock()
    A = 0
    t1 = threading.Thread(target=job1())
    t2 = threading.Thread(target=job2())
    t1.start()
    t2.start()
    t1.join()
    t2.join()