翼度科技»论坛 编程开发 python 查看内容

python的一些常用简易技术(一)

6

主题

6

帖子

18

积分

新手上路

Rank: 1

积分
18
一、python的一些数据结构
0、字符串:python 字符串是不可变的,意味着一旦字符串被创建,其内容就不能被改变。但Python 中的字符串变量的存在,是因为字符串变量实际上是指向字符串对象的引用,而不是字符串本身。
  1. # 字符串的不可变性质
  2. s = "hello"
  3. s[0] = "H"  # 这会引发 TypeError,因为字符串是不可变的
  4. # 变量的引用
  5. s = "hello"
  6. print(s)  # 输出: hello
  7. # 重新分配变量
  8. s = "world"
  9. print(s)  # 输出: world
  10. # 将字符串中的所有字母转换为大写
  11. s = "hello"
  12. print(s.upper())  # 输出: "HELLO"
  13. # 将字符串中的所有字母转换为小写
  14. s = "HELLO"
  15. print(s.lower())  # 输出: "hello"
  16. # 返回子字符串在字符串中第一次出现的位置(序号)。如果未找到子字符串,则返回 -1
  17. s = "hello world"
  18. print(s.find("world"))  # 输出: 6
  19. print(s.find("Python"))  # 输出: -1
  20. # 返回子字符串在字符串中最后一次出现的位置(序号)。如果未找到子字符串,则返回 -1
  21. s = "hello world world"
  22. print(s.rfind("world"))  # 输出: 12
  23. # 将字符串中的某个子字符串替换为另一个子字符串
  24. s = "hello world"
  25. print(s.replace("world", "Python"))  # 输出: "hello Python"
  26. # 将字符串拆分为列表。默认情况下,按空格拆分
  27. s = "hello world"
  28. print(s.split())  # 输出: ['hello', 'world']
  29. # 按行分割字符串,返回一个包含各行的列表
  30. s = "hello\nworld"
  31. print(s.splitlines())  # 输出: ['hello', 'world']
  32. # 将列表中的字符串连接成一个字符串,连接符是源字符串
  33. words = ["hello", "world"]
  34. print(" ".join(words))  # 输出: "hello world"
  35. # 移除字符串开头和结尾的空白字符
  36. s = "  hello world  "
  37. print(s.strip())  # 输出: "hello world"
  38. # 检查字符串是否只包含字母
  39. s = "hello"
  40. print(s.isalpha())  # 输出: True
  41. s = "hello123"
  42. print(s.isalpha())  # 输出: False
  43. # 检查字符串是否只包含数字
  44. s = "123"
  45. print(s.isdigit())  # 输出: True
  46. s = "123abc"
  47. print(s.isdigit())  # 输出: False
  48. # 检查字符串是否只包含字母和数字
  49. s = "hello123"
  50. print(s.isalnum())  # 输出: True
  51. s = "hello 123"
  52. print(s.isalnum())  # 输出: False
复制代码
1、列表:一种有序的、可变的集合,允许重复元素,接近数组概念。列表的索引,从序号:0开始。
  1. # 创建一个空列表
  2. my_list = []
  3. # 创建一个包含初始元素的列表
  4. my_list = [1, 2, 3, 4]
  5. # 将元素添加到列表的末尾
  6. my_list.append(4)
  7. # 在索引1的位置插入'a'
  8. my_list.insert(1, 'a')
  9. # 将另一个列表的所有元素添加到当前列表的末尾
  10. my_list.extend([4, 5])
  11. # 移除列表中第一个匹配的元素
  12. my_list.remove(2)
  13. # 移除并返回指定位置的元素(默认是最后一个元素)
  14. element = my_list.pop()
  15. print(element)
  16. # 移除列表中的所有元素
  17. my_list.clear()
  18. # 通过索引修改元素
  19. my_list[1] = 'b'
  20. # 几种常用切片
  21. my_list = [1, 2, 3, 4, 5]
  22. print(my_list[1:3])  # 输出: [2, 3](不包括索引3的元素)
  23. print(my_list[:3])  # 输出: [1, 2, 3](从开始到索引3,不包括索引3)
  24. print(my_list[2:])  # 输出: [3, 4, 5](从索引2到末尾)
  25. print(my_list[::2])  # 输出: [1, 3, 5](步长为2)
  26. # 返回第一个匹配元素的索引
  27. index = my_list.index(2)
  28. # 返回指定元素在列表中出现的次数
  29. count = my_list.count(2)
  30. # 对列表进行原地排序。该列表即已经按排序修改过了
  31. my_list.sort()
  32. # 反转列表中的元素
  33. my_list.reverse()
  34. # 浅拷贝
  35. my_list = [1, 2, 3]
  36. new_list = my_list.copy()
  37. print(new_list)  # 输出: [1, 2, 3]<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 = [1, 2, 3, 4, 5]<br>print(min(my_list)) # 输出:1<br>print(max(my_list)) # 输出:5<br>print(sum(my_list)) # 输出:15
复制代码
2、字典:是一种无序的、可变的键值对集合,使用键(key)来存取对应的值(value),字典中的键是唯一的,字典保持插入顺序,但本质上是无序的(python3.7+)。
  1. # 创建空字典<br>my_dict = {}<br><br># 创建字典
  2. my_dict = {"name": "xxx", "age": 25}
  3. # 查找:根据key访问值,get()
  4. 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"})
复制代码
  1. # 删除指定键值对
  2. del my_dict["age"]
  3. # 基础方法
  4. print(my_dict.keys())  # 返回所有键dict_keys(['name', 'age'])
  5. print(my_dict.values())  # 返回所有值dict_keys(['xxx', 25])
  6. print(my_dict.items())  # 返回所有键值对dict_keys([('name', 'xxx'), ('age', 25)])<br><br># setdefault() 方法、fromkeys() 方法
复制代码
 3、集合:一种无序的、可变的不重复元素集合,可以添加或删除元素,且元素没有特定的顺序,元素是唯一的,不重复。
  1. # 创建空集合,或从其他可迭代对象(如列表、元组、字符串)创建集合,或者创建一个空集合
  2. my_set = set()
  3. my_list = [1, 2, 3, 4, 4, 5]
  4. my_set = set(my_list)
  5. my_string = "hello"
  6. my_set = set(my_string)
  7. # 创建带有初始元素的集合,和字典一样都是用大括号
  8. my_set = {1, 2, 3, 4}
  9. # 集合中添加单个元素
  10. my_set.add(5)
  11. # 向集合中添加多个元素,可以是列表、元组、字符串或其他集合。会将其他集合分解成单个不重复元素,添加进去
  12. my_set.update([4, 5])
  13. print(my_set)  # 输出: {1, 2, 3, 4, 5}
  14. my_set.update({6, 7})
  15. print(my_set)  # 输出: {1, 2, 3, 4, 5, 6, 7}
  16. my_set.update("abc")
  17. print(my_set)  # 输出: {1, 2, 3, 4, 5, 6, 7, 'a', 'c', 'b'}
  18. # remove:移除指定元素。如果元素不存在,会引发KeyError
  19. # discard:移除指定元素。如果元素不存在,不会引发异常
  20. # pop:移除并返回集合中的一个随机元素。如果集合为空,会引发 KeyError
  21. # clear:移除所有元素
  22. my_set.remove(2)
  23. my_set.discard(2)
  24. ele = my_set.pop()
  25. my_set.clear()
  26. # 查找:检查元素是否在集合中
  27. print(2 in my_set) # 输出: True
  28. # 判断一个集合是否是另外集合的子集
  29. set1 = {1, 2}
  30. set2 = {1, 2, 3}
  31. print(set1.issubset(set2))  # 输出: True
  32. # 集合计算:union,返回两个集合的并集
  33. set1 = {1, 2, 3}
  34. set2 = {3, 4, 5}
  35. print(set1.union(set2))  # 输出: {1, 2, 3, 4, 5}
复制代码
4、元组:种有序的、不可变的集合,允许重复元素,创建后不能修改,元素按照插入的顺序存储。
  1. # 创建空元组
  2. # 创建带有初始元素的元组
  3. empty_tuple = ()
  4. print(empty_tuple)  # 输出: ()
  5. my_tuple = (1, 2, 3)
  6. print(my_tuple)  # 输出: (1, 2, 3)
  7. # 不使用小括号
  8. my_tuple = 1, 2, 3
  9. print(my_tuple)  # 输出: (1, 2, 3)
  10. # 单元素元组
  11. single_element_tuple = (1,)
  12. print(single_element_tuple)  # 输出: (1,)
  13. # 使用 tuple() 构造函数,接受列表、字符串等数据结构
  14. # 从列表创建元组
  15. my_list = [1, 2, 3]
  16. my_tuple = tuple(my_list)
  17. print(my_tuple)  # 输出: (1, 2, 3)
  18. # 从字符串创建元组
  19. my_string = "hello"
  20. my_tuple = tuple(my_string)
  21. print(my_tuple)  # 输出: ('h', 'e', 'l', 'l', 'o')
  22. # 访问:通过索引访问,正序,倒序
  23. print(my_tuple[0])  
  24. print(my_tuple[-1])
  25. # 访问:通过切片访问
  26. my_tuple = (1, 2, 3, 4, 5)
  27. print(my_tuple[1:3])  # 输出: (2, 3)
  28. print(my_tuple[:2])  # 输出: (1, 2)
  29. print(my_tuple[2:])  # 输出: (3, 4, 5)
  30. print(my_tuple[::2])  # 输出: (1, 3, 5)
  31. # 解包
  32. my_tuple = (1, 2, 3)
  33. a, b, c = my_tuple
  34. print(a, b, c)  # 输出: 1 2 3
  35. # 使用*号解包
  36. my_tuple = (1, 2, 3, 4)
  37. a, *b, c = my_tuple
  38. print(a, b, c)  # 输出: 1 [2, 3] 4
  39. # 元组操作:合并
  40. tuple1 = (1, 2)
  41. tuple2 = (3, 4)
  42. merged_tuple = tuple1 + tuple2
  43. # 查找,使用in
  44. print(2 in my_tuple) # True/False
  45. # 返回指定元素的第一个匹配项的索引,如果元素不存在,会引发 ValueError
  46. my_tuple = (1, 2, 3, 2)
  47. print(my_tuple.index(2))  # 输出: 1
  48. # 计数,返回指定元素在元组中出现的次数
  49. my_tuple = (1, 2, 3, 2)
  50. print(my_tuple.count(2))  # 输出: 2
  51. # len() :返回元组中元素的数量
  52. print(len(my_tuple))
  53. # max() 和 min():返回元组中的最大值和最小值
  54. my_tuple = (1, 2, 3)
  55. print(max(my_tuple))  # 输出: 3
  56. print(min(my_tuple))  # 输出: 1
  57. # sum():返回元组中所有元素的和(元素必须是数值类型)
  58. my_tuple = (1, 2, 3)
  59. print(sum(my_tuple))  # 输出: 6
复制代码
 
二、python多进程:库multiprocessing,在一个Python程序中同时运行多个进程,每个进程都有自己的内存空间。通过multiprocessing模块创建多个进程,每个进程有独立的GIL,可以在多个CPU核心上并行执行,从而克服GIL的限制。
对于python,主进程是程序开始运行时的第一个进程,负责启动和管理所有的子进程。可以使用 if __name__ == '__main__' 识别主进程,或者通过 multiprocessing.current_process().name 获取当前进程的信息(识别主进程、子进程)
demo1:创建2个进程,两个进程几乎同时启动,并各自打印自己的编号,等待2秒后,主进程打印结束消息。这里子进程执行完(阻塞),才会继续走主进程。
  1. import multiprocessing
  2. import time
  3. # 定义一个简单的函数,用于进程执行
  4. def worker(num):
  5.     """线程工作函数"""
  6.     print(f'Worker: {num}')
  7.     time.sleep(2)  # 模拟耗时操作
  8. if __name__ == '__main__':
  9.     # 创建两个进程
  10.     processes = []
  11.     for i in range(2):
  12.         p = multiprocessing.Process(target=worker, args=(i,))
  13.         processes.append(p)
  14.         p.start()
  15.     # 等待所有进程完成
  16.     for p in processes:
  17.         p.join()
  18.     print("All processes are done.")
复制代码
demo2:如果想创建出来的子进程不阻塞我们的主进程,将join语句去掉即可,然后主进程就会执行后面的语句了。异步执行:主进程在启动子进程后,立即继续执行而不等待子进程完成。子进程完成后,会在后台输出其结束消息。
demo3:如果子进程会返回一个value,主进程设计去等待子进程执行完返回value,打印出来。使用 multiprocessing 模块中的 Process 类和 Queue来实现。使用 multiprocessing.Queue 在子进程和主进程之间传递数据。子进程将结果放入队列,主进程从队列中获取结果。
a. 使用 queue.get() 从队列中获取子进程的结果。这将阻塞主进程,直到子进程向队列中放入数据。
b. 使用 p.join() 确保子进程完成执行。
c. 使用 multiprocessing.Queue 在子进程和主进程之间传递数据。子进程将结果放入队列,主进程从队列中获取结果。
  1. import multiprocessing
  2. import time
  3. def worker(queue):
  4.     """子进程工作函数"""
  5.     print(f"Worker process started with PID: {multiprocessing.current_process().pid}")
  6.     time.sleep(10)  # 模拟一个耗时10秒的任务
  7.     result = "Result from worker"
  8.     queue.put(result)
  9.     print("Worker process finished.")
  10. if __name__ == '__main__':
  11.     print(f"Main process PID: {multiprocessing.current_process().pid}")
  12.     # 创建一个Queue,用于子进程向主进程传递数据
  13.     queue = multiprocessing.Queue()
  14.     # 创建子进程
  15.     p = multiprocessing.Process(target=worker, args=(queue,))
  16.     # 启动子进程
  17.     p.start()
  18.     # 主进程继续执行其他任务
  19.     print("Main process is doing some work while waiting for the result from worker process.")
  20.     # 等待子进程完成并获取结果
  21.     result = queue.get()  # 这将阻塞主进程,直到子进程向队列中放入数据
  22.     # 确保子进程完成
  23.     p.join()
  24.     print(f"Main process received result: {result}")
  25.     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】 我们会及时删除侵权内容,谢谢合作!

举报 回复 使用道具