python数据类型，数据操作，函数使用等总结上半篇（有拓展细节）_python的数据类型转换,运算符和表达式的实验总结

python学习总结篇（细节）上半篇

一 .
计算机组成：
硬件系统：
1.cpu(中央处理器):处理指令和运算数据
2.内存：存储数据（不是所有数据，）
3 硬盘：永久存储数据

软件系统：
1.系统软件
2.应用软件

二、
Python(免费开源)
网络爬虫，数据分析，人工智能，机器学习，web开发，
自动化运维 ，google(tensorflow) , scikit-learn ，paddle

版本：2.x ，3.x
建议3.5以上

三.
python解释器(编译环境，运行文件)
种类:官方的cpython(c语言开发的) Ipython（基于cpython开发的）

下载-安装-配系统环境

四.
pycharm
社区版 ，专业版

五.
注释（增加代码可读性,解释器不执行注释）
单行注释：以#开头
多行注释：""" xxx “”" , ‘’’ xxx ‘’’
快捷键：ctrl+/

1.变量
存储数据的时候，那个数据在内存地址的名字。
因为外存处理速度比内存慢 ，所以使用变量来快速查找和使用

变量名 = 值 （变量名要满足标识符命名规则，自定义的）

标识符命名规则：
.由数字，字母，下划线组成
.不能以数字开头
.不能使用内置关键字
.严格区分大小写

定义变量例子：person_name = ‘tom’ , tom_age = 1234
使用变量例子 ： print（f“这个人的名字是{person_name}，年龄是{tom_age}”）
输出显示：这个人的名字是tom,年龄是1234

2.Bug
DEbug工具 pycharm集成的调试程序的工具
1.打断点(行号右边空白处单击)，在需要被调试的代码块的第一行打点就可以了
2.调试（逐行调试-step over - F8等方式）

3.数据类型（在编码中可使用type（）函数查看变量数据类型，例 type(person_name)）
数值：整数int，浮点数float
布尔型：TURE ,FALSE
STR字符串，LIST列表 ,TUPLE元组，DICT字典，SET集合

4.输出
格式化输出：
%s 字符串 ，%d有符号的十进制整数 ，%u无符号十进制整数，%f 浮点数等等还有其他建议多看官方文档

例子1：
age = 19
name = ‘tom’
weight = 75.5
print(“今年我的年龄是%d岁” % age )
print(“今年我的名字是%s岁” % name )
print(“今年我的体重是%f岁” % weight)
print(“今年我的体重是%.3f岁” % weight)#保留三位小数输出

输出结果是：
今年我的年龄是19岁
今年我的名字是tom岁
今年我的体重是75.500000岁
今年我的体重是75.500岁

例子2:
#表述输出的整数显示位数，不足以0补全，超出当前位数则原样输出
stuid = 1
stuid2 = 1000
print(“我的学号是%d” %stuid)
print(“我的学号是%03d” %stuid)#输出3位数，不足以0补齐
print(“我的学号是%04d” %stuid)#输出4位数，不足补0
print(“他的学号是%03d” %stuid2)#输出3位数，超出位数原样输出

输出结果是：
我的学号是1
我的学号是001
我的学号是0001
他的学号是1000

例子3：
names = ‘max’
ages = 21
print(‘我的名字是%s,年龄是%d’ % (names,ages))#括号内变量要按照字符串的占位符的顺序
print(‘我的名字是%s,明年的年龄是%d’ % (names,ages+1))

输出结果是：
我的名字是max,年龄是21
我的名字是max,明年的年龄是22

例子4：（这种方式对比上面的比较高效，3.6以上或3.6版本才可用）
names = ‘max’
ages = 21
print(f’我的名字是{names},年龄是{ages}’)
print(f’我的名字是{names},明年的年龄是{ages+1}’)

输出结果是：
我的名字是max,年龄是21
我的名字是max,明年的年龄是22

转义字符：
\n:换行 ，\t:制表符，一个tab键（四个空格键）
例子：
print(‘hello world’)
print(‘hello\nworld’)
print(‘hello \t world’)

输出结果：
hello world
hello
world
hello world

注意：python的print（）函数，它的默认参数结束符 end="\n",所以print是自动换行的，参数end可以改
print函数：
def print(self, *args, sep=’ ‘, end=’\n’, file=None):

5.输入
input(“提示信息”)，常常用变量存储接收到的数据，input接收到的数据类型都是字符串
程序遇到input函数不会继续执行下去，而是等到输入再去执行后面的语句

例子：
a = input(“请输入你的密码：”)
print(a)
print(type(a))

输出结果：
请输入你的密码：1234
1234
<class ‘str’>

6.转换数据类型
int(x) , float(x) ，str(x) , eval()等具体看官方文档

7.python Console(交互式)
######################################################
8.运算符
。算数运算符：+ - x（乘） / (除) %（取余） //（整除） **（指数） （）（提高运算优先级）
。赋值运算符：=（赋值）num = 1 a , b , c = 1,2,3 a = b = 10
。复合赋值运算符：+= -= *= /= //= %= **= (先计算算数运算符 再计算赋值运算符，如果右边是算术表达式 先算右边的算术)
。比较运算符：== != > < >= <=(返回布尔值类型)
。逻辑运算符：and or not (返回布尔值类型)
拓展：数字之间的逻辑运算
and运算符：
只要有一个值为0，则结果为0，否则结果为最后一个非0数据
or运算符：
只有所有值为0结果为0，否则结果为第一个非0数据

###################################################
9.条件语句（注意代码缩进语法，建议四个空格距离）

一，
if 条件：
       条件成立执行的代码
二，
if 条件：
       条件成立执行的代码
else:
      条件不成立执行的代码

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

四，if嵌套

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

五，三目运算符(三元表达式)
语法：

（条件成立执行的表达式） if （ 条件） else （条件不成立执行的表达式）

例子：

a  = 1 
b = 2 
c = b-a  if  b>a  else  c = b+a   
1
2
3

###########################################
10.循环语句（while,for）

```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

########################################
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中，值是靠引用来传递来的


可变类型：列表 字典 集合
不可变：整型 浮点型  字符串  元组
############################







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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273