python学习笔记第3章：数据类型
2.1 列表list[方括号，数组]
备注：大部分列表方法无返回值，在原列表上直接操作
创建
a = ['sed','awk',700] 创建 ，创建空列表a= []或a=list()
l = [i for i in range(0,10)] 推导式生成列表0到9
print( a ) 查看a全部元素
print(a[:]) 查看a全部元素
查看列表
a.count('sed') 查看列表中有几个sed
len(a) 查看列表a元素个数
a.index('sed') 查看sed的索引值（在列表中的位置）
a.index(min(a)) 查找最小值的索引
访问列表
a[2] 访问列表第二个元素
a[0:3] 访问列表前3个元素索引0,1,2，不包括3
a[:3] 访问列表前3个元素
a[3:] 访问列表从第3个元素到最后
a[len(a)-1] 获取列表最后一个元素
a[-1] 获取列表最后一个元素
a[-3:] 获取列表最后3个元素
a[-3:-1] 获取列表倒数第三、第二个元素，不包括最后一个元素
添加修改
a[2]= 'haojiahuo' 修改或设置索引2的元素为
a.append(900) 列表末尾追加一个900
a.insert(1,'aloha') 在列表索引1之前，加一个元素，即awk之前
删除
a.pop() 删除最后一个元素，返回被删的元素
a.pop(2) 删除索引2的值，返回被删的元素
del a[2] 从内存删除索引2的值，无返回值
- remove(700) 删除指定的值，如果存在多个，删除第一个，无返回值, 不存在要删除的值会报错,
列表操作
c = 'sed' in a 判断sed是否在数组a中，返回布尔值
sum(a) #对列表a所有元素求和
c = a + b 列表相加，组合为c。a的值在前。
a+=b 同上，a,b列表相加，赋值给a
- extend(b)同上，把b列表的元素追加到a
a* 2 若原来是1,2,3，变为1,2,3,1,2,3
x,y,z = a 将a的元素分别赋值给x,y,z，xyz个数必须和a元素个数相等
排序
- sort()将a的元素升序排列，直接修改原列表，必须全部为数字
- sort(reverse = True)将a降序排列，T大写
sorted(a) 保留数组a，返回升序排列的结果
sorted((a),reverse=True) 保留数组a，返回降序排列的结果
a = [(32,'a'),(55,'b')]
a.sort(reverse = True) 根据每个元组元素的第一个值排序
复制
a=[3,2,1] b=a 不是复制，数据只有一份，相当于硬链接，或者指针，两个都是地址，不管修改a，还是修改b，都是修改数据，另一个也会变，此时a is b true，a==b true
c=a.copy() 复制一个数组，两份数据,a is c false, a==c true
转换
字符串转列表
s = “[]”
eval(s)
列表转字符串
''.join(l)
其他类型转换为列表
b = list('ABCDE')
b=list(元组名) 元组转列表
遍历列表的索引和值
方法一：
for i,value in enumerate(list1):
print(i,value)
方法二：
for i in range(len(list1)):
print(i,list1[i])
查找嵌套列表中的最大值
value = max(data, key=lambda item: item[1])
#数据样例: data[[1, 2], [3, 4]]
#查找嵌套列表data中, 每个元素的第二个元素的最大值, , 返回该子列表, min是查找最小值, 索引0根据第一个元素查找
2.2 元祖tuple（不能进行增删改操作的列表，定义方式圆括号）
t = ('sed','awk',700)
t=('sec',) 元组只有一个值时，要加逗号
t[1] 引用，列表，元组引用方式都一样，方括号
t = c1+c2 元组可相加，但只能和元组相加，不能和列表相加
t =tuple(list1) 将列表转换为元组
2.3 字典{花括号，关联数组}
2.3.1 定义字典
d = {'apple':'5yuan','bunana':4,'orange':3} 方式一
d = dict(a=20,b=30) 方式二 ，dict（）字符串不用加引号（同时dict可将其他类型转换为字典）
d.fromkeys(list1,tuple1) 方式三：键为list1，值为tuple1
d = { key:value for key,value in prices.items() if key in tech_names } #方式四：生成器
print(d) 打印字典全部内容，输出{'a': 20, 'b': 30}
2.3.2 引用字典
d[ 'apple' ] 用键来引用，返回该键的值，中括号和列表一样,
键不存在会报错
d.get('apple') 用键来引用，返回该键的值，键不存在返回None
d.get('apple',3) 用键来引用，返回该键的值，若键不存在返回3
d['apple']['price'] 引用嵌套字典，不存在会报错
d['apple'].get('price') 引用嵌套字典，不会报错
d.keys() 取得d所有的键，返回所有键组成的无值字典
d.values() 取得d所有的值
d.items() 取得d所有元素（键和值），对其使用list会变成元组，用下标引用得到该位置的键和值
if 'apple' in d.values() #判断apple是否在字典中
for key,value in d.items():
print(key,value) 遍历字典所有键值
2.3.3 修改添加
d['apple'] = '3yuan' 修改值
d['shala']= '2yuan' 添加字典元素，用法和更新一样，存在的更新，不存在添加
d['word'].append(0) 若字典的word健是列表，可对该键使用列表的方法
d.setdefault('egg',1) 返回egg的值，若不存在则创建它，值设置为1
2.3.4 删除
d.pop('apple') 删除apple键值,并返回被删除的值，不存在报错
del d['apple'] 删除方式2,不返回值，不存在报错
d.clear() 清空字典的所有内容，保留d本身
2.3.5 计算
sum(d.values()) #对字典所有的值求和
max(d, key=d.get) #找出字典中的最大值,并返回该值的键
2.3.6 判断
'a' in d #判断键中是否有a,完全匹配
'a' in d.values() #判断值中是否有a,完全匹配
2.3.7 转换
#字典转列表
k=list(d.keys()) 用list函数将字典转换为列表
sorted(d) #按照健对字典d排序，该方法也能用于其他数据类型
#字典转字符串
d = {}
方法一:
json.dumps(d)
方法二:
str(d)
#字符串转字典
s= '{"name" : "john", "gender" : "male"}' #需要键值对形式，外层带花括号
方法一:
import ast
d = ast.literal_eval(s)
方法二:
d = eval(s)
方法三:
import json
json.loads(s)
#固定字典的顺序
import collections
d = collections.OrderedDict(d) #字典键值的顺序固定下来了
2.3.8 常用操作
统计每个元素出现次数，生成一个字典，键为元素，值为出现次数
常规方法
list1 = ['a,','b','c','a'] #字典、列表、元组都可以
d = {}
for key in list1:
d[key] = d.get(key,0) + 1
高效方法
import collections
list1 = ['a,','b','c','a'] #字典、列表、元组都可以
d = collections.Counter(list1)
字典排序
#1.按值排序
新列表 = sorted(旧字典.items(), key=lambda x: x[1], reverse=False)
# 按字典/集合中的值排序。false升序,true降序
# 得到列表: [('a', 1), ('b', 2), ('c', 3)]
#2.按键排序
x[1]改成x[0]
#对字典按值降序排序，返回前n个
# d.common_use(10) #不改变原字典，需要保存时赋值给一个新字典
# d1 = Counter(d1) #不是使用Counter生成的字典要转化一下
# d1.common_use(5)
2.4 集合{花括号，数据不能重复}
s={'app','ios','android'} 定义集合
set(l) 将其他类型转换为集合，将列表转换为集合时，若 列表有重复值，重复值会被删除，只保留一个
集合运算
和,所有项目加起来 a|b a.union(b)
差,a有b没有的 a-b a.difference(b)
积,交集 a&b a.intersection(b) a&b&c a.intersection(b,c)
对称差集,各自独有的加起来 a^b a.symmetric_difference(b)
子集， a <=b a.issubset(b) a包含于b
真子集 a<b
父集 a>=b a.issuperset(b)
真父集 a>b
2.5 字符串
2.5.1 字符串分割为列表
根据单个字符分割
s= '23,58,89'
print('s is ',s)
c= s.split(',') 将字符串转换为列表以，作为分隔符，缺省空格
c=s.split( ',',1) #只分割一次，第一个逗号以后的内容作为一个元素
c=c=s.rsplit( ',',1) #从右往左分割，切只分割一次
c=s.split() #缺省空格作为分隔符
根据多个字符分割
re.split('-|_','share_haotu-icon1')
s is 23,58,89
c is ['23,58,89']
biaotou = f.readline().splitlines() 将读取的一行内容转换为只有一个元素的列表,并去掉所有换行符和制表符,和split区别是,split不会去掉换行等符号.
如需转换为元组，需先转换为列表，再将列表转换元组
2.5.2 字符串拼接
#列表结合为字符串join()，仅使用于列表元素全为字符串的情况
l = ['apple','aloha']
s = ' '.join(l) ' '.join(),引号中可空白，空格，任意字符
print(s)
#拼接
s1 = 'hii'
s2 = '3'
s3 = s1 +' '+ s2
s4 = s1 +'hello'
print(s3*3)
hii 3hii 3hii 3
#填充
s.rjust(20) #右对齐, 左侧填充数个空格, 字符长度达到20
s.ljust(20, '_') #左对齐, 右侧填充数个_, 字符长度达到20
2.5.3 替换replace()
s.repalce('查找值','替换值','只替换前n个')
s1 = '二心二意'
s2 = s1.replace('二'，'一'） #把所有二替换为三
s2 = s1.replace('二'，'一'，1） #只把第一个二替换为三
s = '13333331234'
Yincang=s.replace(s[3:7],'@'*4) 将字符串s的下标从3到6替换为@@@@
s2 = s1.replace(' ', '') #删除字符串中的空格
.replace('\n', '').replace('\t', '') #换行和tab
2.5.4 判断
if 'a' in 'abcdec': #判断a是否在字符串中,返回bool型
s.startswith('ab') #判断字符串开头是不是ab,返回bool型
s.endswith('ab') #判断字符串结尾是不是ab,返回bool型
s.isdigit() #判断字符是否为数字
2.5.5 查看/查找
s='abcdec'
s.count('c') #查看s中有几个c
len(s.encode('utf-8')) #获取字符串所占的字节数
s.find('a') #查看a在字符串中的位置下标，不存在返回-1
s.index() #功能同find， 不存在报错
s1.find('二',1,3) #从下标1开始，到下标3为止，不包括下标3,检索在这个范围内出现的'二'的位置
2.5.6 大小写转换
s.upper() 转换为大写
s.lower() 转换为小写
s.title() 首字母大写
2.5.7 删除
s.strip() 去掉字符串s首尾的空格,换行,制表
s.strip(',') 删除字符串首尾的,存在连续多个,都会被删除
s.strip('a') 删除字符串首尾的a
s.lstrip() 去掉字符串s中左边空格
s.rstrip() 去掉字符串s中右边空格
s1.replace(' ', '') #删除字符串中全部的空格
s = '浙江省杭州余杭区'
s.lstrip('浙江省').lstrip('杭州市')
输出 余杭区
2.5.8 截取部分字符（s是字符串）
s[2:6] 获取下标2到5的字符
s[:6] 获取下标0到5的字符
s[2:] 获取下标2到末尾的字符
s[-2:] 获取最后两个字符
s[2:6:2] 从下标2开始，间隔两个字符，到下标5为止
s[:] 字符串整体，等同于直接s
s[::-1] 倒着排列字符串s
s[0] #得到字符串中的第一个字符
2.5.9 输出字符中的空格制表换行
s='1\t 2 \n 3'
repr(s)
print(repr(s))
1\t 2 \n 3
2.5.10 类型转换
str(s, encoding="utf-8") #二进制转字符串
bytes(s, encoding="utf8") #字符串转二进制
2.5.11 字符串匹配
pip install python-Levenshtein
pip install fuzzywuzzy
from fuzzywuzzy import fuzz
fuzz.ratio(s1, s2) #直接计算s2和s2之间的相似度，返回值为0 - 100，100表示完全相同；
fuzz.partial_ratio(s1, s2) #包含, 部分匹配，如果S1是S2的子串依然返回100；
fuzz.token_sort_ratio(s1, s2) #只比较S1，S2单词是否相同，不考虑词语之间的顺序；
fuzz.token_set_ratio(s1, s2) #相比fuzz.token_sort_ratio不考虑词语出现的次数；
2.6 二进制
b1 = b'abcde' #定义二进制类型数据
2.7 正则表达式
import re
2.7.1 直接上手
step1：定义一个模式
pattern = re.compile(r'pic=(http://h2\.ioliu\.cn/bing/.+?1920x1080\.jpg)',re.S)
step2:查找全部符合条件的字符串（返回一个列表）
url_pic = pattern.findall(text)
扩展：只查找符合条件内容中间的部分（用小括号,返回一个元组，索引1即是第一个括号的内容，索引2第二个括号（如果有），索引0是全部内容）
pattern = re.compile(r ' bing/ (.+?) _ ') #开头bing/ 结尾_索引1是括号里的内容
name = pattern.search(i) #只查找一个
print(name [ 1 ] )
根据多个字符分割字符串，代替字符串split方法
re.split('-|_','sharejs_haotu-icon100')
2.7.2 函数
re.findall( r'\d+', 文本, re.S)
re.search( r'\d+', 文本, re.S)
re.match( r'\d+', 文本, re.S) #从开头匹配
re.fullmatch( r'\d+', 文本, re.S) #完全匹配
s = '306, 307'
3.6.2.1 编译
reg = re.compile(r'\d+') #查找数字
reg = re.compile(r'(\d+), ') #只查找逗号前面的数字
reg = re.compile(r'(模式一| 模式二)') #查找多个条件, 或的关系
reg = re.compile(r'^模式一(模式二)?') #可有可无的用()?
#search 查不到返回None
r = reg.search(s)
r[1] #使用括号分组时, 返回元组形式, 用索引提取, 从1开始计数
r.group() #未使用括号分组时, 会返回全部匹配到的内容, 用group()
#findall
r = reg.findall(s) #查找全部, 返回列表
['306', '307']
r = reg.finditer(s) #查找全部, 返回迭代器
3.6.2.2 不编译直接用
re.findall( r'\d+', 文本, re.S)
re.search( r'\d+', 文本, re.S)
re.match( r'\d+', 文本, re.S) #从开头匹配
re.fullmatch( r'\d+', 文本, re.S) #完全匹配
3.6.2.3 替换
re.sub(pattern,替换成，文本，count=0) #查找替换，count=0，替换全部，缺省值
re.subn() 同上，区别返回值为元组
可选项：
re.S #使 . 匹配包括换行在内的所有字符
re.I #忽略大小写
2.7.3 元字符
. 任意字符
\. 转义点号, [ ]报错时位置可能要根据需要调整
？ 0或1次
+ 1或多次
* 0或多次
{2} 两次,花括号，指定匹配次数
{2,5 } #2到5次 {0,2} 2前面不能有空格
{, 5} #0到5次, 不能带空格
{5, } #5到无数次, 不能带空格
[acd] 中括号，指定匹配括号内的字符
[(单元)] 可匹配词语,
\d 数字 [0-9]
\D 非数字
- zA-Z] 字母
\w 大小写字母加数字
\W 跟上面相反
\s #空白字符, 空格换行tab等
\S #非空白字符
( ) #空格
- #作为连接符号, 放到最后或最前, 或者转义
^ 在开头匹配(例如第一个字符需要数字^\d
$ 在结尾匹配(例如最后一个字符需要数字\d$
| #左右两边任意满足一个
[\u4e00-\u9fa5] 中文
[^abc] 取反, 除了abc
2.7.4 分组
（？#注释）
（？=str） 查找str左侧的内容
（？！str） 查找str右侧的内容
（） 查找括号中的内容，保存在索引1中
浙公网安备 33010602011771号