Python 全栈开发二 python基础 字符串 字典 集合

Posted 2020-10-31 wallacewang

一.字符串

1，在python中，字符串是最为常见的数据类型，一般情况下用引号来创建字符串。

1 >>ch = "wallace"   
2 >>ch1 = ‘wallace‘
3 >>ch2 = ‘‘‘
4 wallace
5 wallace
6 wallace
7 ‘‘‘
8 #以上三种引号都可以定义一字符串，
9 #三引号定义的字符串可以换行

 

注意：字符串是不可变的数据类型，关于可变与不可变将会在后文解释。

2，转义字符

在python中有一些字符是有转义功能的，一般情况下是指\加上一些字符，在使用的时候需要注意：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\‘	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

例如：

1 >>print(‘a\na‘)   #这里的\n表示的就是换行
2 a
3 a

 

3.字符串的常用方法：

 1 >>st = ‘   Wallace waNg   ‘
 2 >>st2 = ‘wallace 123‘
 3 >>st3 = ‘123‘
 4 >>print(st.index(‘w‘))#根据提供的元素返回索引位置
 5 11
 6 >>print(st.count(‘a‘))#返回对应元素的个数
 7 3
 8 >>print(st.isdigit()) #只有全部是数字的时候才返回Ture
 9 Flase
10 >>print(st2.isdigit())#判断是否全为数字组成的字符串
11 Flase
12 >>print(st3.isdigit())
13 True
14 >>print(‘{}{}{}‘.format(st,st2,st3))  #字符串拼接
15    Wallace waNg   wallace 123123
16 >>print(‘{n},{n1},{n2}‘.format(n = st,n1 = st3,n2 = st2))
17    Wallace waNg   ,123,wallace 123
18 >>print(‘ ‘.join((st,st2,st3)))   #字符串拼接，可以用一些符号进行拼接
19    Wallace waNg    wallace 123 123
20 >>print(st.ljust(50,‘1‘))       #给字符串设置宽度，并且可以在一边添加字符 rjust
21    Wallace waNg   11111111111111111111111111111111
22 >>print(st.center(50,‘*‘))      #设置宽度，并对字符串居中
23 ****************   Wallace waNg   ****************
24 >>print(st.replace(‘a‘,‘b‘,1))   #替换字符,可以选择替换次数
25    Wbllace waNg   
26 >>print(st.strip())              #去除字符串两边的空格和换行  rstrip(), lstrip()
27 Wallace waNg
28 >>print(st.find(‘a‘))             # 返回字符的索引位置
29 4
30 >>print(st.endswith(‘a‘))     #判断是否为该字符结尾  startswith  开头
31 Flase
32 >>print(st.split(‘ ‘))       #分割字符，返回一个列表
33 [‘‘, ‘‘, ‘‘, ‘Wallace‘, ‘waNg‘, ‘‘, ‘‘, ‘‘]
34 >>print(st.capitalize())     #全部变为小写
35    wallace wang   
36 》》print(st.encode(encoding=‘gbk‘))   #转换编码方式
37 b‘   Wallace waNg   ‘
38 >>print(st.expandtabs(tabsize=20))  #将tab符号转换为空格，一个tab有8个空格
39    Wallace waNg   
40 >>print(st3.isalnum())     #与isdigit  类似
41 >>print(st.isalpha())     #判断全为字母
42 >>print(‘1A‘.isdecimal())  #检查字符串是否只包含十进制字符
43 >>print(‘2a‘.isidentifier())    #判读是不是一个合法的标识符,即变量名
44 >>print(st2.islower())     #判断是否全为小写
45 >>print(st2.isupper())    #判断是否全为大写
46 >>print(st2.isnumeric())  #如果字符串中只包含数字字符
47 >>print(st.istitle())   #判断是否为标题
48 >>print(st.title())   #转换为标题
49    Wallace Wang   
50 >>print(st.lower())   #全部转换为小写
51    wallace wang   
52 >>print(st.upper())   #全部转换为大写
53    WALLACE WANG   
54 >>print(st.swapcase()) # 将字符串中大写转换为小写，小写转换为大写
55    wALLACE WAnG   

 

二.字典

字典是另一种可变容器模型即是一种无序的可变的数据数据类型，且可存储任意类型对象。字典以键值对的形式存储，键(key)和值(value)用：隔开，每个键值对用逗号隔开。

1 >>di = {
2 "username":"wallace"
3 "passward":"qwe123"
4 "age":13
5 "data":[1,3,4]
6 }

 

#字典的值可以为任意的数据类型
#字典的键未不可变的数据类型

1.字典的CRUD

Create(增加)：

 1 >>di = {
 2 "username":"wallace"
 3 "passward":"qwe123"
 4 "age":13
 5 "data":[1,3,4]
 6 }
 7 >>di["create"] = ‘create‘
 8 >>di
 9 {
10 "username":"wallace"
11 "passward":"qwe123"
12 "age":13
13 "data":[1,3,4]
14 "create":"create"
15 }
16 #添加一个键值对

 

Retrieve(查询)

 1 >>di
 2 {
 3 "username":"wallace"
 4 "passward":"qwe123"
 5 "age":13
 6 "data":[1,3,4]
 7 "create":"create"
 8 }
 9 >>di["username"]  #通过对应的键来找到对应的值
10 "wallace"

 

Update(更新)：

 1 >>di
 2 {
 3 "username":"wallace"
 4 "passward":"qwe123"
 5 "age":13
 6 "data":[1,3,4]
 7 "create":"create"
 8 }
 9 >>di[‘passward‘] = "123"  #根据对应的键来进行修改
10 #如果不存在对应的键则会创建一个键
11 >>di
12 {
13 "username":"wallace"
14 "passward":"123"
15 "age":13
16 "data":[1,3,4]
17 "create":"create"
18 }

 

Delete(删除)：

 1 >>di
 2 {
 3 "username":"wallace"
 4 "passward":"qwe123"
 5 "age":13
 6 "data":[1,3,4]
 7 "create":"create"
 8 }
 9 >>del di[‘age‘]   #选择对应的键，就可以删除
10 >>di
11 {
12 "username":"wallace"
13 "passward":"qwe123"
14 "data":[1,3,4]
15 "create":"create"
16 }
17  

 

2.字典的常用方法

 1 >>di={‘w‘:123,‘l‘:456,‘x‘:789}
 2 >>di.fromkeys([‘a‘,‘b‘,‘c‘],123)#用给定的键建立新的字典，每一个键默认对应值none（自定义）
 3 {‘a‘: 123, ‘b‘: 123, ‘c‘: 123}
 4 >>di.get(‘r‘,‘我不在这里‘)#取值，存在就返回对应值，不存在默认返回none（可自定义）
 5 ‘我不在这里‘
 6 >>di.setdefault(‘w‘,123)#类似get，存在就返回值，不存在就更新到字典，对应值默认none（可以自定义）
 7 123
 8 >>di.items()#list(di.items()) 查看字典的每一项
 9 dict_items([(‘w‘, 123), (‘l‘, 456), (‘x‘, 789)])
10 >>di.keys()#查看字典的所有键
11 dict_keys([‘w‘, ‘l‘, ‘x‘])
12 >>di.values()#查看字典的值
13 dict_values([123, 456, 789])
14 >>di.pop(‘w‘,123)#指定键，删除对应的值，如果键不存在，可以自定义返回值
15 123
16 >>di.popitem()#随机删除某一项
17 (‘x‘, 789)

 

三.集合

python的set是一个无序不重复元素集，基本功能包括关系测试和消除重复元素. 集合对象还支持并、交、差、对称差等。sets 支持 x in set、 len(set)、和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。

1.集合的交并差问题

 1 >>> x = set("wallace")
 2 >>> y = set([‘w‘, ‘a‘, ‘l‘, ‘c‘, ‘e‘,‘v‘])
 3 >>> x       #把字符串转化为set，去重了
 4 set([‘w‘, ‘a‘, ‘l‘, ‘c‘, ‘e‘,‘m‘])
 5 >>> y
 6 set([‘w‘, ‘a‘, ‘l‘, ‘c‘,‘e‘,‘v‘])
 7 >>> x & y   #交
 8 set([‘w‘, ‘a‘, ‘l‘,‘c‘,‘e‘])
 9 >>> x | y   #并
10 set([‘w‘, ‘a‘, ‘l‘, ‘c‘, ‘e‘, ‘v‘,‘m‘])
11 >>> x - y   #差
12 set([‘m‘])
13 >>> y - x
14 set([‘v‘])
15 >>> x ^ y   #对称差：x和y的交集减去并集
16 set([‘m‘, ‘v‘])

 

2.集合的图示

其他情况类似。

3.集合的常用方法

  1 #集合(确定的无序的一组数据)
  2 #基本操作
  3 #创建集合
  4 #空集合
  5 var = set()
  6 print(var,type(var))
  7 
  8 #具有数据的集合
  9 var = {‘zhangwang‘,‘zhangbo‘,‘zhanglang‘}
 10 print(var,type(var))
 11 
 12 #成员检测
 13 result = ‘zhangbo‘ in var
 14 print(result)
 15 
 16 result = ‘zhangsan‘ not in var
 17 print(result)
 18 
 19 #集合推导式
 20 var = {‘蚂蚱‘,‘螳螂‘,‘蝈蝈‘,‘蛐蛐‘}
 21 
 22 #基本的集合推导式
 23 result = {‘*‘+i+‘*‘ for i in var}
 24 print(result)
 25 
 26 #带有判断条件的集合推导式
 27 result = {i for i in var if i != ‘蛐蛐‘}
 28 print(result)
 29 
 30 #多循环集合推导式
 31 colors = {‘red‘,‘blue‘,‘pink‘}
 32 sizes = {36,37,38,39}
 33 result = {c + str(s) for c in colors for s in sizes}
 34 print(result)
 35 
 36 #集合函数
 37 ‘‘‘
 38 #add()  向集合中添加元素
 39 girls = {‘mf‘,‘sl‘,‘yj‘}
 40 girls.add(‘xf‘)
 41 print(girls)
 42 
 43 #pop()  随机删除集合中的一个元素
 44 boys = {‘bd‘,‘zw‘,‘jl‘,‘zy‘}
 45 result = boys.pop()
 46 print(boys)
 47 print(result)
 48 
 49 #remove()  删除集合中指定的元素  删除不存在的元素会报错
 50 boys = {‘bd‘,‘zw‘,‘jl‘,‘zy‘}
 51 boys.remove(‘zy‘)
 52 print(boys)
 53 
 54 #discard()  删除集合中指定的元素  删除不存在的元素啥都不做
 55 boys = {‘bd‘,‘zw‘,‘jl‘,‘zy‘}
 56 boys.discard(‘zy1‘)
 57 print(boys)
 58 
 59 #clear()  清空集合
 60 boys = {‘bd‘,‘zw‘,‘jl‘,‘zy‘}
 61 boys.clear()
 62 print(boys)
 63 
 64 #copy()  复制集合
 65 boys = {‘bd‘,‘zw‘,‘jl‘,‘zy‘}
 66 newboys = boys.copy()
 67 print(newboys)
 68 ‘‘‘
 69 
 70 #difference() 计算2个集合的差集
 71 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
 72 girls = {‘mmf‘,‘lsy‘,‘syj‘}
 73 result = dreamers.difference(girls)# result = a + b
 74 print(result)
 75 
 76 #difference_update()  计算2个集合的差集(差集更新操作)
 77 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
 78 girls = {‘mmf‘,‘lsy‘,‘syj‘}
 79 dreamers.difference_update(girls)#a = a + b  a += b
 80 print(dreamers)
 81 
 82 #union()  并集操作
 83 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
 84 girls = {‘mmf‘,‘lsy‘,‘syj‘}
 85 result = dreamers.union(girls)
 86 print(result)
 87 
 88 #update()  并集更新操作
 89 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
 90 girls = {‘mmf‘,‘lsy‘,‘syj‘}
 91 dreamers.update(girls)
 92 print(dreamers)
 93 
 94 #intersection()  计算2个集合的交集
 95 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
 96 girls = {‘mmf‘,‘lsy‘,‘syj‘}
 97 result = dreamers.intersection(girls)
 98 print(result)
 99 
100 #intersection_update  交集更新操作
101 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
102 girls = {‘mmf‘,‘lsy‘,‘syj‘}
103 dreamers.intersection_update(girls)
104 print(dreamers)
105 
106 #超集和子集
107 boys = {‘zzy‘,‘yqw‘,‘dw‘,‘wzc‘,‘lyb‘,‘wym‘,‘chy‘}
108 zoudu = {‘wzc‘,‘lyb‘,‘wym‘}
109 girls = {‘lsy‘,‘mmf‘,‘syj‘}
110 
111 #issuperset()  检测当前集合是否是另一个集合的超集
112 result = boys.issuperset(zoudu)
113 print(result)
114 
115 #issubset()  检测当前集合是否是另一个集合的子集
116 result = zoudu.issubset(boys)
117 print(result)
118 
119 #isdisjoint()  检测2个集合是否不存在交集  存在交集 False
120 result = boys.isdisjoint(girls)
121 print(result)
122 
123 #symmetric_difference()  对称差集
124 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
125 girls = {‘mmf‘,‘lsy‘,‘syj‘}
126 result = dreamers.symmetric_difference(girls)
127 print(result)
128 
129 #symmetric_difference_update()  对称更新差集
130 dreamers = {‘ljl‘,‘wc‘,‘xy‘,‘zb‘,‘lsy‘}
131 girls = {‘mmf‘,‘lsy‘,‘syj‘}
132 dreamers.symmetric_difference_update(girls)
133 print(dreamers)
134 
135 #冰冻集合
136 #冰冻集合是一种特殊的集合类型,也是集合(集合是列表的话,冰冻集合就是元组)
137 #创建冰冻集合
138 #一般不会创建空的冰冻集合
139 var = frozenset()
140 print(var,type(var))
141 
142 #带有数据的冰冻集合
143 var = frozenset((‘qs‘,‘szx‘,‘bjh‘,‘acs‘))
144 print(var,type(var))
145 
146 #成员检测
147 result = ‘szx‘ in var
148 print(result)
149 
150 #遍历冰冻集合
151 for i in var:
152     print(i)
153 
154 #集合推导式(无法得到冰冻集合,可以得到集合,列表,元组,字典类型)
155 result = {i for i in var}
156 print(result,type(result))
157 
158 #函数
159 #冰冻集合可以使用集合的函数(不修改集合本身的函数都可以使用)
160 var = frozenset((‘qs‘,‘szx‘,‘bjh‘,‘acs‘))
161 
162 #copy()
163 result = var.copy()
164 print(result)
165 
166 #集合操作  交集,并集,差集,对称差集等  不修改冰冻集合本身就能使用:冰冻集合的操作结果都是冰冻集合
167 var1 = frozenset((‘qs‘,‘szx‘,‘bjh‘,‘acs‘))
168 var2 = {‘szx‘,‘bjh‘,‘lc‘,‘wb‘}
169 
170 #冰冻集合操作
171 result = var1.union(var2)
172 print(result)
173 
174 #普通集合操作(冰冻集合是参考集合)
175 result = var2.union(var1)
176 print(result)

 

四.数据的可变与不可变

1、什么可变数据类型和不可变数据类型

  可变数据类型：value值改变，id值不变；不可变数据类型：value值改变，id值也随之改变。

  常见的可变数据类型：列表(list),集合(set),字典(dict) 。

  常见不可变数据类型：整数(int),字符串(char),布尔值(bool),元组(tuple)

2、如何确定一种数据类型是可变的还是不可变的

  根据可变数据类型与不可变数据类型的概念，只需要在改变value值的同时，使用id()函数查看变量id值是否变化就可以知道这种数据类型是可变的还是不可变的了。