Python字符串、元组和字典、集合_有一个列表 alist = [['n',['abc',30,{'k1':['bb',5,'1']},

一、字符串

字符串就是由若干个不同的unicode字符组成的不可变序列

1 .字符串创建

#单引号字符串
str1 = '天要下雨，娘要嫁人，由他去吧'
str2 = str()  #空串
str3 = str([10,20,30])

#双引号字符串
str2 = "天要下雨，娘要嫁人，由他去吧"

#三引号字符串 多行字符串
str3 = '''
好雨知时节
当春乃发生
'''
str4 = """
随风潜入夜
润物细无声
""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.获取字符

因为是不可变序列，所以不能修改单个字符；凡是修改字符串的操作都产生新串

str1 = '天要下雨，娘要嫁人，由他去吧'
print(str1[0],str1[-1]) #天 吧
1
2

3.字符串转义

• 常见转义字符

  转移字符	说明	转移字符	说明
  \'	单引号	\"	双引号
  \n	换行	\r	回车
  \t	tab	\\	\

• 原生字符

  如果在字符串中不把\当做转移字符，可以使用

  str1 = r'c:\wh1803\course\1'
  print(str1)  #c:\wh1803\course\1
  1
  2

4.序列通用操作

#1 字符串拼接
#对于字符串字面值，只要相邻两个字符串中间没有其他字符就会自动拼接为一个字符串
str1 = '中美达成共识'
        '不打贸易战'
print(str1) #中美达成共识不打贸易战

#其他情况使用+运算符拼接字符串
str1 = '你好'
str2 = ' 树先生'
print(str1 + '世界')
print(str1 + str2)

#2.字符串重复
str1 = '汪' * 3
print(str1) #汪汪汪

#3.成员操作
str1 = '天要下雨，娘要嫁人，由他去吧'
if '天' in str1:
    print('是成员')
else:
    print('不是成员')

#4.字符串截取（切片）
str1 = '123456'
print(str1[0:2]) #'12'
print(str1[1:]) #'23456'
print(str1[::2]) #'135'
print(str1[:]) #'123456'
print(str1[::-1]) #'654321'

#5.字符串长度
print(len(str1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

4 字符串常用函数

4.1 字符串查找和替换

str1 = ‘a fox jumped over the fence’

4.2 字符串分隔和组合

4.3 字符串判断

4. 4字符串转换

4.5 其它方法

#1. 将其他类型转换为字符串
print(str(90)) #'90'
print(str([20,30])) #'[20,30]'

#2 ord(x) 返回一个字符所对应的码值
print(ord('a')) #97
print(ord('中')) #20013

#3 chr(x) 输入一个unicode码，返回一个对应的字符。
print(chr(20013))  #中

#eval，将字符串当做代码执行
age = 1
print(eval('age + 3'))  # 4
print(eval('+123'))   #123
print(eval('3 + 2'))   #5

#有安全问题
eval("__import__('os').system('dir')") #显示当前目录的文件列表

#4 repr(x)  返回一个对象的String格式，适合机器执行
a = [20,30]
s1 = repr(a)
list1 = eval(s1)
list2 = str(a)
print(a == list1)
print(a == list2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5. 字符串格式化

• 用%格式化

  %[flags][width][.precision]typecode
  flags:对其方式，-左对齐 +右对齐(默认),0表示用0填充，默认是用空格填充
  width：所占宽度，单位是列
  .precision: 精度，如果带小数点，可以指定带几位小数，指定后会四舍五入
  typecode: d 将数值转换为整型显示；f 将数值转换为浮点数显示 s将数值转换为字符串显示
  #大家好，我叫   王尼玛，我今年35岁了,我有5000000.69
  print("大家好，我叫%+6s，我今年%d岁了,我有%10.2f" % ('王尼玛',35,5000000.687))
  1
  2
  3
  4
  5
  6
  7

• 用format格式化

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kKZBk7O5-1605985592572)(format.jpg)]

  [[fill]align][sign][#][width][.precision][type]
  fill: 填充字符，可选
  align: 对齐方式  <左对齐  >右对齐  ^居中对齐
  sign：显示符号，+正数显示正号，负数显示符号；-正数不显示符号，负数显示符号
  #： 对于2、8、16进制会显示0b 0o 0x
  width: 宽度
  , 千分位分隔符
  .precision：精度
  type： s字符串  d整型  f浮点数
  
  tp1 = "I am {}, age {}, {}".format("seven", 18, 'alex')
  tp2 = "I am {name}, age {age}, really {name}".format(name="seven", age=18)
  tp3 = "I am {:s}, age {:d}, money {:.0f}".format("seven", 18, 88888.1)
  print(tp1) #I am seven, age 18, alex
  print(tp2) #I am seven, age 18, really seven
  print(tp3) #I am seven, age 18, money 88888
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

二、字节

在python3中最重要的特性是对文本和二进制数据做了更加清晰的区分，文本总是Unicode，由字符类型表示，而二进制数据则由byte类型表示，python3不会以任意隐式方式混用字节型和字符型，也因此在python3中不能拼接字符串和字节包（python2中可以，会自动进行转换），也不能在字节包中搜索字符串，也不能将字符串传入参数为字节包的函数。

Bytes 对象是由单个字节作为基本元素（8位，取值范围 0-255）组成的序列，为不可变对象。 bytes对象只负责以二进制字节序列的形式记录所需记录的对象，至于该对象到底表示什么（比如到底是什么字符）则由相应的编码格式解码所决定。Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。可以通过调用bytes()生成bytes实例，其值形式为 b’xxxxx’，其中 ‘xxxxx’ 为一至多个转义的十六进制字符串（单个 x 的形式为：\x12，其中\x为小写的十六进制转义字符，12为二位十六进制数）组成的序列，每个十六进制数代表一个字节（八位二进制数，取值范围0-255），对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值.

1 创建字节

#创建字节
b1 = b'hello'
b2 = b"ello"
b3 = b'''hello'''
b4 = bytes('中文','utf-8')
1
2
3
4
5

2 设置python文件编码格式

# -*- coding: utf-8 -*-
import sys
sys.setdefaultencoding('utf-8') #修改系统默认编码格式
1
2
3

3 字符串和字节的转换

#字符串转字节
s1 = "中文"
s2 = s1.encode('utf-8')  #str.encode()
print(type(s2))  #<class 'bytes'>
print(s2)  #b'\xe4\xb8\xad\xe6\x96\x87'

#字节转字符串
s3 = s2.decode('utf-8')  #bytes.decode()
print(type(s3))  #<class 'str'>
print(s3)  #中文
1
2
3
4
5
6
7
8
9
10

三、元组

元组和列表相似，但元组属于不可变序列，所以元组：

• 不能修改元素的值
• 元组用（）表示

1.1 创建元组

t1 = ()   #创建一个空元组
#或者
t1 = tuple() #空元组

t2 = (1,) #创建带有一个元素的元组，后面的逗号是必须的，否则无法区分是（）表达式还是元组
或者：t2 = 1,
t3 = (1,4,True,'hello')
t4 = 10,20,30 #t4 = (10,20,30)
t5 = tuple('abc')
1
2
3
4
5
6
7
8
9

1.2 成员访问

t1 = (10,7,12,23)
print(t1[0])
#print(t1[4]) 下标越界 IndexError

t2 = (1,2,[4,5])
t2[2][0] = 10  #元组的元素无法修改，但元素如果是可变列表，则列表元素是可以修改的
1
2
3
4
5
6

1.3 通用操作

#1.连接
t1 = (1,2,3)
t2 = (4,5,6)
t3 = t1 + t2
print(t3)  #(1,2,3,4,5,6)

#2.重复
print(t1 * 2)  #(1,2,3,1,2,3)

#3.切片
print(t3[0:3])  #(1,2,3)
print(t3[3:])   #(4,5,6)
print(t3[-1::-1]) (6,5,4,3,2,1)

#4.成员运算符
print(3 in t3)  #True
print(2 not in t3) #False

#5.元素个数
print(len(t3))

#6.最值
print(max(t3))  #6
print(min(t3))  #1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1.4 元组其它操作

• 元组和列表的转换

  t1 = (10,20,30)
  l1 = [1,2,3]
  
  #列表转元组
  print(tuple(l1))
  
  #元组转列表
  print(list(t1))
  1
  2
  3
  4
  5
  6
  7
  8

• 查找

  t1 = (10,20,30,10)
  print(t1.index(20))  #查找值等于20的第一个元素
  print(t1.count(10))  #返回元组中10的个数
  1
  2
  3

• 遍历

  t1 = (10,20,30,10)
  for value in t1:
      print(value)
      
  #同时获取下标和值
  for index,value in enumerate(t1):
      print(index, value)
  
  #通过下标遍历
  for i in range(len(t1)):
      print(t1[i])
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  1.5 二维元组

t1 = ((1,2,3),(4,5,6))

#遍历
for elem in t1:
    for value in elem:
        print(value, end = ' ')
    print('')
1
2
3
4
5
6
7

1.6 序列的解包

#元组解包
#变量个数和元素个数一致
t1 = (11,20)
a, b = t1
print(a,b)  #11 20

a, b = 2, 3  
a,b,c = (1,2,3) 

#变量个数和元素个数不同
#a=10,c=50,_获取（20,30）
a, *_, c = 10,20,30,50
print(a,c,_) #10 50 [20, 30]

#a=10，b=20,c获得剩余的元素
a, b, *c = 10,20,30,50
print(a,b,c) #10 20 [30, 50]

#*解包
print(*(1,2,3))  # 1 2 3

#range解包
a, b, c = range(3)  #a=0,b=1,c=2

#列表解包
a,*_b,c = [1,2,3,4,5]
print(a,_b,c) # 1 [2, 3, 4] 5

#字符串解包
a,b,c = '123'
print(a,b,c) # a='1',b='2',c='3'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

四、字典

字典不属于序列，元素存放无序，是通过哈希方式进行数据存取的，字典是一个可变容器，字典中保存一个个的键值对： key : value。我们通过key来获取对应的值，很类似我们的汉语字典。

• 字典中键必须是唯一的，必须是不可变类型
• 字典查找速度比较快

2.1 字典的创建

d1 = {}  #空字典
d1 = dict()  #空字典
d2 = {'name':'麻辣龙虾','taste':'美味'}
d3 = dict(a=1,b=2)
d4 = dict([('a', 1),('b', 2)])
d5 = dict({'a':1,'b':2})
1
2
3
4
5
6

2.2 字典操作

#存储多个学生的成绩
dict1 = {"jack":78,"hanmeimei":99,"lilei":60}
print(dict1)

#1.元素访问
#获取   语法：字典名[key]
print(dict1["hanmeimei"])

#print(dict1["tom"]) #KeyError: 'tom'

#字典名.get()
result = dict1.get("lilei",'1')  # 如果没有lilei这个键，返回默认值1，不会报错
print(result)

#2.添加:当指定的键不存在的时候，则表示添加
dict1["tom"]  = 70
print(dict1)
#但是，如果键已经存在，则表示修改value
dict1["jack"]  = 50
print(dict1)

#3. 删除 pop 删除并返回指定键对应的值
#注意：通过键，直接删除整个键值对
dict1.pop("jack")
print(dict1)

del dict1['lilei'] #删除键值对，不返回值
dict1.clear()  #清空字典
del dict1  #删除整个字典

#4 字典合并
a = {1:'hello'}
b = {2:'world'}
a.update(b)
print(a)

#5.遍历
dict2 = {"jack":78,"hanmeimei":99,"lilei":60}

#方式一：只获取键
for key in dict2:
    value = dict2[key]
    print(key,value)

#方式二：只获取值
#values,得到的结果是一个列表，当做列表处理
print(dict2.values())

for value in dict2.values():
    print(value)


#方式三：同时获取键和值
#items,得到的结果是一个列表，列表中的元素是元组
print(dict2.items())  #[('jack', 78), ('hanmeimei', 99), ('lilei', 60)]

for key,value  in dict2.items():
    print(key,value)

#方式四
for index,key in enumerate(dict2):
    value = dict2[key]
    print(index,key,value)

#6.获取键值对的个数
print(len(dict1))

#7.成员操作
d2 = {'name':'麻辣龙虾','taste':'美味'}
print('name' in d2) #判断某个键是否在列表中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

五、集合（set)

特点:不允许有重复元素，如果添加重复元素，则会自动过滤，可以进行交集、并集的运算。

本质：无序且无重复元素的数据结构

1 创建集合

s1 = set()  #空集合  不能是{}，这是字典
s2 = {1,2,3,4}
print(s1)
print(set([30,40,50]))  #通过列表创建
print(set((11,22,33)))  #通过元组创建
print(set('hello'))     #通过字符串创建  
print(set({'name':'大宝','age':20}))   #通过字典创建,得到一个键的集合

#注意：重复元素在set中会被自动过滤
1
2
3
4
5
6
7
8
9

2 集合操作

#1 增加
#add添加不可变元素
s1.add(5)
# s1.add([6,7]) #不能添加列表，列表和字典都是不可哈希的
s1.add((6,7))  #可以添加元组元素，元组是可哈希的
print(s1)

#set.update(s) s必须是可迭代的对象：列表、元组、字符串、字典
#update会把列表、元组、字符串打碎添加到集合中
s1 = {1,2,3,4}
s1.update([5,6])
s1.update((7,8))
s1.update('hello')
s1.update({'1':10,'2':20})  #将字典的键添加到s1
print(s1)

#2 删除
#set.remove(elem)
set3 = {1,2,3,4,5,6}
set3.remove(4)  #直接删除指定元素
print(set3)

print(set3.pop()) #删除任意元素，并返回该元素的值
print(set3)
set3.discard(10) #删除的元素不存在，不会报错
#set3.remove(10) #如果元素不存在，则报错：KeyError

#3元素个数
print(len(set3))

#4 成员操作
print(2 in set3)  #True

#5 并、交、差集
s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7}
print(s1 | s2)  #并
print(s1 & s2)  #交集
print(s1 - s2)  #差集
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

二、补充

2.1数据类型的转换

2.2布尔值

在python中，能够解释为假的值有：None、0、0.0、False、所有的空容器（空列表、空元组、空字典、空集合、空字符串），其它是真

2.3 zip函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

语法：zip(iterable1,iterable2, …)

参数说明：iterable – 一个或多个可迭代对象（字符串、列表、元祖、字典）

a = [1,2,3,4]
b = [2,3,4]
res = zip(a,b)
print(list(res))  #[(1, 2), (2, 3), (3, 4)]
# 可以使用for-in 遍历
for x,y in zip(a,b):
    print(x,y)
1
2
3
4
5
6
7

2.4 列表推导式

运用列表推导式，可以快速生成list，可以通过一个list推导出另一个list，而代码却十分简洁。

#列表推导式语法：
[exp for iter_var in iterable] 
执行for-in循环时，通过iter_var遍历iterable每一项，exp表达式中可以直接使用iter_var，每遍历一项，产生一个新的列表元素。
#生成[0,1,4,9,16,25]
[x*x for x in range(6)]

#生成[0,4,16,36,64]
l2 = [x*x for x in range(9) if x % 2 ==0]
print(l2)

#可以使用双重循环
suit = ['♥','♦','♣','♠']
face = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
poke = [(x,y) for x in suit for y in face]

#字典推导式
#列表生成式可以使用两个变量,实现字典的键值交换
d = {"X":"A","Y":"B","Z":"C"}
list5 = {v:k for k,v in d.items()}
print(list5)

#集合推导式
print({x for x in range(10)})

#练习：
1.将一个列表中所有的字符串变成小写
  l = ["Hello","World","IBM","Apple"]
  l1=[]
# for value in l:
#     l1.append(value.lower())
# print(l1)
如果是这样的列表呢
  l =  ["Hello","World",10,"IBM","Apple"]
l2=[]
for value in l:
    if isinstance(value,str):
        l2.append(value.lower())
print(l2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38