python

安装配置

安装相关

python

1.windows 版本的 下载路径 https://www.python.org/downloads/windows/

pycharm

1.安装后 pycharm 的路径 C:\Program Files\JetBrains\PyCharm 2022.3.1\bin
2.pycharm 的 破解方法 https://www.exception.site/article/1702
3.破解文件在 chrome tomorrow\python\pycharm_steup\破解pycharm

配置相关

pycharm

1.配置 不同的 虚拟 python 解释器
	1.点设置 project 下面  python Interpreter
	2.点下来箭头 点 show all 点 + 号 选 add local interpreter
	3.location 表示 虚拟的位置 base interpreter 表示你要选择的 python 的版本
	4.可以 增加 删除 修改 过滤 修改可以修改 虚拟环境的名字 只是名字而已 和 路径 解释器 本身版本无关

基本操作

pycharm

pip基操
	pip list
	pip install requests
	pip install -r requirements.txt 
	pip freeze > requirements.txt # 导出依赖
	pip uninstall requests
	pip install –upgrade requests==2.1.0 
	pip install scrapy -i https://pypi.tuna.tsinghua.edu.cn/simple   #指定源
	pip --version # 查看版本
常见的安装源:
	https://pypi.tuna.tsinghua.edu.cn/simple # 清华
	https://mirrors.aliyun.com/pypi/simple/  # 阿里
	https://mirrors.163.com/pypi/simple/     # 网易
	https://pypi.douban.com/simple/          # 豆瓣
	https://mirror.baidu.com/pypi/simple/    # 百度
	https://pypi.mirrors.ustc.edu.cn/simple/  # 中科大
	https://mirrors.huaweicloud.com/repository/pypi/simple/ # 华为
	https://mirrors.cloud.tencent.com/pypi/simple/ # 腾讯
快捷键：
	格式化代码："Ctrl+Alt+L"
	注释代码："Ctrl+/"
	复制当前行或选定的代码块："Ctrl+D"
	剪切当前行或选定的代码块："Ctrl+X"
	粘贴剪贴板内容："Ctrl+V"
	撤销上一步操作："Ctrl+Z"
	重做上一步操作："Ctrl+Shift+Z"
	查找文件："Ctrl+Shift+N"
	查找类、方法或变量："Ctrl+N"
	在文件中查找文本："Ctrl+F"
	在文件中替换："Ctrl+R"
	在整个项目中查找文本："Ctrl+Shift+F"
	跳转到定义："Ctrl+左键单击"
	显示参数信息：在函数或方法后面输入"("并按下"Ctrl+P"
	运行单元测试：在测试方法上点击右键，然后选择"Run"或按下快捷键"Ctrl+Shift+F10"
	调试单元测试：在测试方法上点击右键，然后选择"Debug"或按下快捷键"Shift+F9"
	跳到新的下一行 shift + 回车

python 语法

1.变量
	1.Python是动态语言，它处理变量的概念与一般静态语言不同。静态语言如C C++当定义变量时内存就会预留空间存储变量内容。
	2.变量所使用的是参照地址的概念，设定一个变量x=10时，Python会在内存某个地址存储10，此时我们简历变量x像是一个标志，
		其内容是存储10的内存地址。如果有另一个变量y=10 则y的标志内容也是存储10的内存地址。相当于变量时名称，不是地址。
		使用内置函数id()获取变量内存地址。
	3.x = 10
		y = 10
		print(id(x)) //21430544
		print(id(y)) //21430544
	4.命名规则
		1.必须有英文字母、_下划线或中文开头，建议用英文字母。
		2.只能由英文字母、数字、_下划线或中文组成，下划线开关的变量会被特别处理。
		3.英文字母大小写敏感，Name和name是两个变量名。
		4.Python系统保留字或关键字不能当做变量名，这会让程序报错。内置函数名不建议当变量名
		5.具体命名：
			命名：
			驼峰命名
			1.appName：第一个单词首字母小写 第二个单词首字母大写
			2.AppName （class）：第一个单词首字母大写，第二个单词首字母大写，以此类推
			下划线命名
			app_name ：用于函数名称 用下划线连接单词名称
			APP_NAME：全大写用于常量
			小结：
			变量命名：变量，函数用下划线 类用大驼峰
			全局变量（常量）：大写，多个单词用下划线连接
	5.下划线变量
		_test
		这样定义为私有变量、函数或方法，不想直接被调用时用单下划线开头
		结尾下划线例如：
		dict_
		为了避免与系统关键字或内置函数名称相同
		前后双下划线例如：
		__test__
		这是python内部保留变量或方法
		前边双下划线例如：
		__test
		私有方法或变量的命名，无法直接使用本命存取
2.多重赋值
	可以多个变量等于一个值
	可以多个变量等于多个值 左右必须个数对称
	x = y = z = 10
	a, b = 10, 4
	print(x, y, z)
	print(a, b)
3.删除变量
	如果某个变量不再需要，可以使用del将其删除，并回收内存空间
		x = 1
		del x
		print(x) // 报错 UnboundLocalError: local variable 'x' referenced before assignment
4.常量
	与变量相反，常量是不可变的量
	但是在Python中，没有严格意义上的常量（constant）概念，即不能直接声明一个不可更改的值。
	然而，Python约定俗成地使用全大写字母命名的变量来表示常量，以表示这些变量的值不应该被修改。
	虽然这些变量的值可以被改变，但是开发者应该遵守约定，不去修改它们。
	例如，以下是使用全大写字母命名的变量作为常量的示例：
		PI = 3.1415926
	在实际使用中，开发者应该避免修改这些被视为常量的变量，以保持代码的可读性和一致性。
5.+ - * / %
	x = 1 + 2
	print("x:", x) # 3
	y = 6 - 5
	print("y:", y) # 1
	z = 3 * 4.5
	print("z:", z) # 13.5
	k = 10 / 3
	print("k:", k) #k: 3.3333333333333335
	l = 10 % 3
	print("l:", l) #l: 1
6.连续写法
	+=	a = a + b  可以写成a += b
	-=	a = a - b   可以写成a -= b
	*=	a = a * b   可以写成a *= b
	/=	a = a / b    可以写成a /= b
	%=	 a = a % b   可以写成a %= b
	//=    a = a // b    可以写成a //= b

7.关于注释
	1.三个引号 (单 双 都可以) #

8.编码问题导致输出中文乱码
	在程序的开头写入如下代码：
	# -*- coding:utf-8 -*-
	或者
	# coding=utf-8
9.查看数据类型 type
	1.常见
		x = 10
		y = x / 3
		print(type(x)) # <class 'int'>
		print(type(y)) # <class 'float'>
		print(type(type(x))) # <class 'type'>
	2.不仅仅是变量的数据类型可以看；函数，列表，字典，元组等都可以用这个内置函数查看它的类型
		def print_hi(name):
			a = ["1", "2"] # <class 'list'>
			b = ("2",) # <class 'tuple'>
			c = [1, 2, 3] #<class 'list'>
			d = {"a": '1'} #<class 'dict'>
			def e(): #<class 'function'>
				pass
			print(type(a))
			print(type(b))
			print(type(c))
			print(type(d))
			print(type(e))
10.数据类型
	1.整数
		1.碎片知识
			整数的英文是integer，在计算机程序语言中用int表示，python和其他语言不一样，没有long，为什么呢？
			因为python3最牛逼，可以是任意值 也可以这么写
				a = 1_1_0
				print(a) # 110
			这么写的原因是？请看下边，你能一眼看出来这是多少吗？
				a = 1000000000000 等价于 a = 1_000_000_000_000 print(a) #1000000000000
		2.整数 强转函数 int()
			1.可以将一个字符串或者浮点数转换成整数
	2.浮点型
		1.强转函数 float()
		2.常见方法
			1.round(4.56,1) //4.6 保留一位小数 四舍五入
			2.is_integer(5.0) # True ； is_integer(5.1) # False
			3.is_integer(5.0) # True
			3.as_integer_ratio() 以元组的形式 返回一个小数的 分数
				1.print(0.5.as_integer_ratio()) # （1，2
				2.print(60.as_integer_ratio()) # （60，1）
	3.布尔型
		1.强转函数 bool
		2.Python中，布尔值是True和False 就python首字母大写！其他都是小写
		3.可以转换所有数据类型！包括列表字典元组，也不能说转换吧，他会输出True或者False
			如果定义的数据为空或者0  他就是输出False 反之则True
				print(bool("0") )#True
				print(bool([0])) #True
				print(bool({"a": 0})) #True
				print(bool((0,))) #True
				print(bool((0))) #False
				print(bool(())) #False
				print(bool({})) #False
				print(bool([])) #False
				print(bool(0))  #False
				print(bool(None)) #False
		4.逻辑运算符
			1.and or not
	4.字符串 str()
		0.字符串函数
			1.len
			2.字符串切片
				1.关于索引 正数 0 1 2 3 最后一个是 -1 -2 -3 -4
				2.一些切片的列子
					name = 'ab宇哥不是说相声的'
					print(len(name)) #10
					print(name[0]) #a
					print(name[-1]) #的
					print(name[0:2]) #ab 左开右闭 右边不被选中
					print(name[2:]) # 宇哥不是说相声的
					print(name[:-2]) # ab宇哥不是说相 仍然符合 右闭的特点 右边不被选中
					print(name[:2] + name[2:]) # ab + 宇哥不是说相声的
					print(name[:5] + name[5:]) # ab宇哥不 + 是说相声的
					print(name[10]) # 越界报错！因为最大索引是 9  ，IndexError: string index out of range
					print(name[2:20]) # 虽然后面越界 但是切片会自动处理 取最大数值 即可 # 宇哥不是说相声的
				3.关于切片的步长 (可以为 正数 也 可以为 负数)
					name = '宇哥不是说相声的'
					print(name[::]) # 宇哥不是说相声的
					print(name) # 宇哥不是说相声的
					print(name[0:-1:1]) # 宇哥不是说相声 默认步长是 1
					# 步长为正数
					name = '宇哥不是说相声的'
					print(name[0:-1:2]) # 宇不说声 隔一个取一个
					# 步长为负数
					name = '宇哥不是说相声的'
					print(name[6:1:-1]) # 声相说是不 等于反过来取了 字符串也是反的
					print(name[::-1]) # 的声相说是不哥宇 相当于反转字符串
			3.其他的一些函数
				a.strip()  返回去除字符串两端空格的版本。
				a.split() 将字符串按照空格分割成多个子字符串，并返回一个列表。
				a.join(iterable) 使用字符串作为连接符，将可迭代对象 `iterable` 中的元素连接成一个字符串。
				a.replace(old, new) 返回将字符串中所有出现的旧子串 `old` 替换为新子串 `new` 的版本。
				a.find(substring) 查找子串 `substring` 在字符串中第一次出现的索引位置，找不到返回 -1。
				a.count(substring) 统计子串 `substring` 在字符串中出现的次数。
				a.startswith(prefix)  检查字符串是否以指定前缀 `prefix` 开头，返回布尔值。
				a.endswith(suffix)  检查字符串是否以指定后缀 `suffix` 结尾，返回布尔值。
				a.lower() 返回字符串的小写。
				a.upper() 返回字符串的大写。
				a.capitalize() 返回字符串的首字母大写版本。
				a.title() 返回字符串中每个单词的首字母大写版本。
				a.islower() 检查字符串中的字母是否都是小写。
				a.isupper() 检查字符串中的字母是否都是大写。
				a.isdigit() 检查字符串是否只包含数字字符。
				a.isalpha() 检查字符串是否只包含字母字符。
				a.isnumeric()  检查字符串是否只包含数字字符（包括Unicode字符）。
				字符串更多方法参考文档：https://docs.python.org/zh-cn/3.9/library/stdtypes.html#string-methods
			4.print 函数
				1.print(value,...,sep=" ",end="\n",file=sys.stdout,flush=False)
					1.参数意义如下：
						value:表示想要输出的数据
						sep:当输出多个数据时，可以插入各个数据分隔字符，默认是一个空格。
						end:当数据输出结束时所插入的字符，默认回车。
						file:数据输出的位置。默认是sys.stdout，也就是屏幕，可以使用此设定输出导入其他文件或设备
						flush:是否清除数据流的缓冲器，预设是不清除
					2.比如 下面两个 会输出到一行 1 2 abc
						print("1","2",end = "\t")
						print("a","c",sep = "b")
				2.格式化输出 %输出
					1.常见的 %
						%s 格式化字符串输出
						%d 格式化整数输出
						%f 格式化浮点数输出
						%c 字符
						%u 无符号十进制整数
						%o 格式化8进制整数输出
						%x 格式化16进制整数输出
						%X 格式化大写16进制整数输出
						%e 科学计数法小写e
						%E 格式化科学计数法大写E的输出
						%g %f和%e的简写
						%G %f和%E的简写
					2.常见例子
							a = "123" ; print("%s 这是一个字符串格式化输出" % a) # 123 这是一个字符串格式化输出
							print("%d 这是一个整数格式化输出" % 111) #111 这是一个整数格式化输出
							print("这是多个格式化输出：整数：%d,字符串：%s" % (123,'www')) #这是多个格式化输出：整数：123,字符串：www
							text = "这是一个测试格式化输出的变量，字符串：%s,%s" % ("hello1","world") #这是一个测试格式化输出的变量，字符串：hello1,world
							text2 = "这是一个测试格式化输出的变量，字符串：%s"  ; print(text2 % "hello2") #这是一个测试格式化输出的变量，字符串：hello2
				3.{}和format() print("...输出格式区...".format( 变量系列区, ...))
					1.一些列子
						print("大爷！您今儿吃什么？，大爷说:吃{},{},{}".format("翔1","翔2","翔3")) #大爷！您今儿吃什么？，大爷说:吃翔1,翔2,翔3
						print("大爷！您今儿吃什么？，大爷说:吃{2},{1},{0}".format("翔1","翔2","翔3")) #大爷！您今儿吃什么？，大爷说:吃翔3,翔2,翔1
						#在format里边赋值
						print("大爷！您今天吃什么？，大爷说:吃{a},{b},{c}".format(a="翔1", b="翔2", c="翔3")) #大爷！您今天吃什么？，大爷说:吃翔1,翔2,翔3
				4.f-strings格式化字符串 在Python3.6x版后有一个改良format格式化方式，称f-strings
					name = "yuge"
					work = "dsb"
					print(f"{name}天天{work}") # yuge天天dsb

					name = "yuge"
					work = "dsb"
					print(f"{name=}天天{work=}") #name='yuge'天天work='dsb'
		1.碎片知识
			设定空字符串 x = str() x = str("ABC") # 同 x = "ABC"
			强制转换 x = str(123)  # 这里的123是int类型
		2.字符串拼接
			x = "hello"
			y = "world"
			print(x + "," + y + "!!!")
		3.多行字符串
			1.三个引号
				str3 = "你大爷还是你大爷。" \
					   "你大妈还是你大妈"
				print("str3:",str3)

				str4 = ("你大爷还是你大爷"
							"你大爷还是你二大爷")
				print("str4:",str4)
		4.转义字符
			1.例子
				print("Hello\nWorld")  # 输出两行，Hello和World分别位于不同行
				print("This is a\ttab")  # 输出带有制表符的文本
				print("She said, \"Hello!\"")  # 输出包含双引号的字符串
				print('He\'s happy')  # 输出包含单引号的字符串
				print("C:\\path\\to\\file")  # 输出包含反斜杠的字符串路径
			2.字符串加r 取消 转义 print(r"abc\nvvv") # abc\nvvv
		5.字符串相乘
			1.可以重复输出n次字符串 print("=" * 100)
	5. bytes数据
		1.碎片
			1.字节集的创建
				1.在Python中，bytes()是一个内置函数，用于创建一个不可变的字节对象。bytes()函数可以接受不同类型的参数，
					1.并将其转换为字节对象
				2.创建空的字节对象：empty_bytes = bytes() 下面两个等价：
					str_bytes = bytes("Hello", encoding="utf-8") # type 后 显示 <class 'bytes'>
					str_bytes1 = b"Hello" # type 后 显示 <class 'bytes'>
				3. 从可迭代对象创建字节对象：iterable_bytes = bytes([72, 101, 108, 108, 111]) # hello
				4. 从十六进制字符串创建字节对象 hex_bytes = bytes.fromhex("48656c6c6f")
							hex_bytes = bytes.fromhex("48656c6c6f")
							print(str(hex_bytes, "utf8")) #hello
				5.从已有的字节对象创建新的字节对象：existing_bytes = bytes(b"Hello")
		2.字节集可以转字符串
			iterable_bytes = bytes([72, 101, 108, 108, 111])
			print(str(iterable_bytes, 'utf-8')) # hello 可以把字节集转为 字符串 

			iterable_bytes1 = [72, 101, 108, 108, 111] #不可以直接把 list 转为字符串
			print(str(iterable_bytes1, 'utf-8')) # 这里报错 TypeError: decoding to str: need a bytes-like object
	6.数据类型总结
		几种数据类型：                                  转换用内置函数
			int类型：整数，如：1234567                   int()
			float类型：浮点数，小数，如：3.1415            float()
			String类型:字符串 如：'123' "321"            str()
			Bool类型：布尔类型 如：True False             bool()
			List类型: 列表 如：['哈哈','呵呵']             list()
				1.切片：	起始索引：结束索引：步长
					pc_list = ["爬虫","逆向","前端","后端","框架"]
					print(pc_list[0])
					print(pc_list[-1])

					pc_list = ["爬虫","逆向","前端","后端","框架"]
					print(pc_list[0:-1:2])
					print(pc_list[::-1]) # 反转
				2.append() al.append("22222") 末尾增加一个元素
				3.insert() al.insert(2,"这是三")
				4.extend() 将可迭代对象的元素分别插入到列表末尾
					al = [1, 2, "3", "4", 5, 6]
					al.extend(["123","333","444"])
					print(al) //[1, 2, '3', '4', 5, 6, '123', '333', '444']
				5.copy() 浅拷贝 复制列表
					fruits = ["apple", "banana", "orange"]
					fruits_copy = fruits.copy()
					print(fruits_copy)  // 输出: ["apple", "banana", "orange"]
				6.mergin = [1,2] + [3,4] 也属于浅拷贝
				7.List1 * 2 列表元素成倍增加
				8.len(List1) 列表长度
				9.remove() al.remove("3")
				10.pop() 删除指定位置的元素，如果不传参数，则删除最后一位
					al = [1, 2, "3", "4", 5, 6]
					al.pop(0)
					al.pop(-1)
					print(al) // [2, '3', '4', 5]
				11.clear() a.clear() 清空
					1.同样可以重新赋值达到清空的效果 a = []
				12.del语句
					a  = ["1","2","3",["4","5"]]
					del a[1] // ['1', '3', ['4', '5']]
					print(a)
					// 同上 清空
					del a[:]
					print(a) // []
				13.index()
					al = [1, 2, "3", "4", 5, 6]
					res = al.index(2) // 1
				14.count() 统计指定元素在列表中出现的次数
					name_list = ["小王","小张","小刘","小王吧","小王"]
					name_list_count = name_list.count("小王")
					print(name_list_count) //2
				15.sort() 排序 默认升序
					fruits = ["apple", "banana", "orange"]
					fruits.sort()
					print(fruits)  # 输出: ["apple", "banana", "orange"]

					a = [2,35,1,123,35,6]
					a.sort(reverse=False) # 是否反转，False就是正序
					a.sort(reverse=True)
					print(a)
				16.reverse() 反转列表 同[::-1]
					fruits = ["apple", "banana", "orange"]
					fruits.reverse()
					print(fruits)  # 输出: ["orange", "banana", "apple"]

					a  = ["1","2","3",["4","5"]]
					a[0:2] = "3","2","1" # ["3","2","1"]
					print(a) # ['3', '2', '1', '3', ['4', '5']]
					a  = ["1","2","3",["4","5"]]
					a[0:2] = "321"
					print(a) # ['3', '2', '1', '3', ['4', '5']]
					a[0] = "11111"
					print(a) # ['11111', '2', '1', '3', ['4', '5']]
				17.in 和not in in 判断一个元素是否在列表里返回布尔 
					a = ["1","2","3"]
					b = "1" in a
					c = "1" not in a
					print(b) # True
					print(c) # False
				18.is  ,is not
					a = 3
					print(a is 3) #True
					print(a is not 3) #False
				19.可循环
					l = []
					for i in ["hello","world"]:
						if i == "hello":
							l.append(i)
					print(l) #['hello']
				20.join 严格来说属于字符串的功能
					txt = ""
					l = ["hello","world","宇哥","爬虫"]
					print(txt.join(l)) # helloworld宇哥爬虫
					txt = ","
					l = ["hello","world","宇哥","爬虫"]
					print(txt.join(l)) # hello,world,宇哥,爬虫
				21.列表嵌套
					a = [1,2,3,4,5,[6,7,8]]
					print(a[5]) # [6,7,8]
					print(a[5][0]) # 6
			Dict类型:字典 如：{'a':'b'}                   dict()
				1.访问
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					print(pc_dict["name1"]) #ppl
					print(pc_dict.get("name1")) #ppl
				2.keys()
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					k = pc_dict.keys()
					print(type(k)) # <class 'dict_keys'>
					print(k) # dict_keys(['name1', 'name2', 'name3'])
				3.values()
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					v = pc_dict.values()
					print(v) # dict_values(['ppl', 'pry', 'yuge'])
				4.items()
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					kv = pc_dict.items()
					print(kv) # dict_items([('name1', 'ppl'), ('name2', 'pry'), ('name3', 'yuge')])
				5.get()
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					aaa = pc_dict.get("aaa","bbb") # 不存在返回bbb
					print(aaa)
				6.pop()
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					res1 = pc_dict.pop("name1")
					res2 = pc_dict.pop("123123","不存在")
					print(res1,res2) # ppl 不存在
					print(pc_dict) # {'name2': 'pry', 'name3': 'yuge'}
				7.update()
					1.将另一个字典中的键值对更新到当前字典中。如果键存在，则会覆盖对应的值；如果键不存在，则会添加新的键值对
						pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
						pc_dict.update({"name1":"ndy"})
						print(pc_dict)
					2.直接定义更新 pc_dict["name1"] = "ndy" # 有就更新没有就添加
				8.clear() del copy() len() 和 List中的用法相同 参考上面
				9.遍历
					pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
					for k,v in pc_dict.items():
						print(f"key:{k}")
						print(f"value:{v}")

					获取key
						pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
						for k in pc_dict.keys():
							print(f"key:{k}")

					// 什么都不加默认是key
						pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
						for k in pc_dict:
							print(f"key:{k}")

					// 获取value
						pc_dict = {"name1":"ppl","name2":"pry","name3":"yuge"}
						for v in pc_dict.values():
							print(f"value:{v}")
				10.字典推导式
						pc_dict = {k:v for k,v in  {"name1":"ppl","name2":"pry","name3":"yuge"}.items() if v == "ppl"}
						print(pc_dict) #{'name1': 'ppl'}
				11.enumerate会返回数据的index
						pc_dict = {k:v for k,v in  enumerate(["ppl","pry","yuge"])}
						print(pc_dict) # {0: 'ppl', 1: 'pry', 2: 'yuge'}
				12.字典嵌套
					pc = {"name": "sb56", "age": 100, "国籍": "xrz",
						  "额外": {"name": "23333",
								"name1": {
									 "name": "zs",
									 "name1": "li",
									}
								 }
						  }
					for k,v in pc["额外"]["name1"].items():
						 print(k,v) # name zs name1 li
			set类型：集合 如：{123,321321,4244,5432546}   set()
				1.一种无序且不重复的数据集合
					pc = {"爬虫","爬虫","JS逆向"} # 即使定义了相同数据，他也不会输出，因为是不重复的
					print(pc) # {'爬虫', 'JS逆向'}
				2.几个特性：
					无序性：集合中的元素是无序的，不能通过索引访问或修改特定位置的元素。
					唯一性：集合中的元素是唯一的，不会出现重复的元素。如果尝试向集合中添加已经存在的元素，集合不会发生改变。
					可变性：集合是可变的，可以添加、删除和修改元素。
					不可哈希性：集合本身是不可哈希的，因此不能作为字典的键或其他集合的元素
				3.定义
					pc = set()
					pc = {1,2,3,4,5,"爬虫"}
				4.取值 无序所以不能取 因为没有索引，而且元素也是唯一，通常用一下方式进行判断
					1.用in 来判断这个值是不是在集合里边
					2.遍历 为什么数字就有序，字符串就无序
				5.add pc.add("devtools")
				6.update pc1.update(pc2, pc3)
				7.remove() pc.remove("devtools") # 不存在会报错KeyError
				8.discard() 移除元素 和 remove 类型 pc.discard("sb56") # 重复删除或者删除了不存在的元素不会报错
				9.pop() 随机删除元素
				10.clear() 清空元素 pc.clear()
				11.copy() pc3.copy() 浅拷贝
				12.union() 或 | 并集 找出两个或多个集合的并集 就是两个集合加一起去掉重复的
						pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
						pc2 = {"爬虫","逆向","JS","Python","sb"}
						print(pc1 | pc2) #{'JS', '逆向', 'sb56', 'Python', 'JS语言', 'Python语言', '爬虫', 'sb'}
						print(pc1.union(pc2)) #{'JS', '逆向', 'sb56', 'Python', 'JS语言', 'Python语言', '爬虫', 'sb'}

						print(pc1|pc2|pc3)
						print(pc1.union(pc2,pc3))
				13.intersection() 或 & 交集
						pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
						pc2 = {"爬虫","逆向","JS","Python","sb"}
						print(pc1 & pc2) # {'爬虫', '逆向'}
						print(pc1.intersection(pc2)) # {'爬虫', '逆向'}
				14.difference() 或 - 前边集合有的后边集合没有的  取差集
						pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
						pc2 = {"爬虫","逆向","JS","Python","sb"}
						print(pc1 - pc2) #{'sb56', 'Python语言', 'JS语言'}
						print(pc1.difference(pc2)) #{'sb56', 'Python语言', 'JS语言'}
						# 反过来结果不同
						print(pc2 - pc1) #{'sb', 'JS', 'Python'}
						print(pc2.difference(pc1)) #{'sb', 'JS', 'Python'}
				15.symmetric_difference() 或 ^ 对称差集 两个集合中不重复的元素的集合。
					1.对称差集包括了两个集合中除了交集部分之外的所有元素。换句话说，对称差集是两个集合的并集减去交集
						pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
						pc2 = {"爬虫","逆向","JS","Python","sb"}
						print(pc1 ^ pc2) #{'Python', 'JS', 'sb56', 'Python语言', 'sb', 'JS语言'}
						print(pc1.symmetric_difference(pc2)) #{'Python', 'JS', 'sb56', 'Python语言', 'sb', 'JS语言'}
				16.isdisjoint() 判断两个集合的相同元素 没有返回 True 有一个相同的就返回 False
					pc3 = {"爬虫","爬爬乐"}
					pc4 = pc3.copy()
					print(pc4.isdisjoint(pc3)) #False

					pc1 = {"爬虫1","爬爬乐1"}
					print(pc1.isdisjoint(pc3)) #True
				17.issubset() 判断当前集合是否是另一个集合的子集 子集：一个集合内的所有元素被另一个集合所包含
					pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
					pc2 = {"爬虫","逆向","JS","Python","sb"}
					pc3 = {"爬虫","逆向"}

					print(pc3.issubset(pc1)) #True
					print(pc3.issubset(pc2)) #True
					print(pc2.issubset(pc3)) #False
				18.issuperset() 用于判断当前集合是否是另一个集合的超集
					1.超集：如果一个集合A包含了另一个集合B的所有元素，那么集合A被称为集合B的超集。
						换句话说，集合A至少拥有集合B中的所有元素，可能还包含其他元素
						pc1 = {"爬虫","逆向","JS语言","Python语言","sb56"}
						pc2 = {"爬虫","逆向","JS","Python","sb"}
						pc3 = {"爬虫"}
						print(pc1.issuperset(pc3)) #True
						print(pc3.issuperset(pc2)) #False
						print(pc2.issuperset(pc3)) #True
				19.集合推导式
					1.将集合中的元素字符全变大写并且生成一个新的集合
						pc = {'sb56','halou','pc'}
						pc = {x.upper() for x in pc}
						print(pc) #{'SB56', 'HALOU', 'PC'}
					2.创建一个20以内单数集合
						seq = {x for x in range(1, 20) if x % 2 == 1} 
						print(seq) # {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}
			Tuple类型:元组 如：(1,) (1,2,3,4,5,6) ('11','22')  tuple()
				1.元组的定义
					pc1 = ()
					pc2 = tuple()
					print(pc1,pc2) # () ()
					print(type(pc1),type(pc2)) # <class 'tuple'> <class 'tuple'>
				2.一个变量赋值多个值就会被打包成元组
					pc = "爬虫","逆向","JS"
					print(pc) # ('爬虫', '逆向', 'JS')
				3.取值
					1.切片 唯一不同的是 不能发生变化 也就是不能赋值
					2.遍历 for 不支持 for k,v in my_tuple
						my_tuple = (1, 2, 3)
						for item in my_tuple:
							print(item) # 1 2 3
				4.count() 取某个数值的个数
					pc = "爬虫","逆向","JS","爬虫"
					res = pc.count("爬虫")
					print(res) // 2
				5.index() 返回第一个出现的值的索引/下标
					pc = "爬虫","逆向","JS","爬虫"
					res = pc.index("爬虫")
					print(res) // 0
				6.len() 统计个数
					pc = "爬虫","逆向","JS","爬虫"
					print(len(pc)) // 4
				7.sorted(iterable, key=None, reverse=False) key 就是排序的函数
					1.排序并返回列表sorted() 适用于列表，元组，字典，字符串等可迭代对象
						my_list = [3, 1, 2, 5, 4]
						sorted_list = sorted(my_list)
						print(sorted_list)  # 输出: [1, 2, 3, 4, 5]

						my_tuple = (3, 1, 2, 5, 4)
						sorted_tuple = sorted(my_tuple)
						print(sorted_tuple)  # 输出: [1, 2, 3, 4, 5]

						my_string = "hello"
						sorted_string = sorted(my_string)
						print(sorted_string)  # 输出: ['e', 'h', 'l', 'l', 'o']
						# 按照绝对值排序
						my_list = [-3, 1, -2, 5, -4]
						sorted_list = sorted(my_list, key=abs)
						print(sorted_list)  # 输出: [1, -2, -3, -4, 5]
				8.最大值 max() 最小值 min()
						pc1 = (1,2,3,7,8,9,4,2,1)
						print(max(pc1)) // 9
						print(min(pc1)) // 1
				9.元组推导式
						sb56 = (x**2 for x in range(1, 6))
						print(sb56) #<generator object <genexpr> at 0x01A874C0>
						print(tuple(sb56)) #(1, 4, 9, 16, 25)

						strings = "爬虫爬数据，数据用爬虫爬"
						pc = tuple(char for char in strings if char == "爬")
						print(pc) #('爬', '爬', '爬', '爬')

11.文件操作
	1.open (open()是python中内置的函数，功能是打开一个文件，进行增删查改等操作)
		1.碎片
			1.知识
				file_obj = open(file_name,mode="r")
				file_name 就是文件名，如果不存在则会创建，不指定路径就在当前路径下
				mode就是打开文件的模式，r是读，w是写，a是追加，b则是打开二进制时需要添加的模式，
				x是打开一个新文件，如果打开的文件已经存在会报错，t打开文本文件模式（默认）
					r	只读，默认模式，文件不存在就报错
					w	只写，文件存在会覆盖内容，不存在则创建
					a	写追加，打开文件用于追加内容。如果文件不存在，会创建新文件。
					x	独占创建模式。打开文件用于写入，只能创建新文件，如果文件已存在则会引发 FileExistsError。
					b	二进制模式。以二进制格式打开文件。（图片，视频等）
					t	文本模式（默认）。以文本格式打开文件。
					+	读写模式。同时支持读取和写入操作。
					经常用的w+,a+,r+,rb,wb等
		2.常见用法
			1.print()输入到文件内（你们肯定没玩过，一般老师不会讲，因为知识点没这么宽）
				file_obj = open("1.txt",mode="w")
				print("dsadadsa",file=file_obj)
				file_obj.close() # 玩完了别忘了关闭
			2.write方法写数据到文件
				file_obj = open("1.txt",mode="w")
				file_obj.write("111111111111111111")
				file_obj.close()
			3.writelines 方法 这里如果是 write 会提示 TypeError: write() argument must be str, not list
				lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
				with open("example.txt", "w") as file:
					file.writelines(lines)
			4.writable()用于检查文件是否可写，返回布尔值
				with open("example.txt", "r") as file:
					print(file.writable())  # False
				with open("example.txt", "w") as file:
					print(file.writable())  # True
			5.read 读
				file_obj = open("1.txt",mode="r")
				txt = file_obj.read()
				print(txt)
				file_obj.close() # 关闭文件，不关闭会占用文件句柄
			6.readline() 逐行读
				1.readline() 方法用于逐行读取文件内容。每次调用 readline() 方法
					它会读取文件中的一行，并将其作为一个字符串返回。连续调用 readline() 方法可以逐行遍历文件的内容。
				file_obj = open("1.txt",mode="r")
				txt = file_obj.readline()
				txt1 = file_obj.readline()
				print(txt,txt1)
				file_obj.close()

				//去掉\n
				file_obj = open("1.txt",mode="r")
				txt = file_obj.readline().strip()
				print(txt)
				file_obj.close()
			7.readlines()
				1.方法用于一次性读取整个文件的所有行，并将每一行作为一个字符串存储在一个列表中返回。
					列表中的每个元素对应文件中的一行。
				file_obj = open("1.txt",mode="r")
				txt = file_obj.readlines()
				print(txt) # 存入列表中
				file_obj.close()

				// for循环遍历
				file_obj = open("1.txt",mode="r")
				for i in file_obj.readlines():
					print(i.strip())
				// txt = file_obj.readlines()
				// print(txt) # 存入列表中
				file_obj.close()
			8.readable() 用于检查文件是否可读，返回布尔值
			9.seek 指针定位seek
				1.file.seek(offset[, whence])
				2.offset参数表示偏移量，即指针要移动的字节数，可以是正数或负数；whence参数表示起始位置，可以是以下值之一：
					 1. 0：从文件开头开始偏移，默认值；
					-2. (0,1)：从当前位置开始偏移；
					-3. (0,2)：从文件末尾开始偏移。
					-4. 负数 ：从文件末尾往开头(-1,2) 或这从当前位置往开头(-2,1)
							with open("1.txt", "a+") as file:
								# 用 with 不用主动关闭文件 自己会关闭 下面直接拿file操作
								# 读取文件的前5个字符
								print(file.read(5))  # "abcdefg"
								# 将指针移动到文件开头
								file.seek(0)
								# 读取整个文件内容
								print(file.read())  # "all file"
								# 将指针移动到文件末尾
								file.seek(0, 2)
								# 写入新的内容
								file.write("\nNice to meet you!")
								# 将指针移动到文件开头
								file.seek(0)
								# 读取整个文件内容
								print(file.read())
					5.需要注意的是，在使用 seek()方法改变指针位置之前，必须以读取模式或读写模式打开文件。
						如果文件以写入模式打开，使用 seek() 方法改变指针位置会导致文件内容被截断。
				3.关于负偏移量
					1.需要注意的是，在使用 seek()方法改变指针位置之前，必须以读取模式或读写模式打开文件。
						如果文件以写入模式打开，使用 seek() 方法改变指针位置会导致文件内容被截断。
					2.seek()方法的负偏移量或相对于末尾的位置在文本模式下是不被允许的。这是因为在文本模式下，
						文件的字节偏移与字符的解码方式有关，而负偏移量或相对于末尾的位置可能会导致无法正确解码字符。
					3.如果你需要在文本模式下进行定位操作，可以考虑使用其他方法，比如逐行读取文件并跟踪行号，
						或者使用tell()方法获取当前文件指针的位置。
					4.请注意，在以二进制模式（'rb'、'wb'、'ab'等）打开文件时，seek()方法可以使用负偏移量或相对于末尾的位置
						进行定位操作。这是因为在二进制模式下，文件的字节偏移是明确的，不受字符解码的影响。
				5.with语句
					1.使用 with 语句可以确保文件在使用完后自动关闭，无需显式调用 close() 方法。
						with open("1.txt",mode="r") as f:
							text = f.read()
							print(text)
12.输入 input()
		1.input函数功能与print()函数功能相反，这个函数会从屏幕读取用户从键盘输入的数据
			value = input("请输入一个爹：")
			//value是变量，所输入的数据会存储到这个变量中，input接收你输入的无论是字符串或者数字，一律为字符串类型，
				如果要执行数学运算需要int()转换为整形。
			//input里边的字符串是提示内容，对于输入的内容不影响
			print(f"类型为:{type(value)},{value}") #类型为:<class 'str'>,my
13.流程控制
	1.if elif else
		if x>3:
			print("x is greater than 3")
		elif x<3:
			print("x is less than 3")
		else:
			print("x is equal to 3")
	2.三元运算符
		1.you = '学爬虫' if nx > 0 else '学个毛'
		2.嵌套三元运算
			1.you = '学爬虫' if nx > 1 else '学个毛' if nx < 0  else '人才啊'
            2.等价于：
                if nx > 1:
                    you = '学爬虫'
                elif nx < 0:
                    you = '学个毛'
                else:
                    you = '人才啊'
    3.流程控制-循环语句for
        1.关键字 for x in y:
            for 是关键字
            x 是变量名
            in 是关键字 
            y 是一个可迭代对象类型
                range() 内置函数，用于生成一个整数序列，常用于循环的对象
                    range() 用于生成一个整数序列。最多接收三个参数。常用与for循环
                    第一个参数，起始值
                    第二个参数，结束值
                    第三个参数，步长
                列表
                元组
                字符串
                集合
                字典
      2.基本操作
          循环字符串
              message = "Hello, wocao!"
              for i in message:
                  print(i)
          循环列表
                hi = ["hello", "world", "wocao"]
                for h in hi:
                    print(h)
          循环字典
              person = {"name": "yg", "age": 30, "city": "BJ"}
              for key in person:
                  print(key)
              person = {"name": "yg", "age": 30, "city": "BJ"}
              for key, value in person.items():
                  print(key, value)
          循环集合
              p = {'hello',233,'world','wocao'}
              for i in p:
                  print(i)
          循环元组
              y = (1,2,3,4,5,6)
              for i in y:
                  print(i)
          支持多个变量循环
              a = ['1','2']
              b = ['3','4']
              for j,k in a,b:
                  print(j)
                  print(k)
          嵌套循环
              for i in range(10):
                  for j in range(10): 
                      print('j',j)
        3.break 和 continue 同其他语言
  4.while 语句
      while True:
          print("hello world")
14.函数
	1.格式定义
		def 函数名(参数1,参数2,参数n):
			"""函数批注"""
			程序代码                    # 缩进
			return 返回值
	2.解释
		关键字：def
		函数名：必须写而且唯一，后边必须加小括号，因为后续程序需要调用，命名规则和变量相同，
			按照PEP8的话建议第一个英文字母用小写
		参数：可有可无，根据程序需要是否传入参数进行处理，参数调用逗号分开。
		函数批注：可有可无，大型程序设计时建议添加批注，比如写参数传的类型，函数的功能等三个单引号和三个双引号都可以，
			可以是多行批注，写了就比较专业！
		return：可有可无，如果没有return的话，调用赋值打印只会输出一个None，所以我们每个函数应该有返回值，方便调用也方便调试。
	3.简单的函数
		def myPrint(txt):
			print(f"txt:{txt}")

		def url1(btm_ppre,bb,cc="cc.00"):
			url = "https://abc.com/control?"
			res = f"{url}btm_ppre={btm_ppre}&bb={bb}"
			return res

		url = url1("a0.b0.c0.d0","bb.bb") # 动态传参
	4.关键词参数 参数名=值 可以不按顺序传参 但是要以这种格式
		1.url = url1(bb="bb.bb",btm_ppre="a0.b0.c0.d0") # 动态传参
		2.默认传参 def url1(btm_ppre,bb,cc="cc.00") // cc 有个默认的数值 可以传可以不传
	5.指定参数类型（注解）
			1.可以让写代码的人和调用代码的人注意，应该传什么类型，代码并不会真的去验证，只是写代码的时候会变黄，规范性写法
			2.def url1(page: int, btm_ppre: str, btm_prem: str, btm_show_id: str) -> None:
					def url1(*pc):
						print(pc)
					url1("爬虫","JS","Python") # ('爬虫', 'JS', 'Python')
				1.指定返回为None
				
	6.参数传递的不能指定默认值 args和kwargs是约定俗成的接受传参的名字，也可以写成其他的
			def url1(*args,**kwargs):
				print(args) # ('爬虫', 'JS')
				print(kwargs) #{'bb': 'Python'}
			url1("爬虫","JS",bb="Python")
	7.函数当参数传递
			def f1():
				return "实现第一个功能"
			def f2(one):
				# print(one)
				return f"{one},实现第二个功能"
			res = f2(f1()) # 这里也可以 f2(f1)) 传函数 而不执行 到函数内部执行
			print(res) # 实现第一个功能,实现第二个功能
	8.函数传参与args参数结合
			def f1(*args):
				return sum(args[0])
			def f2(func, *args):
				return func(args)
			res = f2(f1, 1, 2, 3, 4, 5, 6)
			print(res) # 21
	9.返回 多个变量 tuple , Dict
			def abc():
				return 1,2,"a","b"
			print(abc()) # (1, 2, 'a', 'b')
	10.函数的嵌套
			def c_tmd(a):
				def string(x):
					return f"传入了一个字符串:{x}"
				def ints(x):
					return f"传入了一个数字:{x}"
				def lst(x):
					return f"传入了一个列表:{x}"
				def dicts(x):
					return f"传入了一个字典:{x}"
				res = type(a)
				print(res == str) # True 这里 type 的结果居然 真等于 str 虽然 print 显示 <class 'str'>
				if res == str:
					return string(a)
				elif res == int:
					return ints(a)
				elif res == list:
					return lst(a)
				elif res == dict:
					return dicts(a)
				else:
					print("处理不了当前的传值")
			res = c_tmd("123") 
			print(res) # 传入了一个字符串:123
	11.闭包
		1.具体来说，闭包包括以下几个要素：
			1.内部函数：在某个函数内部定义另一个函数。
			2.外部函数：定义内部函数的那个原始函数。
			3.变量引用：内部函数能够通过外部函数中的变量进行操作。
			4.返回值：当你在外部函数中使用`return`语句后，通常会返回一个指向内部函数的引用。
				def outer():
					b = 10
					def inner(x):
						return b + 1 + x
					return inner
				b = 2
				f = outer()
				print(f(b))
		2.用闭包写一个计数器
				def counter(start_at=0):
					count = [start_at]
					def incr():
						count[0] += 1
						return count[0]
					return incr
				calc = counter()
				print(calc()) // 1
				print(calc()) // 2
				print(type(calc())) // <class 'int'>
	12.递归
		1.写一个阶乘函数
			def factorial(n):
				# 基础情况
				if n == 0 or n == 1:
					return 1
				# 递归情况
				else:
					return n * factorial(n - 1)
			res  = factorial(5)
			print(res)
		2.斐波那契数列
			def fibonacci(n):
				# 基础情况
				if n <= 0:
					return 0
				elif n == 1:
					return 1
				# 递归情况
				else:
					return fibonacci(n - 1) + fibonacci(n - 2)
			print(fibonacci(5))

常见模块

1.requests
	1.主要特点：
		1.简单易学
		2.功能全
		3.会话管理，可以会话保持
		4.支持上传下载
		5.支持ssl证书验证
		6.支持代理
		7.支持cookie
		8.默认自动重定向
		9.异常处理
	2.pip install requests 安装
	3.请求
		1.get requests.get() 传入参数：
			1.url
			2.headers
			3.timeout
			4.data
			5.json
			6.parmas
			7.cookies
			8.verify
			9.proxies
				proxies = {
					  "http": "http://117.80.203.24:8118",
					  }
				 requests.get("http://httpbin.org/ip",  proxies = proxies，timeout=3)

			10.allow_redirects
		2.response 无论发送什么请求都会返回一个response对象
			response.text        响应文本
				返回的字符串数据，文本数据，json数据，包括密文数据。
				根据HTTP 头部对响应的编码推测的文本编码
				response.encoding="utf-8" 修改编码
			respones.content     响应二进制数据或bytes数据
				返回视频数据，图片数据，音乐数据等二进制数据
				print(response.content.decode("utf-8"))
				print(response.content.decode())
				print(response.text)
				content.decode("utf-8")解码
			response.status_code   http响应状态码
			response.headers     响应header
			response.cookies     响应的cookie
				1.print(requests.utils.dict_from_cookiejar(response.cookies)) 把cookies转化为字典
				2.print(response.cookies.get_dict()) 同上面作用一样
			response.encoding    响应网站字符集编码 赋值是设置 不赋值是打印当前
			response.json()        如果返回json可以直接用这个方法转成字典
			response.url             返回响应的最终 URL 重定向的时候有用
			response.raise_for_status() 如果状态码不是200会抛异常 主动结束程序运行
			response.request.headers  返回请求header
			response.request.body     返回请求body
			response.request.url      返回请求url
		session 请求
			// 创建一个会话对象
			session = requests.session()
			headers = {
				'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36',
			}
			response = session.get('https://www.baidu.com',headers=headers)
			print(response.cookies)
			response = session.get('https://www.baidu.com', params={'key': 'value'})
			可以在会话对象中设置全局参数，如超时时间
			session.timeout = 10
			print(response.request.headers)
	4.杂项
		1.报错
			1.请求https站点报错
				ssl.CertificateError开头的报错
				添加verify=False 让请求不验证服务器ssl证书
				response = requests.get(url,verify=False)
		2.代理
			1.常见的代理网站(仅用于学习)
				66免费代理网 http://www.66ip.cn/
				89免费代理 http://www.89ip.cn/
				站大爷 https://www.zdaye.com/free/
				无忧代理 http://www.data5u.com/
				云代理 http://www.ip3366.net/
				快代理 https://www.kuaidaili.com/free/
			2.代理分类
				透明代理（Transparent Proxy）：不对请求做任何修改，客户端和服务器都知道对方的存在。
				匿名代理（Anonymous Proxy）：隐藏客户端的真实 IP 地址，但服务器知道请求来自代理。
				高匿代理（Elite Proxy）：隐藏客户端的真实 IP 地址，服务器无法知道请求来自代理
			3.传输协议分类
				HTTP代理：只能代理HTTP流量。
				HTTPS代理：可以代理HTTPS流量，支持SSL加密传输。
				SOCKS代理：支持多种协议的代理，如HTTP、HTTPS、FTP等
		3.retry
			from retrying import retry
			@retry(stop_max_attempt_number=3) // 尝试次数
			def parse_url():
				# 超市就会报错并且重试
				print("开始请求...")
				response = requests.post("https://www.baidu.com", timeout=3)
				assert response.status_code == 200, '状态码不正确'
				return response
		4.curl 复制后 可以在 splidertools.cn 转 python
2.json
	1.dumps
		1.正常把 字典 转为 字符串
			import json
			dict1 = {
				"name": "小明",
				"age": 18
			}
			j1 = json.dumps(dict1)
			print(type(j1)) #<class 'str'>
			print(type(dict1)) #<class 'dict'>
			print(dict1) # {'name': '小明', 'age': 18} 单引号 就算定义的时候是双引号
			print(j1) # {"name": "\u5c0f\u660e", "age": 18}
		2.参数
			1.dumps配置参数
				indent 美化输出指定缩进的空格数，用于美化输出的JSON字符串。例如，indent=4表示使用4个空格缩进，默认值为None，表示不缩进。
				ensure_ascii  不适用非ascii字符转义，也就是保持中文，别把中文转成Unicode， 默认不加他会自动转成Unicode编码
				sort_keys 指定是否按照键的字母顺序对JSON对象进行排序。默认值为False，表示不排序。如果设置为True，则会按照键的字母顺序进行排序。
				separators 指定分隔符的字符，用于控制JSON字符串中各个元素之间的分隔方式。
				默认separators=(",",":")
			2.代码举例
				import json
				data = {"name": "yg", "age": 18, "techang?": "长"}
				d = json.dumps(data,indent=4,ensure_ascii=False,sort_keys=True,separators=(",",":"))
				print(d)

	2.loads
		1.从字符串loads后转为字典
			import json
			data = '{"name": "yg", "age": 18, "techang?": "chang"}'
			json_data = json.loads(data)
			print(json_data)  #{'name': 'yg', 'age': 18, 'techang?': 'chang'}
			print(type(json_data)) #<class 'dict'>
		2.从文件读取JSON数据 load 注意不是 loads
			import json
			with open("1.txt", "r") as f:
				python_obj = json.load(f)
			print(python_obj)  # {'name': 'yg', 'age': 18, 'techang': 'chang'}
			print(type(python_obj))  # <class 'dict'>
		3.将字典以 json 格式 写入 文件
			import json
			data = {"name": "yg", "age": 18, "techang": "chang"}
			with open("2.txt", "w") as f:
				json.dump(data,f)
3.pyexecjs 模块 py运行js的pyexecjs模块
	1.代码1 compile 编译后 call 调用
		import execjs
		// 创建一个运行时环境
		ctx = execjs.compile(
		这里是三个引号
		function add(x, y) {
			return x + y;
		}
		这里是三个引号
		)
		// 调用JavaScript函数
		result = ctx.call("add", 1, 2)
		print(result)  # 输出3
	2.代码2 Node 环境
		import execjs
		# 获取Node.js运行时环境
		ctx = execjs.get("Node")
		print(ctx)
		# 编写和执行JavaScript代码
		result = ctx.eval("1 + 2")
		print(result)  # 输出3
	3.代码3 runtime
		import execjs
		# 获取一个可用的 JavaScript 运行时
		runtime = execjs.get()
		# 定义一个简单的 JavaScript 代码
		js_code = """
		function add(x, y) {
			return x + y;
		}
		return add(3, 4);
		"""
		# 使用 JavaScript 运行时执行 JavaScript 代码
		result = runtime.exec_(js_code)
		print(result)  # 7
	4.代码4 runtime
		import execjs
		runtime = execjs.get()
		result = runtime.eval("1 + 2")
		print(result) # 3
		runtime = execjs.get()
		result = runtime.eval("new Date().getTime()")
		print(result) #1713191124607
	5.代码5 编译 并调用外部的 js
		import subprocess
		# 这个类需要重写一下 目的就是改变一下编码 encoding="utf-8" 否则下面的调用会报错 默认 encoding=None
		class MySub(subprocess.Popen):
			def __init__(self,*args,**kwargs):
				super().__init__(encoding="utf-8",*args,**kwargs)
		subprocess.Popen = MySub

		import execjs
		node = execjs.get()
		# 创建运行时环境
		with open("S:\project 2021\other\ChromeHelper\chrome tomorrow\逆战宇\\try\\111.js",encoding="utf-8") as f:
			js_code = f.read()
		ctx = node.compile(js_code,cwd="S:\project 2021\other\ChromeHelper\chrome tomorrow\逆战宇\\try\\node_modules")
		# 调用外部 JavaScript 文件中的函数
		data = 'aaaaaaaa'
		result = ctx.call("callByPython",data) # 调用 111.js 里面的 函数 并传入参数 data js里面的 console.log() 不会执行
		print(result) # 正常输出 UVjxz7/6x...
4.re 正则表达式模块
	1.match 匹配不到返回 None
		import re
		data = "a测试数据:123456,hello222222,world"
		res = re.match('^a.*:(\d+),.*o(\d+),.*', data)
		print(res) # <re.Match object; span=(0, 30), match='a测试数据:123456,hello222222,world'>
		print(res.group(0)) # a测试数据:123456,hello222222,world
		print(res.group(1)) # 123456
		print(res.group(2)) # 222222
		print(f"{res.span()},{res.start()},{res.end()}") #(0, 30),0,30
	2.关于分组
		1.匹配分组
			1.| 匹配符号左右任意一个表达式
			2.(ab) 小括号中的字符作为一个分组
			3.\n 引用之前的分组匹配中的规则匹配到的结果当作规则匹配
					import re
					text = "hello hello"
					pattern = r"(\w+)\s\1" #\1 引用前面的子匹配
					matches = re.match(pattern, text)
					print(matches.group(0)) # hello hello
					print(matches.group(1)) # hello
			4.(?P) 是正则表达式中用于给捕获组命名
					import re
					text = "2024-03-24"
					pattern = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
					matches = re.match(pattern, text)
					if matches:
						print("Year:", matches.group('year')) # Year: 2024
						print("Month:", matches.group('month')) # Month: 03
						print("Day:", matches.group('day')) # Day: 24
					else:
						print("No match found.")
			5.(?P=name) 引用之前命名的捕获组
	3.关于第三个参数 正则表达式修饰符
		1.re.I 忽略大小写
		2.re.M 匹配多行
		3.re.S 。可以匹配所有 包括换行
5.time 模块
	1.代码
		import time
		ts = time.time()
		print(ts) # 1713201793.921693
		print(type(ts)) #<class 'float'>
		print(int(ts)) #1713201793 10位
		print(int(ts*1000)) #1713201793921 13位
		ts = time.localtime()
		print(ts) #time.struct_time(tm_year=2024, tm_mon=4, tm_mday=16, tm_hour=1, tm_min=22, tm_sec=24, tm_wday=1, tm_yday=107, tm_isdst=0)
		print(f"{ts.tm_year},{ts.tm_mon},{ts.tm_mday}") #2024,4,16
		print(time.mktime(ts)) #1713201793.0
		print(time.strftime("%Y-%m-%d %H:%M:%S")) #2024-04-16 01:27:36
		print(time.strptime('2018-05-10',"%Y-%m-%d")) # time.struct_time(tm_year=2018, tm_mon=5, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=130, tm_isdst=-1)
		print(time.strptime("2018-01-24 11:31:16","%Y-%m-%d %H:%M:%S")) #time.struct_time(tm_year=2018, tm_mon=1, tm_mday=24, tm_hour=11, tm_min=31, tm_sec=16, tm_wday=2, tm_yday=24, tm_isdst=-1)
		time.sleep(0.5)
6.lxml 模块 xpath
	from lxml import etree
	html = etree.HTML(text)
	# print(html) # <Element html at 0x2004fc8>
	# print(etree.tostring(html).decode("utf-8")) # 打印出网站代码
	res = html.xpath('//*') # [<Element html at 0x1f24d68>, <Element head at 0x2101528>]
	res = html.xpath('//tr/td')# [<Element td at 0x1721768>, <Element td at 0x17216c8>]
	#获取指定节点用text()方法取值
	print(res[0].xpath("./text()")) # ['\n            111.225.152.47\n        ']
	#获取子节点
	res = html.xpath("//tr[1]/td[1]/text()") # ['\n            111.225.152.47\n        ']
	#获取父节点
	res = html.xpath("//tr[1]/td[1]/../td") # 等价于 html.xpath("//tr[1]/td")
	#属性匹配
	res = html.xpath("//tr[1]/td[1]/parent::*/td[@class='ip']/text()") # parent::* 回到了 tr
	#属性获取
	res = html.xpath("//a/text()") #['去百度', '去百度1']
	res1 = html.xpath("//a/@href") # ['http://www.baidu.com', 'http://www.baidu1.com']
	#属性多值匹配 contains 和 and  or 搭配
	res = html.xpath("//a[@class=a]") # 如果有两个 class a a1 写一个匹配不到
	# res = html.xpath("//a[@class=‘a a1’]") # 这么写两个直接报错
	print("-------------------")
	res = html.xpath("//a[contains(@class,'a a1')]/text()") #['去百度'] 一个属性值还是多个属性值都可以用
	res = html.xpath("//a[contains(@class,'a')]/text()")  #['去百度'] 一个属性值还是多个属性值都可以用
	res = html.xpath("//a[contains(@name,'a2') and contains(@class,'a')]/text()") #contains 类似 寻找文本
	res = html.xpath("//a[contains(@name,'a2') and contains(@name,'a3')]/text()") # and
	res = html.xpath("//a[contains(@name,'a2') or @names='qbd']/text()") # or
	res = html.xpath("//a[not(text()='去百度')]/text()") # not 取反
	res = html.xpath("//a[last()]/text()") # 最后一个
	res = html.xpath("//a[last()-1]/text()") #倒数第二个
	res = html.xpath("//a[position()>1]/text()") # position() 位置  > < = 某个位置
	res = html.xpath("//a[position()>1 and position()<4]/text()") # 精确选择 选第2和3节点
	#条件取值 通过 [text()=] 和 [@xxx=] [@xxx!=]都可以
	res = html.xpath("//tr/td[3][text()='河北省张家口市']/text()")
	res = html.xpath("//a[@href='http://www.baidu.com']/@href")
	res = html.xpath("//a[@href!='http://www.baidu.com']/@href")
7.selenium自动化工具
	1.简介
		1.Selenium是一个用于自动化Web应用程序测试的工具。它提供了一组API（应用程序编程接口），允许开发人员以多种编程语言（如Python、Java、C#等）编写测试脚本，用于模拟用户在浏览器中的操作。这些操作可以包括点击链接、填写表单、提交数据等，从而可以对Web应用程序进行功能测试、回归测试等。
		2.Selenium支持多种浏览器，包括Chrome、Firefox、Edge等主流浏览器，可以在不同的浏览器中运行测试脚本。它还支持不同的操作系统，如Windows、Linux、macOS等。
		3.除了自动化测试外，Selenium还可以用于网页数据抓取、网页内容提取等应用场景。由于其灵活性和强大的功能，Selenium被广泛应用于软件开发和测试领域。
	2.安装
		以谷歌浏览器为例：
		新版本安装：https://chromedriver.com/
		老版本安装：https://chromedriver.storage.googleapis.com/index.html
	3.打开 python 在执行完毕代码后 chrome 浏览器会自动关闭 如果想让chrome不关闭 想办法让 py 代码一只执行
		from selenium import webdriver
		browser = webdriver.Chrome()
		browser.get("https://www.baidu.com")

		from selenium import webdriver
		from selenium.webdriver.chrome.service import Service
		CHROMEDRIVER_PATH = r"G:\Python3.9.13\chromedriver.exe"
		svc = Service(executable_path=CHROMEDRIVER_PATH)
		browser = webdriver.Chrome(service=svc)
		browser.get("https://www.baidu.com")
	4.基础语法
		1.声明浏览器对象
			from selenium import webdriver
			browser = webdriver.Chrome()
			browser = webdriver.Firefox()
			browser = webdriver.Edge()
			browser = webdriver.PhantomJS()
			browser = webdriver.Safari()
		2.访问网页
			from selenium import webdriver
			browser = webdriver.Chrome()
			browser.get("https://www.baidu.com")
			browser.get("https://spidertools.cn/#/curl2Request")
			browser.get("https://extfans.com/search/?q=listen")
		3.查找element对网页进行操作
			1.基本用法
				from selenium.webdriver.common.by import By
				from selenium import webdriver
				browser = webdriver.Chrome()
				browser.get("https://www.baidu.com")
				# find_element是查询一个 send_keys 在标签内输入 
				browser.find_element(By.NAME,'wd').send_keys("python")
				# .click() 点击当前标签
				browser.find_element(By.ID,"su").click()
			2.这里还可以不用By.xx因为这只是一个字符串的对应关系
				ID = "id"
				XPATH = "xpath"
				LINK_TEXT = "link text"
				PARTIAL_LINK_TEXT = "partial link text"
				NAME = "name"
				TAG_NAME = "tag name"
				CLASS_NAME = "class name"
				CSS_SELECTOR = "css selector"
				browser.find_element("name",'wd').send_keys("python")
			3.元素定位
				1.找到元素后 不能用 /text() 取文本 要用自己的方法
						res = browser.find_element(By.XPATH,"//tr/td[1]")
						print(res.get_attribute("class")) # 取类名
						res1 = res.get_attribute("innerHTML") # 取元素代码
						res1 = res.get_attribute("innerText") # 取元素文本

		4.截屏
			1.browser.get_screenshot_as_file('bd.png')) 全屏幕截图
			2.form1.screenshot("form1.png")#给这个元素截图

		5.关闭浏览器
			browser.quit() # 退出
			browser.close()# 关闭
		6.cookie操作
			1.获取cookie
				1.browser.get_cookies()
					1.区别get_cookies()直接调用 会返回一个cookis的json 列表套字典
						[{'domain': 'www.baidu.com', 'httpOnly': False, 'name': '666', 'path': '/', 'sameSite': 'Lax', 'secure': True, 'value': '999'}, {...]
						cookies = browser.get_cookies()
						cookies_dict = {cookie['name']:cookie["value"] for cookie in cookies}
				2.browser.get_cookie()
					1.zfy = browser.get_cookie("ZFY")
			2.删除cookie
					browser.delete_all_cookies()
					browser.delete_cookie("ZFY")
			3.设置cookie
				add_cookie() 传入一个字典 传name和value
				{"name":"xx","value":"xx"} 如果name
		7.获取网页源代码
			browser.page_source
			browser.page_source.encode('utf-8')
		8.执行js代码
			js_code1 = "var a = navigator.webdriver;alert(a);"
			browser.execute_script(js_code1)
			time.sleep(5)
		9.切换标签页
			1.代码
				browser.switch_to.window(browser.window_handles[1])
				browser.switch_to.window(browser.window_handles[2])
			2.可以通过判断是否还有标签页 让 py 代码处于执行状态 关闭所有tab页后 就为 0 了
				while len(browser.window_handles) > 0:
					pass
			3.不同页面切换 和 在切换到的tab下面 打开新的网址
				browser.get('https://www.baidu.com')
				time.sleep(1)
				browser.execute_script('window.open("https://www.taobao.com")')
				time.sleep(2)
				browser.switch_to.window(browser.window_handles[0])
				browser.get('https://www.jd.com')
				time.sleep(1)
				browser.switch_to.window(browser.window_handles[1])
				browser.get('https://www.baidu.com')
				time.sleep(10)
		10.前进后退
			borwser.forward() # 前进
			borwser.back()    #后退
		11.滑动
			1.常见代码
				window.scrollBy(x,y)
				window.scrollBy(0,300) # 运行一次就滑动一次
				window.scrollTo(0,300) # 一步到位，多次运行也是一样结果
				driver.execute_script('window.scrollBy(0, 1000);')
			2.滑动到底部
				# 向下滑动到页面底部
				browser.execute_script('window.scrollTo(0, document.body.scrollHeight);') # 最大body距离 document.body.scrollHeight
				# 滑动到顶部
				browser.execute_script('window.scrollTo(0,0);')
				# 当前y轴位置
				y = browser.execute_script("return window.scrollY")
				print(y)
			3.慢慢滚
				for i in range(10):
					time.sleep(0.5)
					browser.execute_script(f'window.scrollTo(0,{i * 300})')
	5.经验用法
		1.配置项 使用配置对象
			1.不让浏览器提示 有自动化程序控制 的提示
				option = webdriver.ChromeOptions()
				# 解决谷歌浏览器提示“Chrome正在受到自动化测试软件的控制”
				option.add_experimental_option("useAutomationExtension", False)
				option.add_experimental_option("excludeSwitches", ["enable-automation"])
				# option.add_argument(‘–headless’) # 给chrome_options添加headless参数
				browser = webdriver.Chrome(options=option)
			2.综合配置项
				from selenium.webdriver.common.by import By
				from selenium import webdriver
				import time
				from selenium.webdriver.support.ui import WebDriverWait
				from selenium.webdriver.support import expected_conditions as EC

				options = webdriver.ChromeOptions()
				# 解决谷歌浏览器提示“Chrome正在受到自动化测试软件的控制”
				options.add_experimental_option("useAutomationExtension", False)
				options.add_experimental_option("excludeSwitches", ["enable-automation"])

				# 无头模式 在后台运行 装逼用的
				# options.add_argument("-headless")
				# 设置代理
				# options.add_argument("--proxy-server=http://123.33.251.23:8080")
				# 设置浏览器大小
				options.add_argument("--window-size=1920,1080")
				# 禁用浏览器通知
				options.add_argument("--disable-notifications")
				# 通过设置user-agent
				ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537111111.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36'
				options.add_argument(f'user-agent={ua}')
				# 禁用扩展程序
				options.add_argument("--disable-extensions")
				# 设置浏览器语言
				options.add_argument("--lang=zh-CN")
				# 启用开发者模式 打开的时候自动开启f12
				options.add_argument("--auto-open-devtools-for-tabs")

				# 禁止自动化提示
				options.add_experimental_option("excludeSwitches", ["enable-automation"])
				options.add_experimental_option("useAutomationExtension", False)
				# 禁用自动化控制接口实现防止被检测
				options.add_argument('--disable-blink-features=AutomationControlled')

				# 禁止图片
				prefs = {"profile.managed_default_content_settings.images": 2}
				options.add_experimental_option("prefs", prefs)
				# 安装插件
				extension_path = r'S:\project 2021\other\ChromeHelper\chrome tomorrow\commonPlugs\xpath\xpath.crx'
				options.add_extension(extension_path)

				# 初始化配置
				browser = webdriver.Chrome(options=options)
				# 将浏览器最大化显示
				# browser.maximize_window()
				browser.get("https://www.baidu.com")
				# 设置宽高
				# browser.set_window_size(480, 800)
				# 通过js新打开一个窗口
				# browser.execute_script('window.open("http://httpbin.org/ip");')

		2.稍微综合用法
			browser.get("https://www.baidu.com/")
			browser.find_element(By.NAME,'wd').send_keys("python")
			browser.find_element(By.ID,"su").click()
			print(browser.page_source.encode('utf-8')) #获取网页源码
			print(browser.get_cookies()) # 获取cookies
			print(browser.get_screenshot_as_file('123.png')) # 保存图片
			print(browser.current_url) #获取当前路径
			time.sleep(10)
		3.等待 某个/全部 元素加载完毕
			1.基本代码
				# 等待某个标签加载，如果没加载就抛出异常
					wait.until(EC.presence_of_element_located((By.ID,"key")))
				# 等待符合条件的标签全部加载完成
					wait.until(EC.presence_of_all_elements_located((By.ID,"key")))
			2.用法举例
				from selenium.webdriver.common.by import By
				from selenium import webdriver
				import time
				from selenium.webdriver.support.ui import WebDriverWait
				from selenium.webdriver.support import expected_conditions as EC

				option = webdriver.ChromeOptions()
				# 解决谷歌浏览器提示“Chrome正在受到自动化测试软件的控制”
				option.add_experimental_option("useAutomationExtension", False)
				option.add_experimental_option("excludeSwitches", ["enable-automation"])
				# option.add_argument(‘–headless’) # 给chrome_options添加headless参数
				browser = webdriver.Chrome(options=option)

				wait = WebDriverWait(browser,10)
				browser.get("https://www.baidu.com")
				# 等待某个标签加载，如果没加载就抛出异常
				wait.until(EC.presence_of_element_located((By.NAME,"key")))
				# 等待符合条件的标签全部加载完成
				wait.until(EC.presence_of_all_elements_located((By.ID,"key")))
			3.用法举例2
				from selenium import webdriver
				from selenium.webdriver.common.by import By
				from selenium.webdriver.support.ui import WebDriverWait  # available since 2.4.0
				from selenium.webdriver.support import expected_conditions as EC  # available since 2.26.0
				from selenium.webdriver.chrome.options import Options
				from selenium.webdriver.remote.webelement import WebElement
				from time import sleep
				import traceback

				chrome_options = Options()
				chrome_options.add_argument('--headless')
				# chrome_options.add_argument('--disable-gpu')
				driver = webdriver.Chrome(options=chrome_options)
				# driver.maximize_window()
				# driver.get("https://www.baidu.com")
				driver.get("https://www.baidu.com")
				print(driver.title)
				# 繁体字
				html = driver.execute_script("return document.documentElement.outerHTML")
				try:
					element = WebDriverWait(driver, 360).until(EC.presence_of_element_located((By.CLASS_NAME, "s-top-left-new")))
					# driver.find_element_by_id("").
					eles = driver.find_elements(By.XPATH, "//ul[@id='hotsearch-content-wrapper']/li")
					print(eles)
					eles = [ele.text for ele in eles]
					for ele in eles:
						print(f"news:{ele}")
				except (Exception, e):
					traceback.print_exc()
				html = driver.execute_script("return document.documentElement.outerHTML")
				sleep(3)
8.csv 模块
	import csv
	with open('data.csv', 'r+', encoding='utf-8',newline="") as f:
		# 第一种 写法
		# data = ["id","name","age"]
		# writer = csv.writer(f)
		# writer.writerow(data)
		# writer.writerow(["1","zs",50])
		# writer.writerow(["2","zs1",51])
		# writer.writerows([["3","zs2",52],["4","zs3",53]])
		# 第二种 写法
		# writer = csv.DictWriter(f,fieldnames=["id","name","age"])
		# writer.writeheader()
		# writer.writerow({"id":"1","name":"zs","age":50})
		# writer.writerow({"id":"2","name":"zs2","age":51})
		# writer.writerow({"id":"3","name":"zs3","age":52})

		#第一种 读法
		# reader = csv.reader(f)
		# for row in reader:
		#     print(row) # ['id', 'name', 'age']

		#第二种 读法
		reader = csv.DictReader(f)
		for row in reader:
			print(row) # {'id': '3', 'name': 'zs3', 'age': '52'}

杂项相关

1.路径相关
	1.路径一般情况下不用转义 但是 遇到 \try 这种就需要写成 \\try \111.js \\111.js 数字也需要转义
2.字符串相关
	1.字符串前面有r a = r"a\tb" r表示的是这个字符串是原始字符串 所有的\不具备转义 功能
		import re
		text1 = "app le"
		matches1 = re.match('app\\sle', text1)
		print(matches1)  # <re.Match object; span=(0, 6), match='app le'>
		matches1 = re.match(r'app\\sle', text1)
		print(matches1)  # None
	2.b"123" == "123".encode("utf-8") # True 结果 都是字节集
3.关于混淆
	1.常见的代码混淆手段
		1.压缩代码
		2.字符串加密(AES Base64)
		3.代码分拆和重组(将原始代码分拆为很多片段 以不同的顺序重组)
		4.变化语法来增加代码复杂性
		5.无意义的代码插入
		6.控制流混淆 (JavaScript Obfuscator 和 Closure Compiler)
		7.代码加密 (WASM)
	2.混淆的弊端
		1.增大代码的体积 浪费流量
	3.混淆的网址
		1.https://www.jsjiami.com/jsfuck.html
4.关于各种编码
	1.encode 结果是返回的字节集
		a = "123"
		print(a.encode("utf-8"))
5.异常处理
	1.代码
		try:
			a = 1/0
		#except Exception as e: 这种写法任意错误都可以 当然错误分很多种
		except ZeroDivisionError as e:
			print(e) #division by zero 零不能作除数 所以报错
		else:
			print("No exception") # 如果不发生异常 走这里
		finally:
			print("Finally") # Finally 无论怎样都走这里
		print("over")
6.装饰器
	1.装饰器代码
		#定义装饰器 被装饰的函数 当作参数 传入到 return 的函数 中去
		def outer(func):
			 def wrapper(*args, **kwargs):
				 print('begin')
				 func(*args, **kwargs)
				 print('end')
			 return wrapper

		@outer
		def login(*args,**kwargs):
			print("login.....")
		#输出结果
		#begin
		#login.....
		#end
		if __name__ == '__main__':
			login(user='admin',pwd='123')
7.类
	1.类的三个属性
		1.__doc__ 参数说明
		2.__name__ print(__name__) # 如果是执行文件 __main__ 如果是类的话 __main__ 是包名
			class Animal(object):
				def __init__(self):
					self.name = __name__
				def __str__(self):
					return "Anmial Info"

			animal = Animal()
			print(animal.name) # __main__ 如果在类文件里面调用

			from test import Animal
			animal = Animal()
			print(animal.name) # test 如果 在引用类的文件里面调用 会输出 两条 test 也就是说 上面的 __main__ 也会变
				1.所以有  if __name__ = "__main__" 来判断  说明在类内部运行
		3.__str__
			class Animal(object):
				def __init__(self):
					self.name = __name__
				def __str__(self):
					return "Anmial Info"

			if __name__ == "__main__":
				animal = Animal()
				print(animal.name)  # __main__
				print(Animal()) # "Anmial Info"

python 简单的类结构

class Car:
    def __init__(self, make, model, year):
        self.__make = make      # 私有变量
        self.__model = model    # 私有变量
        self.__year = year      # 私有变量

    def get_make(self):
        return self.__make     # 通过公共方法访问私有变量

    def set_make(self, make):
        self.__make = make     # 通过公共方法修改私有变量

car = Car("Toyota", "Camry", 2022)
print(car.get_make())         # 输出: Toyota

car.set_make("Honda")
print(car.get_make())         # 输出: Honda

# 尝试直接访问私有变量
print(car.__make)             # 报错: AttributeError: 'Car' object has no attribute '__make'

简单的 继承 Animal Dog

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def speak(self):
        print("I am an animal")
    def say_name(self):
        print(f"My name is {self.name},age is {self.__age}")

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)
        self.breed = breed
    def speak(self):
        print("I am a dog")

dog = Dog("FuGui", 3, "Labrador")
dog.speak() # I am a dog
dog.say_name() # My name is FuGui,age is 3
print(dog.name) # FuGui
print(dog.__age) # AttributeError: 'Dog' object has no attribute '__age' 私有 属性外部不可以访问

复杂的 Animal Dog 继承

class Animal:
    def __init__(self, name="animal", age=99):
        Person("Animal Constructor")
        self.name = name
        self.__age = age
    def speak(self):
        print("I am an animal")
    def say_name(self):
        print(f"My name is {self.name},age is {self.__age}")
    def stand(self):
        print("Animal is standing")
    def aniaml_id(self):
        print("Animal id is 123")
class Person:
    def __init__(self, name, age):
        print("Person Constructor")
        self.name = name
        self.__age = age
    def stand(self):
        print("Person is standing")

class Dog(Person,Animal): # 多继承 谁在前面 谁的方法 优先 比如 stand 可以理解为 作用域链 找到就不再继续找了
    def __init__(self, name, age, breed):
        super().__init__(name, age) # 这里的 super() 是父类 Person 谁在前面执行 谁的构造方法
        #整个过程 Animal super() 的 构造函数没有执行 也就是说 构造方法没有执行
        # 想调用 Animal 的构造函数
        self.breed = breed
    def speak(self):
        print("I am a dog")
    def eat():
        print("Dog can eat")

dog = Dog("FuGui", 3, "Labrador")
dog.stand()
dog.speak() # I am a dog
dog.aniaml_id() # Animal id is 123 虽然 Animal 的 构造函数  __init__ 没有执行 但是方法依然是继承了
# dog.say_name() # My name is FuGui,age is 3 如果 Dog 多继承时候 Animal 放后面 由于 constructor 没有执行 所以这个方法报错
print(dog.name) # FuGui
# print(dog.__age) # AttributeError: 'Dog' object has no attribute '__age' 私有 属性外部不可以访问
Dog.eat() # Dog can eat 不需要 私有属性装饰器 @staticmethod 好像也没问题

8.模块的封装
	1.单文件 Animal.py
		1.代码
			class Animal(object):
				def __init__(self,name,brand,age):
					self.name = name
					self.age = age
					self.brand = brand
				def speak(self):
					print("I am a {} and I am {} years old".format(self.name,self.age))
			def add(a,b):
				print(a+b)

			import Animal
			animal = Animal.Animal("Dog", "Brown", 4)
			animal.speak() # I am a Dog and I am 4 years old
			Animal.add(1,2) # 3
			animal.add(2,3) # ttributeError: 'Animal' object has no attribute 'add'

			from Animal import Animal
				1.如果用这种模式调用 Animal.add(1,2) # 这个也会报错 因为只是调用了文件Animal 里面的 类
	2.多文件
		1.其实就是一个文件夹下面有很多个 py 文件
		2.需要文件夹下有一个 __init__.py 的空文件 即可
		3.代码
			#add.py
			def add(a,b):
				return a + b

			#Animal.py
			class Animal(object):
				def __init__(self,name,brand,age):
					self.name = name
					self.age = age
					self.brand = brand
				def speak(self):
					print("I am a {} and I am {} years old".format(self.name,self.age))

			#MulDiv.py
			def mult(a,b):
				return a*b
			def div(a,b):
				return a/b

			#调用文件
			from myMath.Animal import Animal
			from myMath.add import add
			from myMath.MulDiv import mult,div
			animal = Animal("dog","wangwang",3)
			animal.speak()
			print(add(1,2)) # 3
			print(mult(3,2)) #
			print(div(3,2)) # 1.5
9.数据库
	1.mysql
		1.代码
			import pymysql
			import time
			db = pymysql.connect(host='localhost',user='root',password='abc',db='abc')
			cursor = db.cursor() # 需要 cursor 去执行 语句 但是 提交 commit 和 close 需要 db
			#查询
			res = cursor.execute("select * from de_data limit 205,50") # 返回查询到的条数
			data = cursor.fetchall() # 获取到查询的所有结果

			for i in data:
				print(list(i)) # tuple 结果 每条
				pass

			#插入
			sql = "insert into de_data (email,other_pwd) values (%s,%s)" # 返回查询到的条数
			values = ('python001@gmail.com','abcdefg') # 数据单独写进values
			res = cursor.execute(sql,values) # 执行sql并替换 values 执行后的结果返回一个整数 表示影响的行数
			res = db.commit() # 然后 db 提交 不返回任何东西 None
			db.close() # 关闭 Db
	2.mongodb
		1.代码
			import pymongo
			client = pymongo.MongoClient(host="localhost", port=27017) # MongoClient(host=['localhost:27017']...)
			db = client["tt"] # 选择数据库 Database(MongoClient(host=['localhost:27017'],... 'tt')
			table = db["abc_1"] # 选择表 Collection(Database(MongoClient(host=['localhost:27017'], ... 'tt', 'abc_1')

			# 插入数据
			data = {"name": "zhangsan", "age": 18, "sex": "男"} # 数据的列表可以没有 没有就自动添加一行

			res = table.insert_one(data) # InsertOneResult(ObjectId('662793daf302de51214b7247'), acknowledged=True)

			data2 = [{"name": "lisi", "age": 20, "sex": "女"}, {"name": "wangwu", "age": 22, "sex": "男"}]
			res = table.insert_many(data2)
			print(res) #InsertManyResult([ObjectId('6627943d0f8ccbc8eb75f552'), ObjectId('6627943d0f8ccbc8eb75f553')])

			res = table.find()
			for i in res:
				print(i) # {'_id': ObjectId('662797f32f994fd3350c0615'), 'name': 'zhangsan', 'age': 18, 'sex': '男'}

课件相关

https://docs.qq.com/sheet/DREJyckVrcEV6WVlU?tab=000001 
教学案例（随用随更）：【腾讯文档】爬虫百例-宇哥实战 ：群文件自取 
测试练习题 ：【腾讯文档】测试练习题 （都是实战） 
https://docs.qq.com/doc/DRGR0cENDWk9xd21R 
课件资料：群文件自取 
ps：没有基础或基础不好不要跳着看 
Python课件更新中：https://docs.qq.com/doc/DREFKSHFSc2ZQTll4