Python3基础之字符串、列表、元组、字典、集合等相关操作

发表于 | 分类于 | 热度: ℃
字数统计: 2,957 | 阅读时长 ≈ 14

下面将一一介绍Python中的字符串、列表、元组、集合的相关操作

字符串、列表、元组、字典、集合等相关操作

字符串操作

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
字符串一般情况使用单引号或者双引号引起来
规则: 单不能套单,单可以套双
      双不能套双,双可以套单

## 多行字符串
# 方式二
str3 = '3月25号我来到了美丽的成都,刚下飞机,'\
       '就碰到一个老外帅锅,结果他还跟我打招呼.但是我不会英语,好尴尬'

# 方式一
str4 = '''洁白的婚纱,手捧着鲜花 ,美丽的想通话.想起那年初夏,我为你牵挂.'''

# 方式三
str5 = """洁白的婚纱,手捧着鲜花 ,美丽的想通话.想起那年初夏,我为你牵挂."""
print(str5)

#--------------------------------------------------------------------------------
##字符串的长度
'''
len(): 获取字符串的长度
'''
str1 = 'lhy'
str1 = '刘海艳'
str1 = '幸福像花儿一样'
print(len(str1))

总结: 无论是字符还是汉字,只要有一个,则长度就是几个

#-------------------------------------------------------------------------------
##提取某个字符
'''
提取字符串中的某一个字符
方式:
从左往右开始, 下标从0开始提取
str[0]   str[1]   str[2] ..... str[n]

从优往左开始, 下标从-1开始
str[-1]  str[-2] .....  str[-n]

'''
str1 = 'It is a dog'
print(str1[0])
print(str1[-2])

# pytjon中的字符串一旦定义好之后,是不可以修改的
str1[0] = 'i'
print('str1 =', str1)

#------------------------------------------------------------------------------
##转义字符
'''
转义字符: 将原来的意义给他去掉  \(这是反斜线)   

'''
str1 = '我最喜欢的一首歌是\'咱们结婚吧\''
str1 = 'you\'re a good man'
print(str1)


'''
系统里边有一些特殊的字符: \t(制表符) \n(换行符)
'''
print('你好\\t宝强哥,你的媳妇是马蓉吗?')
print('你好\\n宋喆,你的情人是\t马蓉\n吗?')
# 如果想将原来具有特殊含义的字符失去本身的意义,我们可以直接在整个字符串前边添加一个r
print(r'你好\t宝强哥,你的媳妇是马蓉吗?')
print(r'你好\n宋喆,你的情人是马蓉吗?')

#-------------------------------------------------------------------------------
##字符串截取
'''
字符串截取:
str1[开始下标:结束下标]: 从开始下标截取,到结束下标=结尾,.包含开始下标,但不包含结束下标
str1[0:5] 提取是的结果你是zhous
str1[:3] 默认从下标0开始到结束的开区间
str1[3:] 从指定的下标开始到结尾
str1[-n:]: 从最后边提取n个
str1[:]:  提取全部字符
str1[::2]  根据下标每个n个提取一次
str1[::-1]  将字符逆序排列
'''

#------------------------------------------------------------------------------
##字符串的格式化
%s:    给字符串站位
%d:     给int类型站位
%f:     给浮点类型站位,  默认保留6为小数
        %.2f:  保留两位小数
        %10.2f  共10位,保留两位小数,其他为使用空格补齐
         %010.2f  共10位,保留两位小数,其他为使用0补齐
%c:     打印一个字符
%o:    将十进制转换成八进制
%x:    将十进制转换成十六进制

name = '宝强'
age = 36
like = 'green'
print('他是{},今年{},他喜欢{}' .format(name, age, like))
print('他是{lala},今年{wawa}, 他喜欢{heihei}' .format(wawa=age, heihei=like, lala=name))

#--------------------------------------------------------------------------------
##字符串比较大小
[规则:]从第一个字符开始比较,将字符转换成ascii值进行比较
如果小于则返回True,否则返回False

列表操作

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
'''
列表:  格式:  列表名 = [元素1, 元素2,,...]
'''
# append()往列表后边追加一个元素
list1 = [1, 2, 3, 4]
list1.append(100)
# print(list1)
list1.append([200, 400, 600])
# print(list1)

# 在末尾一次性追加另外一个列表中的多个值
list2 = [3, 4, 5]
list2.extend([200, 300, 400])
# print(list2)

'''
insert():在指定下标出添加一个元素,原来位置处的元素往后移动
@参数一: 列表的下标
@参数二: 列表中下标所对应的值
'''
list3 = [5, 6, 7]
list3.insert(1, 250)
# print(list3)

'''
pop():将列表中指定下标的元素删除, 如果默认不传递参数,则删除的是最后一个元素
@参数一: [可有可无] 列表对应的下标
'''
list4 = [3, 4, 5, 6, 7, 8]
list4.pop()
list4.pop()
# print(list4)
list4.pop(1)
# print(list4)

'''
remove():移除列表中指定的元素
@参数一: 列表中的元素
'''
list5 = [3, 4, 5, 6, 7]
list5.remove(3)
# print(list5)

'''
clear():清除列表中所有的元素
'''
list6 = [1, 3, 4]
list6.clear()
# print(list6)

'''
index():获取列表元素锁对应的下标
@参数一:  列表中的某一个元素
返回值:  列表中元素所对应的下标
'''
list7 = [1, 2, 3, 4, 5, 6]
index1 = list7.index(3)
# print(index1)

# 获取列表的长度
list8 = [1, 2, 3, 4, 5]
# print(len(list8))

list9 = [1, 3, 4, 6, 7]
# print(max(list9))

list10 = [1, 3, 4, 6, 7]
# print(min(list9))

'''
count(): 计算列表中元素出现的次数
'''
list11 = [1, 3, 4, 3, 3, 3, 3, 6, 7]
# print(list11.count(3))

'''
reverse():将列表进行倒序排列
'''
list12 = [1, 2, 3, 4, 5, 10, 7, 8, 9]
list12.reverse()
# print(list12)

'''
sort():将列表中的元素进行升序排列
'''
list13 = [1, 100, 78, 23, 65, 43]
list13.sort()
# print(list13)

'''
引用传递:  
在列表中,如果修改一个列表的元素,那么对应的另外一个列表的元素也改变
'''
list14 = [2, 3, 4]
list15 = list14
list15[1] = 200
# print(list14)
# print(list15)
# id():查看内存的地址
# print(id(list14))
# print(id(list15))

'''
值传递
在列表中修改一个元素的值时,对应的另外一个列表中的值是不发生改变的
'''
list16 = [1, 2, 3, 4]
list17 = list16.copy()
list17[1] = 250
print(list16)
print(list17)
print(id(list16))
print(id(list17))

元组操作

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
'''
元组:也是一种有序集合
特点:
1.跟列表非常相似:  list1 = []   tuple1 = ()
2.一旦定义好之后不能修改
3.使用小括号括起一个集合

'''
# 创建一个空元祖
tuple1 = ()
# print(tuple1)
# print(type(tuple1))

tuple2 = (23, 3.14, 'aaa', None, True)
# print(tuple2)

tuple3 = (4, )#tuple
tuple3 = (4)#int
# print(tuple3)
# print(type(tuple3))

# 访问元祖的元素
tuple4 = (2, 3, 4, 5, 6)
# print(tuple4[0])
# print(tuple4[1])
# 元祖在访问的时候一定不能溢出(越界),直接报错
# print(tuple4[5])
# 获取元祖中最后一个元素
# print(tuple4[-1])
# print(tuple4[-2])
# 一定不能越界
# print(tuple4[-6])

tuple5 = (1, 2, 3, 4, [12, 34, 45])
# print(tuple5)
# tuple5[0] = 150#直接报错, 元祖定义好之后是不能修改的
# print(tuple5)
# print(tuple5[-1][-2])
# print(tuple5[4][1])

# 删除元祖的用法跟删除变量的用法一致
tuple6 = (2, 3, 5, 6)
del tuple6
# print(tuple6)

# 元祖进行操作
tuple7 = (3, 4, 5)
tuple8 = (6, 7, 8)
# 将两个元祖合并成一个新的元祖
tuple9 = tuple7 + tuple8
# print(tuple9)
# print(tuple7, tuple8)

# 将元祖重复n次,最后返回一个新的元祖
tuple10 = (3, 4, 5)
# print(tuple10 * 10)

# 判断一个元素是否在一个元祖中,如果在返回True,否则返回False
tuple11 = (3, 5, 7)
# print(4 in tuple11)

# 元祖的截取
# 格式: 元祖名[开始下标:结束下标]
tuple12 = (1, 2, 3, 4, 5, 6, 7, 8, 9,10)
# print(tuple12[1:5])
# print(tuple12[3:])
# print(tuple12[:6])
# 将元祖进行逆序排列
# print(tuple12[::-1])

# 二维元祖:
tuple13 = ((2, 3, 4), (5, 6, 7))
# print(tuple13[1][1])

# 元祖的方法
# 求一个元祖的长度
tuple14 = (2, 3, 4, 5)
# print(len(tuple14))
# print(max(tuple14))
# print(min(tuple14))

# 对列表进行遍历
# for i in [1, 2, 3, 4, 5]:
#     print(i)

# 对元祖进行遍历
# for x in (3, 4, 5, 6, 7):
#     print(x)

# 将列表转换成元祖
list11 = [3, 5, 6, 8]
tuple15 = tuple(list11)
# print(tuple15)

# 将元祖转换成列表
tuple16 = (4, 6, 8, 9)
list12 = list(tuple16)
# print(list12)

list13 = range(0, 10)
print(type(list13))
# range(): 从开始值开始,但不包含结束值[0, 10)
# for i in range(0, 10):
#     print(i)

字典操作

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
'''
dict(字典): 在字典里边一般存放的是键值对的形式.
键1 = 值1   key = value
键1 : 值1
写法: {键1:值1, 键2:值2, 键3:值3}
例子:dict1 = {'name': '刘海艳', 'age': 17, 'sex': 'girl'}
注意事项:
1.在字典中键(key)的值必须是唯一
2.在字典中可以存放多个键值对
3.在字典中键(key)必须是不可变类型   字符串  整数都可以作为键(key)
4.list和tuple都是有序集合, 而dictsahib无序集合
'''
# 必须保证字典中的key是唯一的
dict1 = {'yelei': 100, 'xiaoming' : 99, 'jianfei': 59, 'zhouying': 110}
# print(dict1)

# 元素的访问
# 获取的方式: 字典名[key]
# print(dict1['xiaoming'])
# print(dict1.get('yelei'))

# print('yelei' in dict1)

ret = dict1.get('lhy')
# if ret == None:
#     print('没有')
# else:
#     print('有')

dict2 = {'user': '大黄', 'sex': '男', 'age': 30, 'height': 150 }
# 添加元素
dict2['lover'] = '小白'
# 一个key只能对应一个value
dict2['lover'] = '小绿'

# 修改
dict2['lover'] = '小花'

# 删除
dict2.pop('sex')
# 直接报错,因为他是无需集合
# dict2.pop()
# print(dict2)

# 遍历
# for x in dict2:
#     print(x, dict2[x])
# 获取字典所有的value和key
# print(dict2.values())
# print(dict2.keys())

# for i in dict2.values():
#     print(i)
#
# for i in dict2.keys():
#     print(i)

# for k,v in dict2.items():
#     print(k, v)

#for k,v in enumerate(dict2):
#    print(k, v)

集合操作

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
'''
set(集合):类似于dict, 也是无序的,以key-value新的形势存在,但是没有value
作用: 是对list,tuple,dict进行去重的, 求交集.并集
1.set是无序
2.set集合是不可改变的
'''

# set1 = set([1, 2, 3, 5, 3, 2])
# print(set1)
# print(type(set1))
# set2 = set((1, 2, 3, 5, 3, 2, 4, 5))
# print(set2)
# print(type(set2))
# set3 = set({3, 4, 5,5, 6, 3, 7})
# print(set3)
# print(type(set3))

# 添加
set4 = set([3, 3, 4, 5, 7, 2, 1, 2])
set4.add(8)
# set4.add(3)#可以添加重复的值,但是没效果

# 总结:list和dict是可改变的, 而tuple是不可改变
# set4.add([10, 9])#直接报错,不能添加list
# set4.add((10, 9))
# set4.add({'a':1})#直接报错,不能添加字典
#
# print(set4)

# 修改
set5 = set([1, 2, 3, 4, 5])
# 将list dict tuple 等等整个插入进去
# set5.update([6, 7, 8])
# set5.update({9, 10})
# set5.update((11, 56))
# print(set5)

# 删除
# set6= set([3, 4, 5, 6, 7])
# set6.remove(4)
# print(set6)

# 遍历
set7 = set([1, 2, 3, 4, 6])
set7 = set(['aaa', 'bbb', 'ccc'])
set7 = set((1, 2, 3, 2, 4, 2, 3))
# 在set集合中,没有value,即使有value也遍历不出来
set7 = set({'name':'小花', 'age': 18})
# for i in set7:
#     print(i, end = ',')

# & | - ^
set8 = set([1, 2, 3, 4])
set9 = set([3, 2, 4, 5])
set10 = set8 & set9
set11 = set8 | set9
set12 = set8 - set9
set13 = set8 ^ set9
print(set10)
print(set11)
print(set12)
print(set13)
-------------本文结束感谢您的阅读-------------

本文标题:Python3基础之字符串、列表、元组、字典、集合等相关操作

文章作者:GavinLiu

发布时间:2017年07月14日 - 20:07

最后更新:2017年07月14日 - 20:07

原始链接:http://gavinliu4011.github.io/post/9a7b293f.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

请博主吃个鸡腿吧
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多
0%