列表生成表达式，可变/不可变类型，生成器，迭代器，re正则表达式

print 补充

print(*objects, sep=' ', end='\n', file=sys.stdout)

参数的具体含义如下：
objects --表示输出的对象。输出多个对象时，需要用 ，（逗号）分隔。
sep – 用来间隔多个对象。
end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。
file – 要写入的文件对象。

a=1
b="Hello World"
print(a, b)  #可以一次输出多个对象，对象之间用逗号分隔

运行结果如下：
1 Hello World


print("www", "snh48", "com", sep=".")  # 设置间隔符

运行结果如下：
www.snh48.com

列表生成表达式

#x在0~9之间依次取值,对每一个x,将x*x的计算结果作为列表中的元素。
ls=[x*x for x in range(10)]
print(ls)
ls=[x*x for x in range(10) if x%2!=0]
print(ls)                         #0~9中所有奇数的平方作为列表的元素。


输出结果:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 9, 25, 49, 81]




#列表生成表达式中也支持多层循环的形式
sno=['1810101','1810102','1810103']             #学号
namelist=['李晓明','马红','张刚']                #姓名


ls=['学号:'+sn+',姓名:'+name for sn in sno for name in namelist]
print(ls)


输出结果:
['学号:1810101,姓名:李晓明', '学号:1810101,姓名:马红', '学号:1810101,姓名:张刚', 
'学号:1810102,姓名:李晓明', '学号:1810102,姓名:马红', '学号:1810102,姓名:张刚', 
'学号:1810103,姓名:李晓明', '学号:1810103,姓名:马红', '学号:1810103,姓名:张刚']

可变/不可变类型

列表---可以接长，拆短的收纳盒。
元组---固定长短的收纳盒。且收纳盒其中的东西是不能替换的。

不可变类型:一旦创建就无法修改数据
整数,浮点数,复数,字符串,逻辑值,元组

可变类型:
列表,字典,集合

字典的键值可以是任意不可变类型，例如可用元组来做键值。

poi={(100,100):'bus stop'}

生成器

range()函数返回的是一个可迭代对象（类型是对象),而不是列表类型;


x=range(5)          			#并不返回一列表
print(range(5))					# range(0, 5)	
print(type(range(5)))			# <class 'range'>
print(x[2])						# 2

一次性生成大量元素保存在列表中，将占用大量的内存空间。

生成器:减少内存空间的使用,生成器并不一开始直接创建所有的数据,而是进行一种"惰性的运算".
即创建的时候,我们创建的只是一个生成器的对象,里面记录的是方法,而没有生成数据.
可以使用特殊的方法,进行随用随取,并且生成器只能遍历一遍

将列表生成表达式中的一对中括号改为一对小括号即可得到生成器。

g=(x*x for x in range(10))                 	#返回了一个生成器对象
print('g的类型为:',type(g))					# <class 'generator'>
for i in g:
    print(i,end=' ')						#一次只生成一个值,减少内存空间使用


0 1 4 9 16 25 36 49 64 81 

还可借助yield关键字利用函数实现生成器。

def faclist(n):
    result =1
    for i in range(2,n+1):      #i在2~n之间取值
        yield result            #遇到yield暂停执行,并返回result,下次执行时从此处继续执行。
        result=result*i
print(faclist(10))
print(list(faclist(10)))
for i in faclist(10):
    print(i, end=' ')


输出结果:
<generator object faclist at 0x0000022A8A9DE740>
[1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
1 2 6 24 120 720 5040 40320 362880 

迭代器

可直接使用for循环遍历的对象统称为可迭代对象(Iterable)。
迭代器(Iterator)是指可以通过next函数不断获取下一个值的对象，并不是所有的可迭代对象都是迭代器。

from collections.abc import Iterable,Iterator #导入Iterable和Iterator类型
ls=[1,2,3,4,5]              #列表
g=(x for x in range(1,6))   #生成器
print('ls是可迭代对象:',isinstance(ls,Iterable))
print('g是可迭代对象:',isinstance(g,Iterable))
print('ls是迭代器:',isinstance(ls,Iterator))
print('g是迭代器:',isinstance(g,Iterator))

输出结果:
ls是可迭代对象: True
g是可迭代对象: True
ls是迭代器: False
g是迭代器: True

from collections.abc import Iterator  #导入Iterator类型
ls=[1,2,3,4,5]           #列表
lt=iter(ls)              #利用iter函数获取ls的迭代器
print('lt是迭代器:',isinstance(lt,Iterator))

输出结果:
lt是迭代器: True

对于迭代器，可以使用next函数不断获取下一个元素，当所有元素都获取完毕后再调用next函数，就会引发StopIteration异常。

g=(x for x in range(1,3))    #创建一个生成器
print('第一个元素:',next(g))
print('第二个元素:',next(g))
# print('第三个元素:',next(g))   #取消前面的注释会引发StopIteration异常

输出结果:
第一个元素: 1
第二个元素: 2

re正则表达式

常用操作符

.             除换行外的任意单个字符
[]            字符集,对单个字符给出取值范围          如: [abc]表示a或者b或者c   [a-z]表示范围在a-z的某个字符   [0-9]表示任意数字
[^ ]          对单个字符给出排除范围                 [^abc]表示这个字符不是a也不是b也不是c
*             前一个0次或无限次扩展       abc*表示ab,abc,abcc,abccc等   a[0-9]*c与ac,a0c,a01c都是匹配的。
+             前一个1次或无限次扩展       abc+表示abc,abcc,abccc等      a[0-9]+c与a0c,a01c匹配,与ac不匹配
？            前一个0次或一次扩展         abc？表示ab或abc
|             左右表达式中的任意一个                 abc|def表示abc或def。 

{m}                  扩展前一个m次                 ab{2}c表示abbc
{m,}                 至少m次
{m,n}                扩展前一个m至n次              ab{1,2}c表示abc或abbc
^                    ^abc表示以abc开头
$                    abc$表示以abc结尾
()                   用()括起来的内容表示一个分组。在匹配完成后,可获取每个分组在字符串中匹配到的内容。贪婪模式: .*   非贪婪模式: .*?
\d                   某个数字,相当于符号[0-9]
\D                   非数字
\w                   某个(字母,数字,下划线,中文)    即a-z、A-Z、0-9、_、汉字
\W                   匹配特殊字符，即非字母、非数字、非汉字、非_
\s                   所有的空白字符(空格,制表符,换页符,换行符等等)
\S                   非空白

P(Y|YT|YTH|YTHO)?N                   表示  PN或PYN,PYTN,PYTHN,PYTHON
PYTHON+                              表示  PYTHON,PYTHONN,PYTHONNN,PYTHONNNN....
PY[TH]ON                             表示  PYTON或者PYHON
PY{:3}N                              表示  PN,PYN,PYYN,PYYYN  

匹配IP地址的正则表达式:

0-99:                         [1-9]?\d
100-199:                      1\d{2}
200-249:                      2[0-4]\d
250-255:                      25[0-5]

(([1-9]?\d | 1\d{2} | 2[0-4]\d | 25[0-5]).){3}([1-9]?\d | 1\d{2} | 2[0-4]\d | 25[0-5])

Re库使用raw string类型来表达正则表达式
raw string 是不包含转义符的字符串

Re库主要函数

import re
#match只会对整个字符串开头的若干个字符进行匹配,成功返回Match对象,
#其中的span是匹配的字符序列在字符串中的位置信息。失败返回None
#pattern是正则表达式,string是待匹配的字符串,flags是参数
#格式: result1=re.match(pattern,string,flags)
result1=re.match(r'python','Python是一门流行的语言.',re.I)
result2=re.match(r'python','我喜欢学习python',re.I)
result3=re.match(r'python','''我喜欢学习python
python是一门流行的语言''',re.I|re.M)#即便设置了参数re.M,match也不会对后面行的开头字符作匹配。
print('result1:',result1)
print('result2:',result2)
print('result3:',result3)


运行结果:
result1: <re.Match object; span=(0, 6), match='Python'>
result2: None
result3: None

import re
#search函数成功返回Match对象,失败返回None。
#对整个字符串进行扫描并返回第一个匹配的结果。
result1=re.search(r'py$','puppy',re.I)
result2=re.search(r'python','我喜欢学习python',re.I)
result3=re.search(r'python','''我喜欢学习python
python是一门流行的语言''',re.I|re.M)#第二行的python不会被扫描到。
print('result1:',result1)
print('result2:',result2)
print('result3:',result3)


运行结果:
result1: <re.Match object; span=(3, 5), match='py'>
result2: <re.Match object; span=(5, 11), match='python'>
result3: <re.Match object; span=(5, 11), match='python'>

match和search函数成功时都会返回一个match对象，失败时都返回None。
将match对象作为判断条件时，永远都返回True；而None则返回False。

import re
#match对象的group()和groups()方法。
#group(0)同group()一样,对应整个正则表达式对象。
#group(1)对应正则表达式对象的特定子组1,group(2)对应特定子组2,group(3)对应特定子组3......
#groups():以tuple格式返回所有匹配子组。
line = "Cats are smarter than dogs"
matchObj = re.match(r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
    print("matchObj.group() : ", matchObj.group())
    print("matchObj.group(1) : ", matchObj.group(1))
    print("matchObj.group(2) : ", matchObj.group(2))
    print('matchObj.groups():',matchObj.groups())
else:
    print ("No match!!")


运行结果:
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter
matchObj.groups(): ('Cats', 'smarter')

import re
#findall在字符串中找到所有和正则表达式匹配的子串。
#匹配成功,则返回一列表。失败,返回空列表。
# finditer返回的迭代器中的每个元素都是一个Match对象。匹配失败时,迭代器中不包含任何元素。
line = "sno:#1810101#,name:#李晓明#,age:#19#,major:#计算机#" \
            "sno:#1810102#,name:#马红#,age:#20#,major:#数学#"
matchObj = re.findall(r'name:#([\s\S]*?)#[\s\S]*?major:#([\s\S]*?)#', line,re.I)
print(line)
print(matchObj) #返回一列表

运行结果:
sno:#1810101#,name:#李晓明#,age:#19#,major:#计算机#sno:#1810102#,name:#马红#,age:#20#,major:#数学#
[('李晓明', '计算机'), ('马红', '数学')]

爬取图片

1.图片的url链接
2.imag_data=requests.get(url,headers).content   #图片要用content,二进制数据。
3.with open(filename(以jpg结尾),'wb') as fp:
		fp.write(imag_data)