Python基础语法

以你之姓@ 2021-11-02 09:02 641阅读 0赞

### 七月在线之python基础入门 ###

*  python的环境搭建
 *   *  python包下载链接
     *  下载Anaconda 的方法
     *  网页编程方式
 *  python规则
 *   *  编程基础
     *   *  exec, eval，help，三元表达式，unpack解包，\*号收集，推导式，常用功能
     *  可迭代对象Iterable,迭代器iterator,生成器generator
     *  闭包，装饰器
     *  异常处理：try...except...、try...except...else...、try...finally...、手动抛出异常raise
     *  不定长位置参数，不定长关键字参数，偏函数
     *  函数
     *   *  匿名函数，回调函数，高阶内置函数
         *  高阶函数
         *   *  map
             *  reduce
             *  filter
             *  sorted
             *  选择排序
             *  冒泡排序
         *  LEGB
     *  面向对象：类，继承，类实例对象，类对象
     *   *  下划线
         *  类
         *  继承
         *  类实例对象与类对象访问实例变量的区别
         *  描述符
         *  类工厂函数
         *  元类
     *  文件操作：文件打开、关闭、读写、定位读写，重命名，删除
     *  文件夹操作：创建文件夹，获取当前目录，获取目录列表，删除文件夹（os模块）
     *  PIL库
     *   *  生成一张固定尺寸固定颜色的图片
         *  生成一张随机颜色的图片
         *  生成一张带有固定字符串的随机颜色的图片
         *  生成一张带有随机字符串随机颜色的图片
         *  生成一张模糊的随机数字4位验证码图片
     *  正则表达式/Regular Expression
     *   *  规则
         *  举例
     *  爬虫
 *  python刷题
 *   *  输出200以内的可逆素数
     *  统计字符串中，各个字符的个数
     *  模拟斗地主，有3个玩家，一付扑克牌，留3张底牌， 将扑克牌随机分配给3个玩家并显示（注意有四种花色和两个王）
     *  设计一个公司类
     *  while循环完成图形输出
     *  “名片管理器”项目

# python的环境搭建 #

## python包下载链接 ##

https://pypi.org/

## 下载Anaconda 的方法 ##

搜索Anaconda 清华镜像→点击并进入清华大学开源软件镜像站→点击链接→选择合适的anaconda安装包  
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]

## 网页编程方式 ##

安装完annaconda后，打开Jupyter Notebook。

# python规则 #

## 编程基础 ##

### exec, eval，help，三元表达式，unpack解包，\*号收集，推导式，常用功能 ###

# exec执行声明语句, eval执行表达式
    	exec('feng = 7')
    	feng
    	Out[4]: 7
    	'feng'
    	Out[5]: 'feng'
    	eval('feng')
    	Out[6]: 7
    
    # 使用帮助
    	help(exec)
    	Help on built-in function exec in module builtins:
    	exec(source, globals=None, locals=None, /)
    	    Execute the given source in the context of globals and locals.
    	    
    	    The source may be a string representing one or more Python statements
    	    or a code object as returned by compile().
    	    The globals must be a dictionary and locals can be any mapping,
    	    defaulting to the current globals and locals.
        
    #文本转义
    	print('I\' am 007')
    	I' am 007
    
    #交换赋值
    	a,b=b,a
    	
    #命名
    	# 普通命名法
    		teacher_name='david'
    		teacher_name
    		
    		Out[29]: 'david'
    	# 直接命名法
    		globals()['teacher']='feng'
    		teacher
    		
    		Out[31]: 'feng'
    		
    #unpack解包
    	l1=[1,2,3,4,5,'6']
    	a,b,c,d,e,f=l1
    	print(a,b,c,d,e,f)
    	1 2 3 4 5 6
    
    #三元表达式
    	age=18
    	'a' if age>50 else 'b'
    	Out[58]: 'b'
    	
    	# expression只能放在左边，因为三元只能对一个变量操作。。
    	a=b=c=15
    	a=5 if b>20 else 3
    	a
    	Out[63]: 3
    # copy.copy和copy.deepcopy
    	import copy
    	a = [1, 2, 3, 4, ['a', 'b']]  # 原始对象 
    	b = a  # 赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变
    	c = copy.copy(a)  # 浅拷贝，只拷贝父对象，子对象会跟着变。
    	d = copy.deepcopy(a)  # 深拷贝,即将被复制对象完全再复制一遍作为独立的新个体单独存在
    	a.append(5)  # 修改对象a 
    	a[4].append('c')  # 修改对象a中的['a', 'b']数组对象 
    	
    	a
    	Out[62]: [1, 2, 3, 4, ['a', 'b', 'c'], 5]
    	b
    	Out[63]: [1, 2, 3, 4, ['a', 'b', 'c'], 5]
    	c
    	Out[64]: [1, 2, 3, 4, ['a', 'b', 'c']]
    	d
    	Out[65]: [1, 2, 3, 4, ['a', 'b']]
    
    #*号收集
    	l1=[1,2,3,4,5,'6']
    	a,*b,c=l1   #  a 接收1，c接收6，其余放在b中
    	print(a,b,c)
    	1 [2, 3, 4, 5] 6
    	c
    	Out[19]: '6'
    	
    	type(c)
    	Out[22]: str
    
    # 字典推导式：
    	# 用字典推导式求一个字符串,以及它的位置下标
    		str1=['i','love','china']
    		{
        key:value for key,value in enumerate(str1)}
    		
    		Out[12]: {
        0: 'i', 1: 'love', 2: 'china'}
    	
    	# 用字典推导式求一个字符串,以及它的位置下标.(以最后一次出现的字符求位置索引)
    		str1='i love china for ever!'
    		{
        item:itemno for itemno,item in enumerate(str1)}
    		
    		Out[3]: 
    		{
        ' ': 16,
    		 '!': 21,
    		 'a': 11,
    		 'c': 7,
    		 'e': 19,
    		 'f': 13,
    		 'h': 8,
    		 'i': 9,
    		 'l': 2,
    		 'n': 10,
    		 'o': 14,
    
    # 常用功能说明
    	help(obj) 在线帮助, obj可是任何类型    
    	
    	
    	eval(str) 表示合法的python表达式，返回这个表达式 
    	exec(str) 执行合法的python声明，返回字节码
    	
    	
    	#名字空间相关
    	dir(obj) 查看obj的name space中可见的name
    	vars(obj) 返回一个object的name space。用dictionary表示    
    	locals() 返回一个局部name space,用dictionary表示    
    	globals() 返回一个全局name space,用dictionary表示
    	
    	#类型
    	type(obj) 查看一个obj的类型    
    	isinstance(obj,cls) 查看obj是不是cls的instance    
    	issubclass(subcls,supcls) 查看subcls是不是supcls的子类  
    	
    	#类型转换
    	chr(i) 把一个ASCII数值,变成字符    
    	ord(i) 把一个字符或者unicode字符,变成ASCII数值    
    	oct(x) 把整数x变成八进制表示的字符串    
    	hex(x) 把整数x变成十六进制表示的字符串    
    	str(obj) 得到obj的字符串描述    
    	list(seq) 把一个sequence转换成一个list    
    	tuple(seq) 把一个sequence转换成一个tuple    
    	dict(),dict(list) 转换成一个dictionary    
    	int(x) 转换成一个integer    
    	long(x) 转换成一个long interger    
    	float(x) 转换成一个浮点数    
    	complex(x) 转换成复数
    	
    # 查找，替换，统计
    	str3='http://{}.com'
    	#查找与替换
    		str3.find('o')
    		str3.replace('.com','.net')
    	
    	#统计
    		str3.count('com')

## 可迭代对象Iterable,迭代器iterator,生成器generator ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]  
迭代对象:  
以直接作用于 for 循环的数据类型有以下几种：  
一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；  
一类是 generator ，包括生成器和带 yield 的generator function。  
这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。

说明：  
1.凡是可作用于 for 循环的对象都是 Iterable 类型；  
2.凡是可作用于 next() 函数的对象都是 Iterator 类型  
3.集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，  
不过可以通过 iter() 函数获得一个 Iterator 对象。

# 迭代器
    	# 可以使用 isinstance() 判断一个对象是否是 Iterable 对象：
    		from collections import Iterable
    		a = isinstance([], Iterable)
    		b = isinstance({
        }, Iterable)
    		c = isinstance("abc", Iterable)
    		d = isinstance(100, Iterable)
    		e = isinstance((x for x in range(10)), Iterable)
    		print(a)   # True
    		print(b)   # True
    		print(c)   # True
    		print(d)   # False  因为是Number
    		print(e)   # True
    
    	# 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
    		
    		#可以使用 isinstance() 判断一个对象是否是 Iterator 对象：
    		from collections import Iterator
    		a = isinstance([], Iterator)
    		a1 = isinstance(iter([]), Iterator) 
    		b = isinstance({
        }, Iterator)
    		c = isinstance("abc", Iterator)
    		d = isinstance(100, Iterator)
    		e = isinstance((x for x in range(10)), Iterator)
    		
    		print(a)   #false
    		print(a1)  #True
    		print(b)   #false
    		print(c)   #false
    		print(d)   #false
    		print(e)   #true
    		
    	# 用列表推导式（还可以是字典，集合等等）生成迭代器
    		l1 = [x for x in range(30) if x%3==0]  
    		# l1通过列表推导式生成一个containner。因为它是可以被for循环的，因此这个containner又是一个iterable可迭代的，iterable不一定是一个可迭代器iterator，需要加iter。iterator都是iterable。
    		
    		l2 = iter(l1)
    		next(l2)
    		Out[52]: 0
    		next(l2)
    		Out[53]: 3
    		next(l2)
    		Out[54]: 6

创建生成器generator的方式有多种，我们学习其中两个常见的方式：  
方式1：  
用generator expressin生成一个生成器generator，只要把一个列表生成式的 \[ \] 改成 ( )

方式2：  
用generator function生成一个生成器generator。

# 生成器 
 	# 用generator expressin生成一个生成器generator
 		l1 = (x for x in range(30) if x % 3 == 0) # []改为（）
 		
 		next(l1)
 		Out[5]: 0
 		next(l1)
 		Out[6]: 3
 		type(l1)
 		Out[7]: generator
 		
 		# 可以for循环去拿所有的
 		for i in l1:
 		 print(i)
 		 
 		6
 		9
 		12
 		15
 		18
 		21
 		24
 		27
 
 
 	# 用generator function（如里面的yield）生成一个生成器generator
 		# 例1： 生成1,1,2,3,5这样的序列
 			# 普通方法
 				def fib():
 				 a = 0
 				 b = 0
 				 c = 1
 				 while a<5:
 				 
 				 temp = c
 				 c = c + b
 				 b = temp
 				 
 				 a += 1
 				 print(b)
 				
 				fib()
 				
 			# 应用yeild	
 				def fib():
 				 a = 0
 				 b = 0
 				 c = 1
 				 while a < 5:
 				 # temp = c
 				 # c = b + c
 				 # b = temp
 				 #
 				 # a += 1
 				 # print(b)
 				 yield c
 				 b,c = c,b+c
 				 a += 1
 				
 				f = fib()
 				print(next(f))
 				print(next(f))
 				print(next(f))
 				
 				# 结果
 				1
 				1
 				2
 				
 		# 例2				
 			# 这里的yeild返回值，但并不停止，return返回并停止
 			def g2_func(n):
 			 for i in range(n):
 			 yield i ** 2
 			
 			
 			g2 = g2_func(7)
 			next(g2)
 			Out[5]: 0
 			next(g2)
 			Out[6]: 1
 			next(g2)
 			Out[7]: 4
 			next(g2)
 			Out[8]: 9

## 闭包，装饰器 ##

# 闭包
 	def func1():
 	 print("haha")
 	
 	def outer(func):
 	 def inner():
 	 print("*******************")
 	 func()
 	 return inner
 	 
 	# 执行文件
 	f = outer(func1) # 相当于inner
 	print(f)
 	f() # 相当于inner（）
 	
 	# 执行结果
 	<function outer.<locals>.inner at 0x0000003F2BE377B8>
 	*******************
 	haha
 	
 # 装饰器
 	# 例1：
 		def w1(func):
 		 def inner():
 		 # 验证1
 		 # 验证2
 		 # 验证3
 		 func()
 		 return inner
 		
 		@w1
 		def f1():
 		 print('f1')
 		
 		f = f1
 		f()
 		
 		# 结果
 		f1
 	# 例2：	
 	# 多个函数实现不同功能普遍做法，但费时费力，如下
 		def fun1():
 		 print('this is foo1 function')
 		
 		def fun2():
 		 print('this is foo2 function')
 		
 		def fun3():
 		 print('this is foo3 function')
 		
 		
 		# 为以上三个函数添加报时功能
 		import datetime
 		
 		
 		# 设计一个能接收函数的函数，功能是打印时间后，然后返回接收到的函数
 		def outer_fun(func):
 		 print(datetime.datetime.now())
 		 return func
 		
 		
 		outer_fun(fun2)()
 		# 输出结果
 		2019-08-15 17:30:04.253557
 		this is foo2 function
 
 	# 例3：
 	
 		import datetime
 		
 		
 		def outer_fun(fun):
 		 # do something you want here
 		 str1 = 'This is string from outer'
 		
 		 def inner():
 		 print(str1)
 		 print('from inner to execute:', fun.__name__)
 		 print('the', fun.__name__, 'result:', fun())
 		 print('extra:', datetime.datetime.now())
 		
 		 return inner
 		
 	# 例4：	
 		def outer(func):
 		 def inner():
 		 print('executed:', func())
 		 return inner
 		
 		@outer
 		def fun1():
 		 return 'this is fun1 function--'
 		
 		fun1()
 		print(type(fun1))
 	
 		# 运行结果
 		executed: this is fun1 function--
 		<class 'function'>
 	
 	# 例5：
 		#定义函数：完成包裹数据
 		def makeBold(fn):
 		 def wrapped():
 		 return "" + fn()
 		 return wrapped
 		
 		#定义函数：完成包裹数据
 		def makeItalic(fn):
 		 def wrapped():
 		 return "" + fn()
 		 return wrapped
 		
 		@makeBold
 		def test1():
 		 return "hello world-1"
 		
 		@makeItalic
 		def test2():
 		 return "hello world-2"
 		
 		@makeBold
 		@makeItalic
 		def test3():
 		 return "hello world-3"
 		
 		print(test1())
 		print(test2())
 		print(test3())
 		
 		# 结果
 		hello world-1
 		hello world-2
 		hello world-3

## 异常处理：try…except…、try…except…else…、try…finally…、手动抛出异常raise ##

# 捕获并处理异常对象，后续代码可以运行
 	try:
 	 a = never_named_value
 	 print(int(a))
 	except ValueError: # 发生ValueError错误执行以下代码
 	 print("Error: 函数参数传值错误")
 	except NameError: # 发生NameError错误执行以下代码
 	 print("Error: 名称空间使用出错")
 	else:
 	 print('Everything is fine')
 print('end line')
 
 	Error: 名称空间使用出错
 	end line
 	
 # 手动抛出异常
 	# 例1
 	
 		def addfunc(a,b):
 		 if type(a)!=type(b):
 		 raise ValueError('类别错误') #或者 raise ValueError,'Invalid value'
 		 return a+b
 		addfunc(5,'f')
 		
 		# 执行结果
 		Traceback (most recent call last):
 		 File "D:\software\anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 2881, in run_code
 		 exec(code_obj, self.user_global_ns, self.user_ns)
 		 File "<ipython-input-16-b82082bcbeb3>", line 5, in <module>
 		 addfunc(5,'f')
 		 File "<ipython-input-16-b82082bcbeb3>", line 3, in addfunc
 		 
 	# 例2
 	
 		class design_wrong(Exception): # Exception是父类
 		 def __init__(self, length, atleast):
 		 self.length = length
 		 self.atleast = atleast
 		
 		def main():
 		 try:
 		 s = input('请输入 --> ')
 		 if len(s) < 3:
 		 # raise引发一个你定义的异常
 		 raise design_wrong(len(s), 3)
 		 except design_wrong as result:#这个变量被绑定到了错误的实例
 		 print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'%
 		 (result.length, result.atleast))
 		 else:
 		 print('没有异常发生.')
 		
 		main()
 		
 		# 执行结果
 		请输入 --> 4
 		ShortInputException: 输入的长度是 1,长度至少应是 3

## 不定长位置参数，不定长关键字参数，偏函数 ##

# 不定长位置参数
 	# def myadd1(a,b,c,d,*parms): # 一个*是元祖
 	 print(type(parms))
 	 print('parms:',parms)
 	 print('a,b,c,d:',a,b,c,d)
 	 return sum(parms)
 	myadd1(1,2,3,4,5,6)
 	
 	<class 'tuple'>
 	parms: (5, 6)
 	a,b,c,d: 1 2 3 4
 	Out[3]: 11
 	
 # 关键字参数
 	#例1：
 		def myadd0(args,lastnum=1000): # 默认参数一定放在后面
 	 	return args+lastnum
 		myadd0(7)
 		
 		Out[5]: 1007
 	
 	#例2
 		def myPrint(str, age):
 		 print(str, age)
 		
 		#使用关键字参数
 		myPrint(age = 18, str = "张三")
 		
 		Out[6]:张三 18
 
 # 不定长关键字参数
 	#例1
 		def myadd(**kwargs): # 2个*是字典 
 		 print(kwargs)
 		myadd(add='sh', tel=13333)
 		
 		{
 'add': 'sh', 'tel': 13333}
 		
 	# 例2
 		def person(name,age,**kw):
 		 print('name:',name,'age:',age,'other:',kw)
 		person('Frank','37')
 		person('Frank','37',city='Shanghai')
 		person('Frank','37',gender='M',job='Engineer')
 		
 		# 结果
 		name: Frank age: 37 other: {
 }
 		name: Frank age: 37 other: {
 'city': 'Shanghai'}
 		name: Frank age: 37 other: {
 'gender': 'M', 'job': 'Engineer'}		
 	
 	
 # 综合使用（不定长位置参数，不定长关键字参数）
 	def myfun1(*args,**kwargs):
 	 print(args)
 	 for item in kwargs:
 	 print(item)
 	d1={
 'name':'david','add':'bj','date':'2018-8-1'}
 	l1=[1,2,3,4,5,6,7]
 	myfun1(*l1,**d1)
 
 	(1, 2, 3, 4, 5, 6, 7)
 	name
 	add
 	date
 	
 # 偏函数
 	def mysal(nums,rate=2):
 	 return nums*rate
 	mysal(5)
 	import functools
 	rmb2jpn=functools.partial(mysal,rate=4)
 	rmb2jpn(7)
 	
 	Out[16]: 28
 	
 # local（），返回一个局部name space,用dictionary表示 
 # 函数内部定义的参数只在内部有效
 b=2
 	def a():
 	 f = 15
 	 b = 34
 	 print(locals())
 	a()
 	
 	{
 'b': 34, 'f': 15}
 	b
 	Out[17]:2

## 函数 ##

### 匿名函数，回调函数，高阶内置函数 ###

# 匿名函数
 	def a(x,y):
 		return x+y
 	a(2,3)
 	Out[73]: 5
 	
 	# 可以写成
 	a = lambda x,y:x+y
 	a(2,3)
 	Out[74]: 5
 	
 # 匿名函数作为参数传递
 	def fun(a, b, opt):
 	 print('a=', a)
 	 print('b=', b)
 	 print('result=', opt(a, b))
 	fun(1, 2, lambda x, y: x + y)
 	
 	a= 1
 	b= 2
 	result= 3
 	
 # 回调函数	
 	# 定义：
 	
 	# 回调函数就是一个通过函数指针调用的函数。
 	# 如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，就说这是回调函数
 	
 	
 	# 回调函数1
 	# 生成一个2k形式的偶数
 	def double(x):
 	 return x * 2
 	
 	# 回调函数2
 	# 生成一个4k形式的偶数
 	def quadruple(x):
 	 return x * 4
 	
 	# 中间函数
 	# 接受一个生成偶数的函数作为参数
 	# 返回一个奇数
 	def getOddNumber(k, getEvenNumber):
 	 return 1 + getEvenNumber(k)
 	
 	
 	# 起始函数，这里是程序的主函数
 	def main():
 	 k = 1
 	 # 当需要生成一个2k+1形式的奇数时
 	 i = getOddNumber(k, double)
 	 print(i)
 	 # 当需要一个4k+1形式的奇数时
 	 i = getOddNumber(k, quadruple)
 	 print(i)
 	 # 当需要一个8k+1形式的奇数时
 	 i = getOddNumber(k, lambda x: x * 8)
 	 print(i)
 	main()
 
 
 # 高阶内置函数
 	# map
 		map?
 		Init signature: map(self, /, *args, **kwargs)
 		Docstring: 
 		map(func, *iterables) --> map object
 		Make an iterator that computes the function using arguments from
 		each of the iterables. Stops when the shortest iterable is exhausted.
 		Type: type
 	
 		# map映射，它的类型是map，用list转换成列表方式查看
 		l1=[1,2,3,4,5,6,7]
 		l2=[7,8,9,10,11,12,13]
 		type(map(lambda x,y:x+y,l1,l2))
 		Out[79]: map
 		list(map(lambda x,y:x+y,l1,l2))
 		Out[78]: [8, 10, 12, 14, 16, 18, 20]
 		
 	# reduce
 		from functools import reduce
 		reduce?
 		
 		Docstring:
 		reduce(function, sequence[, initial]) -> value
 		Apply a function of two arguments cumulatively to the items of a sequence,
 		from left to right, so as to reduce the sequence to a single value.
 		For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
 		((((1+2)+3)+4)+5). If initial is present, it is placed before the items
 		of the sequence in the calculation, and serves as a default when the
 		sequence is empty.
 		
 		# 例：
 		from functools import reduce
 		l1 = [1,2,3,4]
 		reduce(lambda x,y:x+y,l1)
 		Out[84]: 10
 	# filter：按照给定条件过滤
 		l1 = [1,2,3,4]
 		list(filter(lambda x:True if x<3 else False,l1))
 		
 		Out[86]: [1, 2]

### 高阶函数 ###

#### map ####

定义： map() 会根据提供的函数对指定序列做映射。
    语法 map() 函数语法： map(function, iterable, ...)
    map方法的描述：创建一个迭代器，使用每个迭代项。当最短的迭代被耗尽时停止。
    参数
        function -- 函数，有两个参数
        iterable -- 一个或多个序列 
    返回值： Python 2.x 返回列表。 Python 3.x 返回迭代器。
    参数function传的是一个函数名，可以是python内置的，也可以是自定义的。 参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。
    这个函数的意思就是将function应用于iterable的每一个元素

#将单个字符转成对应的字面量整数
    def chr2int(chr):
        return {
        "0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]
    list1 = ["2","1","6","5"]
    res = map(chr2int, list1)
    
    print(res)
    print(list(res))

<map object at 0x0000002F5BFA2F98> 
\[2, 1, 6, 5\]

#### reduce ####

方法的描述：
    将两个参数的函数累加到序列的项中，从左到右，以便将序列减少到单个值。
    例如，减少（lambda x，y:x+y，[1, 2, 3，4, 5 ]）计算
    （（（1＋2）＋3）＋4＋5）。如果初始存在，则放置在项目之前。
    在计算中的顺序，当默认为序列
    
    函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
    用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
    格式：
    reduce(function, iterable[, initializer])
    参数说明：
        function -- 函数，有两个参数
        iterable -- 可迭代对象
        initializer -- 可选，初始参数
    注意：一个函数作用在序列上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素
    累计运算
    返回值：返回函数计算结果

例1：计算序列之和

from functools import reduce
    aa=reduce(lambda x,y:x+y,[1,2,3,4,5])
    print(aa)

15  
例2：获取每个词出现的次数（以空格分割）

# 获取每个词出现的次数（以空格分割）
    from functools import reduce
    str="an apple a banana three apple a desk"
    list=str.split(' ')
    def fun(x,y):
        if y in x:
            x[y]=x[y]+1
        else:
            x[y]=1
        return x
    result=reduce(fun,list,{
        }) # 第三个参数为初始值, 第一次，初始字典为空，作为fun的第一个参数
    print(result)

\{‘an’: 1, ‘apple’: 2, ‘a’: 2, ‘banana’: 1, ‘three’: 1, ‘desk’: 1\}

例3：将字符串转成对应字面量数字

#将字符串转成对应字面量数字
    
    from functools import reduce
    def str2int(str):
        def fc(x, y):
            return x * 10 + y
        def fs(chr):
            return {
        "0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}[chr]
    
        a = map(fs, list(str))
        # print(list(a))
        # print(type(a))
        return reduce(fc, a)
    
    
    a = str2int("12")
    print(a)
    print(type(a))

#### filter ####

"""
    定义：
    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
    
    方法的描述：
    返回一个迭代器，为其生成函数（项）的可迭代项是真的。如果函数为“否”，则返回真实的项。
    
    该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
    然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
    语法
    
    格式：
    filter(function, iterable)
    
    参数
        function --参数1为函数 判断函数。
        iterable --参数2为序列 可迭代对象。
    '''
    
    原型：filter(fn, lsd)
    
    功能：用于过滤序列
    白话文：把传入的函数依次作用与序列每个元素，根据返回的是True还是False决定是否保留该元素
    """

例1

#案例：筛选指定的元素
    list1 = [1,2,3,4,5,6,7,8,9]
    #筛选条件
    def func(num):
        #偶素保留
        if num%2 == 0:
            return True
        #奇数剔除
        return False
    l = filter(func, list1)
    print(list(l))   # [2, 4, 6, 8]
    print(list1)     # [1, 2, 3, 4, 5, 6, 7, 8, 9]

例2

data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]
    def func2(v):
        v = str(v)
        if v == "无":
            return False
        return True
    for line in data:
        m = filter(func2, line)
        print(list(m))

\[‘姓名’, ‘年龄’, ‘爱好’\]  
\[‘tom’, 25\]  
\[‘hanmeimei’, 26, ‘金钱’\]

#### sorted ####

"""
    定义：
    sorted() 函数对所有可迭代的对象进行排序操作。
    
        sort 与 sorted 区别：
        sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
        list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
    
    格式：
    sorted(iterable[, cmp[, key[, reverse]]])
    
    参数说明：
        iterable -- 可迭代对象。
        cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
        key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
        reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    
    返回值：
    返回重新排序的列表。
    
    """

升序，降序

# 普通排序
    list1 = [4,7,2,6,3]
    list2 = sorted(list1)#默认升序排序
    print(list2)
    
    
    # 按绝对值大小排序
    list3 = [4,-7,2,6,-3]
    #key接受函数来实现自定义排序规则
    list4 = sorted(list3, key=abs)
    print(list4)
    
    
    # 降序
    list5 = [4,7,2,6,3]
    list6 = sorted(list5, reverse=True)#默认升序排序
    print(list6)
    
    # 函数可以自己写
    def myLen(str):
        return len(str)
    list7 = ['b333','a1111111','c22','d5554']
    list8 = sorted(list7,key=myLen)#默认升序排序
    print(list8)

#### 选择排序 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]  
最小值放第一个

# 选择排序法：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放到序列的起始位置，直到全部排完。
    
    x = [6, 3, 2, 7, 4, 9, 5]
    xLen = len(x)
    
    for i in range(xLen - 1):
        min = i     # 第一轮先假定最小值索引为0
        # 遍历完成之后，min就指向了最小元素的下标
        for j in range(i + 1, xLen):
            if x[min] > x[j]:
                min = j    # 最小值的索引号
    
        # 把将最小的元素值和坐标为i的元素值进行交换
        x[i], x[min] = x[min], x[i]
    
    print(x)

最大值放最后

# 选择排序法：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放到序列的起始位置，直到全部排完。
    x = [6, 3, 2, 7, 4, 9, 5]
    xLen = len(x)
    
    # range(start, stop, step])
    for i in range(xLen - 1, 0, -1):
        m = 0
        for j in range(1, i + 1):
            if x[j] > x[m]:
                 m = j
    
        x[m],x[i] = x[i],x[m]
    
    print(x)

#### 冒泡排序 ####

# 冒泡法：第一趟：相邻的两数相比，大的往下沉。最后一个元素是最大的。
    # 第二趟：相邻的两数相比，大的往下沉。最后一个元素不用比。
    x = [6, 3, 2, 7, 4, 9, 5]
    xLen = len(x)
    
    for i in range(len(x) - 1, 0, -1):
        for j in range(i):
            if x[j] > x[j + 1]:
                x[j + 1], x[j] = x[j], x[j + 1]
    print(x)

### LEGB ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]

# LEGB
    	# L:先找外函数中的内函数的valuel ，
    	# E:如果找不到内函数的valuel就找外函数中，
    	# G:如果再找不到，就找global，
    	# B:最后找不到就到__builtins__中找valuel
    
        # 例：
    	# 分别定义位于LEGB四个不同作用的，相同名字value1的变量
    	__builtins__.value1 = 'B value stored in __builtins__'  # B
    	value1 = 'G value stored in Global'                     # G
    
    	
    	# 而当出现嵌套函数inner时，也会新产生一个locals()，而如果inner此时还引用了在outter这个函数作用域内出现的变量时，就是闭包
    	def outter():
    		# Values store in Enclosure,称为闭包
    	    value1 = 'E value stored in enclosure'              # E
    	
    	    def inner():
    	        value1 = 'L value stored in locals'             # L
    	        print(value1)  # 此时的value1是inner1这个函数外层函数的变量
    	
    	    return inner
    	
    	
    	outter()()

## 面向对象：类，继承，类实例对象，类对象 ##

### 下划线 ###

![在这里插入图片描述][20190827180827372.png]

### 类 ###

# isinstance
 	isinstance(7,int)
 	Out[88]: True
 
 # 类
 	# 例1：
 		'''
 		BMW = Car()，通过BMW来访问属性或者方法
 		表示给BMW这个对象添加属性，BMW.color = '黑色'，如果后面再次出现BMW.color = xxx表示对属性进行修改
 		BMW是一个对象，它拥有属性（数据）和方法（函数）
 		'''
 		
 		# 定义类
 		class Car:
 		 # 移动
 		 def move(self):
 		 print('车在奔跑...')
 		
 		
 		# 创建一个对象，并用变量BMW来保存它的引用
 		BMW = Car()
 		BMW.color = '黑色' # 添加类的属性，color和wheelNum
 		BMW.move()
 		print(BMW.color)
 
 		# 运行结果
 		车在奔跑...
 		黑色
 
 	# 例2：
 		# 学生类设计
 		# 总学生的人数，全部学生的姓名，已经毕业的学生的数量
 		# 考试功能，分数大于60分，pass,，计入总分，否则 fail
 		# 查分功能，如果考试次数
 		# 查所有已经毕业学员的姓名。
 		
 		
 		class Student(): # 这里的（）可有可无
 		
 		 # 类成员变量
 		 student_total = 0 # 学生总人数
 		 student_namelist = [] # 学生名字list
 		 student_graduated_name_list = [] # 符合毕业要求的学生名字list
 		 
 		 # 初始化函数，调用类时，自动运行初始化
 		 def __init__(self, name, age, gender):
 		 self.name = name
 		 self.age = age
 		 self.gender = gender
 		
 		 self.totalscore = 0 # 总分数
 		 self.times = 0 # 考试次数
 		 Student.student_total += 1 # 人数
 		 Student.student_namelist.append(name) # 名字集合
 		
 		 def exam(self, score): # def函数在类中定义叫方法method,以和类外部定义的函数区分
 		
 		 if score < 60:
 		 print('sorry,better luck next time!')
 		 else: # 如果超过60分
 		 self.times += 1 # 考试次数加一
 		 self.totalscore += score # 考试成绩累加
 		 if self.times >= 2:
 		 Student.student_graduated_name_list.append(self.name)
 		
 		
 		
 		 @classmethod # 类方法
 		 def get_graducated_student_list(cls,): # 第一个参数一定是cls
 		 return Student.student_graduated_name_list # 返回类成员变量
 		
 		
 		# 以下为执行文件
 		zhangsan = Student('zhangsan', 23, 'male') # 创建一个类对象，通过对象访问
 		lisi = Student('lisi', 24, 'female')
 		
 		print('..........................................................')
 		print(zhangsan.age) # 张三年纪
 		
 		print('..........................................................')
 		print(Student.student_namelist) # 名字集合
 		print(Student.student_total) # 学生人数
 		
 		print('..........................................................')
 		one = zhangsan.exam(80) # 张三第一次成绩
 		two = zhangsan.exam(85) # 张三第一次成绩
 		print(zhangsan.times, zhangsan.totalscore) # 打印zhangsan考试次数及总分数
 		
 		print('..........................................................')
 		print(Student.get_graducated_student_list())
 	
 		# 执行结果
 		..........................................................
 		23
 		..........................................................
 		['zhangsan', 'lisi']
 		2
 		..........................................................
 		2 165
 		..........................................................
 		['zhangsan']

### 继承 ###

# 继承
 	# 单继承
 		"""
 		说明：
 		
 		 虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，
 		 所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
 		总结
 		 子类在继承的时候，在定义类时，小括号()中为父类的名字
 		 父类的属性、方法，会被继承给子类
 		"""
 		
 		
 		# 定义一个父类，如下:
 		class Cat(object):
 		
 		 def __init__(self, name, color="白色"):
 		 self.name = name
 		 self.color = color
 		
 		 def run(self):
 		 print("%s--在跑" % self.name)
 		
 		
 		# 定义一个子类，继承Cat类如下:
 		class Bosi(Cat):
 		
 		 def setNewName(self, newName):
 		 self.name = newName
 		
 		 def eat(self):
 		 print("%s--在吃" % self.name)
 		
 		
 		bs = Bosi("印度猫")
 		print('bs的名字为:%s' % bs.name)
 		print('bs的颜色为:%s' % bs.color)
 		bs.eat()
 		bs.setNewName('波斯')
 		bs.run()
 		
 		# 运行结果
 		bs的名字为:印度猫
 		bs的颜色为:白色
 		印度猫--在吃
 		波斯--在跑
 
 		
 	
 	# 多继承
 		"""
 		所谓多继承，即子类有多个父类，并且具有它们的特征
 		"""
 		#Python中多继承的格式如下:
 		# 定义一个父类
 		class A:
 		 def printA(self):
 		 print('----A----')
 		
 		# 定义一个父类
 		class B:
 		 def printB(self):
 		 print('----B----')
 		
 		# 定义一个子类，继承自A、B
 		class C(A,B):
 		 def printC(self):
 		 print('----C----')
 		
 		obj_C = C() # 此处()一定要有，因为obj_C.printA()使用类实例对象调用的是obj_C的成员函数。如果没有的话，报错如下
 		# printA() missing 1 required positional argument: 'self'
 		print(C()) # C()为C类的一个实例化对象
 		print(C) # C相当于指向了C类
 
 		obj_C.printA()
 		obj_C.printB()
 		
 		# 运行结果
 		<__main__.C object at 0x000000625E30C860> 
 		<class '__main__.C'>
 		----A----
 		----B----

### 类实例对象与类对象访问实例变量的区别 ###

# 类属性
    	class People(object):  # (object)可有可无
    	    name = 'Tom'       #公有的类属性
    	    __age = 12         #私有的类属性
    	
    	p = People()           # 此处()可有可无，因为class里面只有类成员变量。
    	
    	print(p.name)
    	print(People.name)
    	print(p.__age)             # 不能调用私有属性
    	print(People.__age)        # 不能调用私有属性
    	
    # 实例属性
    	class People(object):
    	    address = '山东'               # 类成员变量/类属性
    	    def __init__(self):
    	        self.name = 'xiaowang'    # 实例变量/实例属性
    	        self.age = 20 
    	
    	p = People()      # 创建一个类的示例对象
    	p.age =12
    	print(p.address)  # 类的实例对象可以访问类成员变量，实例变量
    	print(p.name)
    	print(p.age)
    	
    	print(People.address)       # 类对象能调用类成员变量
    	print(People.name)          # 类对象调不了实例变量
    	print(People.age)

### 描述符 ###

![在这里插入图片描述][2019082718232313.png]

#@property—把函数调用伪装成对属性的访问,数据描述符属性的优先级高于实例名称空间中的同名成员。
    # 使用@property，不用再像java中使用getter,setter方法去设置和访问类变量   
    # 这时，也只有通过@property，才能对实例变量进行访问或设置，实现了对变量访问的控制，
    
    class Student1():
        def __init__(self,name,age):  ###__init__实例初始化
            self.name = name       ####self:实例变量，变量的名字叫name
            self.__age=age
            
        @property #getter
        def name1(self):
            return self.name
        
        @name1.setter  # setter
        def name1(self,newname):
            self.name = newname
            
        @property #getter
        def age(self):
            return 0
        
        @age.setter  # setter
        def age(self,newage):
            self.__age = newage
            
    # 上面这样设置的是类变量可以被类实例随意访问，修改。
    # 注意，这里的name1，如果和实例变量name重名会导致，无限递归！！！
    # RecursionError: maximum recursion depth exceeded while calling a Python object
    
    # 但如果想让@property和类实例变量同名呢？  
    # 将实例变量设置为私有(像age一样)就不会导致重名引发递归死机了
    s1=Student1('jack',33)
    s1.name1
    
    s1.age        #getter
    s1.age=22     #setter
    
    s1.age

### 类工厂函数 ###

#Namedtuple,类工厂函数
    from collections import namedtuple
    
    # 定义一个namedtuple类型User（实际是User类），并包含name，sex和age属性。
    User = namedtuple('User', ['name', 'sex', 'age'])
    
    # 创建一个User类的实例user
    user = User(name='kongxx', sex='male', age=21)
    
    # 也可以通过一个list来创建一个User对象
    user = User._make(['kongxx', 'male', 21])
    
    print(user)
    # User(name='user1', sex='male', age=21)
    
    # 获取用户的属性
    print(user.name)
    print(user.sex)
    print(user.age)
    
    # 修改对象属性，注意要使用"_replace"方法
    user = user._replace(age=22)
    print(user)
    
    # 将User对象转换成字典，注意要使用"_asdict"
    print(user._asdict())  # OrderedDict([('name', 'kongxx'), ('sex', 'male'), ('age', 22)])

### 元类 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 4]  
内置函数type()除了查看对象所属类型外，还有种非凡的能力，即能抛开固化的类创建代码，而动态的创建类。  
而且通过type()函数创建的类和直接写class是完全一样的。  
因为解释器遇到class关键字时，扫描一下class定义的语法，最后还是调用type()函数创建出class

#type()函数依次传入3个参数：
    # 1.class的名称
    # 2.class继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
    # 3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
    
    # MyShinyClass = type('MyShinyClass', (), {})
    # Foo = type('Foo', (), {'bar':True})
    # FooChild = type('FooChild', (Foo,), {})
    
    s1=dict(locals())
    Foo = type('Foo', (), s1)
    FooChild = type('FooChild', (Foo,), s1)
    print(FooChild.__mro__)

## 文件操作：文件打开、关闭、读写、定位读写，重命名，删除 ##

# 文件打开
 	f = open('test.txt', 'w')
 	说明: 访问模式 说明 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
 	
 	w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
 	
 	a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到
 	
 	已有内容之后。如果该文件不存在，创建新文件进行写入。
 	
 	rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
 	
 	wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
 	
 	ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，
 	
 	新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
 	
 	r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
 	
 	w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
 	
 	a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。
 	
 	如果该文件不存在，创建新文件用于读写。
 	
 	rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
 	
 	wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
 	
 	ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
 	
 	如果该文件不存在，创建新文件用于读写。
 	
 # 文件关闭
 	f = open('test.txt', 'w')
 	f.close()
 	
 # 文件写
 	#使用write()可以完成向文件写入数据
 	f = open('test.txt', 'w')
 	f.write('hello world, i am here!')
 	f.close()
 	"""
 	注意：
 	 如果文件不存在那么创建，如果存在那么就先清空，然后写入数据
 	""" 
 # 文件读
 	# 读文件三大方法：
 	# read() 一个一个读，全部读完
 	# read(n) 读取前n个
 	# readline() 按行读
 	# readlines() 全部读
 
 	# read()方法
 		# 写文件
 		f = open('test.txt', 'w') # 如果没有，就创建一个文件
 		f.write('hello world, \ni am here!')
 		f.close()
 		
 		#读文件，read()函数
 		# 如果前面有read()或read(5)，会接着读，而不是重新读
 		f = open('test.txt', 'r')
 		content1 = f.read(5)
 		print(content1)
 		
 		print("-"*30)
 		content2 = f.read()
 		print(content2)
 		f.close()
 		
 		# 执行结果：
 		hello
 		------------------------------
 		 world, 
 		i am here!
 
 		
 	# readlines()方法
 	
 		# 写文件
 		f = open('test.txt', 'w') # 如果没有，就创建一个文件
 		f.write('hello world, \ni am here!')
 		f.close()
 		
 		# 读文件
 		f = open('test.txt', 'r')
 		content = f.readlines()
 		print(content)
 		print(type(content))
 		
 		i=1
 		for temp in content:
 		 print("%d:%s"%(i, temp))
 		 i+=1
 		f.close()
 		
 		# 执行结果
 		['hello world, \n', 'i am here!']
 		<class 'list'>
 		1:hello world,
 		
 		2:i am here!
 		
 	# readline()方法	
 		# 写文件
 		f = open('test.txt', 'w') # 如果没有，就创建一个文件
 		f.write('hello world, \ni am here!')
 		f.close()
 		
 		#readline()
 		f = open('test.txt', 'r')
 		content = f.readline()
 		print(content)
 		f.close()
 		
 		# 执行结果
 		hello world, 
 		
 # 文件定位读写
 
 	"""
 	seek(offset, from)有2个参数
 	 offset:偏移量
 	 from:方向
 	 0:表示文件开头
 	 1:表示当前位置
 	 2:表示文件末尾
 	"""
 	#把位置设置为：从文件开头，偏移5个字节
 	# 打开一个已经存在的文件
 	f = open("test.txt", "r")
 	str = f.read(5)
 	print ("读取的数据是 : ", str)
 	
 	# 查找当前位置
 	position = f.tell()
 	print ("当前文件位置 : ", position)
 	
 	# 重新设置位置
 	f.seek(7,0)
 	# 查找当前位置
 	position = f.tell()
 	print ("当前文件位置 : ", position)
 	f.close()
 				
 # 运行结果
 读取的数据是 : hello
 	当前文件位置 : 5
 	当前文件位置 : 7
 	
 # 文件重命名
 	import os
 	os.rename("test.txt", "haha.txt")
 	
 # 文件删除
 	import os
 	os.remove("haha.txt")

## 文件夹操作：创建文件夹，获取当前目录，获取目录列表，删除文件夹（os模块） ##

# 创建文件夹
    	import os
    	os.mkdir("张三")
    # 获取当前目录
    	import os
    	os.getcwd()
    # 获取目录列表
    	import os
    	print(os.listdir("./"))
    	# 执行结果
    	['.idea', '1.py', '张三']
    # 删除文件夹
    	import os
    	os.rmdir("张三")

## PIL库 ##

参考：https://blog.csdn.net/figo8875/article/details/88755122

### 生成一张固定尺寸固定颜色的图片 ###

![在这里插入图片描述][20190819221109904.png]

# 生成一张固定尺寸固定颜色的图片
    from PIL import Image
    
    # 获取一个Image对象，参数分别是: RGB模式, 宽150，高30，红色
    image = Image.new('RGB', (150, 30), 'red')
    
    # 保存到硬盘，名为test.png,格式为png的图片
    # wb,以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
    image.save(open('test.png', 'wb'), 'png')

### 生成一张随机颜色的图片 ###

# 生成一张随机颜色的图片
    
    from PIL import Image
    import random
    
    
    def getRandomColor():
        # 获取一个随机颜色(r,g,b)格式的
    
        c1 = random.randint(0, 255)
        c2 = random.randint(0, 255)
        c3 = random.randint(0, 255)
    
        return (c1, c2, c3)
    
    
    # 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
    image = Image.new('RGB', (150, 30), getRandomColor())
    
    # 保存到硬盘，名为test.png格式为png的图片
    image.save(open('test.png', 'wb'), 'png')

### 生成一张带有固定字符串的随机颜色的图片 ###

![在这里插入图片描述][20190820100746939.png]

from PIL import Image
    
    from PIL import ImageDraw
    
    from PIL import ImageFont
    
    import random
    
    
    def getRandomColor():
        '''获取一个随机颜色(r,g,b)格式的'''
    
        c1 = random.randint(0, 255)
    
        c2 = random.randint(0, 255)
    
        c3 = random.randint(0, 255)
    
        return (c1, c2, c3)
    
    
    # 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
    image = Image.new('RGB', (150, 30), getRandomColor())
    
    # 获取一个画笔对象，将图片对象传过去
    # 创建一个可用来对image进行操作的对象。对所有即将使用ImageDraw中操作的图片都要先进行这个对象的创建
    draw = ImageDraw.Draw(image)
    
    # 获取一个font字体对象,参数:是ttf的字体文件的目录，字体的大小
    #  ImageFont.truetype(filename , wordsize)
    #  这个函数创建字体对象给ImageDraw中的text函数使用。
    font = ImageFont.truetype('simhei.ttf', size=25)
    
    # 在图片上写东西,参数是：定位，字符串，颜色，字体
    draw.text((12, 1), '我是字符串', getRandomColor(), font=font)
    
    # 保存到硬盘，名为test.png格式为png的图片
    image.save(open('test.png', 'wb'), 'png')

### 生成一张带有随机字符串随机颜色的图片 ###

![在这里插入图片描述][20190820103911567.png]

# 生成一张带有随机字符串随机颜色的图片
 
 from PIL import Image
 from PIL import ImageDraw
 from PIL import ImageFont
 import random
 
 
 def getRandomColor():
 '''获取一个随机颜色(r,g,b)格式的'''
 
 c1 = random.randint(0, 255)
 c2 = random.randint(0, 255)
 c3 = random.randint(0, 255)
 
 return (c1, c2, c3)
 
 
 def getRandomStr():
 '''获取一个随机字符串，每个字符的颜色也是随机的'''
 # 0~9的数字
 random_num = str(random.randint(0, 9))
 
 #利用random.randint()函数生成一个随机整数a，使得97<=a<=122
 #chr,对应从a到z的ASCII码
 # 小写字母
 random_low_alpha = chr(random.randint(97, 122))
 
 # 大写字母
 random_upper_alpha = chr(random.randint(65, 90))
 
 # choice(seq): 从seq序列中（可以是列表，元组，字符串）随机取一个元素返回
 random_char = random.choice([random_num, random_low_alpha, random_upper_alpha])
 
 return random_char
 
 
 # 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
 image = Image.new('RGB', (150, 30), getRandomColor())
 
 # 获取一个画笔对象，将图片对象传过去
 draw = ImageDraw.Draw(image)
 
 # 获取一个font字体对象参数是ttf的字体文件的目录，以及字体的大小
 font = ImageFont.truetype("simhei.ttf", size=26)
 
 for i in range(4):
 # 循环4次，获取4个随机字符串
 random_char = getRandomStr()
 
 # 在图片上一次写入得到的随机字符串,参数是：定位，字符串，颜色，字体
 draw.text((15 + i * 30, 0), random_char, getRandomColor(), font=font)
 
 # 保存到硬盘，名为test.png格式为png的图片
 image.save(open('test.png', 'wb'), 'png')

### 生成一张模糊的随机数字4位验证码图片 ###

from PIL import Image, ImageDraw, ImageFont, ImageFilter
    import random
    
    
    def getCaptcha(width=40, height=30, n=4, line=0):
        # 随机字母
        def rndNum():
            return str(random.randint(1, 9))
    
        # 为画布随机颜色
        def rndColor():
            return (random.randint(100, 255), random.randint(100, 255), random.randint(100, 255))
    
        # 为字体随机颜色
        def rndColor2():
            return (random.randint(30, 120), random.randint(30, 120), random.randint(30, 120))
    
            # 创建图片对象
    
        image = Image.new('RGB', (width, height), (255, 255, 255))
    
        # 创建Font对象
        font = ImageFont.truetype('arial.ttf', 36)
    
        # 创建Draw对象
        draw = ImageDraw.Draw(image)
    
        # 填充每个像素
        for x in range(width):
            for y in range(height):
                draw.point((x, y), fill=rndColor())
    
        # 输出文字
        for t in range(n):
            draw.text((40 * t + 10, 10), rndNum(), font=font, fill=rndColor2())
    
        # 模糊
        image = image.filter(ImageFilter.BLUR)
        image.save('verify.png', 'png')
    
    getCaptcha(width=160, height=60, n=4, line=0)

## 正则表达式/Regular Expression ##

参考：[https://blog.csdn.net/m0\_37673307/article/details/81605053][https_blog.csdn.net_m0_37673307_article_details_81605053]  
正则表达式30分钟入门教程：[https://deerchao.net/tutorials/regex/regex.htm][https_deerchao.net_tutorials_regex_regex.htm]  
[https://www.jianshu.com/p/04cb736fd375][https_www.jianshu.com_p_04cb736fd375]

### 规则 ###

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。  
在很多文本编辑器里，正则表达式通常被用来检索、替换那些匹配某个模式的文本  
在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用一个模块，名字为re  
re模块的使用过程：

# 导入re模块
    import re
    # 使用match方法进行匹配操作
    result = re.match(正则表达式,要匹配的字符串)
    # 如果上一步匹配到数据的话，可以使用group方法来提取数据
    result.group()

说明：  
re.match是用来进行正则匹配检查的方法，若字符串匹配正则表达式，则match方法返回匹配对象（Match Object），否则返回None（注意不是空字符串""）。  
匹配对象Macth Object具有group方法，用来返回字符串的匹配部分。

正则表达式的字符功能：

. 匹配任意1个字符（除了\n）
    [ ] 匹配[ ]中列举的字符
    \d 匹配数字，即0-9
    \D 匹配非数字，即不是数字
    \s 匹配空白，即 空格，tab键
    \S 匹配非空白
    \w 匹配单词字符，即a-z、A-Z、0-9、_
    \W 匹配非单词字符

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][20190828154237759.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 7]

### 举例 ###

用\[1-9\]?\[0-9\]这个正则去匹“09787787” 先判断第一个是不是0 ，如果是0 不符合【1-9】 到那时\[1-9\]?可以没有 所以 0再匹配后面【0-9】 符合 ，这时正则表达式匹配完成，字符串后面的就不管了。

用\[1-9\]?\[0-9\]这个正则去匹“892888” ，第一个是非0 满足【1-9】 条件，输出第一个 8。 再判断字符串第二个是不是满足\[0-9\] ，9满足条件输出9 ，所以最后是 89 ，字符串其余不管。

# [1-9]?[1-9]表示匹配一个也行 两个也行
    ret = re.match("[1-9]?[0-9]","09")
    print(ret.group())  # 0
    
    # [1-9][1-9] 表示必须匹配两个数字
    ret = re.match("[0-9][0-9]","19332")
    print(ret.group())#19

## 爬虫 ##

HTML基础知识：[https://www.w3cschool.cn/html/][https_www.w3cschool.cn_html]  
CSS基础知识：[https://www.w3cschool.cn/css/][https_www.w3cschool.cn_css]  
使用requests获取网页内容  
[http://docs.python-requests.org/zh\_CN/latest/user/quickstart.html][http_docs.python-requests.org_zh_CN_latest_user_quickstart.html]

# python刷题 #

## 输出200以内的可逆素数 ##

# 思路：先找出素数，再找逆素数
    # 素数：整数在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数
    # 可逆素数是将某素数的各位数字顺序颠倒后仍为素数的数，请编程并输出200以内的可逆素数
    
    numb = 200
    for s in range(2, numb):
    
        for j in range(2,s):
            # 判断是否是素数
            if s%j == 0:
                break
        else:
            # 素数的前提下，判断是否是逆素数
            conv_s = int(str(s)[::-1])  # 将素数转换成字符串后颠倒再转换int
    
            for n in range(2, conv_s):
                if conv_s % n == 0:
                    break
            else:
                print(s)

## 统计字符串中，各个字符的个数 ##

# 统计字符串中，各个字符的个数
    # 比如："hello world" 字符串统计的结果为： h:1 e:1 l:3 o:2 d:1 r:1 w:1
    
    W = 'hello world'
    W = W.replace(' ', '')  # 去掉空格字符
    dic = {
        }
    for item in W:
        # 如果item在dic的key里，则对应item键的值加1
        if item in dic.keys():
            dic[item] += 1
        else:
            dic[item] = 1
    print('"hello world" 字符串统计的结果为: ')
    print(dic)

## 模拟斗地主，有3个玩家，一付扑克牌，留3张底牌， 将扑克牌随机分配给3个玩家并显示（注意有四种花色和两个王） ##

例1：

import random
 
 
 class Poke():
 poke = [] # 扑克牌牌堆
 p1 = [] # 玩家一牌堆
 p2 = [] # 玩家二牌堆
 p3 = [] # 玩家三牌堆
 last = None # 底牌牌堆
 
 def __init__(self, f, num): # 初始化牌堆
 self.flower = f # 花色
 self.num = num # 点数
 
 def __str__(self):
 return "%s%s" % (self.flower, self.num) # 返回牌值
 
 @classmethod
 def init(cls): # 定义牌堆
 ph = ("♥", "♠", "♣", "♦") # 花色元组
 pnum = ("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A") # 点数元组
 king = {
 "big": "大王", "small": "小王"} # 大小王
 for p in ph: # 循环遍历花色
 for _nump in pnum: # 循环遍历点数
 # print(Poke(p, _nump))
 cls.poke.append(Poke(p, _nump)) # 装牌
 
 ################################################
 print(type(Poke.poke)) # <class 'list'>
 print(Poke.poke) # 他是一个object
 
 for i in cls.poke:
 print(i, end=" ")
 print()
 ################################################
 
 # print(Poke(king["big"], ""))
 cls.poke.append(Poke(king["big"], "")) # 装大王
 cls.poke.append(Poke(king["small"], "")) # 装小王
 
 @classmethod
 def wash(cls): # 洗牌
 random.shuffle(cls.poke)
 print(Poke.poke)
 
 @classmethod
 def send(cls): # 发牌
 for _ in range(0, 17): # 三个人每人发17张牌
 cls.p1.append(cls.poke.pop(0)) # 玩家一发牌 pop(0)是删除cls.poke的第一个数并返回第一个数
 
 cls.p2.append(cls.poke.pop(0)) # 玩家二发牌
 
 cls.p3.append(cls.poke.pop(0)) # 玩家三发牌
 
 cls.last = tuple(cls.poke) # 最后三张牌做底牌
 
 @classmethod
 def show(cls): # 展示牌
 print("玩家1:")
 for pokes in cls.p1:
 print(pokes, end=" ")
 print()
 
 print("玩家2:")
 for pokes in cls.p2:
 print(pokes, end=" ")
 print()
 
 print("玩家3:")
 for pokes in cls.p3:
 print(pokes, end=" ")
 print()
 
 print("底牌：")
 for pokes in cls.last:
 print(pokes, end=" ")
 print()
 
 
 Poke.init()
 Poke.wash()
 Poke.send()
 Poke.show()

例2

#斗地主
 import random as R
 
 """一次一人发一张牌"""
 
 L = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
 H = ['♠', '♦', '♥', '♣']
 w1 = []
 w2 = []
 w3 = []
 
 P = ['大王', '小王']
 for x in H:
 for y in L:
 s = x + y
 P.append(s)
 
 R.shuffle(P)
 
 i = 1
 while i <= 17:
 w1.append(P.pop())
 w2.append(P.pop())
 w3.append(P.pop())
 i += 1
 
 print('玩家1号')
 print(w1)
 
 print('玩家2号')
 print(w2)
 
 print('玩家3号')
 print(w3)
 
 print('底牌')
 print(P)

执行结果：

玩家1号  
\[‘♦J’, ‘♠7’, ‘♥7’, ‘♠2’, ‘♣4’, ‘♠8’, ‘♦8’, ‘♣K’, ‘♦9’, ‘♥10’, ‘♠4’, ‘♣8’, ‘♦5’, ‘♥4’, ‘♥2’, ‘♠5’, ‘♣J’\]  
玩家2号  
\[‘♣A’, ‘♠3’, ‘♦Q’, ‘♣5’, ‘♥3’, ‘♥9’, ‘♥5’, ‘♣9’, ‘♠K’, ‘♦K’, ‘♠9’, ‘♦4’, ‘♥8’, ‘♥J’, ‘♣6’, ‘♣2’, ‘♦7’\]  
玩家3号  
\[‘♦10’, ‘♣3’, ‘♠6’, ‘♦3’, ‘♦A’, ‘♦6’, ‘♥6’, ‘♦2’, ‘♠J’, ‘♣Q’, ‘♥Q’, ‘♣10’, ‘♥A’, ‘♥K’, ‘大王’, ‘小王’, ‘♣7’\]  
底牌  
\[‘♠10’, ‘♠A’, ‘♠Q’\]

## 设计一个公司类 ##

'''
    设计一个公司类，完成以下要求，并实例化不同对象进行验证
    
    类变量
     - 类下公司的总个数，类下实例的名称列表
    
    类方法
     - 返回公司类共有多少个公司实例
     - 返回公司类的公司实例有名称列表
    
    实例变量
    - 公司名，简介，利润，销售额，总成本，雇员姓名
    
    实例方法：
    - 招聘人才（每招一个人会有成本产生，影响该实例雇员列表，人数，总成本）
    - 解雇人员（每解雇一个人会有成本产生，影响该实例雇员列表，人数 ，总成本）
    - 公司广告推广(影响该实例总成本)
    - 交社保(按公司雇员总人数计算，影响该实例总成本)
    - 交税(按公司雇员总人数计算，影响该实例总成本)
    - 销售（按销售件数*价格计算销售额，利润按销售额*利润率进行计算利润。）
    - 获取公司雇员列表
    - 获取公司净利润
    '''
    
    
    class Company():
    
        num = 0     # 公司的总个数
        name = []   # 实例的名称列表
    
        def __init__(self, Company_name, Desc,Profit, TotalSales, TotalCost, EmployeeName):
    
            # 实例变量: 公司名，简介，利润，销售额，总成本，雇员姓名
            self.Company_name = Company_name               # 公司名
            self.Desc = Desc                               # 简介
            self.Profit = Profit                           # 利润
            self.TotalSales = TotalSales                   # 销售额
            self.TotalCost = TotalCost                     # 总成本
            self.EmployeeName = EmployeeName               # 雇员姓名
    
            self.Employee_number = len(self.EmployeeName)  # 雇员数量
            Company.num += 1
            Company.name.append(Company_name)
    
        # 招聘人才（每招一个人会有成本产生，影响该实例雇员列表，人数，总成本）
        def recuitment(self, r_name, r_salary):
            self.EmployeeName.append(r_name)    # 雇员列表
            self.TotalCost += r_salary          # 总成本
            self.Employee_number += 1           # 雇员人数
    
        # 解雇人员（每解雇一个人会有成本产生，影响该实例雇员列表，人数 ，总成本）
        def fire(self, f_name, f_salary):
            self.EmployeeName.remove(f_name)    # 雇员列表
            self.TotalCost -= f_salary          # 总成本
            self.Employee_number -= 1           # 雇员人数
    
        # 公司广告推广(影响该实例总成本)
        def advertise(self, ad_cost):
            self.TotalCost += ad_cost           # 总成本
    
        # 交社保(按公司雇员总人数计算，影响该实例总成本)
        def s_security(self, s_cost):
            self.TotalCost += s_cost * self.Employee_number
    
        # 交税(按公司雇员总人数计算，影响该实例总成本)
        def tax(self, t_cost):
            self.TotalCost += t_cost * self.Employee_number
    
        # 销售（销售件数*价格 = 销售额，销售额*利润率 = 利润。）
        def sale(self, sale_number, profit_rate, price):
            self.TotalSales += sale_number * price             # 销售件数*价格 = 销售额
            self.Profit += sale_number * price * profit_rate   # 销售件数*价格*利润率 = 利润
    
        # 获取公司雇员列表
        def get_employee(self):
            return self.EmployeeName
    
        # 获取公司净利润
        def get_profit(self):
            return self.Profit
    
        # 装饰器：类方法
        @classmethod
        def get_num(cls):     # 返回公司类共有多少个公司实例
            return cls.num
    
        # 装饰器：类方法
        @classmethod
        def get_name(cls):    # 返回公司类的公司实例有名称列表
            return cls.name
    
    def main():
        c = Company('C','Company C',0,12,12,['Feng','Zhang'])  # 公司名，简介，利润，销售额，总成本，雇员姓名
        c.recuitment('Gua', 4)    # 招聘人才     参数：人名，薪水
        c.fire('Feng', 3)         # 解雇人员     参数：人名，薪水
        c.advertise(0.5)          # 公司广告推广  参数：广告成本
        c.s_security(0.2)         # 交社保       参数：广告成本
        c.tax(0.1)                # 交税         参数：税成本
        c.sale(10,0.3,100)        # 销售         参数：销售件数，利润率，价格
    
        print('公司名字：', c.Company_name)
        print('总费用：', c.TotalCost)
        print('公司员工：', c.get_employee())
    
        # 类方法的调用
        print('公司名称：', Company.get_name())
        print('公司数量：', Company.num)
    
    
    if __name__ == '__main__':
        main()

## while循环完成图形输出 ##

'''
 使用while，完成以下图形的输出
 *
 * *
 * * *
 * * * *
 * * * * *
 * * * *
 * * *
 * *
 *
 '''
 
 i = 0
 while i <=5:
 j = 0
 while j <= i:
 print("*",end=" ") # end值为空格
 j += 1
 print("") # end值为默认值（换行\n）
 i += 1
 i = 4
 while i >= 0:
 j = 0
 while j <= i:
 print("*",end=" ")
 j += 1
 print("")
 i -= 1

## “名片管理器”项目 ##

"""
     编写程序，完成“名片管理器”项目
    
        需要完成的基本功能：
            添加名片
            删除名片
            修改名片
            查询名片
            退出系统
        程序运行后，除非选择退出系统，否则重复执行功能
        
    须使用自定义函数，完成对程序的模块化
    学生信息至少包含：姓名、年龄、学号，除此以外可以适当添加
    必须完成的功能：添加、删除、修改、查询（单个查询/显示所有）、退出   
    """
    '''
    学生信息系统：
    要求： 用键盘录入的方式
    根据序列完成：
       1. 添加一个新的名片")
       2. 删除一个名片")
       3. 修改一个名片")
       4. 查询一个名片")
       5. 显示所有的名片")
       6. 退出系统"
    '''
    
    # 用来存储名片
    card_infors = []
    
    
    def print_menu():
        """完成打印功能菜单"""
        print("=" * 50)
        print("   名片管理系统 V0.01")
        print(" 1. 添加一个新的名片")
        print(" 2. 删除一个名片")
        print(" 3. 修改一个名片")
        print(" 4. 查询一个名片")
        print(" 5. 显示所有的名片")
        print(" 6. 退出系统")
        print("=" * 50)
    
    
    def add_new_card_infor():
        """完成添加一个新的名片"""
        new_name = input("请输入新的名字:")
        new_qq = input("请输入新的QQ:")
        new_weixin = input("请输入新的微信:")
        new_addr = input("请输入新的住址:")
    
        # 定义一个新的字典,用来存储一个新的名片
        new_infor = {
        }
        new_infor['name'] = new_name
        new_infor['qq'] = new_qq
        new_infor['weixin'] = new_weixin
        new_infor['addr'] = new_addr
    
        # 将一个字典,添加到列表中
        global card_infors
        card_infors.append(new_infor)
    
        # print(card_infors)     # for test
    
    
    def del_card_infors():
        """用来删除一个名片"""
        global card_infors
        find_name = input("请输入要删除的姓名:")
        find_flag = 0
    
        for temp in card_infors:
            tem = 0
            if temp['name'] == find_name:
                print(card_infors)
                card_infors.pop(tem)
                find_flag = 1  # 表示找到了
                break
            tem += 1
        # 判断是否找到了
        if find_flag == 0:
            print("查无此人....")
    
    
    def modif_card_infors():
    
        """用来修改一个名片"""
        global card_infors
        find_name = input("请输入要修改的姓名:")
        find_flag = 0
    
        for temp in card_infors:
            tem = 0
            if temp['name'] == find_name:
                print(card_infors)
    
                print("=" * 50)
                print("   请输入要修改的名片信息：")
                print(" 1. QQ")
                print(" 2. 微信")
                print(" 3. 住址")
                print(" 4. 临时不修改了")
                print("=" * 50)
    
                while True:
    
                    # 获取用户的输入
                    num = int(input("请输入要修改名片信息或退出对应的序号:"))
    
                    # 根据用户的数据执行相应的功能
                    if num == 1:              # QQ
                        new_qq = input("请输入新的QQ:")
                        temp['qq'] = new_qq
    
                    elif num == 2:            # 微信
                        new_weixin = input("请输入新的微信:")
                        temp['weixin'] = new_weixin
    
                    elif num == 3:            # 地址
                        new_addr = input("请输入新的住址:")
                        temp['addr'] = new_addr
    
                    elif num == 4:            # 退出系统
                        break
    
                    else:
                        print("输入有误,请重新输入")
    
                    print("")
    
    
                find_flag = 1  # 表示找到了
                break
            tem += 1
    
        # 判断是否找到了
        if find_flag == 0:
            print("查无此人....")
    
    
    def find_card_infor():
        """用来查询一个名片"""
        global card_infors
    
        find_name = input("请输入要查找的姓名:")
        find_flag = 0  # 默认表示没有找到
    
        for temp in card_infors:
            if find_name == temp["name"]:
                print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
                find_flag = 1  # 表示找到了
                break
    
        # 判断是否找到了
        if find_flag == 0:
            print("查无此人....")
    
    
    def show_all_infor():
        """显示所有的名片信息"""
    
        global card_infors
    
        print("姓名\tQQ\t微信\t住址")
        for temp in card_infors:
            print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
    
    
    def main():
        """完成对整个程序的控制"""
        # 1. 打印功能提示
        print_menu()
    
        while True:
    
            # 2. 获取用户的输入
            num = int(input("请输入操作序号:"))
    
            # 3. 根据用户的数据执行相应的功能
            if num == 1:
                add_new_card_infor()  # 添加名片
    
            elif num == 2:
                del_card_infors()     # 删除名片
    
            elif num == 3:
                modif_card_infors()   # 修改名片
    
            elif num == 4:
                find_card_infor()     # 查询名片
    
            elif num == 5:
                show_all_infor()      # 显示所有名片
    
            elif num == 6:
                break                 # 退出系统
            else:
                print("输入有误,请重新输入")
    
            print("")
    
    
    # 调用主函数
    main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]: /images/20211101/a1e2a4740b2546ad974c8e528cfc7c6a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]: /images/20211101/f6f5f161346c4f99834dd0f690d2922d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 2]: /images/20211101/e9f8a0b8232043ea983083394c176e7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 3]: /images/20211101/9de47934384b46259c6a634fae081883.png
[20190827180827372.png]: /images/20211101/37c4dd0e6593468da71d60bd63ed384f.png
[2019082718232313.png]: /images/20211101/9fbc81d872974d3fba43b85812b3a8d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 4]: /images/20211101/209c19a38aeb440fbe1b7a117a343210.png
[20190819221109904.png]: /images/20211101/ca946a58129640898bf86a3a7a06b494.png
[20190820100746939.png]: /images/20211101/0272a929179c41b5bc02f8601bba8554.png
[20190820103911567.png]: /images/20211101/950cdc16b99844f393674ff31a1eb075.png
[https_blog.csdn.net_m0_37673307_article_details_81605053]: https://blog.csdn.net/m0_37673307/article/details/81605053
[https_deerchao.net_tutorials_regex_regex.htm]: https://deerchao.net/tutorials/regex/regex.htm
[https_www.jianshu.com_p_04cb736fd375]: https://www.jianshu.com/p/04cb736fd375
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 5]: /images/20211101/6aa322ee5885483cba085c89f4fb54dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 6]: /images/20211101/32306a83177e4f8cb9dbca6d9f154720.png
[20190828154237759.png]: /images/20211101/9d1b9de022cc470da7265ac8d85ca3ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 7]: /images/20211101/543d06bf48844dfd802902ad1e95f0f1.png
[https_www.w3cschool.cn_html]: https://www.w3cschool.cn/html/
[https_www.w3cschool.cn_css]: https://www.w3cschool.cn/css/
[http_docs.python-requests.org_zh_CN_latest_user_quickstart.html]: http://docs.python-requests.org/zh_CN/latest/user/quickstart.html