python的一些常用简易技术（一）
一、python的一些数据结构0、字符串：python 字符串是不可变的，意味着一旦字符串被创建，其内容就不能被改变。但Python 中的字符串变量的存在，是因为字符串变量实际上是指向字符串对象的引用，而不是字符串本身。
# 字符串的不可变性质
s = "hello"
s = "H"# 这会引发 TypeError，因为字符串是不可变的
# 变量的引用
s = "hello"
print(s)# 输出: hello
# 重新分配变量
s = "world"
print(s)# 输出: world
# 将字符串中的所有字母转换为大写
s = "hello"
print(s.upper())# 输出: "HELLO"
# 将字符串中的所有字母转换为小写
s = "HELLO"
print(s.lower())# 输出: "hello"
# 返回子字符串在字符串中第一次出现的位置（序号）。如果未找到子字符串，则返回 -1
s = "hello world"
print(s.find("world"))# 输出: 6
print(s.find("Python"))# 输出: -1
# 返回子字符串在字符串中最后一次出现的位置（序号）。如果未找到子字符串，则返回 -1
s = "hello world world"
print(s.rfind("world"))# 输出: 12
# 将字符串中的某个子字符串替换为另一个子字符串
s = "hello world"
print(s.replace("world", "Python"))# 输出: "hello Python"
# 将字符串拆分为列表。默认情况下，按空格拆分
s = "hello world"
print(s.split())# 输出: ['hello', 'world']
# 按行分割字符串，返回一个包含各行的列表
s = "hello\nworld"
print(s.splitlines())# 输出: ['hello', 'world']
# 将列表中的字符串连接成一个字符串，连接符是源字符串
words = ["hello", "world"]
print(" ".join(words))# 输出: "hello world"
# 移除字符串开头和结尾的空白字符
s = "hello world"
print(s.strip())# 输出: "hello world"
# 检查字符串是否只包含字母
s = "hello"
print(s.isalpha())# 输出: True
s = "hello123"
print(s.isalpha())# 输出: False
# 检查字符串是否只包含数字
s = "123"
print(s.isdigit())# 输出: True
s = "123abc"
print(s.isdigit())# 输出: False
# 检查字符串是否只包含字母和数字
s = "hello123"
print(s.isalnum())# 输出: True
s = "hello 123"
print(s.isalnum())# 输出: False1、列表：一种有序的、可变的集合，允许重复元素，接近数组概念。列表的索引，从序号：0开始。
# 创建一个空列表
my_list = []
# 创建一个包含初始元素的列表
my_list =
# 将元素添加到列表的末尾
my_list.append(4)
# 在索引1的位置插入'a'
my_list.insert(1, 'a')
# 将另一个列表的所有元素添加到当前列表的末尾
my_list.extend()
# 移除列表中第一个匹配的元素
my_list.remove(2)
# 移除并返回指定位置的元素（默认是最后一个元素）
element = my_list.pop()
print(element)
# 移除列表中的所有元素
my_list.clear()
# 通过索引修改元素
my_list = 'b'
# 几种常用切片
my_list =
print(my_list)# 输出: （不包括索引3的元素）
print(my_list[:3])# 输出: （从开始到索引3，不包括索引3）
print(my_list)# 输出: （从索引2到末尾）
print(my_list[::2])# 输出: （步长为2）
# 返回第一个匹配元素的索引
index = my_list.index(2)
# 返回指定元素在列表中出现的次数
count = my_list.count(2)
# 对列表进行原地排序。该列表即已经按排序修改过了
my_list.sort()
# 反转列表中的元素
my_list.reverse()
# 浅拷贝
my_list =
new_list = my_list.copy()
print(new_list)# 输出: <br><br># join方法：将列表中的字符串连接成一个字符串。该方法通常用于处理字符串列表<br>words = ["hello", "world"] sentence = " ".join(words) <br>print(sentence) # 输出: "hello world"<br><br># len：返回列表元素数量<br>print(len(my_list))<br><br># min()和max()函数分别返回列表中的最小值和最大值，sum()函数返回列表中的所有元素和（数值型）<br>my_list = <br>print(min(my_list)) # 输出：1<br>print(max(my_list)) # 输出：5<br>print(sum(my_list)) # 输出：152、字典：是一种无序的、可变的键值对集合，使用键（key）来存取对应的值（value），字典中的键是唯一的，字典保持插入顺序，但本质上是无序的（python3.7+）。
# 创建空字典<br>my_dict = {}<br><br># 创建字典
my_dict = {"name": "xxx", "age": 25}
# 查找：根据key访问值，get()
print(my_dict["name"])<br>print(mydict.get("name", "default name"))<br><br># 新增、修改：如果没有这个键值对则是新增，如果有，则修改为当前设定值<br>my_dict["age"] = 26<br><br><em># 通过update增加键值对，以及修改</em><br>my_dict.update({"age": 25, "city": "New York"})# 删除指定键值对
del my_dict["age"]
# 基础方法
print(my_dict.keys())# 返回所有键dict_keys(['name', 'age'])
print(my_dict.values())# 返回所有值dict_keys(['xxx', 25])
print(my_dict.items())# 返回所有键值对dict_keys([('name', 'xxx'), ('age', 25)])<br><br># setdefault() 方法、fromkeys() 方法 3、集合：一种无序的、可变的不重复元素集合，可以添加或删除元素，且元素没有特定的顺序，元素是唯一的，不重复。
# 创建空集合，或从其他可迭代对象（如列表、元组、字符串）创建集合，或者创建一个空集合
my_set = set()
my_list =
my_set = set(my_list)
my_string = "hello"
my_set = set(my_string)
# 创建带有初始元素的集合，和字典一样都是用大括号
my_set = {1, 2, 3, 4}
# 集合中添加单个元素
my_set.add(5)
# 向集合中添加多个元素，可以是列表、元组、字符串或其他集合。会将其他集合分解成单个不重复元素，添加进去
my_set.update()
print(my_set)# 输出: {1, 2, 3, 4, 5}
my_set.update({6, 7})
print(my_set)# 输出: {1, 2, 3, 4, 5, 6, 7}
my_set.update("abc")
print(my_set)# 输出: {1, 2, 3, 4, 5, 6, 7, 'a', 'c', 'b'}
# remove：移除指定元素。如果元素不存在，会引发KeyError
# discard：移除指定元素。如果元素不存在，不会引发异常
# pop：移除并返回集合中的一个随机元素。如果集合为空，会引发 KeyError
# clear：移除所有元素
my_set.remove(2)
my_set.discard(2)
ele = my_set.pop()
my_set.clear()
# 查找：检查元素是否在集合中
print(2 in my_set) # 输出: True
# 判断一个集合是否是另外集合的子集
set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2))# 输出: True
# 集合计算：union，返回两个集合的并集
set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))# 输出: {1, 2, 3, 4, 5}4、元组：种有序的、不可变的集合，允许重复元素，创建后不能修改，元素按照插入的顺序存储。
# 创建空元组
# 创建带有初始元素的元组
empty_tuple = ()
print(empty_tuple)# 输出: ()
my_tuple = (1, 2, 3)
print(my_tuple)# 输出: (1, 2, 3)
# 不使用小括号
my_tuple = 1, 2, 3
print(my_tuple)# 输出: (1, 2, 3)
# 单元素元组
single_element_tuple = (1,)
print(single_element_tuple)# 输出: (1,)
# 使用 tuple() 构造函数，接受列表、字符串等数据结构
# 从列表创建元组
my_list =
my_tuple = tuple(my_list)
print(my_tuple)# 输出: (1, 2, 3)
# 从字符串创建元组
my_string = "hello"
my_tuple = tuple(my_string)
print(my_tuple)# 输出: ('h', 'e', 'l', 'l', 'o')
# 访问：通过索引访问，正序，倒序
print(my_tuple)
print(my_tuple[-1])
# 访问：通过切片访问
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)# 输出: (2, 3)
print(my_tuple[:2])# 输出: (1, 2)
print(my_tuple)# 输出: (3, 4, 5)
print(my_tuple[::2])# 输出: (1, 3, 5)
# 解包
my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)# 输出: 1 2 3
# 使用*号解包
my_tuple = (1, 2, 3, 4)
a, *b, c = my_tuple
print(a, b, c)# 输出: 1 4
# 元组操作：合并
tuple1 = (1, 2)
tuple2 = (3, 4)
merged_tuple = tuple1 + tuple2
# 查找，使用in
print(2 in my_tuple) # True/False
# 返回指定元素的第一个匹配项的索引，如果元素不存在，会引发 ValueError
my_tuple = (1, 2, 3, 2)
print(my_tuple.index(2))# 输出: 1
# 计数，返回指定元素在元组中出现的次数
my_tuple = (1, 2, 3, 2)
print(my_tuple.count(2))# 输出: 2
# len() ：返回元组中元素的数量
print(len(my_tuple))
# max() 和 min()：返回元组中的最大值和最小值
my_tuple = (1, 2, 3)
print(max(my_tuple))# 输出: 3
print(min(my_tuple))# 输出: 1
# sum()：返回元组中所有元素的和（元素必须是数值类型）
my_tuple = (1, 2, 3)
print(sum(my_tuple))# 输出: 6
二、python多进程：库multiprocessing，在一个Python程序中同时运行多个进程，每个进程都有自己的内存空间。通过multiprocessing模块创建多个进程，每个进程有独立的GIL，可以在多个CPU核心上并行执行，从而克服GIL的限制。
对于python，主进程是程序开始运行时的第一个进程，负责启动和管理所有的子进程。可以使用 if __name__ == '__main__' 识别主进程，或者通过 multiprocessing.current_process().name 获取当前进程的信息（识别主进程、子进程）
demo1：创建2个进程，两个进程几乎同时启动，并各自打印自己的编号，等待2秒后，主进程打印结束消息。这里子进程执行完（阻塞），才会继续走主进程。
import multiprocessing
import time
# 定义一个简单的函数，用于进程执行
def worker(num):
"""线程工作函数"""
print(f'Worker: {num}')
time.sleep(2)# 模拟耗时操作
if __name__ == '__main__':
# 创建两个进程
processes = []
for i in range(2):
p = multiprocessing.Process(target=worker, args=(i,))
processes.append(p)
p.start()
# 等待所有进程完成
for p in processes:
p.join()
print("All processes are done.")demo2：如果想创建出来的子进程不阻塞我们的主进程，将join语句去掉即可，然后主进程就会执行后面的语句了。异步执行：主进程在启动子进程后，立即继续执行而不等待子进程完成。子进程完成后，会在后台输出其结束消息。
demo3：如果子进程会返回一个value，主进程设计去等待子进程执行完返回value，打印出来。使用 multiprocessing 模块中的 Process 类和 Queue来实现。使用 multiprocessing.Queue 在子进程和主进程之间传递数据。子进程将结果放入队列，主进程从队列中获取结果。
a. 使用 queue.get() 从队列中获取子进程的结果。这将阻塞主进程，直到子进程向队列中放入数据。
b. 使用 p.join() 确保子进程完成执行。
c. 使用 multiprocessing.Queue 在子进程和主进程之间传递数据。子进程将结果放入队列，主进程从队列中获取结果。
import multiprocessing
import time
def worker(queue):
"""子进程工作函数"""
print(f"Worker process started with PID: {multiprocessing.current_process().pid}")
time.sleep(10)# 模拟一个耗时10秒的任务
result = "Result from worker"
queue.put(result)
print("Worker process finished.")
if __name__ == '__main__':
print(f"Main process PID: {multiprocessing.current_process().pid}")
# 创建一个Queue，用于子进程向主进程传递数据
queue = multiprocessing.Queue()
# 创建子进程
p = multiprocessing.Process(target=worker, args=(queue,))
# 启动子进程
p.start()
# 主进程继续执行其他任务
print("Main process is doing some work while waiting for the result from worker process.")
# 等待子进程完成并获取结果
result = queue.get()# 这将阻塞主进程，直到子进程向队列中放入数据
# 确保子进程完成
p.join()
print(f"Main process received result: {result}")
print("Main process has finished.")tips1：对于python多进程能够在单核机器上运行，但是它们不会真正并行执行，因为单核机器一次只能执行一个进程。操作系统会通过进程切换（时间片轮转）来实现“并发”执行。每个进程在短时间内运行一段时间，然后操作系统会暂停该进程并切换到下一个进程，如此循环，从而给人一种多个进程同时运行的错觉。
tips2：全局解释器锁（GIL）：Python中的GIL限制了在同一时间只有一个线程可以执行Python字节码，多线程在CPU密集型任务中无法充分利用多核CPU的优势。
三、python多线程
四、python异步
五、python常用的并发
六、python模拟发http请求
七、python直连mysql
八、python连redis
九、python操作etcd
十、pytest的一些应用
来源:https://www.cnblogs.com/xiaojp65536/p/18306375
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！
页:
[1]