python数据类型，数据操作，函数使用等总结上半篇（有拓展细节）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
一，
if 条件：
条件成立执行的代码
二，
if 条件：
条件成立执行的代码
else:
条件不成立执行的代码
三，
if 条件1：
条件1成立执行的代码
elif 条件2：（elif可以有多个）
条件2成立执行的代码
else:
以上条件都不成立执行的代码

1
2
3
4
5
6
if 条件1：
条件1成立执行的代码
if
条件2：
条件2成立执行的代码

1
2
3
4
5
6
7
8
9
a
= 1
b = 2
c = b-a
if
b>a
else
c = b+a

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

```python
一，
while 条件：
条件成立执行的代码
二，
break 终止循环 跳出循环体
continue 终止本次循环
进入下一次循环
三，while嵌套
while 条件1：
执行代码1
while 条件2：
执行代码2
四，
for 临时变量 in 序列 ：
重复执行的代码
五，
while 条件：
条件成立执行的代码
else:
循环【正常】（break结束的循环属于不正常）结束之后要执行的代码
六，
for 临时变量 in 序列 ：
重复执行的代码
else:
正常结束执行的代码

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250

########################################
11.
一 .字符串：（数据不可变类型）
单引号 双引号 三引号（支持换行）
二.下标：
string = "qwert"
print(string[1])
输出结果是：w
三.切片：
序列【开始位置下标：结束位置下标：步长】 不包含结束位置下标对应的数据，步长默认为1,都可以使用负数
步长为负数时 ：倒序选取
string = "qwert"
print(string[0:4:1])
#qwer
四.字符串查找修改判断（仅包括常用的几个）
查找：
字符串序列.find(子串，开始位置下标，结束位置下标)
字符串序列.index(子串，开始位置下标，结束位置下标)
字符串序列.count(子串，开始位置下标，结束位置下标)
find()：检测某个字串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则返回-1
index():检测某个字串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常
count():检测某个字串是否包含在这个字符串中，如果在返回这个子串出现的次数，否则返回0
rfind()
rinfex()：从右边开始查找，用法和返回结果与find(),index()一样
修改：
字符串序列.replace(旧子串，新子串，[替换次数])#替换次数如果查出子串出现次数，则替换次数为该子串出现的次数
replace(）：返回一个新的字符串，并不会改变原有字符串
字符串序列.split(分割字符，num)#返回一个列表，列表内不包括分割字符
num表示分割次数
字符或子串.join(多字符串组成的序列)#用一个子串或字符合并字符串，即是将多个字符串合并为一个新的字符串
字符串.lstrip() / rstrip() / strip()
删除字符串 左侧 右侧 两侧的空白字符
判断：
字符串序列.startswith(子串，开始位置下标，结束位置下标)#是否以指定字串开头，返回布尔值
字符串序列.endswith(子串，开始位置下标，结束位置下标)#是否以指定字串结尾，返回布尔值
####################################################
12.
一.列表（数据可变类型）
【数据1，数据2，数据3，....】一次可存储多个数据，且可以为不同数据类型
二.查找
下标：
list_name =【】
函数：
列表序列.index(数据，开始位置下标，结束位置)#返回指定数据所在位置下标，没有就报错
列表序列.count(数据，开始，结束)#统计指定数据在当前列表中出现的次数，没有就返回0
len(列表序列)#访问列表长度，即列表中数据的个数
三.判断
in:判断指定数据在某个列表序列，返回布尔值
not in:判断指定数据不在某个列表序列，返回布尔值
四.增加
列表序列.append(数据)#列表结尾追加数据，数据如果是序列，则将这个序列整个为一个单位加进去
列表序列.extend(数据)#列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
列表序列.insert(位置下标，数据)#指定位置增加数据
五.删除
del name_list 或者 del(name_list)
#删除列表
列表序列.pop(下标)#删除指定下标的数据（默认为最后一个），并返回被删除的数据
列表序列.remove(数据)#移除指定数据
列表序列.clear()#清空列表
六.修改
list[下标] = 数据
列表序列.reverse()#逆序排列
列表序列.sort(key=None,reverse=False/True)#排序: 升序False
降序True
七.复制
列表序列.copy()
八.列表的循环遍历
九.列表嵌套
list_name[[],[],[]]
索引时：list_name[][]
###########################################################
13.元组（数据不可变类型）
tuple = (x,x,x)一个元组可以存储多个数据,数据可以不同类型
tuple = (x,)如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型
查找：
tuple.index(数据,开始，结束)
tuple.count(数据，开始，结束)
len(tuple)
注意：元组的数据是不可修改的，但是元组内有列表，那个列表可以修改
############################################################
14.字典（数据可变类型）
dict = { key:value,key:value}#键值对形式
dict = {}
或者 dict = dict() #空字典
增加：
如果key存在则修改key对应的值，不存在则新增
dict[key] = value
删除：
删除字典或者指定的键值对
del(dict)
del dict[key]
清空
dict.clear()
查找：
dict[key]
dict.get(key,默认值)#如果当前查找的key不存在则返回第二个参数，如果省略第二个参数不写则返回none
dict.keys()#返回一个可迭代对象 返回字典中的key
dict.values()#返回可迭代对象，返回字典中的values
dict.items()#返回可迭代对象，所有键值对，里面的数据是元组，元组数据1是key，元组数据2是value
字典遍历
###########################################################
15.集合(数据不重复，无序)
A = {a,b,c,d}
或者
set{}
#空集合只能用set()方法创建
增加：
A.add(x) #只能增加单一数据，数据序列不行
A.update([x1,x2,x3])#可增加序列，不能增加单一数据
删除：
A.remove(x) #删除指定数据 如果不存在报错
A.disard(x)#删除指定数据 如果不存在不报错
A.pop()# 随机删除某个数据，并且返回这个被删除的数
查找 ：
in
not
in
#################################################
16.公共操作
+ 合并（字符串，列表，元组）
* 复制
( 字符串，列表，元组)
in
元素是否存在
（字符串，列表，元组，字典）
not
in
元素是否不存在 （字符串，列表，元组，字典）
公共方法：
len()
del
del()
max()
min()
range(start,end,step)
enumerate(可遍历对象，start=0)#返回结果是元组，元组第一个数据是原迭代对象的数据下标	，元组第二个数据是对应的数据
容器类型转换：
tuple(x)序列转为元组
list(x)序列转为列表
set(x)序列转为集合
###############################
17.推导式（化简代码）
列表：用一个表达式创建一个有规律的列表或控制一个有规律的列表
例子：
list = [i for i in range(10)]
print(list）
输出结果：【0，1，2，3，4，5，6，7，8，9】
list = [i for i in range(10)
if i % 2 == 0]#求偶数列表
for+if
print(list)
输出结果：【0，2，4，6，8】
list = [(i,j) for i in range(1,3) for
j
in range(3) ]#for嵌套
print(list)
输出结果：【（1，0），（1，1），（1，2），（2，0），（2，1），（2，2）】
字典：快速合并列表为字典或提取字典中目标数据
例子：
dict = {i : i**2 for i
in range(1,5)}
print(dict)#{1:1,2:4,3:9,4:16}
list1 = ['name','age','gender']
list2 = ['tom',20,'man']
dict1 = {list1[i]:list2[i] for i in range(len(list1))}
print(dict1)#{name:tom,age:20,gender:man}
集合：与上面类似的
总结：
【xx for xx in range()】
{xx : xx for ... in ...}
{xx for xx in ...}
###############################################################
18.函数（可高效实现代码重用，必须先定义再调用）
定义函数：
def
函数名（参数）：
代码
.......
调用函数：函数名（参数）
返回值：return x
函数的说明文档：
help(函数名字)
help函数的作用是查看函数的说明
定义函数的说明文档
def 函数名（参数）：
""" 说明文档"""
代码
..........
例子
def sum (a,b):
"""求和函数"""
return a+b
高级使用说明文档方法
def sum (a,b):
"""（在这里敲一下键盘回车键）"""
return a+b
敲完回车键之后：
def sum (a,b):
"""
（这里还可以写说明文档）
:param a: 参数1补充说明
:param b: 参数2补充说明
:return: 返回值补充说明
"""
return a+b
#################################
函数嵌套调用
一个函数里面又调用另一个函数
变量作用域：
局部变量：定义在函数体内部的变量，只在函数内部生效，临时保存数据，函数调用结束便销毁
全局变量：在函数体内，外都能生效的变量
函数体内修改全局变量，要先声明它为全局变量：global 全局变量名
函数的返回值
如果一个函数有两个return
只执行第一个return
原因是因为return可以退出当前函数，导致return下方代码不执行
返回多个值：return a , b
默认是返回一个元组
#######################################################
参数（4种写法）
位置参数：调用函数时根据函数定义的参数位置来传递参数（形参和实参的顺序，个数必须一致）
关键字参数：通过 键=值 形式加以指定（如果有位置参数，那位置参数必须放在关键字参数前面）
缺省参数：设置默认值，调用时可不传参
不定长参数：不设定个数的参数，不确定参数个数，可变参数
*args是元组类型（包裹位置传递）
def
function(*args):
代码
print(args)
......
function(1,2,3)#(1,2,3)
*kwargs是字典类型（包裹关键字传递）
def function2(**kwargs):
代码
print(kwargs)
.......
function2(a = 1,b = 2)#{'a':1,'b':2}
############################################
交换变量值
a,b = 1,2
a,b = b,a
print(a,b)#2 1
引用：在python中，值是靠引用来传递来的
可变类型：列表 字典 集合
不可变：整型 浮点型
字符串
元组
############################