您现在的位置是：首页 > Python

当前栏目

Python基础语法

Python 文件基础对象

2023-03-02 10:27:35 时间

### 七月在线之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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python基础语法

相关文章